Add files using upload-large-folder tool

.gitattributes

@@ -105,3 +105,4 @@ ComfyUI-YoloWorld-EfficientSAM/efficient_sam_s_gpu.jit filter=lfs diff=lfs merge
 miniCUDA124/lib/x64/cudart_static.lib filter=lfs diff=lfs merge=lfs -text
 miniCUDA124/lib/x64/nppist.lib filter=lfs diff=lfs merge=lfs -text
 miniCUDA124/bin/nvlink.exe filter=lfs diff=lfs merge=lfs -text
+miniCUDA124/lib/x64/nvfatbin_static.lib filter=lfs diff=lfs merge=lfs -text

miniCUDA124/lib/x64/nvfatbin_static.lib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4b229fd6f7c3ccdd918b5f9a9e58d2974d67ff81c27d6f3729e463ea088d8ac6
+size 4004556

miniMSVC/VC/Tools/MSVC/14.42.34433/include/__msvc_all_public_headers.hpp

@@ -0,0 +1,226 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// This file is intended as a test resource for tools that want to verify that they can parse all MSVC standard
+// library headers without warnings. This file disables deprecations, so it should not be included in programs directly.
+//
+// This file may be changed, renamed, or removed at any time.
+
+#ifndef __MSVC_ALL_PUBLIC_HEADERS_HPP
+#define __MSVC_ALL_PUBLIC_HEADERS_HPP
+
+#pragma warning(push)
+#pragma warning(1 : 4668) // 'MEOW' is not defined as a preprocessor macro, replacing with '0' for '#if/#elif'
+
+// All STL headers should protect themselves from macroized new.
+#if !(defined(__CUDACC__) && defined(__clang__))
+#pragma push_macro("new")
+#undef new
+#define new WILL NOT COMPILE
+#endif // !(defined(__CUDACC__) && defined(__clang__))
+
+// VSO-768746: mbctype.h macroizes _MS, _MP, _M1, and _M2. Include it first for test coverage.
+#ifndef _MSVC_TESTING_NVCC
+#include <mbctype.h>
+#endif // !defined(_MSVC_TESTING_NVCC)
+
+#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
+#define _SILENCE_CXX20_CISO646_REMOVED_WARNING
+#define _SILENCE_EXPERIMENTAL_FILESYSTEM_DEPRECATION_WARNING
+#define _SILENCE_STDEXT_HASH_DEPRECATION_WARNINGS
+
+// Core STL Headers
+#include <bit>
+#include <compare>
+#include <concepts>
+#include <coroutine>
+#include <initializer_list>
+#include <limits>
+#include <numbers>
+#include <ratio>
+#include <source_location>
+#include <stdfloat>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <version>
+
+// Core C Wrapper Headers
+#include <cassert>
+#include <cctype>
+#include <cerrno>
+#include <cfenv>
+#include <cfloat>
+#include <cinttypes>
+#include <climits>
+#include <clocale>
+#include <csetjmp>
+#include <csignal>
+#include <cstdarg>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+#include <cuchar>
+#include <cwchar>
+#include <cwctype>
+
+#ifndef _CORE_HEADERS_ONLY
+
+// Non-Core STL Headers
+#include <algorithm>
+#include <any>
+#include <array>
+#include <bitset>
+#include <charconv>
+#include <chrono>
+#include <codecvt>
+#include <complex>
+#include <deque>
+#include <exception>
+#include <expected>
+#include <filesystem>
+#include <format>
+#include <forward_list>
+#include <fstream>
+#include <functional>
+#include <hash_map>
+#include <hash_set>
+#include <iomanip>
+#include <ios>
+#include <iosfwd>
+#include <iostream>
+#include <istream>
+#include <iterator>
+#include <list>
+#include <locale>
+#include <map>
+#include <mdspan>
+#include <memory>
+#include <memory_resource>
+#include <new>
+#include <numeric>
+#include <optional>
+#include <ostream>
+#include <print>
+#include <queue>
+#include <random>
+#include <ranges>
+#include <regex>
+#include <scoped_allocator>
+#include <set>
+#include <span>
+#include <spanstream>
+#include <sstream>
+#include <stack>
+#include <stacktrace>
+#include <stdexcept>
+#include <streambuf>
+#include <string>
+#include <string_view>
+#include <strstream>
+#include <syncstream>
+#include <system_error>
+#include <typeindex>
+#include <typeinfo>
+#include <unordered_map>
+#include <unordered_set>
+#include <valarray>
+#include <variant>
+#include <vector>
+
+#ifndef _M_CEE_PURE
+#include <__msvc_cxx_stdatomic.hpp>
+#include <atomic>
+#include <barrier>
+#include <condition_variable>
+#include <execution>
+#include <future>
+#include <latch>
+#include <mutex>
+#include <semaphore>
+#include <shared_mutex>
+#include <stop_token>
+#include <thread>
+#endif // !defined(_M_CEE_PURE)
+
+// Non-Core C Wrapper Headers
+#include <ccomplex>
+#include <ciso646>
+#include <cmath>
+#include <cstdalign>
+#include <cstdbool>
+#include <ctgmath>
+
+// Non-Core Experimental Headers
+#include <experimental/filesystem>
+
+#endif // !defined(_CORE_HEADERS_ONLY)
+
+#ifndef _MSVC_TESTING_NVCC
+#include <assert.h>
+#include <conio.h>
+#include <crtdbg.h>
+#include <ctype.h>
+#include <direct.h>
+#include <dos.h>
+#include <errno.h>
+#include <excpt.h>
+#include <fcntl.h>
+#include <fenv.h>
+#include <float.h>
+#include <intrin.h>
+#include <inttypes.h>
+#include <io.h>
+#include <iso646.h>
+#include <limits.h>
+#include <locale.h>
+#include <malloc.h>
+#include <math.h>
+#include <mbstring.h>
+#include <memory.h>
+#include <minmax.h>
+#include <process.h>
+#include <safeint.h>
+#include <sal.h>
+#include <search.h>
+#include <setjmp.h>
+#include <share.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/locking.h>
+#include <sys/stat.h>
+#include <sys/timeb.h>
+#include <sys/types.h>
+#include <sys/utime.h>
+#include <tchar.h>
+#include <time.h>
+#include <uchar.h>
+#include <wchar.h>
+#include <wctype.h>
+
+#ifndef _CORE_HEADERS_ONLY
+#include <complex.h>
+#include <new.h>
+#endif // !defined(_CORE_HEADERS_ONLY)
+
+#ifndef _M_CEE_PURE
+#include <fpieee.h>
+#endif // !defined(_M_CEE_PURE)
+#endif // !defined(_MSVC_TESTING_NVCC)
+
+#if !(defined(__CUDACC__) && defined(__clang__))
+#pragma pop_macro("new")
+#endif // !(defined(__CUDACC__) && defined(__clang__))
+
+#pragma warning(pop)
+
+#endif // __MSVC_ALL_PUBLIC_HEADERS_HPP

miniMSVC/VC/Tools/MSVC/14.42.34433/include/__msvc_bit_utils.hpp

@@ -0,0 +1,426 @@
+// __msvc_bit_utils.hpp internal header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef __MSVC_BIT_UTILS_HPP
+#define __MSVC_BIT_UTILS_HPP
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <climits>
+#include <xtr1common>
+
+#include _STL_INTRIN_HEADER
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+extern "C" {
+extern int __isa_available;
+}
+
+_INLINE_VAR constexpr int _Stl_isa_available_sse42 = 2; // equal to __ISA_AVAILABLE_SSE42
+_INLINE_VAR constexpr int _Stl_isa_available_avx2  = 5; // equal to __ISA_AVAILABLE_AVX2
+
+template <class _UInt>
+constexpr int _Unsigned_integer_digits = sizeof(_UInt) * CHAR_BIT;
+
+// Implementation of countl_zero without using specialized CPU instructions.
+// Used at compile time and when said instructions are not supported.
+// see "Hacker's Delight" section 5-3
+template <class _Ty>
+_NODISCARD constexpr int _Countl_zero_fallback(_Ty _Val) noexcept {
+    _Ty _Yx = 0;
+
+    unsigned int _Nx = _Unsigned_integer_digits<_Ty>;
+    unsigned int _Cx = _Unsigned_integer_digits<_Ty> / 2;
+    do {
+        _Yx = static_cast<_Ty>(_Val >> _Cx);
+        if (_Yx != 0) {
+            _Nx -= _Cx;
+            _Val = _Yx;
+        }
+        _Cx >>= 1;
+    } while (_Cx != 0);
+    return static_cast<int>(_Nx) - static_cast<int>(_Val);
+}
+
+#if !defined(_M_CEE_PURE) && !defined(__CUDACC__) && !defined(__INTEL_COMPILER)
+#define _HAS_COUNTL_ZERO_INTRINSICS 1
+#else // ^^^ intrinsics available / intrinsics unavailable vvv
+#define _HAS_COUNTL_ZERO_INTRINSICS 0
+#endif // ^^^ intrinsics unavailable ^^^
+
+#if _HAS_COUNTL_ZERO_INTRINSICS
+#if (defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)) || (defined(_M_X64) && !defined(_M_ARM64EC))
+template <class _Ty>
+_NODISCARD int _Countl_zero_lzcnt(const _Ty _Val) noexcept {
+    constexpr int _Digits = _Unsigned_integer_digits<_Ty>;
+
+    if constexpr (_Digits <= 16) {
+        return static_cast<int>(__lzcnt16(_Val) - (16 - _Digits));
+    } else if constexpr (_Digits == 32) {
+        return static_cast<int>(__lzcnt(_Val));
+    } else {
+#ifdef _M_IX86
+        const unsigned int _High = _Val >> 32;
+        const auto _Low          = static_cast<unsigned int>(_Val);
+        if (_High == 0) {
+            return 32 + _Countl_zero_lzcnt(_Low);
+        } else {
+            return _Countl_zero_lzcnt(_High);
+        }
+#else // ^^^ defined(_M_IX86) / !defined(_M_IX86) vvv
+        return static_cast<int>(__lzcnt64(_Val));
+#endif // ^^^ !defined(_M_IX86) ^^^
+    }
+}
+
+template <class _Ty>
+_NODISCARD int _Countl_zero_bsr(const _Ty _Val) noexcept {
+    constexpr int _Digits = _Unsigned_integer_digits<_Ty>;
+
+    unsigned long _Result;
+    if constexpr (_Digits <= 32) {
+        if (!_BitScanReverse(&_Result, _Val)) {
+            return _Digits;
+        }
+    } else {
+#ifdef _M_IX86
+        const unsigned int _High = _Val >> 32;
+        if (_BitScanReverse(&_Result, _High)) {
+            return static_cast<int>(31 - _Result);
+        }
+
+        const auto _Low = static_cast<unsigned int>(_Val);
+        if (!_BitScanReverse(&_Result, _Low)) {
+            return _Digits;
+        }
+#else // ^^^ defined(_M_IX86) / !defined(_M_IX86) vvv
+        if (!_BitScanReverse64(&_Result, _Val)) {
+            return _Digits;
+        }
+#endif // ^^^ !defined(_M_IX86) ^^^
+    }
+    return static_cast<int>(_Digits - 1 - _Result);
+}
+
+template <class _Ty>
+_NODISCARD int _Checked_x86_x64_countl_zero(const _Ty _Val) noexcept {
+#ifdef __AVX2__
+    return _Countl_zero_lzcnt(_Val);
+#else // ^^^ defined(__AVX2__) / !defined(__AVX2__) vvv
+    const bool _Definitely_have_lzcnt = __isa_available >= _Stl_isa_available_avx2;
+    if (_Definitely_have_lzcnt) {
+        return _Countl_zero_lzcnt(_Val);
+    } else {
+        return _Countl_zero_bsr(_Val);
+    }
+#endif // ^^^ !defined(__AVX2__) ^^^
+}
+#endif // (defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)) || (defined(_M_X64) && !defined(_M_ARM64EC))
+
+#if defined(_M_ARM) || defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+#ifdef __clang__ // TRANSITION, GH-1586
+_NODISCARD constexpr int _Clang_arm_arm64_countl_zero(const unsigned short _Val) {
+    return __builtin_clzs(_Val);
+}
+
+_NODISCARD constexpr int _Clang_arm_arm64_countl_zero(const unsigned int _Val) {
+    return __builtin_clz(_Val);
+}
+
+_NODISCARD constexpr int _Clang_arm_arm64_countl_zero(const unsigned long _Val) {
+    return __builtin_clzl(_Val);
+}
+
+_NODISCARD constexpr int _Clang_arm_arm64_countl_zero(const unsigned long long _Val) {
+    return __builtin_clzll(_Val);
+}
+#endif // TRANSITION, GH-1586
+
+template <class _Ty>
+_NODISCARD int _Checked_arm_arm64_countl_zero(const _Ty _Val) noexcept {
+    constexpr int _Digits = _Unsigned_integer_digits<_Ty>;
+    if (_Val == 0) {
+        return _Digits;
+    }
+
+#ifdef __clang__ // TRANSITION, GH-1586
+    if constexpr (is_same_v<remove_cv_t<_Ty>, unsigned char>) {
+        return _Clang_arm_arm64_countl_zero(static_cast<unsigned short>(_Val))
+             - (_Unsigned_integer_digits<unsigned short> - _Digits);
+    } else {
+        return _Clang_arm_arm64_countl_zero(_Val);
+    }
+#else // ^^^ workaround / no workaround vvv
+    if constexpr (_Digits <= 32) {
+        return static_cast<int>(_CountLeadingZeros(_Val)) - (_Unsigned_integer_digits<unsigned long> - _Digits);
+    } else {
+        return static_cast<int>(_CountLeadingZeros64(_Val));
+    }
+#endif // ^^^ no workaround ^^^
+}
+#endif // defined(_M_ARM) || defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+#endif // _HAS_COUNTL_ZERO_INTRINSICS
+
+// Implementation of countr_zero without using specialized CPU instructions.
+// Used at compile time and when said instructions are not supported.
+// see "Hacker's Delight" section 5-4
+template <class _Ty>
+_NODISCARD constexpr int _Countr_zero_fallback(const _Ty _Val) noexcept {
+    constexpr int _Digits = _Unsigned_integer_digits<_Ty>;
+    return _Digits - _Countl_zero_fallback(static_cast<_Ty>(static_cast<_Ty>(~_Val) & static_cast<_Ty>(_Val - 1)));
+}
+
+// Implementation of popcount without using specialized CPU instructions.
+// Used at compile time and when said instructions are not supported.
+template <class _Ty>
+_NODISCARD constexpr int _Popcount_fallback(_Ty _Val) noexcept {
+    constexpr int _Digits = _Unsigned_integer_digits<_Ty>;
+#if (defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)) || defined(_M_ARM)
+    if constexpr (_Digits == 64) {
+        // 64-bit bit operations on architectures without 64-bit registers are less efficient,
+        // hence we split the value so that it fits in 32-bit registers
+        return _Popcount_fallback(static_cast<unsigned long>(_Val))
+             + _Popcount_fallback(static_cast<unsigned long>(_Val >> 32));
+    } else
+#endif // (defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)) || defined(_M_ARM)
+    {
+        // we static_cast these bit patterns in order to truncate them to the correct size
+        _Val = static_cast<_Ty>(_Val - ((_Val >> 1) & static_cast<_Ty>(0x5555'5555'5555'5555ull)));
+        _Val = static_cast<_Ty>((_Val & static_cast<_Ty>(0x3333'3333'3333'3333ull))
+                                + ((_Val >> 2) & static_cast<_Ty>(0x3333'3333'3333'3333ull)));
+        _Val = static_cast<_Ty>((_Val + (_Val >> 4)) & static_cast<_Ty>(0x0F0F'0F0F'0F0F'0F0Full));
+        // Multiply by one in each byte, so that it will have the sum of all source bytes in the highest byte
+        _Val = static_cast<_Ty>(_Val * static_cast<_Ty>(0x0101'0101'0101'0101ull));
+        // Extract highest byte
+        return static_cast<int>(_Val >> (_Digits - 8));
+    }
+}
+
+#if ((defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)) || (defined(_M_X64) && !defined(_M_ARM64EC))) \
+    && !defined(_M_CEE_PURE) && !defined(__CUDACC__) && !defined(__INTEL_COMPILER)
+#define _HAS_TZCNT_BSF_INTRINSICS 1
+#else // ^^^ intrinsics available / intrinsics unavailable vvv
+#define _HAS_TZCNT_BSF_INTRINSICS 0
+#endif // ^^^ intrinsics unavailable ^^^
+
+#if _HAS_TZCNT_BSF_INTRINSICS
+#ifdef __clang__
+#define _TZCNT_U32 __builtin_ia32_tzcnt_u32
+#define _TZCNT_U64 __builtin_ia32_tzcnt_u64
+#else // ^^^ __clang__ / !__clang__ vvv
+#define _TZCNT_U32 _tzcnt_u32
+#define _TZCNT_U64 _tzcnt_u64
+#endif // __clang__
+
+template <class _Ty>
+_NODISCARD int _Countr_zero_tzcnt(const _Ty _Val) noexcept {
+    constexpr int _Digits = _Unsigned_integer_digits<_Ty>;
+    constexpr _Ty _Max    = static_cast<_Ty>(-1); // equal to (numeric_limits<_Ty>::max)()
+
+    if constexpr (_Digits <= 32) {
+        // Intended widening to int. This operation means that a narrow 0 will widen
+        // to 0xFFFF....FFFF0... instead of 0. We need this to avoid counting all the zeros
+        // of the wider type.
+        return static_cast<int>(_TZCNT_U32(static_cast<unsigned int>(~_Max | _Val)));
+    } else {
+#ifdef _M_IX86
+        const auto _Low = static_cast<unsigned int>(_Val);
+        if (_Low == 0) {
+            const unsigned int _High = _Val >> 32;
+            return static_cast<int>(32 + _TZCNT_U32(_High));
+        } else {
+            return static_cast<int>(_TZCNT_U32(_Low));
+        }
+#else // ^^^ defined(_M_IX86) / !defined(_M_IX86) vvv
+        return static_cast<int>(_TZCNT_U64(_Val));
+#endif // ^^^ !defined(_M_IX86) ^^^
+    }
+}
+
+#undef _TZCNT_U32
+#undef _TZCNT_U64
+
+template <class _Ty>
+_NODISCARD int _Countr_zero_bsf(const _Ty _Val) noexcept {
+    constexpr int _Digits = _Unsigned_integer_digits<_Ty>;
+    constexpr _Ty _Max    = static_cast<_Ty>(-1); // equal to (numeric_limits<_Ty>::max)()
+
+    unsigned long _Result;
+    if constexpr (_Digits <= 32) {
+        // Intended widening to int. This operation means that a narrow 0 will widen
+        // to 0xFFFF....FFFF0... instead of 0. We need this to avoid counting all the zeros
+        // of the wider type.
+        if (!_BitScanForward(&_Result, static_cast<unsigned int>(~_Max | _Val))) {
+            return _Digits;
+        }
+    } else {
+#ifdef _M_IX86
+        const auto _Low = static_cast<unsigned int>(_Val);
+        if (_BitScanForward(&_Result, _Low)) {
+            return static_cast<int>(_Result);
+        }
+
+        const unsigned int _High = _Val >> 32;
+        if (!_BitScanForward(&_Result, _High)) {
+            return _Digits;
+        } else {
+            return static_cast<int>(_Result + 32);
+        }
+#else // ^^^ defined(_M_IX86) / !defined(_M_IX86) vvv
+        if (!_BitScanForward64(&_Result, _Val)) {
+            return _Digits;
+        }
+#endif // ^^^ !defined(_M_IX86) ^^^
+    }
+    return static_cast<int>(_Result);
+}
+
+template <class _Ty>
+_NODISCARD int _Checked_x86_x64_countr_zero(const _Ty _Val) noexcept {
+#ifdef __AVX2__
+    return _Countr_zero_tzcnt(_Val);
+#else // ^^^ defined(__AVX2__) / !defined(__AVX2__) vvv
+    const bool _Definitely_have_tzcnt = __isa_available >= _Stl_isa_available_avx2;
+    if (_Definitely_have_tzcnt) {
+        return _Countr_zero_tzcnt(_Val);
+    } else {
+        return _Countr_zero_bsf(_Val);
+    }
+#endif // ^^^ !defined(__AVX2__) ^^^
+}
+
+#endif // _HAS_TZCNT_BSF_INTRINSICS
+
+#if (defined(_M_IX86) || defined(_M_X64) || defined(_M_ARM64)) && !defined(_M_CEE_PURE) && !defined(__CUDACC__) \
+    && !defined(__INTEL_COMPILER)
+#define _HAS_POPCNT_INTRINSICS 1
+#if defined(__AVX__) || defined(_M_ARM64) || defined(_M_ARM64EC)
+#define _POPCNT_INTRINSICS_ALWAYS_AVAILABLE 1
+#else // ^^^ intrinsics always available / intrinsics not always available vvv
+#define _POPCNT_INTRINSICS_ALWAYS_AVAILABLE 0
+#endif // ^^^ intrinsics not always available ^^^
+#else // ^^^ intrinsics available / intrinsics unavailable vvv
+#define _HAS_POPCNT_INTRINSICS 0
+#endif // ^^^ intrinsics unavailable ^^^
+
+#if _HAS_POPCNT_INTRINSICS
+template <class _Ty>
+_NODISCARD int _Unchecked_popcount(const _Ty _Val) noexcept {
+    constexpr int _Digits = _Unsigned_integer_digits<_Ty>;
+    if constexpr (_Digits <= 16) {
+        return static_cast<int>(__popcnt16(_Val));
+    } else if constexpr (_Digits == 32) {
+        return static_cast<int>(__popcnt(_Val));
+    } else {
+#ifdef _M_IX86
+        return static_cast<int>(__popcnt(_Val >> 32) + __popcnt(static_cast<unsigned int>(_Val)));
+#else // ^^^ defined(_M_IX86) / !defined(_M_IX86) vvv
+        return static_cast<int>(__popcnt64(_Val));
+#endif // ^^^ !defined(_M_IX86) ^^^
+    }
+}
+
+template <class _Ty>
+_NODISCARD int _Checked_popcount(const _Ty _Val) noexcept {
+#if !_POPCNT_INTRINSICS_ALWAYS_AVAILABLE
+    const bool _Definitely_have_popcnt = __isa_available >= _Stl_isa_available_sse42;
+    if (!_Definitely_have_popcnt) {
+        return _Popcount_fallback(_Val);
+    }
+#endif // ^^^ !_POPCNT_INTRINSICS_ALWAYS_AVAILABLE ^^^
+    return _Unchecked_popcount(_Val);
+}
+#endif // ^^^ _HAS_POPCNT_INTRINSICS ^^^
+
+template <class _Ty>
+constexpr bool _Is_standard_unsigned_integer =
+    _Is_any_of_v<remove_cv_t<_Ty>, unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long>;
+
+template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
+_NODISCARD _CONSTEXPR20 int _Countr_zero(const _Ty _Val) noexcept {
+#if _HAS_TZCNT_BSF_INTRINSICS
+#if _HAS_CXX20
+    if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+    {
+        return _Checked_x86_x64_countr_zero(_Val);
+    }
+#endif // _HAS_TZCNT_BSF_INTRINSICS
+    return _Countr_zero_fallback(_Val);
+}
+
+template <class _Ty, class _Fn>
+constexpr decltype(auto) _Select_countr_zero_impl(_Fn _Callback) {
+    // TRANSITION, DevCom-1527995: Lambdas in this function ensure inlining
+#if _HAS_TZCNT_BSF_INTRINSICS && _HAS_CXX20
+    if (!_STD is_constant_evaluated()) {
+#ifdef __AVX2__
+        return _Callback([](_Ty _Val) _STATIC_CALL_OPERATOR { return _Countr_zero_tzcnt(_Val); });
+#else // ^^^ AVX2 / not AVX2 vvv
+        const bool _Definitely_have_tzcnt = __isa_available >= _Stl_isa_available_avx2;
+        if (_Definitely_have_tzcnt) {
+            return _Callback([](_Ty _Val) _STATIC_CALL_OPERATOR { return _Countr_zero_tzcnt(_Val); });
+        } else {
+            return _Callback([](_Ty _Val) _STATIC_CALL_OPERATOR { return _Countr_zero_bsf(_Val); });
+        }
+#endif // ^^^ not AVX2 ^^^
+    }
+#endif // ^^^ _HAS_TZCNT_BSF_INTRINSICS && _HAS_CXX20 ^^^
+    // C++17 constexpr gcd() calls this function, so it should be constexpr unless we detect runtime evaluation.
+    return _Callback([](_Ty _Val) _STATIC_CALL_OPERATOR { return _Countr_zero_fallback(_Val); });
+}
+
+template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
+_NODISCARD _CONSTEXPR20 int _Popcount(const _Ty _Val) noexcept {
+#if _HAS_POPCNT_INTRINSICS
+#if _HAS_CXX20
+    if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+    {
+        return _Checked_popcount(_Val);
+    }
+#endif // ^^^ _HAS_POPCNT_INTRINSICS ^^^
+    return _Popcount_fallback(_Val);
+}
+
+template <class _Ty, class _Fn>
+_CONSTEXPR20 decltype(auto) _Select_popcount_impl(_Fn _Callback) {
+    // TRANSITION, DevCom-1527995: Lambdas in this function ensure inlining
+#if _HAS_POPCNT_INTRINSICS
+#if _HAS_CXX20
+    if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+    {
+#if !_POPCNT_INTRINSICS_ALWAYS_AVAILABLE
+        const bool _Definitely_have_popcnt = __isa_available >= _Stl_isa_available_sse42;
+        if (!_Definitely_have_popcnt) {
+            return _Callback([](_Ty _Val) _STATIC_CALL_OPERATOR { return _Popcount_fallback(_Val); });
+        }
+#endif // ^^^ !_POPCNT_INTRINSICS_ALWAYS_AVAILABLE ^^^
+        return _Callback([](_Ty _Val) _STATIC_CALL_OPERATOR { return _Unchecked_popcount(_Val); });
+    }
+#endif // ^^^ _HAS_POPCNT_INTRINSICS ^^^
+    return _Callback([](_Ty _Val) _STATIC_CALL_OPERATOR { return _Popcount_fallback(_Val); });
+}
+
+#undef _HAS_POPCNT_INTRINSICS
+#undef _HAS_TZCNT_BSF_INTRINSICS
+#undef _POPCNT_INTRINSICS_ALWAYS_AVAILABLE
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // __MSVC_BIT_UTILS_HPP

miniMSVC/VC/Tools/MSVC/14.42.34433/include/__msvc_chrono.hpp

@@ -0,0 +1,801 @@
+// __msvc_chrono.hpp internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef __MSVC_CHRONO_HPP
+#define __MSVC_CHRONO_HPP
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <ctime>
+#include <limits>
+#include <ratio>
+#include <type_traits>
+#include <utility>
+#include <xtimec.h>
+
+#if _HAS_CXX20
+#include <compare>
+#endif
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+namespace chrono {
+    _EXPORT_STD template <class _Rep>
+    struct treat_as_floating_point : is_floating_point<_Rep> {}; // tests for floating-point type
+
+    _EXPORT_STD template <class _Rep>
+    constexpr bool treat_as_floating_point_v = treat_as_floating_point<_Rep>::value;
+
+    _EXPORT_STD template <class _Rep>
+    struct duration_values { // gets arithmetic properties of a type
+        _NODISCARD static constexpr _Rep zero() noexcept {
+            // get zero value
+            return _Rep(0);
+        }
+
+        _NODISCARD static constexpr _Rep(min)() noexcept {
+            // get smallest value
+            return numeric_limits<_Rep>::lowest();
+        }
+
+        _NODISCARD static constexpr _Rep(max)() noexcept {
+            // get largest value
+            return (numeric_limits<_Rep>::max)();
+        }
+    };
+
+#if _HAS_CXX20
+    _EXPORT_STD template <class _Clock>
+    constexpr bool is_clock_v = requires {
+        typename _Clock::rep;
+        typename _Clock::period;
+        typename _Clock::duration;
+        typename _Clock::time_point;
+        _Clock::is_steady;
+        _Clock::now();
+    };
+    _EXPORT_STD template <class _Clock>
+    struct is_clock : bool_constant<is_clock_v<_Clock>> {};
+
+    template <class _Clock>
+    constexpr bool _Is_clock_v = is_clock_v<_Clock>;
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    template <class _Clock, class = void>
+    constexpr bool _Is_clock_v = false;
+
+    template <class _Clock>
+    constexpr bool
+        _Is_clock_v<_Clock, void_t<typename _Clock::rep, typename _Clock::period, typename _Clock::duration,
+                                typename _Clock::time_point, decltype(_Clock::is_steady), decltype(_Clock::now())>> =
+            true;
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    _EXPORT_STD template <class _Rep, class _Period = ratio<1>>
+    class duration;
+
+    template <class _Ty>
+    constexpr bool _Is_duration_v = _Is_specialization_v<_Ty, duration>;
+
+    _EXPORT_STD template <class _To, class _Rep, class _Period, enable_if_t<_Is_duration_v<_To>, int> = 0>
+    constexpr _To duration_cast(const duration<_Rep, _Period>&) noexcept(
+        is_arithmetic_v<_Rep> && is_arithmetic_v<typename _To::rep>); // strengthened
+
+    _EXPORT_STD template <class _Rep, class _Period>
+    class duration { // represents a time duration
+    public:
+        using rep    = _Rep;
+        using period = typename _Period::type;
+
+        static_assert(!_Is_duration_v<_Rep>, "duration can't have duration as first template argument");
+        static_assert(_Is_ratio_v<_Period>, "period not an instance of std::ratio");
+        static_assert(0 < _Period::num, "period negative or zero");
+
+        constexpr duration() = default;
+
+        template <class _Rep2,
+            enable_if_t<is_convertible_v<const _Rep2&, _Rep>
+                            && (treat_as_floating_point_v<_Rep> || !treat_as_floating_point_v<_Rep2>),
+                int> = 0>
+        constexpr explicit duration(const _Rep2& _Val) noexcept(
+            is_arithmetic_v<_Rep> && is_arithmetic_v<_Rep2>) // strengthened
+            : _MyRep(static_cast<_Rep>(_Val)) {}
+
+        template <class _Rep2, class _Period2,
+            enable_if_t<treat_as_floating_point_v<_Rep>
+                            || (_Ratio_divide_sfinae<_Period2, _Period>::den == 1 && !treat_as_floating_point_v<_Rep2>),
+                int> = 0>
+        constexpr duration(const duration<_Rep2, _Period2>& _Dur) noexcept(
+            is_arithmetic_v<_Rep> && is_arithmetic_v<_Rep2>) // strengthened
+            : _MyRep(_CHRONO duration_cast<duration>(_Dur).count()) {}
+
+        _NODISCARD constexpr _Rep count() const noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            return _MyRep;
+        }
+
+        _NODISCARD constexpr common_type_t<duration> operator+() const
+            noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            return common_type_t<duration>(*this);
+        }
+
+        _NODISCARD constexpr common_type_t<duration> operator-() const
+            noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            return common_type_t<duration>(-_MyRep);
+        }
+
+        _CONSTEXPR17 duration& operator++() noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            ++_MyRep;
+            return *this;
+        }
+
+        _CONSTEXPR17 duration operator++(int) noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            return duration(_MyRep++);
+        }
+
+        _CONSTEXPR17 duration& operator--() noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            --_MyRep;
+            return *this;
+        }
+
+        _CONSTEXPR17 duration operator--(int) noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            return duration(_MyRep--);
+        }
+
+        _CONSTEXPR17 duration& operator+=(const duration& _Right) noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            _MyRep += _Right._MyRep;
+            return *this;
+        }
+
+        _CONSTEXPR17 duration& operator-=(const duration& _Right) noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            _MyRep -= _Right._MyRep;
+            return *this;
+        }
+
+        _CONSTEXPR17 duration& operator*=(const _Rep& _Right) noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            _MyRep *= _Right;
+            return *this;
+        }
+
+        _CONSTEXPR17 duration& operator/=(const _Rep& _Right) noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            _MyRep /= _Right;
+            return *this;
+        }
+
+        _CONSTEXPR17 duration& operator%=(const _Rep& _Right) noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            _MyRep %= _Right;
+            return *this;
+        }
+
+        _CONSTEXPR17 duration& operator%=(const duration& _Right) noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            _MyRep %= _Right.count();
+            return *this;
+        }
+
+        _NODISCARD static constexpr duration zero() noexcept {
+            // get zero value
+            return duration(duration_values<_Rep>::zero());
+        }
+
+        _NODISCARD static constexpr duration(min)() noexcept {
+            // get minimum value
+            return duration((duration_values<_Rep>::min)());
+        }
+
+        _NODISCARD static constexpr duration(max)() noexcept {
+            // get maximum value
+            return duration((duration_values<_Rep>::max)());
+        }
+
+    private:
+        _Rep _MyRep; // the stored rep
+    };
+
+    _EXPORT_STD template <class _Clock, class _Duration = typename _Clock::duration>
+    class time_point { // represents a point in time
+    public:
+        using clock    = _Clock;
+        using duration = _Duration;
+        using rep      = typename _Duration::rep;
+        using period   = typename _Duration::period;
+
+        static_assert(_Is_duration_v<_Duration>,
+            "N4950 [time.point.general]/1 mandates Duration to be a specialization of chrono::duration.");
+
+        constexpr time_point() = default;
+
+        constexpr explicit time_point(const _Duration& _Other) noexcept(is_arithmetic_v<rep>) // strengthened
+            : _MyDur(_Other) {}
+
+        template <class _Duration2, enable_if_t<is_convertible_v<_Duration2, _Duration>, int> = 0>
+        constexpr time_point(const time_point<_Clock, _Duration2>& _Tp) noexcept(
+            is_arithmetic_v<rep> && is_arithmetic_v<typename _Duration2::rep>) // strengthened
+            : _MyDur(_Tp.time_since_epoch()) {}
+
+        _NODISCARD constexpr _Duration time_since_epoch() const noexcept(is_arithmetic_v<rep>) /* strengthened */ {
+            return _MyDur;
+        }
+
+#if _HAS_CXX20
+        constexpr time_point& operator++() noexcept(is_arithmetic_v<rep>) /* strengthened */ {
+            ++_MyDur;
+            return *this;
+        }
+        constexpr time_point operator++(int) noexcept(is_arithmetic_v<rep>) /* strengthened */ {
+            return time_point{_MyDur++};
+        }
+        constexpr time_point& operator--() noexcept(is_arithmetic_v<rep>) /* strengthened */ {
+            --_MyDur;
+            return *this;
+        }
+        constexpr time_point operator--(int) noexcept(is_arithmetic_v<rep>) /* strengthened */ {
+            return time_point{_MyDur--};
+        }
+#endif // _HAS_CXX20
+
+        _CONSTEXPR17 time_point& operator+=(const _Duration& _Dur) noexcept(is_arithmetic_v<rep>) /* strengthened */ {
+            _MyDur += _Dur;
+            return *this;
+        }
+
+        _CONSTEXPR17 time_point& operator-=(const _Duration& _Dur) noexcept(is_arithmetic_v<rep>) /* strengthened */ {
+            _MyDur -= _Dur;
+            return *this;
+        }
+
+        _NODISCARD static constexpr time_point(min)() noexcept {
+            return time_point((_Duration::min)());
+        }
+
+        _NODISCARD static constexpr time_point(max)() noexcept {
+            return time_point((_Duration::max)());
+        }
+
+    private:
+        _Duration _MyDur{duration::zero()}; // duration since the epoch
+    };
+} // namespace chrono
+
+template <class _Rep, class _Period>
+constexpr bool _Is_trivially_swappable_v<chrono::duration<_Rep, _Period>> = _Is_trivially_swappable_v<_Rep>;
+
+template <class _Clock, class _Duration>
+constexpr bool _Is_trivially_swappable_v<chrono::time_point<_Clock, _Duration>> = _Is_trivially_swappable_v<_Duration>;
+
+_NODISCARD constexpr intmax_t _Lcm(const intmax_t _Ax, const intmax_t _Bx) noexcept {
+    return (_Ax / _Gcd(_Ax, _Bx)) * _Bx;
+}
+
+template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+struct common_type<_CHRONO duration<_Rep1, _Period1>, _CHRONO duration<_Rep2, _Period2>> {
+    using type = _CHRONO duration<common_type_t<_Rep1, _Rep2>,
+        ratio<_Gcd(_Period1::num, _Period2::num), _Lcm(_Period1::den, _Period2::den)>>;
+};
+
+template <class _Clock, class _Duration1, class _Duration2>
+struct common_type<_CHRONO time_point<_Clock, _Duration1>,
+    _CHRONO time_point<_Clock, _Duration2>> { // common type of two time points
+    using type = _CHRONO time_point<_Clock, common_type_t<_Duration1, _Duration2>>;
+};
+
+namespace chrono {
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _NODISCARD constexpr common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>
+        operator+(const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right) noexcept(
+            is_arithmetic_v<_Rep1> && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        using _CD = common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>;
+        return _CD(_CD(_Left).count() + _CD(_Right).count());
+    }
+
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _NODISCARD constexpr common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>
+        operator-(const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right) noexcept(
+            is_arithmetic_v<_Rep1> && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        using _CD = common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>;
+        return _CD(_CD(_Left).count() - _CD(_Right).count());
+    }
+
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2,
+        enable_if_t<is_convertible_v<const _Rep2&, common_type_t<_Rep1, _Rep2>>, int> = 0>
+    _NODISCARD constexpr duration<common_type_t<_Rep1, _Rep2>, _Period1> operator*(
+        const duration<_Rep1, _Period1>& _Left,
+        const _Rep2& _Right) noexcept(is_arithmetic_v<_Rep1> && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        using _CR = common_type_t<_Rep1, _Rep2>;
+        using _CD = duration<_CR, _Period1>;
+        return _CD(_CD(_Left).count() * _Right);
+    }
+
+    _EXPORT_STD template <class _Rep1, class _Rep2, class _Period2,
+        enable_if_t<is_convertible_v<const _Rep1&, common_type_t<_Rep1, _Rep2>>, int> = 0>
+    _NODISCARD constexpr duration<common_type_t<_Rep1, _Rep2>, _Period2> operator*(const _Rep1& _Left,
+        const duration<_Rep2, _Period2>& _Right) noexcept(is_arithmetic_v<_Rep1>
+                                                          && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        return _Right * _Left;
+    }
+
+    template <class _CR, class _Period1, class _Rep2, bool = is_convertible_v<const _Rep2&, _CR>>
+    struct _Duration_div_mod1 { // return type for duration / rep and duration % rep
+        using type = duration<_CR, _Period1>;
+    };
+
+    template <class _CR, class _Period1, class _Rep2>
+    struct _Duration_div_mod1<_CR, _Period1, _Rep2, false> {}; // no return type
+
+    template <class _CR, class _Period1, class _Rep2, bool = _Is_duration_v<_Rep2>>
+    struct _Duration_div_mod {}; // no return type
+
+    template <class _CR, class _Period1, class _Rep2>
+    struct _Duration_div_mod<_CR, _Period1, _Rep2, false> : _Duration_div_mod1<_CR, _Period1, _Rep2> {
+        // return type for duration / rep and duration % rep
+    };
+
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2>
+    _NODISCARD constexpr typename _Duration_div_mod<common_type_t<_Rep1, _Rep2>, _Period1, _Rep2>::type operator/(
+        const duration<_Rep1, _Period1>& _Left,
+        const _Rep2& _Right) noexcept(is_arithmetic_v<_Rep1> && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        using _CR = common_type_t<_Rep1, _Rep2>;
+        using _CD = duration<_CR, _Period1>;
+        return _CD(_CD(_Left).count() / _Right);
+    }
+
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _NODISCARD constexpr common_type_t<_Rep1, _Rep2> operator/(const duration<_Rep1, _Period1>& _Left,
+        const duration<_Rep2, _Period2>& _Right) noexcept(is_arithmetic_v<_Rep1>
+                                                          && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        using _CD = common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>;
+        return _CD(_Left).count() / _CD(_Right).count();
+    }
+
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2>
+    _NODISCARD constexpr typename _Duration_div_mod<common_type_t<_Rep1, _Rep2>, _Period1, _Rep2>::type operator%(
+        const duration<_Rep1, _Period1>& _Left,
+        const _Rep2& _Right) noexcept(is_arithmetic_v<_Rep1> && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        using _CR = common_type_t<_Rep1, _Rep2>;
+        using _CD = duration<_CR, _Period1>;
+        return _CD(_CD(_Left).count() % _Right);
+    }
+
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _NODISCARD constexpr common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>
+        operator%(const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right) noexcept(
+            is_arithmetic_v<_Rep1> && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        using _CD = common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>;
+        return _CD(_CD(_Left).count() % _CD(_Right).count());
+    }
+
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _NODISCARD constexpr bool operator==(const duration<_Rep1, _Period1>& _Left,
+        const duration<_Rep2, _Period2>& _Right) noexcept(is_arithmetic_v<_Rep1>
+                                                          && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        using _CT = common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>;
+        return _CT(_Left).count() == _CT(_Right).count();
+    }
+
+#if !_HAS_CXX20
+    template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _NODISCARD constexpr bool operator!=(const duration<_Rep1, _Period1>& _Left,
+        const duration<_Rep2, _Period2>& _Right) noexcept(is_arithmetic_v<_Rep1>
+                                                          && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _NODISCARD constexpr bool operator<(const duration<_Rep1, _Period1>& _Left,
+        const duration<_Rep2, _Period2>& _Right) noexcept(is_arithmetic_v<_Rep1>
+                                                          && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        using _CT = common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>;
+        return _CT(_Left).count() < _CT(_Right).count();
+    }
+
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _NODISCARD constexpr bool operator<=(const duration<_Rep1, _Period1>& _Left,
+        const duration<_Rep2, _Period2>& _Right) noexcept(is_arithmetic_v<_Rep1>
+                                                          && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        return !(_Right < _Left);
+    }
+
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _NODISCARD constexpr bool operator>(const duration<_Rep1, _Period1>& _Left,
+        const duration<_Rep2, _Period2>& _Right) noexcept(is_arithmetic_v<_Rep1>
+                                                          && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        return _Right < _Left;
+    }
+
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _NODISCARD constexpr bool operator>=(const duration<_Rep1, _Period1>& _Left,
+        const duration<_Rep2, _Period2>& _Right) noexcept(is_arithmetic_v<_Rep1>
+                                                          && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        return !(_Left < _Right);
+    }
+
+#if _HAS_CXX20
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+        requires three_way_comparable<typename common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>::rep>
+    _NODISCARD constexpr auto operator<=>(const duration<_Rep1, _Period1>& _Left,
+        const duration<_Rep2, _Period2>& _Right) noexcept(is_arithmetic_v<_Rep1>
+                                                          && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        using _CT = common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>;
+        return _CT(_Left).count() <=> _CT(_Right).count();
+    }
+#endif // _HAS_CXX20
+
+    _EXPORT_STD template <class _To, class _Rep, class _Period, enable_if_t<_Is_duration_v<_To>, int> /* = 0 */>
+    _NODISCARD constexpr _To duration_cast(const duration<_Rep, _Period>& _Dur) noexcept(
+        is_arithmetic_v<_Rep> && is_arithmetic_v<typename _To::rep>) /* strengthened */ {
+        // convert duration to another duration; truncate
+        using _CF = ratio_divide<_Period, typename _To::period>;
+
+        using _ToRep = typename _To::rep;
+        using _CR    = common_type_t<_ToRep, _Rep, intmax_t>;
+
+        constexpr bool _Num_is_one = _CF::num == 1;
+        constexpr bool _Den_is_one = _CF::den == 1;
+
+        if constexpr (_Den_is_one) {
+            if constexpr (_Num_is_one) {
+                return static_cast<_To>(static_cast<_ToRep>(_Dur.count()));
+            } else {
+                return static_cast<_To>(
+                    static_cast<_ToRep>(static_cast<_CR>(_Dur.count()) * static_cast<_CR>(_CF::num)));
+            }
+        } else {
+            if constexpr (_Num_is_one) {
+                return static_cast<_To>(
+                    static_cast<_ToRep>(static_cast<_CR>(_Dur.count()) / static_cast<_CR>(_CF::den)));
+            } else {
+                return static_cast<_To>(static_cast<_ToRep>(
+                    static_cast<_CR>(_Dur.count()) * static_cast<_CR>(_CF::num) / static_cast<_CR>(_CF::den)));
+            }
+        }
+    }
+
+    _EXPORT_STD template <class _To, class _Rep, class _Period, enable_if_t<_Is_duration_v<_To>, int> = 0>
+    _NODISCARD constexpr _To floor(const duration<_Rep, _Period>& _Dur) noexcept(
+        is_arithmetic_v<_Rep> && is_arithmetic_v<typename _To::rep>) /* strengthened */ {
+        // convert duration to another duration; round towards negative infinity
+        // i.e. the greatest integral result such that the result <= _Dur
+        const _To _Casted{_CHRONO duration_cast<_To>(_Dur)};
+        if (_Casted > _Dur) {
+            return _To{_Casted.count() - static_cast<typename _To::rep>(1)};
+        }
+
+        return _Casted;
+    }
+
+    _EXPORT_STD template <class _To, class _Rep, class _Period, enable_if_t<_Is_duration_v<_To>, int> = 0>
+    _NODISCARD constexpr _To ceil(const duration<_Rep, _Period>& _Dur) noexcept(
+        is_arithmetic_v<_Rep> && is_arithmetic_v<typename _To::rep>) /* strengthened */ {
+        // convert duration to another duration; round towards positive infinity
+        // i.e. the least integral result such that _Dur <= the result
+        const _To _Casted{_CHRONO duration_cast<_To>(_Dur)};
+        if (_Casted < _Dur) {
+            return _To{_Casted.count() + static_cast<typename _To::rep>(1)};
+        }
+
+        return _Casted;
+    }
+
+    template <class _Rep>
+    constexpr bool _Is_even(_Rep _Val) noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+        // Tests whether _Val is even
+        return _Val % 2 == 0;
+    }
+
+    _EXPORT_STD template <class _To, class _Rep, class _Period,
+        enable_if_t<_Is_duration_v<_To> && !treat_as_floating_point_v<typename _To::rep>, int> = 0>
+    _NODISCARD constexpr _To round(const duration<_Rep, _Period>& _Dur) noexcept(
+        is_arithmetic_v<_Rep> && is_arithmetic_v<typename _To::rep>) /* strengthened */ {
+        // convert duration to another duration, round to nearest, ties to even
+        const _To _Floored{_CHRONO floor<_To>(_Dur)};
+        const _To _Ceiled{_Floored + _To{1}};
+        const auto _Floor_adjustment = _Dur - _Floored;
+        const auto _Ceil_adjustment  = _Ceiled - _Dur;
+        if (_Floor_adjustment < _Ceil_adjustment
+            || (_Floor_adjustment == _Ceil_adjustment && _Is_even(_Floored.count()))) {
+            return _Floored;
+        }
+
+        return _Ceiled;
+    }
+
+    _EXPORT_STD template <class _Rep, class _Period, enable_if_t<numeric_limits<_Rep>::is_signed, int> = 0>
+    _NODISCARD constexpr duration<_Rep, _Period> abs(const duration<_Rep, _Period> _Dur) noexcept(
+        is_arithmetic_v<_Rep>) /* strengthened */ {
+        // create a duration whose count() is the absolute value of _Dur.count()
+        if (_Dur < duration<_Rep, _Period>::zero()) {
+            return -_Dur;
+        } else {
+            return _Dur;
+        }
+    }
+
+    _EXPORT_STD using nanoseconds  = duration<long long, nano>;
+    _EXPORT_STD using microseconds = duration<long long, micro>;
+    _EXPORT_STD using milliseconds = duration<long long, milli>;
+    _EXPORT_STD using seconds      = duration<long long>;
+    _EXPORT_STD using minutes      = duration<int, ratio<60>>;
+    _EXPORT_STD using hours        = duration<int, ratio<3600>>;
+#if _HAS_CXX20
+    _EXPORT_STD using days   = duration<int, ratio_multiply<ratio<24>, hours::period>>;
+    _EXPORT_STD using weeks  = duration<int, ratio_multiply<ratio<7>, days::period>>;
+    _EXPORT_STD using years  = duration<int, ratio_multiply<ratio<146097, 400>, days::period>>;
+    _EXPORT_STD using months = duration<int, ratio_divide<years::period, ratio<12>>>;
+#endif // _HAS_CXX20
+
+    _EXPORT_STD template <class _Clock, class _Duration, class _Rep, class _Period>
+    _NODISCARD constexpr time_point<_Clock, common_type_t<_Duration, duration<_Rep, _Period>>>
+        operator+(const time_point<_Clock, _Duration>& _Left, const duration<_Rep, _Period>& _Right) noexcept(
+            is_arithmetic_v<typename _Duration::rep> && is_arithmetic_v<_Rep>) /* strengthened */ {
+        using _RT = time_point<_Clock, common_type_t<_Duration, duration<_Rep, _Period>>>;
+        return _RT(_Left.time_since_epoch() + _Right);
+    }
+
+    _EXPORT_STD template <class _Rep, class _Period, class _Clock, class _Duration>
+    _NODISCARD constexpr time_point<_Clock, common_type_t<duration<_Rep, _Period>, _Duration>>
+        operator+(const duration<_Rep, _Period>& _Left, const time_point<_Clock, _Duration>& _Right) noexcept(
+            is_arithmetic_v<_Rep> && is_arithmetic_v<typename _Duration::rep>) /* strengthened */ {
+        return _Right + _Left;
+    }
+
+    _EXPORT_STD template <class _Clock, class _Duration, class _Rep, class _Period>
+    _NODISCARD constexpr time_point<_Clock, common_type_t<_Duration, duration<_Rep, _Period>>>
+        operator-(const time_point<_Clock, _Duration>& _Left, const duration<_Rep, _Period>& _Right) noexcept(
+            is_arithmetic_v<typename _Duration::rep> && is_arithmetic_v<_Rep>) /* strengthened */ {
+        using _RT = time_point<_Clock, common_type_t<_Duration, duration<_Rep, _Period>>>;
+        return _RT(_Left.time_since_epoch() - _Right);
+    }
+
+    _EXPORT_STD template <class _Clock, class _Duration1, class _Duration2>
+    _NODISCARD constexpr common_type_t<_Duration1, _Duration2>
+        operator-(const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right) noexcept(
+            is_arithmetic_v<typename _Duration1::rep> && is_arithmetic_v<typename _Duration2::rep>) /* strengthened */ {
+        return _Left.time_since_epoch() - _Right.time_since_epoch();
+    }
+
+    _EXPORT_STD template <class _Clock, class _Duration1, class _Duration2>
+    _NODISCARD constexpr bool
+        operator==(const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right) noexcept(
+            is_arithmetic_v<typename _Duration1::rep> && is_arithmetic_v<typename _Duration2::rep>) /* strengthened */ {
+        return _Left.time_since_epoch() == _Right.time_since_epoch();
+    }
+
+#if !_HAS_CXX20
+    template <class _Clock, class _Duration1, class _Duration2>
+    _NODISCARD constexpr bool
+        operator!=(const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right) noexcept(
+            is_arithmetic_v<typename _Duration1::rep> && is_arithmetic_v<typename _Duration2::rep>) /* strengthened */ {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    _EXPORT_STD template <class _Clock, class _Duration1, class _Duration2>
+    _NODISCARD constexpr bool
+        operator<(const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right) noexcept(
+            is_arithmetic_v<typename _Duration1::rep> && is_arithmetic_v<typename _Duration2::rep>) /* strengthened */ {
+        return _Left.time_since_epoch() < _Right.time_since_epoch();
+    }
+
+    _EXPORT_STD template <class _Clock, class _Duration1, class _Duration2>
+    _NODISCARD constexpr bool
+        operator<=(const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right) noexcept(
+            is_arithmetic_v<typename _Duration1::rep> && is_arithmetic_v<typename _Duration2::rep>) /* strengthened */ {
+        return !(_Right < _Left);
+    }
+
+    _EXPORT_STD template <class _Clock, class _Duration1, class _Duration2>
+    _NODISCARD constexpr bool
+        operator>(const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right) noexcept(
+            is_arithmetic_v<typename _Duration1::rep> && is_arithmetic_v<typename _Duration2::rep>) /* strengthened */ {
+        return _Right < _Left;
+    }
+
+    _EXPORT_STD template <class _Clock, class _Duration1, class _Duration2>
+    _NODISCARD constexpr bool
+        operator>=(const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right) noexcept(
+            is_arithmetic_v<typename _Duration1::rep> && is_arithmetic_v<typename _Duration2::rep>) /* strengthened */ {
+        return !(_Left < _Right);
+    }
+
+#if _HAS_CXX20
+    _EXPORT_STD template <class _Clock, class _Duration1, three_way_comparable_with<_Duration1> _Duration2>
+    _NODISCARD constexpr auto
+        operator<=>(const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right) noexcept(
+            is_arithmetic_v<typename _Duration1::rep> && is_arithmetic_v<typename _Duration2::rep>) /* strengthened */ {
+        return _Left.time_since_epoch() <=> _Right.time_since_epoch();
+    }
+#endif // _HAS_CXX20
+
+    _EXPORT_STD template <class _To, class _Clock, class _Duration, enable_if_t<_Is_duration_v<_To>, int> = 0>
+    _NODISCARD constexpr time_point<_Clock, _To> time_point_cast(const time_point<_Clock, _Duration>& _Time) noexcept(
+        is_arithmetic_v<typename _Duration::rep> && is_arithmetic_v<typename _To::rep>) /* strengthened */ {
+        // change the duration type of a time_point; truncate
+        return time_point<_Clock, _To>(_CHRONO duration_cast<_To>(_Time.time_since_epoch()));
+    }
+
+    _EXPORT_STD template <class _To, class _Clock, class _Duration, enable_if_t<_Is_duration_v<_To>, int> = 0>
+    _NODISCARD constexpr time_point<_Clock, _To> floor(const time_point<_Clock, _Duration>& _Time) noexcept(
+        is_arithmetic_v<typename _Duration::rep> && is_arithmetic_v<typename _To::rep>) /* strengthened */ {
+        // change the duration type of a time_point; round towards negative infinity
+        return time_point<_Clock, _To>(_CHRONO floor<_To>(_Time.time_since_epoch()));
+    }
+
+    _EXPORT_STD template <class _To, class _Clock, class _Duration, enable_if_t<_Is_duration_v<_To>, int> = 0>
+    _NODISCARD constexpr time_point<_Clock, _To> ceil(const time_point<_Clock, _Duration>& _Time) noexcept(
+        is_arithmetic_v<typename _Duration::rep> && is_arithmetic_v<typename _To::rep>) /* strengthened */ {
+        // change the duration type of a time_point; round towards positive infinity
+        return time_point<_Clock, _To>(_CHRONO ceil<_To>(_Time.time_since_epoch()));
+    }
+
+    _EXPORT_STD template <class _To, class _Clock, class _Duration,
+        enable_if_t<_Is_duration_v<_To> && !treat_as_floating_point_v<typename _To::rep>, int> = 0>
+    _NODISCARD constexpr time_point<_Clock, _To> round(const time_point<_Clock, _Duration>& _Time) noexcept(
+        is_arithmetic_v<typename _Duration::rep> && is_arithmetic_v<typename _To::rep>) /* strengthened */ {
+        // change the duration type of a time_point; round to nearest, ties to even
+        return time_point<_Clock, _To>(_CHRONO round<_To>(_Time.time_since_epoch()));
+    }
+
+    _EXPORT_STD struct system_clock { // wraps GetSystemTimePreciseAsFileTime
+        using rep                       = long long;
+        using period                    = ratio<1, 10'000'000>; // 100 nanoseconds
+        using duration                  = _CHRONO duration<rep, period>;
+        using time_point                = _CHRONO time_point<system_clock>;
+        static constexpr bool is_steady = false;
+
+        _NODISCARD static time_point now() noexcept { // get current time
+            return time_point(duration(_Xtime_get_ticks()));
+        }
+
+        _NODISCARD static __time64_t to_time_t(const time_point& _Time) noexcept { // convert to __time64_t
+            return duration_cast<seconds>(_Time.time_since_epoch()).count();
+        }
+
+        _NODISCARD static time_point from_time_t(__time64_t _Tm) noexcept { // convert from __time64_t
+            return time_point{seconds{_Tm}};
+        }
+    };
+
+#if _HAS_CXX20
+    _EXPORT_STD template <class _Duration>
+    using sys_time                = time_point<system_clock, _Duration>;
+    _EXPORT_STD using sys_seconds = sys_time<seconds>;
+    _EXPORT_STD using sys_days    = sys_time<days>;
+#endif // _HAS_CXX20
+
+    _EXPORT_STD struct steady_clock { // wraps QueryPerformanceCounter
+        using rep                       = long long;
+        using period                    = nano;
+        using duration                  = nanoseconds;
+        using time_point                = _CHRONO time_point<steady_clock>;
+        static constexpr bool is_steady = true;
+
+#if defined(_M_ARM) || defined(_M_ARM64) // vvv ARM or ARM64 arch vvv
+#define _LIKELY_ARM_ARM64 _LIKELY
+#define _LIKELY_X86_X64
+#elif defined(_M_IX86) || defined(_M_X64) // ^^^ ARM or ARM64 arch / x86 or x64 arch vvv
+#define _LIKELY_ARM_ARM64
+#define _LIKELY_X86_X64 _LIKELY
+#else // ^^^ x86 or x64 arch / other arch vvv
+#define _LIKELY_ARM_ARM64
+#define _LIKELY_X86_X64
+#endif // ^^^ other arch ^^^
+        _NODISCARD static time_point now() noexcept { // get current time
+            const long long _Freq = _Query_perf_frequency(); // doesn't change after system boot
+            const long long _Ctr  = _Query_perf_counter();
+            static_assert(period::num == 1, "This assumes period::num == 1.");
+            // The compiler recognizes the constants for frequency and time period and uses shifts and
+            // multiplies instead of divides to calculate the nanosecond value.
+            constexpr long long _TenMHz        = 10'000'000;
+            constexpr long long _TwentyFourMHz = 24'000'000;
+            // clang-format off
+            if (_Freq == _TenMHz) _LIKELY_X86_X64 {
+                // 10 MHz is a very common QPC frequency on modern x86/x64 PCs. Optimizing for
+                // this specific frequency can double the performance of this function by
+                // avoiding the expensive frequency conversion path.
+                static_assert(period::den % _TenMHz == 0, "It should never fail.");
+                constexpr long long _Multiplier = period::den / _TenMHz;
+                return time_point(duration(_Ctr * _Multiplier));
+            } else if (_Freq == _TwentyFourMHz) _LIKELY_ARM_ARM64 {
+                // 24 MHz is a common frequency on ARM/ARM64, including cases where it emulates x86/x64.
+                const long long _Whole = (_Ctr / _TwentyFourMHz) * period::den;
+                const long long _Part  = (_Ctr % _TwentyFourMHz) * period::den / _TwentyFourMHz;
+                return time_point(duration(_Whole + _Part));
+            } else {
+                // Instead of just having "(_Ctr * period::den) / _Freq",
+                // the algorithm below prevents overflow when _Ctr is sufficiently large.
+                // It assumes that _Freq * period::den does not overflow, which is currently true for nano period.
+                // It is not realistic for _Ctr to accumulate to large values from zero with this assumption,
+                // but the initial value of _Ctr could be large.
+                const long long _Whole = (_Ctr / _Freq) * period::den;
+                const long long _Part  = (_Ctr % _Freq) * period::den / _Freq;
+                return time_point(duration(_Whole + _Part));
+            }
+            // clang-format on
+        }
+#undef _LIKELY_ARM_ARM64
+#undef _LIKELY_X86_X64
+    };
+
+    _EXPORT_STD using high_resolution_clock = steady_clock;
+} // namespace chrono
+
+inline namespace literals {
+    inline namespace chrono_literals {
+        _EXPORT_STD _NODISCARD constexpr _CHRONO hours operator""h(unsigned long long _Val) noexcept
+        /* strengthened */ {
+            return _CHRONO hours(_Val);
+        }
+
+        _EXPORT_STD _NODISCARD constexpr _CHRONO duration<double, ratio<3600>> operator""h(long double _Val) noexcept
+        /* strengthened */ {
+            return _CHRONO duration<double, ratio<3600>>(_Val);
+        }
+
+        _EXPORT_STD _NODISCARD constexpr _CHRONO minutes operator""min(unsigned long long _Val) noexcept
+        /* strengthened */ {
+            return _CHRONO minutes(_Val);
+        }
+
+        _EXPORT_STD _NODISCARD constexpr _CHRONO duration<double, ratio<60>> operator""min(long double _Val) noexcept
+        /* strengthened */ {
+            return _CHRONO duration<double, ratio<60>>(_Val);
+        }
+
+        _EXPORT_STD _NODISCARD constexpr _CHRONO seconds operator""s(unsigned long long _Val) noexcept
+        /* strengthened */ {
+            return _CHRONO seconds(_Val);
+        }
+
+        _EXPORT_STD _NODISCARD constexpr _CHRONO duration<double> operator""s(long double _Val) noexcept
+        /* strengthened */ {
+            return _CHRONO duration<double>(_Val);
+        }
+
+        _EXPORT_STD _NODISCARD constexpr _CHRONO milliseconds operator""ms(unsigned long long _Val) noexcept
+        /* strengthened */ {
+            return _CHRONO milliseconds(_Val);
+        }
+
+        _EXPORT_STD _NODISCARD constexpr _CHRONO duration<double, milli> operator""ms(long double _Val) noexcept
+        /* strengthened */ {
+            return _CHRONO duration<double, milli>(_Val);
+        }
+
+        _EXPORT_STD _NODISCARD constexpr _CHRONO microseconds operator""us(unsigned long long _Val) noexcept
+        /* strengthened */ {
+            return _CHRONO microseconds(_Val);
+        }
+
+        _EXPORT_STD _NODISCARD constexpr _CHRONO duration<double, micro> operator""us(long double _Val) noexcept
+        /* strengthened */ {
+            return _CHRONO duration<double, micro>(_Val);
+        }
+
+        _EXPORT_STD _NODISCARD constexpr _CHRONO nanoseconds operator""ns(unsigned long long _Val) noexcept
+        /* strengthened */ {
+            return _CHRONO nanoseconds(_Val);
+        }
+
+        _EXPORT_STD _NODISCARD constexpr _CHRONO duration<double, nano> operator""ns(long double _Val) noexcept
+        /* strengthened */ {
+            return _CHRONO duration<double, nano>(_Val);
+        }
+    } // namespace chrono_literals
+} // namespace literals
+
+namespace chrono {
+    _EXPORT_STD using namespace literals::chrono_literals;
+} // namespace chrono
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // __MSVC_CHRONO_HPP

miniMSVC/VC/Tools/MSVC/14.42.34433/include/__msvc_cxx_stdatomic.hpp

@@ -0,0 +1,138 @@
+// __msvc_cxx_stdatomic.hpp internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef __MSVC_CXX_STDATOMIC_HPP
+#define __MSVC_CXX_STDATOMIC_HPP
+
+// see _STL_COMPILER_PREPROCESSOR in yvals_core.h
+#if !defined(RC_INVOKED) && !defined(Q_MOC_RUN) && !defined(__midl)
+
+// provide a specific error message for C compilers, before the general error message in yvals_core.h
+#ifndef __cplusplus
+#error <__msvc_cxx_stdatomic.hpp> is an internal header. It is incompatible with C and should not be directly included.
+#endif // !defined(__cplusplus)
+
+#include <yvals.h>
+
+#ifdef _M_CEE_PURE
+#error <stdatomic.h> is not supported when compiling with /clr:pure.
+#endif // defined(_M_CEE_PURE)
+
+#if !_HAS_CXX23
+_EMIT_STL_WARNING(STL4038, "The contents of <stdatomic.h> are available only with C++23 or later.");
+#else // ^^^ !_HAS_CXX23 / _HAS_CXX23 vvv
+
+#include <atomic>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+template <class _Ty>
+using _Std_atomic = _STD atomic<_Ty>;
+
+#define _Atomic(T) _Std_atomic<T>
+
+using _STD memory_order;
+using _STD memory_order_relaxed;
+using _STD memory_order_consume;
+using _STD memory_order_acquire;
+using _STD memory_order_release;
+using _STD memory_order_acq_rel;
+using _STD memory_order_seq_cst;
+
+using _STD atomic_flag;
+
+using _STD atomic_bool;
+using _STD atomic_char;
+using _STD atomic_schar;
+using _STD atomic_uchar;
+using _STD atomic_short;
+using _STD atomic_ushort;
+using _STD atomic_int;
+using _STD atomic_uint;
+using _STD atomic_long;
+using _STD atomic_ulong;
+using _STD atomic_llong;
+using _STD atomic_ullong;
+
+#ifdef __cpp_lib_char8_t
+using _STD atomic_char8_t;
+#endif // defined(__cpp_lib_char8_t)
+
+using _STD atomic_char16_t;
+using _STD atomic_char32_t;
+using _STD atomic_wchar_t;
+using _STD atomic_int8_t;
+using _STD atomic_uint8_t;
+using _STD atomic_int16_t;
+using _STD atomic_uint16_t;
+using _STD atomic_int32_t;
+using _STD atomic_uint32_t;
+using _STD atomic_int64_t;
+using _STD atomic_uint64_t;
+using _STD atomic_int_least8_t;
+using _STD atomic_uint_least8_t;
+using _STD atomic_int_least16_t;
+using _STD atomic_uint_least16_t;
+using _STD atomic_int_least32_t;
+using _STD atomic_uint_least32_t;
+using _STD atomic_int_least64_t;
+using _STD atomic_uint_least64_t;
+using _STD atomic_int_fast8_t;
+using _STD atomic_uint_fast8_t;
+using _STD atomic_int_fast16_t;
+using _STD atomic_uint_fast16_t;
+using _STD atomic_int_fast32_t;
+using _STD atomic_uint_fast32_t;
+using _STD atomic_int_fast64_t;
+using _STD atomic_uint_fast64_t;
+using _STD atomic_intptr_t;
+using _STD atomic_uintptr_t;
+using _STD atomic_size_t;
+using _STD atomic_ptrdiff_t;
+using _STD atomic_intmax_t;
+using _STD atomic_uintmax_t;
+
+using _STD atomic_is_lock_free;
+using _STD atomic_load;
+using _STD atomic_load_explicit;
+using _STD atomic_store;
+using _STD atomic_store_explicit;
+using _STD atomic_exchange;
+using _STD atomic_exchange_explicit;
+using _STD atomic_compare_exchange_strong;
+using _STD atomic_compare_exchange_strong_explicit;
+using _STD atomic_compare_exchange_weak;
+using _STD atomic_compare_exchange_weak_explicit;
+using _STD atomic_fetch_add;
+using _STD atomic_fetch_add_explicit;
+using _STD atomic_fetch_sub;
+using _STD atomic_fetch_sub_explicit;
+using _STD atomic_fetch_or;
+using _STD atomic_fetch_or_explicit;
+using _STD atomic_fetch_xor;
+using _STD atomic_fetch_xor_explicit;
+using _STD atomic_fetch_and;
+using _STD atomic_fetch_and_explicit;
+using _STD atomic_flag_test_and_set;
+using _STD atomic_flag_test_and_set_explicit;
+using _STD atomic_flag_clear;
+using _STD atomic_flag_clear_explicit;
+
+using _STD atomic_thread_fence;
+using _STD atomic_signal_fence;
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ _HAS_CXX23 ^^^
+
+#endif // !defined(RC_INVOKED) && !defined(Q_MOC_RUN) && !defined(__midl)
+#endif // __MSVC_CXX_STDATOMIC_HPP

miniMSVC/VC/Tools/MSVC/14.42.34433/include/__msvc_filebuf.hpp

@@ -0,0 +1,790 @@
+// __msvc_filebuf.hpp internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef __MSVC_FILEBUF_HPP
+#define __MSVC_FILEBUF_HPP
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <cstdio>
+#include <streambuf>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, ABI: The _Path_ish functions accepting filesystem::path or experimental::filesystem::path are templates
+// which always use the same types as a workaround for user code deriving from iostreams types and
+// __declspec(dllexport)ing the derived types. Adding member functions to iostreams broke the ABI of such DLLs.
+// Deriving and __declspec(dllexport)ing standard library types is not supported, but in this particular case
+// the workaround was inexpensive. The workaround will be removed in the next ABI breaking release of the
+// Visual C++ Libraries.
+_STD_BEGIN
+#if _HAS_CXX17
+namespace filesystem {
+    _EXPORT_STD class path;
+}
+#endif // _HAS_CXX17
+
+#ifndef _FSTREAM_SUPPORTS_EXPERIMENTAL_FILESYSTEM
+#ifdef _M_CEE
+#define _FSTREAM_SUPPORTS_EXPERIMENTAL_FILESYSTEM 0
+#else // ^^^ defined(_M_CEE) / !defined(_M_CEE) vvv
+#define _FSTREAM_SUPPORTS_EXPERIMENTAL_FILESYSTEM 1
+#endif // ^^^ !defined(_M_CEE) ^^^
+#endif // _FSTREAM_SUPPORTS_EXPERIMENTAL_FILESYSTEM
+
+#if _FSTREAM_SUPPORTS_EXPERIMENTAL_FILESYSTEM
+namespace experimental {
+    namespace filesystem {
+        inline namespace v1 {
+            class path;
+        }
+    } // namespace filesystem
+} // namespace experimental
+#endif // _FSTREAM_SUPPORTS_EXPERIMENTAL_FILESYSTEM
+
+// clang-format off
+template <class _Ty>
+constexpr bool _Is_any_path = _Is_any_of_v<_Ty
+#if _FSTREAM_SUPPORTS_EXPERIMENTAL_FILESYSTEM
+    , experimental::filesystem::path
+#endif // _FSTREAM_SUPPORTS_EXPERIMENTAL_FILESYSTEM
+#if _HAS_CXX17
+    , filesystem::path
+#endif // _HAS_CXX17
+    >;
+// clang-format on
+
+extern "C++" _CRTIMP2_PURE FILE* __CLRCALL_PURE_OR_CDECL _Fiopen(const char*, ios_base::openmode, int);
+extern "C++" _CRTIMP2_PURE FILE* __CLRCALL_PURE_OR_CDECL _Fiopen(const wchar_t*, ios_base::openmode, int);
+
+template <class _Elem>
+bool _Fgetc(_Elem& _Ch, FILE* _File) { // get an element from a C stream
+    return _CSTD fread(&_Ch, sizeof(_Elem), 1, _File) == 1;
+}
+
+template <>
+inline bool _Fgetc(char& _Byte, FILE* _File) { // get a char element from a C stream
+    int _Meta;
+    if ((_Meta = _CSTD fgetc(_File)) == EOF) {
+        return false;
+    } else { // got one, convert to char
+        _Byte = static_cast<char>(_Meta);
+        return true;
+    }
+}
+
+template <>
+inline bool _Fgetc(wchar_t& _Wchar, FILE* _File) { // get a wchar_t element from a C stream
+    wint_t _Meta;
+    if ((_Meta = _CSTD fgetwc(_File)) == WEOF) {
+        return false;
+    } else { // got one, convert to wchar_t
+        _Wchar = static_cast<wchar_t>(_Meta);
+        return true;
+    }
+}
+
+#ifdef _CRTBLD
+template <>
+inline bool _Fgetc(unsigned short& _Wchar, FILE* _File) { // get an unsigned short element from a C stream
+    wint_t _Meta;
+    if ((_Meta = _CSTD fgetwc(_File)) == WEOF) {
+        return false;
+    } else { // got one, convert to unsigned short
+        _Wchar = static_cast<unsigned short>(_Meta);
+        return true;
+    }
+}
+#endif // defined(_CRTBLD)
+
+template <class _Elem>
+bool _Fputc(_Elem _Ch, FILE* _File) { // put an element to a C stream
+    return _CSTD fwrite(&_Ch, 1, sizeof(_Elem), _File) == sizeof(_Elem);
+}
+
+template <>
+inline bool _Fputc(char _Byte, FILE* _File) { // put a char element to a C stream
+    return _CSTD fputc(_Byte, _File) != EOF;
+}
+
+template <>
+inline bool _Fputc(wchar_t _Wchar, FILE* _File) { // put a wchar_t element to a C stream
+    return _CSTD fputwc(_Wchar, _File) != WEOF;
+}
+
+#ifdef _CRTBLD
+template <>
+inline bool _Fputc(unsigned short _Wchar, FILE* _File) { // put an unsigned short element to a C stream
+    return _CSTD fputwc(_Wchar, _File) != WEOF;
+}
+#endif // defined(_CRTBLD)
+
+template <class _Elem>
+bool _Ungetc(const _Elem&, FILE*) { // put back an arbitrary element to a C stream (always fail)
+    return false;
+}
+
+template <>
+inline bool _Ungetc(const char& _Byte, FILE* _File) { // put back a char element to a C stream
+    return _CSTD ungetc(static_cast<unsigned char>(_Byte), _File) != EOF;
+}
+
+template <>
+inline bool _Ungetc(const signed char& _Byte, FILE* _File) { // put back a signed char element to a C stream
+    return _CSTD ungetc(static_cast<unsigned char>(_Byte), _File) != EOF;
+}
+
+template <>
+inline bool _Ungetc(const unsigned char& _Byte, FILE* _File) { // put back an unsigned char element to a C stream
+    return _CSTD ungetc(_Byte, _File) != EOF;
+}
+
+template <>
+inline bool _Ungetc(const wchar_t& _Wchar, FILE* _File) { // put back a wchar_t element to a C stream
+    return _CSTD ungetwc(_Wchar, _File) != WEOF;
+}
+
+#ifdef _CRTBLD
+template <>
+inline bool _Ungetc(const unsigned short& _Wchar, FILE* _File) { // put back an unsigned short element to a C stream
+    return _CSTD ungetwc(_Wchar, _File) != WEOF;
+}
+#endif // defined(_CRTBLD)
+
+_EXPORT_STD template <class _Elem, class _Traits>
+class basic_filebuf : public basic_streambuf<_Elem, _Traits> { // stream buffer associated with a C stream
+public:
+    using _Mysb = basic_streambuf<_Elem, _Traits>;
+    using _Cvt  = codecvt<_Elem, char, typename _Traits::state_type>;
+
+    basic_filebuf() : _Mysb() {
+        _Init(nullptr, _Newfl);
+    }
+
+    explicit basic_filebuf(FILE* const _File) : _Mysb() { // extension
+        _Init(_File, _Newfl);
+    }
+
+    __CLR_OR_THIS_CALL ~basic_filebuf() noexcept override {
+        if (_Myfile) {
+            _Reset_back(); // revert from _Mychar buffer
+        }
+
+        if (_Closef) {
+            close();
+        }
+    }
+
+    using int_type = typename _Traits::int_type;
+    using pos_type = typename _Traits::pos_type;
+    using off_type = typename _Traits::off_type;
+
+    basic_filebuf(_Uninitialized) noexcept : _Mysb(_Noinit) {}
+
+    basic_filebuf(basic_filebuf&& _Right) {
+        _Init(_Right._Myfile, _Newfl); // match buffering styles
+        _Init(static_cast<FILE*>(nullptr), _Closefl); // then make *this look closed
+        _Assign_rv(_STD move(_Right));
+    }
+
+    basic_filebuf& operator=(basic_filebuf&& _Right) {
+        _Assign_rv(_STD move(_Right));
+        return *this;
+    }
+
+    void _Assign_rv(basic_filebuf&& _Right) {
+        if (this != _STD addressof(_Right)) {
+            close();
+            this->swap(_Right);
+        }
+    }
+
+    void swap(basic_filebuf& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            FILE* _Myfile_sav                       = _Myfile;
+            const _Cvt* _Pcvt_sav                   = _Pcvt;
+            typename _Traits::state_type _State_sav = _State;
+            bool _Wrotesome_sav                     = _Wrotesome;
+            bool _Closef_sav                        = _Closef;
+            bool _Set_eback_sav                     = _Mysb::eback() == &_Mychar;
+            bool _Set_eback_live                    = _Mysb::gptr() == &_Mychar;
+
+            _Elem* _Pfirst0 = _Mysb::pbase();
+            _Elem* _Pnext0  = _Mysb::pptr();
+            _Elem* _Pend    = _Mysb::epptr();
+            _Elem* _Gfirst0 = _Mysb::eback();
+            _Elem* _Gnext0  = _Mysb::gptr();
+            _Elem* _Gend    = _Mysb::egptr();
+
+            // reinitialize *this
+            _Init(_Right._Myfile, _Right._Myfile ? _Openfl : _Newfl);
+            _Mysb::setp(_Right.pbase(), _Right.pptr(), _Right.epptr());
+            if (_Right.eback() != &_Right._Mychar) {
+                _Mysb::setg(_Right.eback(), _Right.gptr(), _Right.egptr());
+            } else if (_Right.gptr() != &_Right._Mychar) {
+                _Mysb::setg(&_Mychar, &_Mychar + 1, &_Mychar + 1);
+            } else {
+                _Mysb::setg(&_Mychar, &_Mychar, &_Mychar + 1);
+            }
+
+            _Pcvt      = _Right._Pcvt;
+            _State     = _Right._State;
+            _Wrotesome = _Right._Wrotesome;
+            _Closef    = _Right._Closef;
+
+            // reinitialize _Right
+            _Right._Init(_Myfile_sav, _Myfile_sav ? _Openfl : _Newfl);
+            _Right.setp(_Pfirst0, _Pnext0, _Pend);
+            if (!_Set_eback_sav) {
+                _Right.setg(_Gfirst0, _Gnext0, _Gend);
+            } else if (!_Set_eback_live) {
+                _Right.setg(&_Right._Mychar, &_Right._Mychar + 1, &_Right._Mychar + 1);
+            } else {
+                _Right.setg(&_Right._Mychar, &_Right._Mychar, &_Right._Mychar + 1);
+            }
+
+            _Right._Pcvt      = _Pcvt_sav;
+            _Right._State     = _State_sav;
+            _Right._Wrotesome = _Wrotesome_sav;
+            _Right._Closef    = _Closef_sav;
+
+            // swap ancillary data
+            _STD swap(_Set_eback, _Right._Set_eback);
+            _STD swap(_Set_egptr, _Right._Set_egptr);
+
+            _STD swap(_Mychar, _Right._Mychar);
+            _STD swap(_Mysb::_Plocale, _Right._Plocale);
+        }
+    }
+
+    basic_filebuf(const basic_filebuf&)            = delete;
+    basic_filebuf& operator=(const basic_filebuf&) = delete;
+
+    enum _Initfl { // reasons for a call to _Init
+        _Newfl,
+        _Openfl,
+        _Closefl
+    };
+
+    _NODISCARD bool is_open() const noexcept /* strengthened */ {
+        return static_cast<bool>(_Myfile);
+    }
+
+    basic_filebuf* open(const char* _Filename, ios_base::openmode _Mode, int _Prot = ios_base::_Default_open_prot) {
+        // _Prot is an extension
+        if (_Myfile) {
+            return nullptr;
+        }
+
+        const auto _File = _Fiopen(_Filename, _Mode, _Prot);
+        if (!_File) {
+            return nullptr; // open failed
+        }
+
+        _Init(_File, _Openfl);
+        _Initcvt(_STD use_facet<_Cvt>(_Mysb::getloc()));
+        return this; // open succeeded
+    }
+
+    basic_filebuf* open(const string& _Str, ios_base::openmode _Mode, int _Prot = ios_base::_Default_open_prot) {
+        // _Prot is an extension
+        return open(_Str.c_str(), _Mode, _Prot);
+    }
+
+#if _HAS_OLD_IOSTREAMS_MEMBERS
+    basic_filebuf* open(const char* _Filename, ios_base::open_mode _Mode) {
+        return open(_Filename, static_cast<ios_base::openmode>(_Mode));
+    }
+#endif // _HAS_OLD_IOSTREAMS_MEMBERS
+
+    basic_filebuf* open(const wchar_t* _Filename, ios_base::openmode _Mode, int _Prot = ios_base::_Default_open_prot) {
+        // in standard as const std::filesystem::path::value_type *; _Prot is an extension
+        if (_Myfile) {
+            return nullptr;
+        }
+
+        const auto _File = _Fiopen(_Filename, _Mode, _Prot);
+        if (!_File) {
+            return nullptr; // open failed
+        }
+
+        _Init(_File, _Openfl);
+        _Initcvt(_STD use_facet<_Cvt>(_Mysb::getloc()));
+        return this; // open succeeded
+    }
+
+    basic_filebuf* open(const wstring& _Str, ios_base::openmode _Mode, int _Prot = ios_base::_Default_open_prot) {
+        // extension
+        return open(_Str.c_str(), _Mode, _Prot);
+    }
+
+#if _FSTREAM_SUPPORTS_EXPERIMENTAL_FILESYSTEM
+    template <class _Path_ish = experimental::filesystem::path>
+    basic_filebuf* open(
+        const _Identity_t<_Path_ish>& _Path, ios_base::openmode _Mode, int _Prot = ios_base::_Default_open_prot) {
+        // _Prot is an extension
+        return open(_Path.c_str(), _Mode, _Prot);
+    }
+#endif // _FSTREAM_SUPPORTS_EXPERIMENTAL_FILESYSTEM
+
+#if _HAS_CXX17
+    template <int = 0, class _Path_ish = filesystem::path>
+    basic_filebuf* open(
+        const _Identity_t<_Path_ish>& _Path, ios_base::openmode _Mode, int _Prot = ios_base::_Default_open_prot) {
+        // _Prot is an extension
+        return open(_Path.c_str(), _Mode, _Prot);
+    }
+#endif // _HAS_CXX17
+
+#if _HAS_OLD_IOSTREAMS_MEMBERS
+    basic_filebuf* open(const wchar_t* _Filename, ios_base::open_mode _Mode) {
+        // in standard as const std::filesystem::path::value_type *
+        return open(_Filename, static_cast<ios_base::openmode>(_Mode));
+    }
+#endif // _HAS_OLD_IOSTREAMS_MEMBERS
+
+    basic_filebuf* close() {
+        basic_filebuf* _Ans;
+        if (_Myfile) { // put any homing sequence and close file
+            _Reset_back(); // revert from _Mychar buffer
+
+            _Ans = this;
+            if (!_Endwrite()) {
+                _Ans = nullptr;
+            }
+
+            if (_CSTD fclose(_Myfile) != 0) {
+                _Ans = nullptr;
+            }
+        } else {
+            _Ans = nullptr;
+        }
+
+        _Init(nullptr, _Closefl);
+        return _Ans;
+    }
+
+    void __CLR_OR_THIS_CALL _Lock() override { // lock file instead of stream buffer
+        if (_Myfile) {
+            _CSTD _lock_file(_Myfile);
+        }
+    }
+
+    void __CLR_OR_THIS_CALL _Unlock() override { // unlock file instead of stream buffer
+        if (_Myfile) {
+            _CSTD _unlock_file(_Myfile);
+        }
+    }
+
+#if _HAS_CXX23 && defined(_CPPRTTI)
+    template <class _Filebuf_type>
+    friend ios_base::iostate _Print_noformat_unicode(ostream&, string_view);
+#endif
+
+protected:
+    int_type __CLR_OR_THIS_CALL overflow(int_type _Meta = _Traits::eof()) override { // put an element to stream
+        if (_Traits::eq_int_type(_Traits::eof(), _Meta)) {
+            return _Traits::not_eof(_Meta); // EOF, return success code
+        }
+
+        if (_Mysb::pptr() && _Mysb::pptr() < _Mysb::epptr()) { // room in buffer, store it
+            *_Mysb::_Pninc() = _Traits::to_char_type(_Meta);
+            return _Meta;
+        }
+
+        if (!_Myfile) {
+            return _Traits::eof(); // no open C stream, fail
+        }
+
+        _Reset_back(); // revert from _Mychar buffer
+        if (!_Pcvt) { // no codecvt facet, put as is
+            return _Fputc(_Traits::to_char_type(_Meta), _Myfile) ? _Meta : _Traits::eof();
+        }
+
+        // put using codecvt facet
+        constexpr size_t _Codecvt_temp_buf = 32;
+        char _Str[_Codecvt_temp_buf];
+        const _Elem _Ch = _Traits::to_char_type(_Meta);
+        const _Elem* _Src;
+        char* _Dest;
+
+        // test result of converting one element
+        switch (_Pcvt->out(_State, &_Ch, &_Ch + 1, _Src, _Str, _Str + _Codecvt_temp_buf, _Dest)) {
+        case codecvt_base::partial:
+        case codecvt_base::ok:
+            { // converted something, try to put it out
+                const auto _Count = static_cast<size_t>(_Dest - _Str);
+                if (0 < _Count && _Count != static_cast<size_t>(_CSTD fwrite(_Str, 1, _Count, _Myfile))) {
+                    return _Traits::eof(); // write failed
+                }
+
+                _Wrotesome = true; // write succeeded
+                if (_Src != &_Ch) {
+                    return _Meta; // converted whole element
+                }
+
+                return _Traits::eof(); // conversion failed
+            }
+
+        case codecvt_base::noconv:
+            // no conversion, put as is
+            return _Fputc(_Ch, _Myfile) ? _Meta : _Traits::eof();
+
+        default:
+            return _Traits::eof(); // conversion failed
+        }
+    }
+
+    int_type __CLR_OR_THIS_CALL pbackfail(int_type _Meta = _Traits::eof()) override {
+        // put an element back to stream
+        if (_Mysb::gptr() && _Mysb::eback() < _Mysb::gptr()
+            && (_Traits::eq_int_type(_Traits::eof(), _Meta)
+                || _Traits::eq_int_type(_Traits::to_int_type(_Mysb::gptr()[-1]),
+                    _Meta))) { // just back up position
+            _Mysb::_Gndec();
+            return _Traits::not_eof(_Meta);
+        } else if (!_Myfile || _Traits::eq_int_type(_Traits::eof(), _Meta)) {
+            return _Traits::eof(); // no open C stream or EOF, fail
+        } else if (!_Pcvt && _Ungetc(_Traits::to_char_type(_Meta), _Myfile)) {
+            return _Meta; // no facet and unget succeeded, return
+        } else if (_Mysb::gptr() != &_Mychar) { // putback to _Mychar
+            _Mychar = _Traits::to_char_type(_Meta);
+            _Set_back(); // switch to _Mychar buffer
+            return _Meta;
+        } else {
+            return _Traits::eof(); // nowhere to put back
+        }
+    }
+
+    int_type __CLR_OR_THIS_CALL underflow() override { // get an element from stream, but don't point past it
+        int_type _Meta;
+        if (_Mysb::gptr() && _Mysb::gptr() < _Mysb::egptr()) {
+            return _Traits::to_int_type(*_Mysb::gptr()); // return buffered
+        } else if (_Traits::eq_int_type(_Traits::eof(), _Meta = uflow())) {
+            return _Meta; // uflow failed, return EOF
+        } else { // get a char, don't point past it
+            pbackfail(_Meta);
+            return _Meta;
+        }
+    }
+
+    int_type __CLR_OR_THIS_CALL uflow() override { // get an element from stream, point past it
+        if (_Mysb::gptr() && _Mysb::gptr() < _Mysb::egptr()) {
+            return _Traits::to_int_type(*_Mysb::_Gninc()); // return buffered
+        }
+
+        if (!_Myfile) {
+            return _Traits::eof(); // no open C stream, fail
+        }
+
+        _Reset_back(); // revert from _Mychar buffer
+        if (!_Pcvt) { // no codecvt facet, just get it
+            _Elem _Ch;
+            return _Fgetc(_Ch, _Myfile) ? _Traits::to_int_type(_Ch) : _Traits::eof();
+        }
+
+        // build string until codecvt succeeds
+        string _Str;
+
+        for (;;) { // get using codecvt facet
+            const char* _Src;
+            int _Meta = _CSTD fgetc(_Myfile);
+
+            if (_Meta == EOF) {
+                return _Traits::eof(); // partial char?
+            }
+
+            _Str.push_back(static_cast<char>(_Meta)); // append byte and convert
+
+            _Elem _Ch;
+            _Elem* _Dest;
+
+            // test result of converting one element
+            switch (_Pcvt->in(_State, _Str.data(), _Str.data() + _Str.size(), _Src, &_Ch, &_Ch + 1, _Dest)) {
+            case codecvt_base::partial:
+            case codecvt_base::ok:
+                if (_Dest != &_Ch) { // got an element, put back excess and deliver it
+                    auto _Nleft = _Str.data() + _Str.size() - _Src;
+                    while (0 < _Nleft) {
+                        _CSTD ungetc(_Src[--_Nleft], _Myfile);
+                    }
+
+                    return _Traits::to_int_type(_Ch);
+                }
+
+                _Str.erase(0, static_cast<size_t>(_Src - _Str.data())); // partial, discard used input
+                break;
+
+            case codecvt_base::noconv:
+                // noconv is only possible if _Elem is char, so we can use it directly
+                return static_cast<int_type>(_Str.front());
+
+            default:
+                return _Traits::eof(); // conversion failed
+            }
+        }
+    }
+
+    streamsize __CLR_OR_THIS_CALL xsgetn(_Elem* _Ptr, streamsize _Count) override {
+        // get _Count characters from stream
+        if constexpr (sizeof(_Elem) == 1) {
+            if (_Count <= 0) {
+                return 0;
+            }
+
+            if (_Pcvt) { // if we need a nontrivial codecvt transform, do the default expensive thing
+                return _Mysb::xsgetn(_Ptr, _Count);
+            }
+
+            // assuming this is OK because _Ptr + _Count must be valid
+            auto _Count_s           = static_cast<size_t>(_Count);
+            const auto _Start_count = _Count;
+            const auto _Available   = static_cast<size_t>(_Mysb::_Gnavail());
+            if (0 < _Available) { // copy from get area
+                const auto _Read_size = (_STD min)(_Count_s, _Available);
+                _Traits::copy(_Ptr, _Mysb::gptr(), _Read_size);
+                _Ptr += _Read_size;
+                _Count_s -= _Read_size;
+                _Mysb::gbump(static_cast<int>(_Read_size));
+            }
+
+            if (_Myfile) { // open C stream, attempt read
+                _Reset_back(); // revert from _Mychar buffer
+                // process in 4k - 1 chunks to avoid tripping over fread's clobber-the-end behavior when
+                // doing \r\n -> \n translation
+                constexpr size_t _Read_size = 4095; // _INTERNAL_BUFSIZ - 1
+                while (_Read_size < _Count_s) {
+                    const auto _Actual_read = _CSTD fread(_Ptr, sizeof(_Elem), _Read_size, _Myfile);
+                    _Ptr += _Actual_read;
+                    _Count_s -= _Actual_read;
+                    if (_Actual_read != _Read_size) {
+                        return static_cast<streamsize>(_Start_count - _Count_s);
+                    }
+                }
+
+                if (0 < _Count_s) {
+                    _Count_s -= _CSTD fread(_Ptr, sizeof(_Elem), _Count_s, _Myfile);
+                }
+            }
+
+            return static_cast<streamsize>(_Start_count - _Count_s);
+        } else { // non-chars always get element-by-element processing
+            return _Mysb::xsgetn(_Ptr, _Count);
+        }
+    }
+
+    streamsize __CLR_OR_THIS_CALL xsputn(const _Elem* _Ptr, streamsize _Count) override {
+        // put _Count characters to stream
+        if constexpr (sizeof(_Elem) == 1) {
+            if (_Pcvt) { // if we need a nontrivial codecvt transform, do the default expensive thing
+                return _Mysb::xsputn(_Ptr, _Count);
+            }
+
+            const streamsize _Start_count = _Count;
+            streamsize _Size              = _Mysb::_Pnavail();
+            if (0 < _Count && 0 < _Size) { // copy to write buffer
+                if (_Count < _Size) {
+                    _Size = _Count;
+                }
+
+                _Traits::copy(_Mysb::pptr(), _Ptr, static_cast<size_t>(_Size));
+                _Ptr += _Size;
+                _Count -= _Size;
+                _Mysb::pbump(static_cast<int>(_Size));
+            }
+
+            if (0 < _Count && _Myfile) { // open C stream, attempt write
+                _Count -= _CSTD fwrite(_Ptr, sizeof(_Elem), static_cast<size_t>(_Count), _Myfile);
+            }
+
+            return _Start_count - _Count;
+        } else { // non-chars always get element-by-element processing
+            return _Mysb::xsputn(_Ptr, _Count);
+        }
+    }
+
+    pos_type __CLR_OR_THIS_CALL seekoff(off_type _Off, ios_base::seekdir _Way,
+        ios_base::openmode = ios_base::in | ios_base::out) override { // change position by _Off
+        fpos_t _Fileposition;
+
+        if (_Mysb::gptr() == &_Mychar // something putback
+            && _Way == ios_base::cur // a relative seek
+            && !_Pcvt) { // not converting
+            _Off -= static_cast<off_type>(sizeof(_Elem)); // back up over _Elem bytes
+        }
+
+        if (!_Myfile || !_Endwrite()
+            || ((_Off != 0 || _Way != ios_base::cur) && _CSTD _fseeki64(_Myfile, _Off, _Way) != 0)
+            || _CSTD fgetpos(_Myfile, &_Fileposition) != 0) {
+            return pos_type{off_type{-1}}; // report failure
+        }
+
+        _Reset_back(); // revert from _Mychar buffer, discarding any putback
+        return pos_type{_State, _Fileposition}; // return new position
+    }
+
+    pos_type __CLR_OR_THIS_CALL seekpos(pos_type _Pos, ios_base::openmode = ios_base::in | ios_base::out) override {
+        // change position to _Pos
+        off_type _Off = static_cast<off_type>(_Pos);
+
+        if (!_Myfile || !_Endwrite() || _CSTD fsetpos(_Myfile, &_Off) != 0) {
+            return pos_type{off_type{-1}}; // report failure
+        }
+
+        _State = _Pos.state();
+        _Reset_back(); // revert from _Mychar buffer, discarding any putback
+        return pos_type{_State, _Off}; // return new position
+    }
+
+    _Mysb* __CLR_OR_THIS_CALL setbuf(_Elem* _Buffer, streamsize _Count) override { // offer _Buffer to C stream
+        int _Mode;
+        if (!_Buffer && _Count == 0) {
+            _Mode = _IONBF;
+        } else {
+            _Mode = _IOFBF;
+        }
+
+        const size_t _Size = static_cast<size_t>(_Count) * sizeof(_Elem);
+
+        if (!_Myfile || _CSTD setvbuf(_Myfile, reinterpret_cast<char*>(_Buffer), _Mode, _Size) != 0) {
+            return nullptr; // failed
+        }
+
+        // new buffer, reinitialize pointers
+        _Init(_Myfile, _Openfl);
+        return this;
+    }
+
+    int __CLR_OR_THIS_CALL sync() override { // synchronize C stream with external file
+        if (!_Myfile || _Traits::eq_int_type(_Traits::eof(), overflow()) || 0 <= _CSTD fflush(_Myfile)) {
+            return 0;
+        }
+
+        return -1;
+    }
+
+    void __CLR_OR_THIS_CALL imbue(const locale& _Loc) override {
+        // set locale to argument (capture nontrivial codecvt facet)
+        _Initcvt(_STD use_facet<_Cvt>(_Loc));
+    }
+
+    void _Init(FILE* _File, _Initfl _Which) noexcept { // initialize to C stream _File after {new, open, close}
+        using _State_type = typename _Traits::state_type;
+
+        __PURE_APPDOMAIN_GLOBAL static _State_type _Stinit; // initial state
+
+        _Closef    = _Which == _Openfl;
+        _Wrotesome = false;
+
+        _Mysb::_Init(); // initialize stream buffer base object
+
+        if (_File && sizeof(_Elem) == 1) { // point inside C stream with [first, first + count) buffer
+            _Elem** _Pb = nullptr;
+            _Elem** _Pn = nullptr;
+            int* _Nr    = nullptr;
+
+            ::_get_stream_buffer_pointers(
+                _File, reinterpret_cast<char***>(&_Pb), reinterpret_cast<char***>(&_Pn), &_Nr);
+            int* _Nw = _Nr;
+
+            _Mysb::_Init(_Pb, _Pn, _Nr, _Pb, _Pn, _Nw);
+        }
+
+        _Myfile = _File;
+        _State  = _Stinit;
+        _Pcvt   = nullptr; // pointer to codecvt facet
+    }
+
+    bool _Endwrite() { // put shift to initial conversion state, as needed
+        if (!_Pcvt || !_Wrotesome) {
+            return true;
+        }
+
+        // may have to put
+        if (_Traits::eq_int_type(_Traits::eof(), overflow())) {
+            return false;
+        }
+
+        constexpr size_t _Codecvt_temp_buf = 32;
+        char _Str[_Codecvt_temp_buf];
+        char* _Dest;
+        switch (_Pcvt->unshift(_State, _Str, _Str + _Codecvt_temp_buf, _Dest)) { // test result of homing conversion
+        case codecvt_base::ok:
+            _Wrotesome = false; // homed successfully
+            _FALLTHROUGH;
+
+        case codecvt_base::partial:
+            { // put any generated bytes
+                const auto _Count = static_cast<size_t>(_Dest - _Str);
+                if (0 < _Count && _Count != static_cast<size_t>(_CSTD fwrite(_Str, 1, _Count, _Myfile))) {
+                    return false; // write failed
+                }
+
+                return !_Wrotesome;
+            }
+
+        case codecvt_base::noconv:
+            _Wrotesome = false; // homed successfully
+            return true; // nothing else to do
+
+        default:
+            return false; // conversion failed
+        }
+    }
+
+    void _Initcvt(const _Cvt& _Newcvt) noexcept { // initialize codecvt pointer
+        if (_Newcvt.always_noconv()) {
+            _Pcvt = nullptr; // nothing to do
+        } else { // set up for nontrivial codecvt facet
+            _Pcvt = _STD addressof(_Newcvt);
+            _Mysb::_Init(); // reset any buffering
+        }
+    }
+
+private:
+    const _Cvt* _Pcvt; // pointer to codecvt facet (may be null)
+    _Elem _Mychar; // putback character, when _Ungetc fails
+    bool _Wrotesome; // true if homing sequence may be needed
+    typename _Traits::state_type _State; // current conversion state
+    bool _Closef; // true if C stream must be closed
+    FILE* _Myfile; // pointer to C stream
+
+    void _Reset_back() noexcept { // restore buffer after putback
+        if (_Mysb::eback() == &_Mychar) {
+            _Mysb::setg(_Set_eback, _Set_eback, _Set_egptr);
+        }
+    }
+
+    void _Set_back() noexcept { // set up putback area
+        if (_Mysb::eback() != &_Mychar) { // save current get buffer
+            _Set_eback = _Mysb::eback();
+            _Set_egptr = _Mysb::egptr();
+        }
+        _Mysb::setg(&_Mychar, &_Mychar, &_Mychar + 1);
+    }
+
+    _Elem* _Set_eback; // saves eback() during one-element putback
+    _Elem* _Set_egptr; // saves egptr()
+};
+
+_EXPORT_STD template <class _Elem, class _Traits>
+void swap(basic_filebuf<_Elem, _Traits>& _Left, basic_filebuf<_Elem, _Traits>& _Right) noexcept /* strengthened */ {
+    _Left.swap(_Right);
+}
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // __MSVC_FILEBUF_HPP

miniMSVC/VC/Tools/MSVC/14.42.34433/include/__msvc_format_ucd_tables.hpp

@@ -0,0 +1,551 @@
+// __msvc_format_ucd_tables.hpp internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// WARNING, this entire header is generated by
+// tools/unicode_properties_parse/unicode_properties_data_gen.py
+// DO NOT MODIFY!
+
+// UNICODE, INC. LICENSE AGREEMENT - DATA FILES AND SOFTWARE
+//
+// See Terms of Use <https://www.unicode.org/copyright.html>
+// for definitions of Unicode Inc.'s Data Files and Software.
+//
+// NOTICE TO USER: Carefully read the following legal agreement.
+// BY DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING UNICODE INC.'S
+// DATA FILES ("DATA FILES"), AND/OR SOFTWARE ("SOFTWARE"),
+// YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
+// TERMS AND CONDITIONS OF THIS AGREEMENT.
+// IF YOU DO NOT AGREE, DO NOT DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE
+// THE DATA FILES OR SOFTWARE.
+//
+// COPYRIGHT AND PERMISSION NOTICE
+//
+// Copyright (c) 1991-2022 Unicode, Inc. All rights reserved.
+// Distributed under the Terms of Use in https://www.unicode.org/copyright.html.
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of the Unicode data files and any associated documentation
+// (the "Data Files") or Unicode software and any associated documentation
+// (the "Software") to deal in the Data Files or Software
+// without restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, and/or sell copies of
+// the Data Files or Software, and to permit persons to whom the Data Files
+// or Software are furnished to do so, provided that either
+// (a) this copyright and permission notice appear with all copies
+// of the Data Files or Software, or
+// (b) this copyright and permission notice appear in associated
+// Documentation.
+//
+// THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF
+// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+// WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT OF THIRD PARTY RIGHTS.
+// IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS
+// NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL
+// DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+// DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THE DATA FILES OR SOFTWARE.
+//
+// Except as contained in this notice, the name of a copyright holder
+// shall not be used in advertising or otherwise to promote the sale,
+// use or other dealings in these Data Files or Software without prior
+// written authorization of the copyright holder.
+
+#ifndef __MSVC_FORMAT_UCD_TABLES_HPP
+#define __MSVC_FORMAT_UCD_TABLES_HPP
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <cstdint>
+#include <xutility>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+template <class _ValueEnum, size_t _NumRanges, bool _Is_binary_property>
+struct _Unicode_property_data {
+    uint32_t _Lower_bounds[_NumRanges];
+    uint16_t _Props_and_size[_NumRanges];
+    _NODISCARD constexpr _ValueEnum _Get_property_for_codepoint(const uint32_t _Code_point) const noexcept {
+        ptrdiff_t _Upper_idx = _STD upper_bound(_Lower_bounds, _STD end(_Lower_bounds), _Code_point) - _Lower_bounds;
+        constexpr auto _No_value_constant = static_cast<_ValueEnum>(UINT8_MAX);
+        if (_Upper_idx == 0) {
+            return _No_value_constant;
+        }
+        --_Upper_idx;
+        const uint32_t _Lower_bound = _Lower_bounds[_Upper_idx];
+        const uint16_t _Data        = _Props_and_size[_Upper_idx];
+        _STL_INTERNAL_CHECK(_Code_point >= _Lower_bound);
+        if constexpr (_Is_binary_property) {
+            if (_Code_point < _Lower_bound + _Data) {
+                return static_cast<_ValueEnum>(0);
+            }
+        } else {
+            const uint16_t _Size   = static_cast<uint16_t>(_Data & 0x0FFF);
+            const _ValueEnum _Prop = static_cast<_ValueEnum>((_Data & 0xF000) >> 12);
+            if (_Code_point < _Lower_bound + _Size) {
+                return _Prop;
+            }
+        }
+        return _No_value_constant;
+    }
+};
+
+// The following static data tables are generated from the Unicode character database.
+// _Grapheme_Break_property_data comes from ucd/auxiliary/GraphemeBreakProperty.txt.
+//
+// _Extended_Pictographic_property_data comes from ucd/emoji/emoji-data.txt.
+//
+// __printable_property_data comes from ucd/extracted/DerivedGeneralCategory.txt.
+//
+// _Grapheme_Extend_property_data comes from ucd/DerivedCoreProperties.txt.
+//
+// The enums containing the values for the properties are also generated, in order to ensure they match
+// up correctly with how we're parsing them.
+//
+// All sets of data tables are generated by tools/unicode_properties_parse/unicode_properties_data_gen.py in the
+// https://github.com/microsoft/stl repository.
+//
+// The data format is a set of arrays for each character property. The first is an array of uint32_t encoding
+// the lower bound of each range of codepoints that has the given property.
+// The second is an array of uint16_t.
+// - For enumerated properties, this array encodes both the range size and property value as follows:
+//   16               12                                   0
+//   +-----------------------------------------------------+
+//   | property_value  |              range_size           |
+//   +-----------------------------------------------------+
+//   that is: the size is stored in the least significant 12 bits
+//   (leading to a max size of 4095), and the property value is stored in the most significant 4 bits,
+//   leading to a maximum of 16 property values.
+// - For binary properties, this array simply stores the range size.
+//
+// Codepoint ranges may not overlap, and, within one property, a codepoint may only appear once. Furthermore the
+// codepoint lower bounds appear in sorted (ascending) order.
+
+// GraphemeBreakProperty-15.0.0.txt
+// Date: 2022-04-27, 17:07:38 GMT
+enum class _Grapheme_Break_property_values : uint8_t {
+    _CR_value,
+    _Control_value,
+    _Extend_value,
+    _L_value,
+    _LF_value,
+    _LV_value,
+    _LVT_value,
+    _Prepend_value,
+    _Regional_Indicator_value,
+    _SpacingMark_value,
+    _T_value,
+    _V_value,
+    _ZWJ_value,
+    _No_value = 255
+};
+
+// GraphemeBreakProperty-15.0.0.txt
+// Date: 2022-04-27, 17:07:38 GMT
+inline constexpr _Unicode_property_data<_Grapheme_Break_property_values, 1371, false> _Grapheme_Break_property_data{
+    {0x0, 0xa, 0xb, 0xd, 0xe, 0x7f, 0xad, 0x300, 0x483, 0x591, 0x5bf, 0x5c1, 0x5c4, 0x5c7, 0x600, 0x610, 0x61c, 0x64b,
+        0x670, 0x6d6, 0x6dd, 0x6df, 0x6e7, 0x6ea, 0x70f, 0x711, 0x730, 0x7a6, 0x7eb, 0x7fd, 0x816, 0x81b, 0x825, 0x829,
+        0x859, 0x890, 0x898, 0x8ca, 0x8e2, 0x8e3, 0x903, 0x93a, 0x93b, 0x93c, 0x93e, 0x941, 0x949, 0x94d, 0x94e, 0x951,
+        0x962, 0x981, 0x982, 0x9bc, 0x9be, 0x9bf, 0x9c1, 0x9c7, 0x9cb, 0x9cd, 0x9d7, 0x9e2, 0x9fe, 0xa01, 0xa03, 0xa3c,
+        0xa3e, 0xa41, 0xa47, 0xa4b, 0xa51, 0xa70, 0xa75, 0xa81, 0xa83, 0xabc, 0xabe, 0xac1, 0xac7, 0xac9, 0xacb, 0xacd,
+        0xae2, 0xafa, 0xb01, 0xb02, 0xb3c, 0xb3e, 0xb40, 0xb41, 0xb47, 0xb4b, 0xb4d, 0xb55, 0xb62, 0xb82, 0xbbe, 0xbbf,
+        0xbc0, 0xbc1, 0xbc6, 0xbca, 0xbcd, 0xbd7, 0xc00, 0xc01, 0xc04, 0xc3c, 0xc3e, 0xc41, 0xc46, 0xc4a, 0xc55, 0xc62,
+        0xc81, 0xc82, 0xcbc, 0xcbe, 0xcbf, 0xcc0, 0xcc2, 0xcc3, 0xcc6, 0xcc7, 0xcca, 0xccc, 0xcd5, 0xce2, 0xcf3, 0xd00,
+        0xd02, 0xd3b, 0xd3e, 0xd3f, 0xd41, 0xd46, 0xd4a, 0xd4d, 0xd4e, 0xd57, 0xd62, 0xd81, 0xd82, 0xdca, 0xdcf, 0xdd0,
+        0xdd2, 0xdd6, 0xdd8, 0xddf, 0xdf2, 0xe31, 0xe33, 0xe34, 0xe47, 0xeb1, 0xeb3, 0xeb4, 0xec8, 0xf18, 0xf35, 0xf37,
+        0xf39, 0xf3e, 0xf71, 0xf7f, 0xf80, 0xf86, 0xf8d, 0xf99, 0xfc6, 0x102d, 0x1031, 0x1032, 0x1039, 0x103b, 0x103d,
+        0x1056, 0x1058, 0x105e, 0x1071, 0x1082, 0x1084, 0x1085, 0x108d, 0x109d, 0x1100, 0x1160, 0x11a8, 0x135d, 0x1712,
+        0x1715, 0x1732, 0x1734, 0x1752, 0x1772, 0x17b4, 0x17b6, 0x17b7, 0x17be, 0x17c6, 0x17c7, 0x17c9, 0x17dd, 0x180b,
+        0x180e, 0x180f, 0x1885, 0x18a9, 0x1920, 0x1923, 0x1927, 0x1929, 0x1930, 0x1932, 0x1933, 0x1939, 0x1a17, 0x1a19,
+        0x1a1b, 0x1a55, 0x1a56, 0x1a57, 0x1a58, 0x1a60, 0x1a62, 0x1a65, 0x1a6d, 0x1a73, 0x1a7f, 0x1ab0, 0x1b00, 0x1b04,
+        0x1b34, 0x1b3b, 0x1b3c, 0x1b3d, 0x1b42, 0x1b43, 0x1b6b, 0x1b80, 0x1b82, 0x1ba1, 0x1ba2, 0x1ba6, 0x1ba8, 0x1baa,
+        0x1bab, 0x1be6, 0x1be7, 0x1be8, 0x1bea, 0x1bed, 0x1bee, 0x1bef, 0x1bf2, 0x1c24, 0x1c2c, 0x1c34, 0x1c36, 0x1cd0,
+        0x1cd4, 0x1ce1, 0x1ce2, 0x1ced, 0x1cf4, 0x1cf7, 0x1cf8, 0x1dc0, 0x200b, 0x200c, 0x200d, 0x200e, 0x2028, 0x2060,
+        0x20d0, 0x2cef, 0x2d7f, 0x2de0, 0x302a, 0x3099, 0xa66f, 0xa674, 0xa69e, 0xa6f0, 0xa802, 0xa806, 0xa80b, 0xa823,
+        0xa825, 0xa827, 0xa82c, 0xa880, 0xa8b4, 0xa8c4, 0xa8e0, 0xa8ff, 0xa926, 0xa947, 0xa952, 0xa960, 0xa980, 0xa983,
+        0xa9b3, 0xa9b4, 0xa9b6, 0xa9ba, 0xa9bc, 0xa9be, 0xa9e5, 0xaa29, 0xaa2f, 0xaa31, 0xaa33, 0xaa35, 0xaa43, 0xaa4c,
+        0xaa4d, 0xaa7c, 0xaab0, 0xaab2, 0xaab7, 0xaabe, 0xaac1, 0xaaeb, 0xaaec, 0xaaee, 0xaaf5, 0xaaf6, 0xabe3, 0xabe5,
+        0xabe6, 0xabe8, 0xabe9, 0xabec, 0xabed, 0xac00, 0xac01, 0xac1c, 0xac1d, 0xac38, 0xac39, 0xac54, 0xac55, 0xac70,
+        0xac71, 0xac8c, 0xac8d, 0xaca8, 0xaca9, 0xacc4, 0xacc5, 0xace0, 0xace1, 0xacfc, 0xacfd, 0xad18, 0xad19, 0xad34,
+        0xad35, 0xad50, 0xad51, 0xad6c, 0xad6d, 0xad88, 0xad89, 0xada4, 0xada5, 0xadc0, 0xadc1, 0xaddc, 0xaddd, 0xadf8,
+        0xadf9, 0xae14, 0xae15, 0xae30, 0xae31, 0xae4c, 0xae4d, 0xae68, 0xae69, 0xae84, 0xae85, 0xaea0, 0xaea1, 0xaebc,
+        0xaebd, 0xaed8, 0xaed9, 0xaef4, 0xaef5, 0xaf10, 0xaf11, 0xaf2c, 0xaf2d, 0xaf48, 0xaf49, 0xaf64, 0xaf65, 0xaf80,
+        0xaf81, 0xaf9c, 0xaf9d, 0xafb8, 0xafb9, 0xafd4, 0xafd5, 0xaff0, 0xaff1, 0xb00c, 0xb00d, 0xb028, 0xb029, 0xb044,
+        0xb045, 0xb060, 0xb061, 0xb07c, 0xb07d, 0xb098, 0xb099, 0xb0b4, 0xb0b5, 0xb0d0, 0xb0d1, 0xb0ec, 0xb0ed, 0xb108,
+        0xb109, 0xb124, 0xb125, 0xb140, 0xb141, 0xb15c, 0xb15d, 0xb178, 0xb179, 0xb194, 0xb195, 0xb1b0, 0xb1b1, 0xb1cc,
+        0xb1cd, 0xb1e8, 0xb1e9, 0xb204, 0xb205, 0xb220, 0xb221, 0xb23c, 0xb23d, 0xb258, 0xb259, 0xb274, 0xb275, 0xb290,
+        0xb291, 0xb2ac, 0xb2ad, 0xb2c8, 0xb2c9, 0xb2e4, 0xb2e5, 0xb300, 0xb301, 0xb31c, 0xb31d, 0xb338, 0xb339, 0xb354,
+        0xb355, 0xb370, 0xb371, 0xb38c, 0xb38d, 0xb3a8, 0xb3a9, 0xb3c4, 0xb3c5, 0xb3e0, 0xb3e1, 0xb3fc, 0xb3fd, 0xb418,
+        0xb419, 0xb434, 0xb435, 0xb450, 0xb451, 0xb46c, 0xb46d, 0xb488, 0xb489, 0xb4a4, 0xb4a5, 0xb4c0, 0xb4c1, 0xb4dc,
+        0xb4dd, 0xb4f8, 0xb4f9, 0xb514, 0xb515, 0xb530, 0xb531, 0xb54c, 0xb54d, 0xb568, 0xb569, 0xb584, 0xb585, 0xb5a0,
+        0xb5a1, 0xb5bc, 0xb5bd, 0xb5d8, 0xb5d9, 0xb5f4, 0xb5f5, 0xb610, 0xb611, 0xb62c, 0xb62d, 0xb648, 0xb649, 0xb664,
+        0xb665, 0xb680, 0xb681, 0xb69c, 0xb69d, 0xb6b8, 0xb6b9, 0xb6d4, 0xb6d5, 0xb6f0, 0xb6f1, 0xb70c, 0xb70d, 0xb728,
+        0xb729, 0xb744, 0xb745, 0xb760, 0xb761, 0xb77c, 0xb77d, 0xb798, 0xb799, 0xb7b4, 0xb7b5, 0xb7d0, 0xb7d1, 0xb7ec,
+        0xb7ed, 0xb808, 0xb809, 0xb824, 0xb825, 0xb840, 0xb841, 0xb85c, 0xb85d, 0xb878, 0xb879, 0xb894, 0xb895, 0xb8b0,
+        0xb8b1, 0xb8cc, 0xb8cd, 0xb8e8, 0xb8e9, 0xb904, 0xb905, 0xb920, 0xb921, 0xb93c, 0xb93d, 0xb958, 0xb959, 0xb974,
+        0xb975, 0xb990, 0xb991, 0xb9ac, 0xb9ad, 0xb9c8, 0xb9c9, 0xb9e4, 0xb9e5, 0xba00, 0xba01, 0xba1c, 0xba1d, 0xba38,
+        0xba39, 0xba54, 0xba55, 0xba70, 0xba71, 0xba8c, 0xba8d, 0xbaa8, 0xbaa9, 0xbac4, 0xbac5, 0xbae0, 0xbae1, 0xbafc,
+        0xbafd, 0xbb18, 0xbb19, 0xbb34, 0xbb35, 0xbb50, 0xbb51, 0xbb6c, 0xbb6d, 0xbb88, 0xbb89, 0xbba4, 0xbba5, 0xbbc0,
+        0xbbc1, 0xbbdc, 0xbbdd, 0xbbf8, 0xbbf9, 0xbc14, 0xbc15, 0xbc30, 0xbc31, 0xbc4c, 0xbc4d, 0xbc68, 0xbc69, 0xbc84,
+        0xbc85, 0xbca0, 0xbca1, 0xbcbc, 0xbcbd, 0xbcd8, 0xbcd9, 0xbcf4, 0xbcf5, 0xbd10, 0xbd11, 0xbd2c, 0xbd2d, 0xbd48,
+        0xbd49, 0xbd64, 0xbd65, 0xbd80, 0xbd81, 0xbd9c, 0xbd9d, 0xbdb8, 0xbdb9, 0xbdd4, 0xbdd5, 0xbdf0, 0xbdf1, 0xbe0c,
+        0xbe0d, 0xbe28, 0xbe29, 0xbe44, 0xbe45, 0xbe60, 0xbe61, 0xbe7c, 0xbe7d, 0xbe98, 0xbe99, 0xbeb4, 0xbeb5, 0xbed0,
+        0xbed1, 0xbeec, 0xbeed, 0xbf08, 0xbf09, 0xbf24, 0xbf25, 0xbf40, 0xbf41, 0xbf5c, 0xbf5d, 0xbf78, 0xbf79, 0xbf94,
+        0xbf95, 0xbfb0, 0xbfb1, 0xbfcc, 0xbfcd, 0xbfe8, 0xbfe9, 0xc004, 0xc005, 0xc020, 0xc021, 0xc03c, 0xc03d, 0xc058,
+        0xc059, 0xc074, 0xc075, 0xc090, 0xc091, 0xc0ac, 0xc0ad, 0xc0c8, 0xc0c9, 0xc0e4, 0xc0e5, 0xc100, 0xc101, 0xc11c,
+        0xc11d, 0xc138, 0xc139, 0xc154, 0xc155, 0xc170, 0xc171, 0xc18c, 0xc18d, 0xc1a8, 0xc1a9, 0xc1c4, 0xc1c5, 0xc1e0,
+        0xc1e1, 0xc1fc, 0xc1fd, 0xc218, 0xc219, 0xc234, 0xc235, 0xc250, 0xc251, 0xc26c, 0xc26d, 0xc288, 0xc289, 0xc2a4,
+        0xc2a5, 0xc2c0, 0xc2c1, 0xc2dc, 0xc2dd, 0xc2f8, 0xc2f9, 0xc314, 0xc315, 0xc330, 0xc331, 0xc34c, 0xc34d, 0xc368,
+        0xc369, 0xc384, 0xc385, 0xc3a0, 0xc3a1, 0xc3bc, 0xc3bd, 0xc3d8, 0xc3d9, 0xc3f4, 0xc3f5, 0xc410, 0xc411, 0xc42c,
+        0xc42d, 0xc448, 0xc449, 0xc464, 0xc465, 0xc480, 0xc481, 0xc49c, 0xc49d, 0xc4b8, 0xc4b9, 0xc4d4, 0xc4d5, 0xc4f0,
+        0xc4f1, 0xc50c, 0xc50d, 0xc528, 0xc529, 0xc544, 0xc545, 0xc560, 0xc561, 0xc57c, 0xc57d, 0xc598, 0xc599, 0xc5b4,
+        0xc5b5, 0xc5d0, 0xc5d1, 0xc5ec, 0xc5ed, 0xc608, 0xc609, 0xc624, 0xc625, 0xc640, 0xc641, 0xc65c, 0xc65d, 0xc678,
+        0xc679, 0xc694, 0xc695, 0xc6b0, 0xc6b1, 0xc6cc, 0xc6cd, 0xc6e8, 0xc6e9, 0xc704, 0xc705, 0xc720, 0xc721, 0xc73c,
+        0xc73d, 0xc758, 0xc759, 0xc774, 0xc775, 0xc790, 0xc791, 0xc7ac, 0xc7ad, 0xc7c8, 0xc7c9, 0xc7e4, 0xc7e5, 0xc800,
+        0xc801, 0xc81c, 0xc81d, 0xc838, 0xc839, 0xc854, 0xc855, 0xc870, 0xc871, 0xc88c, 0xc88d, 0xc8a8, 0xc8a9, 0xc8c4,
+        0xc8c5, 0xc8e0, 0xc8e1, 0xc8fc, 0xc8fd, 0xc918, 0xc919, 0xc934, 0xc935, 0xc950, 0xc951, 0xc96c, 0xc96d, 0xc988,
+        0xc989, 0xc9a4, 0xc9a5, 0xc9c0, 0xc9c1, 0xc9dc, 0xc9dd, 0xc9f8, 0xc9f9, 0xca14, 0xca15, 0xca30, 0xca31, 0xca4c,
+        0xca4d, 0xca68, 0xca69, 0xca84, 0xca85, 0xcaa0, 0xcaa1, 0xcabc, 0xcabd, 0xcad8, 0xcad9, 0xcaf4, 0xcaf5, 0xcb10,
+        0xcb11, 0xcb2c, 0xcb2d, 0xcb48, 0xcb49, 0xcb64, 0xcb65, 0xcb80, 0xcb81, 0xcb9c, 0xcb9d, 0xcbb8, 0xcbb9, 0xcbd4,
+        0xcbd5, 0xcbf0, 0xcbf1, 0xcc0c, 0xcc0d, 0xcc28, 0xcc29, 0xcc44, 0xcc45, 0xcc60, 0xcc61, 0xcc7c, 0xcc7d, 0xcc98,
+        0xcc99, 0xccb4, 0xccb5, 0xccd0, 0xccd1, 0xccec, 0xcced, 0xcd08, 0xcd09, 0xcd24, 0xcd25, 0xcd40, 0xcd41, 0xcd5c,
+        0xcd5d, 0xcd78, 0xcd79, 0xcd94, 0xcd95, 0xcdb0, 0xcdb1, 0xcdcc, 0xcdcd, 0xcde8, 0xcde9, 0xce04, 0xce05, 0xce20,
+        0xce21, 0xce3c, 0xce3d, 0xce58, 0xce59, 0xce74, 0xce75, 0xce90, 0xce91, 0xceac, 0xcead, 0xcec8, 0xcec9, 0xcee4,
+        0xcee5, 0xcf00, 0xcf01, 0xcf1c, 0xcf1d, 0xcf38, 0xcf39, 0xcf54, 0xcf55, 0xcf70, 0xcf71, 0xcf8c, 0xcf8d, 0xcfa8,
+        0xcfa9, 0xcfc4, 0xcfc5, 0xcfe0, 0xcfe1, 0xcffc, 0xcffd, 0xd018, 0xd019, 0xd034, 0xd035, 0xd050, 0xd051, 0xd06c,
+        0xd06d, 0xd088, 0xd089, 0xd0a4, 0xd0a5, 0xd0c0, 0xd0c1, 0xd0dc, 0xd0dd, 0xd0f8, 0xd0f9, 0xd114, 0xd115, 0xd130,
+        0xd131, 0xd14c, 0xd14d, 0xd168, 0xd169, 0xd184, 0xd185, 0xd1a0, 0xd1a1, 0xd1bc, 0xd1bd, 0xd1d8, 0xd1d9, 0xd1f4,
+        0xd1f5, 0xd210, 0xd211, 0xd22c, 0xd22d, 0xd248, 0xd249, 0xd264, 0xd265, 0xd280, 0xd281, 0xd29c, 0xd29d, 0xd2b8,
+        0xd2b9, 0xd2d4, 0xd2d5, 0xd2f0, 0xd2f1, 0xd30c, 0xd30d, 0xd328, 0xd329, 0xd344, 0xd345, 0xd360, 0xd361, 0xd37c,
+        0xd37d, 0xd398, 0xd399, 0xd3b4, 0xd3b5, 0xd3d0, 0xd3d1, 0xd3ec, 0xd3ed, 0xd408, 0xd409, 0xd424, 0xd425, 0xd440,
+        0xd441, 0xd45c, 0xd45d, 0xd478, 0xd479, 0xd494, 0xd495, 0xd4b0, 0xd4b1, 0xd4cc, 0xd4cd, 0xd4e8, 0xd4e9, 0xd504,
+        0xd505, 0xd520, 0xd521, 0xd53c, 0xd53d, 0xd558, 0xd559, 0xd574, 0xd575, 0xd590, 0xd591, 0xd5ac, 0xd5ad, 0xd5c8,
+        0xd5c9, 0xd5e4, 0xd5e5, 0xd600, 0xd601, 0xd61c, 0xd61d, 0xd638, 0xd639, 0xd654, 0xd655, 0xd670, 0xd671, 0xd68c,
+        0xd68d, 0xd6a8, 0xd6a9, 0xd6c4, 0xd6c5, 0xd6e0, 0xd6e1, 0xd6fc, 0xd6fd, 0xd718, 0xd719, 0xd734, 0xd735, 0xd750,
+        0xd751, 0xd76c, 0xd76d, 0xd788, 0xd789, 0xd7b0, 0xd7cb, 0xfb1e, 0xfe00, 0xfe20, 0xfeff, 0xff9e, 0xfff0, 0x101fd,
+        0x102e0, 0x10376, 0x10a01, 0x10a05, 0x10a0c, 0x10a38, 0x10a3f, 0x10ae5, 0x10d24, 0x10eab, 0x10efd, 0x10f46,
+        0x10f82, 0x11000, 0x11001, 0x11002, 0x11038, 0x11070, 0x11073, 0x1107f, 0x11082, 0x110b0, 0x110b3, 0x110b7,
+        0x110b9, 0x110bd, 0x110c2, 0x110cd, 0x11100, 0x11127, 0x1112c, 0x1112d, 0x11145, 0x11173, 0x11180, 0x11182,
+        0x111b3, 0x111b6, 0x111bf, 0x111c2, 0x111c9, 0x111ce, 0x111cf, 0x1122c, 0x1122f, 0x11232, 0x11234, 0x11235,
+        0x11236, 0x1123e, 0x11241, 0x112df, 0x112e0, 0x112e3, 0x11300, 0x11302, 0x1133b, 0x1133e, 0x1133f, 0x11340,
+        0x11341, 0x11347, 0x1134b, 0x11357, 0x11362, 0x11366, 0x11370, 0x11435, 0x11438, 0x11440, 0x11442, 0x11445,
+        0x11446, 0x1145e, 0x114b0, 0x114b1, 0x114b3, 0x114b9, 0x114ba, 0x114bb, 0x114bd, 0x114be, 0x114bf, 0x114c1,
+        0x114c2, 0x115af, 0x115b0, 0x115b2, 0x115b8, 0x115bc, 0x115be, 0x115bf, 0x115dc, 0x11630, 0x11633, 0x1163b,
+        0x1163d, 0x1163e, 0x1163f, 0x116ab, 0x116ac, 0x116ad, 0x116ae, 0x116b0, 0x116b6, 0x116b7, 0x1171d, 0x11722,
+        0x11726, 0x11727, 0x1182c, 0x1182f, 0x11838, 0x11839, 0x11930, 0x11931, 0x11937, 0x1193b, 0x1193d, 0x1193e,
+        0x1193f, 0x11940, 0x11941, 0x11942, 0x11943, 0x119d1, 0x119d4, 0x119da, 0x119dc, 0x119e0, 0x119e4, 0x11a01,
+        0x11a33, 0x11a39, 0x11a3a, 0x11a3b, 0x11a47, 0x11a51, 0x11a57, 0x11a59, 0x11a84, 0x11a8a, 0x11a97, 0x11a98,
+        0x11c2f, 0x11c30, 0x11c38, 0x11c3e, 0x11c3f, 0x11c92, 0x11ca9, 0x11caa, 0x11cb1, 0x11cb2, 0x11cb4, 0x11cb5,
+        0x11d31, 0x11d3a, 0x11d3c, 0x11d3f, 0x11d46, 0x11d47, 0x11d8a, 0x11d90, 0x11d93, 0x11d95, 0x11d96, 0x11d97,
+        0x11ef3, 0x11ef5, 0x11f00, 0x11f02, 0x11f03, 0x11f34, 0x11f36, 0x11f3e, 0x11f40, 0x11f41, 0x11f42, 0x13430,
+        0x13440, 0x13447, 0x16af0, 0x16b30, 0x16f4f, 0x16f51, 0x16f8f, 0x16fe4, 0x16ff0, 0x1bc9d, 0x1bca0, 0x1cf00,
+        0x1cf30, 0x1d165, 0x1d166, 0x1d167, 0x1d16d, 0x1d16e, 0x1d173, 0x1d17b, 0x1d185, 0x1d1aa, 0x1d242, 0x1da00,
+        0x1da3b, 0x1da75, 0x1da84, 0x1da9b, 0x1daa1, 0x1e000, 0x1e008, 0x1e01b, 0x1e023, 0x1e026, 0x1e08f, 0x1e130,
+        0x1e2ae, 0x1e2ec, 0x1e4ec, 0x1e8d0, 0x1e944, 0x1f1e6, 0x1f3fb, 0xe0000, 0xe0020, 0xe0080, 0xe0100, 0xe01f0},
+    {0x100a, 0x4001, 0x1002, 0x1, 0x1012, 0x1021, 0x1001, 0x2070, 0x2007, 0x202d, 0x2001, 0x2002, 0x2002, 0x2001,
+        0x7006, 0x200b, 0x1001, 0x2015, 0x2001, 0x2007, 0x7001, 0x2006, 0x2002, 0x2004, 0x7001, 0x2001, 0x201b, 0x200b,
+        0x2009, 0x2001, 0x2004, 0x2009, 0x2003, 0x2005, 0x2003, 0x7002, 0x2008, 0x2018, 0x7001, 0x2020, 0x9001, 0x2001,
+        0x9001, 0x2001, 0x9003, 0x2008, 0x9004, 0x2001, 0x9002, 0x2007, 0x2002, 0x2001, 0x9002, 0x2001, 0x2001, 0x9002,
+        0x2004, 0x9002, 0x9002, 0x2001, 0x2001, 0x2002, 0x2001, 0x2002, 0x9001, 0x2001, 0x9003, 0x2002, 0x2002, 0x2003,
+        0x2001, 0x2002, 0x2001, 0x2002, 0x9001, 0x2001, 0x9003, 0x2005, 0x2002, 0x9001, 0x9002, 0x2001, 0x2002, 0x2006,
+        0x2001, 0x9002, 0x2001, 0x2002, 0x9001, 0x2004, 0x9002, 0x9002, 0x2001, 0x2003, 0x2002, 0x2001, 0x2001, 0x9001,
+        0x2001, 0x9002, 0x9003, 0x9003, 0x2001, 0x2001, 0x2001, 0x9003, 0x2001, 0x2001, 0x2003, 0x9004, 0x2003, 0x2004,
+        0x2002, 0x2002, 0x2001, 0x9002, 0x2001, 0x9001, 0x2001, 0x9002, 0x2001, 0x9002, 0x2001, 0x9002, 0x9002, 0x2002,
+        0x2002, 0x2002, 0x9001, 0x2002, 0x9002, 0x2002, 0x2001, 0x9002, 0x2004, 0x9003, 0x9003, 0x2001, 0x7001, 0x2001,
+        0x2002, 0x2001, 0x9002, 0x2001, 0x2001, 0x9002, 0x2003, 0x2001, 0x9007, 0x2001, 0x9002, 0x2001, 0x9001, 0x2007,
+        0x2008, 0x2001, 0x9001, 0x2009, 0x2007, 0x2002, 0x2001, 0x2001, 0x2001, 0x9002, 0x200e, 0x9001, 0x2005, 0x2002,
+        0x200b, 0x2024, 0x2001, 0x2004, 0x9001, 0x2006, 0x2002, 0x9002, 0x2002, 0x9002, 0x2002, 0x2003, 0x2004, 0x2001,
+        0x9001, 0x2002, 0x2001, 0x2001, 0x3060, 0xb048, 0xa058, 0x2003, 0x2003, 0x9001, 0x2002, 0x9001, 0x2002, 0x2002,
+        0x2002, 0x9001, 0x2007, 0x9008, 0x2001, 0x9002, 0x200b, 0x2001, 0x2003, 0x1001, 0x2001, 0x2002, 0x2001, 0x2003,
+        0x9004, 0x2002, 0x9003, 0x9002, 0x2001, 0x9006, 0x2003, 0x2002, 0x9002, 0x2001, 0x9001, 0x2001, 0x9001, 0x2007,
+        0x2001, 0x2001, 0x2008, 0x9006, 0x200a, 0x2001, 0x201f, 0x2004, 0x9001, 0x2007, 0x9001, 0x2001, 0x9005, 0x2001,
+        0x9002, 0x2009, 0x2002, 0x9001, 0x9001, 0x2004, 0x9002, 0x2002, 0x9001, 0x2003, 0x2001, 0x9001, 0x2002, 0x9003,
+        0x2001, 0x9001, 0x2003, 0x9002, 0x9008, 0x2008, 0x9002, 0x2002, 0x2003, 0x200d, 0x9001, 0x2007, 0x2001, 0x2001,
+        0x9001, 0x2002, 0x2040, 0x1001, 0x2001, 0xc001, 0x1002, 0x1007, 0x1010, 0x2021, 0x2003, 0x2001, 0x2020, 0x2006,
+        0x2002, 0x2004, 0x200a, 0x2002, 0x2002, 0x2001, 0x2001, 0x2001, 0x9002, 0x2002, 0x9001, 0x2001, 0x9002, 0x9010,
+        0x2002, 0x2012, 0x2001, 0x2008, 0x200b, 0x9002, 0x301d, 0x2003, 0x9001, 0x2001, 0x9002, 0x2004, 0x9002, 0x2002,
+        0x9003, 0x2001, 0x2006, 0x9002, 0x2002, 0x9002, 0x2002, 0x2001, 0x2001, 0x9001, 0x2001, 0x2001, 0x2003, 0x2002,
+        0x2002, 0x2001, 0x9001, 0x2002, 0x9002, 0x9001, 0x2001, 0x9002, 0x2001, 0x9002, 0x2001, 0x9002, 0x9001, 0x2001,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b,
+        0xb017, 0xa031, 0x2001, 0x2010, 0x2010, 0x1001, 0x2002, 0x100c, 0x2001, 0x2001, 0x2005, 0x2003, 0x2002, 0x2004,
+        0x2003, 0x2001, 0x2002, 0x2004, 0x2002, 0x2003, 0x200b, 0x2004, 0x9001, 0x2001, 0x9001, 0x200f, 0x2001, 0x2002,
+        0x2003, 0x9001, 0x9003, 0x2004, 0x9002, 0x2002, 0x7001, 0x2001, 0x7001, 0x2003, 0x2005, 0x9001, 0x2008, 0x9002,
+        0x2001, 0x2002, 0x9001, 0x9003, 0x2009, 0x9002, 0x7002, 0x2004, 0x9001, 0x2001, 0x9003, 0x2003, 0x9002, 0x2001,
+        0x9001, 0x2002, 0x2001, 0x2001, 0x2001, 0x9003, 0x2008, 0x2002, 0x9002, 0x2002, 0x2001, 0x9001, 0x2001, 0x9004,
+        0x9002, 0x9003, 0x2001, 0x9002, 0x2007, 0x2005, 0x9003, 0x2008, 0x9002, 0x2003, 0x9001, 0x2001, 0x2001, 0x2001,
+        0x9002, 0x2006, 0x9001, 0x2001, 0x9002, 0x2001, 0x9001, 0x2002, 0x9001, 0x2002, 0x2001, 0x9002, 0x2004, 0x9004,
+        0x2002, 0x9001, 0x2002, 0x2002, 0x9003, 0x2008, 0x9002, 0x2001, 0x9001, 0x2002, 0x2001, 0x9001, 0x2001, 0x9002,
+        0x2006, 0x9001, 0x2001, 0x2003, 0x2004, 0x9001, 0x2005, 0x9003, 0x2009, 0x9001, 0x2002, 0x2001, 0x9005, 0x9002,
+        0x2002, 0x9001, 0x2001, 0x7001, 0x9001, 0x7001, 0x9001, 0x2001, 0x9003, 0x2004, 0x2002, 0x9004, 0x2001, 0x9001,
+        0x200a, 0x2006, 0x9001, 0x7001, 0x2004, 0x2001, 0x2006, 0x9002, 0x2003, 0x7006, 0x200d, 0x9001, 0x2002, 0x9001,
+        0x2007, 0x2006, 0x9001, 0x2001, 0x2016, 0x9001, 0x2007, 0x9001, 0x2002, 0x9001, 0x2002, 0x2006, 0x2001, 0x2002,
+        0x2007, 0x7001, 0x2001, 0x9005, 0x2002, 0x9002, 0x2001, 0x9001, 0x2001, 0x2002, 0x9002, 0x2002, 0x7001, 0x9001,
+        0x9002, 0x2005, 0x9002, 0x2001, 0x9001, 0x2001, 0x1010, 0x2001, 0x200f, 0x2005, 0x2007, 0x2001, 0x9037, 0x2004,
+        0x2001, 0x9002, 0x2002, 0x1004, 0x202e, 0x2017, 0x2001, 0x9001, 0x2003, 0x9001, 0x2005, 0x1008, 0x2008, 0x2007,
+        0x2004, 0x2003, 0x2037, 0x2032, 0x2001, 0x2001, 0x2005, 0x200f, 0x2007, 0x2011, 0x2007, 0x2002, 0x2005, 0x2001,
+        0x2007, 0x2001, 0x2004, 0x2004, 0x2007, 0x2007, 0x801a, 0x2005, 0x1020, 0x2060, 0x1080, 0x20f0, 0x1e10}};
+
+// emoji-data.txt
+// Date: 2022-08-02, 00:26:10 GMT
+enum class _Extended_Pictographic_property_values : uint8_t { _Extended_Pictographic_value, _No_value = 255 };
+
+// emoji-data.txt
+// Date: 2022-08-02, 00:26:10 GMT
+inline constexpr _Unicode_property_data<_Extended_Pictographic_property_values, 78, true>
+    _Extended_Pictographic_property_data{
+        {0xa9, 0xae, 0x203c, 0x2049, 0x2122, 0x2139, 0x2194, 0x21a9, 0x231a, 0x2328, 0x2388, 0x23cf, 0x23e9, 0x23f8,
+            0x24c2, 0x25aa, 0x25b6, 0x25c0, 0x25fb, 0x2600, 0x2607, 0x2614, 0x2690, 0x2708, 0x2714, 0x2716, 0x271d,
+            0x2721, 0x2728, 0x2733, 0x2744, 0x2747, 0x274c, 0x274e, 0x2753, 0x2757, 0x2763, 0x2795, 0x27a1, 0x27b0,
+            0x27bf, 0x2934, 0x2b05, 0x2b1b, 0x2b50, 0x2b55, 0x3030, 0x303d, 0x3297, 0x3299, 0x1f000, 0x1f10d, 0x1f12f,
+            0x1f16c, 0x1f17e, 0x1f18e, 0x1f191, 0x1f1ad, 0x1f201, 0x1f21a, 0x1f22f, 0x1f232, 0x1f23c, 0x1f249, 0x1f400,
+            0x1f546, 0x1f680, 0x1f774, 0x1f7d5, 0x1f80c, 0x1f848, 0x1f85a, 0x1f888, 0x1f8ae, 0x1f90c, 0x1f93c, 0x1f947,
+            0x1fc00},
+        {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x6, 0x2, 0x2, 0x1, 0x1, 0x1, 0xb, 0x3, 0x1, 0x2, 0x1, 0x1, 0x4, 0x6, 0xc, 0x72,
+            0x76, 0xb, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x1, 0x1, 0x1, 0x1, 0x3, 0x1, 0x5, 0x3, 0x1, 0x1, 0x1, 0x2, 0x3,
+            0x2, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x100, 0x3, 0x1, 0x6, 0x2, 0x1, 0xa, 0x39, 0xf, 0x1, 0x1, 0x9, 0x4,
+            0x1b2, 0x13e, 0x10a, 0x80, 0xc, 0x2b, 0x4, 0x8, 0x6, 0x8, 0x52, 0x2f, 0xa, 0x1b9, 0x3fe}};
+
+// DerivedGeneralCategory-15.0.0.txt
+// Date: 2022-04-26, 23:14:35 GMT
+enum class __printable_property_values : uint8_t { _Yes_value, _No_value = 255 };
+
+// DerivedGeneralCategory-15.0.0.txt
+// Date: 2022-04-26, 23:14:35 GMT
+inline constexpr _Unicode_property_data<__printable_property_values, 711, true> __printable_property_data{
+    {0x20, 0xa1, 0xae, 0x37a, 0x384, 0x38c, 0x38e, 0x3a3, 0x531, 0x559, 0x58d, 0x591, 0x5d0, 0x5ef, 0x606, 0x61d, 0x6de,
+        0x710, 0x74d, 0x7c0, 0x7fd, 0x830, 0x840, 0x85e, 0x860, 0x870, 0x898, 0x8e3, 0x985, 0x98f, 0x993, 0x9aa, 0x9b2,
+        0x9b6, 0x9bc, 0x9c7, 0x9cb, 0x9d7, 0x9dc, 0x9df, 0x9e6, 0xa01, 0xa05, 0xa0f, 0xa13, 0xa2a, 0xa32, 0xa35, 0xa38,
+        0xa3c, 0xa3e, 0xa47, 0xa4b, 0xa51, 0xa59, 0xa5e, 0xa66, 0xa81, 0xa85, 0xa8f, 0xa93, 0xaaa, 0xab2, 0xab5, 0xabc,
+        0xac7, 0xacb, 0xad0, 0xae0, 0xae6, 0xaf9, 0xb01, 0xb05, 0xb0f, 0xb13, 0xb2a, 0xb32, 0xb35, 0xb3c, 0xb47, 0xb4b,
+        0xb55, 0xb5c, 0xb5f, 0xb66, 0xb82, 0xb85, 0xb8e, 0xb92, 0xb99, 0xb9c, 0xb9e, 0xba3, 0xba8, 0xbae, 0xbbe, 0xbc6,
+        0xbca, 0xbd0, 0xbd7, 0xbe6, 0xc00, 0xc0e, 0xc12, 0xc2a, 0xc3c, 0xc46, 0xc4a, 0xc55, 0xc58, 0xc5d, 0xc60, 0xc66,
+        0xc77, 0xc8e, 0xc92, 0xcaa, 0xcb5, 0xcbc, 0xcc6, 0xcca, 0xcd5, 0xcdd, 0xce0, 0xce6, 0xcf1, 0xd00, 0xd0e, 0xd12,
+        0xd46, 0xd4a, 0xd54, 0xd66, 0xd81, 0xd85, 0xd9a, 0xdb3, 0xdbd, 0xdc0, 0xdca, 0xdcf, 0xdd6, 0xdd8, 0xde6, 0xdf2,
+        0xe01, 0xe3f, 0xe81, 0xe84, 0xe86, 0xe8c, 0xea5, 0xea7, 0xec0, 0xec6, 0xec8, 0xed0, 0xedc, 0xf00, 0xf49, 0xf71,
+        0xf99, 0xfbe, 0xfce, 0x1000, 0x10c7, 0x10cd, 0x10d0, 0x124a, 0x1250, 0x1258, 0x125a, 0x1260, 0x128a, 0x1290,
+        0x12b2, 0x12b8, 0x12c0, 0x12c2, 0x12c8, 0x12d8, 0x1312, 0x1318, 0x135d, 0x1380, 0x13a0, 0x13f8, 0x1400, 0x1681,
+        0x16a0, 0x1700, 0x171f, 0x1740, 0x1760, 0x176e, 0x1772, 0x1780, 0x17e0, 0x17f0, 0x1800, 0x180f, 0x1820, 0x1880,
+        0x18b0, 0x1900, 0x1920, 0x1930, 0x1940, 0x1944, 0x1970, 0x1980, 0x19b0, 0x19d0, 0x19de, 0x1a1e, 0x1a60, 0x1a7f,
+        0x1a90, 0x1aa0, 0x1ab0, 0x1b00, 0x1b50, 0x1b80, 0x1bfc, 0x1c3b, 0x1c4d, 0x1c90, 0x1cbd, 0x1cd0, 0x1d00, 0x1f18,
+        0x1f20, 0x1f48, 0x1f50, 0x1f59, 0x1f5b, 0x1f5d, 0x1f5f, 0x1f80, 0x1fb6, 0x1fc6, 0x1fd6, 0x1fdd, 0x1ff2, 0x1ff6,
+        0x2010, 0x2030, 0x2070, 0x2074, 0x2090, 0x20a0, 0x20d0, 0x2100, 0x2190, 0x2440, 0x2460, 0x2b76, 0x2b97, 0x2cf9,
+        0x2d27, 0x2d2d, 0x2d30, 0x2d6f, 0x2d7f, 0x2da0, 0x2da8, 0x2db0, 0x2db8, 0x2dc0, 0x2dc8, 0x2dd0, 0x2dd8, 0x2de0,
+        0x2e80, 0x2e9b, 0x2f00, 0x2ff0, 0x3001, 0x3041, 0x3099, 0x3105, 0x3131, 0x3190, 0x31f0, 0x3220, 0xa490, 0xa4d0,
+        0xa640, 0xa700, 0xa7d0, 0xa7d3, 0xa7d5, 0xa7f2, 0xa830, 0xa840, 0xa880, 0xa8ce, 0xa8e0, 0xa95f, 0xa980, 0xa9cf,
+        0xa9de, 0xaa00, 0xaa40, 0xaa50, 0xaa5c, 0xaadb, 0xab01, 0xab09, 0xab11, 0xab20, 0xab28, 0xab30, 0xab70, 0xabf0,
+        0xac00, 0xd7b0, 0xd7cb, 0xf900, 0xfa70, 0xfb00, 0xfb13, 0xfb1d, 0xfb38, 0xfb3e, 0xfb40, 0xfb43, 0xfb46, 0xfbd3,
+        0xfd92, 0xfdcf, 0xfdf0, 0xfe20, 0xfe54, 0xfe68, 0xfe70, 0xfe76, 0xff01, 0xffc2, 0xffca, 0xffd2, 0xffda, 0xffe0,
+        0xffe8, 0xfffc, 0x10000, 0x1000d, 0x10028, 0x1003c, 0x1003f, 0x10050, 0x10080, 0x10100, 0x10107, 0x10137,
+        0x10190, 0x101a0, 0x101d0, 0x10280, 0x102a0, 0x102e0, 0x10300, 0x1032d, 0x10350, 0x10380, 0x1039f, 0x103c8,
+        0x10400, 0x104a0, 0x104b0, 0x104d8, 0x10500, 0x10530, 0x1056f, 0x1057c, 0x1058c, 0x10594, 0x10597, 0x105a3,
+        0x105b3, 0x105bb, 0x10600, 0x10740, 0x10760, 0x10780, 0x10787, 0x107b2, 0x10800, 0x10808, 0x1080a, 0x10837,
+        0x1083c, 0x1083f, 0x10857, 0x108a7, 0x108e0, 0x108f4, 0x108fb, 0x1091f, 0x1093f, 0x10980, 0x109bc, 0x109d2,
+        0x10a05, 0x10a0c, 0x10a15, 0x10a19, 0x10a38, 0x10a3f, 0x10a50, 0x10a60, 0x10ac0, 0x10aeb, 0x10b00, 0x10b39,
+        0x10b58, 0x10b78, 0x10b99, 0x10ba9, 0x10c00, 0x10c80, 0x10cc0, 0x10cfa, 0x10d30, 0x10e60, 0x10e80, 0x10eab,
+        0x10eb0, 0x10efd, 0x10f30, 0x10f70, 0x10fb0, 0x10fe0, 0x11000, 0x11052, 0x1107f, 0x110be, 0x110d0, 0x110f0,
+        0x11100, 0x11136, 0x11150, 0x11180, 0x111e1, 0x11200, 0x11213, 0x11280, 0x11288, 0x1128a, 0x1128f, 0x1129f,
+        0x112b0, 0x112f0, 0x11300, 0x11305, 0x1130f, 0x11313, 0x1132a, 0x11332, 0x11335, 0x1133b, 0x11347, 0x1134b,
+        0x11350, 0x11357, 0x1135d, 0x11366, 0x11370, 0x11400, 0x1145d, 0x11480, 0x114d0, 0x11580, 0x115b8, 0x11600,
+        0x11650, 0x11660, 0x11680, 0x116c0, 0x11700, 0x1171d, 0x11730, 0x11800, 0x118a0, 0x118ff, 0x11909, 0x1190c,
+        0x11915, 0x11918, 0x11937, 0x1193b, 0x11950, 0x119a0, 0x119aa, 0x119da, 0x11a00, 0x11a50, 0x11ab0, 0x11b00,
+        0x11c00, 0x11c0a, 0x11c38, 0x11c50, 0x11c70, 0x11c92, 0x11ca9, 0x11d00, 0x11d08, 0x11d0b, 0x11d3a, 0x11d3c,
+        0x11d3f, 0x11d50, 0x11d60, 0x11d67, 0x11d6a, 0x11d90, 0x11d93, 0x11da0, 0x11ee0, 0x11f00, 0x11f12, 0x11f3e,
+        0x11fb0, 0x11fc0, 0x11fff, 0x12400, 0x12470, 0x12480, 0x12f90, 0x13000, 0x13440, 0x14400, 0x16800, 0x16a40,
+        0x16a60, 0x16a6e, 0x16ac0, 0x16ad0, 0x16af0, 0x16b00, 0x16b50, 0x16b5b, 0x16b63, 0x16b7d, 0x16e40, 0x16f00,
+        0x16f4f, 0x16f8f, 0x16fe0, 0x16ff0, 0x17000, 0x18800, 0x18d00, 0x1aff0, 0x1aff5, 0x1affd, 0x1b000, 0x1b132,
+        0x1b150, 0x1b155, 0x1b164, 0x1b170, 0x1bc00, 0x1bc70, 0x1bc80, 0x1bc90, 0x1bc9c, 0x1cf00, 0x1cf30, 0x1cf50,
+        0x1d000, 0x1d100, 0x1d129, 0x1d17b, 0x1d200, 0x1d2c0, 0x1d2e0, 0x1d300, 0x1d360, 0x1d400, 0x1d456, 0x1d49e,
+        0x1d4a2, 0x1d4a5, 0x1d4a9, 0x1d4ae, 0x1d4bb, 0x1d4bd, 0x1d4c5, 0x1d507, 0x1d50d, 0x1d516, 0x1d51e, 0x1d53b,
+        0x1d540, 0x1d546, 0x1d54a, 0x1d552, 0x1d6a8, 0x1d7ce, 0x1da9b, 0x1daa1, 0x1df00, 0x1df25, 0x1e000, 0x1e008,
+        0x1e01b, 0x1e023, 0x1e026, 0x1e030, 0x1e08f, 0x1e100, 0x1e130, 0x1e140, 0x1e14e, 0x1e290, 0x1e2c0, 0x1e2ff,
+        0x1e4d0, 0x1e7e0, 0x1e7e8, 0x1e7ed, 0x1e7f0, 0x1e800, 0x1e8c7, 0x1e900, 0x1e950, 0x1e95e, 0x1ec71, 0x1ed01,
+        0x1ee00, 0x1ee05, 0x1ee21, 0x1ee24, 0x1ee27, 0x1ee29, 0x1ee34, 0x1ee39, 0x1ee3b, 0x1ee42, 0x1ee47, 0x1ee49,
+        0x1ee4b, 0x1ee4d, 0x1ee51, 0x1ee54, 0x1ee57, 0x1ee59, 0x1ee5b, 0x1ee5d, 0x1ee5f, 0x1ee61, 0x1ee64, 0x1ee67,
+        0x1ee6c, 0x1ee74, 0x1ee79, 0x1ee7e, 0x1ee80, 0x1ee8b, 0x1eea1, 0x1eea5, 0x1eeab, 0x1eef0, 0x1f000, 0x1f030,
+        0x1f0a0, 0x1f0b1, 0x1f0c1, 0x1f0d1, 0x1f100, 0x1f1e6, 0x1f210, 0x1f240, 0x1f250, 0x1f260, 0x1f300, 0x1f6dc,
+        0x1f6f0, 0x1f700, 0x1f77b, 0x1f7e0, 0x1f7f0, 0x1f800, 0x1f810, 0x1f850, 0x1f860, 0x1f890, 0x1f8b0, 0x1f900,
+        0x1fa60, 0x1fa70, 0x1fa80, 0x1fa90, 0x1fabf, 0x1face, 0x1fae0, 0x1faf0, 0x1fb00, 0x1fb94, 0x1fbf0, 0x20000,
+        0x2a700, 0x2b740, 0x2b820, 0x2ceb0, 0x2f800, 0x30000, 0x31350, 0xe0100},
+    {0x5f, 0xc, 0x2ca, 0x6, 0x7, 0x1, 0x14, 0x18d, 0x26, 0x32, 0x3, 0x37, 0x1b, 0x6, 0x16, 0xc0, 0x30, 0x3b, 0x65, 0x3b,
+        0x31, 0xf, 0x1c, 0x1, 0xb, 0x1f, 0x4a, 0xa1, 0x8, 0x2, 0x16, 0x7, 0x1, 0x4, 0x9, 0x2, 0x4, 0x1, 0x2, 0x5, 0x19,
+        0x3, 0x6, 0x2, 0x16, 0x7, 0x2, 0x2, 0x2, 0x1, 0x5, 0x2, 0x3, 0x1, 0x4, 0x1, 0x11, 0x3, 0x9, 0x3, 0x16, 0x7, 0x2,
+        0x5, 0xa, 0x3, 0x3, 0x1, 0x4, 0xc, 0x7, 0x3, 0x8, 0x2, 0x16, 0x7, 0x2, 0x5, 0x9, 0x2, 0x3, 0x3, 0x2, 0x5, 0x12,
+        0x2, 0x6, 0x3, 0x4, 0x2, 0x1, 0x2, 0x2, 0x3, 0xc, 0x5, 0x3, 0x4, 0x1, 0x1, 0x15, 0xd, 0x3, 0x17, 0x10, 0x9, 0x3,
+        0x4, 0x2, 0x3, 0x1, 0x4, 0xa, 0x16, 0x3, 0x17, 0xa, 0x5, 0x9, 0x3, 0x4, 0x2, 0x2, 0x4, 0xa, 0x3, 0xd, 0x3, 0x33,
+        0x3, 0x6, 0x10, 0x1a, 0x3, 0x12, 0x18, 0x9, 0x1, 0x7, 0x1, 0x6, 0x1, 0x8, 0xa, 0x3, 0x3a, 0x1d, 0x2, 0x1, 0x5,
+        0x18, 0x1, 0x17, 0x5, 0x1, 0x7, 0xa, 0x4, 0x48, 0x24, 0x27, 0x24, 0xf, 0xd, 0xc6, 0x1, 0x1, 0x179, 0x4, 0x7,
+        0x1, 0x4, 0x29, 0x4, 0x21, 0x4, 0x7, 0x1, 0x4, 0xf, 0x39, 0x4, 0x43, 0x20, 0x1a, 0x56, 0x6, 0x280, 0x1c, 0x59,
+        0x16, 0x18, 0x14, 0xd, 0x3, 0x2, 0x5e, 0xa, 0xa, 0xe, 0xb, 0x59, 0x2b, 0x46, 0x1f, 0xc, 0xc, 0x1, 0x2a, 0x5,
+        0x2c, 0x1a, 0xb, 0x3e, 0x41, 0x1d, 0xb, 0xa, 0xe, 0x1f, 0x4d, 0x2f, 0x74, 0x3c, 0xf, 0x3c, 0x2b, 0xb, 0x2b,
+        0x216, 0x6, 0x26, 0x6, 0x8, 0x1, 0x1, 0x1, 0x1f, 0x35, 0xf, 0xe, 0x6, 0x13, 0x3, 0x9, 0x18, 0x2f, 0x2, 0x1b,
+        0xd, 0x21, 0x21, 0x8c, 0x297, 0xb, 0x714, 0x20, 0x15d, 0x2d, 0x1, 0x1, 0x38, 0x2, 0x18, 0x7, 0x7, 0x7, 0x7, 0x7,
+        0x7, 0x7, 0x7, 0x7e, 0x1a, 0x59, 0xd6, 0xc, 0x3f, 0x56, 0x67, 0x2b, 0x5e, 0x54, 0x2f, 0x726d, 0x37, 0x15c, 0xb8,
+        0xcb, 0x2, 0x1, 0x5, 0x3b, 0xa, 0x38, 0x46, 0xc, 0x74, 0x1e, 0x4e, 0xb, 0x21, 0x37, 0xe, 0xa, 0x67, 0x1c, 0x6,
+        0x6, 0x6, 0x7, 0x7, 0x3c, 0x7e, 0xa, 0x2ba4, 0x17, 0x31, 0x16e, 0x6a, 0x7, 0x5, 0x1a, 0x5, 0x1, 0x2, 0x2, 0x7d,
+        0x1bd, 0x36, 0x1, 0x2a, 0x33, 0x13, 0x4, 0x5, 0x87, 0xbe, 0x6, 0x6, 0x6, 0x3, 0x7, 0x7, 0x2, 0xc, 0x1a, 0x13,
+        0x2, 0xf, 0xe, 0x7b, 0x3, 0x2d, 0x58, 0xd, 0x1, 0x2e, 0x1d, 0x31, 0x1c, 0x24, 0x1e, 0x2b, 0x1e, 0x25, 0xe, 0x9e,
+        0xa, 0x24, 0x24, 0x28, 0x34, 0xc, 0xf, 0x7, 0x2, 0xb, 0xf, 0x7, 0x2, 0x137, 0x16, 0x8, 0x6, 0x2a, 0x9, 0x6, 0x1,
+        0x2c, 0x2, 0x1, 0x17, 0x48, 0x9, 0x13, 0x2, 0x21, 0x1b, 0x1, 0x38, 0x14, 0x32, 0x2, 0x8, 0x3, 0x1d, 0x3, 0xa,
+        0x9, 0x40, 0x27, 0xc, 0x36, 0x1d, 0x1b, 0x1a, 0x4, 0x7, 0x49, 0x33, 0x33, 0x2e, 0xa, 0x1f, 0x2a, 0x3, 0x2, 0x2b,
+        0x2a, 0x1a, 0x1c, 0x17, 0x4e, 0x24, 0x3e, 0x5, 0x19, 0xa, 0x35, 0x12, 0x27, 0x60, 0x14, 0x12, 0x2f, 0x7, 0x1,
+        0x4, 0xf, 0xb, 0x3b, 0xa, 0x4, 0x8, 0x2, 0x16, 0x7, 0x2, 0x5, 0xa, 0x2, 0x3, 0x1, 0x1, 0x7, 0x7, 0x5, 0x5c, 0x5,
+        0x48, 0xa, 0x36, 0x26, 0x45, 0xa, 0xd, 0x3a, 0xa, 0x1b, 0xf, 0x17, 0x3c, 0x53, 0x8, 0x1, 0x8, 0x2, 0x1e, 0x2,
+        0xc, 0xa, 0x8, 0x2e, 0xb, 0x48, 0x53, 0x49, 0xa, 0x9, 0x2d, 0xe, 0x1d, 0x20, 0x16, 0xe, 0x7, 0x2, 0x2c, 0x1,
+        0x2, 0x9, 0xa, 0x6, 0x2, 0x25, 0x2, 0x6, 0xa, 0x19, 0x11, 0x29, 0x1c, 0x1, 0x32, 0x39b, 0x6f, 0x5, 0xc4, 0x63,
+        0x430, 0x16, 0x247, 0x239, 0x1f, 0xa, 0x51, 0xa, 0x1e, 0x6, 0x46, 0xa, 0x7, 0x15, 0x13, 0x5b, 0x4b, 0x39, 0x11,
+        0x5, 0x2, 0x17f8, 0x4d6, 0x9, 0x4, 0x7, 0x2, 0x123, 0x1, 0x3, 0x1, 0x4, 0x18c, 0x6b, 0xd, 0x9, 0xa, 0x4, 0x2e,
+        0x17, 0x74, 0xf6, 0x27, 0x4a, 0x70, 0x46, 0x14, 0x14, 0x57, 0x19, 0x55, 0x47, 0x2, 0x1, 0x2, 0x4, 0xc, 0x1, 0x7,
+        0x41, 0x4, 0x8, 0x7, 0x1c, 0x4, 0x5, 0x1, 0x7, 0x154, 0x124, 0x2be, 0x5, 0xf, 0x1f, 0x6, 0x7, 0x11, 0x7, 0x2,
+        0x5, 0x3e, 0x1, 0x2d, 0xe, 0xa, 0x2, 0x1f, 0x3a, 0x1, 0x2a, 0x7, 0x4, 0x2, 0xf, 0xc5, 0x10, 0x4c, 0xa, 0x2,
+        0x44, 0x3d, 0x4, 0x1b, 0x2, 0x1, 0x1, 0xa, 0x4, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x3, 0x2, 0x1, 0x1, 0x1, 0x1, 0x1,
+        0x1, 0x2, 0x1, 0x4, 0x7, 0x4, 0x4, 0x1, 0xa, 0x11, 0x3, 0x5, 0x11, 0x2, 0x2c, 0x64, 0xf, 0xf, 0xf, 0x25, 0xae,
+        0x1d, 0x2c, 0x9, 0x2, 0x6, 0x3d8, 0x11, 0xd, 0x77, 0x5f, 0xc, 0x1, 0xc, 0x38, 0xa, 0x28, 0x1e, 0x2, 0x154, 0xe,
+        0xd, 0x9, 0x2e, 0x7, 0xe, 0x9, 0x9, 0x93, 0x37, 0xa, 0xa6e0, 0x103a, 0xde, 0x1682, 0x1d31, 0x21e, 0x134b,
+        0x1060, 0xf0}};
+
+// DerivedCoreProperties-15.0.0.txt
+// Date: 2022-08-05, 22:17:05 GMT
+enum class _Grapheme_Extend_property_values : uint8_t { _Grapheme_Extend_value, _No_value = 255 };
+
+// DerivedCoreProperties-15.0.0.txt
+// Date: 2022-08-05, 22:17:05 GMT
+inline constexpr _Unicode_property_data<_Grapheme_Extend_property_values, 363, true> _Grapheme_Extend_property_data{
+    {0x300, 0x483, 0x591, 0x5bf, 0x5c1, 0x5c4, 0x5c7, 0x610, 0x64b, 0x670, 0x6d6, 0x6df, 0x6e7, 0x6ea, 0x711, 0x730,
+        0x7a6, 0x7eb, 0x7fd, 0x816, 0x81b, 0x825, 0x829, 0x859, 0x898, 0x8ca, 0x8e3, 0x93a, 0x93c, 0x941, 0x94d, 0x951,
+        0x962, 0x981, 0x9bc, 0x9be, 0x9c1, 0x9cd, 0x9d7, 0x9e2, 0x9fe, 0xa01, 0xa3c, 0xa41, 0xa47, 0xa4b, 0xa51, 0xa70,
+        0xa75, 0xa81, 0xabc, 0xac1, 0xac7, 0xacd, 0xae2, 0xafa, 0xb01, 0xb3c, 0xb3e, 0xb41, 0xb4d, 0xb55, 0xb62, 0xb82,
+        0xbbe, 0xbc0, 0xbcd, 0xbd7, 0xc00, 0xc04, 0xc3c, 0xc3e, 0xc46, 0xc4a, 0xc55, 0xc62, 0xc81, 0xcbc, 0xcbf, 0xcc2,
+        0xcc6, 0xccc, 0xcd5, 0xce2, 0xd00, 0xd3b, 0xd3e, 0xd41, 0xd4d, 0xd57, 0xd62, 0xd81, 0xdca, 0xdcf, 0xdd2, 0xdd6,
+        0xddf, 0xe31, 0xe34, 0xe47, 0xeb1, 0xeb4, 0xec8, 0xf18, 0xf35, 0xf37, 0xf39, 0xf71, 0xf80, 0xf86, 0xf8d, 0xf99,
+        0xfc6, 0x102d, 0x1032, 0x1039, 0x103d, 0x1058, 0x105e, 0x1071, 0x1082, 0x1085, 0x108d, 0x109d, 0x135d, 0x1712,
+        0x1732, 0x1752, 0x1772, 0x17b4, 0x17b7, 0x17c6, 0x17c9, 0x17dd, 0x180b, 0x180f, 0x1885, 0x18a9, 0x1920, 0x1927,
+        0x1932, 0x1939, 0x1a17, 0x1a1b, 0x1a56, 0x1a58, 0x1a60, 0x1a62, 0x1a65, 0x1a73, 0x1a7f, 0x1ab0, 0x1b00, 0x1b34,
+        0x1b3c, 0x1b42, 0x1b6b, 0x1b80, 0x1ba2, 0x1ba8, 0x1bab, 0x1be6, 0x1be8, 0x1bed, 0x1bef, 0x1c2c, 0x1c36, 0x1cd0,
+        0x1cd4, 0x1ce2, 0x1ced, 0x1cf4, 0x1cf8, 0x1dc0, 0x200c, 0x20d0, 0x2cef, 0x2d7f, 0x2de0, 0x302a, 0x3099, 0xa66f,
+        0xa674, 0xa69e, 0xa6f0, 0xa802, 0xa806, 0xa80b, 0xa825, 0xa82c, 0xa8c4, 0xa8e0, 0xa8ff, 0xa926, 0xa947, 0xa980,
+        0xa9b3, 0xa9b6, 0xa9bc, 0xa9e5, 0xaa29, 0xaa31, 0xaa35, 0xaa43, 0xaa4c, 0xaa7c, 0xaab0, 0xaab2, 0xaab7, 0xaabe,
+        0xaac1, 0xaaec, 0xaaf6, 0xabe5, 0xabe8, 0xabed, 0xfb1e, 0xfe00, 0xfe20, 0xff9e, 0x101fd, 0x102e0, 0x10376,
+        0x10a01, 0x10a05, 0x10a0c, 0x10a38, 0x10a3f, 0x10ae5, 0x10d24, 0x10eab, 0x10efd, 0x10f46, 0x10f82, 0x11001,
+        0x11038, 0x11070, 0x11073, 0x1107f, 0x110b3, 0x110b9, 0x110c2, 0x11100, 0x11127, 0x1112d, 0x11173, 0x11180,
+        0x111b6, 0x111c9, 0x111cf, 0x1122f, 0x11234, 0x11236, 0x1123e, 0x11241, 0x112df, 0x112e3, 0x11300, 0x1133b,
+        0x1133e, 0x11340, 0x11357, 0x11366, 0x11370, 0x11438, 0x11442, 0x11446, 0x1145e, 0x114b0, 0x114b3, 0x114ba,
+        0x114bd, 0x114bf, 0x114c2, 0x115af, 0x115b2, 0x115bc, 0x115bf, 0x115dc, 0x11633, 0x1163d, 0x1163f, 0x116ab,
+        0x116ad, 0x116b0, 0x116b7, 0x1171d, 0x11722, 0x11727, 0x1182f, 0x11839, 0x11930, 0x1193b, 0x1193e, 0x11943,
+        0x119d4, 0x119da, 0x119e0, 0x11a01, 0x11a33, 0x11a3b, 0x11a47, 0x11a51, 0x11a59, 0x11a8a, 0x11a98, 0x11c30,
+        0x11c38, 0x11c3f, 0x11c92, 0x11caa, 0x11cb2, 0x11cb5, 0x11d31, 0x11d3a, 0x11d3c, 0x11d3f, 0x11d47, 0x11d90,
+        0x11d95, 0x11d97, 0x11ef3, 0x11f00, 0x11f36, 0x11f40, 0x11f42, 0x13440, 0x13447, 0x16af0, 0x16b30, 0x16f4f,
+        0x16f8f, 0x16fe4, 0x1bc9d, 0x1cf00, 0x1cf30, 0x1d165, 0x1d167, 0x1d16e, 0x1d17b, 0x1d185, 0x1d1aa, 0x1d242,
+        0x1da00, 0x1da3b, 0x1da75, 0x1da84, 0x1da9b, 0x1daa1, 0x1e000, 0x1e008, 0x1e01b, 0x1e023, 0x1e026, 0x1e08f,
+        0x1e130, 0x1e2ae, 0x1e2ec, 0x1e4ec, 0x1e8d0, 0x1e944, 0xe0020, 0xe0100},
+    {0x70, 0x7, 0x2d, 0x1, 0x2, 0x2, 0x1, 0xb, 0x15, 0x1, 0x7, 0x6, 0x2, 0x4, 0x1, 0x1b, 0xb, 0x9, 0x1, 0x4, 0x9, 0x3,
+        0x5, 0x3, 0x8, 0x18, 0x20, 0x1, 0x1, 0x8, 0x1, 0x7, 0x2, 0x1, 0x1, 0x1, 0x4, 0x1, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2,
+        0x2, 0x3, 0x1, 0x2, 0x1, 0x2, 0x1, 0x5, 0x2, 0x1, 0x2, 0x6, 0x1, 0x1, 0x2, 0x4, 0x1, 0x3, 0x2, 0x1, 0x1, 0x1,
+        0x1, 0x1, 0x1, 0x1, 0x1, 0x3, 0x3, 0x4, 0x2, 0x2, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x4,
+        0x1, 0x1, 0x2, 0x1, 0x1, 0x1, 0x3, 0x1, 0x1, 0x1, 0x7, 0x8, 0x1, 0x9, 0x7, 0x2, 0x1, 0x1, 0x1, 0xe, 0x5, 0x2,
+        0xb, 0x24, 0x1, 0x4, 0x6, 0x2, 0x2, 0x2, 0x3, 0x4, 0x1, 0x2, 0x1, 0x1, 0x3, 0x3, 0x2, 0x2, 0x2, 0x2, 0x7, 0x1,
+        0xb, 0x1, 0x3, 0x1, 0x2, 0x1, 0x3, 0x2, 0x1, 0x3, 0x2, 0x1, 0x1, 0x7, 0x1, 0x1, 0x8, 0xa, 0x1, 0x1f, 0x4, 0x7,
+        0x1, 0x1, 0x9, 0x2, 0x4, 0x2, 0x3, 0x1, 0x2, 0x1, 0x3, 0x8, 0x2, 0x3, 0xd, 0x7, 0x1, 0x1, 0x2, 0x40, 0x1, 0x21,
+        0x3, 0x1, 0x20, 0x6, 0x2, 0x4, 0xa, 0x2, 0x2, 0x1, 0x1, 0x1, 0x2, 0x1, 0x2, 0x12, 0x1, 0x8, 0xb, 0x3, 0x1, 0x4,
+        0x2, 0x1, 0x6, 0x2, 0x2, 0x1, 0x1, 0x1, 0x1, 0x3, 0x2, 0x2, 0x1, 0x2, 0x1, 0x1, 0x1, 0x1, 0x1, 0x10, 0x10, 0x2,
+        0x1, 0x1, 0x5, 0x3, 0x2, 0x4, 0x3, 0x1, 0x2, 0x4, 0x2, 0x3, 0xb, 0x4, 0x1, 0xf, 0x1, 0x2, 0x3, 0x4, 0x2, 0x1,
+        0x3, 0x5, 0x8, 0x1, 0x2, 0x9, 0x4, 0x1, 0x3, 0x1, 0x2, 0x1, 0x1, 0x1, 0x8, 0x2, 0x2, 0x1, 0x1, 0x1, 0x7, 0x5,
+        0x8, 0x3, 0x1, 0x1, 0x1, 0x6, 0x1, 0x1, 0x2, 0x2, 0x1, 0x4, 0x2, 0x2, 0x2, 0x8, 0x1, 0x2, 0x1, 0x1, 0x6, 0x1,
+        0x3, 0x4, 0x5, 0x9, 0x2, 0x1, 0x2, 0x1, 0x1, 0x4, 0x2, 0x1, 0xa, 0x6, 0x4, 0x1, 0x6, 0x3, 0xd, 0x2, 0x7, 0x6,
+        0x1, 0x16, 0x7, 0x2, 0x2, 0x6, 0x1, 0x2, 0x7, 0x1, 0x2, 0x1, 0x1, 0x2, 0x2, 0x5, 0x1, 0x1, 0x1, 0xf, 0x5, 0x7,
+        0x1, 0x4, 0x1, 0x2, 0x2e, 0x17, 0x1, 0x3, 0x5, 0x8, 0x7, 0x4, 0x3, 0x37, 0x32, 0x1, 0x1, 0x5, 0xf, 0x7, 0x11,
+        0x7, 0x2, 0x5, 0x1, 0x7, 0x1, 0x4, 0x4, 0x7, 0x7, 0x60, 0xf0}};
+
+// EastAsianWidth-15.0.0.txt
+// Date: 2022-05-24, 17:40:20 GMT [KW, LI]
+inline constexpr char32_t _Width_estimate_intervals_v2[] = {0x1100, 0x1160, 0x231a, 0x231c, 0x2329, 0x232b, 0x23e9,
+    0x23ed, 0x23f0, 0x23f1, 0x23f3, 0x23f4, 0x25fd, 0x25ff, 0x2614, 0x2616, 0x2648, 0x2654, 0x267f, 0x2680, 0x2693,
+    0x2694, 0x26a1, 0x26a2, 0x26aa, 0x26ac, 0x26bd, 0x26bf, 0x26c4, 0x26c6, 0x26ce, 0x26cf, 0x26d4, 0x26d5, 0x26ea,
+    0x26eb, 0x26f2, 0x26f4, 0x26f5, 0x26f6, 0x26fa, 0x26fb, 0x26fd, 0x26fe, 0x2705, 0x2706, 0x270a, 0x270c, 0x2728,
+    0x2729, 0x274c, 0x274d, 0x274e, 0x274f, 0x2753, 0x2756, 0x2757, 0x2758, 0x2795, 0x2798, 0x27b0, 0x27b1, 0x27bf,
+    0x27c0, 0x2b1b, 0x2b1d, 0x2b50, 0x2b51, 0x2b55, 0x2b56, 0x2e80, 0x2e9a, 0x2e9b, 0x2ef4, 0x2f00, 0x2fd6, 0x2ff0,
+    0x2ffc, 0x3000, 0x303f, 0x3041, 0x3097, 0x3099, 0x3100, 0x3105, 0x3130, 0x3131, 0x318f, 0x3190, 0x31e4, 0x31f0,
+    0x321f, 0x3220, 0x3248, 0x3250, 0xa48d, 0xa490, 0xa4c7, 0xa960, 0xa97d, 0xac00, 0xd7a4, 0xf900, 0xfb00, 0xfe10,
+    0xfe1a, 0xfe30, 0xfe53, 0xfe54, 0xfe67, 0xfe68, 0xfe6c, 0xff01, 0xff61, 0xffe0, 0xffe7, 0x16fe0, 0x16fe5, 0x16ff0,
+    0x16ff2, 0x17000, 0x187f8, 0x18800, 0x18cd6, 0x18d00, 0x18d09, 0x1aff0, 0x1aff4, 0x1aff5, 0x1affc, 0x1affd, 0x1afff,
+    0x1b000, 0x1b123, 0x1b132, 0x1b133, 0x1b150, 0x1b153, 0x1b155, 0x1b156, 0x1b164, 0x1b168, 0x1b170, 0x1b2fc, 0x1f004,
+    0x1f005, 0x1f0cf, 0x1f0d0, 0x1f18e, 0x1f18f, 0x1f191, 0x1f19b, 0x1f200, 0x1f203, 0x1f210, 0x1f23c, 0x1f240, 0x1f249,
+    0x1f250, 0x1f252, 0x1f260, 0x1f266, 0x1f300, 0x1f650, 0x1f680, 0x1f6c6, 0x1f6cc, 0x1f6cd, 0x1f6d0, 0x1f6d3, 0x1f6d5,
+    0x1f6d8, 0x1f6dc, 0x1f6e0, 0x1f6eb, 0x1f6ed, 0x1f6f4, 0x1f6fd, 0x1f7e0, 0x1f7ec, 0x1f7f0, 0x1f7f1, 0x1f900, 0x1fa00,
+    0x1fa70, 0x1fa7d, 0x1fa80, 0x1fa89, 0x1fa90, 0x1fabe, 0x1fabf, 0x1fac6, 0x1face, 0x1fadc, 0x1fae0, 0x1fae9, 0x1faf0,
+    0x1faf9, 0x20000, 0x2fffe, 0x30000, 0x3fffe};
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // __MSVC_FORMAT_UCD_TABLES_HPP

miniMSVC/VC/Tools/MSVC/14.42.34433/include/__msvc_formatter.hpp

@@ -0,0 +1,373 @@
+// __msvc_formatter.hpp internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// NOTE:
+// The contents of this header are derived in part from libfmt under the following license:
+
+// Copyright (c) 2012 - present, Victor Zverovich
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+// --- Optional exception to the license ---
+//
+// As an exception, if, as a result of your compiling your source code, portions
+// of this Software are embedded into a machine-executable object form of such
+// source code, you may redistribute such embedded portions in such object form
+// without including the above copyright and permission notices.
+
+#ifndef __MSVC_FORMATTER_HPP
+#define __MSVC_FORMATTER_HPP
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX20
+#error The contents of <format> are only available with C++20. (Also, you should not include this internal header.)
+#endif // !_HAS_CXX20
+
+#include <concepts>
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+#if _HAS_CXX23
+#include <xutility>
+#endif // _HAS_CXX23
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+#if _HAS_CXX23
+#define _FMT_P2286_BEGIN inline namespace __p2286 {
+#define _FMT_P2286_END   }
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+#define _FMT_P2286_BEGIN
+#define _FMT_P2286_END
+#endif // ^^^ !_HAS_CXX23 ^^^
+
+enum class _Fmt_align : uint8_t { _None, _Left, _Right, _Center };
+
+enum class _Fmt_sign : uint8_t { _None, _Plus, _Minus, _Space };
+
+enum class _Basic_format_arg_type : uint8_t {
+    _None,
+    _Int_type,
+    _UInt_type,
+    _Long_long_type,
+    _ULong_long_type,
+    _Bool_type,
+    _Char_type,
+    _Float_type,
+    _Double_type,
+    _Long_double_type,
+    _Pointer_type,
+    _CString_type,
+    _String_type,
+    _Custom_type,
+};
+static_assert(static_cast<int>(_Basic_format_arg_type::_Custom_type) < 16, "must fit in 4-bit bitfield");
+
+#if _HAS_CXX23
+_NODISCARD consteval bool _Is_debug_enabled_fmt_type(_Basic_format_arg_type _Ty) {
+    return _Ty == _Basic_format_arg_type::_Char_type || _Ty == _Basic_format_arg_type::_CString_type
+        || _Ty == _Basic_format_arg_type::_String_type;
+}
+#endif // _HAS_CXX23
+
+template <class _CharT>
+struct _Basic_format_specs {
+    int _Width            = 0;
+    int _Precision        = -1;
+    char _Type            = '\0';
+    _Fmt_align _Alignment = _Fmt_align::_None;
+    _Fmt_sign _Sgn        = _Fmt_sign::_None;
+    bool _Alt             = false;
+    bool _Localized       = false;
+    bool _Leading_zero    = false;
+    uint8_t _Fill_length  = 1;
+    // At most one codepoint (so one char32_t or four utf-8 char8_t).
+    _CharT _Fill[4 / sizeof(_CharT)] = {_CharT{' '}};
+};
+
+// Adds width and precision references to _Basic_format_specs.
+// This is required for std::formatter implementations because we must
+// parse the format specs without having access to the format args (via a format context).
+template <class _CharT>
+struct _Dynamic_format_specs : _Basic_format_specs<_CharT> {
+    int _Dynamic_width_index     = -1;
+    int _Dynamic_precision_index = -1;
+};
+
+_EXPORT_STD template <class _CharT>
+class basic_format_parse_context;
+
+template <class _CharT>
+concept _Format_supported_charT = _Is_any_of_v<_CharT, char, wchar_t>;
+
+// Generic formatter definition, the deleted default constructor
+// makes it "disabled" as per N4950 [format.formatter.spec]/5
+_EXPORT_STD template <class _Ty, class _CharT = char>
+struct formatter {
+    formatter()                            = delete;
+    formatter(const formatter&)            = delete;
+    formatter& operator=(const formatter&) = delete;
+};
+
+_FMT_P2286_BEGIN
+// TRANSITION, VSO-1236041: Avoid declaring and defining member functions in different headers.
+template <_Basic_format_arg_type _ArgType, class _CharT, class _Pc>
+constexpr _Pc::iterator _Formatter_base_parse(_Dynamic_format_specs<_CharT>& _Specs, _Pc& _ParseCtx);
+
+template <class _Ty, class _CharT, class _FormatContext>
+_FormatContext::iterator _Formatter_base_format(
+    const _Dynamic_format_specs<_CharT>& _Specs, const _Ty& _Val, _FormatContext& _FormatCtx);
+
+template <class _Ty, class _CharT, _Basic_format_arg_type _ArgType>
+struct _Formatter_base {
+public:
+#if _HAS_CXX23
+    constexpr void _Set_debug_format() noexcept
+        requires (_Is_debug_enabled_fmt_type(_ArgType))
+    {
+        _Specs._Type = '?';
+    }
+#endif // _HAS_CXX23
+
+    template <class _Pc = basic_format_parse_context<_CharT>>
+    constexpr _Pc::iterator parse(type_identity_t<_Pc&> _ParseCtx) {
+        return _Formatter_base_parse<_ArgType>(_Specs, _ParseCtx);
+    }
+
+    template <class _FormatContext>
+    _FormatContext::iterator format(const _Ty& _Val, _FormatContext& _FormatCtx) const {
+        return _Formatter_base_format(_Specs, _Val, _FormatCtx);
+    }
+
+private:
+    _Dynamic_format_specs<_CharT> _Specs;
+};
+_FMT_P2286_END
+
+#define _FORMAT_SPECIALIZE_FOR(_Type, _ArgType) \
+    template <_Format_supported_charT _CharT>   \
+    struct formatter<_Type, _CharT> : _Formatter_base<_Type, _CharT, _ArgType> {}
+
+_FORMAT_SPECIALIZE_FOR(int, _Basic_format_arg_type::_Int_type);
+_FORMAT_SPECIALIZE_FOR(unsigned int, _Basic_format_arg_type::_UInt_type);
+_FORMAT_SPECIALIZE_FOR(long long, _Basic_format_arg_type::_Long_long_type);
+_FORMAT_SPECIALIZE_FOR(unsigned long long, _Basic_format_arg_type::_ULong_long_type);
+_FORMAT_SPECIALIZE_FOR(bool, _Basic_format_arg_type::_Bool_type);
+_FORMAT_SPECIALIZE_FOR(float, _Basic_format_arg_type::_Float_type);
+_FORMAT_SPECIALIZE_FOR(double, _Basic_format_arg_type::_Double_type);
+_FORMAT_SPECIALIZE_FOR(long double, _Basic_format_arg_type::_Long_double_type);
+_FORMAT_SPECIALIZE_FOR(nullptr_t, _Basic_format_arg_type::_Pointer_type);
+_FORMAT_SPECIALIZE_FOR(void*, _Basic_format_arg_type::_Pointer_type);
+_FORMAT_SPECIALIZE_FOR(const void*, _Basic_format_arg_type::_Pointer_type);
+_FORMAT_SPECIALIZE_FOR(short, _Basic_format_arg_type::_Int_type);
+_FORMAT_SPECIALIZE_FOR(unsigned short, _Basic_format_arg_type::_UInt_type);
+_FORMAT_SPECIALIZE_FOR(long, _Basic_format_arg_type::_Int_type);
+_FORMAT_SPECIALIZE_FOR(unsigned long, _Basic_format_arg_type::_UInt_type);
+_FORMAT_SPECIALIZE_FOR(signed char, _Basic_format_arg_type::_Int_type);
+_FORMAT_SPECIALIZE_FOR(unsigned char, _Basic_format_arg_type::_UInt_type);
+
+#undef _FORMAT_SPECIALIZE_FOR
+
+// not using the macro because we'd like to add 'set_debug_format' member function in C++23 mode
+template <_Format_supported_charT _CharT>
+struct formatter<char, _CharT> : _Formatter_base<char, _CharT, _Basic_format_arg_type::_Char_type> {
+#if _HAS_CXX23
+    constexpr void set_debug_format() noexcept {
+        this->_Set_debug_format();
+    }
+#endif // _HAS_CXX23
+};
+
+// not using the macro because we'd like to avoid the formatter<wchar_t, char> specialization
+template <>
+struct formatter<wchar_t, wchar_t> : _Formatter_base<wchar_t, wchar_t, _Basic_format_arg_type::_Char_type> {
+#if _HAS_CXX23
+    constexpr void set_debug_format() noexcept {
+        _Set_debug_format();
+    }
+#endif // _HAS_CXX23
+};
+
+// We could use the macro for these specializations, but it's confusing to refer to symbols that are defined
+// inside the macro in the macro's "call".
+template <_Format_supported_charT _CharT>
+struct formatter<_CharT*, _CharT> : _Formatter_base<_CharT*, _CharT, _Basic_format_arg_type::_CString_type> {
+#if _HAS_CXX23
+    constexpr void set_debug_format() noexcept {
+        this->_Set_debug_format();
+    }
+#endif // _HAS_CXX23
+};
+
+template <_Format_supported_charT _CharT>
+struct formatter<const _CharT*, _CharT>
+    : _Formatter_base<const _CharT*, _CharT, _Basic_format_arg_type::_CString_type> {
+#if _HAS_CXX23
+    constexpr void set_debug_format() noexcept {
+        this->_Set_debug_format();
+    }
+#endif // _HAS_CXX23
+};
+
+template <_Format_supported_charT _CharT, size_t _Nx>
+struct formatter<_CharT[_Nx], _CharT> : _Formatter_base<_CharT[_Nx], _CharT, _Basic_format_arg_type::_CString_type> {
+#if _HAS_CXX23
+    constexpr void set_debug_format() noexcept {
+        this->_Set_debug_format();
+    }
+#endif // _HAS_CXX23
+};
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+class basic_string;
+
+_EXPORT_STD template <class _Elem, class _Traits>
+class basic_string_view;
+
+template <_Format_supported_charT _CharT, class _Traits, class _Allocator>
+struct formatter<basic_string<_CharT, _Traits, _Allocator>, _CharT>
+    : _Formatter_base<basic_string<_CharT, _Traits, _Allocator>, _CharT, _Basic_format_arg_type::_String_type> {
+#if _HAS_CXX23
+    constexpr void set_debug_format() noexcept {
+        this->_Set_debug_format();
+    }
+#endif // _HAS_CXX23
+};
+
+template <_Format_supported_charT _CharT, class _Traits>
+struct formatter<basic_string_view<_CharT, _Traits>, _CharT>
+    : _Formatter_base<basic_string_view<_CharT, _Traits>, _CharT, _Basic_format_arg_type::_String_type> {
+#if _HAS_CXX23
+    constexpr void set_debug_format() noexcept {
+        this->_Set_debug_format();
+    }
+#endif // _HAS_CXX23
+};
+
+#if _HAS_CXX23
+template <>
+struct formatter<char*, wchar_t> {
+    formatter()                            = delete;
+    formatter(const formatter&)            = delete;
+    formatter& operator=(const formatter&) = delete;
+};
+
+template <>
+struct formatter<const char*, wchar_t> {
+    formatter()                            = delete;
+    formatter(const formatter&)            = delete;
+    formatter& operator=(const formatter&) = delete;
+};
+
+template <size_t _Size>
+struct formatter<char[_Size], wchar_t> {
+    formatter()                            = delete;
+    formatter(const formatter&)            = delete;
+    formatter& operator=(const formatter&) = delete;
+};
+
+template <class _Traits, class _Allocator>
+struct formatter<basic_string<char, _Traits, _Allocator>, wchar_t> {
+    formatter()                            = delete;
+    formatter(const formatter&)            = delete;
+    formatter& operator=(const formatter&) = delete;
+};
+
+template <class _Traits>
+struct formatter<basic_string_view<char, _Traits>, wchar_t> {
+    formatter()                            = delete;
+    formatter(const formatter&)            = delete;
+    formatter& operator=(const formatter&) = delete;
+};
+
+_EXPORT_STD enum class range_format { disabled, map, set, sequence, string, debug_string };
+
+template <class _Ty>
+struct _Invalid_format_kind {
+    static_assert(_Always_false<_Ty>, "A program that instantiates the primary template of format_kind is ill-formed. "
+                                      "(N4981 [format.range.fmtkind]/1)");
+};
+
+_EXPORT_STD template <class _Ty>
+constexpr _Invalid_format_kind<_Ty> format_kind;
+
+template <class _Ty>
+constexpr bool _Is_two_tuple = false;
+
+template <class _Ty, class _Uty>
+constexpr bool _Is_two_tuple<pair<_Ty, _Uty>> = true;
+
+template <class _Ty, class _Uty>
+constexpr bool _Is_two_tuple<tuple<_Ty, _Uty>> = true;
+
+template <_RANGES input_range _Rng>
+    requires same_as<_Rng, remove_cvref_t<_Rng>>
+constexpr range_format format_kind<_Rng> = []() consteval {
+    using _Ref_value_t = remove_cvref_t<_RANGES range_reference_t<_Rng>>;
+    if constexpr (same_as<_Ref_value_t, _Rng>) {
+        return range_format::disabled;
+    } else if constexpr (requires { typename _Rng::key_type; }) {
+        if constexpr (requires { typename _Rng::mapped_type; } && _Is_two_tuple<_Ref_value_t>) {
+            return range_format::map;
+        } else {
+            return range_format::set;
+        }
+    } else {
+        return range_format::sequence;
+    }
+}();
+
+// Specializations for pairs, tuples, and ranges are forward-declared to avoid any risk of using the disabled primary
+// template.
+
+// Per LWG-3997, `_CharT` in library-provided `formatter` specializations is
+// constrained to character types supported by `format`.
+
+template <class _Rng>
+concept _Formatting_enabled_range = format_kind<_Rng> != range_format::disabled;
+
+template <_RANGES input_range _Rng, _Format_supported_charT _CharT>
+    requires _Formatting_enabled_range<_Rng>
+struct formatter<_Rng, _CharT>;
+
+template <_Format_supported_charT _CharT, class _Ty1, class _Ty2>
+struct formatter<pair<_Ty1, _Ty2>, _CharT>;
+
+template <_Format_supported_charT _CharT, class... _Types>
+struct formatter<tuple<_Types...>, _CharT>;
+#endif // _HAS_CXX23
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // __MSVC_FORMATTER_HPP

miniMSVC/VC/Tools/MSVC/14.42.34433/include/system_error

@@ -0,0 +1,738 @@
+// system_error standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _SYSTEM_ERROR_
+#define _SYSTEM_ERROR_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <__msvc_system_error_abi.hpp>
+#include <cerrno>
+#include <cstdlib>
+#include <stdexcept>
+#include <xcall_once.h>
+#include <xerrc.h>
+#ifndef _M_CEE_PURE
+#include <atomic>
+#endif // !defined(_M_CEE_PURE)
+
+#if _HAS_CXX20
+#include <compare>
+#endif // _HAS_CXX20
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("noop_dtor")
+#undef msvc
+#undef noop_dtor
+
+_STD_BEGIN
+_EXPORT_STD enum class io_errc { // error codes for ios_base::failure
+    stream = 1
+};
+
+_EXPORT_STD template <class _Enum>
+struct is_error_code_enum : false_type {};
+
+template <>
+struct is_error_code_enum<io_errc> : true_type {};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_error_code_enum_v = is_error_code_enum<_Ty>::value;
+
+_EXPORT_STD template <class _Enum>
+struct is_error_condition_enum : false_type {};
+
+template <>
+struct is_error_condition_enum<errc> : true_type {};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_error_condition_enum_v = is_error_condition_enum<_Ty>::value;
+
+_EXPORT_STD class error_code;
+_EXPORT_STD class error_condition;
+
+namespace _Ensure_adl {
+    void make_error_code()      = delete;
+    void make_error_condition() = delete;
+} // namespace _Ensure_adl
+
+_EXPORT_STD class error_category;
+
+_EXPORT_STD _NODISCARD const error_category& generic_category() noexcept;
+_EXPORT_STD _NODISCARD const error_category& iostream_category() noexcept;
+_EXPORT_STD _NODISCARD const error_category& system_category() noexcept;
+
+_EXPORT_STD class __declspec(novtable) error_category { // categorize an error
+public:
+#ifdef _M_CEE_PURE
+    /* constexpr */ error_category() noexcept { // TRANSITION, ABI
+        _Addr = reinterpret_cast<uintptr_t>(this);
+    }
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+#pragma warning(push)
+#pragma warning(disable : 4355) // 'this': used in base member initializer list
+    constexpr error_category() noexcept : _Addr(this) {}
+#pragma warning(pop)
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+
+    _CONSTEXPR20 virtual ~error_category() noexcept = default;
+
+    _NODISCARD virtual const char* name() const noexcept = 0;
+
+    _NODISCARD virtual string message(int _Errval) const = 0;
+
+    _NODISCARD virtual error_condition default_error_condition(int _Errval) const noexcept;
+
+    _NODISCARD virtual bool equivalent(int _Errval, const error_condition& _Cond) const noexcept;
+
+    _NODISCARD virtual bool equivalent(const error_code& _Code, int _Errval) const noexcept;
+
+    _NODISCARD bool operator==(const error_category& _Right) const noexcept {
+#ifdef _M_CEE_PURE
+        return _Addr == _Right._Addr;
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+        return _Bit_cast<uintptr_t>(_Addr) == _Bit_cast<uintptr_t>(_Right._Addr);
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+    }
+
+#if _HAS_CXX20
+    _NODISCARD strong_ordering operator<=>(const error_category& _Right) const noexcept {
+        return _Bit_cast<uintptr_t>(_Addr) <=> _Bit_cast<uintptr_t>(_Right._Addr);
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD bool operator!=(const error_category& _Right) const noexcept {
+        return !(*this == _Right);
+    }
+
+    _NODISCARD bool operator<(const error_category& _Right) const noexcept {
+#ifdef _M_CEE_PURE
+        return _Addr < _Right._Addr;
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+        return _Bit_cast<uintptr_t>(_Addr) < _Bit_cast<uintptr_t>(_Right._Addr);
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    error_category(const error_category&)            = delete;
+    error_category& operator=(const error_category&) = delete;
+
+protected:
+#ifdef _M_CEE_PURE
+    uintptr_t _Addr;
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+    union _Addr_storage {
+    private:
+        uintptr_t _Num;
+        error_category* _Ptr;
+
+    public:
+        constexpr explicit _Addr_storage(const uintptr_t _Addr_num) noexcept : _Num(_Addr_num) {}
+        constexpr explicit _Addr_storage(error_category* const _Addr_ptr) noexcept : _Ptr(_Addr_ptr) {}
+
+        // TRANSITION: As of Boost 1.80.0, boost::system::detail::std_category assigns to _Addr.
+        constexpr _Addr_storage& operator=(const uintptr_t _Addr_num) noexcept {
+            _Num = _Addr_num;
+            return *this;
+        }
+    };
+    _STL_INTERNAL_STATIC_ASSERT(sizeof(_Addr_storage) == sizeof(uintptr_t));
+    _STL_INTERNAL_STATIC_ASSERT(alignof(_Addr_storage) == alignof(uintptr_t));
+
+    _Addr_storage _Addr;
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+
+    constexpr explicit error_category(const uintptr_t _Addr_) noexcept : _Addr(_Addr_) {}
+
+    enum : uintptr_t { // symbolic addresses for Standard error_category objects
+        _Future_addr   = 1,
+        _Generic_addr  = 3,
+        _Iostream_addr = 5,
+        _System_addr   = 7
+    };
+};
+
+#if _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS
+_NODISCARD inline bool _System_error_equal(const error_code&, const error_condition&) noexcept;
+#endif // _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS
+
+_EXPORT_STD class error_code { // store an implementation-specific error code and category
+public:
+    error_code() noexcept : _Myval(0), _Mycat(&_STD system_category()) {} // construct non-error
+
+    error_code(int _Val, const error_category& _Cat) noexcept : _Myval(_Val), _Mycat(&_Cat) {}
+
+    template <class _Enum, enable_if_t<is_error_code_enum_v<_Enum>, int> = 0>
+    error_code(_Enum _Errcode) noexcept : _Myval(0), _Mycat(nullptr) {
+        using _Ensure_adl::make_error_code;
+        *this = make_error_code(_Errcode); // intentional ADL
+    }
+
+    void assign(int _Val, const error_category& _Cat) noexcept {
+        _Myval = _Val;
+        _Mycat = &_Cat;
+    }
+
+    template <class _Enum, enable_if_t<is_error_code_enum_v<_Enum>, int> = 0>
+    error_code& operator=(_Enum _Errcode) noexcept {
+        using _Ensure_adl::make_error_code;
+        *this = make_error_code(_Errcode); // intentional ADL
+        return *this;
+    }
+
+    void clear() noexcept {
+        _Myval = 0;
+        _Mycat = &_STD system_category();
+    }
+
+    _NODISCARD int value() const noexcept {
+        return _Myval;
+    }
+
+    _NODISCARD const error_category& category() const noexcept {
+        return *_Mycat;
+    }
+
+    _NODISCARD error_condition default_error_condition() const noexcept;
+
+    _NODISCARD string message() const {
+        return category().message(value());
+    }
+
+    explicit operator bool() const noexcept {
+        return value() != 0;
+    }
+
+#if _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS
+    _NODISCARD friend bool operator==(const error_code& _Left, const error_code& _Right) noexcept {
+        return _Left.category() == _Right.category() && _Left.value() == _Right.value();
+    }
+
+    _NODISCARD friend bool operator==(const error_code& _Left, const error_condition& _Right) noexcept {
+        return _System_error_equal(_Left, _Right);
+    }
+
+#if _HAS_CXX20
+    _NODISCARD friend strong_ordering operator<=>(const error_code& _Left, const error_code& _Right) noexcept {
+        if (const auto _Result = _Left.category() <=> _Right.category(); _Result != 0) {
+            return _Result;
+        }
+        return _Left.value() <=> _Right.value();
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD friend bool operator<(const error_code& _Left, const error_code& _Right) noexcept {
+        return _Left.category() < _Right.category()
+            || (_Left.category() == _Right.category() && _Left.value() < _Right.value());
+    }
+    _NODISCARD friend bool operator==(const error_condition& _Left, const error_code& _Right) noexcept {
+        return _System_error_equal(_Right, _Left);
+    }
+
+    _NODISCARD friend bool operator!=(const error_code& _Left, const error_code& _Right) noexcept {
+        return !(_Left == _Right);
+    }
+
+    _NODISCARD friend bool operator!=(const error_code& _Left, const error_condition& _Right) noexcept {
+        return !_System_error_equal(_Left, _Right);
+    }
+
+    _NODISCARD friend bool operator!=(const error_condition& _Left, const error_code& _Right) noexcept {
+        return !_System_error_equal(_Right, _Left);
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+#endif // _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS
+
+private:
+    int _Myval; // the stored error number
+    const error_category* _Mycat; // pointer to error category
+};
+
+_EXPORT_STD class error_condition { // store an abstract error code and category
+public:
+    error_condition() noexcept : _Myval(0), _Mycat(&_STD generic_category()) {} // construct non-error
+
+    error_condition(int _Val, const error_category& _Cat) noexcept : _Myval(_Val), _Mycat(&_Cat) {}
+
+    template <class _Enum, enable_if_t<is_error_condition_enum_v<_Enum>, int> = 0>
+    error_condition(_Enum _Errcode) noexcept : _Myval(0), _Mycat(nullptr) {
+        using _Ensure_adl::make_error_condition;
+        *this = make_error_condition(_Errcode); // intentional ADL
+    }
+
+    void assign(int _Val, const error_category& _Cat) noexcept {
+        _Myval = _Val;
+        _Mycat = &_Cat;
+    }
+
+    template <class _Enum, enable_if_t<is_error_condition_enum_v<_Enum>, int> = 0>
+    error_condition& operator=(_Enum _Errcode) noexcept {
+        using _Ensure_adl::make_error_condition;
+        *this = make_error_condition(_Errcode); // intentional ADL
+        return *this;
+    }
+
+    void clear() noexcept {
+        _Myval = 0;
+        _Mycat = &_STD generic_category();
+    }
+
+    _NODISCARD int value() const noexcept {
+        return _Myval;
+    }
+
+    _NODISCARD const error_category& category() const noexcept {
+        return *_Mycat;
+    }
+
+    _NODISCARD string message() const {
+        return category().message(value());
+    }
+
+    explicit operator bool() const noexcept {
+        return value() != 0;
+    }
+
+#if _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS
+    _NODISCARD friend bool operator==(const error_condition& _Left, const error_condition& _Right) noexcept {
+        return _Left.category() == _Right.category() && _Left.value() == _Right.value();
+    }
+
+#if _HAS_CXX20
+    _NODISCARD friend strong_ordering operator<=>(
+        const error_condition& _Left, const error_condition& _Right) noexcept {
+        if (const auto _Result = _Left.category() <=> _Right.category(); _Result != 0) {
+            return _Result;
+        }
+        return _Left.value() <=> _Right.value();
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD friend bool operator<(const error_condition& _Left, const error_condition& _Right) noexcept {
+        return _Left.category() < _Right.category()
+            || (_Left.category() == _Right.category() && _Left.value() < _Right.value());
+    }
+    _NODISCARD friend bool operator!=(const error_condition& _Left, const error_condition& _Right) noexcept {
+        return !(_Left == _Right);
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    // We grant friendship to the operators from error_code here to allow is_error_code_enum_v but not
+    // is_error_condition_enum_v enums to be compared directly with error_condition; for example:
+    // io_errc::stream == make_error_condition(errc::out_of_memory)
+    friend bool operator==(const error_code& _Left, const error_condition& _Right) noexcept;
+#if !_HAS_CXX20
+    friend bool operator==(const error_condition& _Left, const error_code& _Right) noexcept;
+    friend bool operator!=(const error_code& _Left, const error_condition& _Right) noexcept;
+    friend bool operator!=(const error_condition& _Left, const error_code& _Right) noexcept;
+#endif // !_HAS_CXX20
+#endif // _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS
+
+private:
+    int _Myval; // the stored error number
+    const error_category* _Mycat; // pointer to error category
+};
+
+#if _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS
+_NODISCARD inline bool _System_error_equal(const error_code& _Left, const error_condition& _Right) noexcept {
+    return _Left.category().equivalent(_Left.value(), _Right) || _Right.category().equivalent(_Left, _Right.value());
+}
+#else // ^^^ _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS / !_STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS vvv
+_EXPORT_STD _NODISCARD inline bool operator==(const error_code& _Left, const error_code& _Right) noexcept {
+    return _Left.category() == _Right.category() && _Left.value() == _Right.value();
+}
+
+_EXPORT_STD _NODISCARD inline bool operator==(const error_code& _Left, const error_condition& _Right) noexcept {
+    return _Left.category().equivalent(_Left.value(), _Right) || _Right.category().equivalent(_Left, _Right.value());
+}
+
+_EXPORT_STD _NODISCARD inline bool operator==(const error_condition& _Left, const error_condition& _Right) noexcept {
+    return _Left.category() == _Right.category() && _Left.value() == _Right.value();
+}
+
+#if _HAS_CXX20
+_EXPORT_STD _NODISCARD inline strong_ordering operator<=>(const error_code& _Left, const error_code& _Right) noexcept {
+    if (const auto _Result = _Left.category() <=> _Right.category(); _Result != 0) {
+        return _Result;
+    }
+    return _Left.value() <=> _Right.value();
+}
+
+_EXPORT_STD _NODISCARD inline strong_ordering operator<=>(
+    const error_condition& _Left, const error_condition& _Right) noexcept {
+    if (const auto _Result = _Left.category() <=> _Right.category(); _Result != 0) {
+        return _Result;
+    }
+    return _Left.value() <=> _Right.value();
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+_NODISCARD inline bool operator<(const error_code& _Left, const error_code& _Right) noexcept {
+    return _Left.category() < _Right.category()
+        || (_Left.category() == _Right.category() && _Left.value() < _Right.value());
+}
+
+_NODISCARD inline bool operator<(const error_condition& _Left, const error_condition& _Right) noexcept {
+    return _Left.category() < _Right.category()
+        || (_Left.category() == _Right.category() && _Left.value() < _Right.value());
+}
+
+_NODISCARD inline bool operator==(const error_condition& _Left, const error_code& _Right) noexcept {
+    return _Right.category().equivalent(_Right.value(), _Left) || _Left.category().equivalent(_Right, _Left.value());
+}
+
+_NODISCARD inline bool operator!=(const error_code& _Left, const error_code& _Right) noexcept {
+    return !(_Left == _Right);
+}
+
+_NODISCARD inline bool operator!=(const error_code& _Left, const error_condition& _Right) noexcept {
+    return !(_Left == _Right);
+}
+
+_NODISCARD inline bool operator!=(const error_condition& _Left, const error_code& _Right) noexcept {
+    return !(_Left == _Right);
+}
+
+_NODISCARD inline bool operator!=(const error_condition& _Left, const error_condition& _Right) noexcept {
+    return !(_Left == _Right);
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+#endif // ^^^ !_STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS ^^^
+
+_NODISCARD inline error_condition error_category::default_error_condition(int _Errval) const noexcept {
+    // make error_condition for error code
+    return error_condition(_Errval, *this);
+}
+
+_NODISCARD inline bool error_category::equivalent(int _Errval, const error_condition& _Cond) const noexcept {
+    return default_error_condition(_Errval) == _Cond;
+}
+
+_NODISCARD inline bool error_category::equivalent(const error_code& _Code, int _Errval) const noexcept {
+    return *this == _Code.category() && _Code.value() == _Errval;
+}
+
+_NODISCARD inline error_condition error_code::default_error_condition() const noexcept {
+    // make error_condition for error code
+    return category().default_error_condition(value());
+}
+
+_EXPORT_STD _NODISCARD inline error_code make_error_code(errc _Ec) noexcept {
+    return error_code(static_cast<int>(_Ec), _STD generic_category());
+}
+
+_EXPORT_STD _NODISCARD inline error_code make_error_code(io_errc _Ec) noexcept {
+    return error_code(static_cast<int>(_Ec), _STD iostream_category());
+}
+
+_EXPORT_STD _NODISCARD inline error_condition make_error_condition(errc _Ec) noexcept {
+    return error_condition(static_cast<int>(_Ec), _STD generic_category());
+}
+
+_EXPORT_STD _NODISCARD inline error_condition make_error_condition(io_errc _Ec) noexcept {
+    return error_condition(static_cast<int>(_Ec), _STD iostream_category());
+}
+
+template <>
+struct hash<error_code> {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = error_code;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
+
+    _NODISCARD _STATIC_CALL_OPERATOR size_t operator()(const error_code& _Keyval) _CONST_CALL_OPERATOR noexcept {
+        return hash<int>{}(_Keyval.value());
+    }
+};
+
+template <>
+struct hash<error_condition> {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = error_condition;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
+
+    _NODISCARD _STATIC_CALL_OPERATOR size_t operator()(const error_condition& _Keyval) _CONST_CALL_OPERATOR noexcept {
+        return hash<int>{}(_Keyval.value());
+    }
+};
+
+class _System_error : public runtime_error { // base of all system-error exceptions
+private:
+    static string _Makestr(error_code _Errcode, string _Message) { // compose error message
+        if (!_Message.empty()) {
+            _Message.append(": ");
+        }
+
+        _Message.append(_Errcode.message());
+        return _Message;
+    }
+
+protected:
+    _System_error(error_code _Errcode) : runtime_error(_Errcode.message()), _Mycode(_Errcode) {}
+
+    _System_error(error_code _Errcode, const string& _Message)
+        : runtime_error(_Makestr(_Errcode, _Message)), _Mycode(_Errcode) {}
+
+    error_code _Mycode; // the stored error code
+};
+
+_EXPORT_STD class system_error : public _System_error { // base of all system-error exceptions
+private:
+    using _Mybase = _System_error;
+
+public:
+    system_error(error_code _Errcode) : _Mybase(_Errcode) {}
+
+    system_error(error_code _Errcode, const string& _Message) : _Mybase(_Errcode, _Message) {}
+
+    system_error(error_code _Errcode, const char* _Message) : _Mybase(_Errcode, _Message) {}
+
+    system_error(int _Errval, const error_category& _Errcat) : _Mybase(error_code(_Errval, _Errcat)) {}
+
+    system_error(int _Errval, const error_category& _Errcat, const string& _Message)
+        : _Mybase(error_code(_Errval, _Errcat), _Message) {}
+
+    system_error(int _Errval, const error_category& _Errcat, const char* _Message)
+        : _Mybase(error_code(_Errval, _Errcat), _Message) {}
+
+    _NODISCARD const error_code& code() const noexcept {
+        return _Mycode;
+    }
+
+#if !_HAS_EXCEPTIONS
+protected:
+    void _Doraise() const override { // perform class-specific exception handling
+        _RAISE(*this);
+    }
+#endif // !_HAS_EXCEPTIONS
+};
+
+[[noreturn]] inline void _Throw_system_error(const errc _Ec) {
+    _THROW(system_error{_STD make_error_code(_Ec)});
+}
+
+extern "C++" _CRTIMP2_PURE const char* __CLRCALL_PURE_OR_CDECL _Syserror_map(int);
+extern "C++" _CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Winerror_map(int);
+
+struct _System_error_message {
+    char* _Str;
+    size_t _Length;
+
+    explicit _System_error_message(const unsigned long _Ec) noexcept
+        : _Str(nullptr), _Length(_CSTD __std_system_error_allocate_message(_Ec, &_Str)) {}
+
+    _System_error_message(const _System_error_message&)            = delete;
+    _System_error_message& operator=(const _System_error_message&) = delete;
+
+    ~_System_error_message() {
+        _CSTD __std_system_error_deallocate_message(_Str);
+    }
+};
+
+class _Generic_error_category : public error_category { // categorize a generic error
+public:
+    constexpr _Generic_error_category() noexcept : error_category(_Generic_addr) {}
+
+    _NODISCARD const char* name() const noexcept override {
+        return "generic";
+    }
+
+    _NODISCARD string message(int _Errcode) const override {
+        return _Syserror_map(_Errcode);
+    }
+};
+
+class _Iostream_error_category2 : public error_category { // categorize an iostream error
+public:
+    constexpr _Iostream_error_category2() noexcept : error_category(_Iostream_addr) {}
+
+    _NODISCARD const char* name() const noexcept override {
+        return "iostream";
+    }
+
+    _NODISCARD string message(int _Errcode) const override {
+        if (_Errcode == static_cast<int>(io_errc::stream)) {
+            static constexpr char _Iostream_error[] = "iostream stream error";
+            constexpr size_t _Iostream_error_length = sizeof(_Iostream_error) - 1; // TRANSITION, DevCom-906503
+            return string{_Iostream_error, _Iostream_error_length};
+        } else {
+            return _Syserror_map(_Errcode);
+        }
+    }
+};
+
+class _System_error_category : public error_category { // categorize an operating system error
+public:
+    constexpr _System_error_category() noexcept : error_category(_System_addr) {}
+
+    _NODISCARD const char* name() const noexcept override {
+        return "system";
+    }
+
+    _NODISCARD string message(int _Errcode) const override {
+        const _System_error_message _Msg(static_cast<unsigned long>(_Errcode));
+
+        if (_Msg._Str && _Msg._Length != 0) {
+            // CodeQL [SM02310] _Msg's ctor inits _Str(nullptr) before doing work, then we test _Msg._Str above.
+            return string{_Msg._Str, _Msg._Length};
+        } else {
+            static constexpr char _Unknown_error[] = "unknown error";
+            constexpr size_t _Unknown_error_length = sizeof(_Unknown_error) - 1; // TRANSITION, DevCom-906503
+            return string{_Unknown_error, _Unknown_error_length};
+        }
+    }
+
+    _NODISCARD error_condition default_error_condition(int _Errval) const noexcept override {
+        if (_Errval == 0) {
+            return error_condition(0, _STD generic_category());
+        }
+
+        // make error_condition for error code (generic if possible)
+        const int _Posv = _Winerror_map(_Errval);
+        if (_Posv == 0) {
+            return error_condition(_Errval, _STD system_category());
+        } else {
+            return error_condition(_Posv, _STD generic_category());
+        }
+    }
+};
+
+// _Immortalize_memcpy_image is used to provide a nonstandard guarantee.
+// Specifically, we want the error category objects returned from things like std::system_category() to always
+//   be available, even during DLL unload (otherwise, <system_error> would be a huge regression vs. legacy error codes).
+// Moreover, we need to be very conservative in the runtime support we request. Thus, we have these constraints:
+//
+// * can't use magic statics in standard modes, because that would inject a .TLS section into all binaries using
+//   <system_error> and would likely put borderline programs over the TLS slot count limit, and would destroy the
+//   variable during DLL unload
+// * can't declare the error_category as an ordinary constexpr variable for most compilers before C++20, because
+//   error_category has a virtual destructor
+// * can't declare the error_category as an ordinary non-constexpr variable even with a constexpr constructor, because
+//   the compiler will emit code to destroy it which invalidates its use in these DLL shutdown scenarios
+//
+// As a result, we use a workaround: We create an atomic<uintptr_t> array to store the error_category instance, test
+//   if the first atomic is nonzero (acquire), and if so, we know we have formed the instance and can return a
+//   reinterpreted pointer to that storage. If the first atomic is zero, we write all except the first atomic (relaxed),
+//   then write the first one as a store-release. (The non-first values are transferred to other threads in the
+//   release sequence).
+//
+// Acknowledged undefined and implementation-defined behavior happening here:
+// * There is a data race when filling in the values other than the first atomic; this is OK on all hardware we target
+//   because the racing threads are all writing identical values that never change afterwards.
+// * We are reaching into the layout of atomic<uintptr_t>[N] and assuming we can reinterpret that as some other type.
+// * We are assuming that virtual functions are implemented with a vfptr located as the first member of an object.
+// (there are probably others)
+//
+// Inspecting the resulting assembly of any callers of _Immortalize_memcpy_image is recommended.
+//
+
+#if defined(_M_CEE_PURE)
+// /clr:pure doesn't ever do constant initialization, so rely on the CLR and magic statics
+template <class _Ty>
+_NODISCARD const _Ty& _Immortalize_memcpy_image() noexcept {
+    /* MAGIC */ static _Immortalizer_impl<_Ty> _Static;
+    return _Static._Storage;
+}
+#elif _HAS_CXX20
+template <class _Ty>
+_NODISCARD const _Ty& _Immortalize_memcpy_image() noexcept {
+    static constexpr _Ty _Static;
+    return _Static;
+}
+#elif defined(__clang__)
+template <class _Ty>
+_NODISCARD const _Ty& _Immortalize_memcpy_image() noexcept {
+    [[_Clang::__require_constant_initialization__]] static _Ty _Static;
+    return _Static;
+}
+#elif !defined(_M_CEE)
+template <class _Ty>
+struct _Constexpr_immortalize_impl {
+    union {
+        _Ty _Storage;
+    };
+
+    constexpr _Constexpr_immortalize_impl() noexcept : _Storage{} {}
+
+    _Constexpr_immortalize_impl(const _Constexpr_immortalize_impl&)            = delete;
+    _Constexpr_immortalize_impl& operator=(const _Constexpr_immortalize_impl&) = delete;
+
+    _MSVC_NOOP_DTOR ~_Constexpr_immortalize_impl() {
+        // do nothing, allowing _Ty to be used during shutdown
+    }
+};
+
+template <class _Ty>
+_NODISCARD const _Ty& _Immortalize_memcpy_image() noexcept {
+    static _Constexpr_immortalize_impl<_Ty> _Static;
+    return _Static._Storage;
+}
+#else // ^^^ !defined(_M_CEE) / defined(_M_CEE), TRANSITION, VSO-1153256 vvv
+template <class _Ty>
+_NODISCARD const _Ty& _Immortalize_memcpy_image() noexcept {
+    // return reference to a memcpy'd default-initialized _Ty
+    // pre: A default-initialized _Ty sets the first pointer-sized field to nonzero
+    constexpr size_t _Pointer_count = sizeof(_Ty) / sizeof(uintptr_t);
+    static atomic<uintptr_t> _Storage[_Pointer_count];
+    static_assert(sizeof(_Storage) == sizeof(_Ty), "Bad storage size");
+    static_assert(alignof(decltype(_Storage)) >= alignof(_Ty), "Bad alignment assumptions");
+    if (_Storage[0].load(memory_order_acquire) != 0) {
+        return reinterpret_cast<_Ty&>(_Storage);
+    }
+
+    const _Ty _Target;
+    const auto _Target_iter = reinterpret_cast<const uintptr_t*>(_STD addressof(_Target));
+    _CSTD memcpy(_Storage + 1, _Target_iter + 1, sizeof(_Ty) - sizeof(uintptr_t));
+    _Storage[0].store(_Target_iter[0], memory_order_release);
+    return reinterpret_cast<_Ty&>(_Storage);
+}
+#endif // ^^^ defined(_M_CEE), TRANSITION, VSO-1153256 ^^^
+
+_EXPORT_STD _NODISCARD inline const error_category& generic_category() noexcept {
+    return _Immortalize_memcpy_image<_Generic_error_category>();
+}
+
+_EXPORT_STD _NODISCARD inline const error_category& iostream_category() noexcept {
+    return _Immortalize_memcpy_image<_Iostream_error_category2>();
+}
+
+_EXPORT_STD _NODISCARD inline const error_category& system_category() noexcept {
+    return _Immortalize_memcpy_image<_System_error_category>();
+}
+_STD_END
+
+#if _HAS_CXX17
+extern "C" {
+enum class __std_win_error : unsigned long;
+} // extern "C"
+
+_STD_BEGIN
+// We would really love to use the proper way of building error_code by specializing
+// is_error_code_enum and make_error_code for __std_win_error, but because:
+//   1. We would like to keep the definition of __std_win_error in xfilesystem_abi.h
+//   2. and xfilesystem_abi.h cannot include <system_error>
+//   3. and specialization of is_error_code_enum and overload of make_error_code
+//      need to be kept together with the enum (see limerick in N4950 [temp.expl.spec]/8)
+// we resort to using this _Make_ec helper.
+_NODISCARD inline error_code _Make_ec(__std_win_error _Errno) noexcept { // make an error_code
+    return {static_cast<int>(_Errno), _STD system_category()};
+}
+
+[[noreturn]] inline void _Throw_system_error_from_std_win_error(const __std_win_error _Errno) {
+    _THROW(system_error{_Make_ec(_Errno)});
+}
+_STD_END
+#endif // _HAS_CXX17
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("noop_dtor")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _SYSTEM_ERROR_

miniMSVC/VC/Tools/MSVC/14.42.34433/include/thread

@@ -0,0 +1,446 @@
+// thread standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _THREAD_
+#define _THREAD_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#ifdef _M_CEE_PURE
+#error <thread> is not supported when compiling with /clr:pure.
+#endif // defined(_M_CEE_PURE)
+
+#include <__msvc_chrono.hpp>
+#include <memory>
+#include <process.h>
+#include <tuple>
+#include <xthreads.h>
+
+#if _HAS_CXX20
+#include <compare>
+#include <stop_token>
+#endif // _HAS_CXX20
+
+#if _HAS_CXX23
+#include <format>
+#endif // _HAS_CXX23
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+#if _HAS_CXX20
+_EXPORT_STD class jthread;
+#endif // _HAS_CXX20
+
+_EXPORT_STD class thread { // class for observing and managing threads
+public:
+    class id;
+
+    using native_handle_type = void*;
+
+    thread() noexcept : _Thr{} {}
+
+private:
+#if _HAS_CXX20
+    friend jthread;
+#endif // _HAS_CXX20
+
+    template <class _Tuple, size_t... _Indices>
+    static unsigned int __stdcall _Invoke(void* _RawVals) noexcept /* terminates */ {
+        // adapt invoke of user's callable object to _beginthreadex's thread procedure
+        const unique_ptr<_Tuple> _FnVals(static_cast<_Tuple*>(_RawVals));
+        _Tuple& _Tup = *_FnVals.get(); // avoid ADL, handle incomplete types
+        _STD invoke(_STD move(_STD get<_Indices>(_Tup))...);
+        _Cnd_do_broadcast_at_thread_exit(); // TRANSITION, ABI
+        return 0;
+    }
+
+    template <class _Tuple, size_t... _Indices>
+    _NODISCARD static constexpr auto _Get_invoke(index_sequence<_Indices...>) noexcept {
+        return &_Invoke<_Tuple, _Indices...>;
+    }
+
+#pragma warning(push) // pointer or reference to potentially throwing function passed to 'extern "C"' function under
+#pragma warning(disable : 5039) // -EHc. Undefined behavior may occur if this function throws an exception. (/Wall)
+    template <class _Fn, class... _Args>
+    void _Start(_Fn&& _Fx, _Args&&... _Ax) {
+        using _Tuple                 = tuple<decay_t<_Fn>, decay_t<_Args>...>;
+        auto _Decay_copied           = _STD make_unique<_Tuple>(_STD forward<_Fn>(_Fx), _STD forward<_Args>(_Ax)...);
+        constexpr auto _Invoker_proc = _Get_invoke<_Tuple>(make_index_sequence<1 + sizeof...(_Args)>{});
+
+        _Thr._Hnd =
+            reinterpret_cast<void*>(_CSTD _beginthreadex(nullptr, 0, _Invoker_proc, _Decay_copied.get(), 0, &_Thr._Id));
+
+        if (_Thr._Hnd) { // ownership transferred to the thread
+            (void) _Decay_copied.release();
+        } else { // failed to start thread
+            _Thr._Id = 0;
+            _Throw_Cpp_error(_RESOURCE_UNAVAILABLE_TRY_AGAIN);
+        }
+    }
+#pragma warning(pop)
+
+public:
+    template <class _Fn, class... _Args, enable_if_t<!is_same_v<_Remove_cvref_t<_Fn>, thread>, int> = 0>
+    _NODISCARD_CTOR_THREAD explicit thread(_Fn&& _Fx, _Args&&... _Ax) {
+        _Start(_STD forward<_Fn>(_Fx), _STD forward<_Args>(_Ax)...);
+    }
+
+    ~thread() noexcept {
+        if (joinable()) {
+            _STD terminate(); // per N4950 [thread.thread.destr]/1
+        }
+    }
+
+    thread(thread&& _Other) noexcept : _Thr(_STD exchange(_Other._Thr, {})) {}
+
+    thread& operator=(thread&& _Other) noexcept {
+        if (joinable()) {
+            _STD terminate(); // per N4950 [thread.thread.assign]/1
+        }
+
+        _Thr = _STD exchange(_Other._Thr, {});
+        return *this;
+    }
+
+    thread(const thread&)            = delete;
+    thread& operator=(const thread&) = delete;
+
+    void swap(thread& _Other) noexcept {
+        _STD swap(_Thr, _Other._Thr);
+    }
+
+    _NODISCARD bool joinable() const noexcept {
+        return _Thr._Id != 0;
+    }
+
+    void join() {
+        if (!joinable()) {
+            _Throw_Cpp_error(_INVALID_ARGUMENT);
+        }
+
+        if (_Thr._Id == _Thrd_id()) {
+            _Throw_Cpp_error(_RESOURCE_DEADLOCK_WOULD_OCCUR);
+        }
+
+        if (_Thrd_join(_Thr, nullptr) != _Thrd_result::_Success) {
+            _Throw_Cpp_error(_NO_SUCH_PROCESS);
+        }
+
+        _Thr = {};
+    }
+
+    void detach() {
+        if (!joinable()) {
+            _Throw_Cpp_error(_INVALID_ARGUMENT);
+        }
+
+        if (_Thrd_detach(_Thr) != _Thrd_result::_Success) {
+            _Throw_Cpp_error(_INVALID_ARGUMENT);
+        }
+
+        _Thr = {};
+    }
+
+    _NODISCARD id get_id() const noexcept;
+
+    _NODISCARD native_handle_type native_handle() noexcept /* strengthened */ { // return Win32 HANDLE as void *
+        return _Thr._Hnd;
+    }
+
+    _NODISCARD static unsigned int hardware_concurrency() noexcept {
+        return _Thrd_hardware_concurrency();
+    }
+
+private:
+    _Thrd_t _Thr;
+};
+
+template <class _Rep, class _Period>
+_NODISCARD auto _To_absolute_time(const chrono::duration<_Rep, _Period>& _Rel_time) noexcept {
+    constexpr auto _Zero                 = chrono::duration<_Rep, _Period>::zero();
+    const auto _Now                      = chrono::steady_clock::now();
+    decltype(_Now + _Rel_time) _Abs_time = _Now; // return common type
+    if (_Rel_time > _Zero) {
+        constexpr auto _Forever = (chrono::steady_clock::time_point::max)();
+        if (_Abs_time < _Forever - _Rel_time) {
+            _Abs_time += _Rel_time;
+        } else {
+            _Abs_time = _Forever;
+        }
+    }
+    return _Abs_time;
+}
+
+struct _Clamped_rel_time_ms_count_result {
+    unsigned long _Count;
+    bool _Clamped;
+};
+
+template <class _Duration>
+_NODISCARD _Clamped_rel_time_ms_count_result _Clamped_rel_time_ms_count(const _Duration& _Rel) {
+    // _Clamp must be less than 2^32 - 1 (INFINITE) milliseconds, but is otherwise arbitrary.
+    constexpr chrono::milliseconds _Clamp{chrono::hours{24}};
+
+    if (_Rel > _Clamp) {
+        return {static_cast<unsigned long>(_Clamp.count()), true};
+    } else {
+        const auto _Rel_ms = chrono::ceil<chrono::milliseconds>(_Rel);
+        return {static_cast<unsigned long>(_Rel_ms.count()), false};
+    }
+}
+
+namespace this_thread {
+    _EXPORT_STD _NODISCARD thread::id get_id() noexcept;
+
+    _EXPORT_STD inline void yield() noexcept {
+        _Thrd_yield();
+    }
+
+    _EXPORT_STD template <class _Clock, class _Duration>
+    void sleep_until(const chrono::time_point<_Clock, _Duration>& _Abs_time) {
+        static_assert(chrono::_Is_clock_v<_Clock>, "Clock type required");
+        for (;;) {
+            const auto _Now = _Clock::now();
+            if (_Abs_time <= _Now) {
+                return;
+            }
+
+            const unsigned long _Rel_ms_count = _Clamped_rel_time_ms_count(_Abs_time - _Now)._Count;
+            _Thrd_sleep_for(_Rel_ms_count);
+        }
+    }
+
+    _EXPORT_STD template <class _Rep, class _Period>
+    void sleep_for(const chrono::duration<_Rep, _Period>& _Rel_time) {
+        sleep_until(_To_absolute_time(_Rel_time));
+    }
+} // namespace this_thread
+
+class thread::id { // thread id
+public:
+    id() noexcept = default; // id for no thread
+
+#if _HAS_CXX23
+    _NODISCARD _Thrd_id_t _Get_underlying_id() const noexcept {
+        return _Id;
+    }
+#endif // _HAS_CXX23
+
+private:
+    explicit id(_Thrd_id_t _Other_id) noexcept : _Id(_Other_id) {}
+
+    _Thrd_id_t _Id = 0;
+
+    friend thread::id thread::get_id() const noexcept;
+    friend thread::id this_thread::get_id() noexcept;
+    friend bool operator==(thread::id _Left, thread::id _Right) noexcept;
+#if _HAS_CXX20
+    friend strong_ordering operator<=>(thread::id _Left, thread::id _Right) noexcept;
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    friend bool operator<(thread::id _Left, thread::id _Right) noexcept;
+#endif // ^^^ !_HAS_CXX20 ^^^
+    template <class _Ch, class _Tr>
+    friend basic_ostream<_Ch, _Tr>& operator<<(basic_ostream<_Ch, _Tr>& _Str, thread::id _Id);
+    friend hash<thread::id>;
+};
+
+_NODISCARD inline thread::id thread::get_id() const noexcept {
+    return thread::id{_Thr._Id};
+}
+
+_EXPORT_STD _NODISCARD inline thread::id this_thread::get_id() noexcept {
+    return thread::id{_Thrd_id()};
+}
+
+_EXPORT_STD inline void swap(thread& _Left, thread& _Right) noexcept {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD _NODISCARD inline bool operator==(thread::id _Left, thread::id _Right) noexcept {
+    return _Left._Id == _Right._Id;
+}
+
+#if _HAS_CXX20
+_EXPORT_STD _NODISCARD inline strong_ordering operator<=>(thread::id _Left, thread::id _Right) noexcept {
+    return _Left._Id <=> _Right._Id;
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+_NODISCARD inline bool operator!=(thread::id _Left, thread::id _Right) noexcept {
+    return !(_Left == _Right);
+}
+
+_NODISCARD inline bool operator<(thread::id _Left, thread::id _Right) noexcept {
+    return _Left._Id < _Right._Id;
+}
+
+_NODISCARD inline bool operator<=(thread::id _Left, thread::id _Right) noexcept {
+    return !(_Right < _Left);
+}
+
+_NODISCARD inline bool operator>(thread::id _Left, thread::id _Right) noexcept {
+    return _Right < _Left;
+}
+
+_NODISCARD inline bool operator>=(thread::id _Left, thread::id _Right) noexcept {
+    return !(_Left < _Right);
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+_EXPORT_STD template <class _Ch, class _Tr>
+basic_ostream<_Ch, _Tr>& operator<<(basic_ostream<_Ch, _Tr>& _Str, thread::id _Id) {
+    _STL_INTERNAL_STATIC_ASSERT(sizeof(_Thrd_id_t) == 4);
+    _Ch _Buff[11]; // can hold 2^32 - 1, plus terminating null
+    _Ch* _RNext = _STD end(_Buff);
+    *--_RNext   = static_cast<_Ch>('\0');
+    _RNext      = _STD _UIntegral_to_buff(_RNext, _Id._Id);
+    return _Str << _RNext;
+}
+
+#if _HAS_CXX23
+// Per LWG-3997, `_CharT` in library-provided `formatter` specializations is
+// constrained to character types supported by `format`.
+template <_Format_supported_charT _CharT>
+struct formatter<thread::id, _CharT> {
+private:
+    using _Pc = basic_format_parse_context<_CharT>;
+
+public:
+    constexpr _Pc::iterator parse(_Pc& _Parse_ctx) {
+        return _Impl._Parse(_Parse_ctx);
+    }
+
+    template <class _FormatContext>
+    _FormatContext::iterator format(thread::id _Val, _FormatContext& _Format_ctx) const {
+        _STL_INTERNAL_STATIC_ASSERT(sizeof(_Thrd_id_t) == 4);
+        _CharT _Buff[10]; // can hold 2^32 - 1
+        _CharT* const _Last        = _STD end(_Buff);
+        const _CharT* const _First = _STD _UIntegral_to_buff(_Last, _Val._Get_underlying_id());
+        return _Impl._Format(_Format_ctx, static_cast<int>(_Last - _First), _Fmt_align::_Right,
+            [&](_FormatContext::iterator _Out) { return _RANGES copy(_First, _Last, _STD move(_Out)).out; });
+    }
+
+private:
+    _Fill_align_and_width_formatter<_CharT> _Impl;
+};
+#endif // _HAS_CXX23
+
+template <>
+struct hash<thread::id> {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = thread::id;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
+
+    _NODISCARD _STATIC_CALL_OPERATOR size_t operator()(const thread::id _Keyval) _CONST_CALL_OPERATOR noexcept {
+        return _Hash_representation(_Keyval._Id);
+    }
+};
+
+#if _HAS_CXX20
+_EXPORT_STD class jthread {
+public:
+    using id                 = thread::id;
+    using native_handle_type = thread::native_handle_type;
+
+    jthread() noexcept : _Impl{}, _Ssource{nostopstate} {}
+
+    template <class _Fn, class... _Args>
+        requires (!is_same_v<remove_cvref_t<_Fn>, jthread>)
+    _NODISCARD_CTOR_JTHREAD explicit jthread(_Fn&& _Fx, _Args&&... _Ax) {
+        if constexpr (is_invocable_v<decay_t<_Fn>, stop_token, decay_t<_Args>...>) {
+            _Impl._Start(_STD forward<_Fn>(_Fx), _Ssource.get_token(), _STD forward<_Args>(_Ax)...);
+        } else {
+            _Impl._Start(_STD forward<_Fn>(_Fx), _STD forward<_Args>(_Ax)...);
+        }
+    }
+
+    ~jthread() {
+        _Try_cancel_and_join();
+    }
+
+    jthread(const jthread&)            = delete;
+    jthread(jthread&&) noexcept        = default;
+    jthread& operator=(const jthread&) = delete;
+
+    jthread& operator=(jthread&& _Other) noexcept {
+        if (this == _STD addressof(_Other)) {
+            return *this;
+        }
+
+        _Try_cancel_and_join();
+        _Impl    = _STD move(_Other._Impl);
+        _Ssource = _STD move(_Other._Ssource);
+        return *this;
+    }
+
+    void swap(jthread& _Other) noexcept {
+        _Impl.swap(_Other._Impl);
+        _Ssource.swap(_Other._Ssource);
+    }
+
+    _NODISCARD bool joinable() const noexcept {
+        return _Impl.joinable();
+    }
+
+    void join() {
+        _Impl.join();
+    }
+
+    void detach() {
+        _Impl.detach();
+    }
+
+    _NODISCARD id get_id() const noexcept {
+        return _Impl.get_id();
+    }
+
+    _NODISCARD native_handle_type native_handle() noexcept /* strengthened */ {
+        return _Impl.native_handle();
+    }
+
+    _NODISCARD stop_source get_stop_source() noexcept {
+        return _Ssource;
+    }
+
+    _NODISCARD stop_token get_stop_token() const noexcept {
+        return _Ssource.get_token();
+    }
+
+    bool request_stop() noexcept {
+        return _Ssource.request_stop();
+    }
+
+    friend void swap(jthread& _Lhs, jthread& _Rhs) noexcept {
+        _Lhs.swap(_Rhs);
+    }
+
+    _NODISCARD static unsigned int hardware_concurrency() noexcept {
+        return thread::hardware_concurrency();
+    }
+
+private:
+    void _Try_cancel_and_join() noexcept {
+        if (_Impl.joinable()) {
+            _Ssource.request_stop();
+            _Impl.join();
+        }
+    }
+
+    thread _Impl;
+    stop_source _Ssource;
+};
+#endif // _HAS_CXX20
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _THREAD_

miniMSVC/VC/Tools/MSVC/14.42.34433/include/threads.h

@@ -0,0 +1,146 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+
+#pragma once
+#define _THREADS_H
+
+#include <vcruntime.h>
+#include <corecrt.h>
+#include <stdint.h>
+#include <time.h>
+
+#pragma warning(push)
+#pragma warning(disable : _UCRT_DISABLED_WARNINGS)
+_UCRT_DISABLE_CLANG_WARNINGS
+_CRT_BEGIN_C_HEADER
+
+#ifndef __cplusplus
+#define thread_local _Thread_local
+#endif
+
+enum {
+    mtx_plain     = 0,
+    mtx_recursive = 1 << 0,
+    mtx_timed     = 1 << 1,
+};
+
+typedef struct {
+    uintptr_t _Type;
+    void* _Ptr;
+    void* _Cv;
+    uint32_t _Owner;
+    uint32_t _Cnt;
+} mtx_t;
+
+void __cdecl mtx_destroy(mtx_t* _Mtx);
+int __cdecl mtx_init(_Out_ mtx_t* _Mtx, int _Type);
+_Acquires_lock_(*_Mtx) int __cdecl mtx_lock(mtx_t* _Mtx);
+
+int __cdecl _mtx_timedlock32(
+    mtx_t* __restrict _Mtx, const struct _timespec32* __restrict _Ts);
+int __cdecl _mtx_timedlock64(
+    mtx_t* __restrict _Mtx, const struct _timespec64* __restrict _Ts);
+
+#ifndef _CRT_NO_TIME_T
+#ifdef _USE_32BIT_TIME_T
+static inline int __cdecl mtx_timedlock(mtx_t* __restrict _Mtx, const struct timespec* __restrict _Ts) {
+    return _mtx_timedlock32(_Mtx, (struct _timespec32*) _Ts);
+}
+#else // ^^^ _CRT_32BIT_TIME_T / vvv 64-bit
+static inline int __cdecl mtx_timedlock(mtx_t* __restrict _Mtx, const struct timespec* __restrict _Ts) {
+    return _mtx_timedlock64(_Mtx, (struct _timespec64*) _Ts);
+}
+#endif // _CRT_32BIT_TIME_T
+#endif // _CRT_NO_TIME_T
+
+int __cdecl mtx_trylock(mtx_t* _Mtx);
+
+_Releases_lock_(*_Mtx) int __cdecl mtx_unlock(mtx_t* _Mtx);
+
+typedef struct {
+    void* _Ptr;
+} cnd_t;
+
+int __cdecl cnd_broadcast(cnd_t* _Cond);
+void __cdecl cnd_destroy(cnd_t* _Cond);
+int __cdecl cnd_init(_Out_ cnd_t* _Cond);
+int __cdecl cnd_signal(cnd_t* _Cond);
+int __cdecl _cnd_timedwait32(cnd_t* _Cond, mtx_t* _Mtx, const struct _timespec32* _Ts);
+int __cdecl _cnd_timedwait64(cnd_t* _Cond, mtx_t* _Mtx, const struct _timespec64* _Ts);
+
+#ifndef _CRT_NO_TIME_T
+#ifdef _USE_32BIT_TIME_T
+static inline int __cdecl cnd_timedwait(cnd_t* _Cond, mtx_t* _Mtx, const struct timespec* _Ts) {
+    return _cnd_timedwait32(_Cond, _Mtx, (struct _timespec32*) _Ts);
+}
+#else
+static inline int __cdecl cnd_timedwait(cnd_t* _Cond, mtx_t* _Mtx, const struct timespec* _Ts) {
+    return _cnd_timedwait64(_Cond, _Mtx, (struct _timespec64*) _Ts);
+}
+#endif
+#endif // _CRT_NO_TIME_T
+int cnd_wait(cnd_t* _Cond, mtx_t* _Mtx);
+
+
+typedef struct {
+    void* _Handle;
+    uint32_t _Tid;
+} thrd_t;
+
+enum { thrd_success, thrd_nomem, thrd_timedout, thrd_busy, thrd_error };
+
+typedef int(__cdecl* thrd_start_t)(void*);
+
+_Success_(return == thrd_success) int __cdecl thrd_create(_Out_ thrd_t* _Thr, thrd_start_t _Func, void* _Arg);
+thrd_t __cdecl thrd_current(void);
+int __cdecl thrd_detach(thrd_t _Thr);
+int __cdecl thrd_equal(thrd_t _Thr0, thrd_t _Thr1);
+
+#ifdef __cplusplus // TRANSITION, [[_Noreturn]]
+[[noreturn]] void __cdecl thrd_exit(int _Res);
+#else
+_Noreturn void __cdecl thrd_exit(int _Res);
+#endif
+
+int __cdecl thrd_join(thrd_t _Thr, int* _Res);
+int __cdecl _thrd_sleep32(
+    const struct _timespec32* duration, struct _timespec32* remaining);
+int __cdecl _thrd_sleep64(
+    const struct _timespec64* duration, struct _timespec64* remaining);
+
+#ifndef _CRT_NO_TIME_T
+#ifdef _USE_32BIT_TIME_T
+static inline int __cdecl thrd_sleep(const struct timespec* duration, struct timespec* remaining) {
+    return _thrd_sleep32((struct _timespec32*) duration, (struct _timespec32*) remaining);
+}
+#else
+static inline int __cdecl thrd_sleep(const struct timespec* duration, struct timespec* remaining) {
+    return _thrd_sleep64((struct _timespec64*) duration, (struct _timespec64*) remaining);
+}
+#endif
+#endif
+
+void __cdecl thrd_yield(void);
+
+#define TSS_DTOR_ITERATIONS 1
+typedef struct {
+    uint32_t _Idx;
+} tss_t;
+
+typedef void (*tss_dtor_t)(void*);
+
+int __cdecl tss_create(tss_t* _Key, tss_dtor_t _Dtor);
+void __cdecl tss_delete(tss_t _Key);
+void* __cdecl tss_get(tss_t _Key);
+int __cdecl tss_set(tss_t _Key, void* _Val);
+
+typedef struct {
+    void* _Opaque;
+} once_flag;
+
+void __cdecl call_once(once_flag* _Flag, void(*_Func)(void));
+
+#define ONCE_FLAG_INIT { 0 }
+
+_CRT_END_C_HEADER
+_UCRT_RESTORE_CLANG_WARNINGS
+#pragma warning(pop) // _UCRT_DISABLED_WARNINGS

miniMSVC/VC/Tools/MSVC/14.42.34433/include/tmmintrin.h

@@ -0,0 +1,147 @@
+/*
+ *  Copyright (C) 1985-2015 Intel Corporation.
+ *
+ *  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#pragma once
+
+#if !defined(_M_IX86) && !defined(_M_X64) && !(defined(_M_ARM64) && defined(USE_SOFT_INTRINSICS))
+#error This header is specific to X86, X64, ARM64, and ARM64EC targets
+#endif
+
+#if (defined(_M_ARM64) || defined(_M_ARM64EC)) && !defined(__INTRIN_H_)
+#error this header should only be included through <intrin.h>
+#endif
+
+#ifndef _INCLUDED_TMM
+#define _INCLUDED_TMM
+#ifndef __midl
+
+#if defined (_M_CEE_PURE)
+        #error ERROR: XMM intrinsics not supported in the pure mode!
+#else  /* defined (_M_CEE_PURE) */
+
+#include <pmmintrin.h>
+
+#ifdef _MM2_FUNCTIONALITY
+/* support old notation */
+#ifndef _MM_FUNCTIONALITY
+#define _MM_FUNCTIONALITY
+#endif  /* _MM_FUNCTIONALITY */
+#endif  /* _MM2_FUNCTIONALITY */
+
+#ifdef __cplusplus
+extern "C" {
+#endif  /* __cplusplus */
+
+    // Horizontal Add: add pairs of adjacent words or double words.
+    // Each field in the result is the sum of two adjacent fields
+    // from the arguments, with the lower result fields coming from
+    // the first argument and the upper result fields coming from
+    // the second argument. The "hadds" forms saturate the signed
+    // addition rather than wrapping.
+
+    extern __m128i _mm_hadd_epi16 (__m128i, __m128i);
+    extern __m128i _mm_hadd_epi32 (__m128i, __m128i);
+    extern __m128i _mm_hadds_epi16 (__m128i, __m128i);
+
+#if defined(_M_IX86)
+    extern __m64 _mm_hadd_pi16 (__m64, __m64);
+    extern __m64 _mm_hadd_pi32 (__m64, __m64);
+    extern __m64 _mm_hadds_pi16 (__m64, __m64);
+#endif
+
+    // Horizontal Subtract: subtract pairs of adjacent words or double
+    // words. Each field in the result is the difference of two adjacent
+    // fields from the arguments, where the upper field is subtracted
+    // from the lower field. The lower result fields come from
+    // the first argument and the upper result fields come from
+    // the second argument. The "hsubs" forms saturate the signed
+    // subtraction rather than wrapping.
+
+    extern __m128i _mm_hsub_epi16 (__m128i, __m128i);
+    extern __m128i _mm_hsub_epi32 (__m128i, __m128i);
+    extern __m128i _mm_hsubs_epi16 (__m128i, __m128i);
+
+#if defined(_M_IX86)
+    extern __m64 _mm_hsub_pi16 (__m64, __m64);
+    extern __m64 _mm_hsub_pi32 (__m64, __m64);
+    extern __m64 _mm_hsubs_pi16 (__m64, __m64);
+#endif
+
+    // Multiply unsigned bytes by signed bytes and sum the word
+    // results in pairs with saturation. Each byte of the first
+    // argument is zero-extended to a word field and each byte
+    // of the second argument is sign-extended to a word field,
+    // then each pair of words is multiplied together to give
+    // signed word intermediate results. Pairs of words from
+    // that result are added horizontally with saturation
+    // to give the final result.
+
+    extern __m128i _mm_maddubs_epi16 (__m128i, __m128i);
+
+#if defined(_M_IX86)
+    extern __m64 _mm_maddubs_pi16 (__m64, __m64);
+#endif
+
+    // Packed multiply high integers with round and scaling,
+    // {X,}MM2/m{128,64} (b) to {X,}MM1 (a).
+
+    extern __m128i _mm_mulhrs_epi16 (__m128i, __m128i);
+
+#if defined(_M_IX86)
+    extern __m64 _mm_mulhrs_pi16 (__m64, __m64);
+#endif
+
+    // Packed shuffle bytes
+    // {X,}MM2/m{128,64} (b) by {X,}MM1 (a).
+
+    extern __m128i _mm_shuffle_epi8 (__m128i, __m128i);
+
+#if defined(_M_IX86)
+    extern __m64 _mm_shuffle_pi8 (__m64, __m64);
+#endif
+
+    // Packed byte, word, double word sign, {X,}MM2/m{128,64} (b) to
+    // {X,}MM1 (a).
+
+    extern __m128i _mm_sign_epi8 (__m128i, __m128i);
+    extern __m128i _mm_sign_epi16 (__m128i, __m128i);
+    extern __m128i _mm_sign_epi32 (__m128i, __m128i);
+
+#if defined(_M_IX86)
+    extern __m64 _mm_sign_pi8 (__m64, __m64);
+    extern __m64 _mm_sign_pi16 (__m64, __m64);
+    extern __m64 _mm_sign_pi32 (__m64, __m64);
+#endif
+
+    // Packed align and shift right by n*8 bits,
+    // {X,}MM2/m{128,64} (b) to {X,}MM1 (a).
+
+    extern __m128i _mm_alignr_epi8 (__m128i, __m128i, int);
+
+#if defined(_M_IX86)
+    extern __m64 _mm_alignr_pi8 (__m64, __m64, int);
+#endif
+
+    // Packed byte, word, double word absolute value,
+    // {X,}MM2/m{128,64} (b) to {X,}MM1 (a).
+
+    extern __m128i _mm_abs_epi8 (__m128i);
+    extern __m128i _mm_abs_epi16 (__m128i);
+    extern __m128i _mm_abs_epi32 (__m128i);
+
+#if defined(_M_IX86)
+    extern __m64 _mm_abs_pi8 (__m64);
+    extern __m64 _mm_abs_pi16 (__m64);
+    extern __m64 _mm_abs_pi32 (__m64);
+#endif
+
+#ifdef __cplusplus
+};
+#endif  /* __cplusplus */
+
+#endif  /* defined (_M_CEE_PURE) */
+#endif  /* __midl */
+#endif  /* _INCLUDED_TMM */

miniMSVC/VC/Tools/MSVC/14.42.34433/include/tuple

@@ -0,0 +1,1177 @@
+// tuple standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _TUPLE_
+#define _TUPLE_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#if _HAS_CXX20
+#include <compare>
+#endif // _HAS_CXX20
+#include <__msvc_iter_core.hpp>
+#include <type_traits>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+template <bool _Same, class _Dest, class... _Srcs>
+constexpr bool _Tuple_conditional_explicit_v0 = false;
+
+template <class... _Dests, class... _Srcs>
+constexpr bool _Tuple_conditional_explicit_v0<true, tuple<_Dests...>, _Srcs...> =
+    !conjunction_v<is_convertible<_Srcs, _Dests>...>;
+
+template <class _Dest, class... _Srcs>
+constexpr bool _Tuple_conditional_explicit_v =
+    _Tuple_conditional_explicit_v0<tuple_size_v<_Dest> == sizeof...(_Srcs), _Dest, _Srcs...>;
+
+template <bool _Same, class _Dest, class... _Srcs>
+constexpr bool _Tuple_constructible_v0 = false;
+
+template <class... _Dests, class... _Srcs>
+constexpr bool _Tuple_constructible_v0<true, tuple<_Dests...>, _Srcs...> =
+    conjunction_v<is_constructible<_Dests, _Srcs>...>;
+
+template <class _Dest, class... _Srcs>
+constexpr bool _Tuple_constructible_v =
+    _Tuple_constructible_v0<tuple_size_v<_Dest> == sizeof...(_Srcs), _Dest, _Srcs...>;
+
+template <class _Dest, class... _Srcs>
+struct _Tuple_constructible_val : bool_constant<_Tuple_constructible_v<_Dest, _Srcs...>> {};
+
+template <bool _Same, class _Dest, class... _Srcs>
+constexpr bool _Tuple_nothrow_constructible_v0 = false;
+
+template <class... _Dests, class... _Srcs>
+constexpr bool _Tuple_nothrow_constructible_v0<true, tuple<_Dests...>, _Srcs...> =
+    conjunction_v<is_nothrow_constructible<_Dests, _Srcs>...>;
+
+template <class _Dest, class... _Srcs>
+constexpr bool _Tuple_nothrow_constructible_v =
+    _Tuple_nothrow_constructible_v0<tuple_size_v<_Dest> == sizeof...(_Srcs), _Dest, _Srcs...>;
+
+template <bool _Same, class _Dest, class... _Srcs>
+constexpr bool _Tuple_assignable_v0 = false;
+
+template <class... _Dests, class... _Srcs>
+constexpr bool _Tuple_assignable_v0<true, tuple<_Dests...>, _Srcs...> =
+    conjunction_v<is_assignable<_Dests&, _Srcs>...>; // note _Dests& instead of _Dests
+
+#if _HAS_CXX23
+template <class... _Dests, class... _Srcs>
+constexpr bool _Tuple_assignable_v0<true, const tuple<_Dests...>, _Srcs...> =
+    conjunction_v<is_assignable<const _Dests&, _Srcs>...>;
+#endif // _HAS_CXX23
+
+template <class _Dest, class... _Srcs>
+constexpr bool _Tuple_assignable_v = _Tuple_assignable_v0<tuple_size_v<_Dest> == sizeof...(_Srcs), _Dest, _Srcs...>;
+
+template <class _Dest, class... _Srcs>
+struct _Tuple_assignable_val : bool_constant<_Tuple_assignable_v<_Dest, _Srcs...>> {};
+
+template <bool _Same, class _Dest, class... _Srcs>
+constexpr bool _Tuple_nothrow_assignable_v0 = false;
+
+template <class... _Dests, class... _Srcs>
+constexpr bool _Tuple_nothrow_assignable_v0<true, tuple<_Dests...>, _Srcs...> =
+    conjunction_v<is_nothrow_assignable<_Dests&, _Srcs>...>; // note _Dests& instead of _Dests
+
+#if _HAS_CXX23
+template <class... _Dests, class... _Srcs>
+constexpr bool _Tuple_nothrow_assignable_v0<true, const tuple<_Dests...>, _Srcs...> =
+    conjunction_v<is_nothrow_assignable<const _Dests&, _Srcs>...>;
+#endif // _HAS_CXX23
+
+template <class _Dest, class... _Srcs>
+constexpr bool _Tuple_nothrow_assignable_v =
+    _Tuple_nothrow_assignable_v0<tuple_size_v<_Dest> == sizeof...(_Srcs), _Dest, _Srcs...>;
+
+// Constrain tuple's converting constructors
+template <class _Myself, class _OtherTuple, class... _Other>
+struct _Tuple_convert_val : true_type {};
+
+template <class _This, class _OtherTuple, class _Uty>
+struct _Tuple_convert_val<tuple<_This>, _OtherTuple, _Uty>
+    : bool_constant<!disjunction_v<is_same<_This, _Uty>, is_constructible<_This, _OtherTuple>,
+          is_convertible<_OtherTuple, _This>>> {};
+
+// Constrain tuple's perfect forwarding constructor (LWG-3121)
+template <class _Myself, class _This2, class... _Rest2>
+struct _Tuple_perfect_val : true_type {};
+
+template <class _Myself, class _This2>
+struct _Tuple_perfect_val<_Myself, _This2> : bool_constant<!is_same_v<_Myself, _Remove_cvref_t<_This2>>> {};
+
+template <class _Ty0, class _Ty1, class _Uty0, class _Uty1>
+struct _Tuple_perfect_val<tuple<_Ty0, _Ty1>, _Uty0, _Uty1>
+    : bool_constant<disjunction_v<negation<is_same<_Remove_cvref_t<_Uty0>, allocator_arg_t>>,
+          is_same<_Remove_cvref_t<_Ty0>, allocator_arg_t>>> {};
+
+template <class _Ty0, class _Ty1, class _Ty2, class _Uty0, class _Uty1, class _Uty2>
+struct _Tuple_perfect_val<tuple<_Ty0, _Ty1, _Ty2>, _Uty0, _Uty1, _Uty2>
+    : bool_constant<disjunction_v<negation<is_same<_Remove_cvref_t<_Uty0>, allocator_arg_t>>,
+          is_same<_Remove_cvref_t<_Ty0>, allocator_arg_t>>> {};
+
+// Note: To improve throughput, this file uses extra _STD qualification for names that appear in the
+// arguments of enable_if_t. Specifically, we qualify names which appear anywhere in the STL as members of
+// some class - including injected-class-names! - that we know are not members of the class being defined.
+// This avoids pointless class-member lookup for those names in this context.
+
+template <class _Ty>
+struct _Tuple_val { // stores each value in a tuple
+    constexpr _Tuple_val() : _Val() {}
+
+    template <class _Other>
+    constexpr _Tuple_val(_Other&& _Arg) : _Val(_STD forward<_Other>(_Arg)) {}
+
+    template <class _Alloc, class... _Other, enable_if_t<!uses_allocator_v<_Ty, _Alloc>, int> = 0>
+    constexpr _Tuple_val(const _Alloc&, allocator_arg_t, _Other&&... _Arg) : _Val(_STD forward<_Other>(_Arg)...) {}
+
+    template <class _Alloc, class... _Other,
+        enable_if_t<conjunction_v<_STD uses_allocator<_Ty, _Alloc>,
+                        _STD is_constructible<_Ty, _STD allocator_arg_t, const _Alloc&, _Other...>>,
+            int> = 0>
+    constexpr _Tuple_val(const _Alloc& _Al, allocator_arg_t, _Other&&... _Arg)
+        : _Val(allocator_arg, _Al, _STD forward<_Other>(_Arg)...) {}
+
+    template <class _Alloc, class... _Other,
+        enable_if_t<conjunction_v<_STD uses_allocator<_Ty, _Alloc>,
+                        _STD negation<_STD is_constructible<_Ty, _STD allocator_arg_t, const _Alloc&, _Other...>>>,
+            int> = 0>
+    constexpr _Tuple_val(const _Alloc& _Al, allocator_arg_t, _Other&&... _Arg)
+        : _Val(_STD forward<_Other>(_Arg)..., _Al) {}
+
+    _Ty _Val;
+};
+
+struct _Exact_args_t {
+    explicit _Exact_args_t() = default;
+}; // tag type to disambiguate construction (from one arg per element)
+
+struct _Unpack_tuple_t {
+    explicit _Unpack_tuple_t() = default;
+}; // tag type to disambiguate construction (from unpacking a tuple/pair)
+
+struct _Alloc_exact_args_t {
+    explicit _Alloc_exact_args_t() = default;
+}; // tag type to disambiguate construction (from an allocator and one arg per element)
+
+struct _Alloc_unpack_tuple_t {
+    explicit _Alloc_unpack_tuple_t() = default;
+}; // tag type to disambiguate construction (from an allocator and unpacking a tuple/pair)
+
+#if _HAS_CXX23
+template <class _Tuple, class _Other, class _Indices = make_index_sequence<tuple_size_v<_Tuple>>>
+constexpr bool _Can_construct_values_from_tuple_like_v = false;
+
+template <class... _Types, class _Other, size_t... _Indices>
+constexpr bool _Can_construct_values_from_tuple_like_v<tuple<_Types...>, _Other, index_sequence<_Indices...>> =
+    conjunction_v<is_constructible<_Types, decltype(_STD get<_Indices>(_STD declval<_Other>()))>...>;
+
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, LLVM-59827 and VSO-1900279
+template <class _TupleLike, class _Tuple>
+concept _Can_construct_from_tuple_like =
+    _Different_from<_TupleLike, _Tuple> && _Tuple_like<_TupleLike> && !_Is_subrange_v<remove_cvref_t<_TupleLike>>
+    && (tuple_size_v<_Tuple> == tuple_size_v<remove_cvref_t<_TupleLike>>) //
+    &&_Can_construct_values_from_tuple_like_v<_Tuple, _TupleLike>
+    && (tuple_size_v<_Tuple> != 1
+        || (!is_convertible_v<_TupleLike, tuple_element_t<0, _Tuple>>
+            && !is_constructible_v<tuple_element_t<0, _Tuple>, _TupleLike>) );
+#endif // ^^^ workaround ^^^
+
+template <class _TTuple, class _UTuple, class _Indices = make_index_sequence<tuple_size_v<_UTuple>>>
+struct _Three_way_comparison_result_with_tuple_like {};
+
+template <class... _TTypes, class _UTuple, size_t... _Indices>
+    requires
+#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, DevCom-10265237
+    (sizeof...(_TTypes) == sizeof...(_Indices)) &&
+#endif // ^^^ workaround ^^^
+    (requires { typename _Synth_three_way_result<_TTypes, tuple_element_t<_Indices, _UTuple>>; } && ...)
+struct _Three_way_comparison_result_with_tuple_like<tuple<_TTypes...>, _UTuple, index_sequence<_Indices...>> {
+    using type = common_comparison_category_t<_Synth_three_way_result<_TTypes, tuple_element_t<_Indices, _UTuple>>...>;
+};
+
+template <class _TTuple, _Tuple_like _UTuple>
+using _Three_way_comparison_result_with_tuple_like_t =
+    _Three_way_comparison_result_with_tuple_like<_TTuple, _UTuple>::type;
+
+template <class _Ty>
+concept _Tuple_like_non_tuple = !_Is_specialization_v<_Ty, tuple> && _Tuple_like<_Ty>;
+#endif // _HAS_CXX23
+
+template <>
+class tuple<> { // empty tuple
+public:
+    constexpr tuple() noexcept = default; /* strengthened */
+
+    constexpr tuple(const tuple&) noexcept /* strengthened */ {} // TRANSITION, ABI: should be defaulted
+
+#if _HAS_CXX23
+    template <_Different_from<tuple> _Other>
+        requires _Tuple_like<_Other> && (tuple_size_v<remove_cvref_t<_Other>> == 0)
+    constexpr tuple(_Other&&) noexcept /* strengthened */ {}
+#endif // _HAS_CXX23
+
+    template <class _Alloc>
+    _CONSTEXPR20 tuple(allocator_arg_t, const _Alloc&) noexcept /* strengthened */ {}
+
+    template <class _Alloc>
+    _CONSTEXPR20 tuple(allocator_arg_t, const _Alloc&, const tuple&) noexcept /* strengthened */ {}
+
+#if _HAS_CXX23
+    template <class _Alloc, _Different_from<tuple> _Other>
+        requires _Tuple_like<_Other> && (tuple_size_v<remove_cvref_t<_Other>> == 0)
+    constexpr tuple(allocator_arg_t, const _Alloc&, _Other&&) noexcept /* strengthened */ {}
+#endif // _HAS_CXX23
+
+    template <class _Tag, enable_if_t<is_same_v<_Tag, _STD _Exact_args_t>, int> = 0>
+    constexpr tuple(_Tag) noexcept /* strengthened */ {}
+
+    template <class _Tag, class _Alloc, enable_if_t<is_same_v<_Tag, _STD _Alloc_exact_args_t>, int> = 0>
+    constexpr tuple(_Tag, const _Alloc&) noexcept /* strengthened */ {}
+
+    constexpr tuple& operator=(const tuple&) = default;
+#if _HAS_CXX23
+    constexpr const tuple& operator=(const tuple&) const noexcept /* strengthened */ {
+        return *this;
+    }
+
+    template <_Different_from<tuple> _Other>
+        requires _Tuple_like<_Other> && (tuple_size_v<remove_cvref_t<_Other>> == 0)
+    constexpr tuple& operator=(_Other&&) noexcept /* strengthened */ {
+        return *this;
+    }
+
+    template <_Different_from<tuple> _Other>
+        requires _Tuple_like<_Other> && (tuple_size_v<remove_cvref_t<_Other>> == 0)
+    constexpr const tuple& operator=(_Other&&) const noexcept /* strengthened */ {
+        return *this;
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 void swap(tuple&) noexcept {}
+#if _HAS_CXX23
+    constexpr void swap(const tuple&) const noexcept {}
+#endif // _HAS_CXX23
+
+    constexpr bool _Equals(const tuple&) const noexcept {
+        return true;
+    }
+
+#if _HAS_CXX20
+    _NODISCARD constexpr strong_ordering _Three_way_compare(const tuple&) const noexcept {
+        return strong_ordering::equal;
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD constexpr bool _Less(const tuple&) const noexcept {
+        return false;
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+#if _HAS_CXX23
+    template <_Tuple_like_non_tuple _Other>
+    _NODISCARD friend constexpr bool operator==(const tuple&, const _Other&) noexcept /* strengthened */ {
+        static_assert(tuple_size_v<_Other> == 0, "Cannot compare tuples of different sizes (N4950 [tuple.rel]/2).");
+        return true;
+    }
+
+    template <_Tuple_like_non_tuple _Other>
+        requires (tuple_size_v<remove_cvref_t<_Other>> == 0)
+    _NODISCARD friend constexpr strong_ordering operator<=>(const tuple&, const _Other&) noexcept /* strengthened */ {
+        return strong_ordering::equal;
+    }
+#endif // _HAS_CXX23
+};
+
+template <class _This, class... _Rest>
+class tuple<_This, _Rest...> : private tuple<_Rest...> { // recursive tuple definition
+public:
+    using _This_type = _This;
+    using _Mybase    = tuple<_Rest...>;
+
+    template <class _Tag, class _This2, class... _Rest2, enable_if_t<is_same_v<_Tag, _STD _Exact_args_t>, int> = 0>
+    constexpr tuple(_Tag, _This2&& _This_arg, _Rest2&&... _Rest_arg)
+        : _Mybase(_Exact_args_t{}, _STD forward<_Rest2>(_Rest_arg)...), _Myfirst(_STD forward<_This2>(_This_arg)) {}
+
+    template <class _Tag, class _Tpl, size_t... _Indices, enable_if_t<is_same_v<_Tag, _STD _Unpack_tuple_t>, int> = 0>
+    constexpr tuple(_Tag, _Tpl&& _Right, index_sequence<_Indices...>);
+
+    template <class _Tag, class _Tpl, enable_if_t<is_same_v<_Tag, _STD _Unpack_tuple_t>, int> = 0>
+    constexpr tuple(_Tag, _Tpl&& _Right)
+        : tuple(_Unpack_tuple_t{}, _STD forward<_Tpl>(_Right),
+            make_index_sequence<tuple_size_v<remove_reference_t<_Tpl>>>{}) {}
+
+    template <class _Tag, class _Alloc, class _This2, class... _Rest2,
+        enable_if_t<is_same_v<_Tag, _STD _Alloc_exact_args_t>, int> = 0>
+    constexpr tuple(_Tag, const _Alloc& _Al, _This2&& _This_arg, _Rest2&&... _Rest_arg)
+        : _Mybase(_Alloc_exact_args_t{}, _Al, _STD forward<_Rest2>(_Rest_arg)...),
+          _Myfirst(_Al, allocator_arg, _STD forward<_This2>(_This_arg)) {}
+
+    template <class _Tag, class _Alloc, class _Tpl, size_t... _Indices,
+        enable_if_t<is_same_v<_Tag, _STD _Alloc_unpack_tuple_t>, int> = 0>
+    constexpr tuple(_Tag, const _Alloc& _Al, _Tpl&& _Right, index_sequence<_Indices...>);
+
+    template <class _Tag, class _Alloc, class _Tpl, enable_if_t<is_same_v<_Tag, _STD _Alloc_unpack_tuple_t>, int> = 0>
+    constexpr tuple(_Tag, const _Alloc& _Al, _Tpl&& _Right)
+        : tuple(_Alloc_unpack_tuple_t{}, _Al, _STD forward<_Tpl>(_Right),
+            make_index_sequence<tuple_size_v<remove_reference_t<_Tpl>>>{}) {}
+
+    template <class _This2 = _This,
+        enable_if_t<conjunction_v<_STD is_default_constructible<_This2>, _STD is_default_constructible<_Rest>...>,
+            int>           = 0>
+    constexpr explicit(
+        !conjunction_v<_Is_implicitly_default_constructible<_This2>, _Is_implicitly_default_constructible<_Rest>...>)
+        tuple() noexcept(conjunction_v<is_nothrow_default_constructible<_This2>,
+            is_nothrow_default_constructible<_Rest>...>) // strengthened
+        : _Mybase(), _Myfirst() {}
+
+    template <class _This2 = _This, enable_if_t<_Tuple_constructible_v<tuple, const _This2&, const _Rest&...>, int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, const _This2&, const _Rest&...>) tuple(
+        const _This& _This_arg, const _Rest&... _Rest_arg) noexcept(conjunction_v<is_nothrow_copy_constructible<_This2>,
+        is_nothrow_copy_constructible<_Rest>...>) // strengthened
+        : tuple(_Exact_args_t{}, _This_arg, _Rest_arg...) {}
+
+    template <class _This2, class... _Rest2,
+        enable_if_t<conjunction_v<_STD _Tuple_perfect_val<tuple, _This2, _Rest2...>,
+                        _STD _Tuple_constructible_val<tuple, _This2, _Rest2...>>,
+            int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, _This2, _Rest2...>) tuple(_This2&& _This_arg,
+        _Rest2&&... _Rest_arg) noexcept(_Tuple_nothrow_constructible_v<tuple, _This2, _Rest2...>) // strengthened
+        : tuple(_Exact_args_t{}, _STD forward<_This2>(_This_arg), _STD forward<_Rest2>(_Rest_arg)...) {}
+
+    tuple(const tuple&) = default;
+    tuple(tuple&&)      = default;
+
+#if _HAS_CXX23
+    template <class... _Other, enable_if_t<conjunction_v<_STD _Tuple_constructible_val<tuple, _Other&...>,
+                                               _STD _Tuple_convert_val<tuple, tuple<_Other...>&, _Other...>>,
+                                   int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, _Other&...>)
+        tuple(tuple<_Other...>& _Right) noexcept(_Tuple_nothrow_constructible_v<tuple, _Other&...>) // strengthened
+        : tuple(_Unpack_tuple_t{}, _Right) {}
+#endif // _HAS_CXX23
+
+    template <class... _Other, enable_if_t<conjunction_v<_STD _Tuple_constructible_val<tuple, const _Other&...>,
+                                               _STD _Tuple_convert_val<tuple, const tuple<_Other...>&, _Other...>>,
+                                   int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, const _Other&...>)
+        tuple(const tuple<_Other...>& _Right) noexcept(
+            _Tuple_nothrow_constructible_v<tuple, const _Other&...>) // strengthened
+        : tuple(_Unpack_tuple_t{}, _Right) {}
+
+    template <class... _Other, enable_if_t<conjunction_v<_STD _Tuple_constructible_val<tuple, _Other...>,
+                                               _STD _Tuple_convert_val<tuple, tuple<_Other...>, _Other...>>,
+                                   int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, _Other...>)
+        tuple(tuple<_Other...>&& _Right) noexcept(_Tuple_nothrow_constructible_v<tuple, _Other...>) // strengthened
+        : tuple(_Unpack_tuple_t{}, _STD move(_Right)) {}
+
+#if _HAS_CXX23
+    template <class... _Other, enable_if_t<conjunction_v<_STD _Tuple_constructible_val<tuple, const _Other...>,
+                                               _STD _Tuple_convert_val<tuple, const tuple<_Other...>, _Other...>>,
+                                   int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, const _Other...>)
+        tuple(const tuple<_Other...>&& _Right) noexcept(
+            _Tuple_nothrow_constructible_v<tuple, const _Other...>) // strengthened
+        : tuple(_Unpack_tuple_t{}, _STD move(_Right)) {}
+
+    template <class _First, class _Second, enable_if_t<_Tuple_constructible_v<tuple, _First&, _Second&>, int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, _First&, _Second&>)
+        tuple(pair<_First, _Second>& _Right) noexcept(
+            _Tuple_nothrow_constructible_v<tuple, _First&, _Second&>) // strengthened
+        : tuple(_Unpack_tuple_t{}, _Right) {}
+#endif // _HAS_CXX23
+
+    template <class _First, class _Second,
+        enable_if_t<_Tuple_constructible_v<tuple, const _First&, const _Second&>, int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, const _First&, const _Second&>)
+        tuple(const pair<_First, _Second>& _Right) noexcept(
+            _Tuple_nothrow_constructible_v<tuple, const _First&, const _Second&>) // strengthened
+        : tuple(_Unpack_tuple_t{}, _Right) {}
+
+    template <class _First, class _Second, enable_if_t<_Tuple_constructible_v<tuple, _First, _Second>, int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, _First, _Second>) tuple(
+        pair<_First, _Second>&& _Right) noexcept(_Tuple_nothrow_constructible_v<tuple, _First, _Second>) // strengthened
+        : tuple(_Unpack_tuple_t{}, _STD move(_Right)) {}
+
+#if _HAS_CXX23
+    template <class _First, class _Second,
+        enable_if_t<_Tuple_constructible_v<tuple, const _First, const _Second>, int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, const _First, const _Second>)
+        tuple(const pair<_First, _Second>&& _Right) noexcept(
+            _Tuple_nothrow_constructible_v<tuple, const _First, const _Second>) // strengthened
+        : tuple(_Unpack_tuple_t{}, _STD move(_Right)) {}
+
+    template <class _Other, class _Indices = index_sequence_for<_Rest...>>
+    static constexpr bool _Is_tuple_like_constructor_explicit_v = false;
+
+    template <_Tuple_like _Other, size_t... _Indices>
+    static constexpr bool _Is_tuple_like_constructor_explicit_v<_Other, index_sequence<_Indices...>> =
+        negation_v<conjunction<is_convertible<decltype(_STD get<0>(_STD declval<_Other>())), _This>,
+            is_convertible<decltype(_STD get<_Indices + 1>(_STD declval<_Other>())), _Rest>...>>;
+
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, LLVM-59827 and VSO-1900279
+    template <class _Other, enable_if_t<_Can_construct_from_tuple_like<_Other, tuple>, int> = 0>
+#else // ^^^ workaround / no workaround vvv
+    template <_Different_from<tuple> _Other>
+        requires _Tuple_like<_Other> && (!_Is_subrange_v<remove_cvref_t<_Other>>)
+              && (1 + sizeof...(_Rest) == tuple_size_v<remove_cvref_t<_Other>>)
+              && _Can_construct_values_from_tuple_like_v<tuple, _Other>
+              && (sizeof...(_Rest) != 0 || (!is_convertible_v<_Other, _This> && !is_constructible_v<_This, _Other>) )
+#endif // ^^^ no workaround ^^^
+    constexpr explicit(_Is_tuple_like_constructor_explicit_v<_Other>) tuple(_Other&& _Right)
+        : tuple(_Unpack_tuple_t{}, _STD forward<_Other>(_Right)) {
+    }
+#endif // _HAS_CXX23
+
+    template <class _Alloc, class _This2 = _This,
+        enable_if_t<conjunction_v<_STD is_default_constructible<_This2>, _STD is_default_constructible<_Rest>...>,
+            int> = 0>
+    _CONSTEXPR20 explicit(
+        !conjunction_v<_Is_implicitly_default_constructible<_This2>, _Is_implicitly_default_constructible<_Rest>...>)
+        tuple(allocator_arg_t, const _Alloc& _Al)
+        : _Mybase(allocator_arg, _Al), _Myfirst(_Al, allocator_arg) {}
+
+    template <class _Alloc, class _This2 = _This,
+        enable_if_t<_Tuple_constructible_v<tuple, const _This2&, const _Rest&...>, int> = 0>
+    _CONSTEXPR20 explicit(_Tuple_conditional_explicit_v<tuple, const _This2&, const _Rest&...>)
+        tuple(allocator_arg_t, const _Alloc& _Al, const _This& _This_arg, const _Rest&... _Rest_arg)
+        : tuple(_Alloc_exact_args_t{}, _Al, _This_arg, _Rest_arg...) {}
+
+    template <class _Alloc, class _This2, class... _Rest2,
+        enable_if_t<conjunction_v<_STD _Tuple_perfect_val<tuple, _This2, _Rest2...>,
+                        _STD _Tuple_constructible_val<tuple, _This2, _Rest2...>>,
+            int> = 0>
+    _CONSTEXPR20 explicit(_Tuple_conditional_explicit_v<tuple, _This2, _Rest2...>)
+        tuple(allocator_arg_t, const _Alloc& _Al, _This2&& _This_arg, _Rest2&&... _Rest_arg)
+        : tuple(_Alloc_exact_args_t{}, _Al, _STD forward<_This2>(_This_arg), _STD forward<_Rest2>(_Rest_arg)...) {}
+
+    template <class _Alloc, class _This2 = _This,
+        enable_if_t<_Tuple_constructible_v<tuple, const _This2&, const _Rest&...>, int> = 0>
+    _CONSTEXPR20 tuple(allocator_arg_t, const _Alloc& _Al, const tuple& _Right)
+        : tuple(_Alloc_unpack_tuple_t{}, _Al, _Right) {}
+
+    template <class _Alloc, class _This2 = _This, enable_if_t<_Tuple_constructible_v<tuple, _This2, _Rest...>, int> = 0>
+    _CONSTEXPR20 tuple(allocator_arg_t, const _Alloc& _Al, tuple&& _Right)
+        : tuple(_Alloc_unpack_tuple_t{}, _Al, _STD move(_Right)) {}
+
+#if _HAS_CXX23
+    template <class _Alloc, class... _Other,
+        enable_if_t<conjunction_v<_STD _Tuple_constructible_val<tuple, _Other&...>,
+                        _STD _Tuple_convert_val<tuple, tuple<_Other...>&, _Other...>>,
+            int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, _Other&...>)
+        tuple(allocator_arg_t, const _Alloc& _Al, tuple<_Other...>& _Right)
+        : tuple(_Alloc_unpack_tuple_t{}, _Al, _Right) {}
+#endif // _HAS_CXX23
+
+    template <class _Alloc, class... _Other,
+        enable_if_t<conjunction_v<_STD _Tuple_constructible_val<tuple, const _Other&...>,
+                        _STD _Tuple_convert_val<tuple, const tuple<_Other...>&, _Other...>>,
+            int> = 0>
+    _CONSTEXPR20 explicit(_Tuple_conditional_explicit_v<tuple, const _Other&...>)
+        tuple(allocator_arg_t, const _Alloc& _Al, const tuple<_Other...>& _Right)
+        : tuple(_Alloc_unpack_tuple_t{}, _Al, _Right) {}
+
+    template <class _Alloc, class... _Other,
+        enable_if_t<conjunction_v<_STD _Tuple_constructible_val<tuple, _Other...>,
+                        _STD _Tuple_convert_val<tuple, tuple<_Other...>, _Other...>>,
+            int> = 0>
+    _CONSTEXPR20 explicit(_Tuple_conditional_explicit_v<tuple, _Other...>)
+        tuple(allocator_arg_t, const _Alloc& _Al, tuple<_Other...>&& _Right)
+        : tuple(_Alloc_unpack_tuple_t{}, _Al, _STD move(_Right)) {}
+
+#if _HAS_CXX23
+    template <class _Alloc, class... _Other,
+        enable_if_t<conjunction_v<_STD _Tuple_constructible_val<tuple, const _Other...>,
+                        _STD _Tuple_convert_val<tuple, const tuple<_Other...>, _Other...>>,
+            int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, const _Other...>)
+        tuple(allocator_arg_t, const _Alloc& _Al, const tuple<_Other...>&& _Right)
+        : tuple(_Alloc_unpack_tuple_t{}, _Al, _STD move(_Right)) {}
+
+    template <class _Alloc, class _First, class _Second,
+        enable_if_t<_Tuple_constructible_v<tuple, _First&, _Second&>, int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, _First&, _Second&>)
+        tuple(allocator_arg_t, const _Alloc& _Al, pair<_First, _Second>& _Right)
+        : tuple(_Alloc_unpack_tuple_t{}, _Al, _Right) {}
+#endif // _HAS_CXX23
+
+    template <class _Alloc, class _First, class _Second,
+        enable_if_t<_Tuple_constructible_v<tuple, const _First&, const _Second&>, int> = 0>
+    _CONSTEXPR20 explicit(_Tuple_conditional_explicit_v<tuple, const _First&, const _Second&>)
+        tuple(allocator_arg_t, const _Alloc& _Al, const pair<_First, _Second>& _Right)
+        : tuple(_Alloc_unpack_tuple_t{}, _Al, _Right) {}
+
+    template <class _Alloc, class _First, class _Second,
+        enable_if_t<_Tuple_constructible_v<tuple, _First, _Second>, int> = 0>
+    _CONSTEXPR20 explicit(_Tuple_conditional_explicit_v<tuple, _First, _Second>)
+        tuple(allocator_arg_t, const _Alloc& _Al, pair<_First, _Second>&& _Right)
+        : tuple(_Alloc_unpack_tuple_t{}, _Al, _STD move(_Right)) {}
+
+#if _HAS_CXX23
+    template <class _Alloc, class _First, class _Second,
+        enable_if_t<_Tuple_constructible_v<tuple, const _First, const _Second>, int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, const _First, const _Second>)
+        tuple(allocator_arg_t, const _Alloc& _Al, const pair<_First, _Second>&& _Right)
+        : tuple(_Alloc_unpack_tuple_t{}, _Al, _STD move(_Right)) {}
+
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, LLVM-59827 (Clang), VSO-1900279 (EDG)
+    template <class _Alloc, class _Other, enable_if_t<_Can_construct_from_tuple_like<_Other, tuple>, int> = 0>
+#else // ^^^ workaround / no workaround vvv
+    template <class _Alloc, _Different_from<tuple> _Other>
+        requires _Tuple_like<_Other> && (!_Is_subrange_v<remove_cvref_t<_Other>>)
+              && (1 + sizeof...(_Rest) == tuple_size_v<remove_cvref_t<_Other>>)
+              && _Can_construct_values_from_tuple_like_v<tuple, _Other>
+              && (sizeof...(_Rest) != 0 || (!is_convertible_v<_Other, _This> && !is_constructible_v<_This, _Other>) )
+#endif // ^^^ no workaround ^^^
+    constexpr explicit(_Is_tuple_like_constructor_explicit_v<_Other>)
+        tuple(allocator_arg_t, const _Alloc& _Al, _Other&& _Right)
+        : tuple(_Alloc_unpack_tuple_t{}, _Al, _STD forward<_Other>(_Right)) {
+    }
+#endif // _HAS_CXX23
+
+    tuple& operator=(const volatile tuple&) = delete;
+
+    template <class _Myself = tuple, class _This2 = _This,
+        enable_if_t<conjunction_v<_STD _Is_copy_assignable_no_precondition_check<_This2>,
+                        _STD _Is_copy_assignable_no_precondition_check<_Rest>...>,
+            int> = 0>
+    _CONSTEXPR20 tuple& operator=(_Identity_t<const _Myself&> _Right) noexcept(
+        conjunction_v<is_nothrow_copy_assignable<_This2>, is_nothrow_copy_assignable<_Rest>...>) /* strengthened */ {
+        _Myfirst._Val = _Right._Myfirst._Val;
+        _Get_rest()   = _Right._Get_rest();
+        return *this;
+    }
+
+#if _HAS_CXX23
+    template <class _Myself = tuple>
+        requires conjunction_v<_STD _Is_copy_assignable_no_precondition_check<const _This>,
+            _STD _Is_copy_assignable_no_precondition_check<const _Rest>...>
+    constexpr const tuple& operator=(_Identity_t<const _Myself&> _Right) const
+        noexcept(conjunction_v<is_nothrow_copy_assignable<const _This>,
+            is_nothrow_copy_assignable<const _Rest>...>) /* strengthened */ {
+        _Myfirst._Val = _Right._Myfirst._Val;
+        _Get_rest()   = _Right._Get_rest();
+        return *this;
+    }
+#endif // _HAS_CXX23
+
+    template <class _Myself = tuple, class _This2 = _This,
+        enable_if_t<conjunction_v<_STD _Is_move_assignable_no_precondition_check<_This2>,
+                        _STD _Is_move_assignable_no_precondition_check<_Rest>...>,
+            int> = 0>
+    _CONSTEXPR20 tuple& operator=(_Identity_t<_Myself&&> _Right) noexcept(
+        conjunction_v<is_nothrow_move_assignable<_This2>, is_nothrow_move_assignable<_Rest>...>) {
+        _Myfirst._Val = _STD forward<_This>(_Right._Myfirst._Val);
+        _Get_rest()   = _STD forward<_Mybase>(_Right._Get_rest());
+        return *this;
+    }
+
+#if _HAS_CXX23
+    template <class _Myself = tuple>
+        requires conjunction_v<_STD _Is_assignable_no_precondition_check<const _This&, _This>,
+            _STD _Is_assignable_no_precondition_check<const _Rest&, _Rest>...>
+    constexpr const tuple& operator=(_Identity_t<_Myself&&> _Right) const
+        noexcept(conjunction_v<is_nothrow_assignable<const _This&, _This>,
+            is_nothrow_assignable<const _Rest&, _Rest>...>) /* strengthened */ {
+        _Myfirst._Val = _STD forward<_This>(_Right._Myfirst._Val);
+        _Get_rest()   = _STD forward<_Mybase>(_Right._Get_rest());
+        return *this;
+    }
+#endif // _HAS_CXX23
+
+    template <class... _Other, enable_if_t<conjunction_v<_STD negation<_STD is_same<tuple, _STD tuple<_Other...>>>,
+                                               _STD _Tuple_assignable_val<tuple, const _Other&...>>,
+                                   int> = 0>
+    _CONSTEXPR20 tuple& operator=(const tuple<_Other...>& _Right) noexcept(
+        _Tuple_nothrow_assignable_v<tuple, const _Other&...>) /* strengthened */ {
+        _Myfirst._Val = _Right._Myfirst._Val;
+        _Get_rest()   = _Right._Get_rest();
+        return *this;
+    }
+
+#if _HAS_CXX23
+    template <class... _Other>
+        requires (!is_same_v<tuple, _STD tuple<_Other...>>) && _Tuple_assignable_v<const tuple, const _Other&...>
+    constexpr const tuple& operator=(const tuple<_Other...>& _Right) const
+        noexcept(_Tuple_nothrow_assignable_v<const tuple, const _Other&...>) /* strengthened */ {
+        _Myfirst._Val = _Right._Myfirst._Val;
+        _Get_rest()   = _Right._Get_rest();
+        return *this;
+    }
+#endif // _HAS_CXX23
+
+    template <class... _Other, enable_if_t<conjunction_v<_STD negation<_STD is_same<tuple, _STD tuple<_Other...>>>,
+                                               _STD _Tuple_assignable_val<tuple, _Other...>>,
+                                   int> = 0>
+    _CONSTEXPR20 tuple& operator=(tuple<_Other...>&& _Right) noexcept(
+        _Tuple_nothrow_assignable_v<tuple, _Other...>) /* strengthened */ {
+        _Myfirst._Val = _STD forward<typename tuple<_Other...>::_This_type>(_Right._Myfirst._Val);
+        _Get_rest()   = _STD forward<typename tuple<_Other...>::_Mybase>(_Right._Get_rest());
+        return *this;
+    }
+
+#if _HAS_CXX23
+    template <class... _Other>
+        requires (!is_same_v<tuple, _STD tuple<_Other...>>) && _Tuple_assignable_v<const tuple, _Other...>
+    constexpr const tuple& operator=(tuple<_Other...>&& _Right) const
+        noexcept(_Tuple_nothrow_assignable_v<const tuple, _Other...>) /* strengthened */ {
+        _Myfirst._Val = _STD forward<typename tuple<_Other...>::_This_type>(_Right._Myfirst._Val);
+        _Get_rest()   = _STD forward<typename tuple<_Other...>::_Mybase>(_Right._Get_rest());
+        return *this;
+    }
+#endif // _HAS_CXX23
+
+    template <class _First, class _Second,
+        enable_if_t<_Tuple_assignable_v<tuple, const _First&, const _Second&>, int> = 0>
+    _CONSTEXPR20 tuple& operator=(const pair<_First, _Second>& _Right) noexcept(
+        _Tuple_nothrow_assignable_v<tuple, const _First&, const _Second&>) /* strengthened */ {
+        _Myfirst._Val             = _Right.first;
+        _Get_rest()._Myfirst._Val = _Right.second;
+        return *this;
+    }
+
+#if _HAS_CXX23
+    template <class _First, class _Second>
+        requires _Tuple_assignable_v<const tuple, const _First&, const _Second&>
+    constexpr const tuple& operator=(const pair<_First, _Second>& _Right) const
+        noexcept(_Tuple_nothrow_assignable_v<const tuple, const _First&, const _Second&>) /* strengthened */ {
+        _Myfirst._Val             = _Right.first;
+        _Get_rest()._Myfirst._Val = _Right.second;
+        return *this;
+    }
+#endif // _HAS_CXX23
+
+    template <class _First, class _Second, enable_if_t<_Tuple_assignable_v<tuple, _First, _Second>, int> = 0>
+    _CONSTEXPR20 tuple& operator=(pair<_First, _Second>&& _Right) noexcept(
+        _Tuple_nothrow_assignable_v<tuple, _First, _Second>) /* strengthened */ {
+        _Myfirst._Val             = _STD forward<_First>(_Right.first);
+        _Get_rest()._Myfirst._Val = _STD forward<_Second>(_Right.second);
+        return *this;
+    }
+
+#if _HAS_CXX23
+    template <class _First, class _Second>
+        requires _Tuple_assignable_v<const tuple, _First, _Second>
+    constexpr const tuple& operator=(pair<_First, _Second>&& _Right) const
+        noexcept(_Tuple_nothrow_assignable_v<const tuple, _First, _Second>) /* strengthened */ {
+        _Myfirst._Val             = _STD forward<_First>(_Right.first);
+        _Get_rest()._Myfirst._Val = _STD forward<_Second>(_Right.second);
+        return *this;
+    }
+
+    template <bool _Const_assignment, class _Other, class _Indices = index_sequence_for<_Rest...>>
+    static constexpr bool _Can_assign_values_from_tuple_like_v = false;
+
+    template <_Tuple_like _Other, size_t... _Indices>
+    static constexpr bool _Can_assign_values_from_tuple_like_v<false, _Other, index_sequence<_Indices...>> =
+        conjunction_v<is_assignable<_This&, decltype(_STD get<0>(_STD declval<_Other>()))>,
+            is_assignable<_Rest&, decltype(_STD get<_Indices + 1>(_STD declval<_Other>()))>...>;
+
+    template <_Tuple_like _Other, size_t... _Indices>
+    static constexpr bool _Can_assign_values_from_tuple_like_v<true, _Other, index_sequence<_Indices...>> =
+        conjunction_v<is_assignable<const _This&, decltype(_STD get<0>(_STD declval<_Other>()))>,
+            is_assignable<const _Rest&, decltype(_STD get<_Indices + 1>(_STD declval<_Other>()))>...>;
+
+    template <_Tuple_like _Other, size_t... _Indices>
+    constexpr void _Assign_tuple_like(_Other&& _Right, index_sequence<_Indices...>) {
+        ((void) (_STD get<_Indices>(*this) = _STD get<_Indices>(_STD forward<_Other>(_Right))), ...);
+    }
+
+    template <_Tuple_like _Other, size_t... _Indices>
+    constexpr void _Assign_tuple_like(_Other&& _Right, index_sequence<_Indices...>) const {
+        ((void) (_STD get<_Indices>(*this) = _STD get<_Indices>(_STD forward<_Other>(_Right))), ...);
+    }
+
+    template <_Different_from<tuple> _Other>
+        requires _Tuple_like<_Other> && (!_Is_subrange_v<remove_cvref_t<_Other>>)
+              && (1 + sizeof...(_Rest) == tuple_size_v<remove_cvref_t<_Other>>)
+              && _Can_assign_values_from_tuple_like_v<false, _Other>
+    constexpr tuple& operator=(_Other&& _Right) {
+        _Assign_tuple_like(_STD forward<_Other>(_Right), make_index_sequence<1 + sizeof...(_Rest)>{});
+        return *this;
+    }
+
+    template <_Different_from<tuple> _Other>
+        requires _Tuple_like<_Other> && (!_Is_subrange_v<remove_cvref_t<_Other>>)
+              && (1 + sizeof...(_Rest) == tuple_size_v<remove_cvref_t<_Other>>)
+              && _Can_assign_values_from_tuple_like_v<true, _Other>
+    constexpr const tuple& operator=(_Other&& _Right) const {
+        _Assign_tuple_like(_STD forward<_Other>(_Right), make_index_sequence<1 + sizeof...(_Rest)>{});
+        return *this;
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 void swap(tuple& _Right) noexcept(
+        conjunction_v<_Is_nothrow_swappable<_This>, _Is_nothrow_swappable<_Rest>...>) {
+        using _STD swap;
+        swap(_Myfirst._Val, _Right._Myfirst._Val); // intentional ADL
+        _Mybase::swap(_Right._Get_rest());
+    }
+
+#if _HAS_CXX23
+    template <int = 0> // see GH-3013
+    constexpr void swap(const tuple& _Right) const
+        noexcept(conjunction_v<is_nothrow_swappable<const _This>, is_nothrow_swappable<const _Rest>...>) {
+        using _STD swap;
+        swap(_Myfirst._Val, _Right._Myfirst._Val); // intentional ADL
+        _Mybase::swap(_Right._Get_rest());
+    }
+#endif // _HAS_CXX23
+
+    constexpr _Mybase& _Get_rest() noexcept { // get reference to rest of elements
+        return *this;
+    }
+
+    constexpr const _Mybase& _Get_rest() const noexcept { // get const reference to rest of elements
+        return *this;
+    }
+
+    template <class... _Other>
+    constexpr bool _Equals(const tuple<_Other...>& _Right) const {
+        return _Myfirst._Val == _Right._Myfirst._Val && _Mybase::_Equals(_Right._Get_rest());
+    }
+
+#if _HAS_CXX20
+    template <class _First, class... _Other>
+    _NODISCARD constexpr common_comparison_category_t<_Synth_three_way_result<_This, _First>,
+        _Synth_three_way_result<_Rest, _Other>...>
+        _Three_way_compare(const tuple<_First, _Other...>& _Right) const {
+        if (auto _Result = _Synth_three_way{}(_Myfirst._Val, _Right._Myfirst._Val); _Result != 0) {
+            return _Result;
+        }
+        return _Mybase::_Three_way_compare(_Right._Get_rest());
+    }
+
+#if _HAS_CXX23
+    template <class _Other, class _Indices = make_index_sequence<1 + sizeof...(_Rest)>>
+    static constexpr bool _Can_equal_compare_with_tuple_like_v = false;
+
+    template <class _Other, size_t... _Indices>
+    static constexpr bool _Can_equal_compare_with_tuple_like_v<_Other, index_sequence<_Indices...>> =
+        (requires(const tuple& _Left, const _Other& _Right) {
+            { _STD get<_Indices>(_Left) == _STD get<_Indices>(_Right) } -> _Boolean_testable;
+        } && ...);
+
+    template <class _Other, size_t... _Indices>
+    _NODISCARD constexpr bool _Equals_to_tuple_like(const _Other& _Right, index_sequence<_Indices...>) const {
+        return ((_STD get<_Indices>(*this) == _STD get<_Indices>(_Right)) && ...);
+    }
+
+    template <_Tuple_like_non_tuple _Other>
+    _NODISCARD friend constexpr bool operator==(const tuple& _Left, const _Other& _Right) {
+        static_assert(1 + sizeof...(_Rest) == tuple_size_v<_Other>,
+            "Cannot compare tuples of different sizes (N4950 [tuple.rel]/2).");
+        static_assert(_Can_equal_compare_with_tuple_like_v<_Other>,
+            "For all i, where 0 <= i < sizeof...(TTypes), get<i>(t) == get<i>(u) must be a valid expression (N4950 "
+            "[tuple.rel]/2).");
+        return _Left._Equals_to_tuple_like(_Right, make_index_sequence<1 + sizeof...(_Rest)>{});
+    }
+
+    template <class _Other, size_t... _Indices>
+    _NODISCARD constexpr auto _Three_way_compare_with_tuple_like(
+        const _Other& _Right, index_sequence<_Indices...>) const {
+        _Three_way_comparison_result_with_tuple_like_t<tuple, _Other> _Result = strong_ordering::equal;
+        (void) (((_Result = _Synth_three_way{}(_STD get<_Indices>(*this), _STD get<_Indices>(_Right))) == 0) && ...);
+        return _Result;
+    }
+
+    template <_Tuple_like_non_tuple _Other>
+    _NODISCARD friend constexpr auto operator<=>(const tuple& _Left, const _Other& _Right)
+        -> _Three_way_comparison_result_with_tuple_like_t<tuple, _Other> {
+        return _Left._Three_way_compare_with_tuple_like(_Right, make_index_sequence<1 + sizeof...(_Rest)>{});
+    }
+#endif // _HAS_CXX23
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    template <class... _Other>
+    _NODISCARD constexpr bool _Less(const tuple<_Other...>& _Right) const {
+        return _Myfirst._Val < _Right._Myfirst._Val
+            || (!(_Right._Myfirst._Val < _Myfirst._Val) && _Mybase::_Less(_Right._Get_rest()));
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    template <size_t _Index, class... _Types>
+    friend constexpr tuple_element_t<_Index, tuple<_Types...>>& get(tuple<_Types...>& _Tuple) noexcept;
+
+    template <size_t _Index, class... _Types>
+    friend constexpr const tuple_element_t<_Index, tuple<_Types...>>& get(const tuple<_Types...>& _Tuple) noexcept;
+
+    template <size_t _Index, class... _Types>
+    friend constexpr tuple_element_t<_Index, tuple<_Types...>>&& get(tuple<_Types...>&& _Tuple) noexcept;
+
+    template <size_t _Index, class... _Types>
+    friend constexpr const tuple_element_t<_Index, tuple<_Types...>>&& get(const tuple<_Types...>&& _Tuple) noexcept;
+
+    template <size_t _Index, class... _Types>
+    friend constexpr auto&& _Tuple_get(tuple<_Types...>&& _Tuple) noexcept;
+
+    template <class _Ty, class... _Types>
+    friend constexpr _Ty& get(tuple<_Types...>& _Tuple) noexcept;
+
+    template <class _Ty, class... _Types>
+    friend constexpr const _Ty& get(const tuple<_Types...>& _Tuple) noexcept;
+
+    template <class _Ty, class... _Types>
+    friend constexpr _Ty&& get(tuple<_Types...>&& _Tuple) noexcept;
+
+    template <class _Ty, class... _Types>
+    friend constexpr const _Ty&& get(const tuple<_Types...>&& _Tuple) noexcept;
+
+    _Tuple_val<_This> _Myfirst; // the stored element
+};
+
+#if _HAS_CXX17
+template <class... _Types>
+tuple(_Types...) -> tuple<_Types...>;
+
+template <class _Ty1, class _Ty2>
+tuple(pair<_Ty1, _Ty2>) -> tuple<_Ty1, _Ty2>;
+
+template <class _Alloc, class... _Types>
+tuple(allocator_arg_t, _Alloc, _Types...) -> tuple<_Types...>;
+
+template <class _Alloc, class _Ty1, class _Ty2>
+tuple(allocator_arg_t, _Alloc, pair<_Ty1, _Ty2>) -> tuple<_Ty1, _Ty2>;
+
+template <class _Alloc, class... _Types>
+tuple(allocator_arg_t, _Alloc, tuple<_Types...>) -> tuple<_Types...>;
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class... _Types1, class... _Types2>
+_NODISCARD constexpr bool operator==(const tuple<_Types1...>& _Left, const tuple<_Types2...>& _Right) {
+    static_assert(
+        sizeof...(_Types1) == sizeof...(_Types2), "Cannot compare tuples of different sizes (N4950 [tuple.rel]/2).");
+    return _Left._Equals(_Right);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class... _Types1, class... _Types2>
+_NODISCARD constexpr common_comparison_category_t<_Synth_three_way_result<_Types1, _Types2>...> operator<=>(
+    const tuple<_Types1...>& _Left, const tuple<_Types2...>& _Right) {
+    return _Left._Three_way_compare(_Right);
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class... _Types1, class... _Types2>
+_NODISCARD constexpr bool operator!=(const tuple<_Types1...>& _Left, const tuple<_Types2...>& _Right) {
+    return !(_Left == _Right);
+}
+
+template <class... _Types1, class... _Types2>
+_NODISCARD constexpr bool operator<(const tuple<_Types1...>& _Left, const tuple<_Types2...>& _Right) {
+    static_assert(sizeof...(_Types1) == sizeof...(_Types2), "cannot compare tuples of different sizes");
+    return _Left._Less(_Right);
+}
+
+template <class... _Types1, class... _Types2>
+_NODISCARD constexpr bool operator>=(const tuple<_Types1...>& _Left, const tuple<_Types2...>& _Right) {
+    return !(_Left < _Right);
+}
+
+template <class... _Types1, class... _Types2>
+_NODISCARD constexpr bool operator>(const tuple<_Types1...>& _Left, const tuple<_Types2...>& _Right) {
+    return _Right < _Left;
+}
+
+template <class... _Types1, class... _Types2>
+_NODISCARD constexpr bool operator<=(const tuple<_Types1...>& _Left, const tuple<_Types2...>& _Right) {
+    return !(_Right < _Left);
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+_EXPORT_STD template <class... _Types, enable_if_t<conjunction_v<_Is_swappable<_Types>...>, int> = 0>
+_CONSTEXPR20 void swap(tuple<_Types...>& _Left, tuple<_Types...>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+
+#if _HAS_CXX23
+_EXPORT_STD template <class... _Types>
+    requires conjunction_v<is_swappable<const _Types>...>
+constexpr void swap(const tuple<_Types...>& _Left, const tuple<_Types...>& _Right) noexcept(
+    noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+#endif // _HAS_CXX23
+
+_EXPORT_STD template <size_t _Index, class... _Types>
+_NODISCARD constexpr tuple_element_t<_Index, tuple<_Types...>>& get(tuple<_Types...>& _Tuple) noexcept {
+    using _Ttype = typename tuple_element<_Index, tuple<_Types...>>::_Ttype;
+    return static_cast<_Ttype&>(_Tuple)._Myfirst._Val;
+}
+
+_EXPORT_STD template <size_t _Index, class... _Types>
+_NODISCARD constexpr const tuple_element_t<_Index, tuple<_Types...>>& get(const tuple<_Types...>& _Tuple) noexcept {
+    using _Ttype = typename tuple_element<_Index, tuple<_Types...>>::_Ttype;
+    return static_cast<const _Ttype&>(_Tuple)._Myfirst._Val;
+}
+
+_EXPORT_STD template <size_t _Index, class... _Types>
+_NODISCARD constexpr tuple_element_t<_Index, tuple<_Types...>>&& get(tuple<_Types...>&& _Tuple) noexcept {
+    using _Ty    = tuple_element_t<_Index, tuple<_Types...>>;
+    using _Ttype = typename tuple_element<_Index, tuple<_Types...>>::_Ttype;
+    return static_cast<_Ty&&>(static_cast<_Ttype&>(_Tuple)._Myfirst._Val);
+}
+
+_EXPORT_STD template <size_t _Index, class... _Types>
+_NODISCARD constexpr const tuple_element_t<_Index, tuple<_Types...>>&& get(const tuple<_Types...>&& _Tuple) noexcept {
+    using _Ty    = tuple_element_t<_Index, tuple<_Types...>>;
+    using _Ttype = typename tuple_element<_Index, tuple<_Types...>>::_Ttype;
+    return static_cast<const _Ty&&>(static_cast<const _Ttype&>(_Tuple)._Myfirst._Val);
+}
+
+template <size_t _Index, class... _Types>
+_NODISCARD constexpr auto&& _Tuple_get(tuple<_Types...>&& _Tuple) noexcept {
+    // used by pair's piecewise constructor
+    using _Ty    = tuple_element_t<_Index, tuple<_Types...>>;
+    using _Ttype = typename tuple_element<_Index, tuple<_Types...>>::_Ttype;
+    return static_cast<_Ty&&>(static_cast<_Ttype&>(_Tuple)._Myfirst._Val);
+}
+
+_EXPORT_STD template <class _Ty, class... _Types>
+_NODISCARD constexpr _Ty& get(tuple<_Types...>& _Tuple) noexcept {
+    constexpr size_t _Idx = _Meta_find_unique_index<tuple<_Types...>, _Ty>::value;
+    if constexpr (_Idx < sizeof...(_Types)) {
+        using _Ttype = typename tuple_element<_Idx, tuple<_Types...>>::_Ttype;
+        return static_cast<_Ttype&>(_Tuple)._Myfirst._Val;
+    } else {
+        static_assert(false, "get<T>(tuple<Types...>&) "
+                             "requires T to occur exactly once in Types. (N4971 [tuple.elem]/5)");
+    }
+}
+
+_EXPORT_STD template <class _Ty, class... _Types>
+_NODISCARD constexpr const _Ty& get(const tuple<_Types...>& _Tuple) noexcept {
+    constexpr size_t _Idx = _Meta_find_unique_index<tuple<_Types...>, _Ty>::value;
+    if constexpr (_Idx < sizeof...(_Types)) {
+        using _Ttype = typename tuple_element<_Idx, tuple<_Types...>>::_Ttype;
+        return static_cast<const _Ttype&>(_Tuple)._Myfirst._Val;
+    } else {
+        static_assert(false, "get<T>(const tuple<Types...>&) "
+                             "requires T to occur exactly once in Types. (N4971 [tuple.elem]/5)");
+    }
+}
+
+_EXPORT_STD template <class _Ty, class... _Types>
+_NODISCARD constexpr _Ty&& get(tuple<_Types...>&& _Tuple) noexcept {
+    constexpr size_t _Idx = _Meta_find_unique_index<tuple<_Types...>, _Ty>::value;
+    if constexpr (_Idx < sizeof...(_Types)) {
+        using _Ttype = typename tuple_element<_Idx, tuple<_Types...>>::_Ttype;
+        return static_cast<_Ty&&>(static_cast<_Ttype&>(_Tuple)._Myfirst._Val);
+    } else {
+        static_assert(false, "get<T>(tuple<Types...>&&) "
+                             "requires T to occur exactly once in Types. (N4971 [tuple.elem]/5)");
+    }
+}
+
+_EXPORT_STD template <class _Ty, class... _Types>
+_NODISCARD constexpr const _Ty&& get(const tuple<_Types...>&& _Tuple) noexcept {
+    constexpr size_t _Idx = _Meta_find_unique_index<tuple<_Types...>, _Ty>::value;
+    if constexpr (_Idx < sizeof...(_Types)) {
+        using _Ttype = typename tuple_element<_Idx, tuple<_Types...>>::_Ttype;
+        return static_cast<const _Ty&&>(static_cast<const _Ttype&>(_Tuple)._Myfirst._Val);
+    } else {
+        static_assert(false, "get<T>(const tuple<Types...>&&) "
+                             "requires T to occur exactly once in Types. (N4971 [tuple.elem]/5)");
+    }
+}
+
+template <class _This, class... _Rest>
+template <class _Tag, class _Tpl, size_t... _Indices, enable_if_t<is_same_v<_Tag, _STD _Unpack_tuple_t>, int> /* = 0 */>
+constexpr tuple<_This, _Rest...>::tuple(_Tag, _Tpl&& _Right, index_sequence<_Indices...>)
+    : tuple(_Exact_args_t{}, _STD get<_Indices>(_STD forward<_Tpl>(_Right))...) {}
+
+template <class _This, class... _Rest>
+template <class _Tag, class _Alloc, class _Tpl, size_t... _Indices,
+    enable_if_t<is_same_v<_Tag, _STD _Alloc_unpack_tuple_t>, int> /* = 0 */>
+constexpr tuple<_This, _Rest...>::tuple(_Tag, const _Alloc& _Al, _Tpl&& _Right, index_sequence<_Indices...>)
+    : tuple(_Alloc_exact_args_t{}, _Al, _STD get<_Indices>(_STD forward<_Tpl>(_Right))...) {}
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD constexpr tuple<_Unrefwrap_t<_Types>...> make_tuple(_Types&&... _Args) { // make tuple from elements
+    using _Ttype = tuple<_Unrefwrap_t<_Types>...>;
+    return _Ttype(_STD forward<_Types>(_Args)...);
+}
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD constexpr tuple<_Types&...> tie(_Types&... _Args) noexcept { // make tuple from elements
+    using _Ttype = tuple<_Types&...>;
+    return _Ttype(_Args...);
+}
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD constexpr tuple<_Types&&...> forward_as_tuple(_Types&&... _Args) noexcept { // forward arguments in a tuple
+    return tuple<_Types&&...>(_STD forward<_Types>(_Args)...);
+}
+
+template <class _Ty, class _Kx_arg, class _Ix_arg, size_t _Ix_next, class... _Sequences>
+struct _Tuple_cat2;
+
+template <class _Ty, size_t... _Kx, size_t... _Ix, size_t _Ix_next>
+struct _Tuple_cat2<_Ty, index_sequence<_Kx...>, index_sequence<_Ix...>, _Ix_next> {
+    using _Ret    = tuple<tuple_element_t<_Kx, _Remove_cvref_t<tuple_element_t<_Ix, _Ty>>>...>;
+    using _Kx_seq = index_sequence<_Kx...>;
+    using _Ix_seq = index_sequence<_Ix...>;
+};
+
+template <class _Ty, size_t... _Kx, size_t... _Ix, size_t _Ix_next, size_t... _Kx_next, class... _Rest>
+struct _Tuple_cat2<_Ty, index_sequence<_Kx...>, index_sequence<_Ix...>, _Ix_next, index_sequence<_Kx_next...>, _Rest...>
+    : _Tuple_cat2<_Ty, index_sequence<_Kx..., _Kx_next...>,
+          index_sequence<_Ix..., (_Ix_next + 0 * _Kx_next)...>, // repeat _Ix_next, ignoring the elements of _Kx_next
+          _Ix_next + 1, _Rest...> {};
+
+#if _HAS_CXX23
+template <_Tuple_like... _Tuples>
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+template <class... _Tuples>
+#endif // ^^^ !_HAS_CXX23 ^^^
+using _Tuple_cat1 = _Tuple_cat2<tuple<_Tuples&&...>, index_sequence<>, index_sequence<>, 0,
+    make_index_sequence<tuple_size_v<_Remove_cvref_t<_Tuples>>>...>;
+
+template <class _Ret, size_t... _Kx, size_t... _Ix, class _Ty>
+constexpr _Ret _Tuple_cat(index_sequence<_Kx...>, index_sequence<_Ix...>, _Ty _Arg) {
+    return _Ret{_STD get<_Kx>(_STD get<_Ix>(_STD move(_Arg)))...};
+}
+
+#if _HAS_CXX23
+_EXPORT_STD template <_Tuple_like... _Tuples>
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+_EXPORT_STD template <class... _Tuples>
+#endif // ^^^ !_HAS_CXX23 ^^^
+_NODISCARD constexpr typename _Tuple_cat1<_Tuples...>::_Ret tuple_cat(_Tuples&&... _Tpls) { // concatenate tuples
+    using _Cat1   = _Tuple_cat1<_Tuples...>;
+    using _Ret    = typename _Cat1::_Ret;
+    using _Kx_seq = typename _Cat1::_Kx_seq;
+    using _Ix_seq = typename _Cat1::_Ix_seq;
+    return _STD _Tuple_cat<_Ret>(_Kx_seq{}, _Ix_seq{}, _STD forward_as_tuple(_STD forward<_Tuples>(_Tpls)...));
+}
+
+#if _HAS_CXX17
+#if _HAS_CXX23
+template <class _Callable, _Tuple_like _Tuple, size_t... _Indices>
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+template <class _Callable, class _Tuple, size_t... _Indices>
+#endif // ^^^ !_HAS_CXX23 ^^^
+constexpr decltype(auto) _Apply_impl(_Callable&& _Obj, _Tuple&& _Tpl, index_sequence<_Indices...>) noexcept(
+    noexcept(_STD invoke(_STD forward<_Callable>(_Obj), _STD get<_Indices>(_STD forward<_Tuple>(_Tpl))...))) {
+    return _STD invoke(_STD forward<_Callable>(_Obj), _STD get<_Indices>(_STD forward<_Tuple>(_Tpl))...);
+}
+
+#if _HAS_CXX23
+_EXPORT_STD template <class _Callable, _Tuple_like _Tuple>
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+_EXPORT_STD template <class _Callable, class _Tuple>
+#endif // ^^^ !_HAS_CXX23 ^^^
+constexpr decltype(auto) apply(_Callable&& _Obj, _Tuple&& _Tpl) noexcept(
+    noexcept(_STD _Apply_impl(_STD forward<_Callable>(_Obj), _STD forward<_Tuple>(_Tpl),
+        make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{}))) {
+    return _STD _Apply_impl(_STD forward<_Callable>(_Obj), _STD forward<_Tuple>(_Tpl),
+        make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{});
+}
+
+template <class _Ty, class _Tuple, class _Seq = make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>>
+constexpr bool _Can_make_from_tuple = false;
+template <class _Ty, class _Tuple, size_t... _Indices>
+constexpr bool _Can_make_from_tuple<_Ty, _Tuple, index_sequence<_Indices...>> =
+    is_constructible_v<_Ty, decltype(_STD get<_Indices>(_STD declval<_Tuple>()))...>;
+
+template <class _Ty, class _Tuple, size_t... _Indices>
+constexpr _Ty _Make_from_tuple_impl(_Tuple&& _Tpl, index_sequence<_Indices...>) noexcept(
+    is_nothrow_constructible_v<_Ty, decltype(_STD get<_Indices>(_STD forward<_Tuple>(_Tpl)))...>) {
+    return _Ty(_STD get<_Indices>(_STD forward<_Tuple>(_Tpl))...);
+}
+
+#if _HAS_CXX23
+_EXPORT_STD template <class _Ty, _Tuple_like _Tuple>
+    requires _Can_make_from_tuple<_Ty, _Tuple>
+#elif _HAS_CXX20
+_EXPORT_STD template <class _Ty, class _Tuple>
+    requires _Can_make_from_tuple<_Ty, _Tuple>
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Ty, class _Tuple, enable_if_t<_Can_make_from_tuple<_Ty, _Tuple>, int> = 0>
+#endif // ^^^ !_HAS_CXX20 ^^^
+_NODISCARD constexpr _Ty make_from_tuple(_Tuple&& _Tpl) noexcept(noexcept(_STD _Make_from_tuple_impl<_Ty>(
+    _STD forward<_Tuple>(_Tpl), make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{}))) /* strengthened */ {
+    // construct _Ty from the elements of _Tpl
+    return _STD _Make_from_tuple_impl<_Ty>(
+        _STD forward<_Tuple>(_Tpl), make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{});
+}
+#endif // _HAS_CXX17
+
+template <class... _Types, class _Alloc>
+struct uses_allocator<tuple<_Types...>, _Alloc> : true_type {}; // true_type if container allocator enabled
+
+#if _HAS_CXX23
+template <_Tuple_like _TTuple, _Tuple_like _UTuple, template <class> class _TQual, template <class> class _UQual,
+    class _Indices = make_index_sequence<tuple_size_v<_TTuple>>>
+struct _Tuple_like_common_reference;
+
+template <class _TTuple, class _UTuple, template <class> class _TQual, template <class> class _UQual,
+    size_t... _Indices>
+    requires requires {
+        typename tuple<common_reference_t<_TQual<tuple_element_t<_Indices, _TTuple>>,
+            _UQual<tuple_element_t<_Indices, _UTuple>>>...>;
+    }
+struct _Tuple_like_common_reference<_TTuple, _UTuple, _TQual, _UQual, index_sequence<_Indices...>> {
+    using type = tuple<
+        common_reference_t<_TQual<tuple_element_t<_Indices, _TTuple>>, _UQual<tuple_element_t<_Indices, _UTuple>>>...>;
+};
+
+template <_Tuple_like _TTuple, _Tuple_like _UTuple, template <class> class _TQual, template <class> class _UQual>
+    requires (_Is_specialization_v<_TTuple, tuple> || _Is_specialization_v<_UTuple, tuple>)
+          && is_same_v<_TTuple, decay_t<_TTuple>> && is_same_v<_UTuple, decay_t<_UTuple>>
+          && (tuple_size_v<_TTuple> == tuple_size_v<_UTuple>) && requires {
+                 typename _Tuple_like_common_reference<_TTuple, _UTuple, _TQual, _UQual>::type;
+             }
+struct basic_common_reference<_TTuple, _UTuple, _TQual, _UQual> {
+    using type = _Tuple_like_common_reference<_TTuple, _UTuple, _TQual, _UQual>::type;
+};
+
+template <_Tuple_like _TTuple, _Tuple_like _UTuple, class _Indices = make_index_sequence<tuple_size_v<_TTuple>>>
+struct _Tuple_like_common_type;
+
+template <class _TTuple, class _UTuple, size_t... _Indices>
+    requires requires {
+        typename tuple<common_type_t<tuple_element_t<_Indices, _TTuple>, tuple_element_t<_Indices, _UTuple>>...>;
+    }
+struct _Tuple_like_common_type<_TTuple, _UTuple, index_sequence<_Indices...>> {
+    using type = tuple<common_type_t<tuple_element_t<_Indices, _TTuple>, tuple_element_t<_Indices, _UTuple>>...>;
+};
+
+template <_Tuple_like _TTuple, _Tuple_like _UTuple>
+    requires (_Is_specialization_v<_TTuple, tuple> || _Is_specialization_v<_UTuple, tuple>)
+          && is_same_v<_TTuple, decay_t<_TTuple>> && is_same_v<_UTuple, decay_t<_UTuple>>
+          && (tuple_size_v<_TTuple> == tuple_size_v<_UTuple>) && requires {
+                 typename _Tuple_like_common_type<_TTuple, _UTuple>::type;
+             }
+struct common_type<_TTuple, _UTuple> {
+    using type = _Tuple_like_common_type<_TTuple, _UTuple>::type;
+};
+#endif // _HAS_CXX23
+
+#if _HAS_TR1_NAMESPACE
+namespace _DEPRECATE_TR1_NAMESPACE tr1 {
+    using _STD get;
+    using _STD ignore;
+    using _STD make_tuple;
+    using _STD ref;
+    using _STD tie;
+    using _STD tuple;
+} // namespace _DEPRECATE_TR1_NAMESPACE tr1
+#endif // _HAS_TR1_NAMESPACE
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _TUPLE_

miniMSVC/VC/Tools/MSVC/14.42.34433/include/typeindex

@@ -0,0 +1,95 @@
+// typeindex standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _TYPEINDEX_
+#define _TYPEINDEX_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <typeinfo>
+
+#if _HAS_CXX20
+#include <compare>
+#include <cstring>
+#endif // _HAS_CXX20
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD class type_index { // wraps a typeinfo for indexing
+public:
+    type_index(const type_info& _Tinfo) noexcept : _Tptr(&_Tinfo) {}
+
+    _NODISCARD size_t hash_code() const noexcept {
+        return _Tptr->hash_code();
+    }
+
+    _NODISCARD const char* name() const noexcept {
+        return _Tptr->name();
+    }
+
+    _NODISCARD bool operator==(const type_index& _Right) const noexcept {
+        return *_Tptr == *_Right._Tptr;
+    }
+
+#if _HAS_CXX20
+    _NODISCARD strong_ordering operator<=>(const type_index& _Right) const noexcept {
+        // TRANSITION, DevCom-10326599, should rely on a stable interface
+        if (_Tptr == _Right._Tptr) {
+            return strong_ordering::equal;
+        }
+
+#pragma push_macro("raw_name") // TRANSITION, GH-2195
+#undef raw_name
+        return _CSTD strcmp(_Tptr->raw_name() + 1, _Right._Tptr->raw_name() + 1) <=> 0;
+#pragma pop_macro("raw_name")
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD bool operator!=(const type_index& _Right) const noexcept {
+        return !(*this == _Right);
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    _NODISCARD bool operator<(const type_index& _Right) const noexcept {
+        return _Tptr->before(*_Right._Tptr);
+    }
+
+    _NODISCARD bool operator>=(const type_index& _Right) const noexcept {
+        return !(*this < _Right);
+    }
+
+    _NODISCARD bool operator>(const type_index& _Right) const noexcept {
+        return _Right < *this;
+    }
+
+    _NODISCARD bool operator<=(const type_index& _Right) const noexcept {
+        return !(_Right < *this);
+    }
+
+private:
+    const type_info* _Tptr;
+};
+
+template <>
+struct hash<type_index> {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = type_index;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
+
+    _NODISCARD _STATIC_CALL_OPERATOR size_t operator()(const type_index& _Keyval) _CONST_CALL_OPERATOR noexcept {
+        return _Keyval.hash_code();
+    }
+};
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _TYPEINDEX_

miniMSVC/VC/Tools/MSVC/14.42.34433/include/typeinfo

@@ -0,0 +1,73 @@
+// typeinfo standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _TYPEINFO_
+#define _TYPEINFO_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <exception>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+#pragma warning(disable : 4275) // non dll-interface class 'X' used as base for dll-interface class 'Y'
+
+#pragma push_macro("raw_name") // TRANSITION, GH-2195
+#undef raw_name
+#include <vcruntime_typeinfo.h>
+#pragma pop_macro("raw_name")
+
+_STD_BEGIN
+
+// size in pointers of std::function and std::any (roughly 3 pointers larger than std::string when building debug)
+_INLINE_VAR constexpr int _Small_object_num_ptrs = 6 + 16 / sizeof(void*);
+
+#if !_HAS_EXCEPTIONS
+_EXPORT_STD class bad_cast : public exception { // base of all bad cast exceptions
+public:
+    bad_cast(const char* _Message = "bad cast") noexcept : exception(_Message) {}
+
+    ~bad_cast() noexcept override {}
+
+protected:
+    void _Doraise() const override { // perform class-specific exception handling
+        _RAISE(*this);
+    }
+};
+
+_EXPORT_STD class bad_typeid : public exception { // base of all bad typeid exceptions
+public:
+    bad_typeid(const char* _Message = "bad typeid") noexcept : exception(_Message) {}
+
+    ~bad_typeid() noexcept override {}
+
+protected:
+    void _Doraise() const override { // perform class-specific exception handling
+        _RAISE(*this);
+    }
+};
+
+class __non_rtti_object : public bad_typeid { // report a non-RTTI object
+public:
+    __non_rtti_object(const char* _Message) : bad_typeid(_Message) {}
+};
+#endif // ^^^ !_HAS_EXCEPTIONS ^^^
+
+[[noreturn]] inline void _Throw_bad_cast() {
+    _THROW(bad_cast{});
+}
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma pack(pop)
+#pragma warning(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _TYPEINFO_

miniMSVC/VC/Tools/MSVC/14.42.34433/include/unordered_map

@@ -0,0 +1,944 @@
+// unordered_map standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _UNORDERED_MAP_
+#define _UNORDERED_MAP_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <xhash>
+
+#if _HAS_CXX17
+#include <xpolymorphic_allocator.h>
+#endif // _HAS_CXX17
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+template <class _Kty, // key type
+    class _Ty, // mapped type
+    class _Tr, // comparator predicate type
+    class _Alloc, // actual allocator type (should be value allocator)
+    bool _Mfl> // true if multiple equivalent keys are permitted
+class _Umap_traits : public _Tr { // traits required to make _Hash behave like a map
+public:
+    using key_type            = _Kty;
+    using value_type          = pair<const _Kty, _Ty>;
+    using _Mutable_value_type = pair<_Kty, _Ty>;
+    using key_compare         = _Tr;
+    using allocator_type      = _Alloc;
+#if _HAS_CXX17
+    using node_type = _Node_handle<_List_node<value_type, typename allocator_traits<_Alloc>::void_pointer>, _Alloc,
+        _Node_handle_map_base, _Kty, _Ty>;
+#endif // _HAS_CXX17
+
+    static constexpr bool _Multi    = _Mfl;
+    static constexpr bool _Standard = true;
+
+    template <class... _Args>
+    using _In_place_key_extractor = _In_place_key_extract_map<_Kty, _Args...>;
+
+    _Umap_traits() = default;
+
+    explicit _Umap_traits(const _Tr& _Traits) noexcept(is_nothrow_copy_constructible_v<_Tr>) : _Tr(_Traits) {}
+
+    using value_compare = void; // TRANSITION, remove when _Standard becomes unconditionally true
+
+    template <class _Ty1, class _Ty2>
+    static const _Kty& _Kfn(const pair<_Ty1, _Ty2>& _Val) noexcept { // extract key from element value
+        return _Val.first;
+    }
+};
+
+_EXPORT_STD template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>,
+    class _Alloc = allocator<pair<const _Kty, _Ty>>>
+class unordered_map : public _Hash<_Umap_traits<_Kty, _Ty, _Uhash_compare<_Kty, _Hasher, _Keyeq>, _Alloc, false>> {
+    // hash table of {key, mapped} values, unique keys
+public:
+    static_assert(!_ENFORCE_MATCHING_ALLOCATORS || is_same_v<pair<const _Kty, _Ty>, typename _Alloc::value_type>,
+        _MISMATCHED_ALLOCATOR_MESSAGE("unordered_map<Key, Value, Hasher, Eq, Allocator>", "pair<const Key, Value>"));
+    static_assert(is_object_v<_Kty>, "The C++ Standard forbids containers of non-object types "
+                                     "because of [container.requirements].");
+
+private:
+    using _Mytraits      = _Uhash_compare<_Kty, _Hasher, _Keyeq>;
+    using _Mybase        = _Hash<_Umap_traits<_Kty, _Ty, _Mytraits, _Alloc, false>>;
+    using _Alnode        = typename _Mybase::_Alnode;
+    using _Alnode_traits = typename _Mybase::_Alnode_traits;
+    using _Nodeptr       = typename _Mybase::_Nodeptr;
+    using _Key_compare   = typename _Mybase::_Key_compare;
+
+public:
+    using hasher      = _Hasher;
+    using key_type    = _Kty;
+    using mapped_type = _Ty;
+    using key_equal   = _Keyeq;
+
+    using value_type      = pair<const _Kty, _Ty>;
+    using allocator_type  = typename _Mybase::allocator_type;
+    using size_type       = typename _Mybase::size_type;
+    using difference_type = typename _Mybase::difference_type;
+    using pointer         = typename _Mybase::pointer;
+    using const_pointer   = typename _Mybase::const_pointer;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+    using iterator        = typename _Mybase::iterator;
+    using const_iterator  = typename _Mybase::const_iterator;
+
+    using local_iterator       = typename _Mybase::iterator;
+    using const_local_iterator = typename _Mybase::const_iterator;
+
+#if _HAS_CXX17
+    using insert_return_type = _Insert_return_type<iterator, typename _Mybase::node_type>;
+#endif // _HAS_CXX17
+
+    unordered_map() : _Mybase(_Key_compare(), allocator_type()) {}
+
+    explicit unordered_map(const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {}
+
+    unordered_map(const unordered_map& _Right)
+        : _Mybase(_Right, _Alnode_traits::select_on_container_copy_construction(_Right._Getal())) {}
+
+    unordered_map(const unordered_map& _Right, const allocator_type& _Al) : _Mybase(_Right, _Al) {}
+
+    explicit unordered_map(size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+    }
+
+    unordered_map(size_type _Buckets, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        _Mybase::rehash(_Buckets);
+    }
+
+    unordered_map(size_type _Buckets, const hasher& _Hasharg) : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+    }
+
+    unordered_map(size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        _Mybase::rehash(_Buckets);
+    }
+
+    unordered_map(size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+    }
+
+    unordered_map(size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        _Mybase::rehash(_Buckets);
+    }
+
+    template <class _Iter>
+    unordered_map(_Iter _First, _Iter _Last) : _Mybase(_Key_compare(), allocator_type()) {
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_map(_Iter _First, _Iter _Last, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_map(_Iter _First, _Iter _Last, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_map(_Iter _First, _Iter _Last, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        _Mybase::rehash(_Buckets);
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_map(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_map(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        _Mybase::rehash(_Buckets);
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_map(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_map(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg,
+        const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        _Mybase::rehash(_Buckets);
+        insert(_First, _Last);
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_map(from_range_t, _Rng&& _Range) : _Mybase(_Key_compare(), allocator_type()) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_map(from_range_t, _Rng&& _Range, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_map(from_range_t, _Rng&& _Range, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_map(from_range_t, _Rng&& _Range, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_map(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_map(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_map(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_map(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg,
+        const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // _HAS_CXX23
+
+    unordered_map& operator=(const unordered_map& _Right) {
+        _Mybase::operator=(_Right);
+        return *this;
+    }
+
+    unordered_map(unordered_map&& _Right) : _Mybase(_STD move(_Right)) {}
+
+    unordered_map(unordered_map&& _Right, const allocator_type& _Al) : _Mybase(_STD move(_Right), _Al) {}
+
+    unordered_map& operator=(unordered_map&& _Right) noexcept(_Alnode_traits::is_always_equal::value
+                                                              && is_nothrow_move_assignable_v<_Hasher>
+                                                              && is_nothrow_move_assignable_v<_Keyeq>) {
+        _Mybase::operator=(_STD move(_Right));
+        return *this;
+    }
+
+    mapped_type& operator[](key_type&& _Keyval) {
+        return this->_Try_emplace(_STD move(_Keyval)).first->_Myval.second;
+    }
+
+    void swap(unordered_map& _Right) noexcept(noexcept(_Mybase::swap(_Right))) {
+        _Mybase::swap(_Right);
+    }
+
+    using _Mybase::insert;
+
+    template <class _Valty, enable_if_t<is_constructible_v<value_type, _Valty>, int> = 0>
+    pair<iterator, bool> insert(_Valty&& _Val) {
+        return this->emplace(_STD forward<_Valty>(_Val));
+    }
+
+    template <class _Valty, enable_if_t<is_constructible_v<value_type, _Valty>, int> = 0>
+    iterator insert(const_iterator _Where, _Valty&& _Val) {
+        return this->emplace_hint(_Where, _STD forward<_Valty>(_Val));
+    }
+
+    template <class... _Mappedty>
+    pair<iterator, bool> try_emplace(const key_type& _Keyval, _Mappedty&&... _Mapval) {
+        const auto _Result = this->_Try_emplace(_Keyval, _STD forward<_Mappedty>(_Mapval)...);
+        return {this->_List._Make_iter(_Result.first), _Result.second};
+    }
+
+    template <class... _Mappedty>
+    pair<iterator, bool> try_emplace(key_type&& _Keyval, _Mappedty&&... _Mapval) {
+        const auto _Result = this->_Try_emplace(_STD move(_Keyval), _STD forward<_Mappedty>(_Mapval)...);
+        return {this->_List._Make_iter(_Result.first), _Result.second};
+    }
+
+    template <class... _Mappedty>
+    iterator try_emplace(const const_iterator _Hint, const key_type& _Keyval, _Mappedty&&... _Mapval) {
+        return this->_List._Make_iter(
+            this->_Try_emplace_hint(_Hint._Ptr, _Keyval, _STD forward<_Mappedty>(_Mapval)...));
+    }
+
+    template <class... _Mappedty>
+    iterator try_emplace(const const_iterator _Hint, key_type&& _Keyval, _Mappedty&&... _Mapval) {
+        return this->_List._Make_iter(
+            this->_Try_emplace_hint(_Hint._Ptr, _STD move(_Keyval), _STD forward<_Mappedty>(_Mapval)...));
+    }
+
+private:
+    template <class _Keyty, class _Mappedty>
+    pair<iterator, bool> _Insert_or_assign(_Keyty&& _Keyval_arg, _Mappedty&& _Mapval) {
+        const auto& _Keyval   = _Keyval_arg;
+        const size_t _Hashval = this->_Traitsobj(_Keyval);
+        auto _Target          = this->_Find_last(_Keyval, _Hashval);
+        if (_Target._Duplicate) {
+            _Target._Duplicate->_Myval.second = _STD forward<_Mappedty>(_Mapval);
+            return {this->_List._Make_iter(_Target._Duplicate), false};
+        }
+
+        this->_Check_max_size();
+        // invalidates _Keyval:
+        _List_node_emplace_op2<_Alnode> _Newnode(
+            this->_Getal(), _STD forward<_Keyty>(_Keyval_arg), _STD forward<_Mappedty>(_Mapval));
+        if (this->_Check_rehash_required_1()) {
+            this->_Rehash_for_1();
+            _Target = this->_Find_last(_Newnode._Ptr->_Myval.first, _Hashval);
+        }
+
+        return {this->_List._Make_iter(
+                    this->_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release())),
+            true};
+    }
+
+    template <class _Keyty, class _Mappedty>
+    iterator _Insert_or_assign(const _Nodeptr _Hint, _Keyty&& _Keyval_arg, _Mappedty&& _Mapval) {
+        const auto& _Keyval   = _Keyval_arg;
+        const size_t _Hashval = this->_Traitsobj(_Keyval);
+        auto _Target          = this->_Find_hint(_Hint, _Keyval, _Hashval);
+        if (_Target._Duplicate) {
+            _Target._Duplicate->_Myval.second = _STD forward<_Mappedty>(_Mapval);
+            return this->_List._Make_iter(_Target._Duplicate);
+        }
+
+        this->_Check_max_size();
+        // invalidates _Keyval:
+        _List_node_emplace_op2<_Alnode> _Newnode(
+            this->_Getal(), _STD forward<_Keyty>(_Keyval_arg), _STD forward<_Mappedty>(_Mapval));
+        if (this->_Check_rehash_required_1()) {
+            this->_Rehash_for_1();
+            _Target = this->_Find_hint(_Hint, _Newnode._Ptr->_Myval.first, _Hashval);
+        }
+
+        return this->_List._Make_iter(
+            this->_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release()));
+    }
+
+public:
+    template <class _Mappedty>
+    pair<iterator, bool> insert_or_assign(const key_type& _Keyval, _Mappedty&& _Mapval) {
+        return _Insert_or_assign(_Keyval, _STD forward<_Mappedty>(_Mapval));
+    }
+
+    template <class _Mappedty>
+    pair<iterator, bool> insert_or_assign(key_type&& _Keyval, _Mappedty&& _Mapval) {
+        return _Insert_or_assign(_STD move(_Keyval), _STD forward<_Mappedty>(_Mapval));
+    }
+
+    template <class _Mappedty>
+    iterator insert_or_assign(const_iterator _Hint, const key_type& _Keyval, _Mappedty&& _Mapval) {
+        return _Insert_or_assign(_Hint._Ptr, _Keyval, _STD forward<_Mappedty>(_Mapval));
+    }
+
+    template <class _Mappedty>
+    iterator insert_or_assign(const_iterator _Hint, key_type&& _Keyval, _Mappedty&& _Mapval) {
+        return _Insert_or_assign(_Hint._Ptr, _STD move(_Keyval), _STD forward<_Mappedty>(_Mapval));
+    }
+
+    unordered_map(initializer_list<value_type> _Ilist) : _Mybase(_Key_compare(), allocator_type()) {
+        insert(_Ilist);
+    }
+
+    unordered_map(initializer_list<value_type> _Ilist, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        insert(_Ilist);
+    }
+
+    unordered_map(initializer_list<value_type> _Ilist, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        insert(_Ilist);
+    }
+
+    unordered_map(initializer_list<value_type> _Ilist, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        _Mybase::rehash(_Buckets);
+        insert(_Ilist);
+    }
+
+    unordered_map(initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        insert(_Ilist);
+    }
+
+    unordered_map(
+        initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        _Mybase::rehash(_Buckets);
+        insert(_Ilist);
+    }
+
+    unordered_map(
+        initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        insert(_Ilist);
+    }
+
+    unordered_map(initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg,
+        const _Keyeq& _Keyeqarg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        _Mybase::rehash(_Buckets);
+        insert(_Ilist);
+    }
+
+    unordered_map& operator=(initializer_list<value_type> _Ilist) {
+        _Mybase::clear();
+        insert(_Ilist);
+        return *this;
+    }
+
+    _NODISCARD hasher hash_function() const {
+        return _Mybase::_Traitsobj._Mypair._Get_first();
+    }
+
+    _NODISCARD key_equal key_eq() const {
+        return _Mybase::_Traitsobj._Mypair._Myval2._Get_first();
+    }
+
+    mapped_type& operator[](const key_type& _Keyval) {
+        return this->_Try_emplace(_Keyval).first->_Myval.second;
+    }
+
+    _NODISCARD mapped_type& at(const key_type& _Keyval) {
+        const auto _Target = this->_Find_last(_Keyval, this->_Traitsobj(_Keyval));
+        if (_Target._Duplicate) {
+            return _Target._Duplicate->_Myval.second;
+        }
+
+        _Xout_of_range("invalid unordered_map<K, T> key");
+    }
+
+    _NODISCARD const mapped_type& at(const key_type& _Keyval) const {
+        const auto _Target = this->_Find_last(_Keyval, this->_Traitsobj(_Keyval));
+        if (_Target._Duplicate) {
+            return _Target._Duplicate->_Myval.second;
+        }
+
+        _Xout_of_range("invalid unordered_map<K, T> key");
+    }
+
+    using _Mybase::_Unchecked_begin;
+    using _Mybase::_Unchecked_end;
+};
+
+#if _HAS_CXX17
+template <class _Iter, class _Hasher = hash<_Guide_key_t<_Iter>>, class _Keyeq = equal_to<_Guide_key_t<_Iter>>,
+    class _Alloc = allocator<_Guide_pair_t<_Iter>>,
+    enable_if_t<
+        conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>,
+        int> = 0>
+unordered_map(_Iter, _Iter, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(), _Alloc = _Alloc())
+    -> unordered_map<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, _Hasher, _Keyeq, _Alloc>;
+
+template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>,
+    class _Alloc = allocator<pair<const _Kty, _Ty>>,
+    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_map(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
+    _Alloc = _Alloc()) -> unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>;
+
+template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_map(_Iter, _Iter, _Alloc) -> unordered_map<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>,
+    hash<_Guide_key_t<_Iter>>, equal_to<_Guide_key_t<_Iter>>, _Alloc>;
+
+template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_map(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Alloc) -> unordered_map<_Guide_key_t<_Iter>,
+    _Guide_val_t<_Iter>, hash<_Guide_key_t<_Iter>>, equal_to<_Guide_key_t<_Iter>>, _Alloc>;
+
+template <class _Iter, class _Hasher, class _Alloc,
+    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_map(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_map<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, _Hasher, equal_to<_Guide_key_t<_Iter>>, _Alloc>;
+
+template <class _Kty, class _Ty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+unordered_map(initializer_list<pair<_Kty, _Ty>>, _Alloc)
+    -> unordered_map<_Kty, _Ty, hash<_Kty>, equal_to<_Kty>, _Alloc>;
+
+template <class _Kty, class _Ty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+unordered_map(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc>, _Alloc)
+    -> unordered_map<_Kty, _Ty, hash<_Kty>, equal_to<_Kty>, _Alloc>;
+
+template <class _Kty, class _Ty, class _Hasher, class _Alloc,
+    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_map(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_map<_Kty, _Ty, _Hasher, equal_to<_Kty>, _Alloc>;
+
+#if _HAS_CXX23
+template <_RANGES input_range _Rng, _Hasher_for_container _Hasher = hash<_Range_key_type<_Rng>>,
+    class _Keyeq                    = equal_to<_Range_key_type<_Rng>>,
+    _Allocator_for_container _Alloc = allocator<_Range_to_alloc_type<_Rng>>>
+    requires (!_Allocator_for_container<_Keyeq>)
+unordered_map(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
+    _Alloc = _Alloc()) -> unordered_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Hasher, _Keyeq, _Alloc>;
+
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc>
+unordered_map(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Alloc) -> unordered_map<_Range_key_type<_Rng>,
+    _Range_mapped_type<_Rng>, hash<_Range_key_type<_Rng>>, equal_to<_Range_key_type<_Rng>>, _Alloc>;
+
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc>
+unordered_map(from_range_t, _Rng&&, _Alloc) -> unordered_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
+    hash<_Range_key_type<_Rng>>, equal_to<_Range_key_type<_Rng>>, _Alloc>;
+
+template <_RANGES input_range _Rng, _Hasher_for_container _Hasher, _Allocator_for_container _Alloc>
+unordered_map(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Hasher, equal_to<_Range_key_type<_Rng>>, _Alloc>;
+#endif // _HAS_CXX23
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
+void swap(unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Left,
+    unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc, class _Pr>
+unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>::size_type erase_if(
+    unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Cont, _Pr _Pred) {
+    return _STD _Erase_nodes_if(_Cont, _STD _Pass_fn(_Pred));
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
+_NODISCARD bool operator==(const unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Left,
+    const unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Right) {
+    return _Hash_equal(_Left, _Right);
+}
+
+#if !_HAS_CXX20
+template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
+_NODISCARD bool operator!=(const unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Left,
+    const unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Right) {
+    return !(_Left == _Right);
+}
+#endif // !_HAS_CXX20
+
+_EXPORT_STD template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>,
+    class _Alloc = allocator<pair<const _Kty, _Ty>>>
+class unordered_multimap : public _Hash<_Umap_traits<_Kty, _Ty, _Uhash_compare<_Kty, _Hasher, _Keyeq>, _Alloc, true>> {
+    // hash table of {key, mapped} values, non-unique keys
+public:
+    static_assert(!_ENFORCE_MATCHING_ALLOCATORS || is_same_v<pair<const _Kty, _Ty>, typename _Alloc::value_type>,
+        _MISMATCHED_ALLOCATOR_MESSAGE(
+            "unordered_multimap<Key, Value, Hasher, Eq, Allocator>", "pair<const Key, Value>"));
+    static_assert(is_object_v<_Kty>, "The C++ Standard forbids containers of non-object types "
+                                     "because of [container.requirements].");
+
+private:
+    using _Mytraits      = _Uhash_compare<_Kty, _Hasher, _Keyeq>;
+    using _Mybase        = _Hash<_Umap_traits<_Kty, _Ty, _Mytraits, _Alloc, true>>;
+    using _Alnode        = typename _Mybase::_Alnode;
+    using _Alnode_traits = typename _Mybase::_Alnode_traits;
+    using _Key_compare   = typename _Mybase::_Key_compare;
+
+public:
+    using hasher      = _Hasher;
+    using key_type    = _Kty;
+    using mapped_type = _Ty;
+    using key_equal   = _Keyeq;
+
+    using value_type      = pair<const _Kty, _Ty>;
+    using allocator_type  = typename _Mybase::allocator_type;
+    using size_type       = typename _Mybase::size_type;
+    using difference_type = typename _Mybase::difference_type;
+    using pointer         = typename _Mybase::pointer;
+    using const_pointer   = typename _Mybase::const_pointer;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+    using iterator        = typename _Mybase::iterator;
+    using const_iterator  = typename _Mybase::const_iterator;
+
+    using local_iterator       = typename _Mybase::iterator;
+    using const_local_iterator = typename _Mybase::const_iterator;
+
+    unordered_multimap() : _Mybase(_Key_compare(), allocator_type()) {} // construct empty map from defaults
+
+    explicit unordered_multimap(const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {} // construct empty map from defaults, allocator
+
+    unordered_multimap(const unordered_multimap& _Right)
+        : _Mybase(_Right, _Alnode_traits::select_on_container_copy_construction(_Right._Getal())) {}
+
+    unordered_multimap(const unordered_multimap& _Right, const allocator_type& _Al) : _Mybase(_Right, _Al) {}
+
+    explicit unordered_multimap(size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+    }
+
+    unordered_multimap(size_type _Buckets, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        _Mybase::rehash(_Buckets);
+    }
+
+    unordered_multimap(size_type _Buckets, const hasher& _Hasharg) : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+    }
+
+    unordered_multimap(size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        _Mybase::rehash(_Buckets);
+    }
+
+    unordered_multimap(size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+    }
+
+    unordered_multimap(size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        _Mybase::rehash(_Buckets);
+    }
+
+    template <class _Iter>
+    unordered_multimap(_Iter _First, _Iter _Last) : _Mybase(_Key_compare(), allocator_type()) {
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multimap(_Iter _First, _Iter _Last, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multimap(_Iter _First, _Iter _Last, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multimap(_Iter _First, _Iter _Last, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        _Mybase::rehash(_Buckets);
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multimap(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multimap(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        _Mybase::rehash(_Buckets);
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multimap(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multimap(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg,
+        const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        _Mybase::rehash(_Buckets);
+        insert(_First, _Last);
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multimap(from_range_t, _Rng&& _Range) : _Mybase(_Key_compare(), allocator_type()) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multimap(from_range_t, _Rng&& _Range, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multimap(from_range_t, _Rng&& _Range, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multimap(from_range_t, _Rng&& _Range, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multimap(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multimap(
+        from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multimap(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multimap(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg,
+        const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // _HAS_CXX23
+
+    unordered_multimap& operator=(const unordered_multimap& _Right) {
+        _Mybase::operator=(_Right);
+        return *this;
+    }
+
+    unordered_multimap(unordered_multimap&& _Right) : _Mybase(_STD move(_Right)) {}
+
+    unordered_multimap(unordered_multimap&& _Right, const allocator_type& _Al) : _Mybase(_STD move(_Right), _Al) {}
+
+    unordered_multimap& operator=(unordered_multimap&& _Right) noexcept(_Alnode_traits::is_always_equal::value
+                                                                        && is_nothrow_move_assignable_v<_Hasher>
+                                                                        && is_nothrow_move_assignable_v<_Keyeq>) {
+        _Mybase::operator=(_STD move(_Right));
+        return *this;
+    }
+
+    void swap(unordered_multimap& _Right) noexcept(noexcept(_Mybase::swap(_Right))) {
+        _Mybase::swap(_Right);
+    }
+
+    using _Mybase::insert;
+
+    template <class _Valty, enable_if_t<is_constructible_v<value_type, _Valty>, int> = 0>
+    iterator insert(_Valty&& _Val) {
+        return this->emplace(_STD forward<_Valty>(_Val));
+    }
+
+    template <class _Valty, enable_if_t<is_constructible_v<value_type, _Valty>, int> = 0>
+    iterator insert(const_iterator _Where, _Valty&& _Val) {
+        return this->emplace_hint(_Where, _STD forward<_Valty>(_Val));
+    }
+
+    unordered_multimap(initializer_list<value_type> _Ilist) : _Mybase(_Key_compare(), allocator_type()) {
+        insert(_Ilist);
+    }
+
+    unordered_multimap(initializer_list<value_type> _Ilist, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        insert(_Ilist);
+    }
+
+    unordered_multimap(initializer_list<value_type> _Ilist, size_type _Buckets)
+        : _Mybase(_Key_compare(), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        insert(_Ilist);
+    }
+
+    unordered_multimap(initializer_list<value_type> _Ilist, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        _Mybase::rehash(_Buckets);
+        insert(_Ilist);
+    }
+
+    unordered_multimap(initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        insert(_Ilist);
+    }
+
+    unordered_multimap(
+        initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        _Mybase::rehash(_Buckets);
+        insert(_Ilist);
+    }
+
+    unordered_multimap(
+        initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        insert(_Ilist);
+    }
+
+    unordered_multimap(initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg,
+        const _Keyeq& _Keyeqarg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        _Mybase::rehash(_Buckets);
+        insert(_Ilist);
+    }
+
+    unordered_multimap& operator=(initializer_list<value_type> _Ilist) {
+        _Mybase::clear();
+        insert(_Ilist);
+        return *this;
+    }
+
+    _NODISCARD hasher hash_function() const {
+        return _Mybase::_Traitsobj._Mypair._Get_first();
+    }
+
+    _NODISCARD key_equal key_eq() const {
+        return _Mybase::_Traitsobj._Mypair._Myval2._Get_first();
+    }
+
+    using _Mybase::_Unchecked_begin;
+    using _Mybase::_Unchecked_end;
+};
+
+#if _HAS_CXX17
+template <class _Iter, class _Hasher = hash<_Guide_key_t<_Iter>>, class _Keyeq = equal_to<_Guide_key_t<_Iter>>,
+    class _Alloc = allocator<_Guide_pair_t<_Iter>>,
+    enable_if_t<
+        conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>,
+        int> = 0>
+unordered_multimap(_Iter, _Iter, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
+    _Alloc = _Alloc()) -> unordered_multimap<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, _Hasher, _Keyeq, _Alloc>;
+
+template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>,
+    class _Alloc = allocator<pair<const _Kty, _Ty>>,
+    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_multimap(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(),
+    _Keyeq = _Keyeq(), _Alloc = _Alloc()) -> unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>;
+
+template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_multimap(_Iter, _Iter, _Alloc) -> unordered_multimap<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>,
+    hash<_Guide_key_t<_Iter>>, equal_to<_Guide_key_t<_Iter>>, _Alloc>;
+
+template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_multimap(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Alloc) -> unordered_multimap<_Guide_key_t<_Iter>,
+    _Guide_val_t<_Iter>, hash<_Guide_key_t<_Iter>>, equal_to<_Guide_key_t<_Iter>>, _Alloc>;
+
+template <class _Iter, class _Hasher, class _Alloc,
+    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_multimap(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_multimap<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, _Hasher, equal_to<_Guide_key_t<_Iter>>, _Alloc>;
+
+template <class _Kty, class _Ty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+unordered_multimap(initializer_list<pair<_Kty, _Ty>>, _Alloc)
+    -> unordered_multimap<_Kty, _Ty, hash<_Kty>, equal_to<_Kty>, _Alloc>;
+
+template <class _Kty, class _Ty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+unordered_multimap(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc>, _Alloc)
+    -> unordered_multimap<_Kty, _Ty, hash<_Kty>, equal_to<_Kty>, _Alloc>;
+
+template <class _Kty, class _Ty, class _Hasher, class _Alloc,
+    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_multimap(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_multimap<_Kty, _Ty, _Hasher, equal_to<_Kty>, _Alloc>;
+
+#if _HAS_CXX23
+template <_RANGES input_range _Rng, _Hasher_for_container _Hasher = hash<_Range_key_type<_Rng>>,
+    class _Keyeq                    = equal_to<_Range_key_type<_Rng>>,
+    _Allocator_for_container _Alloc = allocator<_Range_to_alloc_type<_Rng>>>
+    requires (!_Allocator_for_container<_Keyeq>)
+unordered_multimap(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
+    _Alloc = _Alloc()) -> unordered_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Hasher, _Keyeq, _Alloc>;
+
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc>
+unordered_multimap(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Alloc)
+    -> unordered_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, hash<_Range_key_type<_Rng>>,
+        equal_to<_Range_key_type<_Rng>>, _Alloc>;
+
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc>
+unordered_multimap(from_range_t, _Rng&&, _Alloc) -> unordered_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
+    hash<_Range_key_type<_Rng>>, equal_to<_Range_key_type<_Rng>>, _Alloc>;
+
+template <_RANGES input_range _Rng, _Hasher_for_container _Hasher, _Allocator_for_container _Alloc>
+unordered_multimap(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Hasher, equal_to<_Range_key_type<_Rng>>,
+        _Alloc>;
+#endif // _HAS_CXX23
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
+void swap(unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Left,
+    unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc, class _Pr>
+unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>::size_type erase_if(
+    unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Cont, _Pr _Pred) {
+    return _STD _Erase_nodes_if(_Cont, _STD _Pass_fn(_Pred));
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
+_NODISCARD bool operator==(const unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Left,
+    const unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Right) {
+    return _Hash_equal(_Left, _Right);
+}
+
+#if !_HAS_CXX20
+template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
+_NODISCARD bool operator!=(const unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Left,
+    const unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Right) {
+    return !(_Left == _Right);
+}
+#endif // !_HAS_CXX20
+
+#if _HAS_TR1_NAMESPACE
+namespace _DEPRECATE_TR1_NAMESPACE tr1 {
+    using _STD unordered_map;
+    using _STD unordered_multimap;
+} // namespace _DEPRECATE_TR1_NAMESPACE tr1
+#endif // _HAS_TR1_NAMESPACE
+
+#if _HAS_CXX17
+namespace pmr {
+    _EXPORT_STD template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>>
+    using unordered_map = _STD unordered_map<_Kty, _Ty, _Hasher, _Keyeq, polymorphic_allocator<pair<const _Kty, _Ty>>>;
+
+    _EXPORT_STD template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>>
+    using unordered_multimap =
+        _STD unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, polymorphic_allocator<pair<const _Kty, _Ty>>>;
+} // namespace pmr
+#endif // _HAS_CXX17
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _UNORDERED_MAP_

miniMSVC/VC/Tools/MSVC/14.42.34433/include/unordered_set

@@ -0,0 +1,771 @@
+// unordered_set standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _UNORDERED_SET_
+#define _UNORDERED_SET_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <xhash>
+
+#if _HAS_CXX17
+#include <xpolymorphic_allocator.h>
+#endif // _HAS_CXX17
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+template <class _Kty, // key type (same as value type)
+    class _Tr, // comparator predicate type
+    class _Alloc, // actual allocator type (should be value allocator)
+    bool _Mfl> // true if multiple equivalent keys are permitted
+class _Uset_traits : public _Tr { // traits required to make _Hash behave like a set
+public:
+    using key_type            = _Kty;
+    using value_type          = _Kty;
+    using _Mutable_value_type = _Kty;
+    using key_compare         = _Tr;
+    using allocator_type      = _Alloc;
+#if _HAS_CXX17
+    using node_type = _Node_handle<_List_node<value_type, typename allocator_traits<_Alloc>::void_pointer>, _Alloc,
+        _Node_handle_set_base, _Kty>;
+#endif // _HAS_CXX17
+
+    static constexpr bool _Multi    = _Mfl;
+    static constexpr bool _Standard = true;
+
+    template <class... _Args>
+    using _In_place_key_extractor = _In_place_key_extract_set<_Kty, _Args...>;
+
+    _Uset_traits() = default;
+
+    explicit _Uset_traits(const _Tr& _Traits) noexcept(is_nothrow_copy_constructible_v<_Tr>) : _Tr(_Traits) {}
+
+    using value_compare = void; // TRANSITION, remove when _Standard becomes unconditionally true
+
+    static const _Kty& _Kfn(const value_type& _Val) noexcept {
+        return _Val;
+    }
+};
+
+_EXPORT_STD template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>,
+    class _Alloc = allocator<_Kty>>
+class unordered_set : public _Hash<_Uset_traits<_Kty, _Uhash_compare<_Kty, _Hasher, _Keyeq>, _Alloc, false>> {
+    // hash table of key-values, unique keys
+public:
+    static_assert(!_ENFORCE_MATCHING_ALLOCATORS || is_same_v<_Kty, typename _Alloc::value_type>,
+        _MISMATCHED_ALLOCATOR_MESSAGE("unordered_set<T, Hasher, Eq, Allocator>", "T"));
+    static_assert(is_object_v<_Kty>, "The C++ Standard forbids containers of non-object types "
+                                     "because of [container.requirements].");
+
+private:
+    using _Mytraits      = _Uhash_compare<_Kty, _Hasher, _Keyeq>;
+    using _Mybase        = _Hash<_Uset_traits<_Kty, _Mytraits, _Alloc, false>>;
+    using _Alnode        = typename _Mybase::_Alnode;
+    using _Alnode_traits = typename _Mybase::_Alnode_traits;
+    using _Key_compare   = typename _Mybase::_Key_compare;
+
+public:
+    using hasher    = _Hasher;
+    using key_type  = _Kty;
+    using key_equal = _Keyeq;
+
+    using value_type      = typename _Mybase::value_type;
+    using allocator_type  = typename _Mybase::allocator_type;
+    using size_type       = typename _Mybase::size_type;
+    using difference_type = typename _Mybase::difference_type;
+    using pointer         = typename _Mybase::pointer;
+    using const_pointer   = typename _Mybase::const_pointer;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+    using iterator        = typename _Mybase::iterator;
+    using const_iterator  = typename _Mybase::const_iterator;
+
+    using local_iterator       = typename _Mybase::iterator;
+    using const_local_iterator = typename _Mybase::const_iterator;
+
+#if _HAS_CXX17
+    using insert_return_type = _Insert_return_type<iterator, typename _Mybase::node_type>;
+#endif // _HAS_CXX17
+
+    unordered_set() : _Mybase(_Key_compare(), allocator_type()) {}
+
+    explicit unordered_set(const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {}
+
+    unordered_set(const unordered_set& _Right)
+        : _Mybase(_Right, _Alnode_traits::select_on_container_copy_construction(_Right._Getal())) {}
+
+    unordered_set(const unordered_set& _Right, const allocator_type& _Al) : _Mybase(_Right, _Al) {}
+
+    explicit unordered_set(size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        this->rehash(_Buckets);
+    }
+
+    unordered_set(size_type _Buckets, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        this->rehash(_Buckets);
+    }
+
+    unordered_set(size_type _Buckets, const hasher& _Hasharg) : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        this->rehash(_Buckets);
+    }
+
+    unordered_set(size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        this->rehash(_Buckets);
+    }
+
+    unordered_set(size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        this->rehash(_Buckets);
+    }
+
+    unordered_set(size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        this->rehash(_Buckets);
+    }
+
+    template <class _Iter>
+    unordered_set(_Iter _First, _Iter _Last) : _Mybase(_Key_compare(), allocator_type()) {
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_set(_Iter _First, _Iter _Last, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_set(_Iter _First, _Iter _Last, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        this->rehash(_Buckets);
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_set(_Iter _First, _Iter _Last, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        this->rehash(_Buckets);
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_set(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        this->rehash(_Buckets);
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_set(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        this->rehash(_Buckets);
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_set(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        this->rehash(_Buckets);
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_set(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg,
+        const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        this->rehash(_Buckets);
+        this->insert(_First, _Last);
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_set(from_range_t, _Rng&& _Range) : _Mybase(_Key_compare(), allocator_type()) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_set(from_range_t, _Rng&& _Range, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_set(from_range_t, _Rng&& _Range, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_set(from_range_t, _Rng&& _Range, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_set(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_set(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_set(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_set(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg,
+        const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // _HAS_CXX23
+
+    unordered_set& operator=(const unordered_set& _Right) {
+        _Mybase::operator=(_Right);
+        return *this;
+    }
+
+    unordered_set(unordered_set&& _Right) : _Mybase(_STD move(_Right)) {}
+
+    unordered_set(unordered_set&& _Right, const allocator_type& _Al) : _Mybase(_STD move(_Right), _Al) {}
+
+    unordered_set& operator=(unordered_set&& _Right) noexcept(_Alnode_traits::is_always_equal::value
+                                                              && is_nothrow_move_assignable_v<_Hasher>
+                                                              && is_nothrow_move_assignable_v<_Keyeq>) {
+        _Mybase::operator=(_STD move(_Right));
+        return *this;
+    }
+
+    void swap(unordered_set& _Right) noexcept(noexcept(_Mybase::swap(_Right))) {
+        _Mybase::swap(_Right);
+    }
+
+    unordered_set(initializer_list<value_type> _Ilist) : _Mybase(_Key_compare(), allocator_type()) {
+        this->insert(_Ilist);
+    }
+
+    unordered_set(initializer_list<value_type> _Ilist, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        this->insert(_Ilist);
+    }
+
+    unordered_set(initializer_list<value_type> _Ilist, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        this->rehash(_Buckets);
+        this->insert(_Ilist);
+    }
+
+    unordered_set(initializer_list<value_type> _Ilist, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        this->rehash(_Buckets);
+        this->insert(_Ilist);
+    }
+
+    unordered_set(initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        this->rehash(_Buckets);
+        this->insert(_Ilist);
+    }
+
+    unordered_set(
+        initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        this->rehash(_Buckets);
+        this->insert(_Ilist);
+    }
+
+    unordered_set(
+        initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        this->rehash(_Buckets);
+        this->insert(_Ilist);
+    }
+
+    unordered_set(initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg,
+        const _Keyeq& _Keyeqarg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        this->rehash(_Buckets);
+        this->insert(_Ilist);
+    }
+
+    unordered_set& operator=(initializer_list<value_type> _Ilist) {
+        this->clear();
+        this->insert(_Ilist);
+        return *this;
+    }
+
+    _NODISCARD hasher hash_function() const {
+        return this->_Traitsobj._Mypair._Get_first();
+    }
+
+    _NODISCARD key_equal key_eq() const {
+        return this->_Traitsobj._Mypair._Myval2._Get_first();
+    }
+
+    using _Mybase::_Unchecked_begin;
+    using _Mybase::_Unchecked_end;
+};
+
+#if _HAS_CXX17
+template <class _Iter, class _Hasher = hash<_Iter_value_t<_Iter>>, class _Keyeq = equal_to<_Iter_value_t<_Iter>>,
+    class _Alloc = allocator<_Iter_value_t<_Iter>>,
+    enable_if_t<
+        conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>,
+        int> = 0>
+unordered_set(_Iter, _Iter, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(), _Alloc = _Alloc())
+    -> unordered_set<_Iter_value_t<_Iter>, _Hasher, _Keyeq, _Alloc>;
+
+template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>,
+    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_set(initializer_list<_Kty>, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
+    _Alloc = _Alloc()) -> unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>;
+
+template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_set(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Alloc)
+    -> unordered_set<_Iter_value_t<_Iter>, hash<_Iter_value_t<_Iter>>, equal_to<_Iter_value_t<_Iter>>, _Alloc>;
+
+template <class _Iter, class _Hasher, class _Alloc,
+    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_set(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_set<_Iter_value_t<_Iter>, _Hasher, equal_to<_Iter_value_t<_Iter>>, _Alloc>;
+
+template <class _Kty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+unordered_set(initializer_list<_Kty>, _Guide_size_type_t<_Alloc>, _Alloc)
+    -> unordered_set<_Kty, hash<_Kty>, equal_to<_Kty>, _Alloc>;
+
+template <class _Kty, class _Hasher, class _Alloc,
+    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_set(initializer_list<_Kty>, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_set<_Kty, _Hasher, equal_to<_Kty>, _Alloc>;
+
+#if _HAS_CXX23
+template <_RANGES input_range _Rng, _Hasher_for_container _Hasher = hash<_RANGES range_value_t<_Rng>>,
+    class _Keyeq                    = equal_to<_RANGES range_value_t<_Rng>>,
+    _Allocator_for_container _Alloc = allocator<_RANGES range_value_t<_Rng>>>
+    requires (!_Allocator_for_container<_Keyeq>)
+unordered_set(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
+    _Alloc = _Alloc()) -> unordered_set<_RANGES range_value_t<_Rng>, _Hasher, _Keyeq, _Alloc>;
+
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc>
+unordered_set(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Alloc) -> unordered_set<_RANGES range_value_t<_Rng>,
+    hash<_RANGES range_value_t<_Rng>>, equal_to<_RANGES range_value_t<_Rng>>, _Alloc>;
+
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc>
+unordered_set(from_range_t, _Rng&&, _Alloc) -> unordered_set<_RANGES range_value_t<_Rng>,
+    hash<_RANGES range_value_t<_Rng>>, equal_to<_RANGES range_value_t<_Rng>>, _Alloc>;
+
+template <_RANGES input_range _Rng, _Hasher_for_container _Hasher, _Allocator_for_container _Alloc>
+unordered_set(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_set<_RANGES range_value_t<_Rng>, _Hasher, equal_to<_RANGES range_value_t<_Rng>>, _Alloc>;
+#endif // _HAS_CXX23
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
+void swap(unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>& _Left,
+    unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Kty, class _Hasher, class _Keyeq, class _Alloc, class _Pr>
+unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>::size_type erase_if(
+    unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>& _Cont, _Pr _Pred) {
+    return _STD _Erase_nodes_if(_Cont, _STD _Pass_fn(_Pred));
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
+_NODISCARD bool operator==(const unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>& _Left,
+    const unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>& _Right) {
+    return _Hash_equal(_Left, _Right);
+}
+
+#if !_HAS_CXX20
+template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
+_NODISCARD bool operator!=(const unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>& _Left,
+    const unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>& _Right) {
+    return !(_Left == _Right);
+}
+#endif // !_HAS_CXX20
+
+_EXPORT_STD template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>,
+    class _Alloc = allocator<_Kty>>
+class unordered_multiset : public _Hash<_Uset_traits<_Kty, _Uhash_compare<_Kty, _Hasher, _Keyeq>, _Alloc, true>> {
+    // hash table of key-values, non-unique keys
+public:
+    static_assert(!_ENFORCE_MATCHING_ALLOCATORS || is_same_v<_Kty, typename _Alloc::value_type>,
+        _MISMATCHED_ALLOCATOR_MESSAGE("unordered_multiset<T, Hasher, Eq, Allocator>", "T"));
+    static_assert(is_object_v<_Kty>, "The C++ Standard forbids containers of non-object types "
+                                     "because of [container.requirements].");
+
+private:
+    using _Mytraits      = _Uhash_compare<_Kty, _Hasher, _Keyeq>;
+    using _Mybase        = _Hash<_Uset_traits<_Kty, _Mytraits, _Alloc, true>>;
+    using _Alnode        = typename _Mybase::_Alnode;
+    using _Alnode_traits = typename _Mybase::_Alnode_traits;
+    using _Key_compare   = typename _Mybase::_Key_compare;
+
+public:
+    using hasher    = _Hasher;
+    using key_type  = _Kty;
+    using key_equal = _Keyeq;
+
+    using value_type      = typename _Mybase::value_type;
+    using allocator_type  = typename _Mybase::allocator_type;
+    using size_type       = typename _Mybase::size_type;
+    using difference_type = typename _Mybase::difference_type;
+    using pointer         = typename _Mybase::pointer;
+    using const_pointer   = typename _Mybase::const_pointer;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+    using iterator        = typename _Mybase::iterator;
+    using const_iterator  = typename _Mybase::const_iterator;
+
+    unordered_multiset() : _Mybase(_Key_compare(), allocator_type()) {}
+
+    explicit unordered_multiset(const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {}
+
+    unordered_multiset(const unordered_multiset& _Right)
+        : _Mybase(_Right, _Alnode_traits::select_on_container_copy_construction(_Right._Getal())) {}
+
+    unordered_multiset(const unordered_multiset& _Right, const allocator_type& _Al) : _Mybase(_Right, _Al) {}
+
+    explicit unordered_multiset(size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        this->rehash(_Buckets);
+    }
+
+    unordered_multiset(size_type _Buckets, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        this->rehash(_Buckets);
+    }
+
+    unordered_multiset(size_type _Buckets, const hasher& _Hasharg) : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        this->rehash(_Buckets);
+    }
+
+    unordered_multiset(size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        this->rehash(_Buckets);
+    }
+
+    unordered_multiset(size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        this->rehash(_Buckets);
+    }
+
+    unordered_multiset(size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        this->rehash(_Buckets);
+    }
+
+    template <class _Iter>
+    unordered_multiset(_Iter _First, _Iter _Last) : _Mybase(_Key_compare(), allocator_type()) {
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multiset(_Iter _First, _Iter _Last, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multiset(_Iter _First, _Iter _Last, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        this->rehash(_Buckets);
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multiset(_Iter _First, _Iter _Last, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        this->rehash(_Buckets);
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multiset(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        this->rehash(_Buckets);
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multiset(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        this->rehash(_Buckets);
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multiset(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        this->rehash(_Buckets);
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multiset(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg,
+        const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        this->rehash(_Buckets);
+        this->insert(_First, _Last);
+    }
+
+    unordered_multiset& operator=(const unordered_multiset& _Right) {
+        _Mybase::operator=(_Right);
+        return *this;
+    }
+
+    unordered_multiset(unordered_multiset&& _Right) : _Mybase(_STD move(_Right)) {}
+
+    unordered_multiset(unordered_multiset&& _Right, const allocator_type& _Al) : _Mybase(_STD move(_Right), _Al) {}
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multiset(from_range_t, _Rng&& _Range) : _Mybase(_Key_compare(), allocator_type()) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multiset(from_range_t, _Rng&& _Range, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multiset(from_range_t, _Rng&& _Range, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multiset(from_range_t, _Rng&& _Range, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multiset(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multiset(
+        from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multiset(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multiset(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg,
+        const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // _HAS_CXX23
+
+    unordered_multiset& operator=(unordered_multiset&& _Right) noexcept(_Alnode_traits::is_always_equal::value
+                                                                        && is_nothrow_move_assignable_v<_Hasher>
+                                                                        && is_nothrow_move_assignable_v<_Keyeq>) {
+        _Mybase::operator=(_STD move(_Right));
+        return *this;
+    }
+
+    void swap(unordered_multiset& _Right) noexcept(noexcept(_Mybase::swap(_Right))) {
+        _Mybase::swap(_Right);
+    }
+
+    unordered_multiset(initializer_list<value_type> _Ilist) : _Mybase(_Key_compare(), allocator_type()) {
+        this->insert(_Ilist);
+    }
+
+    unordered_multiset(initializer_list<value_type> _Ilist, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        this->insert(_Ilist);
+    }
+
+    unordered_multiset(initializer_list<value_type> _Ilist, size_type _Buckets)
+        : _Mybase(_Key_compare(), allocator_type()) {
+        this->rehash(_Buckets);
+        this->insert(_Ilist);
+    }
+
+    unordered_multiset(initializer_list<value_type> _Ilist, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        this->rehash(_Buckets);
+        this->insert(_Ilist);
+    }
+
+    unordered_multiset(initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        this->rehash(_Buckets);
+        this->insert(_Ilist);
+    }
+
+    unordered_multiset(
+        initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        this->rehash(_Buckets);
+        this->insert(_Ilist);
+    }
+
+    unordered_multiset(
+        initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        this->rehash(_Buckets);
+        this->insert(_Ilist);
+    }
+
+    unordered_multiset(initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg,
+        const _Keyeq& _Keyeqarg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        this->rehash(_Buckets);
+        this->insert(_Ilist);
+    }
+
+    unordered_multiset& operator=(initializer_list<value_type> _Ilist) {
+        this->clear();
+        this->insert(_Ilist);
+        return *this;
+    }
+
+    _NODISCARD hasher hash_function() const {
+        return this->_Traitsobj._Mypair._Get_first();
+    }
+
+    _NODISCARD key_equal key_eq() const {
+        return this->_Traitsobj._Mypair._Myval2._Get_first();
+    }
+
+    using _Mybase::_Unchecked_begin;
+    using _Mybase::_Unchecked_end;
+};
+
+#if _HAS_CXX17
+template <class _Iter, class _Hasher = hash<_Iter_value_t<_Iter>>, class _Keyeq = equal_to<_Iter_value_t<_Iter>>,
+    class _Alloc = allocator<_Iter_value_t<_Iter>>,
+    enable_if_t<
+        conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>,
+        int> = 0>
+unordered_multiset(_Iter, _Iter, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
+    _Alloc = _Alloc()) -> unordered_multiset<_Iter_value_t<_Iter>, _Hasher, _Keyeq, _Alloc>;
+
+template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>,
+    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_multiset(initializer_list<_Kty>, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
+    _Alloc = _Alloc()) -> unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>;
+
+template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_multiset(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Alloc)
+    -> unordered_multiset<_Iter_value_t<_Iter>, hash<_Iter_value_t<_Iter>>, equal_to<_Iter_value_t<_Iter>>, _Alloc>;
+
+template <class _Iter, class _Hasher, class _Alloc,
+    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_multiset(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_multiset<_Iter_value_t<_Iter>, _Hasher, equal_to<_Iter_value_t<_Iter>>, _Alloc>;
+
+template <class _Kty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+unordered_multiset(initializer_list<_Kty>, _Guide_size_type_t<_Alloc>, _Alloc)
+    -> unordered_multiset<_Kty, hash<_Kty>, equal_to<_Kty>, _Alloc>;
+
+template <class _Kty, class _Hasher, class _Alloc,
+    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_multiset(initializer_list<_Kty>, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_multiset<_Kty, _Hasher, equal_to<_Kty>, _Alloc>;
+
+#if _HAS_CXX23
+template <_RANGES input_range _Rng, _Hasher_for_container _Hasher = hash<_RANGES range_value_t<_Rng>>,
+    class _Keyeq                    = equal_to<_RANGES range_value_t<_Rng>>,
+    _Allocator_for_container _Alloc = allocator<_RANGES range_value_t<_Rng>>>
+    requires (!_Allocator_for_container<_Keyeq>)
+unordered_multiset(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
+    _Alloc = _Alloc()) -> unordered_multiset<_RANGES range_value_t<_Rng>, _Hasher, _Keyeq, _Alloc>;
+
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc>
+unordered_multiset(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Alloc)
+    -> unordered_multiset<_RANGES range_value_t<_Rng>, hash<_RANGES range_value_t<_Rng>>,
+        equal_to<_RANGES range_value_t<_Rng>>, _Alloc>;
+
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc>
+unordered_multiset(from_range_t, _Rng&&, _Alloc) -> unordered_multiset<_RANGES range_value_t<_Rng>,
+    hash<_RANGES range_value_t<_Rng>>, equal_to<_RANGES range_value_t<_Rng>>, _Alloc>;
+
+template <_RANGES input_range _Rng, _Hasher_for_container _Hasher, _Allocator_for_container _Alloc>
+unordered_multiset(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_multiset<_RANGES range_value_t<_Rng>, _Hasher, equal_to<_RANGES range_value_t<_Rng>>, _Alloc>;
+#endif // _HAS_CXX23
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
+void swap(unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>& _Left,
+    unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Kty, class _Hasher, class _Keyeq, class _Alloc, class _Pr>
+unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>::size_type erase_if(
+    unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>& _Cont, _Pr _Pred) {
+    return _STD _Erase_nodes_if(_Cont, _STD _Pass_fn(_Pred));
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
+_NODISCARD bool operator==(const unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>& _Left,
+    const unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>& _Right) {
+    return _Hash_equal(_Left, _Right);
+}
+
+#if !_HAS_CXX20
+template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
+_NODISCARD bool operator!=(const unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>& _Left,
+    const unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>& _Right) {
+    return !(_Left == _Right);
+}
+#endif // !_HAS_CXX20
+
+#if _HAS_TR1_NAMESPACE
+namespace _DEPRECATE_TR1_NAMESPACE tr1 {
+    using _STD unordered_multiset;
+    using _STD unordered_set;
+} // namespace _DEPRECATE_TR1_NAMESPACE tr1
+#endif // _HAS_TR1_NAMESPACE
+
+#if _HAS_CXX17
+namespace pmr {
+    _EXPORT_STD template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>>
+    using unordered_set = _STD unordered_set<_Kty, _Hasher, _Keyeq, polymorphic_allocator<_Kty>>;
+
+    _EXPORT_STD template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>>
+    using unordered_multiset = _STD unordered_multiset<_Kty, _Hasher, _Keyeq, polymorphic_allocator<_Kty>>;
+} // namespace pmr
+#endif // _HAS_CXX17
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _UNORDERED_SET_

miniMSVC/VC/Tools/MSVC/14.42.34433/include/use_ansi.h

@@ -0,0 +1,57 @@
+// use_ansi.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _USE_ANSI_CPP
+#define _USE_ANSI_CPP
+
+#ifdef _CRTBLD
+#define _CRT_NOPRAGMA_LIBS
+#else
+#undef _CRT_NOPRAGMA_LIBS
+#endif
+
+#ifndef _CRT_NOPRAGMA_LIBS
+
+#ifndef _M_CEE_PURE
+
+#undef _DEBUG_AFFIX
+#undef _IDL_AFFIX
+#undef _IDL_DEFAULT
+#undef _LIB_STEM
+
+#ifdef _DEBUG
+#define _DEBUG_AFFIX "d"
+#define _IDL_DEFAULT 2
+#else // ^^^ defined(_DEBUG) / !defined(_DEBUG) vvv
+#define _DEBUG_AFFIX ""
+#define _IDL_DEFAULT 0
+#endif // ^^^ !defined(_DEBUG) ^^^
+
+#if defined(_DLL) && !defined(_STATIC_CPPLIB)
+#define _LIB_STEM "msvcprt"
+#else // ^^^ defined(_DLL) && !defined(_STATIC_CPPLIB) / !defined(_DLL) || defined(_STATIC_CPPLIB) vvv
+#define _LIB_STEM "libcpmt"
+
+#if _ITERATOR_DEBUG_LEVEL != _IDL_DEFAULT
+#define _IDL_AFFIX _STL_STRINGIZE(_ITERATOR_DEBUG_LEVEL)
+#endif // _ITERATOR_DEBUG_LEVEL != _IDL_DEFAULT
+#endif // ^^^ !defined(_DLL) || defined(_STATIC_CPPLIB) ^^^
+
+#ifndef _IDL_AFFIX
+#define _IDL_AFFIX ""
+#endif
+
+#pragma comment(lib, _LIB_STEM _DEBUG_AFFIX _IDL_AFFIX)
+
+#undef _DEBUG_AFFIX
+#undef _IDL_AFFIX
+#undef _IDL_DEFAULT
+#undef _LIB_STEM
+
+#endif // !defined(_M_CEE_PURE)
+
+#endif // !defined(_CRT_NOPRAGMA_LIBS)
+
+#endif // _USE_ANSI_CPP

miniMSVC/VC/Tools/MSVC/14.42.34433/include/utility

@@ -0,0 +1,988 @@
+// utility standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _UTILITY_
+#define _UTILITY_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <initializer_list>
+#include <type_traits>
+
+#if _HAS_CXX20
+#include <compare>
+#include <concepts>
+#endif // _HAS_CXX20
+
+#if _HAS_CXX23
+#include <cstdlib>
+#endif // _HAS_CXX23
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("intrinsic")
+#pragma push_macro("known_semantics")
+#pragma push_macro("lifetimebound")
+#undef msvc
+#undef intrinsic
+#undef known_semantics
+#undef lifetimebound
+
+_STD_BEGIN
+_EXPORT_STD template <class _Ty, _Ty... _Vals>
+struct integer_sequence { // sequence of integer parameters
+    static_assert(is_integral_v<_Ty>, "integer_sequence<T, I...> requires T to be an integral type.");
+
+    using value_type = _Ty;
+
+    _NODISCARD static constexpr size_t size() noexcept {
+        return sizeof...(_Vals);
+    }
+};
+
+_EXPORT_STD template <class _Ty, _Ty _Size>
+using make_integer_sequence = __make_integer_seq<integer_sequence, _Ty, _Size>;
+
+_EXPORT_STD template <size_t... _Vals>
+using index_sequence = integer_sequence<size_t, _Vals...>;
+
+_EXPORT_STD template <size_t _Size>
+using make_index_sequence = make_integer_sequence<size_t, _Size>;
+
+_EXPORT_STD template <class... _Types>
+using index_sequence_for = make_index_sequence<sizeof...(_Types)>;
+
+_EXPORT_STD template <class _Ty, class _Pr>
+_NODISCARD constexpr const _Ty&(max) (const _Ty& _Left _MSVC_LIFETIMEBOUND, const _Ty& _Right _MSVC_LIFETIMEBOUND,
+    _Pr _Pred) noexcept(noexcept(_Pred(_Left, _Right))) /* strengthened */ {
+    // return larger of _Left and _Right
+    return _Pred(_Left, _Right) ? _Right : _Left;
+}
+
+#pragma warning(push)
+#pragma warning(disable : 28285) // (syntax error in SAL annotation, occurs when _Ty is not an integral type)
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Post_equal_to_(_Left < _Right ? _Right : _Left) constexpr const _Ty& //
+    (max) (const _Ty& _Left _MSVC_LIFETIMEBOUND, const _Ty& _Right _MSVC_LIFETIMEBOUND) noexcept(
+        noexcept(_Left < _Right)) /* strengthened */ {
+    // return larger of _Left and _Right
+    return _Left < _Right ? _Right : _Left;
+}
+#pragma warning(pop)
+
+_EXPORT_STD template <class _Ty, class _Pr>
+_NODISCARD constexpr _Ty(max)(initializer_list<_Ty>, _Pr); // implemented in <algorithm>
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD constexpr _Ty(max)(initializer_list<_Ty>); // implemented in <algorithm>
+
+_EXPORT_STD template <class _Ty, class _Pr>
+_NODISCARD constexpr const _Ty&(min) (const _Ty& _Left _MSVC_LIFETIMEBOUND, const _Ty& _Right _MSVC_LIFETIMEBOUND,
+    _Pr _Pred) noexcept(noexcept(_Pred(_Right, _Left))) /* strengthened */ {
+    // return smaller of _Left and _Right
+    return _Pred(_Right, _Left) ? _Right : _Left;
+}
+
+#pragma warning(push)
+#pragma warning(disable : 28285) // (syntax error in SAL annotation, occurs when _Ty is not an integral type)
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Post_equal_to_(_Right < _Left ? _Right : _Left) constexpr const _Ty& //
+    (min) (const _Ty& _Left _MSVC_LIFETIMEBOUND, const _Ty& _Right _MSVC_LIFETIMEBOUND) noexcept(
+        noexcept(_Right < _Left)) /* strengthened */ {
+    // return smaller of _Left and _Right
+    return _Right < _Left ? _Right : _Left;
+}
+#pragma warning(pop)
+
+_EXPORT_STD template <class _Ty, class _Pr>
+_NODISCARD constexpr _Ty(min)(initializer_list<_Ty>, _Pr); // implemented in <algorithm>
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD constexpr _Ty(min)(initializer_list<_Ty>); // implemented in <algorithm>
+
+_EXPORT_STD template <class _Ty, size_t _Size, enable_if_t<_Is_swappable<_Ty>::value, int> /* = 0 */>
+_CONSTEXPR20 void swap(_Ty (&_Left)[_Size], _Ty (&_Right)[_Size]) noexcept(_Is_nothrow_swappable<_Ty>::value) {
+    if (&_Left != &_Right) {
+        _Ty* _First1 = _Left;
+        _Ty* _Last1  = _First1 + _Size;
+        _Ty* _First2 = _Right;
+        for (; _First1 != _Last1; ++_First1, ++_First2) {
+            swap(*_First1, *_First2); // intentional ADL
+        }
+    }
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _Ty, enable_if_t<is_move_constructible_v<_Ty> && is_move_assignable_v<_Ty>, int> /* = 0 */>
+#else // ^^^ _HAS_CXX17 / !_HAS_CXX17 vvv
+template <class _Ty, int _Enabled /* = 0 */>
+#endif // ^^^ !_HAS_CXX17 ^^^
+_CONSTEXPR20 void swap(_Ty& _Left, _Ty& _Right) noexcept(
+    is_nothrow_move_constructible_v<_Ty> && is_nothrow_move_assignable_v<_Ty>) {
+    _Ty _Tmp = _STD move(_Left);
+    _Left    = _STD move(_Right);
+    _Right   = _STD move(_Tmp);
+}
+
+_EXPORT_STD struct piecewise_construct_t { // tag type for pair tuple arguments
+    explicit piecewise_construct_t() = default;
+};
+
+_EXPORT_STD _INLINE_VAR constexpr piecewise_construct_t piecewise_construct{};
+
+struct _Ignore { // struct that ignores assignments
+    template <class _Ty>
+    constexpr const _Ignore& operator=(const _Ty&) const noexcept {
+        // do nothing
+        return *this;
+    }
+};
+
+_EXPORT_STD _INLINE_VAR constexpr _Ignore ignore{};
+
+_EXPORT_STD template <class... _Types>
+class tuple;
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+struct pair;
+
+_EXPORT_STD template <class _Ty, size_t _Size>
+class array;
+
+_EXPORT_STD template <class _Tuple>
+struct tuple_size;
+
+_EXPORT_STD template <class _Ty>
+constexpr size_t tuple_size_v = tuple_size<_Ty>::value;
+
+_EXPORT_STD template <size_t _Index, class _Tuple>
+struct tuple_element;
+
+_EXPORT_STD template <size_t _Index, class _Tuple>
+using tuple_element_t = typename tuple_element<_Index, _Tuple>::type;
+
+template <size_t _Index, class... _Types>
+_NODISCARD constexpr auto&& _Tuple_get(tuple<_Types...>&& _Tuple) noexcept;
+
+_EXPORT_STD template <size_t _Index, class... _Types>
+_NODISCARD constexpr tuple_element_t<_Index, tuple<_Types...>>& get(tuple<_Types...>& _Tuple) noexcept;
+
+_EXPORT_STD template <size_t _Index, class... _Types>
+_NODISCARD constexpr const tuple_element_t<_Index, tuple<_Types...>>& get(const tuple<_Types...>& _Tuple) noexcept;
+
+_EXPORT_STD template <size_t _Index, class... _Types>
+_NODISCARD constexpr tuple_element_t<_Index, tuple<_Types...>>&& get(tuple<_Types...>&& _Tuple) noexcept;
+
+_EXPORT_STD template <size_t _Index, class... _Types>
+_NODISCARD constexpr const tuple_element_t<_Index, tuple<_Types...>>&& get(const tuple<_Types...>&& _Tuple) noexcept;
+
+_EXPORT_STD template <size_t _Idx, class _Ty, size_t _Size>
+_NODISCARD constexpr _Ty& get(array<_Ty, _Size>& _Arr) noexcept;
+
+_EXPORT_STD template <size_t _Idx, class _Ty, size_t _Size>
+_NODISCARD constexpr const _Ty& get(const array<_Ty, _Size>& _Arr) noexcept;
+
+_EXPORT_STD template <size_t _Idx, class _Ty, size_t _Size>
+_NODISCARD constexpr _Ty&& get(array<_Ty, _Size>&& _Arr) noexcept;
+
+_EXPORT_STD template <size_t _Idx, class _Ty, size_t _Size>
+_NODISCARD constexpr const _Ty&& get(const array<_Ty, _Size>&& _Arr) noexcept;
+
+#if _HAS_CXX20
+template <class _Ty1, class _Ty2>
+concept _Different_from = !same_as<remove_cvref_t<_Ty1>, remove_cvref_t<_Ty2>>;
+
+template <class>
+constexpr bool _Is_subrange_v = false;
+
+#if _HAS_CXX23
+template <class>
+constexpr bool _Tuple_like_impl = false;
+
+template <class... _Types>
+constexpr bool _Tuple_like_impl<tuple<_Types...>> = true;
+
+template <class _Ty1, class _Ty2>
+constexpr bool _Tuple_like_impl<pair<_Ty1, _Ty2>> = true;
+
+template <class _Ty, size_t _Size>
+constexpr bool _Tuple_like_impl<array<_Ty, _Size>> = true;
+
+template <class _Ty>
+concept _Tuple_like = _Tuple_like_impl<remove_cvref_t<_Ty>>;
+
+template <class _Ty>
+concept _Pair_like = _Tuple_like<_Ty> && tuple_size_v<remove_cvref_t<_Ty>> == 2;
+
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, LLVM-59827 and VSO-1900279
+template <class _PairLike, class _Ty1, class _Ty2>
+concept _Can_construct_from_pair_like = _Pair_like<_PairLike> && !_Is_subrange_v<remove_cvref_t<_PairLike>>
+                                     && is_constructible_v<_Ty1, decltype(_STD get<0>(_STD declval<_PairLike>()))>
+                                     && is_constructible_v<_Ty2, decltype(_STD get<1>(_STD declval<_PairLike>()))>;
+#endif // ^^^ workaround ^^^
+#endif // _HAS_CXX23
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+struct pair { // store a pair of values
+    using first_type  = _Ty1;
+    using second_type = _Ty2;
+
+    template <class _Uty1 = _Ty1, class _Uty2 = _Ty2,
+        enable_if_t<conjunction_v<is_default_constructible<_Uty1>, is_default_constructible<_Uty2>>, int> = 0>
+    constexpr explicit(
+        !conjunction_v<_Is_implicitly_default_constructible<_Uty1>, _Is_implicitly_default_constructible<_Uty2>>)
+        pair() noexcept(
+            is_nothrow_default_constructible_v<_Uty1> && is_nothrow_default_constructible_v<_Uty2>) // strengthened
+        : first(), second() {}
+
+    template <class _Uty1 = _Ty1, class _Uty2 = _Ty2,
+        enable_if_t<conjunction_v<is_copy_constructible<_Uty1>, is_copy_constructible<_Uty2>>, int> = 0>
+    constexpr explicit(!conjunction_v<is_convertible<const _Uty1&, _Uty1>, is_convertible<const _Uty2&, _Uty2>>)
+        pair(const _Ty1& _Val1, const _Ty2& _Val2) noexcept(
+            is_nothrow_copy_constructible_v<_Uty1> && is_nothrow_copy_constructible_v<_Uty2>) // strengthened
+        : first(_Val1), second(_Val2) {}
+
+#if _HAS_CXX23
+    template <class _Other1 = _Ty1, class _Other2 = _Ty2,
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+    template <class _Other1, class _Other2,
+#endif // ^^^ !_HAS_CXX23 ^^^
+        enable_if_t<conjunction_v<is_constructible<_Ty1, _Other1>, is_constructible<_Ty2, _Other2>>, int> = 0>
+    constexpr explicit(!conjunction_v<is_convertible<_Other1, _Ty1>, is_convertible<_Other2, _Ty2>>)
+        pair(_Other1&& _Val1, _Other2&& _Val2) noexcept(
+            is_nothrow_constructible_v<_Ty1, _Other1> && is_nothrow_constructible_v<_Ty2, _Other2>) // strengthened
+        : first(_STD forward<_Other1>(_Val1)), second(_STD forward<_Other2>(_Val2)) {
+    }
+
+    pair(const pair&) = default;
+    pair(pair&&)      = default;
+
+#if _HAS_CXX23
+    template <class _Other1, class _Other2>
+        requires is_constructible_v<_Ty1, _Other1&> && is_constructible_v<_Ty2, _Other2&>
+    constexpr explicit(!conjunction_v<is_convertible<_Other1&, _Ty1>, is_convertible<_Other2&, _Ty2>>)
+        pair(pair<_Other1, _Other2>& _Right) noexcept(
+            is_nothrow_constructible_v<_Ty1, _Other1&> && is_nothrow_constructible_v<_Ty2, _Other2&>) // strengthened
+        : first(_Right.first), second(_Right.second) {}
+#endif // _HAS_CXX23
+
+    template <class _Other1, class _Other2,
+        enable_if_t<conjunction_v<is_constructible<_Ty1, const _Other1&>, is_constructible<_Ty2, const _Other2&>>,
+            int> = 0>
+    constexpr explicit(!conjunction_v<is_convertible<const _Other1&, _Ty1>, is_convertible<const _Other2&, _Ty2>>)
+        pair(const pair<_Other1, _Other2>& _Right) noexcept(
+            is_nothrow_constructible_v<_Ty1, const _Other1&>
+            && is_nothrow_constructible_v<_Ty2, const _Other2&>) // strengthened
+        : first(_Right.first), second(_Right.second) {}
+
+    template <class _Other1, class _Other2,
+        enable_if_t<conjunction_v<is_constructible<_Ty1, _Other1>, is_constructible<_Ty2, _Other2>>, int> = 0>
+    constexpr explicit(!conjunction_v<is_convertible<_Other1, _Ty1>, is_convertible<_Other2, _Ty2>>)
+        pair(pair<_Other1, _Other2>&& _Right) noexcept(
+            is_nothrow_constructible_v<_Ty1, _Other1> && is_nothrow_constructible_v<_Ty2, _Other2>) // strengthened
+        : first(_STD forward<_Other1>(_Right.first)), second(_STD forward<_Other2>(_Right.second)) {}
+
+#if _HAS_CXX23
+    template <class _Other1, class _Other2>
+        requires is_constructible_v<_Ty1, const _Other1> && is_constructible_v<_Ty2, const _Other2>
+    constexpr explicit(!conjunction_v<is_convertible<const _Other1, _Ty1>, is_convertible<const _Other2, _Ty2>>)
+        pair(const pair<_Other1, _Other2>&& _Right) noexcept(
+            is_nothrow_constructible_v<_Ty1, const _Other1>
+            && is_nothrow_constructible_v<_Ty2, const _Other2>) // strengthened
+        : first(_STD forward<const _Other1>(_Right.first)), second(_STD forward<const _Other2>(_Right.second)) {}
+
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, LLVM-59827 (Clang), VSO-1900279 (EDG)
+    template <class _Other, enable_if_t<_Can_construct_from_pair_like<_Other, _Ty1, _Ty2>, int> = 0>
+#else // ^^^ workaround / no workaround vvv
+    template <_Pair_like _Other>
+        requires conjunction_v<bool_constant<!_Is_subrange_v<remove_cvref_t<_Other>>>,
+                     is_constructible<_Ty1, decltype(_STD get<0>(_STD declval<_Other>()))>,
+                     is_constructible<_Ty2, decltype(_STD get<1>(_STD declval<_Other>()))>>
+#endif // ^^^ no workaround ^^^
+    constexpr explicit(!conjunction_v<is_convertible<decltype(_STD get<0>(_STD declval<_Other>())), _Ty1>,
+                       is_convertible<decltype(_STD get<1>(_STD declval<_Other>())), _Ty2>>)
+        pair(_Other&& _Right) noexcept(
+            is_nothrow_constructible_v<_Ty1, decltype(_STD get<0>(_STD declval<_Other>()))>
+            && is_nothrow_constructible_v<_Ty2, decltype(_STD get<1>(_STD declval<_Other>()))>) // strengthened
+        : first(_STD get<0>(_STD forward<_Other>(_Right))), second(_STD get<1>(_STD forward<_Other>(_Right))) {
+    }
+#endif // _HAS_CXX23
+
+    template <class _Tuple1, class _Tuple2, size_t... _Indices1, size_t... _Indices2>
+    constexpr pair(_Tuple1& _Val1, _Tuple2& _Val2, index_sequence<_Indices1...>, index_sequence<_Indices2...>)
+        : first(_STD _Tuple_get<_Indices1>(_STD move(_Val1))...),
+          second(_STD _Tuple_get<_Indices2>(_STD move(_Val2))...) {}
+
+    template <class... _Types1, class... _Types2>
+    _CONSTEXPR20 pair(piecewise_construct_t, tuple<_Types1...> _Val1, tuple<_Types2...> _Val2)
+        : pair(_Val1, _Val2, index_sequence_for<_Types1...>{}, index_sequence_for<_Types2...>{}) {}
+
+    pair& operator=(const volatile pair&) = delete;
+
+    template <class _Myself = pair,
+        enable_if_t<conjunction_v<_Is_copy_assignable_no_precondition_check<typename _Myself::first_type>,
+                        _Is_copy_assignable_no_precondition_check<typename _Myself::second_type>>,
+            int>            = 0>
+    _CONSTEXPR20 pair& operator=(_Identity_t<const _Myself&> _Right) noexcept(
+        conjunction_v<is_nothrow_copy_assignable<_Ty1>, is_nothrow_copy_assignable<_Ty2>>) /* strengthened */ {
+        first  = _Right.first;
+        second = _Right.second;
+        return *this;
+    }
+
+#if _HAS_CXX23
+    template <class _Myself = pair>
+        requires _Is_copy_assignable_unchecked_v<const typename _Myself::first_type>
+              && _Is_copy_assignable_unchecked_v<const typename _Myself::second_type>
+    constexpr const pair& operator=(_Identity_t<const _Myself&> _Right) const
+        noexcept(conjunction_v<is_nothrow_copy_assignable<const _Ty1>,
+            is_nothrow_copy_assignable<const _Ty2>>) /* strengthened */ {
+        first  = _Right.first;
+        second = _Right.second;
+        return *this;
+    }
+#endif // _HAS_CXX23
+
+    template <class _Myself = pair,
+        enable_if_t<conjunction_v<_Is_move_assignable_no_precondition_check<typename _Myself::first_type>,
+                        _Is_move_assignable_no_precondition_check<typename _Myself::second_type>>,
+            int>            = 0>
+    _CONSTEXPR20 pair& operator=(_Identity_t<_Myself&&> _Right) noexcept(
+        conjunction_v<is_nothrow_move_assignable<_Ty1>, is_nothrow_move_assignable<_Ty2>>) /* strengthened */ {
+        first  = _STD forward<_Ty1>(_Right.first);
+        second = _STD forward<_Ty2>(_Right.second);
+        return *this;
+    }
+
+#if _HAS_CXX23
+    template <class _Myself = pair>
+        requires _Is_assignable_no_precondition_check<const typename _Myself::first_type&, _Ty1>::value
+              && _Is_assignable_no_precondition_check<const typename _Myself::second_type&, _Ty2>::value
+    constexpr const pair& operator=(_Identity_t<_Myself&&> _Right) const
+        noexcept(conjunction_v<is_nothrow_assignable<const _Ty1&, _Ty1>,
+            is_nothrow_assignable<const _Ty2&, _Ty2>>) /* strengthened */ {
+        first  = _STD forward<_Ty1>(_Right.first);
+        second = _STD forward<_Ty2>(_Right.second);
+        return *this;
+    }
+#endif // _HAS_CXX23
+
+    template <class _Other1, class _Other2,
+        enable_if_t<conjunction_v<negation<is_same<pair, pair<_Other1, _Other2>>>, is_assignable<_Ty1&, const _Other1&>,
+                        is_assignable<_Ty2&, const _Other2&>>,
+            int> = 0>
+    _CONSTEXPR20 pair& operator=(const pair<_Other1, _Other2>& _Right) noexcept(
+        is_nothrow_assignable_v<_Ty1&, const _Other1&>
+        && is_nothrow_assignable_v<_Ty2&, const _Other2&>) /* strengthened */ {
+        first  = _Right.first;
+        second = _Right.second;
+        return *this;
+    }
+
+#if _HAS_CXX23
+    template <class _Other1, class _Other2>
+        requires (!is_same_v<pair, pair<_Other1, _Other2>>)
+              && is_assignable_v<const _Ty1&, const _Other1&> && is_assignable_v<const _Ty2&, const _Other2&>
+    constexpr const pair& operator=(const pair<_Other1, _Other2>& _Right) const
+        noexcept(is_nothrow_assignable_v<const _Ty1&, const _Other1&>
+                 && is_nothrow_assignable_v<const _Ty2&, const _Other2&>) /* strengthened */ {
+        first  = _Right.first;
+        second = _Right.second;
+        return *this;
+    }
+#endif // _HAS_CXX23
+
+    template <class _Other1, class _Other2,
+        enable_if_t<conjunction_v<negation<is_same<pair, pair<_Other1, _Other2>>>, is_assignable<_Ty1&, _Other1>,
+                        is_assignable<_Ty2&, _Other2>>,
+            int> = 0>
+    _CONSTEXPR20 pair& operator=(pair<_Other1, _Other2>&& _Right) noexcept(
+        is_nothrow_assignable_v<_Ty1&, _Other1> && is_nothrow_assignable_v<_Ty2&, _Other2>) /* strengthened */ {
+        first  = _STD forward<_Other1>(_Right.first);
+        second = _STD forward<_Other2>(_Right.second);
+        return *this;
+    }
+
+#if _HAS_CXX23
+    template <class _Other1, class _Other2>
+        requires (!is_same_v<pair, pair<_Other1, _Other2>>)
+              && is_assignable_v<const _Ty1&, _Other1> && is_assignable_v<const _Ty2&, _Other2>
+    constexpr const pair& operator=(pair<_Other1, _Other2>&& _Right) const
+        noexcept(is_nothrow_assignable_v<const _Ty1&, _Other1>
+                 && is_nothrow_assignable_v<const _Ty2&, _Other2>) /* strengthened */ {
+        first  = _STD forward<_Other1>(_Right.first);
+        second = _STD forward<_Other2>(_Right.second);
+        return *this;
+    }
+
+    template <_Pair_like _Other>
+        requires _Different_from<_Other, pair> && (!_Is_subrange_v<remove_cvref_t<_Other>>)
+              && is_assignable_v<_Ty1&, decltype(_STD get<0>(_STD declval<_Other>()))>
+              && is_assignable_v<_Ty2&, decltype(_STD get<1>(_STD declval<_Other>()))>
+    constexpr pair& operator=(_Other&& _Right) noexcept(
+        is_nothrow_assignable_v<_Ty1&, decltype(_STD get<0>(_STD declval<_Other>()))>
+        && is_nothrow_assignable_v<_Ty2&, decltype(_STD get<1>(_STD declval<_Other>()))>) /* strengthened */ {
+        first  = _STD get<0>(_STD forward<_Other>(_Right));
+        second = _STD get<1>(_STD forward<_Other>(_Right));
+        return *this;
+    }
+
+    template <_Pair_like _Other>
+        requires _Different_from<_Other, pair> && (!_Is_subrange_v<remove_cvref_t<_Other>>)
+              && is_assignable_v<const _Ty1&, decltype(_STD get<0>(_STD declval<_Other>()))>
+              && is_assignable_v<const _Ty2&, decltype(_STD get<1>(_STD declval<_Other>()))>
+    constexpr const pair& operator=(_Other&& _Right) const noexcept(
+        is_nothrow_assignable_v<const _Ty1&, decltype(_STD get<0>(_STD declval<_Other>()))>
+        && is_nothrow_assignable_v<const _Ty2&, decltype(_STD get<1>(_STD declval<_Other>()))>) /* strengthened */ {
+        first  = _STD get<0>(_STD forward<_Other>(_Right));
+        second = _STD get<1>(_STD forward<_Other>(_Right));
+        return *this;
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 void swap(pair& _Right) noexcept(
+        _Is_nothrow_swappable<_Ty1>::value && _Is_nothrow_swappable<_Ty2>::value) {
+        using _STD swap;
+        swap(first, _Right.first); // intentional ADL
+        swap(second, _Right.second); // intentional ADL
+    }
+
+#if _HAS_CXX23
+    template <int = 0> // see GH-3013
+    constexpr void swap(const pair& _Right) const
+        noexcept(is_nothrow_swappable_v<const _Ty1> && is_nothrow_swappable_v<const _Ty2>) {
+        using _STD swap;
+        swap(first, _Right.first); // intentional ADL
+        swap(second, _Right.second); // intentional ADL
+    }
+#endif // _HAS_CXX23
+
+    _Ty1 first; // the first stored value
+    _Ty2 second; // the second stored value
+};
+
+#if _HAS_CXX17
+template <class _Ty1, class _Ty2>
+pair(_Ty1, _Ty2) -> pair<_Ty1, _Ty2>;
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Ty1, class _Ty2,
+    enable_if_t<_Is_swappable<_Ty1>::value && _Is_swappable<_Ty2>::value, int> = 0>
+_CONSTEXPR20 void swap(pair<_Ty1, _Ty2>& _Left, pair<_Ty1, _Ty2>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+
+#if _HAS_CXX23
+_EXPORT_STD template <class _Ty1, class _Ty2>
+    requires is_swappable<const _Ty1>::value && is_swappable<const _Ty2>::value // TRANSITION, /permissive needs ::value
+constexpr void swap(const pair<_Ty1, _Ty2>& _Left, const pair<_Ty1, _Ty2>& _Right) noexcept(
+    noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+#endif // _HAS_CXX23
+
+_EXPORT_STD template <class _Ty1, class _Ty2, class _Uty1, class _Uty2>
+_NODISCARD constexpr bool operator==(const pair<_Ty1, _Ty2>& _Left, const pair<_Uty1, _Uty2>& _Right) {
+    return _Left.first == _Right.first && _Left.second == _Right.second;
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty1, class _Ty2, class _Uty1, class _Uty2>
+_NODISCARD constexpr common_comparison_category_t<_Synth_three_way_result<_Ty1, _Uty1>,
+    _Synth_three_way_result<_Ty2, _Uty2>>
+    operator<=>(const pair<_Ty1, _Ty2>& _Left, const pair<_Uty1, _Uty2>& _Right) {
+    if (auto _Result = _Synth_three_way{}(_Left.first, _Right.first); _Result != 0) {
+        return _Result;
+    }
+    return _Synth_three_way{}(_Left.second, _Right.second);
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Ty1, class _Ty2, class _Uty1, class _Uty2>
+_NODISCARD constexpr bool operator!=(const pair<_Ty1, _Ty2>& _Left, const pair<_Uty1, _Uty2>& _Right) {
+    return !(_Left == _Right);
+}
+
+template <class _Ty1, class _Ty2, class _Uty1, class _Uty2>
+_NODISCARD constexpr bool operator<(const pair<_Ty1, _Ty2>& _Left, const pair<_Uty1, _Uty2>& _Right) {
+    return _Left.first < _Right.first || (!(_Right.first < _Left.first) && _Left.second < _Right.second);
+}
+
+template <class _Ty1, class _Ty2, class _Uty1, class _Uty2>
+_NODISCARD constexpr bool operator>(const pair<_Ty1, _Ty2>& _Left, const pair<_Uty1, _Uty2>& _Right) {
+    return _Right < _Left;
+}
+
+template <class _Ty1, class _Ty2, class _Uty1, class _Uty2>
+_NODISCARD constexpr bool operator<=(const pair<_Ty1, _Ty2>& _Left, const pair<_Uty1, _Uty2>& _Right) {
+    return !(_Right < _Left);
+}
+
+template <class _Ty1, class _Ty2, class _Uty1, class _Uty2>
+_NODISCARD constexpr bool operator>=(const pair<_Ty1, _Ty2>& _Left, const pair<_Uty1, _Uty2>& _Right) {
+    return !(_Left < _Right);
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+#if _HAS_CXX23
+template <class _Ty1, class _Ty2, class _Uty1, class _Uty2, template <class> class _TQual,
+    template <class> class _UQual>
+    requires requires {
+        typename pair<common_reference_t<_TQual<_Ty1>, _UQual<_Uty1>>, common_reference_t<_TQual<_Ty2>, _UQual<_Uty2>>>;
+    }
+struct basic_common_reference<pair<_Ty1, _Ty2>, pair<_Uty1, _Uty2>, _TQual, _UQual> {
+    using type = pair<common_reference_t<_TQual<_Ty1>, _UQual<_Uty1>>, common_reference_t<_TQual<_Ty2>, _UQual<_Uty2>>>;
+};
+
+template <class _Ty1, class _Ty2, class _Uty1, class _Uty2>
+    requires requires { typename pair<common_type_t<_Ty1, _Uty1>, common_type_t<_Ty2, _Uty2>>; }
+struct common_type<pair<_Ty1, _Ty2>, pair<_Uty1, _Uty2>> {
+    using type = pair<common_type_t<_Ty1, _Uty1>, common_type_t<_Ty2, _Uty2>>;
+};
+#endif // _HAS_CXX23
+
+template <class _Ty>
+struct _Unrefwrap_helper { // leave unchanged if not a reference_wrapper
+    using type = _Ty;
+};
+
+template <class _Ty>
+struct _Unrefwrap_helper<reference_wrapper<_Ty>> { // make a reference from a reference_wrapper
+    using type = _Ty&;
+};
+
+// decay, then unwrap a reference_wrapper
+template <class _Ty>
+using _Unrefwrap_t = typename _Unrefwrap_helper<decay_t<_Ty>>::type;
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr pair<_Unrefwrap_t<_Ty1>, _Unrefwrap_t<_Ty2>> make_pair(_Ty1&& _Val1, _Ty2&& _Val2) noexcept(
+    is_nothrow_constructible_v<_Unrefwrap_t<_Ty1>, _Ty1>
+    && is_nothrow_constructible_v<_Unrefwrap_t<_Ty2>, _Ty2>) /* strengthened */ {
+    // return pair composed from arguments
+    using _Mypair = pair<_Unrefwrap_t<_Ty1>, _Unrefwrap_t<_Ty2>>;
+    return _Mypair(_STD forward<_Ty1>(_Val1), _STD forward<_Ty2>(_Val2));
+}
+
+namespace _CXX20_DEPRECATE_REL_OPS rel_ops {
+    _EXPORT_STD template <class _Ty>
+    _CXX20_DEPRECATE_REL_OPS _NODISCARD bool operator!=(const _Ty& _Left, const _Ty& _Right) {
+        return !(_Left == _Right);
+    }
+
+    _EXPORT_STD template <class _Ty>
+    _CXX20_DEPRECATE_REL_OPS _NODISCARD bool operator>(const _Ty& _Left, const _Ty& _Right) {
+        return _Right < _Left;
+    }
+
+    _EXPORT_STD template <class _Ty>
+    _CXX20_DEPRECATE_REL_OPS _NODISCARD bool operator<=(const _Ty& _Left, const _Ty& _Right) {
+        return !(_Right < _Left);
+    }
+
+    _EXPORT_STD template <class _Ty>
+    _CXX20_DEPRECATE_REL_OPS _NODISCARD bool operator>=(const _Ty& _Left, const _Ty& _Right) {
+        return !(_Left < _Right);
+    }
+} // namespace _CXX20_DEPRECATE_REL_OPS rel_ops
+
+template <class _Tuple, class = void>
+struct _Tuple_size_sfinae {}; // selected when tuple_size<_Tuple>::value isn't well-formed
+
+template <class _Tuple>
+struct _Tuple_size_sfinae<_Tuple, void_t<decltype(tuple_size<_Tuple>::value)>>
+    : integral_constant<size_t, tuple_size<_Tuple>::value> {}; // selected when tuple_size<_Tuple>::value is well-formed
+
+template <class _Tuple>
+struct tuple_size<const _Tuple> : _Tuple_size_sfinae<_Tuple> {}; // ignore cv
+
+template <class _Tuple>
+struct _CXX20_DEPRECATE_VOLATILE tuple_size<volatile _Tuple> : _Tuple_size_sfinae<_Tuple> {}; // ignore cv
+
+template <class _Tuple>
+struct _CXX20_DEPRECATE_VOLATILE tuple_size<const volatile _Tuple> : _Tuple_size_sfinae<_Tuple> {}; // ignore cv
+
+template <size_t _Index, class _Tuple>
+struct _MSVC_KNOWN_SEMANTICS tuple_element<_Index, const _Tuple> : tuple_element<_Index, _Tuple> {
+    using _Mybase = tuple_element<_Index, _Tuple>;
+    using type    = add_const_t<typename _Mybase::type>;
+};
+
+template <size_t _Index, class _Tuple>
+struct _CXX20_DEPRECATE_VOLATILE _MSVC_KNOWN_SEMANTICS tuple_element<_Index, volatile _Tuple>
+    : tuple_element<_Index, _Tuple> {
+    using _Mybase = tuple_element<_Index, _Tuple>;
+    using type    = add_volatile_t<typename _Mybase::type>;
+};
+
+template <size_t _Index, class _Tuple>
+struct _CXX20_DEPRECATE_VOLATILE _MSVC_KNOWN_SEMANTICS tuple_element<_Index, const volatile _Tuple>
+    : tuple_element<_Index, _Tuple> {
+    using _Mybase = tuple_element<_Index, _Tuple>;
+    using type    = add_cv_t<typename _Mybase::type>;
+};
+
+template <class _Ty, size_t _Size>
+struct tuple_size<array<_Ty, _Size>> : integral_constant<size_t, _Size> {}; // size of array
+
+template <size_t _Idx, class _Ty, size_t _Size>
+struct _MSVC_KNOWN_SEMANTICS tuple_element<_Idx, array<_Ty, _Size>> {
+    static_assert(_Idx < _Size, "array index out of bounds");
+
+    using type = _Ty;
+};
+
+template <class... _Types>
+struct tuple_size<tuple<_Types...>> : integral_constant<size_t, sizeof...(_Types)> {}; // size of tuple
+
+template <size_t _Index>
+struct _MSVC_KNOWN_SEMANTICS tuple_element<_Index, tuple<>> { // enforce bounds checking
+    static_assert(_Always_false<integral_constant<size_t, _Index>>, "tuple index out of bounds");
+};
+
+template <class _This, class... _Rest>
+struct _MSVC_KNOWN_SEMANTICS tuple_element<0, tuple<_This, _Rest...>> { // select first element
+    using type = _This;
+    // MSVC assumes the meaning of _Ttype; remove or rename, but do not change semantics
+    using _Ttype = tuple<_This, _Rest...>;
+};
+
+template <size_t _Index, class _This, class... _Rest>
+struct _MSVC_KNOWN_SEMANTICS tuple_element<_Index, tuple<_This, _Rest...>>
+    : tuple_element<_Index - 1, tuple<_Rest...>> {}; // recursive tuple_element definition
+
+template <class _Ty1, class _Ty2>
+struct tuple_size<pair<_Ty1, _Ty2>> : integral_constant<size_t, 2> {}; // size of pair
+
+template <size_t _Idx, class _Ty1, class _Ty2>
+struct _MSVC_KNOWN_SEMANTICS tuple_element<_Idx, pair<_Ty1, _Ty2>> {
+    static_assert(_Idx < 2, "pair index out of bounds");
+
+    using type = conditional_t<_Idx == 0, _Ty1, _Ty2>;
+};
+
+_EXPORT_STD template <size_t _Idx, class _Ty1, class _Ty2>
+_NODISCARD constexpr tuple_element_t<_Idx, pair<_Ty1, _Ty2>>& get(pair<_Ty1, _Ty2>& _Pr) noexcept {
+    // get reference to element at _Idx in pair _Pr
+    if constexpr (_Idx == 0) {
+        return _Pr.first;
+    } else {
+        return _Pr.second;
+    }
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr _Ty1& get(pair<_Ty1, _Ty2>& _Pr) noexcept {
+    // get reference to element _Ty1 in pair _Pr
+    return _Pr.first;
+}
+
+_EXPORT_STD template <class _Ty2, class _Ty1>
+_NODISCARD constexpr _Ty2& get(pair<_Ty1, _Ty2>& _Pr) noexcept {
+    // get reference to element _Ty2 in pair _Pr
+    return _Pr.second;
+}
+
+_EXPORT_STD template <size_t _Idx, class _Ty1, class _Ty2>
+_NODISCARD constexpr const tuple_element_t<_Idx, pair<_Ty1, _Ty2>>& get(const pair<_Ty1, _Ty2>& _Pr) noexcept {
+    // get const reference to element at _Idx in pair _Pr
+    if constexpr (_Idx == 0) {
+        return _Pr.first;
+    } else {
+        return _Pr.second;
+    }
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr const _Ty1& get(const pair<_Ty1, _Ty2>& _Pr) noexcept {
+    // get const reference to element _Ty1 in pair _Pr
+    return _Pr.first;
+}
+
+_EXPORT_STD template <class _Ty2, class _Ty1>
+_NODISCARD constexpr const _Ty2& get(const pair<_Ty1, _Ty2>& _Pr) noexcept {
+    // get const reference to element _Ty2 in pair _Pr
+    return _Pr.second;
+}
+
+_EXPORT_STD template <size_t _Idx, class _Ty1, class _Ty2>
+_NODISCARD constexpr tuple_element_t<_Idx, pair<_Ty1, _Ty2>>&& get(pair<_Ty1, _Ty2>&& _Pr) noexcept {
+    // get rvalue reference to element at _Idx in pair _Pr
+    if constexpr (_Idx == 0) {
+        return _STD forward<_Ty1>(_Pr.first);
+    } else {
+        return _STD forward<_Ty2>(_Pr.second);
+    }
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr _Ty1&& get(pair<_Ty1, _Ty2>&& _Pr) noexcept {
+    // get rvalue reference to element _Ty1 in pair _Pr
+    return _STD forward<_Ty1>(_Pr.first);
+}
+
+_EXPORT_STD template <class _Ty2, class _Ty1>
+_NODISCARD constexpr _Ty2&& get(pair<_Ty1, _Ty2>&& _Pr) noexcept {
+    // get rvalue reference to element _Ty2 in pair _Pr
+    return _STD forward<_Ty2>(_Pr.second);
+}
+
+_EXPORT_STD template <size_t _Idx, class _Ty1, class _Ty2>
+_NODISCARD constexpr const tuple_element_t<_Idx, pair<_Ty1, _Ty2>>&& get(const pair<_Ty1, _Ty2>&& _Pr) noexcept {
+    // get const rvalue reference to element at _Idx in pair _Pr
+    if constexpr (_Idx == 0) {
+        return _STD forward<const _Ty1>(_Pr.first);
+    } else {
+        return _STD forward<const _Ty2>(_Pr.second);
+    }
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr const _Ty1&& get(const pair<_Ty1, _Ty2>&& _Pr) noexcept {
+    // get const rvalue reference to element _Ty1 in pair _Pr
+    return _STD forward<const _Ty1>(_Pr.first);
+}
+
+_EXPORT_STD template <class _Ty2, class _Ty1>
+_NODISCARD constexpr const _Ty2&& get(const pair<_Ty1, _Ty2>&& _Pr) noexcept {
+    // get const rvalue reference to element _Ty2 in pair _Pr
+    return _STD forward<const _Ty2>(_Pr.second);
+}
+
+_EXPORT_STD template <class _Ty, class _Other = _Ty>
+_CONSTEXPR20 _Ty exchange(_Ty& _Val, _Other&& _New_val) noexcept(
+    conjunction_v<is_nothrow_move_constructible<_Ty>, is_nothrow_assignable<_Ty&, _Other>>) {
+    // assign _New_val to _Val, return previous _Val
+    _Ty _Old_val = static_cast<_Ty&&>(_Val);
+    _Val         = static_cast<_Other&&>(_New_val);
+    return _Old_val;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _MSVC_INTRINSIC constexpr add_const_t<_Ty>& as_const(_Ty& _Val) noexcept { // view _Val through const lenses
+    return _Val;
+}
+
+_EXPORT_STD template <class _Ty>
+void as_const(const _Ty&&) = delete;
+
+#if _HAS_CXX17
+_EXPORT_STD struct in_place_t { // tag used to select a constructor which initializes a contained object in place
+    explicit in_place_t() = default;
+};
+_EXPORT_STD inline constexpr in_place_t in_place{};
+
+_EXPORT_STD template <class>
+struct in_place_type_t { // tag that selects a type to construct in place
+    explicit in_place_type_t() = default;
+};
+_EXPORT_STD template <class _Ty>
+constexpr in_place_type_t<_Ty> in_place_type{};
+
+_EXPORT_STD template <size_t>
+struct in_place_index_t { // tag that selects the index of a type to construct in place
+    explicit in_place_index_t() = default;
+};
+_EXPORT_STD template <size_t _Idx>
+constexpr in_place_index_t<_Idx> in_place_index{};
+#endif // _HAS_CXX17
+
+template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool _Cmp_equal(const _Ty1 _Left, const _Ty2 _Right) noexcept {
+    _STL_INTERNAL_STATIC_ASSERT(_Is_nonbool_integral<_Ty1> && _Is_nonbool_integral<_Ty2>); // allows character types
+    if constexpr (is_signed_v<_Ty1> == is_signed_v<_Ty2>) {
+        return _Left == _Right;
+    } else if constexpr (is_signed_v<_Ty2>) {
+        return _Left == static_cast<make_unsigned_t<_Ty2>>(_Right) && _Right >= 0;
+    } else {
+        return static_cast<make_unsigned_t<_Ty1>>(_Left) == _Right && _Left >= 0;
+    }
+}
+
+template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool _Cmp_not_equal(const _Ty1 _Left, const _Ty2 _Right) noexcept {
+    return !_STD _Cmp_equal(_Left, _Right);
+}
+
+template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool _Cmp_less(const _Ty1 _Left, const _Ty2 _Right) noexcept {
+    _STL_INTERNAL_STATIC_ASSERT(_Is_nonbool_integral<_Ty1> && _Is_nonbool_integral<_Ty2>); // allows character types
+    if constexpr (is_signed_v<_Ty1> == is_signed_v<_Ty2>) {
+        return _Left < _Right;
+    } else if constexpr (is_signed_v<_Ty2>) {
+        return _Right > 0 && _Left < static_cast<make_unsigned_t<_Ty2>>(_Right);
+    } else {
+        return _Left < 0 || static_cast<make_unsigned_t<_Ty1>>(_Left) < _Right;
+    }
+}
+
+template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool _Cmp_greater(const _Ty1 _Left, const _Ty2 _Right) noexcept {
+    return _STD _Cmp_less(_Right, _Left);
+}
+
+template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool _Cmp_less_equal(const _Ty1 _Left, const _Ty2 _Right) noexcept {
+    return !_STD _Cmp_less(_Right, _Left);
+}
+
+template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool _Cmp_greater_equal(const _Ty1 _Left, const _Ty2 _Right) noexcept {
+    return !_STD _Cmp_less(_Left, _Right);
+}
+
+template <class _Ty>
+_NODISCARD constexpr _Ty _Min_limit() noexcept { // same as (numeric_limits<_Ty>::min)(), less throughput cost
+    _STL_INTERNAL_STATIC_ASSERT(is_integral_v<_Ty>); // doesn't attempt to handle all types
+    if constexpr (is_signed_v<_Ty>) {
+        constexpr auto _Unsigned_max = static_cast<make_unsigned_t<_Ty>>(-1);
+        return static_cast<_Ty>((_Unsigned_max >> 1) + 1); // well-defined, N4950 [conv.integral]/3
+    } else {
+        return 0;
+    }
+}
+
+template <class _Ty>
+_NODISCARD constexpr _Ty _Max_limit() noexcept { // same as (numeric_limits<_Ty>::max)(), less throughput cost
+    _STL_INTERNAL_STATIC_ASSERT(is_integral_v<_Ty>); // doesn't attempt to handle all types
+    if constexpr (is_signed_v<_Ty>) {
+        constexpr auto _Unsigned_max = static_cast<make_unsigned_t<_Ty>>(-1);
+        return static_cast<_Ty>(_Unsigned_max >> 1);
+    } else {
+        return static_cast<_Ty>(-1);
+    }
+}
+
+template <class _Rx, class _Ty>
+_NODISCARD constexpr bool _In_range(const _Ty _Value) noexcept {
+    _STL_INTERNAL_STATIC_ASSERT(_Is_nonbool_integral<_Rx> && _Is_nonbool_integral<_Ty>); // allows character types
+
+    constexpr auto _Ty_min = _Min_limit<_Ty>();
+    constexpr auto _Rx_min = _Min_limit<_Rx>();
+
+    if constexpr (_STD _Cmp_less(_Ty_min, _Rx_min)) {
+        if (_Value < _Ty{_Rx_min}) {
+            return false;
+        }
+    }
+
+    constexpr auto _Ty_max = _Max_limit<_Ty>();
+    constexpr auto _Rx_max = _Max_limit<_Rx>();
+
+    if constexpr (_STD _Cmp_greater(_Ty_max, _Rx_max)) {
+        if (_Value > _Ty{_Rx_max}) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+#if _HAS_CXX20
+template <class _Ty>
+constexpr bool _Is_standard_integer = _Is_any_of_v<remove_cv_t<_Ty>, signed char, short, int, long, long long,
+    unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long>;
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool cmp_equal(const _Ty1 _Left, const _Ty2 _Right) noexcept {
+    static_assert(_Is_standard_integer<_Ty1> && _Is_standard_integer<_Ty2>,
+        "The integer comparison functions only accept standard and extended integer types.");
+    return _STD _Cmp_equal(_Left, _Right);
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool cmp_not_equal(const _Ty1 _Left, const _Ty2 _Right) noexcept {
+    static_assert(_Is_standard_integer<_Ty1> && _Is_standard_integer<_Ty2>,
+        "The integer comparison functions only accept standard and extended integer types.");
+    return _STD _Cmp_not_equal(_Left, _Right);
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool cmp_less(const _Ty1 _Left, const _Ty2 _Right) noexcept {
+    static_assert(_Is_standard_integer<_Ty1> && _Is_standard_integer<_Ty2>,
+        "The integer comparison functions only accept standard and extended integer types.");
+    return _STD _Cmp_less(_Left, _Right);
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool cmp_greater(const _Ty1 _Left, const _Ty2 _Right) noexcept {
+    static_assert(_Is_standard_integer<_Ty1> && _Is_standard_integer<_Ty2>,
+        "The integer comparison functions only accept standard and extended integer types.");
+    return _STD _Cmp_greater(_Left, _Right);
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool cmp_less_equal(const _Ty1 _Left, const _Ty2 _Right) noexcept {
+    static_assert(_Is_standard_integer<_Ty1> && _Is_standard_integer<_Ty2>,
+        "The integer comparison functions only accept standard and extended integer types.");
+    return _STD _Cmp_less_equal(_Left, _Right);
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool cmp_greater_equal(const _Ty1 _Left, const _Ty2 _Right) noexcept {
+    static_assert(_Is_standard_integer<_Ty1> && _Is_standard_integer<_Ty2>,
+        "The integer comparison functions only accept standard and extended integer types.");
+    return _STD _Cmp_greater_equal(_Left, _Right);
+}
+
+_EXPORT_STD template <class _Rx, class _Ty>
+_NODISCARD constexpr bool in_range(const _Ty _Value) noexcept {
+    static_assert(_Is_standard_integer<_Rx> && _Is_standard_integer<_Ty>,
+        "The integer comparison functions only accept standard and extended integer types.");
+    return _STD _In_range<_Rx>(_Value);
+}
+#endif // _HAS_CXX20
+
+#if _HAS_CXX23
+_EXPORT_STD template <class _Ty>
+_NODISCARD _MSVC_INTRINSIC constexpr underlying_type_t<_Ty> to_underlying(_Ty _Value) noexcept {
+    return static_cast<underlying_type_t<_Ty>>(_Value);
+}
+
+_EXPORT_STD [[noreturn]] __forceinline void unreachable() noexcept /* strengthened */ {
+    _STL_UNREACHABLE;
+#ifdef _DEBUG
+    _CSTD abort(); // likely to be called in debug mode, but can't be relied upon - already entered the UB territory
+#endif // defined(_DEBUG)
+}
+
+template <class _Ty, class _Uty,
+    class _Tmp = _Maybe_const<is_const_v<remove_reference_t<_Ty>>, remove_reference_t<_Uty>>>
+using _Forward_like_t = conditional_t<is_rvalue_reference_v<_Ty&&>, _Tmp&&, _Tmp&>;
+
+_EXPORT_STD template <class _Ty, class _Uty>
+_NODISCARD _MSVC_INTRINSIC constexpr _Forward_like_t<_Ty, _Uty> forward_like(_Uty&& _Ux) noexcept {
+    return static_cast<_Forward_like_t<_Ty, _Uty>>(_Ux);
+}
+#endif // _HAS_CXX23
+
+#if _HAS_TR1_NAMESPACE
+namespace _DEPRECATE_TR1_NAMESPACE tr1 {
+    using _STD get;
+    using _STD tuple_element;
+    using _STD tuple_size;
+} // namespace _DEPRECATE_TR1_NAMESPACE tr1
+#endif // _HAS_TR1_NAMESPACE
+
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("lifetimebound")
+#pragma pop_macro("known_semantics")
+#pragma pop_macro("intrinsic")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _UTILITY_

miniMSVC/VC/Tools/MSVC/14.42.34433/include/vadefs.h

@@ -0,0 +1,208 @@
+//
+// vadefs.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Definitions of macro helpers used by <stdarg.h>.  This is the topmost header
+// in the CRT header lattice, and is always the first CRT header to be included,
+// explicitly or implicitly.  Therefore, this header also has several definitions
+// that are used throughout the CRT.
+//
+#pragma once
+#define _INC_VADEFS
+
+#define _CRT_PACKING 8
+#pragma pack(push, _CRT_PACKING)
+
+// C4339: '__type_info_node': use of undefined type detected in CLR meta-data (/Wall)
+#ifndef _VCRUNTIME_DISABLED_WARNING_4339
+    #ifdef _M_CEE_PURE
+        #define _VCRUNTIME_DISABLED_WARNING_4339 4339
+    #else
+        #define _VCRUNTIME_DISABLED_WARNING_4339
+    #endif
+#endif
+
+// C4412: function signature contains type '<typename>';
+//        C++ objects are unsafe to pass between pure code and mixed or native. (/Wall)
+#ifndef _VCRUNTIME_DISABLED_WARNING_4412
+    #ifdef _M_CEE_PURE
+        #define _VCRUNTIME_DISABLED_WARNING_4412 4412
+    #else
+        #define _VCRUNTIME_DISABLED_WARNING_4412
+    #endif
+#endif
+
+// Use _VCRUNTIME_EXTRA_DISABLED_WARNINGS to add additional warning suppressions to VCRuntime headers.
+#ifndef _VCRUNTIME_EXTRA_DISABLED_WARNINGS
+    #define _VCRUNTIME_EXTRA_DISABLED_WARNINGS
+#endif
+
+// C4514: unreferenced inline function has been removed (/Wall)
+// C4820: '<typename>' : 'N' bytes padding added after data member (/Wall)
+#ifndef _VCRUNTIME_DISABLED_WARNINGS
+    #define _VCRUNTIME_DISABLED_WARNINGS _VCRUNTIME_DISABLED_WARNING_4339 _VCRUNTIME_DISABLED_WARNING_4412 4514 4820 _VCRUNTIME_EXTRA_DISABLED_WARNINGS
+#endif
+
+#pragma warning(push)
+#pragma warning(disable: _VCRUNTIME_DISABLED_WARNINGS)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined _W64
+#define _W64
+#endif
+
+#ifndef _UINTPTR_T_DEFINED
+    #define _UINTPTR_T_DEFINED
+    #ifdef _WIN64
+        typedef unsigned __int64  uintptr_t;
+    #else
+        typedef unsigned int uintptr_t;
+    #endif
+#endif
+
+#ifndef _VA_LIST_DEFINED
+    #define _VA_LIST_DEFINED
+    #ifdef _M_CEE_PURE
+        typedef System::ArgIterator va_list;
+    #else
+        typedef char* va_list;
+    #endif
+#endif
+
+#ifdef __cplusplus
+    #define _ADDRESSOF(v) (&const_cast<char&>(reinterpret_cast<const volatile char&>(v)))
+#else
+    #define _ADDRESSOF(v) (&(v))
+#endif
+
+#if (defined _M_ARM || defined _M_HYBRID_X86_ARM64) && !defined _M_CEE_PURE
+    #define _VA_ALIGN       4
+    #define _SLOTSIZEOF(t)  ((sizeof(t) + _VA_ALIGN - 1) & ~(_VA_ALIGN - 1))
+    #define _APALIGN(t,ap)  (((va_list)0 - (ap)) & (__alignof(t) - 1))
+#elif (defined _M_ARM64 || defined _M_ARM64EC) && !defined _M_CEE_PURE
+    #define _VA_ALIGN       8
+    #define _SLOTSIZEOF(t)  ((sizeof(t) + _VA_ALIGN - 1) & ~(_VA_ALIGN - 1))
+    #define _APALIGN(t,ap)  (((va_list)0 - (ap)) & (__alignof(t) - 1))
+#else
+    #define _SLOTSIZEOF(t)  (sizeof(t))
+    #define _APALIGN(t,ap)  (__alignof(t))
+#endif
+
+#if defined _M_CEE_PURE || (defined _M_CEE && !defined _M_ARM && !defined _M_ARM64)
+
+    void  __cdecl __va_start(va_list*, ...);
+    void* __cdecl __va_arg(va_list*, ...);
+    void  __cdecl __va_end(va_list*);
+
+    #define __crt_va_start_a(ap, v) ((void)(__va_start(&ap, _ADDRESSOF(v), _SLOTSIZEOF(v), __alignof(v), _ADDRESSOF(v))))
+    #define __crt_va_arg(ap, t)     (*(t *)__va_arg(&ap, _SLOTSIZEOF(t), _APALIGN(t,ap), (t*)0))
+    #define __crt_va_end(ap)        ((void)(__va_end(&ap)))
+
+#elif defined _M_IX86 && !defined _M_HYBRID_X86_ARM64
+
+    #define _INTSIZEOF(n)          ((sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1))
+
+    #define __crt_va_start_a(ap, v) ((void)(ap = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v)))
+    #define __crt_va_arg(ap, t)     (*(t*)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)))
+    #define __crt_va_end(ap)        ((void)(ap = (va_list)0))
+
+#elif defined _M_ARM
+
+    #ifdef __cplusplus
+        void __cdecl __va_start(va_list*, ...);
+        #define __crt_va_start_a(ap, v) ((void)(__va_start(&ap, _ADDRESSOF(v), _SLOTSIZEOF(v), _ADDRESSOF(v))))
+    #else
+        #define __crt_va_start_a(ap, v) ((void)(ap = (va_list)_ADDRESSOF(v) + _SLOTSIZEOF(v)))
+    #endif
+
+    #define __crt_va_arg(ap, t) (*(t*)((ap += _SLOTSIZEOF(t) + _APALIGN(t,ap)) - _SLOTSIZEOF(t)))
+    #define __crt_va_end(ap)    ((void)(ap = (va_list)0))
+
+#elif defined _M_HYBRID_X86_ARM64
+    void __cdecl __va_start(va_list*, ...);
+    #define __crt_va_start_a(ap,v) ((void)(__va_start(&ap, _ADDRESSOF(v), _SLOTSIZEOF(v), __alignof(v), _ADDRESSOF(v))))
+    #define __crt_va_arg(ap, t)    (*(t*)((ap += _SLOTSIZEOF(t)) - _SLOTSIZEOF(t)))
+    #define __crt_va_end(ap)       ((void)(ap = (va_list)0))
+
+#elif defined _M_ARM64
+
+    void __cdecl __va_start(va_list*, ...);
+
+    #define __crt_va_start_a(ap,v) ((void)(__va_start(&ap, _ADDRESSOF(v), _SLOTSIZEOF(v), __alignof(v), _ADDRESSOF(v))))
+    #define __crt_va_arg(ap, t)                                                 \
+       ((sizeof(t) > (2 * sizeof(__int64)))                                   \
+           ? **(t**)((ap += sizeof(__int64)) - sizeof(__int64))               \
+           : *(t*)((ap += _SLOTSIZEOF(t) + _APALIGN(t,ap)) - _SLOTSIZEOF(t)))
+    #define __crt_va_end(ap)       ((void)(ap = (va_list)0))
+
+#elif defined _M_ARM64EC
+    void __cdecl __va_start(va_list*, ...);
+    //take the ARM64 va_start (for now)
+    #define __crt_va_start_a(ap,v) ((void)(__va_start(&ap, _ADDRESSOF(v), _SLOTSIZEOF(v), __alignof(v), _ADDRESSOF(v))))
+    //a hybrid va arg, to account for the shift in calling convention, with the alignment of ARM64
+    #define __crt_va_arg(ap, t)                                               \
+        ((sizeof(t) > sizeof(__int64) || (sizeof(t) & (sizeof(t) - 1)) != 0) \
+            ? **(t**)((ap += sizeof(__int64)) - sizeof(__int64))             \
+            : *(t*)((ap += _SLOTSIZEOF(t) + _APALIGN(t,ap)) - _SLOTSIZEOF(t)))
+    #define __crt_va_end(ap)        ((void)(ap = (va_list)0))
+
+#elif defined _M_X64
+
+    void __cdecl __va_start(va_list* , ...);
+
+    #define __crt_va_start_a(ap, x) ((void)(__va_start(&ap, x)))
+    #define __crt_va_arg(ap, t)                                               \
+        ((sizeof(t) > sizeof(__int64) || (sizeof(t) & (sizeof(t) - 1)) != 0) \
+            ? **(t**)((ap += sizeof(__int64)) - sizeof(__int64))             \
+            :  *(t* )((ap += sizeof(__int64)) - sizeof(__int64)))
+    #define __crt_va_end(ap)        ((void)(ap = (va_list)0))
+
+#endif
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#if defined __cplusplus && !defined _CRT_NO_VA_START_VALIDATION
+    extern "C++"
+    {
+        template <typename _Ty>
+        struct __vcrt_va_list_is_reference
+        {
+            enum : bool { __the_value = false };
+        };
+
+        template <typename _Ty>
+        struct __vcrt_va_list_is_reference<_Ty&>
+        {
+            enum : bool { __the_value = true };
+        };
+
+        template <typename _Ty>
+        struct __vcrt_va_list_is_reference<_Ty&&>
+        {
+            enum : bool { __the_value = true };
+        };
+
+        template <typename _Ty>
+        struct __vcrt_assert_va_start_is_not_reference
+        {
+            static_assert(!__vcrt_va_list_is_reference<_Ty>::__the_value,
+                "va_start argument must not have reference type and must not be parenthesized");
+        };
+    } // extern "C++"
+
+    #define __crt_va_start(ap, x) ((void)(__vcrt_assert_va_start_is_not_reference<decltype(x)>(), __crt_va_start_a(ap, x)))
+
+#else // ^^^ __cplusplus ^^^ // vvv !__cplusplus vvv //
+
+    #define __crt_va_start(ap, x) __crt_va_start_a(ap, x)
+
+#endif
+
+#pragma warning(pop) // _VCRUNTIME_DISABLED_WARNINGS
+#pragma pack(pop)

miniMSVC/VC/Tools/MSVC/14.42.34433/include/valarray

@@ -0,0 +1,2120 @@
+// valarray standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _VALARRAY_
+#define _VALARRAY_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <cmath>
+#include <xmemory>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD class gslice;
+_EXPORT_STD class slice;
+
+_EXPORT_STD template <class _Ty>
+class gslice_array;
+_EXPORT_STD template <class _Ty>
+class indirect_array;
+_EXPORT_STD template <class _Ty>
+class mask_array;
+_EXPORT_STD template <class _Ty>
+class slice_array;
+_EXPORT_STD template <class _Ty>
+class valarray;
+
+template <class _Ty>
+_Ty* _Allocate_for_op_delete(size_t _Count) {
+    // allocates space for _Count objects of type _Ty
+    if (_Count == 0) {
+        return nullptr;
+    }
+
+    const size_t _Bytes = _Get_size_of_n<sizeof(_Ty)>(_Count);
+#ifdef __cpp_aligned_new
+    constexpr bool _Extended_alignment = alignof(_Ty) > __STDCPP_DEFAULT_NEW_ALIGNMENT__;
+    if constexpr (_Extended_alignment) {
+        return static_cast<_Ty*>(::operator new(_Bytes, align_val_t{alignof(_Ty)}));
+    } else
+#endif // defined(__cpp_aligned_new)
+    {
+        return static_cast<_Ty*>(::operator new(_Bytes));
+    }
+}
+
+using _Boolarray = valarray<bool>;
+using _Sizarray  = valarray<size_t>;
+
+_EXPORT_STD template <class _Ty>
+class valarray { // store array with various indexing options
+public:
+    friend _Tidy_deallocate_guard<valarray>;
+
+    template <class _Ty2>
+    friend _Ty2* begin(valarray<_Ty2>& _Array) noexcept /* strengthened */;
+
+    template <class _Ty2>
+    friend const _Ty2* begin(const valarray<_Ty2>& _Array) noexcept /* strengthened */;
+
+    template <class _Ty2>
+    friend _Ty2* end(valarray<_Ty2>& _Array) noexcept /* strengthened */;
+
+    template <class _Ty2>
+    friend const _Ty2* end(const valarray<_Ty2>& _Array) noexcept /* strengthened */;
+
+    using value_type = _Ty;
+
+    valarray() = default; // construct empty valarray
+
+    explicit valarray(size_t _Count) { // construct with _Count * _Ty()
+        _Grow(_Count);
+    }
+
+    valarray(const _Ty& _Val, size_t _Count) { // construct with _Count * _Val
+        _Grow(_Count, &_Val);
+    }
+
+    valarray(const _Ty* _Ptr, size_t _Count) { // construct with [_Ptr, _Ptr + _Count)
+        _Grow(_Count, _Ptr, 1);
+    }
+
+    valarray(const valarray& _Right) {
+        _Grow(_Right.size(), _Right._Myptr, 1);
+    }
+
+    valarray(const slice_array<_Ty>& _Slicearr) {
+        *this = _Slicearr;
+    }
+
+    valarray(const gslice_array<_Ty>& _Gslicearr) {
+        *this = _Gslicearr;
+    }
+
+    valarray(const mask_array<_Ty>& _Maskarr) {
+        *this = _Maskarr;
+    }
+
+    valarray(const indirect_array<_Ty>& _Indarr) {
+        *this = _Indarr;
+    }
+
+    valarray(valarray&& _Right) noexcept
+        : _Myptr(_STD exchange(_Right._Myptr, nullptr)), _Mysize(_STD exchange(_Right._Mysize, size_t{})) {}
+
+    valarray& operator=(valarray&& _Right) noexcept {
+        if (this != _STD addressof(_Right)) { // clear this and steal from _Right
+            _Tidy_deallocate();
+            _Myptr  = _STD exchange(_Right._Myptr, nullptr);
+            _Mysize = _STD exchange(_Right._Mysize, size_t{});
+        }
+        return *this;
+    }
+
+    valarray(initializer_list<_Ty> _Ilist) {
+        _Grow(_Ilist.size(), _Ilist.begin(), 1);
+    }
+
+    valarray& operator=(initializer_list<_Ty> _Ilist) {
+        _Assign(_Ilist.size(), _Ilist.begin());
+        return *this;
+    }
+
+    void swap(valarray& _Right) noexcept {
+        if (this != _STD addressof(_Right)) {
+            _STD swap(_Myptr, _Right._Myptr);
+            _STD swap(_Mysize, _Right._Mysize);
+        }
+    }
+
+    ~valarray() noexcept {
+        _Tidy_deallocate();
+    }
+
+    valarray& operator=(const valarray& _Right) {
+        if (this != _STD addressof(_Right)) {
+            _Assign(_Right.size(), _Right._Myptr);
+        }
+
+        return *this;
+    }
+
+    valarray& operator=(const _Ty& _Val) {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] = _Val;
+        }
+        return *this;
+    }
+
+    void resize(size_t _Newsize) { // determine new length, filling with _Ty() elements
+        _Tidy_deallocate();
+        _Grow(_Newsize);
+    }
+
+    void resize(size_t _Newsize, _Ty _Val) { // determine new length, filling with _Val elements
+        _Tidy_deallocate();
+        _Grow(_Newsize, &_Val, 0);
+    }
+
+    valarray& operator=(const slice_array<_Ty>& _Slicearr); // defined below
+
+    valarray& operator=(const gslice_array<_Ty>& _Gslicearr); // defined below
+
+    valarray& operator=(const mask_array<_Ty>& _Maskarr); // defined below
+
+    valarray& operator=(const indirect_array<_Ty>& _Indarr); // defined below
+
+    _NODISCARD valarray operator+() const {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        valarray<_Ty> _Ans(_Size);
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Ans[_Idx] = +_Myptr[_Idx];
+        }
+        return _Ans;
+    }
+
+    _NODISCARD valarray operator-() const {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        valarray<_Ty> _Ans(_Size);
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Ans[_Idx] = -_Myptr[_Idx];
+        }
+        return _Ans;
+    }
+
+    _NODISCARD valarray operator~() const {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        valarray<_Ty> _Ans(_Size);
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Ans[_Idx] = ~_Myptr[_Idx];
+        }
+        return _Ans;
+    }
+
+    _NODISCARD _Boolarray operator!() const {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        valarray<bool> _Ans(_Size);
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Ans[_Idx] = !_Myptr[_Idx];
+        }
+        return _Ans;
+    }
+
+    valarray& operator*=(const _Ty& _Right) {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] *= _Right;
+        }
+        return *this;
+    }
+
+    valarray& operator/=(const _Ty& _Right) {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] /= _Right;
+        }
+        return *this;
+    }
+
+    valarray& operator%=(const _Ty& _Right) {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] %= _Right;
+        }
+        return *this;
+    }
+
+    valarray& operator+=(const _Ty& _Right) {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] += _Right;
+        }
+        return *this;
+    }
+
+    valarray& operator-=(const _Ty& _Right) {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] -= _Right;
+        }
+        return *this;
+    }
+
+    valarray& operator^=(const _Ty& _Right) {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] ^= _Right;
+        }
+        return *this;
+    }
+
+    valarray& operator&=(const _Ty& _Right) {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] &= _Right;
+        }
+        return *this;
+    }
+
+    valarray& operator|=(const _Ty& _Right) {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] |= _Right;
+        }
+        return *this;
+    }
+
+    valarray& operator<<=(const _Ty& _Right) {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] <<= _Right;
+        }
+        return *this;
+    }
+
+    valarray& operator>>=(const _Ty& _Right) {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] >>= _Right;
+        }
+        return *this;
+    }
+
+    valarray& operator*=(const valarray& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_Mysize == _Right._Mysize, "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] *= _Right[_Idx];
+        }
+        return *this;
+    }
+
+    valarray& operator/=(const valarray& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_Mysize == _Right._Mysize, "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] /= _Right[_Idx];
+        }
+        return *this;
+    }
+
+    valarray& operator%=(const valarray& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_Mysize == _Right._Mysize, "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] %= _Right[_Idx];
+        }
+        return *this;
+    }
+
+    valarray& operator+=(const valarray& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_Mysize == _Right._Mysize, "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] += _Right[_Idx];
+        }
+        return *this;
+    }
+
+    valarray& operator-=(const valarray& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_Mysize == _Right._Mysize, "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] -= _Right[_Idx];
+        }
+        return *this;
+    }
+
+    valarray& operator^=(const valarray& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_Mysize == _Right._Mysize, "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] ^= _Right[_Idx];
+        }
+        return *this;
+    }
+
+    valarray& operator|=(const valarray& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_Mysize == _Right._Mysize, "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] |= _Right[_Idx];
+        }
+        return *this;
+    }
+
+    valarray& operator&=(const valarray& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_Mysize == _Right._Mysize, "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] &= _Right[_Idx];
+        }
+        return *this;
+    }
+
+    valarray& operator<<=(const valarray& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_Mysize == _Right._Mysize, "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] <<= _Right[_Idx];
+        }
+        return *this;
+    }
+
+    valarray& operator>>=(const valarray& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_Mysize == _Right._Mysize, "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] >>= _Right[_Idx];
+        }
+        return *this;
+    }
+
+    _NODISCARD size_t size() const noexcept /* strengthened */ {
+        return _Mysize;
+    }
+
+    _NODISCARD const _Ty& operator[](size_t _Off) const noexcept /* strengthened */ {
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_Off < _Mysize, "valarray subscript out of range");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+
+        return _Myptr[_Off];
+    }
+
+    _NODISCARD _Ty& operator[](size_t _Off) noexcept /* strengthened */ {
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_Off < _Mysize, "valarray subscript out of range");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+
+        return _Myptr[_Off];
+    }
+
+    _NODISCARD valarray operator[](slice _Slicearr) const; // defined below
+
+    _NODISCARD slice_array<_Ty> operator[](slice _Slicearr) noexcept /* strengthened */; // defined below
+
+    _NODISCARD valarray operator[](const gslice& _Gslicearr) const; // defined below
+
+    _NODISCARD gslice_array<_Ty> operator[](const gslice& _Gslicearr); // defined below
+
+    _NODISCARD valarray operator[](const _Boolarray& _Boolarr) const; // defined below
+
+    _NODISCARD mask_array<_Ty> operator[](const _Boolarray& _Boolarr); // defined below
+
+    _NODISCARD valarray operator[](const _Sizarray& _Indarr) const; // defined below
+
+    _NODISCARD indirect_array<_Ty> operator[](const _Sizarray& _Indarr); // defined below
+
+    _NODISCARD _Ty sum() const {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        _Ty _Sum           = _Myptr[0];
+        for (size_t _Idx = 1; _Idx < _Size; ++_Idx) {
+            _Sum += _Myptr[_Idx];
+        }
+
+        return _Sum;
+    }
+
+    _NODISCARD _Ty(min)() const {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        _Ty _Min           = _Myptr[0];
+        for (size_t _Idx = 1; _Idx < _Size; ++_Idx) {
+            if (_Myptr[_Idx] < _Min) {
+                _Min = _Myptr[_Idx];
+            }
+        }
+
+        return _Min;
+    }
+
+    _NODISCARD _Ty(max)() const {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        _Ty _Max           = _Myptr[0];
+        for (size_t _Idx = 1; _Idx < _Size; ++_Idx) {
+            if (_Max < _Myptr[_Idx]) {
+                _Max = _Myptr[_Idx];
+            }
+        }
+
+        return _Max;
+    }
+
+    _NODISCARD valarray shift(int _Count) const {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        valarray<_Ty> _Ans(_Size);
+        size_t _Min = 0;
+        size_t _Max = _Size;
+        if (_Count < 0) {
+            const size_t _Skip = static_cast<size_t>(-_Count);
+            _Min += _Skip;
+        } else {
+            const size_t _Skip = static_cast<size_t>(_Count);
+            if (_Skip < _Size) {
+                _Max -= _Skip;
+            } else {
+                _Max = 0;
+            }
+        }
+        for (size_t _Idx = _Min; _Idx < _Max; ++_Idx) {
+            _Ans[_Idx] = _Myptr[_Idx + _Count];
+        }
+        return _Ans;
+    }
+
+    _NODISCARD valarray cshift(int _Count) const {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        if (_Size != 0) {
+            if (_Count < 0) { // right shift
+                if (_Size < size_t{0} - _Count) {
+                    _Count = static_cast<int>(_Size - (size_t{0} - _Count - _Size) % _Size);
+                } else {
+                    _Count = static_cast<int>(_Size + _Count);
+                }
+            } else if (_Size <= static_cast<size_t>(_Count)) {
+                _Count %= _Size;
+            }
+        }
+
+        valarray<_Ty> _Ans(_Size);
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Ans[_Idx] =
+                _Size - _Idx <= static_cast<size_t>(_Count) ? _Myptr[_Idx - _Size + _Count] : _Myptr[_Idx + _Count];
+        }
+        return _Ans;
+    }
+
+    _NODISCARD valarray apply(_Ty _Func(_Ty)) const {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        valarray<_Ty> _Ans(_Size);
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Ans[_Idx] = _Func(_Myptr[_Idx]);
+        }
+        return _Ans;
+    }
+
+    _NODISCARD valarray apply(_Ty _Func(const _Ty&)) const {
+        // return valarray transformed by _Func, nonmutable argument
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        valarray<_Ty> _Ans(_Size);
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Ans[_Idx] = _Func(_Myptr[_Idx]);
+        }
+        return _Ans;
+    }
+
+private:
+    void _Grow(size_t _Newsize) { // allocate space for _Count elements and fill with default values
+        if (0 < _Newsize) { // worth doing, allocate
+            _Myptr = _Allocate_for_op_delete<_Ty>(_Newsize);
+            _Tidy_deallocate_guard<valarray> _Guard{this};
+            for (size_t _Idx = 0; _Idx < _Newsize; ++_Idx) {
+                _Construct_in_place(_Myptr[_Idx]);
+            }
+
+            _Guard._Target = nullptr;
+            _Mysize        = _Newsize;
+        }
+    }
+
+    void _Grow(size_t _Newsize, const _Ty* _Ptr, size_t _Inc = 0) {
+        // allocate space for _Count elements and fill with *_Ptr
+        if (0 < _Newsize) { // worth doing, allocate
+            _Myptr = _Allocate_for_op_delete<_Ty>(_Newsize);
+            _Tidy_deallocate_guard<valarray> _Guard{this};
+            for (size_t _Idx = 0; _Idx < _Newsize; ++_Idx, _Ptr += _Inc) {
+                _Construct_in_place(_Myptr[_Idx], *_Ptr);
+            }
+
+            _Guard._Target = nullptr;
+            _Mysize        = _Newsize;
+        }
+    }
+
+    void _Tidy_deallocate() noexcept {
+        if (_Myptr) { // destroy elements
+            _Destroy_range(_Myptr, _Myptr + _Mysize);
+#ifdef __cpp_aligned_new
+            constexpr bool _Extended_alignment = alignof(_Ty) > __STDCPP_DEFAULT_NEW_ALIGNMENT__;
+            if constexpr (_Extended_alignment) {
+                ::operator delete(static_cast<void*>(_Myptr), align_val_t{alignof(_Ty)});
+            } else
+#endif // defined(__cpp_aligned_new)
+            {
+                ::operator delete(static_cast<void*>(_Myptr));
+            }
+        }
+
+        _Mysize = 0;
+        _Myptr  = nullptr;
+    }
+
+    void _Assign(size_t _Newsize, const _Ty* _Ptr) {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        if (_Size == _Newsize) {
+            for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+                _Myptr[_Idx] = _Ptr[_Idx];
+            }
+        } else { // resize and copy
+            _Tidy_deallocate();
+            _Grow(_Newsize, _Ptr, 1);
+        }
+    }
+
+    _Ty* _Myptr    = nullptr; // current storage reserved for array
+    size_t _Mysize = 0; // current length of sequence
+};
+
+#if _HAS_CXX17
+template <class _Ty, size_t _Nx>
+valarray(const _Ty (&)[_Nx], size_t) -> valarray<_Ty>;
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Ty>
+void swap(valarray<_Ty>& _Left, valarray<_Ty>& _Right) noexcept {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Ty* begin(valarray<_Ty>& _Array) noexcept /* strengthened */ {
+    return _Array._Myptr;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD const _Ty* begin(const valarray<_Ty>& _Array) noexcept /* strengthened */ {
+    return _Array._Myptr;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Ty* end(valarray<_Ty>& _Array) noexcept /* strengthened */ {
+    return _Array._Myptr + _Array.size();
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD const _Ty* end(const valarray<_Ty>& _Array) noexcept /* strengthened */ {
+    return _Array._Myptr + _Array.size();
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator*(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] * _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator*(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left * _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator/(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] / _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator/(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left / _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator%(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] % _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator%(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left % _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator+(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] + _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator+(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left + _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator-(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] - _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator-(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left - _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator^(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] ^ _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator^(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left ^ _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator&(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] & _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator&(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left & _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator|(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] | _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator|(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left | _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator<<(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] << _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator<<(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left << _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator>>(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] >> _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator>>(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left >> _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator&&(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] && _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator&&(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left && _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator||(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] || _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator||(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left || _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator*(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] * _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator/(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] / _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator%(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] % _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator+(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] + _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator-(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] - _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator^(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] ^ _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator&(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] & _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator|(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] | _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator<<(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] << _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator>>(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] >> _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator&&(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] && _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator||(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] || _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator==(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] == _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator==(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left == _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator==(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] == _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator!=(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] != _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator!=(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left != _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator!=(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] != _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator<(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] < _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator<(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left < _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator<(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] < _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator>(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] > _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator>(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left > _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator>(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] > _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator<=(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] <= _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator<=(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left <= _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator<=(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] <= _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator>=(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] >= _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator>=(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left >= _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator>=(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _CONTAINER_DEBUG_LEVEL > 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] >= _Right[_Idx];
+    }
+    return _Ans;
+}
+
+// [valarray.transcend] Transcendentals
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> abs(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = abs(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> acos(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = acos(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> asin(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = asin(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> atan(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = atan(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> atan2(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = atan2(_Left[_Idx], _Right[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> atan2(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = atan2(_Left[_Idx], _Right); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> atan2(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = atan2(_Left, _Right[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> cos(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = cos(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> cosh(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = cosh(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> exp(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = exp(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> log(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = log(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> log10(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = log10(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> pow(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = pow(_Left[_Idx], _Right[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> pow(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = pow(_Left[_Idx], _Right); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> pow(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = pow(_Left, _Right[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> sin(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = sin(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> sinh(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = sinh(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> sqrt(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = sqrt(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> tan(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = tan(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> tanh(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = tanh(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD class slice { // define a slice of a valarray
+public:
+    slice() = default;
+
+    slice(size_t _Off, size_t _Count, size_t _Inc) noexcept // strengthened
+        : _Start(_Off), _Len(_Count), _Stride(_Inc) {}
+
+    _NODISCARD size_t start() const noexcept /* strengthened */ {
+        return _Start;
+    }
+
+    _NODISCARD size_t size() const noexcept /* strengthened */ {
+        return _Len;
+    }
+
+    _NODISCARD size_t stride() const noexcept /* strengthened */ {
+        return _Stride;
+    }
+
+#if _HAS_CXX20
+    _NODISCARD friend bool operator==(const slice& _Left, const slice& _Right) noexcept /* strengthened */ {
+        return _Left.start() == _Right.start() && _Left.size() == _Right.size() && _Left.stride() == _Right.stride();
+    }
+#endif // _HAS_CXX20
+
+protected:
+    size_t _Start  = 0; // the starting offset
+    size_t _Len    = 0; // the number of elements
+    size_t _Stride = 0; // the distance between elements
+};
+
+_EXPORT_STD template <class _Ty>
+class slice_array : public slice { // define a slice of a valarray
+public:
+    using value_type = _Ty;
+
+    void operator=(const valarray<_Ty>& _Right) const {
+        size_t _Off = _Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
+            _Myptr[_Off] = _Right[_Idx];
+        }
+    }
+
+    void operator=(const _Ty& _Right) const {
+        size_t _Off = _Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
+            _Myptr[_Off] = _Right;
+        }
+    }
+
+    void operator*=(const valarray<_Ty>& _Right) const {
+        size_t _Off = _Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
+            _Myptr[_Off] *= _Right[_Idx];
+        }
+    }
+
+    void operator/=(const valarray<_Ty>& _Right) const {
+        size_t _Off = _Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
+            _Myptr[_Off] /= _Right[_Idx];
+        }
+    }
+
+    void operator%=(const valarray<_Ty>& _Right) const {
+        size_t _Off = _Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
+            _Myptr[_Off] %= _Right[_Idx];
+        }
+    }
+
+    void operator+=(const valarray<_Ty>& _Right) const {
+        size_t _Off = _Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
+            _Myptr[_Off] += _Right[_Idx];
+        }
+    }
+
+    void operator-=(const valarray<_Ty>& _Right) const {
+        size_t _Off = _Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
+            _Myptr[_Off] -= _Right[_Idx];
+        }
+    }
+
+    void operator^=(const valarray<_Ty>& _Right) const {
+        size_t _Off = _Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
+            _Myptr[_Off] ^= _Right[_Idx];
+        }
+    }
+
+    void operator&=(const valarray<_Ty>& _Right) const {
+        size_t _Off = _Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
+            _Myptr[_Off] &= _Right[_Idx];
+        }
+    }
+
+    void operator|=(const valarray<_Ty>& _Right) const {
+        size_t _Off = _Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
+            _Myptr[_Off] |= _Right[_Idx];
+        }
+    }
+
+    void operator<<=(const valarray<_Ty>& _Right) const {
+        size_t _Off = _Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
+            _Myptr[_Off] <<= _Right[_Idx];
+        }
+    }
+
+    void operator>>=(const valarray<_Ty>& _Right) const {
+        size_t _Off = _Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
+            _Myptr[_Off] >>= _Right[_Idx];
+        }
+    }
+
+    _Ty& _Data(size_t _Idx) const noexcept {
+        return _Myptr[_Idx];
+    }
+
+    slice_array() = delete;
+
+    slice_array(const slice_array&) = default;
+
+    const slice_array& operator=(const slice_array& _Right) const noexcept /* strengthened */ {
+        size_t _Dst_off = _Start;
+        size_t _Src_off = _Right._Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Dst_off += _Stride, _Src_off += _Right._Stride) {
+            _Myptr[_Dst_off] = _Right._Myptr[_Src_off];
+        }
+        return *this;
+    }
+
+private:
+    friend valarray<_Ty>;
+
+    slice_array(const slice& _Slice, _Ty* _Pdata) noexcept : slice(_Slice), _Myptr(_Pdata) {}
+
+    _Ty* _Myptr; // pointer to valarray contents
+};
+
+_EXPORT_STD class gslice { // define a generalized (multidimensional) slice of a valarray
+public:
+    gslice() = default; // construct with all zeros
+
+    gslice(size_t _Off, const _Sizarray& _Lenarr, const _Sizarray& _Incarr)
+        : _Start(_Off), _Len(_Lenarr), _Stride(_Incarr) {}
+
+    _NODISCARD size_t start() const noexcept /* strengthened */ {
+        return _Start;
+    }
+
+    _NODISCARD _Sizarray size() const {
+        return _Len;
+    }
+
+    _NODISCARD _Sizarray stride() const {
+        return _Stride;
+    }
+
+    size_t _Nslice() const noexcept {
+        return _Len.size();
+    }
+
+    size_t _Off(_Sizarray& _Indexarr) const noexcept {
+        size_t _Idx;
+        size_t _Ans        = _Start;
+        const size_t _Size = _Indexarr.size();
+        for (_Idx = 0; _Idx < _Size; ++_Idx) {
+            _Ans += _Indexarr[_Idx] * _Stride[_Idx]; // compute offset
+        }
+
+        while (0 < _Idx) {
+            --_Idx;
+            if (++_Indexarr[_Idx] < _Len[_Idx]) {
+                break; // increment done, quit
+            } else {
+                _Indexarr[_Idx] = 0; // carry to more-significant index
+            }
+        }
+
+        return _Ans;
+    }
+
+    _NODISCARD size_t _Totlen() const noexcept {
+        const size_t _Size = _Len.size();
+        if (_Size == 0) {
+            return 0;
+        }
+
+        size_t _Count = _Len[0];
+        for (size_t _Idx = 1; _Idx < _Size; ++_Idx) {
+            _Count *= _Len[_Idx];
+        }
+
+        return _Count;
+    }
+
+private:
+    size_t _Start = 0; // the starting offset
+    _Sizarray _Len; // array of numbers of elements
+    _Sizarray _Stride; // array of distances between elements
+};
+
+_EXPORT_STD template <class _Ty>
+class gslice_array : public gslice { // define a generalized slice of a valarray
+public:
+    using value_type = _Ty;
+
+    void operator=(const valarray<_Ty>& _Right) const {
+        _Sizarray _Indexarray(size_t{0}, _Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Indexarray)] = _Right[_Idx];
+        }
+    }
+
+    void operator=(const _Ty& _Right) const {
+        _Sizarray _Indexarray(size_t{0}, _Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Indexarray)] = _Right;
+        }
+    }
+
+    void operator*=(const valarray<_Ty>& _Right) const { // multiply generalized slice by valarray
+        _Sizarray _Indexarray(size_t{0}, _Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Indexarray)] *= _Right[_Idx];
+        }
+    }
+
+    void operator/=(const valarray<_Ty>& _Right) const { // divide generalized slice by valarray
+        _Sizarray _Indexarray(size_t{0}, _Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Indexarray)] /= _Right[_Idx];
+        }
+    }
+
+    void operator%=(const valarray<_Ty>& _Right) const { // remainder generalized slice by valarray
+        _Sizarray _Indexarray(size_t{0}, _Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Indexarray)] %= _Right[_Idx];
+        }
+    }
+
+    void operator+=(const valarray<_Ty>& _Right) const { // add valarray to generalized slice
+        _Sizarray _Indexarray(size_t{0}, _Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Indexarray)] += _Right[_Idx];
+        }
+    }
+
+    void operator-=(const valarray<_Ty>& _Right) const { // subtract valarray from generalized slice
+        _Sizarray _Indexarray(size_t{0}, _Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Indexarray)] -= _Right[_Idx];
+        }
+    }
+
+    void operator^=(const valarray<_Ty>& _Right) const { // XOR valarray into generalized slice
+        _Sizarray _Indexarray(size_t{0}, _Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Indexarray)] ^= _Right[_Idx];
+        }
+    }
+
+    void operator&=(const valarray<_Ty>& _Right) const { // AND valarray into generalized slice
+        _Sizarray _Indexarray(size_t{0}, _Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Indexarray)] &= _Right[_Idx];
+        }
+    }
+
+    void operator|=(const valarray<_Ty>& _Right) const { // OR valarray into generalized slice
+        _Sizarray _Indexarray(size_t{0}, _Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Indexarray)] |= _Right[_Idx];
+        }
+    }
+
+    void operator<<=(const valarray<_Ty>& _Right) const { // left shift generalized slice by valarray
+        _Sizarray _Indexarray(size_t{0}, _Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Indexarray)] <<= _Right[_Idx];
+        }
+    }
+
+    void operator>>=(const valarray<_Ty>& _Right) const { // right shift generalized slice by valarray
+        _Sizarray _Indexarray(size_t{0}, _Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Indexarray)] >>= _Right[_Idx];
+        }
+    }
+
+    _NODISCARD _Ty& _Data(size_t _Idx) const noexcept {
+        return _Myptr[_Idx];
+    }
+
+    gslice_array() = delete;
+
+    gslice_array(const gslice_array&) = default;
+
+    const gslice_array& operator=(const gslice_array& _Right) const {
+        _Sizarray _Dst_indexarray(size_t{0}, _Nslice());
+        _Sizarray _Src_indexarray(size_t{0}, _Right._Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Dst_indexarray)] = _Right._Myptr[_Right._Off(_Src_indexarray)];
+        }
+        return *this;
+    }
+
+private:
+    friend valarray<_Ty>;
+
+    gslice_array(const gslice& _Gslice, _Ty* _Ptr) : gslice(_Gslice), _Myptr(_Ptr) {}
+
+    _Ty* _Myptr; // pointer to valarray contents
+};
+
+_EXPORT_STD template <class _Ty>
+class mask_array { // define a subset of a valarray with an array of mask bits
+public:
+    using value_type = _Ty;
+
+    void operator=(const valarray<_Ty>& _Right) const {
+        const size_t _Size = _Mybool.size();
+        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
+            _Myptr[_Off] = _Right[_Idx];
+        }
+    }
+
+    void operator=(const _Ty& _Right) const {
+        const size_t _Size = _Mybool.size();
+        for (size_t _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off)) {
+            _Myptr[_Off] = _Right;
+        }
+    }
+
+    void operator*=(const valarray<_Ty>& _Right) const { // multiply masked array by valarray
+        const size_t _Size = _Mybool.size();
+        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
+            _Myptr[_Off] *= _Right[_Idx];
+        }
+    }
+
+    void operator/=(const valarray<_Ty>& _Right) const { // divide masked array by valarray
+        const size_t _Size = _Mybool.size();
+        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
+            _Myptr[_Off] /= _Right[_Idx];
+        }
+    }
+
+    void operator%=(const valarray<_Ty>& _Right) const { // remainder masked array by valarray
+        const size_t _Size = _Mybool.size();
+        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
+            _Myptr[_Off] %= _Right[_Idx];
+        }
+    }
+
+    void operator+=(const valarray<_Ty>& _Right) const { // add valarray to masked array
+        const size_t _Size = _Mybool.size();
+        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
+            _Myptr[_Off] += _Right[_Idx];
+        }
+    }
+
+    void operator-=(const valarray<_Ty>& _Right) const { // subtract valarray from masked array
+        const size_t _Size = _Mybool.size();
+        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
+            _Myptr[_Off] -= _Right[_Idx];
+        }
+    }
+
+    void operator^=(const valarray<_Ty>& _Right) const { // XOR valarray into masked array
+        const size_t _Size = _Mybool.size();
+        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
+            _Myptr[_Off] ^= _Right[_Idx];
+        }
+    }
+
+    void operator&=(const valarray<_Ty>& _Right) const { // OR valarray into masked array
+        const size_t _Size = _Mybool.size();
+        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
+            _Myptr[_Off] &= _Right[_Idx];
+        }
+    }
+
+    void operator|=(const valarray<_Ty>& _Right) const { // OR valarray into masked array
+        const size_t _Size = _Mybool.size();
+        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
+            _Myptr[_Off] |= _Right[_Idx];
+        }
+    }
+
+    void operator<<=(const valarray<_Ty>& _Right) const { // left shift masked array by valarray
+        const size_t _Size = _Mybool.size();
+        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
+            _Myptr[_Off] <<= _Right[_Idx];
+        }
+    }
+
+    void operator>>=(const valarray<_Ty>& _Right) const { // right shift masked array by valarray
+        const size_t _Size = _Mybool.size();
+        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
+            _Myptr[_Off] >>= _Right[_Idx];
+        }
+    }
+
+    _NODISCARD _Ty& _Data(size_t _Idx) const noexcept {
+        return _Myptr[_Idx];
+    }
+
+    _NODISCARD bool _Mask(size_t _Idx) const noexcept {
+        return _Mybool[_Idx];
+    }
+
+    _NODISCARD size_t _Start_off() const noexcept {
+        size_t _Off        = 0;
+        const size_t _Size = _Mybool.size();
+        while (_Off < _Size && !_Mybool[_Off]) {
+            ++_Off;
+        }
+        return _Off;
+    }
+
+    _NODISCARD size_t _Next_off(size_t _Off) const noexcept {
+        const size_t _Size = _Mybool.size();
+        do {
+            ++_Off;
+        } while (_Off < _Size && !_Mybool[_Off]);
+        return _Off;
+    }
+
+    _NODISCARD size_t _Totlen() const noexcept {
+        size_t _Count      = 0;
+        const size_t _Size = _Mybool.size();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            if (_Mybool[_Idx]) {
+                ++_Count;
+            }
+        }
+
+        return _Count;
+    }
+
+    mask_array() = delete;
+
+    mask_array(const mask_array&) = default;
+
+    const mask_array& operator=(const mask_array& _Right) const noexcept /* strengthened */ {
+        const size_t _Size = _Mybool.size();
+        size_t _Dst_off    = _Start_off();
+        size_t _Src_off    = _Right._Start_off();
+        for (; _Dst_off < _Size; _Src_off = _Right._Next_off(_Src_off), _Dst_off = _Next_off(_Dst_off)) {
+            _Myptr[_Dst_off] = _Right._Myptr[_Src_off];
+        }
+        return *this;
+    }
+
+private:
+    friend valarray<_Ty>;
+
+    mask_array(const _Boolarray& _Maskarr, _Ty* _Pdata) : _Mybool(_Maskarr), _Myptr(_Pdata) {}
+
+    _Boolarray _Mybool; // array of mask bits
+    _Ty* _Myptr; // pointer to valarray contents
+};
+
+_EXPORT_STD template <class _Ty>
+class indirect_array { // define a subset of a valarray with an array of indexes
+public:
+    using value_type = _Ty;
+
+    void operator=(const valarray<_Ty>& _Right) const {
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] = _Right[_Idx];
+        }
+    }
+
+    void operator=(const _Ty& _Right) const {
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] = _Right;
+        }
+    }
+
+    void operator*=(const valarray<_Ty>& _Right) const { // multiply indirect array by valarray
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] *= _Right[_Idx];
+        }
+    }
+
+    void operator/=(const valarray<_Ty>& _Right) const { // divide indirect array by valarray
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] /= _Right[_Idx];
+        }
+    }
+
+    void operator%=(const valarray<_Ty>& _Right) const { // remainder indirect array by valarray
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] %= _Right[_Idx];
+        }
+    }
+
+    void operator+=(const valarray<_Ty>& _Right) const { // add valarray to indirect array
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] += _Right[_Idx];
+        }
+    }
+
+    void operator-=(const valarray<_Ty>& _Right) const { // subtract valarray from indirect array
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] -= _Right[_Idx];
+        }
+    }
+
+    void operator^=(const valarray<_Ty>& _Right) const { // XOR valarray into indirect array
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] ^= _Right[_Idx];
+        }
+    }
+
+    void operator&=(const valarray<_Ty>& _Right) const { // AND valarray into indirect array
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] &= _Right[_Idx];
+        }
+    }
+
+    void operator|=(const valarray<_Ty>& _Right) const { // OR valarray into indirect array
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] |= _Right[_Idx];
+        }
+    }
+
+    void operator<<=(const valarray<_Ty>& _Right) const { // left shift indirect array by valarray
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] <<= _Right[_Idx];
+        }
+    }
+
+    void operator>>=(const valarray<_Ty>& _Right) const { // right shift indirect array by valarray
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] >>= _Right[_Idx];
+        }
+    }
+
+    _NODISCARD _Ty& _Data(size_t _Idx) const noexcept {
+        return _Myptr[_Idx];
+    }
+
+    _NODISCARD size_t _Indir(size_t _Idx) const noexcept {
+        return _Myindarr[_Idx];
+    }
+
+    _NODISCARD size_t _Totlen() const noexcept {
+        return _Myindarr.size();
+    }
+
+    indirect_array() = delete;
+
+    indirect_array(const indirect_array&) = default;
+
+    const indirect_array& operator=(const indirect_array& _Right) const noexcept /* strengthened */ {
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] = _Right._Myptr[_Right._Indir(_Idx)];
+        }
+        return *this;
+    }
+
+private:
+    friend valarray<_Ty>;
+
+    indirect_array(const _Sizarray& _Indarr, _Ty* _Ptr) : _Myindarr(_Indarr), _Myptr(_Ptr) {}
+
+    _Sizarray _Myindarr; // array of indirect indexes
+    _Ty* _Myptr; // pointer to valarray contents
+};
+
+template <class _Ty>
+valarray<_Ty>& valarray<_Ty>::operator=(const slice_array<_Ty>& _Slicearr) {
+    _Tidy_deallocate();
+    _Grow(_Slicearr.size(), &_Slicearr._Data(_Slicearr.start()), _Slicearr.stride());
+    return *this;
+}
+
+template <class _Ty>
+_NODISCARD valarray<_Ty> valarray<_Ty>::operator[](slice _Slice) const {
+    return valarray<_Ty>(slice_array<_Ty>(_Slice, _Myptr));
+}
+
+template <class _Ty>
+_NODISCARD slice_array<_Ty> valarray<_Ty>::operator[](slice _Slice) noexcept /* strengthened */ {
+    return slice_array<_Ty>(_Slice, _Myptr);
+}
+
+template <class _Ty>
+valarray<_Ty>& valarray<_Ty>::operator=(const gslice_array<_Ty>& _Gslicearr) {
+    _Tidy_deallocate();
+    _Grow(_Gslicearr._Totlen());
+    _Sizarray _Indexarray(size_t{0}, _Gslicearr._Nslice());
+    const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Myptr[_Idx] = _Gslicearr._Data(_Gslicearr._Off(_Indexarray));
+    }
+    return *this;
+}
+
+template <class _Ty>
+_NODISCARD valarray<_Ty> valarray<_Ty>::operator[](const gslice& _Gslice) const {
+    return valarray<_Ty>(gslice_array<_Ty>(_Gslice, _Myptr));
+}
+
+template <class _Ty>
+_NODISCARD gslice_array<_Ty> valarray<_Ty>::operator[](const gslice& _Gslicearr) {
+    return gslice_array<_Ty>(_Gslicearr, _Myptr);
+}
+
+template <class _Ty>
+valarray<_Ty>& valarray<_Ty>::operator=(const mask_array<_Ty>& _Maskarr) {
+    _Tidy_deallocate();
+    _Grow(_Maskarr._Totlen());
+    size_t _Count = 0;
+
+    const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+    for (size_t _Idx = 0; _Idx < _Size; ++_Count) {
+        if (_Maskarr._Mask(_Count)) {
+            _Myptr[_Idx++] = _Maskarr._Data(_Count);
+        }
+    }
+
+    return *this;
+}
+
+template <class _Ty>
+_NODISCARD valarray<_Ty> valarray<_Ty>::operator[](const _Boolarray& _Boolarr) const {
+    return valarray<_Ty>(mask_array<_Ty>(_Boolarr, _Myptr));
+}
+
+template <class _Ty>
+_NODISCARD mask_array<_Ty> valarray<_Ty>::operator[](const _Boolarray& _Boolarr) {
+    return mask_array<_Ty>(_Boolarr, _Myptr);
+}
+
+template <class _Ty>
+valarray<_Ty>& valarray<_Ty>::operator=(const indirect_array<_Ty>& _Indarr) {
+    _Tidy_deallocate();
+    _Grow(_Indarr._Totlen());
+    const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Myptr[_Idx] = _Indarr._Data(_Indarr._Indir(_Idx));
+    }
+    return *this;
+}
+
+template <class _Ty>
+_NODISCARD valarray<_Ty> valarray<_Ty>::operator[](const _Sizarray& _Indarr) const {
+    return valarray<_Ty>(indirect_array<_Ty>(_Indarr, _Myptr));
+}
+
+template <class _Ty>
+_NODISCARD indirect_array<_Ty> valarray<_Ty>::operator[](const _Sizarray& _Indarr) {
+    return indirect_array<_Ty>(_Indarr, _Myptr);
+}
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _VALARRAY_

miniMSVC/VC/Tools/MSVC/14.42.34433/include/varargs.h

@@ -0,0 +1,49 @@
+//
+// varargs.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// XENIX-style macros for accessing arguments of a function which takes a
+// variable number of arguments.  Use the C Standard <stdarg.h> instead.
+//
+#pragma once
+#define _INC_VARARGS
+
+#include <vcruntime.h>
+
+#pragma warning(push)
+#pragma warning(disable: _VCRUNTIME_DISABLED_WARNINGS)
+
+_CRT_BEGIN_C_HEADER
+
+
+
+#if __STDC__
+    #error varargs.h incompatible with __STDC__ (use stdarg.h)
+#endif
+
+#ifndef va_arg
+    #if defined _M_CEE
+        #error varargs.h not supported when targeting _M_CEE (use stdarg.h)
+    #endif
+
+    #define va_dcl va_list va_alist;
+    #define va_arg __crt_va_arg
+    #define va_end __crt_va_end
+
+    #if defined _M_IX86 || defined _M_ARM
+        #define va_start(ap) ((void)(ap = (va_list)&va_alist))
+    #elif defined _M_X64 && !defined(_M_ARM64EC)
+        #define va_start(ap) ((void)(__va_start(&ap, 0)))
+    #elif defined _M_ARM64 || defined _M_ARM64EC
+        #define va_start(ap) ((void)(__va_start(&ap, 0, 0, 0, 0)))
+    #else
+        #error Unsupported architecture
+    #endif
+#endif // va_arg
+
+
+
+_CRT_END_C_HEADER
+
+#pragma warning(pop) // _VCRUNTIME_DISABLED_WARNINGS

miniMSVC/VC/Tools/MSVC/14.42.34433/include/variant

@@ -0,0 +1,1718 @@
+// variant standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _VARIANT_
+#define _VARIANT_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX17
+_EMIT_STL_WARNING(STL4038, "The contents of <variant> are available only with C++17 or later.");
+#else // ^^^ !_HAS_CXX17 / _HAS_CXX17 vvv
+#if _HAS_CXX20
+#include <compare>
+#endif // _HAS_CXX20
+#include <exception>
+#include <initializer_list>
+#include <type_traits>
+#include <utility>
+#include <xsmf_control.h>
+#include <xutility>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+template <class...>
+struct _Meta_list; // a sequence of types (not defined)
+
+template <class _List>
+struct _Meta_front_;
+template <class _List>
+using _Meta_front =
+    // extract the first type in a sequence (head of list)
+    typename _Meta_front_<_List>::type;
+
+template <template <class...> class _List, class _First, class... _Rest>
+struct _Meta_front_<_List<_First, _Rest...>> {
+    using type = _First;
+};
+
+template <class _List>
+struct _Meta_pop_front_;
+template <class _List>
+using _Meta_pop_front =
+    // subsequence including all but the first type (tail of list)
+    typename _Meta_pop_front_<_List>::type;
+
+template <template <class...> class _List, class _First, class... _Rest>
+struct _Meta_pop_front_<_List<_First, _Rest...>> {
+    using type = _List<_Rest...>;
+};
+
+template <class _List, class _Ty>
+struct _Meta_push_front_;
+template <class _List, class _Ty>
+using _Meta_push_front =
+    // prepend a new type onto a sequence
+    typename _Meta_push_front_<_List, _Ty>::type;
+
+template <template <class...> class _List, class... _Types, class _Ty>
+struct _Meta_push_front_<_List<_Types...>, _Ty> {
+    using type = _List<_Ty, _Types...>;
+};
+
+template <class _Void, template <class...> class _Fn, class... _Args>
+struct _Meta_quote_helper_;
+template <template <class...> class _Fn, class... _Args>
+struct _Meta_quote_helper_<void_t<_Fn<_Args...>>, _Fn, _Args...> {
+    using type = _Fn<_Args...>;
+};
+template <template <class...> class _Fn>
+struct _Meta_quote { // encapsulate a template into a meta-callable type
+    template <class... _Types>
+    using _Invoke = typename _Meta_quote_helper_<void, _Fn, _Types...>::type;
+};
+
+template <class _Fn, class... _Args>
+using _Meta_invoke = // invoke meta-callable _Fn with _Args
+    typename _Fn::template _Invoke<_Args...>;
+
+template <class _Fn, class... _Args>
+struct _Meta_bind_back { // construct a meta-callable that passes its arguments and _Args to _Fn
+    template <class... _Types>
+    using _Invoke = _Meta_invoke<_Fn, _Types..., _Args...>;
+};
+
+template <class _Fn, class _List>
+struct _Meta_apply_;
+template <class _Fn, class _List>
+using _Meta_apply =
+    // unpack _List into the parameters of meta-callable _Fn
+    typename _Meta_apply_<_Fn, _List>::type;
+
+template <class _Fn, template <class...> class _List, class... _Types>
+struct _Meta_apply_<_Fn, _List<_Types...>> {
+    // invoke meta-callable _Fn with the parameters of a template specialization
+    using type = _Meta_invoke<_Fn, _Types...>;
+};
+
+template <class _Fn, class _Ty, _Ty... _Idxs>
+struct _Meta_apply_<_Fn, integer_sequence<_Ty, _Idxs...>> {
+    // invoke meta-callable _Fn with the elements of an integer_sequence
+    using type = _Meta_invoke<_Fn, integral_constant<_Ty, _Idxs>...>;
+};
+
+template <class _Fn, class _List>
+struct _Meta_transform_;
+template <class _Fn, class _List>
+using _Meta_transform =
+    // transform sequence of _Types... into sequence of _Fn<_Types...>
+    typename _Meta_transform_<_Fn, _List>::type;
+
+template <template <class...> class _List, class _Fn, class... _Types>
+struct _Meta_transform_<_Fn, _List<_Types...>> {
+    using type = _List<_Meta_invoke<_Fn, _Types>...>;
+};
+
+template <class, class, template <class...> class>
+struct _Meta_repeat_n_c_;
+template <size_t _Count, class _Ty, template <class...> class _Continue>
+using _Meta_repeat_n_c =
+    // construct a sequence consisting of repetitions of _Ty
+    typename _Meta_repeat_n_c_<_Ty, make_index_sequence<_Count>, _Continue>::type;
+
+template <class _Ty, size_t>
+using _Meta_repeat_first_helper = _Ty;
+
+template <class _Ty, size_t... _Idxs, template <class...> class _Continue>
+struct _Meta_repeat_n_c_<_Ty, index_sequence<_Idxs...>, _Continue> {
+    using type = _Continue<_Meta_repeat_first_helper<_Ty, _Idxs>...>;
+};
+
+template <class _List, size_t _Idx, class = void>
+struct _Meta_at_;
+template <class _List, size_t _Idx>
+using _Meta_at_c =
+    // Extract the _Idx-th type from _List
+    typename _Meta_at_<_List, _Idx>::type;
+
+#ifdef __clang__
+template <template <class...> class _List, class... _Types, size_t _Idx>
+struct _Meta_at_<_List<_Types...>, _Idx, void_t<__type_pack_element<_Idx, _Types...>>> {
+    using type = __type_pack_element<_Idx, _Types...>;
+};
+#else // ^^^ defined(__clang__) / !defined(__clang__) vvv
+template <class... _VoidPtrs>
+struct _Meta_at_impl {
+    template <class _Ty, class... _Types>
+    static _Ty _Eval(_VoidPtrs..., _Ty*, _Types*...); // undefined
+};
+
+template <class _Ty>
+constexpr _Identity<_Ty>* _Type_as_pointer() {
+    return nullptr;
+}
+
+template <template <class...> class _List, class... _Types, size_t _Idx>
+struct _Meta_at_<_List<_Types...>, _Idx, enable_if_t<(_Idx < sizeof...(_Types))>> {
+    using type =
+        typename decltype(_Meta_repeat_n_c<_Idx, void*, _Meta_at_impl>::_Eval(_Type_as_pointer<_Types>()...))::type;
+};
+#endif // ^^^ !defined(__clang__) ^^^
+
+template <class>
+struct _Meta_as_list_;
+template <class _Ty>
+using _Meta_as_list =
+    // convert _Ty to a _Meta_list
+    typename _Meta_as_list_<_Ty>::type;
+
+template <template <class...> class _List, class... _Types>
+struct _Meta_as_list_<_List<_Types...>> {
+    // convert the parameters of an arbitrary template specialization to a _Meta_list of types
+    using type = _Meta_list<_Types...>;
+};
+
+template <class _Ty, _Ty... _Idxs>
+struct _Meta_as_list_<integer_sequence<_Ty, _Idxs...>> {
+    // convert an integer_sequence to a _Meta_list of integral_constants
+    using type = _Meta_list<integral_constant<_Ty, _Idxs>...>;
+};
+
+template <class _List>
+struct _Meta_as_integer_sequence_;
+template <class _List>
+using _Meta_as_integer_sequence =
+    // convert a list of integral_constants to an integer_sequence
+    typename _Meta_as_integer_sequence_<_List>::type;
+
+template <template <class...> class _List, class _Ty, _Ty... _Idxs>
+struct _Meta_as_integer_sequence_<_List<integral_constant<_Ty, _Idxs>...>> {
+    using type = integer_sequence<_Ty, _Idxs...>;
+};
+
+template <class...>
+struct _Meta_concat_;
+template <class... _Types>
+using _Meta_concat =
+    // merge several lists into one
+    typename _Meta_concat_<_Types...>::type;
+
+template <template <class...> class _List>
+struct _Meta_concat_<_List<>> {
+    using type = _List<>;
+};
+
+template <template <class...> class _List, class... _Items1>
+struct _Meta_concat_<_List<_Items1...>> {
+    using type = _List<_Items1...>;
+};
+
+template <template <class...> class _List, class... _Items1, class... _Items2>
+struct _Meta_concat_<_List<_Items1...>, _List<_Items2...>> {
+    using type = _List<_Items1..., _Items2...>;
+};
+
+template <template <class...> class _List, class... _Items1, class... _Items2, class... _Items3>
+struct _Meta_concat_<_List<_Items1...>, _List<_Items2...>, _List<_Items3...>> {
+    using type = _List<_Items1..., _Items2..., _Items3...>;
+};
+
+template <template <class...> class _List, class... _Items1, class... _Items2, class... _Items3, class... _Rest>
+struct _Meta_concat_<_List<_Items1...>, _List<_Items2...>, _List<_Items3...>, _Rest...> {
+    using type = _Meta_concat<_List<_Items1..., _Items2..., _Items3...>, _Rest...>;
+};
+
+template <class _ListOfLists>
+using _Meta_join =
+    // transform a list of lists of elements into a single list containing those elements
+    _Meta_apply<_Meta_quote<_Meta_concat>, _ListOfLists>;
+
+template <class>
+struct _Meta_cartesian_product_;
+template <class _ListOfLists>
+using _Meta_cartesian_product =
+    // find the n-ary Cartesian Product of the lists in the input list
+    typename _Meta_cartesian_product_<_ListOfLists>::type;
+
+template <template <class...> class _List>
+struct _Meta_cartesian_product_<_List<>> {
+    using type = _List<>;
+};
+
+template <template <class...> class _List1, template <class...> class _List2, class... _Items>
+struct _Meta_cartesian_product_<_List1<_List2<_Items...>>> {
+    using type = _List1<_List2<_Items>...>;
+};
+
+template <template <class...> class _List1, class... _Items, template <class...> class _List2, class... _Lists>
+struct _Meta_cartesian_product_<_List1<_List2<_Items...>, _Lists...>> {
+    using type = _Meta_join<_List1<_Meta_transform<_Meta_bind_back<_Meta_quote<_Meta_push_front>, _Items>,
+        _Meta_cartesian_product<_List1<_Lists...>>>...>>;
+};
+
+#define _STL_STAMP4(n, x) \
+    x(n);                 \
+    x(n + 1);             \
+    x(n + 2);             \
+    x(n + 3)
+#define _STL_STAMP16(n, x) \
+    _STL_STAMP4(n, x);     \
+    _STL_STAMP4(n + 4, x); \
+    _STL_STAMP4(n + 8, x); \
+    _STL_STAMP4(n + 12, x)
+#define _STL_STAMP64(n, x)   \
+    _STL_STAMP16(n, x);      \
+    _STL_STAMP16(n + 16, x); \
+    _STL_STAMP16(n + 32, x); \
+    _STL_STAMP16(n + 48, x)
+#define _STL_STAMP256(n, x)   \
+    _STL_STAMP64(n, x);       \
+    _STL_STAMP64(n + 64, x);  \
+    _STL_STAMP64(n + 128, x); \
+    _STL_STAMP64(n + 192, x)
+
+#define _STL_STAMP(n, x) x(_STL_STAMP##n, n)
+
+_EXPORT_STD template <class... _Types>
+class variant;
+
+_EXPORT_STD template <class _Ty>
+struct variant_size; // undefined
+template <class _Ty>
+struct variant_size<const _Ty> : variant_size<_Ty>::type {};
+template <class _Ty>
+struct _CXX20_DEPRECATE_VOLATILE variant_size<volatile _Ty> : variant_size<_Ty>::type {};
+template <class _Ty>
+struct _CXX20_DEPRECATE_VOLATILE variant_size<const volatile _Ty> : variant_size<_Ty>::type {};
+_EXPORT_STD template <class _Ty>
+constexpr size_t variant_size_v = variant_size<_Ty>::value;
+
+template <class... _Types>
+struct variant_size<variant<_Types...>> : integral_constant<size_t, sizeof...(_Types)> {};
+
+_EXPORT_STD template <size_t _Idx, class _Ty>
+struct variant_alternative; // undefined
+_EXPORT_STD template <size_t _Idx, class _Ty>
+using variant_alternative_t = typename variant_alternative<_Idx, _Ty>::type;
+template <size_t _Idx, class _Ty>
+struct variant_alternative<_Idx, const _Ty> {
+    using type = add_const_t<variant_alternative_t<_Idx, _Ty>>;
+};
+template <size_t _Idx, class _Ty>
+struct _CXX20_DEPRECATE_VOLATILE variant_alternative<_Idx, volatile _Ty> {
+    using type = add_volatile_t<variant_alternative_t<_Idx, _Ty>>;
+};
+template <size_t _Idx, class _Ty>
+struct _CXX20_DEPRECATE_VOLATILE variant_alternative<_Idx, const volatile _Ty> {
+    using type = add_cv_t<variant_alternative_t<_Idx, _Ty>>;
+};
+template <size_t _Idx, class... _Types>
+struct variant_alternative<_Idx, variant<_Types...>> {
+    static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
+
+#ifdef __clang__
+    using type = __type_pack_element<_Idx, _Types...>;
+#else // ^^^ defined(__clang__) / !defined(__clang__) vvv
+    using type = _Meta_at_c<variant<_Types...>, _Idx>;
+#endif // ^^^ !defined(__clang__) ^^^
+};
+
+_EXPORT_STD inline constexpr size_t variant_npos = _Meta_npos;
+
+template <bool _TrivialDestruction, class... _Types>
+class _Variant_storage_ {}; // empty storage (empty "_Types" case)
+
+template <class... _Types>
+using _Variant_storage = _Variant_storage_<conjunction_v<is_trivially_destructible<_Types>...>, _Types...>;
+
+template <class _First, class... _Rest>
+class _Variant_storage_<true, _First, _Rest...> { // Storage for variant alternatives (trivially destructible case)
+public:
+    static constexpr size_t _Size = 1 + sizeof...(_Rest);
+    union {
+        remove_cv_t<_First> _Head;
+        _Variant_storage<_Rest...> _Tail;
+    };
+
+    _CONSTEXPR20 _Variant_storage_() noexcept {} // no initialization (no active member)
+
+    template <class... _Types>
+    constexpr explicit _Variant_storage_(integral_constant<size_t, 0>, _Types&&... _Args) noexcept(
+        is_nothrow_constructible_v<_First, _Types...>)
+        : _Head(static_cast<_Types&&>(_Args)...) {} // initialize _Head with _Args...
+
+    template <size_t _Idx, class... _Types, enable_if_t<(_Idx > 0), int> = 0>
+    constexpr explicit _Variant_storage_(integral_constant<size_t, _Idx>, _Types&&... _Args) noexcept(
+        is_nothrow_constructible_v<_Variant_storage<_Rest...>, integral_constant<size_t, _Idx - 1>, _Types...>)
+        : _Tail(integral_constant<size_t, _Idx - 1>{}, static_cast<_Types&&>(_Args)...) {} // initialize _Tail (recurse)
+
+    _NODISCARD constexpr _First& _Get() & noexcept {
+        return _Head;
+    }
+    _NODISCARD constexpr const _First& _Get() const& noexcept {
+        return _Head;
+    }
+    _NODISCARD constexpr _First&& _Get() && noexcept {
+        return _STD move(_Head);
+    }
+    _NODISCARD constexpr const _First&& _Get() const&& noexcept {
+        return _STD move(_Head);
+    }
+};
+
+template <class _First, class... _Rest>
+class _Variant_storage_<false, _First, _Rest...> { // Storage for variant alternatives (non-trivially destructible case)
+public:
+    static constexpr size_t _Size = 1 + sizeof...(_Rest);
+    union {
+        remove_cv_t<_First> _Head;
+        _Variant_storage<_Rest...> _Tail;
+    };
+
+    _CONSTEXPR20 ~_Variant_storage_()
+#ifndef __clang__ // TRANSITION, LLVM-59854
+        noexcept
+#endif // ^^^ no workaround ^^^
+    {
+        // explicitly non-trivial destructor (which would otherwise be defined as deleted
+        // since the class has a variant member with a non-trivial destructor)
+    }
+
+    _CONSTEXPR20 _Variant_storage_() noexcept {} // no initialization (no active member)
+
+    template <class... _Types>
+    constexpr explicit _Variant_storage_(integral_constant<size_t, 0>, _Types&&... _Args) noexcept(
+        is_nothrow_constructible_v<_First, _Types...>)
+        : _Head(static_cast<_Types&&>(_Args)...) {} // initialize _Head with _Args...
+
+    template <size_t _Idx, class... _Types, enable_if_t<(_Idx > 0), int> = 0>
+    constexpr explicit _Variant_storage_(integral_constant<size_t, _Idx>, _Types&&... _Args) noexcept(
+        is_nothrow_constructible_v<_Variant_storage<_Rest...>, integral_constant<size_t, _Idx - 1>, _Types...>)
+        : _Tail(integral_constant<size_t, _Idx - 1>{}, static_cast<_Types&&>(_Args)...) {} // initialize _Tail (recurse)
+
+    _Variant_storage_(_Variant_storage_&&)                 = default;
+    _Variant_storage_(const _Variant_storage_&)            = default;
+    _Variant_storage_& operator=(_Variant_storage_&&)      = default;
+    _Variant_storage_& operator=(const _Variant_storage_&) = default;
+
+    _NODISCARD constexpr _First& _Get() & noexcept {
+        return _Head;
+    }
+    _NODISCARD constexpr const _First& _Get() const& noexcept {
+        return _Head;
+    }
+    _NODISCARD constexpr _First&& _Get() && noexcept {
+        return _STD move(_Head);
+    }
+    _NODISCARD constexpr const _First&& _Get() const&& noexcept {
+        return _STD move(_Head);
+    }
+};
+
+#ifdef __cplusplus_winrt // TRANSITION, VSO-586813
+// C++/CX is unable to store hats in unions. We instead store them inside a
+// wrapper to enable minimal hats-in-variants support.
+template <class _Ty>
+struct _Variant_item {
+    remove_cv_t<_Ty> _Item;
+
+    template <class... _Types>
+    constexpr _Variant_item(_Types&&... _Args) noexcept(is_nothrow_constructible_v<_Ty, _Types...>)
+        : _Item(static_cast<_Types&&>(_Args)...) {}
+};
+
+template <class _First, class... _Rest>
+class _Variant_storage_<false, _First ^, _Rest...> { // Storage for variant alternatives (^ case)
+public:
+    static constexpr size_t _Size = 1 + sizeof...(_Rest);
+    union {
+        _Variant_item<_First ^> _Head;
+        _Variant_storage<_Rest...> _Tail;
+    };
+
+    _CONSTEXPR20 ~_Variant_storage_() noexcept {
+        // explicitly non-trivial destructor (which would otherwise be defined as deleted
+        // since the class has a variant member with a non-trivial destructor)
+    }
+
+    _CONSTEXPR20 _Variant_storage_() noexcept {} // no initialization (no active member)
+
+    template <class... _Types>
+    constexpr explicit _Variant_storage_(integral_constant<size_t, 0>, _Types&&... _Args) noexcept(
+        is_nothrow_constructible_v<_First ^, _Types...>)
+        : _Head(static_cast<_Types&&>(_Args)...) {} // initialize _Head with _Args...
+
+    template <size_t _Idx, class... _Types, enable_if_t<(_Idx > 0), int> = 0>
+    constexpr explicit _Variant_storage_(integral_constant<size_t, _Idx>, _Types&&... _Args) noexcept(
+        is_nothrow_constructible_v<_Variant_storage<_Rest...>, integral_constant<size_t, _Idx - 1>, _Types...>)
+        : _Tail(integral_constant<size_t, _Idx - 1>{}, static_cast<_Types&&>(_Args)...) {} // initialize _Tail (recurse)
+
+    _Variant_storage_(_Variant_storage_&&)                 = default;
+    _Variant_storage_(const _Variant_storage_&)            = default;
+    _Variant_storage_& operator=(_Variant_storage_&&)      = default;
+    _Variant_storage_& operator=(const _Variant_storage_&) = default;
+
+    _NODISCARD constexpr _First ^ &_Get() & noexcept {
+        return _Head._Item;
+    }
+    _NODISCARD constexpr _First ^ const& _Get() const& noexcept {
+        return _Head._Item;
+    }
+    _NODISCARD constexpr _First ^ &&_Get() && noexcept {
+        return _STD move(_Head)._Item;
+    }
+    _NODISCARD constexpr _First ^ const&& _Get() const&& noexcept {
+        return _STD move(_Head)._Item;
+    }
+};
+#endif // ^^^ workaround ^^^
+
+template <size_t _Idx, class _Storage>
+_NODISCARD constexpr decltype(auto) _Variant_raw_get(_Storage&& _Obj) noexcept {
+    // access the _Idx-th element of a _Variant_storage
+    if constexpr (_Idx == 0) {
+        return static_cast<_Storage&&>(_Obj)._Get();
+    } else if constexpr (_Idx == 1) {
+        return static_cast<_Storage&&>(_Obj)._Tail._Get();
+    } else if constexpr (_Idx == 2) {
+        return static_cast<_Storage&&>(_Obj)._Tail._Tail._Get();
+    } else if constexpr (_Idx == 3) {
+        return static_cast<_Storage&&>(_Obj)._Tail._Tail._Tail._Get();
+    } else if constexpr (_Idx == 4) {
+        return static_cast<_Storage&&>(_Obj)._Tail._Tail._Tail._Tail._Get();
+    } else if constexpr (_Idx == 5) {
+        return static_cast<_Storage&&>(_Obj)._Tail._Tail._Tail._Tail._Tail._Get();
+    } else if constexpr (_Idx == 6) {
+        return static_cast<_Storage&&>(_Obj)._Tail._Tail._Tail._Tail._Tail._Tail._Get();
+    } else if constexpr (_Idx == 7) {
+        return static_cast<_Storage&&>(_Obj)._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Get();
+    } else if constexpr (_Idx < 16) {
+        return _STD _Variant_raw_get<_Idx - 8>(
+            static_cast<_Storage&&>(_Obj)._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail);
+    } else if constexpr (_Idx < 32) {
+        return _STD _Variant_raw_get<_Idx - 16>(
+            static_cast<_Storage&&>(_Obj)
+                ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail);
+    } else if constexpr (_Idx < 64) {
+        return _STD _Variant_raw_get<_Idx - 32>(
+            static_cast<_Storage&&>(_Obj)
+                ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail
+                ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail);
+    } else { // _Idx >= 64
+        return _STD _Variant_raw_get<_Idx - 64>(
+            static_cast<_Storage&&>(_Obj)
+                ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail
+                ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail
+                ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail
+                ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail);
+    }
+}
+
+template <class _Ty, size_t _Tag>
+struct _Tagged { // aggregate a runtime value and a compile-time tag value
+    static constexpr size_t _Idx = _Tag;
+    _Ty _Val;
+};
+
+template <class _Storage, size_t _Idx>
+using _Variant_tagged_ref_t = _Tagged<decltype(_STD _Variant_raw_get<_Idx>(_STD declval<_Storage>()))&&, _Idx>;
+
+template <class _Fn, class _Storage>
+using _Variant_raw_visit_t = decltype(_STD declval<_Fn>()(_STD declval<_Variant_tagged_ref_t<_Storage, 0>>()));
+
+template <size_t _Idx, class _Fn, class _Storage>
+_NODISCARD constexpr _Variant_raw_visit_t<_Fn, _Storage> _Variant_raw_visit_dispatch(
+    _Fn&& _Func, _Storage&& _Var) noexcept(is_nothrow_invocable_v<_Fn, _Variant_tagged_ref_t<_Storage, _Idx>>) {
+    // call _Func with the _Idx-th element in _Storage (tagged with _Idx)
+    return static_cast<_Fn&&>(_Func)(
+        _Variant_tagged_ref_t<_Storage, _Idx>{_STD _Variant_raw_get<_Idx>(static_cast<_Storage&&>(_Var))});
+}
+
+template <class _Fn, class _Storage>
+_NODISCARD constexpr _Variant_raw_visit_t<_Fn, _Storage> _Variant_raw_visit_valueless(
+    _Fn&& _Func, _Storage&& _Obj) noexcept(is_nothrow_invocable_v<_Fn, _Tagged<_Storage&&, variant_npos>>) {
+    // call _Func with _Storage (tagged with variant_npos)
+    return static_cast<_Fn&&>(_Func)(_Tagged<_Storage&&, variant_npos>{static_cast<_Storage&&>(_Obj)});
+}
+
+template <class _Fn, class _Storage, class _Indices = make_index_sequence<remove_reference_t<_Storage>::_Size>>
+constexpr bool _Variant_raw_visit_noexcept = false;
+
+template <class _Fn, class _Storage, size_t... _Idxs>
+constexpr bool _Variant_raw_visit_noexcept<_Fn, _Storage, index_sequence<_Idxs...>> =
+    conjunction_v<is_nothrow_invocable<_Fn, _Tagged<_Storage&&, variant_npos>>,
+        is_nothrow_invocable<_Fn, _Variant_tagged_ref_t<_Storage, _Idxs>>...>;
+
+template <class _Fn, class _Storage,
+    class _Indices = make_index_sequence<remove_reference_t<_Storage>::_Size>>
+struct _Variant_raw_dispatch_table1; // undefined
+
+template <class _Fn, class _Storage, size_t... _Idxs>
+struct _Variant_raw_dispatch_table1<_Fn, _Storage, index_sequence<_Idxs...>> {
+    // map from canonical index to visitation target
+    using _Dispatch_t = _Variant_raw_visit_t<_Fn, _Storage> (*)(_Fn&&, _Storage&&) noexcept(
+        _Variant_raw_visit_noexcept<_Fn, _Storage>);
+    static constexpr _Dispatch_t _Array[] = {
+        &_STD _Variant_raw_visit_valueless<_Fn, _Storage>, &_STD _Variant_raw_visit_dispatch<_Idxs, _Fn, _Storage>...};
+};
+
+template <int _Strategy>
+struct _Variant_raw_visit1;
+
+template <>
+struct _Variant_raw_visit1<-1> { // Fallback case for variants too large for any of the following "switch" strategies
+    template <class _Fn, class _Storage>
+    _NODISCARD static constexpr _Variant_raw_visit_t<_Fn, _Storage> _Visit(
+        size_t _Idx, _Fn&& _Func, _Storage&& _Obj) noexcept(_Variant_raw_visit_noexcept<_Fn, _Storage>) {
+        // dispatch a visitor for a _Variant_storage with many states
+        constexpr size_t _Size = remove_reference_t<_Storage>::_Size;
+        static_assert(_Size > 256);
+        constexpr auto& _Array = _Variant_raw_dispatch_table1<_Fn, _Storage>::_Array;
+        return _Array[_Idx](static_cast<_Fn&&>(_Func), static_cast<_Storage&&>(_Obj));
+    }
+};
+
+#define _STL_CASE(n)                                                                                              \
+    case (n) + 1:                                                                                                 \
+        if constexpr ((n) < _Size) {                                                                              \
+            return static_cast<_Fn&&>(_Func)(                                                                     \
+                _Variant_tagged_ref_t<_Storage, (n)>{_STD _Variant_raw_get<(n)>(static_cast<_Storage&&>(_Obj))}); \
+        }                                                                                                         \
+        _STL_UNREACHABLE;                                                                                         \
+        [[fallthrough]]
+
+#define _STL_VISIT_STAMP(stamper, n)                                                                        \
+    constexpr size_t _Size = remove_reference_t<_Storage>::_Size;                                           \
+    static_assert(((n) == 4 || _Size > (n) / 4) && _Size <= (n));                                           \
+    switch (_Idx) {                                                                                         \
+    case 0:                                                                                                 \
+        return static_cast<_Fn&&>(_Func)(_Tagged<_Storage&&, variant_npos>{static_cast<_Storage&&>(_Obj)}); \
+                                                                                                            \
+        stamper(0, _STL_CASE);                                                                              \
+    default:                                                                                                \
+        _STL_UNREACHABLE;                                                                                   \
+    }
+
+template <>
+struct _Variant_raw_visit1<1> {
+    template <class _Fn, class _Storage>
+    _NODISCARD static constexpr _Variant_raw_visit_t<_Fn, _Storage> _Visit(
+        size_t _Idx, _Fn&& _Func, _Storage&& _Obj) noexcept(_Variant_raw_visit_noexcept<_Fn, _Storage>) {
+        // dispatch a visitor for a _Variant_storage with at most 4^1 states
+        _STL_STAMP(4, _STL_VISIT_STAMP);
+    }
+};
+
+template <>
+struct _Variant_raw_visit1<2> {
+    template <class _Fn, class _Storage>
+    _NODISCARD static constexpr _Variant_raw_visit_t<_Fn, _Storage> _Visit(
+        size_t _Idx, _Fn&& _Func, _Storage&& _Obj) noexcept(_Variant_raw_visit_noexcept<_Fn, _Storage>) {
+        // dispatch a visitor for a _Variant_storage with at most 4^2 states
+        _STL_STAMP(16, _STL_VISIT_STAMP);
+    }
+};
+
+template <>
+struct _Variant_raw_visit1<3> {
+    template <class _Fn, class _Storage>
+    _NODISCARD static constexpr _Variant_raw_visit_t<_Fn, _Storage> _Visit(
+        size_t _Idx, _Fn&& _Func, _Storage&& _Obj) noexcept(_Variant_raw_visit_noexcept<_Fn, _Storage>) {
+        // dispatch a visitor for a _Variant_storage with at most 4^3 states
+        _STL_STAMP(64, _STL_VISIT_STAMP);
+    }
+};
+
+template <>
+struct _Variant_raw_visit1<4> {
+    template <class _Fn, class _Storage>
+    _NODISCARD static constexpr _Variant_raw_visit_t<_Fn, _Storage> _Visit(
+        size_t _Idx, _Fn&& _Func, _Storage&& _Obj) noexcept(_Variant_raw_visit_noexcept<_Fn, _Storage>) {
+        // dispatch a visitor for a _Variant_storage with at most 4^4 states
+        _STL_STAMP(256, _STL_VISIT_STAMP);
+    }
+};
+
+#undef _STL_VISIT_STAMP
+#undef _STL_CASE
+
+template <class _Storage, class _Fn>
+_NODISCARD constexpr _Variant_raw_visit_t<_Fn, _Storage> _Variant_raw_visit(
+    size_t _Idx, _Storage&& _Obj, _Fn&& _Func) noexcept(_Variant_raw_visit_noexcept<_Fn, _Storage>) {
+    // Call _Func with _Storage if _Idx is variant_npos, and otherwise the _Idx-th element in _Storage.
+    // pre: _Idx + 1 <= remove_reference_t<_Storage>::_Size
+    constexpr size_t _Size  = remove_reference_t<_Storage>::_Size;
+    constexpr int _Strategy = _Size <= 4 ? 1 : _Size <= 16 ? 2 : _Size <= 64 ? 3 : _Size <= 256 ? 4 : -1;
+    ++_Idx; // bias index by +1 to map {variant_npos} U [0, _Size) to the contiguous range [0, _Size]
+    return _Variant_raw_visit1<_Strategy>::_Visit(_Idx, static_cast<_Fn&&>(_Func), static_cast<_Storage&&>(_Obj));
+}
+
+template <class...>
+class _Variant_base;
+
+inline constexpr size_t _Schar_max_as_size = static_cast<unsigned char>(-1) / 2;
+inline constexpr size_t _Short_max_as_size = static_cast<unsigned short>(-1) / 2;
+
+template <size_t _Count>
+using _Variant_index_t = // signed so that conversion of -1 to size_t can cheaply sign extend
+    conditional_t<(_Count < _Schar_max_as_size), signed char, conditional_t<(_Count < _Short_max_as_size), short, int>>;
+
+template <class... _Types>
+struct _Variant_construct_visitor { // visitor that constructs the same alternative in a target _Variant_base as is
+                                    // currently active in a source _Variant_base from the source's contained value
+    _Variant_base<_Types...>& _Self;
+
+    template <class _Ty, size_t _Idx>
+    _CONSTEXPR20 void operator()(_Tagged<_Ty, _Idx> _Source) const noexcept(
+        disjunction_v<bool_constant<_Idx == variant_npos>, is_nothrow_constructible<remove_reference_t<_Ty>, _Ty>>) {
+        // initialize _Idx-th item in _Self from _Source
+        _STL_INTERNAL_CHECK(_Self.valueless_by_exception());
+        if constexpr (_Idx != variant_npos) {
+            _STD _Construct_in_place(
+                _Self._Storage(), integral_constant<size_t, _Idx>{}, static_cast<_Ty&&>(_Source._Val));
+            _Self._Set_index(_Idx);
+        }
+    }
+};
+
+template <class _Target, class... _Types>
+constexpr bool _Variant_should_directly_construct_v =
+    disjunction_v<is_nothrow_constructible<_Target, _Types...>, negation<is_nothrow_move_constructible<_Target>>>;
+
+template <class... _Types>
+struct _Variant_assign_visitor { // visitor that implements assignment for variants with non-trivial alternatives
+    _Variant_base<_Types...>& _Self;
+
+    template <class _Ty, size_t _Idx>
+    _CONSTEXPR20 void operator()(_Tagged<_Ty, _Idx> _Source) const
+        noexcept(disjunction_v<bool_constant<_Idx == variant_npos>,
+            conjunction<is_nothrow_assignable<_Remove_cvref_t<_Ty>&, _Ty>,
+                is_nothrow_constructible<_Remove_cvref_t<_Ty>, _Ty>>>) {
+        // assign the _Idx-th alternative of _Self from _Source
+        if constexpr (_Idx == variant_npos) { // assign from valueless _Source
+            _Self._Reset();
+        } else {
+            if (_Self._Which == _Idx) { // same alternative: assign directly
+                auto& _Target = _STD _Variant_raw_get<_Idx>(_Self._Storage());
+                _Target       = static_cast<_Ty&&>(_Source._Val);
+            } else { // different alternative
+                if constexpr (is_lvalue_reference_v<_Ty>) { // RHS is an lvalue: copy
+                    if constexpr (_Variant_should_directly_construct_v<_Remove_cvref_t<_Ty>, _Ty>) {
+                        // copy is nothrow or move throws; construct in place
+                        _Self._Reset();
+                        _STD _Construct_in_place(_Self._Storage(), integral_constant<size_t, _Idx>{}, _Source._Val);
+                    } else { // copy throws and move does not; move from a temporary copy
+                        auto _Temp = _Source._Val;
+                        _Self._Reset();
+                        _STD _Construct_in_place(_Self._Storage(), integral_constant<size_t, _Idx>{}, _STD move(_Temp));
+                    }
+                } else { // RHS is an rvalue: move
+                    _Self._Reset();
+                    _STD _Construct_in_place(
+                        _Self._Storage(), integral_constant<size_t, _Idx>{}, static_cast<_Ty&&>(_Source._Val));
+                }
+
+                _Self._Set_index(_Idx);
+            }
+        }
+    }
+};
+
+template <class... _Types> // Associate an integral discriminator with a _Variant_storage
+class _Variant_base : private _Variant_storage<_Types...> {
+public:
+    using _Index_t                       = _Variant_index_t<sizeof...(_Types)>;
+    static constexpr auto _Invalid_index = static_cast<_Index_t>(-1);
+    _Index_t _Which;
+
+    using _Storage_t = _Variant_storage<_Types...>;
+    _NODISCARD constexpr _Storage_t& _Storage() & noexcept { // access this variant's storage
+        return *this;
+    }
+    _NODISCARD constexpr const _Storage_t& _Storage() const& noexcept { // access this variant's storage
+        return *this;
+    }
+    _NODISCARD constexpr _Storage_t&& _Storage() && noexcept { // access this variant's storage
+        return _STD move(*this);
+    }
+    _NODISCARD constexpr const _Storage_t&& _Storage() const&& noexcept { // access this variant's storage
+        return _STD move(*this);
+    }
+
+    // initialize to the value-less state
+    _CONSTEXPR20 _Variant_base() noexcept : _Storage_t{}, _Which{_Invalid_index} {}
+
+    template <size_t _Idx, class... _UTypes,
+        enable_if_t<is_constructible_v<_Meta_at_c<variant<_Types...>, _Idx>, _UTypes...>, int> = 0>
+    constexpr explicit _Variant_base(in_place_index_t<_Idx>, _UTypes&&... _Args) noexcept(
+        is_nothrow_constructible_v<_Meta_at_c<variant<_Types...>, _Idx>, _UTypes...>)
+        : _Storage_t(integral_constant<size_t, _Idx>{}, static_cast<_UTypes&&>(_Args)...),
+          _Which{static_cast<_Index_t>(_Idx)} { // initialize alternative _Idx from _Args...
+    }
+
+    _NODISCARD constexpr bool valueless_by_exception() const noexcept { // does this variant NOT hold a value?
+        return _Which < 0;
+    }
+    _NODISCARD constexpr size_t index() const noexcept {
+        // index of the contained alternative or variant_npos if valueless_by_exception
+        return static_cast<size_t>(_Which);
+    }
+    _CONSTEXPR20 void _Set_index(const size_t _Idx) noexcept {
+        // record _Idx as the active alternative
+        // pre: the active alternative of *this is _Idx
+        _Which = static_cast<_Index_t>(_Idx);
+    }
+
+    template <size_t _Idx>
+    _CONSTEXPR20 void _Destroy() noexcept {
+        // destroy the contained value
+        // pre: _Idx == index()
+        using _Indexed_value_type = remove_cv_t<_Meta_at_c<variant<_Types...>, _Idx>>;
+        if constexpr (_Idx != variant_npos && !is_trivially_destructible_v<_Indexed_value_type>) {
+            _STD _Variant_raw_get<_Idx>(_Storage()).~_Indexed_value_type();
+        }
+    }
+
+    _CONSTEXPR20 void _Destroy() noexcept { // destroy the contained value, if any
+        if constexpr (!conjunction_v<is_trivially_destructible<_Types>...>) {
+            _STD _Variant_raw_visit(index(), _Storage(), [](auto _Ref) noexcept {
+                if constexpr (decltype(_Ref)::_Idx != variant_npos) {
+                    using _Indexed_value_type = _Remove_cvref_t<decltype(_Ref._Val)>;
+                    _Ref._Val.~_Indexed_value_type();
+                }
+            });
+        }
+    }
+
+    _CONSTEXPR20 void _Reset() noexcept { // transition to the valueless_by_exception state
+        _Destroy();
+        _Set_index(variant_npos);
+    }
+
+    template <size_t _Idx>
+    _CONSTEXPR20 void _Reset() noexcept {
+        // transition to the valueless_by_exception state
+        // pre: _Idx == index()
+        if constexpr (_Idx != variant_npos) {
+            _Destroy<_Idx>();
+            _Set_index(variant_npos);
+        }
+    }
+
+    _CONSTEXPR20 void _Construct_from(const _Variant_base& _That) noexcept(
+        conjunction_v<is_nothrow_copy_constructible<_Types>...>) {
+        // copy _That's contained value into *this
+        // pre: valueless_by_exception()
+        _STD _Variant_raw_visit(_That.index(), _That._Storage(), _Variant_construct_visitor<_Types...>{*this});
+    }
+
+    _CONSTEXPR20 void _Construct_from(_Variant_base&& _That) noexcept(
+        conjunction_v<is_nothrow_move_constructible<_Types>...>) {
+        // move _That's contained value into *this
+        // pre: valueless_by_exception()
+        _STD _Variant_raw_visit(
+            _That.index(), _STD move(_That)._Storage(), _Variant_construct_visitor<_Types...>{*this});
+    }
+
+    _CONSTEXPR20 void _Assign_from(const _Variant_base& _That) noexcept(
+        conjunction_v<is_nothrow_copy_constructible<_Types>..., is_nothrow_copy_assignable<_Types>...>) {
+        // copy assign _That's contained value (if any) into *this
+        _STD _Variant_raw_visit(_That.index(), _That._Storage(), _Variant_assign_visitor<_Types...>{*this});
+    }
+
+    _CONSTEXPR20 void _Assign_from(_Variant_base&& _That) noexcept(
+        conjunction_v<is_nothrow_move_constructible<_Types>..., is_nothrow_move_assignable<_Types>...>) {
+        // move assign _That's contained value (if any) into *this
+        _STD _Variant_raw_visit(_That.index(), _STD move(_That)._Storage(), _Variant_assign_visitor<_Types...>{*this});
+    }
+};
+
+template <class... _Types>
+struct _Variant_destroy_layer_ : _Variant_base<_Types...> { // destruction behavior facade (non-trivial case)
+    using _Variant_base<_Types...>::_Variant_base;
+
+    _CONSTEXPR20 ~_Variant_destroy_layer_() noexcept { // Destroy contained value, if any
+        this->_Destroy();
+    }
+
+    _Variant_destroy_layer_()                                          = default;
+    _Variant_destroy_layer_(const _Variant_destroy_layer_&)            = default;
+    _Variant_destroy_layer_(_Variant_destroy_layer_&&)                 = default;
+    _Variant_destroy_layer_& operator=(const _Variant_destroy_layer_&) = default;
+    _Variant_destroy_layer_& operator=(_Variant_destroy_layer_&&)      = default;
+};
+
+template <class... _Types>
+using _Variant_destroy_layer = conditional_t<conjunction_v<is_trivially_destructible<_Types>...>,
+    _Variant_base<_Types...>, _Variant_destroy_layer_<_Types...>>;
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-volatile"
+#else // ^^^ Clang / not Clang vvv
+#pragma warning(push)
+#pragma warning(disable : 4242) // '%s': conversion from '%s' to '%s', possible loss of data
+#pragma warning(disable : 4244) // '%s': conversion from '%s' to '%s', possible loss of data (Yes, duplicated message.)
+#pragma warning(disable : 4365) // '%s': conversion from '%s' to '%s', signed/unsigned mismatch
+#pragma warning(disable : 5215) // '%s' a function parameter with volatile qualified type is deprecated in C++20
+#endif // ^^^ not Clang ^^^
+
+// build Ti x[] = {std::forward<T>(t)};
+template <size_t _Idx, class _TargetType>
+auto _Construct_array(_TargetType (&&)[1]) -> _Meta_list<integral_constant<size_t, _Idx>, _TargetType>;
+
+template <size_t _Idx, class _TargetType, class _InitializerType>
+using _Variant_type_resolver = decltype(_STD _Construct_array<_Idx, _TargetType>({_STD declval<_InitializerType>()}));
+
+template <size_t _Idx, class _TargetType>
+struct _Variant_init_single_overload {
+    template <class _InitializerType>
+    auto operator()(_TargetType, _InitializerType&&) -> _Variant_type_resolver<_Idx, _TargetType, _InitializerType>;
+};
+
+template <class _Indices, class... _Types>
+struct _Variant_init_overload_set_;
+
+template <size_t... _Indices, class... _Types>
+struct _Variant_init_overload_set_<index_sequence<_Indices...>, _Types...>
+    : _Variant_init_single_overload<_Indices, _Types>... {
+    using _Variant_init_single_overload<_Indices, _Types>::operator()...;
+};
+
+template <class... _Types>
+using _Variant_init_overload_set = _Variant_init_overload_set_<index_sequence_for<_Types...>, _Types...>;
+
+template <class Enable, class _Ty, class... _Types>
+struct _Variant_init_helper {}; // failure case (has no member "type")
+
+template <class _Ty, class... _Types>
+struct _Variant_init_helper<
+    void_t<decltype(_Variant_init_overload_set<_Types...>{}(_STD declval<_Ty>(), _STD declval<_Ty>()))>, _Ty,
+    _Types...> {
+    // perform overload resolution to determine the unique alternative that should be initialized in
+    // variant<_Types...> from an argument expression with type and value category _Ty
+    using type = decltype(_Variant_init_overload_set<_Types...>{}(_STD declval<_Ty>(), _STD declval<_Ty>()));
+};
+
+template <class _Ty, class... _Types> // extract the type from _Variant_init_helper
+using _Variant_init_type = _Meta_front<_Meta_pop_front<typename _Variant_init_helper<void, _Ty, _Types...>::type>>;
+
+template <class _Ty, class... _Types> // extract the index from _Variant_init_helper
+using _Variant_init_index = _Meta_front<typename _Variant_init_helper<void, _Ty, _Types...>::type>;
+#ifdef __clang__
+#pragma clang diagnostic pop
+#else // ^^^ Clang / not Clang vvv
+#pragma warning(pop)
+#endif // ^^^ not Clang ^^^
+
+template <class>
+constexpr bool _Is_in_place_index_specialization = false;
+template <size_t _Idx>
+constexpr bool _Is_in_place_index_specialization<in_place_index_t<_Idx>> = true;
+
+_EXPORT_STD template <class... _Types>
+class variant : private _SMF_control<_Variant_destroy_layer<_Types...>, _Types...> { // discriminated union
+public:
+    static_assert(conjunction_v<is_object<_Types>..., negation<is_array<_Types>>..., is_destructible<_Types>...>,
+        "variant<Types...> requires all of the Types to meet the Cpp17Destructible requirements "
+        "(N4950 [variant.variant.general]/2).");
+    static_assert(sizeof...(_Types) > 0,
+        "variant<> (with no template arguments) may not be instantiated (N4950 [variant.variant.general]/3).");
+    using _Mybase = _SMF_control<_Variant_destroy_layer<_Types...>, _Types...>;
+
+    template <class _First = _Meta_front<variant>, enable_if_t<is_default_constructible_v<_First>, int> = 0>
+    constexpr variant() noexcept(is_nothrow_default_constructible_v<_First>)
+        : _Mybase(in_place_index<0>) {} // value-initialize alternative 0
+
+    template <class _Ty,
+        enable_if_t<sizeof...(_Types) != 0 //
+                        && !is_same_v<_Remove_cvref_t<_Ty>, variant> //
+                        && !_Is_specialization_v<_Remove_cvref_t<_Ty>, in_place_type_t> //
+                        && !_Is_in_place_index_specialization<_Remove_cvref_t<_Ty>> //
+                        && is_constructible_v<_Variant_init_type<_Ty, _Types...>, _Ty>, //
+            int> = 0>
+    constexpr variant(_Ty&& _Obj) noexcept(is_nothrow_constructible_v<_Variant_init_type<_Ty, _Types...>, _Ty>)
+        : _Mybase(in_place_index<_Variant_init_index<_Ty, _Types...>::value>, static_cast<_Ty&&>(_Obj)) {
+        // initialize to the type selected by passing _Obj to the overload set f(Types)...
+    }
+
+    template <class _Ty, class... _UTypes, class _Idx = _Meta_find_unique_index<variant, _Ty>,
+        enable_if_t<_Idx::value != _Meta_npos && is_constructible_v<_Ty, _UTypes...>, int> = 0>
+    constexpr explicit variant(in_place_type_t<_Ty>, _UTypes&&... _Args) noexcept(
+        is_nothrow_constructible_v<_Ty, _UTypes...>) // strengthened
+        : _Mybase(in_place_index<_Idx::value>, static_cast<_UTypes&&>(_Args)...) {
+        // initialize alternative _Ty from _Args...
+    }
+    template <class _Ty, class _Elem, class... _UTypes, class _Idx = _Meta_find_unique_index<variant, _Ty>,
+        enable_if_t<_Idx::value != _Meta_npos && is_constructible_v<_Ty, initializer_list<_Elem>&, _UTypes...>, int> =
+            0>
+    constexpr explicit variant(in_place_type_t<_Ty>, initializer_list<_Elem> _Ilist, _UTypes&&... _Args) noexcept(
+        is_nothrow_constructible_v<_Ty, initializer_list<_Elem>&, _UTypes...>) // strengthened
+        : _Mybase(in_place_index<_Idx::value>, _Ilist, static_cast<_UTypes&&>(_Args)...) {
+        // initialize alternative _Ty from _Ilist and _Args...
+    }
+
+    template <size_t _Idx, class... _UTypes,
+        enable_if_t<is_constructible_v<_Meta_at_c<variant, _Idx>, _UTypes...>, int> = 0>
+    constexpr explicit variant(in_place_index_t<_Idx>, _UTypes&&... _Args) noexcept(
+        is_nothrow_constructible_v<_Meta_at_c<variant, _Idx>, _UTypes...>) // strengthened
+        : _Mybase(in_place_index<_Idx>, static_cast<_UTypes&&>(_Args)...) {
+        // initialize alternative _Idx from _Args...
+    }
+    template <size_t _Idx, class _Elem, class... _UTypes,
+        enable_if_t<is_constructible_v<_Meta_at_c<variant, _Idx>, initializer_list<_Elem>&, _UTypes...>, int> = 0>
+    constexpr explicit variant(in_place_index_t<_Idx>, initializer_list<_Elem> _Ilist, _UTypes&&... _Args) noexcept(
+        is_constructible_v<_Meta_at_c<variant, _Idx>, initializer_list<_Elem>&, _UTypes...>) // strengthened
+        : _Mybase(in_place_index<_Idx>, _Ilist, static_cast<_UTypes&&>(_Args)...) {
+        // initialize alternative _Idx from _Ilist and _Args...
+    }
+
+    template <class _Ty, enable_if_t<!is_same_v<_Remove_cvref_t<_Ty>, variant>
+                                         && is_constructible_v<_Variant_init_type<_Ty, _Types...>, _Ty>
+                                         && is_assignable_v<_Variant_init_type<_Ty, _Types...>&, _Ty>,
+                             int> = 0>
+    _CONSTEXPR20 variant& operator=(_Ty&& _Obj) noexcept(
+        is_nothrow_assignable_v<_Variant_init_type<_Ty, _Types...>&, _Ty>
+        && is_nothrow_constructible_v<_Variant_init_type<_Ty, _Types...>, _Ty>) {
+        // assign/emplace the alternative chosen by overload resolution of _Obj with f(_Types)...
+        constexpr size_t _TargetIdx = _Variant_init_index<_Ty, _Types...>::value;
+        if (index() == _TargetIdx) {
+            auto& _Target = _STD _Variant_raw_get<_TargetIdx>(_Storage());
+            _Target       = static_cast<_Ty&&>(_Obj);
+        } else {
+            using _TargetTy = _Variant_init_type<_Ty, _Types...>;
+            if constexpr (_Variant_should_directly_construct_v<_TargetTy, _Ty>) {
+                this->_Reset();
+                _Emplace_valueless<_TargetIdx>(static_cast<_Ty&&>(_Obj));
+            } else {
+                _TargetTy _Temp(static_cast<_Ty&&>(_Obj));
+                this->_Reset();
+                _Emplace_valueless<_TargetIdx>(_STD move(_Temp));
+            }
+        }
+
+        return *this;
+    }
+
+    using _Mybase::_Storage;
+
+    template <class _Ty, class... _ArgTypes, size_t _Idx = _Meta_find_unique_index<variant, _Ty>::value,
+        enable_if_t<_Idx != _Meta_npos && is_constructible_v<_Ty, _ArgTypes...>, int> = 0>
+    _CONSTEXPR20 _Ty& emplace(_ArgTypes&&... _Args) noexcept(
+        is_nothrow_constructible_v<_Ty, _ArgTypes...>) /* strengthened */ {
+        // emplace alternative _Ty from _Args...
+        this->_Reset();
+        return _Emplace_valueless<_Idx>(static_cast<_ArgTypes&&>(_Args)...);
+    }
+    template <class _Ty, class _Elem, class... _ArgTypes, size_t _Idx = _Meta_find_unique_index<variant, _Ty>::value,
+        enable_if_t<_Idx != _Meta_npos && is_constructible_v<_Ty, initializer_list<_Elem>&, _ArgTypes...>, int> = 0>
+    _CONSTEXPR20 _Ty& emplace(initializer_list<_Elem> _Ilist, _ArgTypes&&... _Args) noexcept(
+        is_nothrow_constructible_v<_Ty, initializer_list<_Elem>&, _ArgTypes...>) /* strengthened */ {
+        // emplace alternative _Ty from _Ilist and _Args...
+        this->_Reset();
+        return _Emplace_valueless<_Idx>(_Ilist, static_cast<_ArgTypes&&>(_Args)...);
+    }
+
+    template <size_t _Idx, class... _ArgTypes,
+        enable_if_t<is_constructible_v<_Meta_at_c<variant, _Idx>, _ArgTypes...>, int> = 0>
+    _CONSTEXPR20 _Meta_at_c<variant, _Idx>& emplace(_ArgTypes&&... _Args) noexcept(
+        is_nothrow_constructible_v<_Meta_at_c<variant, _Idx>, _ArgTypes...>) /* strengthened */ {
+        // emplace alternative _Idx from _Args...
+        this->_Reset();
+        return _Emplace_valueless<_Idx>(static_cast<_ArgTypes&&>(_Args)...);
+    }
+    template <size_t _Idx, class _Elem, class... _ArgTypes,
+        enable_if_t<is_constructible_v<_Meta_at_c<variant, _Idx>, initializer_list<_Elem>&, _ArgTypes...>, int> = 0>
+    _CONSTEXPR20 _Meta_at_c<variant, _Idx>& emplace(initializer_list<_Elem> _Ilist, _ArgTypes&&... _Args) noexcept(
+        is_nothrow_constructible_v<_Meta_at_c<variant, _Idx>, initializer_list<_Elem>&,
+            _ArgTypes...>) /* strengthened */ {
+        // emplace alternative _Idx from _Ilist and _Args...
+        this->_Reset();
+        return _Emplace_valueless<_Idx>(_Ilist, static_cast<_ArgTypes&&>(_Args)...);
+    }
+
+    using _Mybase::index;
+    using _Mybase::valueless_by_exception;
+
+#ifdef __clang__ // TRANSITION, LLVM-35450
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-lambda-capture"
+#endif // ^^^ workaround ^^^
+    _CONSTEXPR20 void swap(variant& _That) noexcept(
+        conjunction_v<is_nothrow_move_constructible<_Types>..., is_nothrow_swappable<_Types>...>) {
+        // exchange the contained values if *this and _That hold the same alternative, otherwise exchange the values of
+        // the variants themselves
+        static_assert(conjunction_v<is_move_constructible<_Types>...>,
+            "variant<Types...>::swap requires all of the Types... to be move constructible. (N4950 [variant.swap]/1)");
+        static_assert(disjunction_v<negation<is_move_constructible<_Types>>..., conjunction<is_swappable<_Types>...>>,
+            "variant<Types...>::swap requires all of the Types... to be swappable. (N4950 [variant.swap]/2)");
+        if constexpr (conjunction_v<_Is_trivially_swappable<_Types>...>) {
+            using _BaseTy = _Variant_base<_Types...>;
+            _STD swap(static_cast<_BaseTy&>(*this), static_cast<_BaseTy&>(_That));
+        } else if constexpr (sizeof...(_Types) < 32) {
+            // Limit the size of variants that use this quadratic code size implementation of swap.
+            _STD _Variant_raw_visit(index(), _Storage(),
+                [this, &_That](auto _My_ref) noexcept(
+                    conjunction_v<is_nothrow_move_constructible<_Types>..., is_nothrow_swappable<_Types>...>) {
+                    _STD _Variant_raw_visit(_That.index(), _That._Storage(),
+                        [this, &_That, _My_ref](auto _That_ref) noexcept(
+                            conjunction_v<is_nothrow_move_constructible<_Types>..., is_nothrow_swappable<_Types>...>) {
+                            constexpr size_t _That_idx = decltype(_That_ref)::_Idx;
+                            constexpr size_t _My_idx   = decltype(_My_ref)::_Idx;
+                            if constexpr (_My_idx == _That_idx) { // Same alternatives...
+                                if constexpr (_My_idx != variant_npos) { // ...and not valueless, swap directly
+                                    using _STD swap;
+                                    swap(_My_ref._Val, _That_ref._Val); // intentional ADL
+                                }
+                            } else if constexpr (_My_idx == variant_npos) { // *this is valueless, _That is not
+                                this->_Emplace_valueless<_That_idx>(_STD move(_That_ref._Val));
+                                _That.template _Reset<_That_idx>();
+                            } else if constexpr (_That_idx == variant_npos) { // _That is valueless, *this is not
+                                _That._Emplace_valueless<_My_idx>(_STD move(_My_ref._Val));
+                                this->template _Reset<_My_idx>();
+                            } else { // different non-valueless alternatives
+                                auto _Tmp = _STD move(_My_ref._Val);
+                                this->template _Reset<_My_idx>();
+                                this->_Emplace_valueless<_That_idx>(_STD move(_That_ref._Val));
+                                _That.template _Reset<_That_idx>();
+                                _That._Emplace_valueless<_My_idx>(_STD move(_Tmp));
+                            }
+                        });
+                });
+        } else {
+            if (this->_Which == _That._Which) {
+                _STD _Variant_raw_visit(static_cast<size_t>(this->_Which), _That._Storage(),
+                    [this](auto _Ref) noexcept(conjunction_v<is_nothrow_swappable<_Types>...>) {
+                        constexpr size_t _Idx = decltype(_Ref)::_Idx;
+                        if constexpr (_Idx != variant_npos) {
+                            using _STD swap;
+                            swap(_Variant_raw_get<_Idx>(this->_Storage()), _Ref._Val); // intentional ADL
+                        }
+                    });
+            } else {
+                variant _Tmp = _STD move(*this);
+                this->_Emplace_from(_STD move(_That));
+                _That._Emplace_from(_STD move(_Tmp));
+            }
+        }
+    }
+#ifdef __clang__ // TRANSITION, LLVM-35450
+#pragma clang diagnostic pop
+#endif // ^^^ workaround ^^^
+
+private:
+    template <size_t _Idx, class... _ArgTypes>
+    _CONSTEXPR20 _Meta_at_c<variant, _Idx>& _Emplace_valueless(_ArgTypes&&... _Args) noexcept(
+        is_nothrow_constructible_v<_Meta_at_c<variant, _Idx>, _ArgTypes...>) {
+        // initialize alternative _Idx from _Args...
+        _STL_INTERNAL_CHECK(valueless_by_exception());
+        _STD _Construct_in_place(_Storage(), integral_constant<size_t, _Idx>{}, static_cast<_ArgTypes&&>(_Args)...);
+        this->_Set_index(_Idx);
+        return _STD _Variant_raw_get<_Idx>(_Storage());
+    }
+
+    _CONSTEXPR20 void _Emplace_from(variant&& _That) noexcept(conjunction_v<is_nothrow_move_constructible<_Types>...>) {
+        // steal the contained value from _That
+        this->_Reset();
+        _STD _Variant_raw_visit(_That.index(), _That._Storage(),
+            [this](auto _Ref) noexcept(conjunction_v<is_nothrow_move_constructible<_Types>...>) {
+                constexpr size_t _Idx = decltype(_Ref)::_Idx;
+                if constexpr (_Idx != variant_npos) {
+                    this->_Emplace_valueless<_Idx>(_STD move(_Ref._Val));
+                }
+            });
+    }
+};
+
+_EXPORT_STD template <class _Ty, class... _Types>
+_NODISCARD constexpr bool holds_alternative(const variant<_Types...>& _Var) noexcept {
+    // true iff _Var holds alternative _Ty
+    constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
+    if constexpr (_Idx != _Meta_npos) {
+        return _Var.index() == _Idx;
+    } else {
+        static_assert(false, "holds_alternative<T>(const variant<Types...>&) requires T to occur exactly "
+                             "once in Types. (N4971 [variant.get]/1)");
+    }
+}
+
+_EXPORT_STD template <size_t _Idx, class... _Types>
+_NODISCARD constexpr decltype(auto) get(variant<_Types...>& _Var) {
+    // access the contained value of _Var if its _Idx-th alternative is active
+    static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
+    if (_Var.index() == _Idx) {
+        return _STD _Variant_raw_get<_Idx>(_Var._Storage());
+    }
+
+    _STD _Throw_bad_variant_access();
+}
+_EXPORT_STD template <size_t _Idx, class... _Types>
+_NODISCARD constexpr decltype(auto) get(variant<_Types...>&& _Var) {
+    // access the contained value of _Var if its _Idx-th alternative is active
+    static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
+    if (_Var.index() == _Idx) {
+        return _STD _Variant_raw_get<_Idx>(_STD move(_Var)._Storage());
+    }
+
+    _STD _Throw_bad_variant_access();
+}
+_EXPORT_STD template <size_t _Idx, class... _Types>
+_NODISCARD constexpr decltype(auto) get(const variant<_Types...>& _Var) {
+    // access the contained value of _Var if its _Idx-th alternative is active
+    static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
+    if (_Var.index() == _Idx) {
+        return _STD _Variant_raw_get<_Idx>(_Var._Storage());
+    }
+
+    _STD _Throw_bad_variant_access();
+}
+_EXPORT_STD template <size_t _Idx, class... _Types>
+_NODISCARD constexpr decltype(auto) get(const variant<_Types...>&& _Var) {
+    // access the contained value of _Var if its _Idx-th alternative is active
+    static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
+    if (_Var.index() == _Idx) {
+        return _STD _Variant_raw_get<_Idx>(_STD move(_Var)._Storage());
+    }
+
+    _STD _Throw_bad_variant_access();
+}
+
+_EXPORT_STD template <class _Ty, class... _Types>
+_NODISCARD constexpr decltype(auto) get(variant<_Types...>& _Var) {
+    // access the contained value of _Var if its alternative _Ty is active
+    constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
+    if constexpr (_Idx < sizeof...(_Types)) {
+        return _STD get<_Idx>(_Var);
+    } else {
+        static_assert(false, "get<T>(variant<Types...>&) "
+                             "requires T to occur exactly once in Types. (N4971 [variant.get]/8)");
+    }
+}
+_EXPORT_STD template <class _Ty, class... _Types>
+_NODISCARD constexpr decltype(auto) get(variant<_Types...>&& _Var) {
+    // access the contained value of _Var if its alternative _Ty is active
+    constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
+    if constexpr (_Idx < sizeof...(_Types)) {
+        return _STD get<_Idx>(_STD move(_Var));
+    } else {
+        static_assert(false, "get<T>(variant<Types...>&&) "
+                             "requires T to occur exactly once in Types. (N4971 [variant.get]/8)");
+    }
+}
+_EXPORT_STD template <class _Ty, class... _Types>
+_NODISCARD constexpr decltype(auto) get(const variant<_Types...>& _Var) {
+    // access the contained value of _Var if its alternative _Ty is active
+    constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
+    if constexpr (_Idx < sizeof...(_Types)) {
+        return _STD get<_Idx>(_Var);
+    } else {
+        static_assert(false, "get<T>(const variant<Types...>&) "
+                             "requires T to occur exactly once in Types. (N4971 [variant.get]/8)");
+    }
+}
+_EXPORT_STD template <class _Ty, class... _Types>
+_NODISCARD constexpr decltype(auto) get(const variant<_Types...>&& _Var) {
+    // access the contained value of _Var if its alternative _Ty is active
+    constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
+    if constexpr (_Idx < sizeof...(_Types)) {
+        return _STD get<_Idx>(_STD move(_Var));
+    } else {
+        static_assert(false, "get<T>(const variant<Types...>&&) "
+                             "requires T to occur exactly once in Types. (N4971 [variant.get]/8)");
+    }
+}
+
+_EXPORT_STD template <size_t _Idx, class... _Types>
+_NODISCARD constexpr auto get_if(variant<_Types...>* _Ptr) noexcept {
+    // get the address of *_Ptr's contained value if it holds alternative _Idx
+    static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
+    return _Ptr && _Ptr->index() == _Idx ? _STD addressof(_STD _Variant_raw_get<_Idx>(_Ptr->_Storage())) : nullptr;
+}
+_EXPORT_STD template <size_t _Idx, class... _Types>
+_NODISCARD constexpr auto get_if(const variant<_Types...>* _Ptr) noexcept {
+    // get the address of *_Ptr's contained value if it holds alternative _Idx
+    static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
+    return _Ptr && _Ptr->index() == _Idx ? _STD addressof(_STD _Variant_raw_get<_Idx>(_Ptr->_Storage())) : nullptr;
+}
+
+_EXPORT_STD template <class _Ty, class... _Types>
+_NODISCARD constexpr add_pointer_t<_Ty> get_if(variant<_Types...>* _Ptr) noexcept {
+    // get the address of *_Ptr's contained value if it holds alternative _Ty
+    constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
+    if constexpr (_Idx != _Meta_npos) {
+        return _STD get_if<_Idx>(_Ptr);
+    } else {
+        static_assert(false,
+            "get_if<T>(variant<Types...> *) requires T to occur exactly once in Types. (N4971 [variant.get]/12)");
+    }
+}
+_EXPORT_STD template <class _Ty, class... _Types>
+_NODISCARD constexpr add_pointer_t<const _Ty> get_if(const variant<_Types...>* _Ptr) noexcept {
+    // get the address of *_Ptr's contained value if it holds alternative _Ty
+    constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
+    if constexpr (_Idx != _Meta_npos) {
+        return _STD get_if<_Idx>(_Ptr);
+    } else {
+        static_assert(false,
+            "get_if<T>(const variant<Types...> *) requires T to occur exactly once in Types. (N4971 [variant.get]/12)");
+    }
+}
+
+template <class _Op, class _Result, class... _Types>
+struct _Variant_relop_visitor2 { // evaluate _Op with the contained value of two variants that hold the same alternative
+    const _Variant_storage<_Types...>& _Left;
+
+    template <class _Ty, size_t _Idx>
+    _NODISCARD constexpr _Result operator()(_Tagged<const _Ty&, _Idx> _Right) const
+        noexcept(disjunction_v<bool_constant<_Idx == variant_npos>,
+            is_nothrow_invocable_r<_Result, _Op, const _Ty&, const _Ty&>>) {
+        // determine the relationship between the stored values of _Left and _Right
+        // pre: _Left.index() == _Idx && _Right.index() == _Idx
+        if constexpr (_Idx != variant_npos) {
+            return _Op{}(_STD _Variant_raw_get<_Idx>(_Left), _Right._Val);
+        } else { // return whatever _Op returns for equal values
+            return _Op{}(0, 0);
+        }
+    }
+};
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD constexpr bool operator==(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
+    conjunction_v<is_nothrow_invocable_r<bool, equal_to<>, const _Types&, const _Types&>...>) /* strengthened */ {
+    // determine if the arguments are both valueless or contain equal values
+    using _Visitor            = _Variant_relop_visitor2<equal_to<>, bool, _Types...>;
+    const size_t _Right_index = _Right.index();
+    return _Left.index() == _Right_index
+        && _STD _Variant_raw_visit(_Right_index, _Right._Storage(), _Visitor{_Left._Storage()});
+}
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD constexpr bool operator!=(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
+    conjunction_v<is_nothrow_invocable_r<bool, not_equal_to<>, const _Types&, const _Types&>...>) /* strengthened */ {
+    // determine if the arguments have different active alternatives or contain unequal values
+    using _Visitor            = _Variant_relop_visitor2<not_equal_to<>, bool, _Types...>;
+    const size_t _Right_index = _Right.index();
+    return _Left.index() != _Right_index
+        || _STD _Variant_raw_visit(_Right_index, _Right._Storage(), _Visitor{_Left._Storage()});
+}
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD constexpr bool operator<(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
+    conjunction_v<is_nothrow_invocable_r<bool, less<>, const _Types&, const _Types&>...>) /* strengthened */ {
+    // determine if _Left has a lesser index(), or equal index() and lesser
+    // contained value than _Right
+    using _Visitor             = _Variant_relop_visitor2<less<>, bool, _Types...>;
+    const size_t _Left_offset  = _Left.index() + 1;
+    const size_t _Right_offset = _Right.index() + 1;
+    return _Left_offset < _Right_offset
+        || (_Left_offset == _Right_offset
+            && _STD _Variant_raw_visit(_Right_offset - 1, _Right._Storage(), _Visitor{_Left._Storage()}));
+}
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD constexpr bool operator>(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
+    conjunction_v<is_nothrow_invocable_r<bool, greater<>, const _Types&, const _Types&>...>) /* strengthened */ {
+    // determine if _Left has a greater index(), or equal index() and
+    // greater contained value than _Right
+    using _Visitor             = _Variant_relop_visitor2<greater<>, bool, _Types...>;
+    const size_t _Left_offset  = _Left.index() + 1;
+    const size_t _Right_offset = _Right.index() + 1;
+    return _Left_offset > _Right_offset
+        || (_Left_offset == _Right_offset
+            && _STD _Variant_raw_visit(_Right_offset - 1, _Right._Storage(), _Visitor{_Left._Storage()}));
+}
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD constexpr bool operator<=(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
+    conjunction_v<is_nothrow_invocable_r<bool, less_equal<>, const _Types&, const _Types&>...>) /* strengthened */ {
+    // determine if _Left's index() is less than _Right's, or equal and
+    // _Left contains a value less than or equal to _Right
+    using _Visitor             = _Variant_relop_visitor2<less_equal<>, bool, _Types...>;
+    const size_t _Left_offset  = _Left.index() + 1;
+    const size_t _Right_offset = _Right.index() + 1;
+    return _Left_offset < _Right_offset
+        || (_Left_offset == _Right_offset
+            && _STD _Variant_raw_visit(_Right_offset - 1, _Right._Storage(), _Visitor{_Left._Storage()}));
+}
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD constexpr bool operator>=(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
+    conjunction_v<is_nothrow_invocable_r<bool, greater_equal<>, const _Types&, const _Types&>...>) /* strengthened */ {
+    // determine if _Left's index() is greater than _Right's, or equal and
+    // _Left contains a value greater than or equal to _Right
+    using _Visitor             = _Variant_relop_visitor2<greater_equal<>, bool, _Types...>;
+    const size_t _Left_offset  = _Left.index() + 1;
+    const size_t _Right_offset = _Right.index() + 1;
+    return _Left_offset > _Right_offset
+        || (_Left_offset == _Right_offset
+            && _STD _Variant_raw_visit(_Right_offset - 1, _Right._Storage(), _Visitor{_Left._Storage()}));
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class... _Types>
+    requires (three_way_comparable<_Types> && ...)
+_NODISCARD constexpr common_comparison_category_t<compare_three_way_result_t<_Types>...>
+    operator<=>(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
+        conjunction_v<is_nothrow_invocable_r<common_comparison_category_t<compare_three_way_result_t<_Types>...>,
+            compare_three_way, const _Types&, const _Types&>...>) /* strengthened */ {
+    // determine the three-way comparison of _Left's and _Right's index, if equal
+    // return the three-way comparison of the contained values of _Left and _Right
+    using _Visitor             = _Variant_relop_visitor2<compare_three_way,
+        common_comparison_category_t<compare_three_way_result_t<_Types>...>, _Types...>;
+    const size_t _Left_offset  = _Left.index() + 1;
+    const size_t _Right_offset = _Right.index() + 1;
+    const auto _Offset_order   = _Left_offset <=> _Right_offset;
+    return _Offset_order != 0
+             ? _Offset_order
+             : _STD _Variant_raw_visit(_Right_offset - 1, _Right._Storage(), _Visitor{_Left._Storage()});
+}
+#endif // _HAS_CXX20
+
+template <class... _Variants>
+constexpr size_t _Variant_total_states =
+    (size_t{1} * ... * (variant_size_v<_Variants> + 1)); // +1 to account for the valueless state
+
+_NODISCARD constexpr size_t _Variant_visit_index1(const size_t _Acc) noexcept {
+    return _Acc;
+}
+template <class _FirstTy, class... _RestTys>
+_NODISCARD constexpr size_t _Variant_visit_index1(
+    size_t _Acc, const _FirstTy& _First, const _RestTys&... _Rest) noexcept {
+    // calculate a canonical index from the biased indices of the variants _First and _Rest...
+    _Acc += (_First.index() + 1) * _Variant_total_states<_RestTys...>;
+    return _STD _Variant_visit_index1(_Acc, _Rest...);
+}
+
+template <class _Callable, class... _Types>
+using _Variant_visit_result_t =
+    decltype(_STD invoke(_STD declval<_Callable>(), _STD _Variant_raw_get<0>(_STD declval<_Types>()._Storage())...));
+
+template <class>
+struct _Variant_dispatcher;
+
+template <size_t... _Is>
+struct _Variant_dispatcher<index_sequence<_Is...>> {
+    template <class _Ret, class _Callable, class... _Types, bool _Any_valueless = ((_Is == 0) || ...)>
+    _NODISCARD static constexpr _Ret _Dispatch2(_Callable&& _Obj, _Types&&... _Args) {
+        if constexpr (_Any_valueless) {
+#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, VSO-1513409
+            ((void) _Args, ...);
+#endif // ^^^ workaround ^^^
+            _STD _Throw_bad_variant_access();
+        }
+#if _HAS_CXX20
+        else if constexpr (is_void_v<_Ret>) {
+            static_cast<void>(_STD invoke(static_cast<_Callable&&>(_Obj),
+                _STD _Variant_raw_get<_Is - 1>(static_cast<_Types&&>(_Args)._Storage())...));
+        }
+#endif // _HAS_CXX20
+        else {
+            return _STD invoke(static_cast<_Callable&&>(_Obj),
+                _STD _Variant_raw_get<_Is - 1>(static_cast<_Types&&>(_Args)._Storage())...);
+        }
+    }
+};
+
+template <class _Ret, class _Ordinals, class _Callable, class _Variants>
+struct _Variant_dispatch_table; // undefined
+
+template <class _Ret, class... _Ordinals, class _Callable, class... _Variants>
+struct _Variant_dispatch_table<_Ret, _Meta_list<_Ordinals...>, _Callable, _Meta_list<_Variants...>> {
+    // map from canonical index to visitation target
+    using _Dispatch_t                     = _Ret (*)(_Callable&&, _Variants&&...);
+    static constexpr _Dispatch_t _Array[] = {
+        &_Variant_dispatcher<_Ordinals>::template _Dispatch2<_Ret, _Callable, _Variants...>...};
+};
+
+template <int _Strategy>
+struct _Visit_strategy;
+
+template <>
+struct _Visit_strategy<-1> {
+    // Fallback strategy for visitations with too many total states for the following "switch" strategies.
+    template <class _Ret, class _ListOfIndexVectors, class _Callable, class... _Variants>
+    static constexpr _Ret _Visit2(
+        size_t _Idx, _Callable&& _Obj, _Variants&&... _Args) { // dispatch a visitation with many potential states
+        constexpr size_t _Size = _Variant_total_states<_Remove_cvref_t<_Variants>...>;
+        static_assert(_Size > 256);
+        constexpr auto& _Array =
+            _Variant_dispatch_table<_Ret, _ListOfIndexVectors, _Callable, _Meta_list<_Variants...>>::_Array;
+        return _Array[_Idx](static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...);
+    }
+};
+
+template <>
+struct _Visit_strategy<0> {
+    template <class _Ret, class, class _Callable>
+    static constexpr _Ret _Visit2(size_t, _Callable&& _Obj) { // dispatch a visitation with 4^0 potential states
+        if constexpr (is_void_v<_Ret>) {
+            return static_cast<void>(static_cast<_Callable&&>(_Obj)());
+        } else {
+            return static_cast<_Callable&&>(_Obj)();
+        }
+    }
+};
+
+#define _STL_CASE(n)                                                                                  \
+    case (n):                                                                                         \
+        if constexpr ((n) < _Size) {                                                                  \
+            using _Indices = _Meta_at_c<_ListOfIndexVectors, (n)>;                                    \
+            return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( \
+                static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...);                  \
+        }                                                                                             \
+        _STL_UNREACHABLE;                                                                             \
+        [[fallthrough]]
+
+#define _STL_VISIT_STAMP(stamper, n)                                               \
+    constexpr size_t _Size = _Variant_total_states<_Remove_cvref_t<_Variants>...>; \
+    static_assert(_Size > (n) / 4 && _Size <= (n));                                \
+    switch (_Idx) {                                                                \
+        stamper(0, _STL_CASE);                                                     \
+    default:                                                                       \
+        _STL_UNREACHABLE;                                                          \
+    }
+
+template <>
+struct _Visit_strategy<1> {
+    template <class _Ret, class _ListOfIndexVectors, class _Callable, class... _Variants>
+    static constexpr _Ret _Visit2(size_t _Idx, _Callable&& _Obj, _Variants&&... _Args) {
+        // dispatch a visitation with 4^1 potential states
+        _STL_STAMP(4, _STL_VISIT_STAMP);
+    }
+};
+
+template <>
+struct _Visit_strategy<2> {
+    template <class _Ret, class _ListOfIndexVectors, class _Callable, class... _Variants>
+    static constexpr _Ret _Visit2(size_t _Idx, _Callable&& _Obj, _Variants&&... _Args) {
+        // dispatch a visitation with 4^2 potential states
+        _STL_STAMP(16, _STL_VISIT_STAMP);
+    }
+};
+
+template <>
+struct _Visit_strategy<3> {
+    template <class _Ret, class _ListOfIndexVectors, class _Callable, class... _Variants>
+    static constexpr _Ret _Visit2(size_t _Idx, _Callable&& _Obj, _Variants&&... _Args) {
+        // dispatch a visitation with 4^3 potential states
+        _STL_STAMP(64, _STL_VISIT_STAMP);
+    }
+};
+
+template <>
+struct _Visit_strategy<4> {
+    template <class _Ret, class _ListOfIndexVectors, class _Callable, class... _Variants>
+    static constexpr _Ret _Visit2(size_t _Idx, _Callable&& _Obj, _Variants&&... _Args) {
+        // dispatch a visitation with 4^4 potential states
+        _STL_STAMP(256, _STL_VISIT_STAMP);
+    }
+};
+
+#undef _STL_VISIT_STAMP
+#undef _STL_CASE
+
+template <class... _Types>
+variant<_Types...>& _As_variant_impl(variant<_Types...>&);
+template <class... _Types>
+const variant<_Types...>& _As_variant_impl(const variant<_Types...>&);
+template <class... _Types>
+variant<_Types...>&& _As_variant_impl(variant<_Types...>&&);
+template <class... _Types>
+const variant<_Types...>&& _As_variant_impl(const variant<_Types...>&&);
+template <class _Ty>
+using _As_variant = // Deduce variant specialization from a derived type
+    decltype(_STD _As_variant_impl(_STD declval<_Ty>()));
+
+template <size_t _Size, class _Ret, class _ListOfIndexVectors, class _Callable, class... _Variants>
+constexpr _Ret _Visit_impl(_Callable&& _Obj, _Variants&&... _Args) {
+    constexpr int _Strategy = _Size == 1   ? 0
+                            : _Size <= 4   ? 1
+                            : _Size <= 16  ? 2
+                            : _Size <= 64  ? 3
+                            : _Size <= 256 ? 4
+                                           : -1;
+    return _Visit_strategy<_Strategy>::template _Visit2<_Ret, _ListOfIndexVectors>(
+        _STD _Variant_visit_index1(0, static_cast<_As_variant<_Variants>&>(_Args)...), static_cast<_Callable&&>(_Obj),
+        static_cast<_As_variant<_Variants>&&>(_Args)...);
+}
+
+template <class _Expected, class _Callable, class _ArgList, class... _Variants>
+constexpr bool _Variant_all_visit_results_same = false;
+
+template <class _Expected, class _Callable, class... _Args>
+constexpr bool _Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args...>> =
+    is_same_v<decltype(_STD invoke(_STD declval<_Callable>(), _STD declval<_Args>()...)), _Expected>;
+
+template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
+constexpr bool
+    _Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args...>, variant<_Types...>&, _Rest...> =
+        (_Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args..., _Types&>, _Rest...> && ...);
+
+template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
+constexpr bool
+    _Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args...>, const variant<_Types...>&, _Rest...> =
+        (_Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args..., const _Types&>, _Rest...> && ...);
+
+template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
+constexpr bool
+    _Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args...>, variant<_Types...>&&, _Rest...> =
+        (_Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args..., _Types>, _Rest...> && ...);
+
+template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
+constexpr bool
+    _Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args...>, const variant<_Types...>&&, _Rest...> =
+        (_Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args..., const _Types>, _Rest...> && ...);
+
+_EXPORT_STD template <class _Callable, class... _Variants, class = void_t<_As_variant<_Variants>...>>
+constexpr _Variant_visit_result_t<_Callable, _As_variant<_Variants>...> visit(_Callable&& _Obj, _Variants&&... _Args) {
+    // Invoke _Obj with the contained values of _Args...
+    constexpr auto _Size = _Variant_total_states<_Remove_cvref_t<_As_variant<_Variants>>...>;
+    using _ListOfIndexLists =
+        _Meta_list<_Meta_as_list<make_index_sequence<1 + variant_size_v<_Remove_cvref_t<_As_variant<_Variants>>>>>...>;
+    using _ListOfIndexVectors =
+        _Meta_transform<_Meta_quote<_Meta_as_integer_sequence>, _Meta_cartesian_product<_ListOfIndexLists>>;
+    using _Ret = _Variant_visit_result_t<_Callable, _As_variant<_Variants>...>;
+    static_assert(_Variant_all_visit_results_same<_Ret, _Callable, _Meta_list<>, _As_variant<_Variants>...>,
+        "visit() requires the result of all potential invocations to have the same type and value category "
+        "(N4950 [variant.visit]/5).");
+
+    return _STD _Visit_impl<_Size, _Ret, _ListOfIndexVectors>(
+        static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...);
+}
+
+#if _HAS_CXX20
+template <class _Expected, class _Callable, class _ArgList, class... _Variants>
+constexpr bool _Variant_all_visit_results_convertible = false;
+
+template <class _Expected, class _Callable, class... _Args>
+constexpr bool _Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args...>> =
+    _Invoke_convertible<decltype(_STD invoke(_STD declval<_Callable>(), _STD declval<_Args>()...)), _Expected>::value;
+
+template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
+constexpr bool
+    _Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args...>, variant<_Types...>&, _Rest...> =
+        (_Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args..., _Types&>, _Rest...> && ...);
+
+template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
+constexpr bool _Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args...>,
+    const variant<_Types...>&, _Rest...> =
+    (_Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args..., const _Types&>, _Rest...>
+        && ...);
+
+template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
+constexpr bool
+    _Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args...>, variant<_Types...>&&, _Rest...> =
+        (_Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args..., _Types>, _Rest...> && ...);
+
+template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
+constexpr bool _Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args...>,
+    const variant<_Types...>&&, _Rest...> =
+    (_Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args..., const _Types>, _Rest...> && ...);
+
+_EXPORT_STD template <class _Ret, class _Callable, class... _Variants, class = void_t<_As_variant<_Variants>...>>
+constexpr _Ret visit(_Callable&& _Obj, _Variants&&... _Args) {
+    constexpr auto _Size = _Variant_total_states<_Remove_cvref_t<_As_variant<_Variants>>...>;
+    using _ListOfIndexLists =
+        _Meta_list<_Meta_as_list<make_index_sequence<1 + variant_size_v<_Remove_cvref_t<_As_variant<_Variants>>>>>...>;
+    using _ListOfIndexVectors =
+        _Meta_transform<_Meta_quote<_Meta_as_integer_sequence>, _Meta_cartesian_product<_ListOfIndexLists>>;
+    if constexpr (!is_void_v<_Ret>) {
+        static_assert(_Variant_all_visit_results_convertible<_Ret, _Callable, _Meta_list<>, _As_variant<_Variants>...>,
+            "visit<R>() requires the result of all potential invocations to be implicitly convertible to R "
+            "(N4950 [variant.visit]/5).");
+    }
+
+    return _STD _Visit_impl<_Size, _Ret, _ListOfIndexVectors>(
+        static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...);
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD _NODISCARD constexpr bool operator==(monostate, monostate) noexcept {
+    return true;
+}
+
+#if _HAS_CXX20
+_EXPORT_STD _NODISCARD constexpr strong_ordering operator<=>(monostate, monostate) noexcept {
+    return strong_ordering::equal;
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+_NODISCARD constexpr bool operator!=(monostate, monostate) noexcept {
+    return false;
+}
+_NODISCARD constexpr bool operator<(monostate, monostate) noexcept {
+    return false;
+}
+_NODISCARD constexpr bool operator>(monostate, monostate) noexcept {
+    return false;
+}
+_NODISCARD constexpr bool operator<=(monostate, monostate) noexcept {
+    return true;
+}
+_NODISCARD constexpr bool operator>=(monostate, monostate) noexcept {
+    return true;
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+_EXPORT_STD template <class... _Types,
+    enable_if_t<conjunction_v<is_move_constructible<_Types>..., is_swappable<_Types>...>, int> = 0>
+_CONSTEXPR20 void swap(variant<_Types...>& _Left, variant<_Types...>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+
+struct _Variant_hash_visitor { // visitation function for hashing variants
+    template <class _Ty, size_t _Idx>
+    _NODISCARD _STATIC_CALL_OPERATOR size_t operator()(_Tagged<const _Ty&, _Idx> _Obj) _CONST_CALL_OPERATOR
+        noexcept(disjunction_v<bool_constant<_Idx == variant_npos>,
+            is_nothrow_invocable<hash<_Ty>, const _Ty&>>) { // hash contained value _Obj
+        if constexpr (_Idx == variant_npos) { // hash a valueless variant
+            return 0;
+        } else { // hash the contained value
+            return hash<_Ty>{}(_Obj._Val);
+        }
+    }
+};
+
+template <class... _Types>
+struct hash<variant<_Types...>> : _Conditionally_enabled_hash<variant<_Types...>,
+                                      conjunction_v<is_default_constructible<hash<remove_const_t<_Types>>>...>> {
+    _NODISCARD static size_t _Do_hash(const variant<_Types...>& _Var) noexcept(
+        conjunction_v<_Is_nothrow_hashable<remove_const_t<_Types>>...>) {
+        // called from the CRTP base to hash _Var iff the hash is enabled
+        return _STD _Variant_raw_visit(_Var.index(), _Var._Storage(), _Variant_hash_visitor{});
+    }
+};
+
+template <>
+struct hash<monostate> {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = monostate;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
+
+    _NODISCARD _STATIC_CALL_OPERATOR size_t operator()(monostate) _CONST_CALL_OPERATOR noexcept {
+        return 1729; // Arbitrary value
+    }
+};
+
+_STD_END
+
+#undef _STL_STAMP
+#undef _STL_STAMP256
+#undef _STL_STAMP64
+#undef _STL_STAMP16
+#undef _STL_STAMP4
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ _HAS_CXX17 ^^^
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _VARIANT_

miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcclr.h

@@ -0,0 +1,53 @@
+//
+//	vcclr.h - helper code for using the managed extensions to C++
+//
+//	Copyright (C) Microsoft Corporation
+//	All rights reserved.
+//
+
+#if _MSC_VER > 1000
+#pragma once
+#endif
+
+#if !defined(_INC_VCCLR)
+#define _INC_VCCLR
+#ifndef RC_INVOKED
+
+#include <gcroot.h>
+
+#pragma warning(push)
+#pragma warning(disable:4400)
+
+#ifdef __cplusplus_cli
+typedef cli::interior_ptr<const System::Char> __const_Char_ptr;
+typedef cli::interior_ptr<const System::Byte> __const_Byte_ptr;
+typedef cli::interior_ptr<System::Byte> _Byte_ptr;
+typedef const System::String^ __const_String_handle;
+#define _NULLPTR nullptr
+#else
+typedef const System::Char* __const_Char_ptr;
+typedef const System::Byte* __const_Byte_ptr;
+typedef System::Byte* _Byte_ptr;
+typedef const System::String* __const_String_handle;
+#define _NULLPTR 0
+#endif
+
+
+//
+// get an interior gc pointer to the first character contained in a System::String object
+//
+inline __const_Char_ptr PtrToStringChars(__const_String_handle s) {
+
+	_Byte_ptr bp = const_cast<_Byte_ptr>(reinterpret_cast<__const_Byte_ptr>(s));
+	if( bp != _NULLPTR ) {
+		bp += System::Runtime::CompilerServices::RuntimeHelpers::OffsetToStringData;
+	}
+	return reinterpret_cast<__const_Char_ptr>(bp);
+}
+
+#pragma warning(pop)
+
+#undef _NULLPTR
+
+#endif /* RC_INVOKED */
+#endif //_INC_VCCLR

miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime.h

@@ -0,0 +1,404 @@
+//
+// vcruntime.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Declarations used throughout the VCRuntime library.
+//
+#pragma once
+//
+// Note on use of "deprecate":
+//
+// Various places in this header and other headers use
+// __declspec(deprecate) or macros that have the term DEPRECATE in them.
+// We use "deprecate" here ONLY to signal the compiler to emit a warning
+// about these items. The use of "deprecate" should NOT be taken to imply
+// that any standard committee has deprecated these functions from the
+// relevant standards.  In fact, these functions are NOT deprecated from
+// the standard.
+//
+// Full details can be found in our documentation by searching for
+// "Security Enhancements in the CRT".
+//
+#ifndef _VCRUNTIME_H
+#define _VCRUNTIME_H
+
+#ifndef _VCRT_COMPILER_PREPROCESSOR
+// Many VCRuntime headers avoid exposing their contents to non-compilers like
+// the Windows resource compiler and Qt's meta-object compiler (moc).
+#if defined(RC_INVOKED) || defined(Q_MOC_RUN)
+#define _VCRT_COMPILER_PREPROCESSOR 0
+#else
+#define _VCRT_COMPILER_PREPROCESSOR 1
+#endif
+#endif // _VCRT_COMPILER_PREPROCESSOR
+
+#ifndef _UCRT
+    #define _UCRT
+#endif
+
+// The _CRTIMP macro is not used in the VCRuntime or the CoreCRT anymore, but
+// there is a lot of existing code that declares CRT functions using this macro,
+// and if we remove its definition, we break that existing code.  It is thus
+// defined here only for compatibility.
+#ifndef _CRTIMP
+    #define _VCRT_DEFINED_CRTIMP
+    #if defined CRTDLL && defined _CRTBLD
+        #define _CRTIMP __declspec(dllexport)
+    #else
+        #ifdef _DLL
+            #define _CRTIMP __declspec(dllimport)
+        #else
+            #define _CRTIMP
+        #endif
+    #endif
+#endif
+
+#include <sal.h>
+#include <vadefs.h>
+
+#pragma warning(push)
+#pragma warning(disable: _VCRUNTIME_DISABLED_WARNINGS)
+
+// All C headers have a common prologue and epilogue, to enclose the header in
+// an extern "C" declaration when the header is #included in a C++ translation
+// unit and to push/pop the packing.
+#if defined __cplusplus
+
+    #define _CRT_BEGIN_C_HEADER            \
+        __pragma(pack(push, _CRT_PACKING)) \
+        extern "C" {
+
+    #define _CRT_END_C_HEADER \
+        }                     \
+        __pragma(pack(pop))
+
+#elif defined __midl
+
+    #define _CRT_BEGIN_C_HEADER                         \
+        cpp_quote("__pragma(pack(push, _CRT_PACKING))") \
+        cpp_quote("extern \"C\" {")
+
+    #define _CRT_END_C_HEADER            \
+        cpp_quote("}")                   \
+        cpp_quote("__pragma(pack(pop))")
+
+#else
+
+    #define _CRT_BEGIN_C_HEADER            \
+        __pragma(pack(push, _CRT_PACKING))
+
+    #define _CRT_END_C_HEADER \
+        __pragma(pack(pop))
+
+#endif
+
+_CRT_BEGIN_C_HEADER
+
+
+
+#ifndef _HAS_EXCEPTIONS // Predefine as 0 to disable exceptions
+    #ifdef _KERNEL_MODE
+        #define _HAS_EXCEPTIONS 0
+    #else
+        #define _HAS_EXCEPTIONS 1
+    #endif /* _KERNEL_MODE */
+#endif /* _HAS_EXCEPTIONS */
+
+
+
+#define _CRT_STRINGIZE_(x) #x
+#define _CRT_STRINGIZE(x) _CRT_STRINGIZE_(x)
+
+#define _CRT_WIDE_(s) L ## s
+#define _CRT_WIDE(s) _CRT_WIDE_(s)
+
+#define _CRT_CONCATENATE_(a, b) a ## b
+#define _CRT_CONCATENATE(a, b)  _CRT_CONCATENATE_(a, b)
+
+#define _CRT_UNPARENTHESIZE_(...) __VA_ARGS__
+#define _CRT_UNPARENTHESIZE(...)  _CRT_UNPARENTHESIZE_ __VA_ARGS__
+
+#ifndef _VCRTIMP
+    #if defined _CRTIMP && !defined _VCRT_DEFINED_CRTIMP
+        #define _VCRTIMP _CRTIMP
+    #elif defined _VCRT_BUILD && defined CRTDLL && !defined _VCRT_SAT_1
+        #define _VCRTIMP __declspec(dllexport)
+    #else
+        #define _VCRTIMP
+    #endif
+#endif
+
+#ifndef _MRTIMP
+    #if defined MRTDLL && defined _CRTBLD && !defined _M_CEE_PURE
+        #define _MRTIMP __declspec(dllexport)
+    #else
+        #define _MRTIMP
+    #endif
+#endif
+
+// Definitions of calling conventions used code sometimes compiled as managed
+#if defined _M_CEE_PURE || defined MRTDLL
+    #define __CLRCALL_OR_CDECL __clrcall
+    #define __CLR_OR_THIS_CALL __clrcall
+#else
+    #define __CLRCALL_OR_CDECL __cdecl
+    #define __CLR_OR_THIS_CALL
+#endif
+
+#ifdef _M_CEE_PURE
+    #define __CLRCALL_PURE_OR_CDECL __clrcall
+#else
+    #define __CLRCALL_PURE_OR_CDECL __cdecl
+#endif
+
+#define __CRTDECL __CLRCALL_PURE_OR_CDECL
+
+// Definitions of common __declspecs
+#define _VCRT_NOALIAS __declspec(noalias)
+#define _VCRT_RESTRICT __declspec(restrict)
+#define _VCRT_ALLOCATOR __declspec(allocator)
+
+#if defined _M_CEE && defined _M_X64
+    #define _VCRT_JIT_INTRINSIC __declspec(jitintrinsic)
+#else
+    #define _VCRT_JIT_INTRINSIC
+#endif
+
+#ifdef __midl
+    #define _VCRT_ALIGN(x)
+#else
+    #define _VCRT_ALIGN(x) __declspec(align(x))
+#endif
+
+#ifndef _CONST_RETURN
+    #ifdef __cplusplus
+        #define _CRT_CONST_CORRECT_OVERLOADS
+        #define _CONST_RETURN  const
+    #else
+      #define _CONST_RETURN
+    #endif
+#endif
+
+// For backwards compatibility
+#define _WConst_return _CONST_RETURN
+
+// Definitions of common types
+#ifdef _WIN64
+    typedef unsigned __int64 size_t;
+    typedef __int64          ptrdiff_t;
+    typedef __int64          intptr_t;
+#else
+    typedef unsigned int     size_t;
+    typedef int              ptrdiff_t;
+    typedef int              intptr_t;
+#endif
+
+#if defined __cplusplus
+    typedef bool  __vcrt_bool;
+#elif defined __midl
+    // MIDL understands neither bool nor _Bool.  Use char as a best-fit
+    // replacement (the differences won't matter in practice).
+    typedef char __vcrt_bool;
+#else
+    typedef _Bool __vcrt_bool;
+#endif
+
+// Indicate that these common types are defined
+#ifndef _SIZE_T_DEFINED
+    #define _SIZE_T_DEFINED
+#endif
+
+#ifndef _PTRDIFF_T_DEFINED
+    #define _PTRDIFF_T_DEFINED
+#endif
+
+#ifndef _INTPTR_T_DEFINED
+    #define _INTPTR_T_DEFINED
+#endif
+
+// Provide a typedef for wchar_t for use under /Zc:wchar_t-
+#ifndef _WCHAR_T_DEFINED
+    #define _WCHAR_T_DEFINED
+    typedef unsigned short wchar_t;
+#endif
+
+#ifndef NULL
+    #ifdef __cplusplus
+        #define NULL 0
+    #else
+        #define NULL ((void *)0)
+    #endif
+#endif
+
+#if defined _M_X64 || defined _M_ARM || defined _M_ARM64
+    #define _UNALIGNED __unaligned
+#else
+    #define _UNALIGNED
+#endif
+
+#if defined _M_ARM64EC
+    #define __security_check_cookie __security_check_cookie_arm64ec
+#endif
+
+#ifdef __cplusplus
+    extern "C++"
+    {
+        template <typename _CountofType, size_t _SizeOfArray>
+        char (*__countof_helper(_UNALIGNED _CountofType (&_Array)[_SizeOfArray]))[_SizeOfArray];
+
+        #define __crt_countof(_Array) (sizeof(*__countof_helper(_Array)) + 0)
+    }
+#else
+    #define __crt_countof(_Array) (sizeof(_Array) / sizeof(_Array[0]))
+#endif
+
+#if defined(_M_IX86) && defined(_CRT_LEGACY_X86_FLT_EXCEPTIONS) && !defined(_M_CEE_PURE)
+    #pragma comment(lib, "legacy_x86_flt_exceptions")
+#endif
+
+#ifdef __cplusplus
+    #if defined(_MSVC_LANG) && _MSVC_LANG > __cplusplus
+        #define _STL_LANG _MSVC_LANG
+    #else  // ^^^ language mode is _MSVC_LANG / language mode is __cplusplus vvv
+        #define _STL_LANG __cplusplus
+    #endif // ^^^ language mode is larger of _MSVC_LANG and __cplusplus ^^^
+#else  // ^^^ determine compiler's C++ mode / no C++ support vvv
+    #define _STL_LANG 0L
+#endif // ^^^ no C++ support ^^^
+
+#ifndef _HAS_CXX17
+    #if _STL_LANG > 201402L
+        #define _HAS_CXX17 1
+    #else
+        #define _HAS_CXX17 0
+    #endif
+#endif // _HAS_CXX17
+
+#ifndef _HAS_CXX20
+    #if _HAS_CXX17 && _STL_LANG > 201703L
+        #define _HAS_CXX20 1
+    #else
+        #define _HAS_CXX20 0
+    #endif
+#endif // _HAS_CXX20
+
+#ifndef _HAS_CXX23
+    #if _HAS_CXX20 && _STL_LANG > 202002L
+        #define _HAS_CXX23 1
+    #else
+        #define _HAS_CXX23 0
+    #endif
+#endif // _HAS_CXX23
+
+#undef _STL_LANG
+
+#if _HAS_CXX20 && !_HAS_CXX17
+    #error _HAS_CXX20 must imply _HAS_CXX17.
+#endif
+
+#if _HAS_CXX23 && !_HAS_CXX20
+    #error _HAS_CXX23 must imply _HAS_CXX20.
+#endif
+
+// [[nodiscard]] attributes on STL functions
+#ifndef _HAS_NODISCARD
+    #ifndef __has_cpp_attribute
+        #define _HAS_NODISCARD 0
+    #elif __has_cpp_attribute(nodiscard) >= 201603L // TRANSITION, VSO#939899 (need toolset update)
+        #define _HAS_NODISCARD 1
+    #else
+        #define _HAS_NODISCARD 0
+    #endif
+#endif // _HAS_NODISCARD
+
+#if _HAS_NODISCARD
+    #define _NODISCARD [[nodiscard]]
+#else // ^^^ CAN HAZ [[nodiscard]] / NO CAN HAZ [[nodiscard]] vvv
+    #define _NODISCARD
+#endif // _HAS_NODISCARD
+
+#pragma push_macro("msvc")
+#pragma push_macro("constexpr")
+#undef msvc
+#undef constexpr
+
+// Determine if we should use [[msvc::constexpr]] to allow for "extended constexpr"
+// in Visual C++.
+#ifndef _MSVC_CONSTEXPR
+    #ifdef _MSVC_CONSTEXPR_ATTRIBUTE
+        #define _MSVC_CONSTEXPR [[msvc::constexpr]]
+    #else
+        #define _MSVC_CONSTEXPR
+    #endif
+#endif
+
+#pragma pop_macro("constexpr")
+#pragma pop_macro("msvc")
+
+#ifdef _BUILD_STD_MODULE
+    #define _VCRT_EXPORT_STD export
+#else // ^^^ defined(_BUILD_STD_MODULE) / !defined(_BUILD_STD_MODULE) vvv
+    #define _VCRT_EXPORT_STD
+#endif // ^^^ !defined(_BUILD_STD_MODULE) ^^^
+
+// See note on use of "deprecate" at the top of this file
+#define _CRT_DEPRECATE_TEXT(_Text) __declspec(deprecated(_Text))
+
+#if defined _CRT_SECURE_NO_DEPRECATE && !defined _CRT_SECURE_NO_WARNINGS
+    #define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#ifndef _CRT_INSECURE_DEPRECATE
+    #ifdef _CRT_SECURE_NO_WARNINGS
+        #define _CRT_INSECURE_DEPRECATE(_Replacement)
+    #else
+        #define _CRT_INSECURE_DEPRECATE(_Replacement) _CRT_DEPRECATE_TEXT(    \
+            "This function or variable may be unsafe. Consider using "        \
+            #_Replacement                                                     \
+            " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " \
+            "See online help for details.")
+    #endif
+#endif
+
+#if defined _CRT_SECURE_DEPRECATE_MEMORY && !defined _CRT_SECURE_WARNINGS_MEMORY
+    #define _CRT_SECURE_WARNINGS_MEMORY
+#endif
+
+#ifndef _CRT_INSECURE_DEPRECATE_MEMORY
+    #ifndef _CRT_SECURE_WARNINGS_MEMORY
+        #define _CRT_INSECURE_DEPRECATE_MEMORY(_Replacement)
+    #else
+        #define _CRT_INSECURE_DEPRECATE_MEMORY(_Replacement) \
+            _CRT_INSECURE_DEPRECATE(_Replacement)
+    #endif
+#endif
+
+#if !defined _M_CEE && !defined __midl
+    void __cdecl __security_init_cookie(void);
+
+    #if defined(_M_IX86)
+        void __fastcall __security_check_cookie(_In_ uintptr_t _StackCookie);
+        __declspec(noreturn) void __cdecl __report_gsfailure(void);
+    #elif defined(_M_ARM64EC)
+        void __cdecl __security_check_cookie_arm64ec(_In_ uintptr_t _StackCookie);
+        __declspec(noreturn) void __cdecl __report_gsfailure(_In_ uintptr_t _StackCookie);
+    #else
+        void __cdecl __security_check_cookie(_In_ uintptr_t _StackCookie);
+        __declspec(noreturn) void __cdecl __report_gsfailure(_In_ uintptr_t _StackCookie);
+    #endif
+#endif
+
+extern uintptr_t __security_cookie;
+
+#ifndef _VCRT_BUILD
+    #define __vcrt_malloc_normal(_Size) malloc(_Size)
+    #define __vcrt_calloc_normal(_Count, _Size) calloc(_Count, _Size)
+    #define __vcrt_free_normal(_Memory) free(_Memory)
+#endif
+
+_CRT_END_C_HEADER
+
+#pragma warning(pop) // _VCRUNTIME_DISABLED_WARNINGS
+
+#endif // _VCRUNTIME_H

miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime_c11_atomic_support.h

@@ -0,0 +1,1127 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// C11 atomic support routines
+#pragma once
+
+#ifdef __cplusplus
+// this header should never be included in c++ mode, but if it is
+// we need to catch it because the content of this header is provided by
+// the STL's <atomic> header in C++
+#error "vcruntime_c11_atomic_support.h is a C-only header"
+#endif // __cplusplus
+
+#include <crtdbg.h>
+#include <intrin0.h>
+#include <stdint.h>
+#include <vcruntime_string.h>
+
+// code from xatomic.h
+#define _CONCATX(x, y) x##y
+#define _CONCAT(x, y)  _CONCATX(x, y)
+
+// Interlocked intrinsic mapping for _nf/_acq/_rel
+#if defined(_M_CEE_PURE) || (defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)) || (defined(_M_X64) && !defined(_M_ARM64EC))
+#define _INTRIN_RELAXED(x) x
+#define _INTRIN_ACQUIRE(x) x
+#define _INTRIN_RELEASE(x) x
+#define _INTRIN_ACQ_REL(x) x
+#ifdef _M_CEE_PURE
+#define _YIELD_PROCESSOR()
+#else // ^^^ _M_CEE_PURE / !_M_CEE_PURE vvv
+#define _YIELD_PROCESSOR() _mm_pause()
+#endif // ^^^ !_M_CEE_PURE ^^^
+
+#elif defined(_M_ARM) || defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+#define _INTRIN_RELAXED(x) _CONCAT(x, _nf)
+#define _INTRIN_ACQUIRE(x) _CONCAT(x, _acq)
+#define _INTRIN_RELEASE(x) _CONCAT(x, _rel)
+// We don't have interlocked intrinsics for acquire-release ordering, even on
+// ARM32/ARM64, so fall back to sequentially consistent.
+#define _INTRIN_ACQ_REL(x) x
+#define _YIELD_PROCESSOR() __yield()
+
+#else // ^^^ ARM32/ARM64/ARM64EC/HYBRID_X86_ARM64 / unsupported hardware vvv
+#error Unsupported hardware
+#endif // hardware
+// end code from xatomic.h
+
+
+// The following is modified from the _CRT_SECURE_INVALID_PARAMETER macro in
+// corecrt.h. We need to do this because this header must be C, not C++, but we
+// still want to report invalid parameters in the same way as C++ does. The
+// macro in the CRT expands to C++ code because it contains global namespace
+// qualification. This can be fixed in the ucrt by using a mechanism that
+// defines something like _GLOBAL_NAMESPACE to :: in c++ mode and nothing in C
+// mode.
+#ifndef _ATOMIC_INVALID_PARAMETER
+#ifdef _DEBUG
+#define _ATOMIC_INVALID_PARAMETER(expr) _invalid_parameter(_CRT_WIDE(#expr), L"", __FILEW__, __LINE__, 0)
+#else
+// By default, _ATOMIC_INVALID_PARAMETER in retail invokes
+// _invalid_parameter_noinfo_noreturn(), which is marked
+// __declspec(noreturn) and does not return control to the application.
+// Even if _set_invalid_parameter_handler() is used to set a new invalid
+// parameter handler which does return control to the application,
+// _invalid_parameter_noinfo_noreturn() will terminate the application
+// and invoke Watson. You can overwrite the definition of
+// _ATOMIC_INVALID_PARAMETER if you need.
+#define _ATOMIC_INVALID_PARAMETER(expr) _invalid_parameter_noinfo_noreturn()
+#endif
+#endif
+
+// The following code is SHARED between the STL's <atomic> header and vcruntime's
+// vcruntime_c11_atomic_support.h header. Any updates should be mirrored.
+// Also: if any macros are added they should be #undefed in both headers
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+#define _STD_ATOMIC_USE_ARM64_LDAR_STLR 1
+#ifdef __clang__
+#define __LOAD_ACQUIRE_ARM64(_Width, _Ptr) \
+    (__int##_Width)(__atomic_load_n((const volatile unsigned __int##_Width*)(_Ptr), 2))
+#define __STORE_RELEASE(_Width, _Ptr, _Desired) \
+    _Compiler_barrier();                        \
+    __atomic_store_n((volatile unsigned __int##_Width*)(_Ptr), (unsigned __int##_Width)(_Desired), 3)
+#else // ^^^ Clang / MSVC vvv
+#define __LOAD_ACQUIRE_ARM64(_Width, _Ptr) \
+    (__int##_Width)(__load_acquire##_Width((const volatile unsigned __int##_Width*)(_Ptr)))
+#define __STORE_RELEASE(_Width, _Ptr, _Desired) \
+    _Compiler_barrier();                        \
+    __stlr##_Width(                             \
+        (volatile unsigned __int##_Width*)(_Ptr), (unsigned __int##_Width)(_Desired))
+#endif // ^^^ MSVC ^^^
+#else // ^^^ ARM64/ARM64EC/HYBRID_X86_ARM64 / Other architectures vvv
+#define _STD_ATOMIC_USE_ARM64_LDAR_STLR 0
+#define __STORE_RELEASE(_Width, _Ptr, _Desired) \
+    _Compiler_or_memory_barrier();              \
+    __iso_volatile_store##_Width((_Ptr), (_Desired))
+#endif // ^^^ Other architectures ^^^
+
+enum {
+    _Atomic_memory_order_relaxed,
+    _Atomic_memory_order_consume,
+    _Atomic_memory_order_acquire,
+    _Atomic_memory_order_release,
+    _Atomic_memory_order_acq_rel,
+    _Atomic_memory_order_seq_cst,
+};
+
+#ifndef _INVALID_MEMORY_ORDER
+#ifdef _DEBUG
+#define _INVALID_MEMORY_ORDER                              \
+    do {                                                   \
+        _RPTF0(_CRT_ASSERT, "Invalid memory order");       \
+        _ATOMIC_INVALID_PARAMETER("Invalid memory order"); \
+    } while (0)
+#else // ^^^ _DEBUG / !_DEBUG vvv
+#define _INVALID_MEMORY_ORDER
+#endif // _DEBUG
+#endif // _INVALID_MEMORY_ORDER
+
+#if defined(_M_ARM) || defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+#define _Memory_barrier()             __dmb(0xB) // inner shared data memory barrier
+#define _Compiler_or_memory_barrier() _Memory_barrier()
+#if defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+#define _Memory_load_acquire_barrier() __dmb(0x9) // inner shared data memory load barrier
+#else // ^^^ ARM64/ARM64EC/HYBRID_X86_ARM64 / ARM32 vvv
+#define _Memory_load_acquire_barrier() _Memory_barrier()
+#endif // ^^^ ARM32 ^^^
+#elif defined(_M_IX86) || defined(_M_X64)
+// x86/x64 hardware only emits memory barriers inside _Interlocked intrinsics
+#define _Compiler_or_memory_barrier() _Compiler_barrier()
+#else // ^^^ x86/x64 / unsupported hardware vvv
+#error Unsupported hardware
+#endif // hardware
+
+inline void _Check_memory_order(const unsigned int _Order) {
+    if (_Order > _Atomic_memory_order_seq_cst) {
+        _INVALID_MEMORY_ORDER;
+    }
+}
+
+// this is different from the STL
+// we are the MSVC runtime so we need not support clang here
+#define _Compiler_barrier()                                                                   \
+    _Pragma("warning(push)") _Pragma("warning(disable : 4996)") /* was declared deprecated */ \
+        _ReadWriteBarrier() _Pragma("warning(pop)")
+
+// note: these macros are _not_ always safe to use with a trailing semicolon,
+// we avoid wrapping them in do {} while (0) because MSVC generates code for such loops
+// in debug mode.
+
+#if (defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)) || (defined(_M_X64) && !defined(_M_ARM64EC))
+#define _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _Intrinsic, ...) \
+    _Check_memory_order(_Order);                                   \
+    _Result = _Intrinsic(__VA_ARGS__)
+#elif defined(_M_ARM) || defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+#define _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _Intrinsic, ...) \
+    switch (_Order) {                                              \
+    case _Atomic_memory_order_relaxed:                             \
+        _Result = _INTRIN_RELAXED(_Intrinsic)(__VA_ARGS__);        \
+        break;                                                     \
+    case _Atomic_memory_order_consume:                             \
+    case _Atomic_memory_order_acquire:                             \
+        _Result = _INTRIN_ACQUIRE(_Intrinsic)(__VA_ARGS__);        \
+        break;                                                     \
+    case _Atomic_memory_order_release:                             \
+        _Result = _INTRIN_RELEASE(_Intrinsic)(__VA_ARGS__);        \
+        break;                                                     \
+    default:                                                       \
+        _INVALID_MEMORY_ORDER;                                     \
+        /* [[fallthrough]]; */                                     \
+    case _Atomic_memory_order_acq_rel:                             \
+    case _Atomic_memory_order_seq_cst:                             \
+        _Result = _Intrinsic(__VA_ARGS__);                         \
+        break;                                                     \
+    }
+#endif // hardware
+
+#if _STD_ATOMIC_USE_ARM64_LDAR_STLR == 1
+
+#define _ATOMIC_LOAD_ARM64(_Result, _Width, _Ptr, _Order_var) \
+    switch (_Order_var) {                                     \
+    case _Atomic_memory_order_relaxed:                        \
+        _Result = __iso_volatile_load##_Width(_Ptr);          \
+        break;                                                \
+    case _Atomic_memory_order_consume:                        \
+    case _Atomic_memory_order_acquire:                        \
+    case _Atomic_memory_order_seq_cst:                        \
+        _Result = __LOAD_ACQUIRE_ARM64(_Width, _Ptr);         \
+        _Compiler_barrier();                                  \
+        break;                                                \
+    case _Atomic_memory_order_release:                        \
+    case _Atomic_memory_order_acq_rel:                        \
+    default:                                                  \
+        _Result = __iso_volatile_load##_Width(_Ptr);          \
+        _INVALID_MEMORY_ORDER;                                \
+        break;                                                \
+    }
+
+#endif // _STD_ATOMIC_USE_ARM64_LDAR_STLR == 1
+
+#define _ATOMIC_POST_LOAD_BARRIER_AS_NEEDED(_Order_var) \
+    switch (_Order_var) {                               \
+    case _Atomic_memory_order_relaxed:                  \
+        break;                                          \
+    case _Atomic_memory_order_consume:                  \
+    case _Atomic_memory_order_acquire:                  \
+    case _Atomic_memory_order_seq_cst:                  \
+        _Compiler_or_memory_barrier();                  \
+        break;                                          \
+    case _Atomic_memory_order_release:                  \
+    case _Atomic_memory_order_acq_rel:                  \
+    default:                                            \
+        _INVALID_MEMORY_ORDER;                          \
+        break;                                          \
+    }
+
+#define _ATOMIC_STORE_PREFIX(_Width, _Ptr, _Desired)      \
+    case _Atomic_memory_order_relaxed:                    \
+        __iso_volatile_store##_Width((_Ptr), (_Desired)); \
+        return;                                           \
+    case _Atomic_memory_order_release:                    \
+        __STORE_RELEASE(_Width, _Ptr, _Desired);          \
+        return;                                           \
+    default:                                              \
+    case _Atomic_memory_order_consume:                    \
+    case _Atomic_memory_order_acquire:                    \
+    case _Atomic_memory_order_acq_rel:                    \
+        _INVALID_MEMORY_ORDER;                            \
+        /* [[fallthrough]]; */
+
+#define _ATOMIC_STORE_SEQ_CST_ARM(_Width, _Ptr, _Desired) \
+    _Memory_barrier();                                    \
+    __iso_volatile_store##_Width((_Ptr), (_Desired));     \
+    _Memory_barrier();
+
+#define _ATOMIC_STORE_SEQ_CST_ARM64(_Width, _Ptr, _Desired) \
+    __STORE_RELEASE(_Width, _Ptr, _Desired);                \
+    _Memory_barrier();
+
+#define _ATOMIC_STORE_SEQ_CST_X86_X64(_Width, _Ptr, _Desired) (void) _InterlockedExchange##_Width((_Ptr), (_Desired));
+#define _ATOMIC_STORE_32_SEQ_CST_X86_X64(_Ptr, _Desired) \
+    (void) _InterlockedExchange((volatile long*)(_Ptr), (long)(_Desired));
+
+#define _ATOMIC_STORE_64_SEQ_CST_IX86(_Ptr, _Desired) \
+    _Compiler_barrier();                              \
+    __iso_volatile_store64((_Ptr), (_Desired));       \
+    _Atomic_thread_fence(_Atomic_memory_order_seq_cst);
+
+#if defined(_M_ARM)
+#define _ATOMIC_STORE_SEQ_CST(_Width, _Ptr, _Desired) _ATOMIC_STORE_SEQ_CST_ARM(_Width, (_Ptr), (_Desired))
+#define _ATOMIC_STORE_32_SEQ_CST(_Ptr, _Desired)      _ATOMIC_STORE_SEQ_CST_ARM(32, (_Ptr), (_Desired))
+#define _ATOMIC_STORE_64_SEQ_CST(_Ptr, _Desired)      _ATOMIC_STORE_SEQ_CST_ARM(64, (_Ptr), (_Desired))
+#elif defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64) // ^^^ ARM32 / ARM64/ARM64EC/HYBRID_X86_ARM64 vvv
+#define _ATOMIC_STORE_SEQ_CST(_Width, _Ptr, _Desired) _ATOMIC_STORE_SEQ_CST_ARM64(_Width, (_Ptr), (_Desired))
+#define _ATOMIC_STORE_32_SEQ_CST(_Ptr, _Desired)      _ATOMIC_STORE_SEQ_CST_ARM64(32, (_Ptr), (_Desired))
+#define _ATOMIC_STORE_64_SEQ_CST(_Ptr, _Desired)      _ATOMIC_STORE_SEQ_CST_ARM64(64, (_Ptr), (_Desired))
+#elif defined(_M_IX86) || defined(_M_X64) // ^^^ ARM64/ARM64EC/HYBRID_X86_ARM64 / x86/x64 vvv
+#define _ATOMIC_STORE_SEQ_CST(_Width, _Ptr, _Desired) _ATOMIC_STORE_SEQ_CST_X86_X64(_Width, (_Ptr), (_Desired))
+#define _ATOMIC_STORE_32_SEQ_CST(_Ptr, _Desired)      _ATOMIC_STORE_32_SEQ_CST_X86_X64((_Ptr), (_Desired))
+#ifdef _M_IX86
+#define _ATOMIC_STORE_64_SEQ_CST(_Ptr, _Desired) _ATOMIC_STORE_64_SEQ_CST_IX86((_Ptr), (_Desired))
+#else // ^^^ x86 / x64 vvv
+#define _ATOMIC_STORE_64_SEQ_CST(_Ptr, _Desired) _ATOMIC_STORE_SEQ_CST_X86_X64(64, (_Ptr), (_Desired))
+#endif // ^^^ x64 ^^^
+#else // ^^^ x86/x64 / Unsupported hardware vvv
+#error "Unsupported hardware"
+#endif
+
+#pragma warning(push)
+#pragma warning(disable : 6001) // "Using uninitialized memory '_Guard'"
+#pragma warning(disable : 28113) // "Accessing a local variable _Guard via an Interlocked function: This is an unusual
+                                 // usage which could be reconsidered."
+inline void _Atomic_thread_fence(const unsigned int _Order) {
+    if (_Order == _Atomic_memory_order_relaxed) {
+        return;
+    }
+
+#if (defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)) || (defined(_M_X64) && !defined(_M_ARM64EC))
+    _Compiler_barrier();
+    if (_Order == _Atomic_memory_order_seq_cst) {
+        volatile long _Guard; // Not initialized to avoid an unnecessary operation; the value does not matter
+
+        // _mm_mfence could have been used, but it is not supported on older x86 CPUs and is slower on some recent CPUs.
+        // The memory fence provided by interlocked operations has some exceptions, but this is fine:
+        // std::atomic_thread_fence works with respect to other atomics only; it may not be a full fence for all ops.
+        (void) _InterlockedIncrement(&_Guard);
+        _Compiler_barrier();
+    }
+#elif defined(_M_ARM) || defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+    if (_Order == _Atomic_memory_order_acquire || _Order == _Atomic_memory_order_consume) {
+        _Memory_load_acquire_barrier();
+    } else {
+        _Memory_barrier();
+    }
+#else // ^^^ ARM32/ARM64/ARM64EC/HYBRID_X86_ARM64 / unsupported hardware vvv
+#error Unsupported hardware
+#endif // unsupported hardware
+}
+#pragma warning(pop)
+
+// End of code shared with STL <atomic>
+
+inline void _Atomic_lock_acquire(volatile long* _Spinlock) {
+#if (defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)) || (defined(_M_X64) && !defined(_M_ARM64EC))
+    // Algorithm from Intel(R) 64 and IA-32 Architectures Optimization Reference Manual, May 2020
+    // Example 2-4. Contended Locks with Increasing Back-off Example - Improved Version, page 2-22
+    // The code in mentioned manual is covered by the 0BSD license.
+    int _Current_backoff   = 1;
+    const int _Max_backoff = 64;
+    while (_InterlockedExchange(_Spinlock, 1) != 0) {
+        while (__iso_volatile_load32((int*) _Spinlock) != 0) {
+            for (int _Count_down = _Current_backoff; _Count_down != 0; --_Count_down) {
+                _mm_pause();
+            }
+            _Current_backoff = _Current_backoff < _Max_backoff ? _Current_backoff << 1 : _Max_backoff;
+        }
+    }
+#elif defined(_M_ARM) || defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+    while (_InterlockedExchange_acq(_Spinlock, 1) != 0) {
+        while (__iso_volatile_load32((int*) _Spinlock) != 0) {
+            __yield();
+        }
+    }
+#else // ^^^ defined(_M_ARM) || defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64) ^^^
+#error Unsupported hardware
+#endif
+}
+
+inline void _Atomic_lock_release(volatile long* _Spinlock) {
+    __STORE_RELEASE(32, (int*) _Spinlock, 0);
+}
+
+// End of code shared with vcruntime
+
+inline void _Atomic_signal_fence(int _Order) {
+    if (_Order != _Atomic_memory_order_relaxed) {
+        _Compiler_barrier();
+    }
+}
+
+inline _Bool _Atomic_is_lock_free(size_t _Sz) {
+    return _Sz <= 8 && (_Sz & _Sz - 1) == 0;
+}
+
+inline void _Atomic_store8(volatile char* _Ptr, char _Desired, int _Order) {
+    switch (_Order) {
+        _ATOMIC_STORE_PREFIX(8, _Ptr, _Desired)
+    case _Atomic_memory_order_seq_cst:
+        _ATOMIC_STORE_SEQ_CST(8, _Ptr, _Desired)
+        return;
+    }
+}
+
+inline void _Atomic_store16(volatile short* _Ptr, short _Desired, int _Order) {
+    switch (_Order) {
+        _ATOMIC_STORE_PREFIX(16, _Ptr, _Desired)
+    case _Atomic_memory_order_seq_cst:
+        _ATOMIC_STORE_SEQ_CST(16, _Ptr, _Desired)
+        return;
+    }
+}
+
+inline void _Atomic_store32(volatile int* _Ptr, int _Desired, int _Order) {
+    switch (_Order) {
+        _ATOMIC_STORE_PREFIX(32, _Ptr, _Desired)
+    case _Atomic_memory_order_seq_cst:
+        _ATOMIC_STORE_32_SEQ_CST(_Ptr, _Desired)
+        return;
+    }
+}
+
+inline void _Atomic_store64(volatile long long* _Ptr, long long _Desired, int _Order) {
+    switch (_Order) {
+        _ATOMIC_STORE_PREFIX(64, _Ptr, _Desired)
+    case _Atomic_memory_order_seq_cst:
+        _ATOMIC_STORE_64_SEQ_CST(_Ptr, _Desired)
+        return;
+    }
+}
+
+inline void _Atomic_storef(volatile float* _Ptr, float _Desired, int _Order) {
+    _Atomic_store32((volatile int*)_Ptr, *(int*)&_Desired, _Order);
+}
+
+inline void _Atomic_stored(volatile double* _Ptr, double _Desired, int _Order) {
+    _Atomic_store64((volatile long long*)_Ptr, *(long long*)&_Desired, _Order);
+}
+
+inline char _Atomic_load8(const volatile char* _Ptr, int _Order) {
+    char _As_bytes;
+#if _STD_ATOMIC_USE_ARM64_LDAR_STLR == 1
+    _ATOMIC_LOAD_ARM64(_As_bytes, 8, _Ptr, _Order)
+#else
+    _As_bytes = __iso_volatile_load8(_Ptr);
+    _ATOMIC_POST_LOAD_BARRIER_AS_NEEDED(_Order)
+#endif
+    return _As_bytes;
+}
+inline short _Atomic_load16(const volatile short* _Ptr, int _Order) {
+    short _As_bytes;
+#if _STD_ATOMIC_USE_ARM64_LDAR_STLR == 1
+    _ATOMIC_LOAD_ARM64(_As_bytes, 16, _Ptr, _Order)
+#else
+    _As_bytes = __iso_volatile_load16(_Ptr);
+    _ATOMIC_POST_LOAD_BARRIER_AS_NEEDED(_Order)
+#endif
+    return _As_bytes;
+}
+inline int _Atomic_load32(const volatile int* _Ptr, int _Order) {
+    int _As_bytes;
+#if _STD_ATOMIC_USE_ARM64_LDAR_STLR == 1
+    _ATOMIC_LOAD_ARM64(_As_bytes, 32, _Ptr, _Order)
+#else
+    _As_bytes = __iso_volatile_load32(_Ptr);
+    _ATOMIC_POST_LOAD_BARRIER_AS_NEEDED(_Order)
+#endif
+    return _As_bytes;
+}
+inline long long _Atomic_load64(const volatile long long* _Ptr, int _Order) {
+    long long _As_bytes;
+#if _STD_ATOMIC_USE_ARM64_LDAR_STLR == 1
+    _ATOMIC_LOAD_ARM64(_As_bytes, 64, _Ptr, _Order)
+#else // ^^^ _STD_ATOMIC_USE_ARM64_LDAR_STLR == 1 / _STD_ATOMIC_USE_ARM64_LDAR_STLR != 1 vvv
+
+#ifdef _M_ARM
+    _As_bytes = __ldrexd(_Ptr);
+#else
+    _As_bytes = __iso_volatile_load64(_Ptr);
+#endif
+    _ATOMIC_POST_LOAD_BARRIER_AS_NEEDED(_Order);
+#endif // _STD_ATOMIC_USE_ARM64_LDAR_STLR == 1
+    return _As_bytes;
+}
+inline float _Atomic_loadf(const volatile float* _Ptr, int _Order) {
+    int _As_bytes = _Atomic_load32((const volatile int*)_Ptr, _Order);
+    return *(float*)&_As_bytes;
+}
+inline double _Atomic_loadd(const volatile double* _Ptr, int _Order) {
+    long long _As_bytes = _Atomic_load64((const volatile long long*)_Ptr, _Order);
+    return *(double*)&_As_bytes;
+}
+
+inline _Bool _Atomic_compare_exchange_strong8(volatile char* _Ptr, char* _Expected, char _Desired, int _Order) {
+    char _Prev_bytes;
+    char _Expected_bytes = *_Expected;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Prev_bytes, _InterlockedCompareExchange8, _Ptr, _Desired, _Expected_bytes);
+    if (_Prev_bytes == _Expected_bytes) {
+        return 1;
+    }
+    *_Expected = _Prev_bytes;
+    return 0;
+}
+inline _Bool _Atomic_compare_exchange_strong16(volatile short* _Ptr, short* _Expected, short _Desired, int _Order) {
+    short _Prev_bytes;
+    short _Expected_bytes = *_Expected;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Prev_bytes, _InterlockedCompareExchange16, _Ptr, _Desired, _Expected_bytes);
+    if (_Prev_bytes == _Expected_bytes) {
+        return 1;
+    }
+    *_Expected = _Prev_bytes;
+    return 0;
+}
+inline _Bool _Atomic_compare_exchange_strong32(volatile int* _Ptr, int* _Expected, int _Desired, int _Order) {
+    int _Prev_bytes;
+    int _Expected_bytes = *_Expected;
+    _ATOMIC_CHOOSE_INTRINSIC(
+        _Order, _Prev_bytes, _InterlockedCompareExchange, (volatile long*) _Ptr, _Desired, _Expected_bytes);
+    if (_Prev_bytes == _Expected_bytes) {
+        return 1;
+    }
+    *_Expected = _Prev_bytes;
+    return 0;
+}
+inline _Bool _Atomic_compare_exchange_strong64(
+    volatile long long* _Ptr, long long* _Expected, long long _Desired, int _Order) {
+    long long _Prev_bytes;
+    long long _Expected_bytes = *_Expected;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Prev_bytes, _InterlockedCompareExchange64, _Ptr, _Desired, _Expected_bytes);
+    if (_Prev_bytes == _Expected_bytes) {
+        return 1;
+    }
+    *_Expected = _Prev_bytes;
+    return 0;
+}
+inline _Bool _Atomic_compare_exchange_strongf(volatile float* _Ptr, float* _Expected, float _Desired, int _Order) {
+    return _Atomic_compare_exchange_strong32((volatile int*)_Ptr, (int*)_Expected, *(int*)&_Desired, _Order);
+}
+inline _Bool _Atomic_compare_exchange_strongd(volatile double* _Ptr, double* _Expected, double _Desired, int _Order) {
+    return _Atomic_compare_exchange_strong64((volatile long long*)_Ptr, (long long*)_Expected, *(long long*)&_Desired, _Order);
+}
+
+inline char _Atomic_exchange8(volatile char* _Ptr, int _Desired, int _Order) {
+    char _As_bytes;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _As_bytes, _InterlockedExchange8, _Ptr, (char) _Desired);
+    return _As_bytes;
+}
+inline short _Atomic_exchange16(volatile short* _Ptr, int _Desired, int _Order) {
+    short _As_bytes;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _As_bytes, _InterlockedExchange16, _Ptr, (short) _Desired);
+    return _As_bytes;
+}
+inline int _Atomic_exchange32(volatile int* _Ptr, int _Desired, int _Order) {
+    long _As_bytes;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _As_bytes, _InterlockedExchange, (volatile long*) _Ptr, (long) _Desired);
+    return (int) _As_bytes;
+}
+inline long long _Atomic_exchange64(volatile long long* _Ptr, long long _Desired, int _Order) {
+#if defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)
+    long long _As_bytes = _Atomic_load64(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong64(_Ptr, &_As_bytes, _Desired, _Order)) {
+    }
+    return _As_bytes;
+#else // ^^^ defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64) / !defined(_M_IX86) || defined(_M_HYBRID_X86_ARM64) vvv
+    long long _As_bytes;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _As_bytes, _InterlockedExchange64, _Ptr, _Desired);
+    return _As_bytes;
+#endif // defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)
+}
+inline float _Atomic_exchangef(volatile float* _Ptr, float _Desired, int _Order) {
+    long _As_bytes = _Atomic_exchange32((volatile int*)_Ptr, *(int*)&_Desired, _Order);
+    return *(float*) &_As_bytes;
+}
+inline double _Atomic_exchanged(volatile double* _Ptr, double _Desired, int _Order) {
+    long long _As_bytes = _Atomic_exchange64((volatile long long*)_Ptr, *(long long*)&_Desired, _Order);
+    return *(double*)&_As_bytes;
+}
+
+inline char _Atomic_fetch_add8(volatile char* _Ptr, int _Val, int _Order) {
+    char _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedExchangeAdd8, _Ptr, (char) _Val);
+    return _Result;
+}
+inline short _Atomic_fetch_add16(volatile short* _Ptr, int _Val, int _Order) {
+    short _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedExchangeAdd16, _Ptr, (short) _Val);
+    return _Result;
+}
+inline int _Atomic_fetch_add32(volatile int* _Ptr, int _Val, int _Order) {
+    int _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedExchangeAdd, (volatile long*) _Ptr, _Val);
+    return _Result;
+}
+inline long long _Atomic_fetch_add64(volatile long long* _Ptr, long long _Val, int _Order) {
+#if defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)
+    long long _Result = _Atomic_load64(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong64(_Ptr, &_Result, _Result + _Val, _Order)) {
+    }
+    return _Result;
+#else // ^^^ defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64) / !defined(_M_IX86) || defined(_M_HYBRID_X86_ARM64) vvvv
+    long long _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedExchangeAdd64, _Ptr, _Val);
+    return _Result;
+#endif // defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)
+}
+inline float _Atomic_fetch_addf(volatile float* _Ptr, float _Val, int _Order) {
+    float _Result = _Atomic_loadf(_Ptr, _Atomic_memory_order_relaxed);
+    while (!_Atomic_compare_exchange_strongf(_Ptr, &_Result, _Result + _Val, _Order)) {
+    }
+    return _Result;
+}
+inline double _Atomic_fetch_addd(volatile double* _Ptr, double _Val, int _Order) {
+    double _Result = _Atomic_loadd(_Ptr, _Atomic_memory_order_relaxed);
+    while (!_Atomic_compare_exchange_strongd(_Ptr, &_Result, _Result + _Val, _Order)) {
+    }
+    return _Result;
+}
+
+inline char _Atomic_add_fetch8(volatile char* _Ptr, int _Val, int _Order) {
+    char _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedExchangeAdd8, _Ptr, (char) _Val);
+    return (char) (_Result + (char) _Val);
+}
+inline short _Atomic_add_fetch16(volatile short* _Ptr, int _Val, int _Order) {
+    short _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedExchangeAdd16, _Ptr, (short) _Val);
+    return (short) (_Result + (short) _Val);
+}
+inline int _Atomic_add_fetch32(volatile int* _Ptr, int _Val, int _Order) {
+    int _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedExchangeAdd, (volatile long*) _Ptr, _Val);
+    return _Result + _Val;
+}
+inline long long _Atomic_add_fetch64(volatile long long* _Ptr, long long _Val, int _Order) {
+#if defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)
+    long long _Result = _Atomic_load64(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong64(_Ptr, &_Result, _Result + _Val, _Order)) {
+    }
+    return _Result + _Val;
+#else // ^^^ defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64) / !defined(_M_IX86) || defined(_M_HYBRID_X86_ARM64) vvvv
+    long long _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedExchangeAdd64, _Ptr, _Val);
+    return _Result + _Val;
+#endif // defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)
+}
+inline float _Atomic_add_fetchf(volatile float* _Ptr, float _Val, int _Order) {
+    float _Result = _Atomic_loadf(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strongf(_Ptr, &_Result, _Result + _Val, _Order)) {
+    }
+    return _Result + _Val;
+}
+inline double _Atomic_add_fetchd(volatile double* _Ptr, double _Val, int _Order) {
+    double _Result = _Atomic_loadd(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strongd(_Ptr, &_Result, _Result + _Val, _Order)) {
+    }
+    return _Result + _Val;
+}
+
+inline char _Atomic_fetch_sub8(volatile char* _Ptr, int _Val, int _Order) {
+    char _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedExchangeAdd8, _Ptr, -(char) _Val);
+    return _Result;
+}
+inline short _Atomic_fetch_sub16(volatile short* _Ptr, int _Val, int _Order) {
+    short _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedExchangeAdd16, _Ptr, -(short) _Val);
+    return _Result;
+}
+inline int _Atomic_fetch_sub32(volatile int* _Ptr, int _Val, int _Order) {
+    int _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedExchangeAdd, (volatile long*) _Ptr, -_Val);
+    return _Result;
+}
+inline long long _Atomic_fetch_sub64(volatile long long* _Ptr, long long _Val, int _Order) {
+#if defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)
+    long long _Result = _Atomic_load64(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong64(_Ptr, &_Result, _Result - _Val, _Order)) {
+    }
+    return _Result;
+#else // ^^^ defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64) / !defined(_M_IX86) || defined(_M_HYBRID_X86_ARM64) vvvv
+    long long _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedExchangeAdd64, _Ptr, -_Val);
+    return _Result;
+#endif // defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)
+}
+inline float _Atomic_fetch_subf(volatile float* _Ptr, float _Val, int _Order) {
+    float _Result = _Atomic_loadf(_Ptr, _Atomic_memory_order_relaxed);
+    while (!_Atomic_compare_exchange_strongf(_Ptr, &_Result, _Result - _Val, _Order)) {
+    }
+    return _Result;
+}
+inline double _Atomic_fetch_subd(volatile double* _Ptr, double _Val, int _Order) {
+    double _Result = _Atomic_loadd(_Ptr, _Atomic_memory_order_relaxed);
+    while (!_Atomic_compare_exchange_strongd(_Ptr, &_Result, _Result - _Val, _Order)) {
+    }
+    return _Result;
+}
+
+inline char _Atomic_sub_fetch8(volatile char* _Ptr, int _Val, int _Order) {
+    char _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedExchangeAdd8, _Ptr, -(char) _Val);
+    return (char) (_Result - (char) _Val);
+}
+inline short _Atomic_sub_fetch16(volatile short* _Ptr, int _Val, int _Order) {
+    short _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedExchangeAdd16, _Ptr, -(short) _Val);
+    return (short) (_Result - (short) _Val);
+}
+inline int _Atomic_sub_fetch32(volatile int* _Ptr, int _Val, int _Order) {
+    int _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedExchangeAdd, (volatile long*) _Ptr, -_Val);
+    return _Result - _Val;
+}
+inline long long _Atomic_sub_fetch64(volatile long long* _Ptr, long long _Val, int _Order) {
+#if defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)
+    long long _Result = _Atomic_load64(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong64(_Ptr, &_Result, _Result - _Val, _Order)) {
+    }
+    return _Result - _Val;
+#else // ^^^ defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64) / !defined(_M_IX86) || defined(_M_HYBRID_X86_ARM64) vvvv
+    long long _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedExchangeAdd64, _Ptr, -_Val);
+    return _Result - _Val;
+#endif // defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)
+}
+inline float _Atomic_sub_fetchf(volatile float* _Ptr, float _Val, int _Order) {
+    float _Result = _Atomic_loadf(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strongf(_Ptr, &_Result, _Result - _Val, _Order)) {
+    }
+    return _Result - _Val;
+}
+inline double _Atomic_sub_fetchd(volatile double* _Ptr, double _Val, int _Order) {
+    double _Result = _Atomic_loadd(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strongd(_Ptr, &_Result, _Result - _Val, _Order)) {
+    }
+    return _Result - _Val;
+}
+
+inline char _Atomic_fetch_and8(volatile char* _Ptr, int _Val, int _Order) {
+    char _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedAnd8, _Ptr, (char) _Val);
+    return _Result;
+}
+inline short _Atomic_fetch_and16(volatile short* _Ptr, int _Val, int _Order) {
+    short _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedAnd16, _Ptr, (short) _Val);
+    return _Result;
+}
+inline int _Atomic_fetch_and32(volatile int* _Ptr, int _Val, int _Order) {
+    int _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedAnd, (volatile long*) _Ptr, _Val);
+    return _Result;
+}
+inline long long _Atomic_fetch_and64(volatile long long* _Ptr, long long _Val, int _Order) {
+#if defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)
+    long long _Result = _Atomic_load64(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong64(_Ptr, &_Result, _Result & _Val, _Order)) {
+    }
+    return _Result;
+#else // ^^^ defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64) / !defined(_M_IX86) || defined(_M_HYBRID_X86_ARM64) vvvv
+    long long _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedAnd64, _Ptr, _Val);
+    return _Result;
+#endif // defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)
+}
+
+inline char _Atomic_and_fetch8(volatile char* _Ptr, int _Val, int _Order) {
+    char _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedAnd8, _Ptr, (char) _Val);
+    return (char) (_Result & (char) _Val);
+}
+inline short _Atomic_and_fetch16(volatile short* _Ptr, int _Val, int _Order) {
+    short _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedAnd16, _Ptr, (short) _Val);
+    return (short) (_Result & (short) _Val);
+}
+inline int _Atomic_and_fetch32(volatile int* _Ptr, int _Val, int _Order) {
+    int _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedAnd, (volatile long*) _Ptr, _Val);
+    return _Result & _Val;
+}
+inline long long _Atomic_and_fetch64(volatile long long* _Ptr, long long _Val, int _Order) {
+#if defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)
+    long long _Result = _Atomic_load64(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong64(_Ptr, &_Result, _Result & _Val, _Order)) {
+    }
+    return _Result & _Val;
+#else // ^^^ defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64) / !defined(_M_IX86) || defined(_M_HYBRID_X86_ARM64) vvvv
+    long long _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedAnd64, _Ptr, _Val);
+    return _Result & _Val;
+#endif // defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)
+}
+
+inline char _Atomic_fetch_or8(volatile char* _Ptr, int _Val, int _Order) {
+    char _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedOr8, _Ptr, (char) _Val);
+    return _Result;
+}
+inline short _Atomic_fetch_or16(volatile short* _Ptr, int _Val, int _Order) {
+    short _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedOr16, _Ptr, (short) _Val);
+    return _Result;
+}
+inline int _Atomic_fetch_or32(volatile int* _Ptr, int _Val, int _Order) {
+    int _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedOr, (volatile long*) _Ptr, _Val);
+    return _Result;
+}
+inline long long _Atomic_fetch_or64(volatile long long* _Ptr, long long _Val, int _Order) {
+#if defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)
+    long long _Result = _Atomic_load64(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong64(_Ptr, &_Result, _Result | _Val, _Order)) {
+    }
+    return _Result;
+#else // ^^^ defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64) / !defined(_M_IX86) || defined(_M_HYBRID_X86_ARM64) vvvv
+    long long _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedOr64, _Ptr, _Val);
+    return _Result;
+#endif // defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)
+}
+
+inline char _Atomic_or_fetch8(volatile char* _Ptr, int _Val, int _Order) {
+    char _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedOr8, _Ptr, (char) _Val);
+    return (char) (_Result | (char) _Val);
+}
+inline short _Atomic_or_fetch16(volatile short* _Ptr, int _Val, int _Order) {
+    short _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedOr16, _Ptr, (short) _Val);
+    return (short) (_Result | (short) _Val);
+}
+inline int _Atomic_or_fetch32(volatile int* _Ptr, int _Val, int _Order) {
+    int _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedOr, (volatile long*) _Ptr, _Val);
+    return _Result | _Val;
+}
+inline long long _Atomic_or_fetch64(volatile long long* _Ptr, long long _Val, int _Order) {
+#if defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)
+    long long _Result = _Atomic_load64(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong64(_Ptr, &_Result, _Result | _Val, _Order)) {
+    }
+    return _Result | _Val;
+#else // ^^^ defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64) / !defined(_M_IX86) || defined(_M_HYBRID_X86_ARM64) vvvv
+    long long _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedOr64, _Ptr, _Val);
+    return _Result | _Val;
+#endif // defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)
+}
+
+inline char _Atomic_fetch_xor8(volatile char* _Ptr, int _Val, int _Order) {
+    char _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedXor8, _Ptr, (char) _Val);
+    return _Result;
+}
+inline short _Atomic_fetch_xor16(volatile short* _Ptr, int _Val, int _Order) {
+    short _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedXor16, _Ptr, (short) _Val);
+    return _Result;
+}
+inline int _Atomic_fetch_xor32(volatile int* _Ptr, int _Val, int _Order) {
+    int _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedXor, (volatile long*) _Ptr, _Val);
+    return _Result;
+}
+inline long long _Atomic_fetch_xor64(volatile long long* _Ptr, long long _Val, int _Order) {
+#if defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)
+    long long _Result = _Atomic_load64(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong64(_Ptr, &_Result, _Result ^ _Val, _Order)) {
+    }
+    return _Result;
+#else // ^^^ defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64) / !defined(_M_IX86) || defined(_M_HYBRID_X86_ARM64) vvvv
+    long long _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedXor64, _Ptr, _Val);
+    return _Result;
+#endif // defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)
+}
+
+inline char _Atomic_xor_fetch8(volatile char* _Ptr, int _Val, int _Order) {
+    char _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedXor8, _Ptr, (char) _Val);
+    return (char) (_Result ^ (char) _Val);
+}
+inline short _Atomic_xor_fetch16(volatile short* _Ptr, int _Val, int _Order) {
+    short _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedXor16, _Ptr, (short) _Val);
+    return (short) (_Result ^ (short) _Val);
+}
+inline int _Atomic_xor_fetch32(volatile int* _Ptr, int _Val, int _Order) {
+    int _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedXor, (volatile long*) _Ptr, _Val);
+    return _Result ^ _Val;
+}
+inline long long _Atomic_xor_fetch64(volatile long long* _Ptr, long long _Val, int _Order) {
+#if defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)
+    long long _Result = _Atomic_load64(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong64(_Ptr, &_Result, _Result ^ _Val, _Order)) {
+    }
+    return _Result ^ _Val;
+#else // ^^^ defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64) / !defined(_M_IX86) || defined(_M_HYBRID_X86_ARM64) vvvv
+    long long _Result;
+    _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedXor64, _Ptr, _Val);
+    return _Result ^ _Val;
+#endif // defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)
+}
+
+inline char _Atomic_mult_fetch8(volatile char* _Ptr, int _Val, int _Order) {
+    char _Result = _Atomic_load8(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong8(_Ptr, &_Result, (char) (_Result * (char) _Val), _Order)) {
+    }
+    return (char) (_Result * (char) _Val);
+}
+inline short _Atomic_mult_fetch16(volatile short* _Ptr, int _Val, int _Order) {
+    short _Result = _Atomic_load16(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong16(_Ptr, &_Result, (short) (_Result * (short) _Val), _Order)) {
+    }
+    return (short) (_Result * (short) _Val);
+}
+inline int _Atomic_mult_fetch32(volatile int* _Ptr, int _Val, int _Order) {
+    int _Result = _Atomic_load32(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong32(_Ptr, &_Result, _Result * _Val, _Order)) {
+    }
+    return _Result * _Val;
+}
+inline long long _Atomic_mult_fetch64(volatile long long* _Ptr, long long _Val, int _Order) {
+    long long _Result = _Atomic_load64(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong64(_Ptr, &_Result, _Result * _Val, _Order)) {
+    }
+    return _Result * _Val;
+}
+inline float _Atomic_mult_fetchf(volatile float* _Ptr, float _Val, int _Order) {
+    float _Result = _Atomic_loadf(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strongf(_Ptr, &_Result, _Result * _Val, _Order)) {
+    }
+    return _Result * _Val;
+}
+inline double _Atomic_mult_fetchd(volatile double* _Ptr, double _Val, int _Order) {
+    double _Result = _Atomic_loadd(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strongd(_Ptr, &_Result, _Result * _Val, _Order)) {
+    }
+    return _Result * _Val;
+}
+
+inline unsigned char _Atomic_div_fetch8(volatile unsigned char* _Ptr, unsigned int _Val, int _Order) {
+    unsigned char _Result = (unsigned char) _Atomic_load8((volatile char*) _Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong8(
+        (volatile char*) _Ptr, (char*) &_Result, (char) (_Result / (unsigned char) _Val), _Order)) {
+    }
+    return (unsigned char) (_Result / (unsigned char) _Val);
+}
+inline unsigned short _Atomic_div_fetch16(volatile unsigned short* _Ptr, unsigned int _Val, int _Order) {
+    unsigned short _Result = (unsigned short) _Atomic_load16((volatile short*) _Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong16(
+        (volatile short*) _Ptr, (short*) &_Result, (short) (_Result / (unsigned short) _Val), _Order)) {
+    }
+    return (unsigned short) (_Result / (unsigned short) _Val);
+}
+inline unsigned int _Atomic_div_fetch32(volatile unsigned int* _Ptr, unsigned int _Val, int _Order) {
+    unsigned int _Result = (unsigned int) _Atomic_load32((volatile int*) _Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong32((volatile int*) _Ptr, (int*) &_Result, (int) (_Result / _Val), _Order)) {
+    }
+    return _Result / _Val;
+}
+inline unsigned long long _Atomic_div_fetch64(volatile unsigned long long* _Ptr, unsigned long long _Val, int _Order) {
+    unsigned long long _Result =
+        (unsigned long long) _Atomic_load64((volatile long long*) _Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong64(
+        (volatile long long*) _Ptr, (long long*) &_Result, (long long) (_Result / _Val), _Order)) {
+    }
+    return _Result / _Val;
+}
+inline float _Atomic_div_fetchf(volatile float* _Ptr, float _Val, int _Order) {
+    float _Result = _Atomic_loadf(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strongf(_Ptr, &_Result, _Result / _Val, _Order)) {
+    }
+    return _Result / _Val;
+}
+inline double _Atomic_div_fetchd(volatile double* _Ptr, double _Val, int _Order) {
+    double _Result = _Atomic_loadd(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strongd(_Ptr, &_Result, _Result / _Val, _Order)) {
+    }
+    return _Result / _Val;
+}
+
+inline signed char _Atomic_idiv_fetch8(volatile char* _Ptr, int _Val, int _Order) {
+    signed char _Result = (signed char) _Atomic_load8(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong8(_Ptr, (char*) &_Result, (char) (_Result / (signed char) _Val), _Order)) {
+    }
+    return (signed char) (_Result / (signed char) _Val);
+}
+inline short _Atomic_idiv_fetch16(volatile short* _Ptr, int _Val, int _Order) {
+    short _Result = _Atomic_load16(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong16(_Ptr, &_Result, (short) (_Result / (short) _Val), _Order)) {
+    }
+    return (short) (_Result / (short) _Val);
+}
+inline int _Atomic_idiv_fetch32(volatile int* _Ptr, int _Val, int _Order) {
+    int _Result = _Atomic_load32(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong32(_Ptr, &_Result, _Result / _Val, _Order)) {
+    }
+    return _Result / _Val;
+}
+inline long long _Atomic_idiv_fetch64(volatile long long* _Ptr, long long _Val, int _Order) {
+    long long _Result = _Atomic_load64(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong64(_Ptr, &_Result, _Result / _Val, _Order)) {
+    }
+    return _Result / _Val;
+}
+
+inline char _Atomic_shl_fetch8(volatile char* _Ptr, int _Val, int _Order) {
+    char _Result = _Atomic_load8(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong8(_Ptr, &_Result, (char) (_Result << (char) _Val), _Order)) {
+    }
+    return (char) (_Result << (char) _Val);
+}
+inline short _Atomic_shl_fetch16(volatile short* _Ptr, int _Val, int _Order) {
+    short _Result = _Atomic_load16(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong16(_Ptr, &_Result, (short) (_Result << (short) _Val), _Order)) {
+    }
+    return (short) (_Result << (short) _Val);
+}
+inline int _Atomic_shl_fetch32(volatile int* _Ptr, int _Val, int _Order) {
+    int _Result = _Atomic_load32(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong32(_Ptr, &_Result, _Result << _Val, _Order)) {
+    }
+    return _Result << _Val;
+}
+inline long long _Atomic_shl_fetch64(volatile long long* _Ptr, long long _Val, int _Order) {
+    long long _Result = _Atomic_load64(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong64(_Ptr, &_Result, _Result << _Val, _Order)) {
+    }
+    return _Result << _Val;
+}
+
+inline char _Atomic_shr_fetch8(volatile char* _Ptr, int _Val, int _Order) {
+    char _Result = _Atomic_load8(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong8(_Ptr, &_Result, (char) (_Result >> (char) _Val), _Order)) {
+    }
+    return (char) (_Result >> (char) _Val);
+}
+inline short _Atomic_shr_fetch16(volatile short* _Ptr, int _Val, int _Order) {
+    short _Result = _Atomic_load16(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong16(_Ptr, &_Result, (short) (_Result >> (short) _Val), _Order)) {
+    }
+    return (short) (_Result >> (short) _Val);
+}
+inline int _Atomic_shr_fetch32(volatile int* _Ptr, int _Val, int _Order) {
+    int _Result = _Atomic_load32(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong32(_Ptr, &_Result, _Result >> _Val, _Order)) {
+    }
+    return _Result >> _Val;
+}
+inline long long _Atomic_shr_fetch64(volatile long long* _Ptr, long long _Val, int _Order) {
+    long long _Result = _Atomic_load64(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong64(_Ptr, &_Result, _Result >> _Val, _Order)) {
+    }
+    return _Result >> _Val;
+}
+
+inline signed char _Atomic_imod_fetch8(volatile char* _Ptr, int _Val, int _Order) {
+    signed char _Result = (signed char) _Atomic_load8(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong8(_Ptr, (char*) &_Result, (char) (_Result % (signed char) _Val), _Order)) {
+    }
+    return (signed char) (_Result % (signed char) _Val);
+}
+inline short _Atomic_imod_fetch16(volatile short* _Ptr, int _Val, int _Order) {
+    short _Result = _Atomic_load16(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong16(_Ptr, &_Result, (short) (_Result % (short) _Val), _Order)) {
+    }
+    return (short) (_Result % (short) _Val);
+}
+inline int _Atomic_imod_fetch32(volatile int* _Ptr, int _Val, int _Order) {
+    int _Result = _Atomic_load32(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong32(_Ptr, &_Result, _Result % _Val, _Order)) {
+    }
+    return _Result % _Val;
+}
+inline long long _Atomic_imod_fetch64(volatile long long* _Ptr, long long _Val, int _Order) {
+    long long _Result = _Atomic_load64(_Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong64(_Ptr, &_Result, _Result % _Val, _Order)) {
+    }
+    return _Result % _Val;
+}
+
+inline unsigned char _Atomic_mod_fetch8(volatile unsigned char* _Ptr, unsigned int _Val, int _Order) {
+    unsigned char _Result = (unsigned char) _Atomic_load8((volatile char*) _Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong8(
+        (volatile char*) _Ptr, (char*) &_Result, (char) (_Result % (unsigned char) _Val), _Order)) {
+    }
+    return (unsigned char) (_Result % (unsigned char) _Val);
+}
+inline unsigned short _Atomic_mod_fetch16(volatile unsigned short* _Ptr, unsigned int _Val, int _Order) {
+    unsigned short _Result = (unsigned short) _Atomic_load16((volatile short*) _Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong16(
+        (volatile short*) _Ptr, (short*) &_Result, (short) (_Result % (unsigned short) _Val), _Order)) {
+    }
+    return (unsigned short) (_Result % (unsigned short) _Val);
+}
+inline unsigned int _Atomic_mod_fetch32(volatile unsigned int* _Ptr, unsigned int _Val, int _Order) {
+    unsigned int _Result = (unsigned int) _Atomic_load32((volatile int*) _Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong32((volatile int*) _Ptr, (int*) &_Result, (int) (_Result % _Val), _Order)) {
+    }
+    return _Result % _Val;
+}
+inline unsigned long long _Atomic_mod_fetch64(volatile unsigned long long* _Ptr, unsigned long long _Val, int _Order) {
+    unsigned long long _Result =
+        (unsigned long long) _Atomic_load64((volatile long long*) _Ptr, _Atomic_memory_order_seq_cst);
+    while (!_Atomic_compare_exchange_strong64(
+        (volatile long long*) _Ptr, (long long*) &_Result, (long long) (_Result % _Val), _Order)) {
+    }
+    return _Result % _Val;
+}
+
+inline void _Atomic_lock_and_store(volatile void* _Obj, const void* _Desired, int _Offset, size_t _Size) {
+    _Atomic_lock_acquire(_Obj);
+    memmove((char*) _Obj + _Offset, _Desired, _Size);
+    _Atomic_lock_release(_Obj);
+}
+
+inline void _Atomic_lock_and_load(volatile void* _Obj, void* _Dest, int _Offset, size_t _Size) {
+    _Atomic_lock_acquire(_Obj);
+    memmove(_Dest, (char*) _Obj + _Offset, _Size);
+    _Atomic_lock_release(_Obj);
+}
+
+inline void _Atomic_lock_and_exchange(
+    volatile void* _Obj, const void* _Desired, void* _Dest, int _Offset, size_t _Size) {
+    _Atomic_lock_acquire(_Obj);
+    memmove(_Dest, (char*) _Obj + _Offset, _Size);
+    memmove((char*) _Obj + _Offset, _Desired, _Size);
+    _Atomic_lock_release(_Obj);
+}
+
+inline _Bool _Atomic_lock_and_compare_exchange_strong(
+    volatile void* _Obj, void* _Expected, const void* _Desired, int _Offset, size_t _Size) {
+    _Bool _Result;
+    _Atomic_lock_acquire(_Obj);
+    _Result = memcmp((char*) _Obj + _Offset, _Expected, _Size) == 0;
+    if (_Result) {
+        memmove((char*) _Obj + _Offset, _Desired, _Size);
+    } else {
+        memmove(_Expected, (char*) _Obj + _Offset, _Size);
+    }
+    _Atomic_lock_release(_Obj);
+    return _Result;
+}
+
+#undef _ATOMIC_CHOOSE_INTRINSIC
+#undef _ATOMIC_POST_LOAD_BARRIER_AS_NEEDED
+#undef _ATOMIC_STORE_PREFIX
+#undef _ATOMIC_STORE_SEQ_CST_ARM
+#undef _ATOMIC_STORE_SEQ_CST_X86_X64
+#undef _ATOMIC_STORE_32_SEQ_CST_X86_X64
+#undef _ATOMIC_STORE_SEQ_CST
+#undef _ATOMIC_STORE_32_SEQ_CST
+#undef _ATOMIC_STORE_64_SEQ_CST
+#undef _ATOMIC_STORE_64_SEQ_CST_IX86
+#undef _ATOMIC_INVALID_PARAMETER
+#undef _ATOMIC_STORE_SEQ_CST_ARM64
+#undef __LOAD_ACQUIRE_ARM64
+#undef _ATOMIC_LOAD_ARM64
+#undef __STORE_RELEASE
+#undef _STD_ATOMIC_USE_ARM64_LDAR_STLR
+
+#undef _STD_COMPARE_EXCHANGE_128
+#undef _INVALID_MEMORY_ORDER
+#undef _Compiler_or_memory_barrier
+#undef _Memory_barrier
+#undef _Memory_load_acquire_barrier
+#undef _Compiler_barrier
+
+#undef _CONCATX
+#undef _CONCAT
+#undef _INTRIN_RELAXED
+#undef _INTRIN_ACQUIRE
+#undef _INTRIN_RELEASE
+#undef _INTRIN_ACQ_REL
+#undef _YIELD_PROCESSOR

miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime_c11_stdatomic.h

@@ -0,0 +1,128 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// C11 version of stdatomic.h
+#pragma once
+
+#ifdef __cplusplus
+// This header should never be included in C++ mode, C++ has it's own stdatomic.h
+#error "vcruntime_c11_stdatomic.h is a C-only header"
+#endif
+
+#include <stddef.h>
+#include <stdint.h>
+#include <uchar.h>
+#include <vcruntime_c11_atomic_support.h>
+
+typedef enum memory_order {
+    memory_order_relaxed = _Atomic_memory_order_relaxed,
+    memory_order_consume = _Atomic_memory_order_consume,
+    memory_order_acquire = _Atomic_memory_order_acquire,
+    memory_order_release = _Atomic_memory_order_release,
+    memory_order_acq_rel = _Atomic_memory_order_acq_rel,
+    memory_order_seq_cst = _Atomic_memory_order_seq_cst
+} memory_order;
+
+#define ATOMIC_BOOL_LOCK_FREE     1
+#define ATOMIC_CHAR_LOCK_FREE     1
+#define ATOMIC_CHAR16_T_LOCK_FREE 1
+#define ATOMIC_CHAR32_T_LOCK_FREE 1
+#define ATOMIC_WCHAR_T_LOCK_FREE  1
+#define ATOMIC_SHORT_LOCK_FREE    1
+#define ATOMIC_INT_LOCK_FREE      1
+#define ATOMIC_LONG_LOCK_FREE     1
+#define ATOMIC_LLONG_LOCK_FREE    1
+#define ATOMIC_POINTER_LOCK_FREE  1
+
+typedef _Atomic(_Bool) atomic_bool;
+typedef _Atomic(char) atomic_char;
+typedef _Atomic(signed char) atomic_schar;
+typedef _Atomic(unsigned char) atomic_uchar;
+typedef _Atomic(short) atomic_short;
+typedef _Atomic(unsigned short) atomic_ushort;
+typedef _Atomic(int) atomic_int;
+typedef _Atomic(unsigned int) atomic_uint;
+typedef _Atomic(long) atomic_long;
+typedef _Atomic(unsigned long) atomic_ulong;
+typedef _Atomic(long long) atomic_llong;
+typedef _Atomic(unsigned long long) atomic_ullong;
+typedef _Atomic(char16_t) atomic_char16_t;
+typedef _Atomic(char32_t) atomic_char32_t;
+typedef _Atomic(wchar_t) atomic_wchar_t;
+typedef _Atomic(int_least8_t) atomic_int_least8_t;
+typedef _Atomic(uint_least8_t) atomic_uint_least8_t;
+typedef _Atomic(int_least16_t) atomic_int_least16_t;
+typedef _Atomic(uint_least16_t) atomic_uint_least16_t;
+typedef _Atomic(int_least32_t) atomic_int_least32_t;
+typedef _Atomic(uint_least32_t) atomic_uint_least32_t;
+typedef _Atomic(int_least64_t) atomic_int_least64_t;
+typedef _Atomic(uint_least64_t) atomic_uint_least64_t;
+typedef _Atomic(int_fast8_t) atomic_int_fast8_t;
+typedef _Atomic(uint_fast8_t) atomic_uint_fast8_t;
+typedef _Atomic(int_fast16_t) atomic_int_fast16_t;
+typedef _Atomic(uint_fast16_t) atomic_uint_fast16_t;
+typedef _Atomic(int_fast32_t) atomic_int_fast32_t;
+typedef _Atomic(uint_fast32_t) atomic_uint_fast32_t;
+typedef _Atomic(int_fast64_t) atomic_int_fast64_t;
+typedef _Atomic(uint_fast64_t) atomic_uint_fast64_t;
+typedef _Atomic(intptr_t) atomic_intptr_t;
+typedef _Atomic(uintptr_t) atomic_uintptr_t;
+typedef _Atomic(size_t) atomic_size_t;
+typedef _Atomic(ptrdiff_t) atomic_ptrdiff_t;
+typedef _Atomic(intmax_t) atomic_intmax_t;
+typedef _Atomic(uintmax_t) atomic_uintmax_t;
+
+#define atomic_init __c11_atomic_init
+
+#define kill_dependency(_Obj) (_Obj)
+
+#define atomic_thread_fence(_Order) _Atomic_thread_fence(_Order)
+#define atomic_signal_fence(_Order) _Atomic_signal_fence(_Order)
+
+#define atomic_is_lock_free(_Obj) _Atomic_is_lock_free(sizeof(__typeof_unqual__(*(_Obj))))
+
+#define atomic_store(_Obj, _Desired) __c11_atomic_store(_Obj, _Desired, _Atomic_memory_order_seq_cst)
+#define atomic_store_explicit        __c11_atomic_store
+
+#define atomic_load(_Obj)    __c11_atomic_load(_Obj, _Atomic_memory_order_seq_cst)
+#define atomic_load_explicit __c11_atomic_load
+
+#define atomic_exchange(_Obj, _Desired) __c11_atomic_exchange(_Obj, _Desired, _Atomic_memory_order_seq_cst)
+#define atomic_exchange_explicit        __c11_atomic_exchange
+
+#define atomic_compare_exchange_strong(_Obj, _Expected, _Desired) \
+    __c11_atomic_compare_exchange_strong(                         \
+        _Obj, _Expected, _Desired, _Atomic_memory_order_seq_cst, _Atomic_memory_order_seq_cst)
+#define atomic_compare_exchange_strong_explicit __c11_atomic_compare_exchange_strong
+
+#define atomic_compare_exchange_weak(_Obj, _Expected, _Desired) \
+    __c11_atomic_compare_exchange_weak(                         \
+        _Obj, _Expected, _Desired, _Atomic_memory_order_seq_cst, _Atomic_memory_order_seq_cst)
+#define atomic_compare_exchange_weak_explicit __c11_atomic_compare_exchange_weak
+
+#define atomic_fetch_add(_Obj, _Val) __c11_atomic_fetch_add(_Obj, _Val, _Atomic_memory_order_seq_cst)
+#define atomic_fetch_add_explicit    __c11_atomic_fetch_add
+
+#define atomic_fetch_sub(_Obj, _Val) __c11_atomic_fetch_sub(_Obj, _Val, _Atomic_memory_order_seq_cst)
+#define atomic_fetch_sub_explicit    __c11_atomic_fetch_sub
+
+#define atomic_fetch_or(_Obj, _Val) __c11_atomic_fetch_or(_Obj, _Val, _Atomic_memory_order_seq_cst)
+#define atomic_fetch_or_explicit    __c11_atomic_fetch_or
+
+#define atomic_fetch_xor(_Obj, _Val) __c11_atomic_fetch_xor(_Obj, _Val, _Atomic_memory_order_seq_cst)
+#define atomic_fetch_xor_explicit    __c11_atomic_fetch_xor
+
+#define atomic_fetch_and(_Obj, _Val) __c11_atomic_fetch_and(_Obj, _Val, _Atomic_memory_order_seq_cst)
+#define atomic_fetch_and_explicit    __c11_atomic_fetch_and
+
+#define ATOMIC_FLAG_INIT \
+    { 0 }
+
+typedef struct atomic_flag {
+    _Atomic(_Bool) _Val;
+} atomic_flag;
+
+#define atomic_flag_test_and_set(_Obj)                  __c11_atomic_exchange(&(_Obj)->_Val, 1, _Atomic_memory_order_seq_cst)
+#define atomic_flag_test_and_set_explicit(_Obj, _Order) __c11_atomic_exchange(&(_Obj)->_Val, 1, _Order)
+
+#define atomic_flag_clear(_Obj)                  __c11_atomic_store(&(_Obj)->_Val, 0, _Atomic_memory_order_seq_cst)
+#define atomic_flag_clear_explicit(_Obj, _Order) __c11_atomic_store(&(_Obj)->_Val, 0, _Order)

miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime_exception.h

@@ -0,0 +1,155 @@
+//
+// vcruntime_exception.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// <exception> functionality that is implemented in the VCRuntime.
+//
+#pragma once
+
+#include <eh.h>
+
+#ifdef _M_CEE_PURE
+    #include <vcruntime_new.h>
+#endif
+
+#if _VCRT_COMPILER_PREPROCESSOR && _HAS_EXCEPTIONS
+
+#pragma warning(push)
+#pragma warning(disable: _VCRUNTIME_DISABLED_WARNINGS)
+#pragma warning(disable: 4577) // 'noexcept' used with no exception handling mode specified
+#pragma warning(disable: 4643) // Forward declaring 'meow' in namespace std is not permitted by the C++ Standard.
+
+#pragma pack(push, _CRT_PACKING)
+
+_CRT_BEGIN_C_HEADER
+
+struct __std_exception_data
+{
+    char const* _What;
+    bool        _DoFree;
+};
+
+_VCRTIMP void __cdecl __std_exception_copy(
+    _In_    __std_exception_data const* _From,
+    _Inout_ __std_exception_data*       _To
+    );
+
+_VCRTIMP void __cdecl __std_exception_destroy(
+    _Inout_ __std_exception_data* _Data
+    );
+
+_CRT_END_C_HEADER
+
+
+extern "C++" {
+
+namespace std {
+
+_VCRT_EXPORT_STD class exception
+{
+public:
+
+    exception() noexcept
+        : _Data()
+    {
+    }
+
+    explicit exception(char const* const _Message) noexcept
+        : _Data()
+    {
+        __std_exception_data _InitData = { _Message, true };
+        __std_exception_copy(&_InitData, &_Data);
+    }
+
+    exception(char const* const _Message, int) noexcept
+        : _Data()
+    {
+        _Data._What = _Message;
+    }
+
+    exception(exception const& _Other) noexcept
+        : _Data()
+    {
+        __std_exception_copy(&_Other._Data, &_Data);
+    }
+
+    exception& operator=(exception const& _Other) noexcept
+    {
+        if (this == &_Other)
+        {
+            return *this;
+        }
+
+        __std_exception_destroy(&_Data);
+        __std_exception_copy(&_Other._Data, &_Data);
+        return *this;
+    }
+
+    virtual ~exception() noexcept
+    {
+        __std_exception_destroy(&_Data);
+    }
+
+    _NODISCARD virtual char const* what() const
+    {
+        return _Data._What ? _Data._What : "Unknown exception";
+    }
+
+private:
+
+    __std_exception_data _Data;
+};
+
+_VCRT_EXPORT_STD class bad_exception
+    : public exception
+{
+public:
+
+    bad_exception() noexcept
+        : exception("bad exception", 1)
+    {
+    }
+};
+
+_VCRT_EXPORT_STD class bad_array_new_length;
+
+_VCRT_EXPORT_STD class bad_alloc
+    : public exception
+{
+public:
+
+    bad_alloc() noexcept
+        : exception("bad allocation", 1)
+    {
+    }
+
+private:
+
+    friend bad_array_new_length;
+
+    bad_alloc(char const* const _Message) noexcept
+        : exception(_Message, 1)
+    {
+    }
+};
+
+_VCRT_EXPORT_STD class bad_array_new_length
+    : public bad_alloc
+{
+public:
+
+    bad_array_new_length() noexcept
+        : bad_alloc("bad array new length")
+    {
+    }
+};
+
+} // namespace std
+
+} // extern "C++"
+
+#pragma pack(pop)
+
+#pragma warning(pop) // _VCRUNTIME_DISABLED_WARNINGS
+#endif // _VCRT_COMPILER_PREPROCESSOR && _HAS_EXCEPTIONS

miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime_new.h

@@ -0,0 +1,198 @@
+//
+// vcruntime_new.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Declarations and definitions of memory management functions in the VCRuntime.
+//
+#pragma once
+
+#include <vcruntime.h>
+
+#pragma warning(push)
+#pragma warning(disable: _VCRUNTIME_DISABLED_WARNINGS)
+#pragma warning(disable: 4985) // attributes not present on previous declaration
+
+#ifdef __cplusplus
+extern "C++" {
+
+#pragma pack(push, _CRT_PACKING)
+
+#pragma push_macro("new")
+#undef new
+
+#ifdef __cpp_aligned_new
+namespace std
+{
+    _VCRT_EXPORT_STD enum class align_val_t : size_t {};
+}
+#endif // __cpp_aligned_new
+
+#ifndef __NOTHROW_T_DEFINED
+#define __NOTHROW_T_DEFINED
+    namespace std
+    {
+        _VCRT_EXPORT_STD struct nothrow_t {
+            explicit nothrow_t() = default;
+        };
+
+        _VCRT_EXPORT_STD extern nothrow_t const nothrow;
+    }
+#endif
+
+_VCRT_EXPORT_STD _NODISCARD _Ret_notnull_ _Post_writable_byte_size_(_Size) _VCRT_ALLOCATOR
+void* __CRTDECL operator new(
+    size_t _Size
+    );
+
+_VCRT_EXPORT_STD _NODISCARD _Ret_maybenull_ _Success_(return != NULL) _Post_writable_byte_size_(_Size) _VCRT_ALLOCATOR
+void* __CRTDECL operator new(
+    size_t _Size,
+    ::std::nothrow_t const&
+    ) noexcept;
+
+_VCRT_EXPORT_STD _NODISCARD _Ret_notnull_ _Post_writable_byte_size_(_Size) _VCRT_ALLOCATOR
+void* __CRTDECL operator new[](
+    size_t _Size
+    );
+
+_VCRT_EXPORT_STD _NODISCARD _Ret_maybenull_ _Success_(return != NULL) _Post_writable_byte_size_(_Size) _VCRT_ALLOCATOR
+void* __CRTDECL operator new[](
+    size_t _Size,
+    ::std::nothrow_t const&
+    ) noexcept;
+
+_VCRT_EXPORT_STD void __CRTDECL operator delete(
+    void* _Block
+    ) noexcept;
+
+_VCRT_EXPORT_STD void __CRTDECL operator delete(
+    void* _Block,
+    ::std::nothrow_t const&
+    ) noexcept;
+
+_VCRT_EXPORT_STD void __CRTDECL operator delete[](
+    void* _Block
+    ) noexcept;
+
+_VCRT_EXPORT_STD void __CRTDECL operator delete[](
+    void* _Block,
+    ::std::nothrow_t const&
+    ) noexcept;
+
+_VCRT_EXPORT_STD void __CRTDECL operator delete(
+    void*  _Block,
+    size_t _Size
+    ) noexcept;
+
+_VCRT_EXPORT_STD void __CRTDECL operator delete[](
+    void* _Block,
+    size_t _Size
+    ) noexcept;
+
+#ifdef __cpp_aligned_new
+_VCRT_EXPORT_STD _NODISCARD _Ret_notnull_ _Post_writable_byte_size_(_Size) _VCRT_ALLOCATOR
+void* __CRTDECL operator new(
+    size_t             _Size,
+    ::std::align_val_t _Al
+    );
+
+_VCRT_EXPORT_STD _NODISCARD _Ret_maybenull_ _Success_(return != NULL) _Post_writable_byte_size_(_Size) _VCRT_ALLOCATOR
+void* __CRTDECL operator new(
+    size_t                  _Size,
+    ::std::align_val_t      _Al,
+    ::std::nothrow_t const&
+    ) noexcept;
+
+
+_VCRT_EXPORT_STD _NODISCARD _Ret_notnull_ _Post_writable_byte_size_(_Size) _VCRT_ALLOCATOR
+void* __CRTDECL operator new[](
+    size_t             _Size,
+    ::std::align_val_t _Al
+    );
+
+_VCRT_EXPORT_STD _NODISCARD _Ret_maybenull_ _Success_(return != NULL) _Post_writable_byte_size_(_Size) _VCRT_ALLOCATOR
+void* __CRTDECL operator new[](
+    size_t                  _Size,
+    ::std::align_val_t      _Al,
+    ::std::nothrow_t const&
+    ) noexcept;
+
+_VCRT_EXPORT_STD void __CRTDECL operator delete(
+    void*              _Block,
+    ::std::align_val_t _Al
+    ) noexcept;
+
+_VCRT_EXPORT_STD void __CRTDECL operator delete(
+    void*                   _Block,
+    ::std::align_val_t      _Al,
+    ::std::nothrow_t const&
+    ) noexcept;
+
+_VCRT_EXPORT_STD void __CRTDECL operator delete[](
+    void*              _Block,
+    ::std::align_val_t _Al
+    ) noexcept;
+
+_VCRT_EXPORT_STD void __CRTDECL operator delete[](
+    void*                   _Block,
+    ::std::align_val_t      _Al,
+    ::std::nothrow_t const&
+    ) noexcept;
+
+_VCRT_EXPORT_STD void __CRTDECL operator delete(
+    void*              _Block,
+    size_t             _Size,
+    ::std::align_val_t _Al
+    ) noexcept;
+
+_VCRT_EXPORT_STD void __CRTDECL operator delete[](
+    void*              _Block,
+    size_t             _Size,
+    ::std::align_val_t _Al
+    ) noexcept;
+#endif // __cpp_aligned_new
+
+#pragma warning(push)
+#pragma warning(disable: 4577) // 'noexcept' used with no exception handling mode specified
+#pragma warning(disable: 4514) // 'operator new': unreferenced inline function has been removed
+#ifndef __PLACEMENT_NEW_INLINE
+    #define __PLACEMENT_NEW_INLINE
+    _VCRT_EXPORT_STD _NODISCARD _MSVC_CONSTEXPR _Ret_notnull_ _Post_writable_byte_size_(_Size) _Post_satisfies_(return == _Where)
+    inline void* __CRTDECL operator new(size_t _Size,
+        _Writable_bytes_(_Size) void* _Where) noexcept
+    {
+        (void)_Size;
+        return _Where;
+    }
+
+    _VCRT_EXPORT_STD inline void __CRTDECL operator delete(void*, void*) noexcept
+    {
+        return;
+    }
+#endif
+
+#ifndef __PLACEMENT_VEC_NEW_INLINE
+    #define __PLACEMENT_VEC_NEW_INLINE
+    _VCRT_EXPORT_STD _NODISCARD _Ret_notnull_ _Post_writable_byte_size_(_Size) _Post_satisfies_(return == _Where)
+    inline void* __CRTDECL operator new[](size_t _Size,
+        _Writable_bytes_(_Size) void* _Where) noexcept
+    {
+        (void)_Size;
+        return _Where;
+    }
+
+    _VCRT_EXPORT_STD inline void __CRTDECL operator delete[](void*, void*) noexcept
+    {
+    }
+#endif
+#pragma warning(pop)
+
+#pragma pop_macro("new")
+
+#pragma pack(pop)
+
+} // extern "C++"
+#endif // __cplusplus
+
+#pragma warning(pop) // _VCRUNTIME_DISABLED_WARNINGS

miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime_new_debug.h

@@ -0,0 +1,64 @@
+//
+// vcruntime_new_debug.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Declarations and definitions of the debug operators new and delete.
+//
+#pragma once
+
+#include <vcruntime_new.h>
+
+#pragma warning(push)
+#pragma warning(disable: _VCRUNTIME_DISABLED_WARNINGS)
+
+#ifdef __cplusplus
+extern "C++" {
+
+#pragma pack(push, _CRT_PACKING)
+
+#pragma push_macro("new")
+#undef new
+
+#ifndef _MFC_OVERRIDES_NEW
+
+    _NODISCARD _Check_return_ _Ret_notnull_ _Post_writable_byte_size_(_Size)
+    _VCRT_ALLOCATOR void* __CRTDECL operator new(
+        _In_   size_t      _Size,
+        _In_   int         _BlockUse,
+        _In_z_ char const* _FileName,
+        _In_   int         _LineNumber
+        );
+
+    _NODISCARD _Check_return_ _Ret_notnull_ _Post_writable_byte_size_(_Size)
+    _VCRT_ALLOCATOR void* __CRTDECL operator new[](
+        _In_   size_t      _Size,
+        _In_   int         _BlockUse,
+        _In_z_ char const* _FileName,
+        _In_   int         _LineNumber
+        );
+
+    void __CRTDECL operator delete(
+        void*       _Block,
+        int         _BlockUse,
+        char const* _FileName,
+        int         _LineNumber
+        ) noexcept;
+
+    void __CRTDECL operator delete[](
+        void*       _Block,
+        int         _BlockUse,
+        char const* _FileName,
+        int         _LineNumber
+        ) noexcept;
+
+#endif
+
+#pragma pop_macro("new")
+
+#pragma pack(pop)
+
+} // extern "C++"
+#endif // __cplusplus
+
+#pragma warning(pop) // _VCRUNTIME_DISABLED_WARNINGS

miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime_startup.h

@@ -0,0 +1,56 @@
+//
+// vcruntime_startup.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Declarations of the VCRuntime startup functionality
+//
+#pragma once
+
+#include <vcruntime.h>
+
+#pragma warning(push)
+#pragma warning(disable: _VCRUNTIME_DISABLED_WARNINGS)
+
+_CRT_BEGIN_C_HEADER
+
+
+
+typedef enum _crt_argv_mode
+{
+    _crt_argv_no_arguments,
+    _crt_argv_unexpanded_arguments,
+    _crt_argv_expanded_arguments,
+} _crt_argv_mode;
+
+typedef enum _crt_exit_return_mode
+{
+    _crt_exit_terminate_process,
+    _crt_exit_return_to_caller
+} _crt_exit_return_mode;
+
+typedef enum _crt_exit_cleanup_mode
+{
+    _crt_exit_full_cleanup,
+    _crt_exit_quick_cleanup,
+    _crt_exit_no_cleanup
+} _crt_exit_cleanup_mode;
+
+extern _crt_exit_return_mode __current_exit_return_mode;
+
+
+
+__vcrt_bool __cdecl __vcrt_initialize(void);
+__vcrt_bool __cdecl __vcrt_uninitialize(_In_ __vcrt_bool _Terminating);
+__vcrt_bool __cdecl __vcrt_uninitialize_critical(void);
+__vcrt_bool __cdecl __vcrt_thread_attach(void);
+__vcrt_bool __cdecl __vcrt_thread_detach(void);
+
+int __cdecl __isa_available_init(void);
+_crt_argv_mode __CRTDECL _get_startup_argv_mode(void);
+
+
+
+_CRT_END_C_HEADER
+
+#pragma warning(pop) // _VCRUNTIME_DISABLED_WARNINGS

miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime_string.h

@@ -0,0 +1,113 @@
+//
+// vcruntime_string.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// <string.h> functionality that is implemented in the VCRuntime.
+//
+#pragma once
+
+#include <vcruntime.h>
+
+#pragma warning(push)
+#pragma warning(disable: _VCRUNTIME_DISABLED_WARNINGS)
+
+#ifndef __midl
+
+_CRT_BEGIN_C_HEADER
+
+
+
+_NODISCARD _Check_return_
+_VCRTIMP void _CONST_RETURN* __cdecl memchr(
+    _In_reads_bytes_opt_(_MaxCount) void const* _Buf,
+    _In_                            int         _Val,
+    _In_                            size_t      _MaxCount
+    );
+
+_NODISCARD _Check_return_
+int __cdecl memcmp(
+    _In_reads_bytes_(_Size) void const* _Buf1,
+    _In_reads_bytes_(_Size) void const* _Buf2,
+    _In_                    size_t      _Size
+    );
+
+_CRT_INSECURE_DEPRECATE_MEMORY(memcpy_s)
+_Post_equal_to_(_Dst)
+_At_buffer_(
+    (unsigned char*)_Dst,
+    _Iter_,
+    _Size,
+    _Post_satisfies_(((unsigned char*)_Dst)[_Iter_] == ((unsigned char*)_Src)[_Iter_])
+)
+void* __cdecl memcpy(
+    _Out_writes_bytes_all_(_Size) void* _Dst,
+    _In_reads_bytes_(_Size)       void const* _Src,
+    _In_                          size_t      _Size
+    );
+
+_CRT_INSECURE_DEPRECATE_MEMORY(memmove_s)
+_VCRTIMP void* __cdecl memmove(
+    _Out_writes_bytes_all_opt_(_Size) void*       _Dst,
+    _In_reads_bytes_opt_(_Size)       void const* _Src,
+    _In_                              size_t      _Size
+    );
+
+_Post_equal_to_(_Dst)
+_At_buffer_(
+    (unsigned char*)_Dst,
+    _Iter_,
+    _Size,
+    _Post_satisfies_(((unsigned char*)_Dst)[_Iter_] == _Val)
+)
+void* __cdecl memset(
+    _Out_writes_bytes_all_(_Size) void*  _Dst,
+    _In_                          int    _Val,
+    _In_                          size_t _Size
+    );
+
+_NODISCARD _Check_return_
+_VCRTIMP char _CONST_RETURN* __cdecl strchr(
+    _In_z_ char const* _Str,
+    _In_   int         _Val
+    );
+
+_NODISCARD _Check_return_
+_VCRTIMP char _CONST_RETURN* __cdecl strrchr(
+    _In_z_ char const* _Str,
+    _In_   int         _Ch
+    );
+
+_NODISCARD _Check_return_ _Ret_maybenull_
+_VCRTIMP char _CONST_RETURN* __cdecl strstr(
+    _In_z_ char const* _Str,
+    _In_z_ char const* _SubStr
+    );
+
+_NODISCARD _Check_return_
+_When_(return != NULL, _Ret_range_(_Str, _Str + _String_length_(_Str) - 1))
+_VCRTIMP wchar_t _CONST_RETURN* __cdecl wcschr(
+    _In_z_ wchar_t const* _Str,
+    _In_   wchar_t        _Ch
+    );
+
+_NODISCARD _Check_return_
+_VCRTIMP wchar_t _CONST_RETURN* __cdecl wcsrchr(
+    _In_z_ wchar_t const* _Str,
+    _In_   wchar_t        _Ch
+    );
+
+_NODISCARD _Check_return_ _Ret_maybenull_
+_When_(return != NULL, _Ret_range_(_Str, _Str + _String_length_(_Str) - 1))
+_VCRTIMP wchar_t _CONST_RETURN* __cdecl wcsstr(
+    _In_z_ wchar_t const* _Str,
+    _In_z_ wchar_t const* _SubStr
+    );
+
+
+
+_CRT_END_C_HEADER
+
+#endif // __midl
+
+#pragma warning(pop) // _VCRUNTIME_DISABLED_WARNINGS

miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime_typeinfo.h

@@ -0,0 +1,221 @@
+//
+// vcruntime_typeinfo.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// <typeinfo> functionality that is implemented in the VCRuntime.
+//
+#pragma once
+
+#include <vcruntime.h>
+
+#if _VCRT_COMPILER_PREPROCESSOR
+#include <vcruntime_exception.h>
+
+#pragma warning(push)
+#pragma warning(disable: _VCRUNTIME_DISABLED_WARNINGS)
+
+#pragma pack(push, _CRT_PACKING)
+
+extern "C++" { // attach declarations to the global module, see N4910 [module.unit]/7
+
+#if defined _M_CEE_MIXED && !defined _VCRT_BUILD
+    // Provide a fake definition of __type_info_node to suppress linker warning
+    // LNK4248: unresolved typeref token for '__type_info_node'; image may not run.
+    struct __type_info_node { };
+#else
+    struct __type_info_node;
+#endif
+
+#ifdef _M_CEE_PURE
+    extern System::IntPtr __type_info_root_node;
+#else
+    extern __type_info_node __type_info_root_node;
+#endif
+
+} // extern "C++"
+
+
+_CRT_BEGIN_C_HEADER
+
+struct __std_type_info_data
+{
+    const char * _UndecoratedName;
+    const char   _DecoratedName[1];
+    __std_type_info_data() = delete;
+    __std_type_info_data(const __std_type_info_data&) = delete;
+    __std_type_info_data(__std_type_info_data&&) = delete;
+
+    __std_type_info_data& operator=(const __std_type_info_data&) = delete;
+    __std_type_info_data& operator=(__std_type_info_data&&) = delete;
+};
+
+_VCRTIMP int __cdecl __std_type_info_compare(
+    _In_ const __std_type_info_data* _Lhs,
+    _In_ const __std_type_info_data* _Rhs
+    );
+
+_VCRTIMP size_t __cdecl __std_type_info_hash(
+    _In_ const __std_type_info_data* _Data
+    );
+
+_VCRTIMP const char* __cdecl __std_type_info_name(
+    _Inout_ __std_type_info_data* _Data,
+    _Inout_ __type_info_node*     _RootNode
+    );
+
+_CRT_END_C_HEADER
+
+
+extern "C++" { // attach declarations to the global module, see N4910 [module.unit]/7
+
+#pragma warning(push)
+#pragma warning(disable: 4577) // 'noexcept' used with no exception handling mode specified
+_VCRT_EXPORT_STD class type_info // Exported because for typeid, MSVC looks for type_info in the global namespace
+{
+public:
+
+    type_info(const type_info&) = delete;
+    type_info& operator=(const type_info&) = delete;
+
+    _NODISCARD size_t hash_code() const noexcept
+    {
+        return __std_type_info_hash(&_Data);
+    }
+
+    _NODISCARD
+#if _HAS_CXX23
+    constexpr
+#endif // _HAS_CXX23
+    bool operator==(const type_info& _Other) const noexcept
+    {
+#if _HAS_CXX23
+        if (__builtin_is_constant_evaluated())
+        {
+            return &_Data == &_Other._Data;
+        }
+#endif // _HAS_CXX23
+
+        return __std_type_info_compare(&_Data, &_Other._Data) == 0;
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD bool operator!=(const type_info& _Other) const noexcept
+    {
+        return __std_type_info_compare(&_Data, &_Other._Data) != 0;
+    }
+#endif // !_HAS_CXX20
+
+    _NODISCARD bool before(const type_info& _Other) const noexcept
+    {
+        return __std_type_info_compare(&_Data, &_Other._Data) < 0;
+    }
+
+    _NODISCARD const char* name() const noexcept
+    {
+        #ifdef _M_CEE_PURE
+        return __std_type_info_name(&_Data, static_cast<__type_info_node*>(__type_info_root_node.ToPointer()));
+        #else
+        return __std_type_info_name(&_Data, &__type_info_root_node);
+        #endif
+    }
+
+    _NODISCARD const char* raw_name() const noexcept
+    {
+        return _Data._DecoratedName;
+    }
+
+    virtual ~type_info() noexcept;
+
+private:
+
+    mutable __std_type_info_data _Data;
+};
+#pragma warning(pop)
+
+namespace std {
+    _VCRT_EXPORT_STD using ::type_info;
+}
+
+#if _HAS_EXCEPTIONS
+
+namespace std {
+
+#pragma warning(push)
+#pragma warning(disable: 4577) // 'noexcept' used with no exception handling mode specified
+_VCRT_EXPORT_STD class bad_cast
+    : public exception
+{
+public:
+
+    bad_cast() noexcept
+        : exception("bad cast", 1)
+    {
+    }
+
+    static bad_cast __construct_from_string_literal(const char* const _Message) noexcept
+    {
+        return bad_cast(_Message, 1);
+    }
+
+private:
+
+    bad_cast(const char* const _Message, int) noexcept
+        : exception(_Message, 1)
+    {
+    }
+};
+
+_VCRT_EXPORT_STD class bad_typeid
+    : public exception
+{
+public:
+
+    bad_typeid() noexcept
+        : exception("bad typeid", 1)
+    {
+    }
+
+    static bad_typeid __construct_from_string_literal(const char* const _Message) noexcept
+    {
+        return bad_typeid(_Message, 1);
+    }
+
+private:
+
+    friend class __non_rtti_object;
+
+    bad_typeid(const char* const _Message, int) noexcept
+        : exception(_Message, 1)
+    {
+    }
+};
+
+class __non_rtti_object
+    : public bad_typeid
+{
+public:
+
+    static __non_rtti_object __construct_from_string_literal(const char* const _Message) noexcept
+    {
+        return __non_rtti_object(_Message, 1);
+    }
+
+private:
+
+    __non_rtti_object(const char* const _Message, int) noexcept
+        : bad_typeid(_Message, 1)
+    {
+    }
+};
+
+#pragma warning(pop)
+} // namespace std
+
+#endif // _HAS_EXCEPTIONS
+
+} // extern "C++"
+
+#pragma pack(pop)
+#pragma warning(pop) // _VCRUNTIME_DISABLED_WARNINGS
+#endif // _VCRT_COMPILER_PREPROCESSOR

miniMSVC/VC/Tools/MSVC/14.42.34433/include/version

@@ -0,0 +1,9 @@
+// version standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _STD_VERSION_HEADER_
+#define _STD_VERSION_HEADER_
+#include <yvals_core.h>
+#endif // _STD_VERSION_HEADER_

miniMSVC/VC/Tools/MSVC/14.42.34433/include/wmmintrin.h

@@ -0,0 +1,91 @@
+/*
+ *  Copyright (C) 1985-2015 Intel Corporation.
+ *
+ *  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+/*
+ * wmmintrin.h
+ *
+ * Principal header file for Intel(R) AES and PCLMULQDQ intrinsics.
+ */
+
+#pragma once
+
+#if !defined(_M_IX86) && !defined(_M_X64) && !(defined(_M_ARM64) && defined(USE_SOFT_INTRINSICS))
+#error This header is specific to X86, X64, ARM64, and ARM64EC targets
+#endif
+
+#if (defined(_M_ARM64) || defined(_M_ARM64EC)) && !defined(__INTRIN_H_)
+#error this header should only be included through <intrin.h>
+#endif
+
+#ifndef _INCLUDED_WMM
+#define _INCLUDED_WMM
+#ifndef __midl
+
+#if defined (_M_CEE_PURE)
+        #error ERROR: EMM intrinsics not supported in the pure mode!
+#else  /* defined (_M_CEE_PURE) */
+
+#include <nmmintrin.h>
+
+
+#if defined (__cplusplus)
+extern "C" {
+#endif  /* defined (__cplusplus) */
+
+/*
+ * Performs 1 round of AES decryption of the first m128i using
+ * the second m128i as a round key.
+ */
+extern __m128i _mm_aesdec_si128(__m128i /* v */, __m128i /* rkey */);
+
+/*
+ * Performs the last round of AES decryption of the first m128i
+ * using the second m128i as a round key.
+ */
+extern __m128i _mm_aesdeclast_si128(__m128i /* v */, __m128i /* rkey */);
+
+/*
+ * Performs 1 round of AES encryption of the first m128i using
+ * the second m128i as a round key.
+ */
+extern __m128i _mm_aesenc_si128(__m128i /* v */, __m128i /* rkey */);
+
+/*
+ * Performs the last round of AES encryption of the first m128i
+ * using the second m128i as a round key.
+ */
+extern __m128i _mm_aesenclast_si128(__m128i /* v */, __m128i /* rkey */);
+
+/*
+ * Performs the InverseMixColumn operation on the source m128i
+ * and stores the result into m128i destination.
+ */
+extern __m128i _mm_aesimc_si128(__m128i /* v */);
+
+/*
+ * Generates a m128i round key for the input m128i
+ * AES cipher key and byte round constant.
+ * The second parameter must be a compile time constant.
+ */
+extern __m128i _mm_aeskeygenassist_si128(__m128i /* ckey */, const int /* rcon */);
+
+/*
+ * Performs carry-less integer multiplication of 64-bit halves
+ * of 128-bit input operands.
+ * The third parameter indicates which 64-bit halves of the input parameters
+ * v1 and v2 should be used. It must be a compile time constant.
+ */
+extern __m128i _mm_clmulepi64_si128(__m128i /* v1 */, __m128i /* v2 */,
+                                            const int /* imm8 */);
+
+
+#if defined __cplusplus
+}; /* End "C" */
+#endif  /* defined __cplusplus */
+
+#endif  /* defined (_M_CEE_PURE) */
+#endif  /* __midl */
+#endif  /* _INCLUDED_WMM */

miniMSVC/VC/Tools/MSVC/14.42.34433/include/xatomic.h

@@ -0,0 +1,132 @@
+// xatomic.h internal header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XATOMIC_H
+#define _XATOMIC_H
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <type_traits>
+
+#include _STL_INTRIN_HEADER
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+#define _CONCATX(x, y) x##y
+#define _CONCAT(x, y)  _CONCATX(x, y)
+
+// Interlocked intrinsic mapping for _nf/_acq/_rel
+#if defined(_M_CEE_PURE) || (defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)) \
+    || (defined(_M_X64) && !defined(_M_ARM64EC))
+#define _INTRIN_RELAXED(x) x
+#define _INTRIN_ACQUIRE(x) x
+#define _INTRIN_RELEASE(x) x
+#define _INTRIN_ACQ_REL(x) x
+#ifdef _M_CEE_PURE
+#define _YIELD_PROCESSOR()
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+#define _YIELD_PROCESSOR() _mm_pause()
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+
+#elif defined(_M_ARM) || defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+#define _INTRIN_RELAXED(x) _CONCAT(x, _nf)
+#define _INTRIN_ACQUIRE(x) _CONCAT(x, _acq)
+#define _INTRIN_RELEASE(x) _CONCAT(x, _rel)
+// We don't have interlocked intrinsics for acquire-release ordering, even on
+// ARM32/ARM64, so fall back to sequentially consistent.
+#define _INTRIN_ACQ_REL(x) x
+#define _YIELD_PROCESSOR() __yield()
+
+#else // ^^^ ARM32/ARM64/ARM64EC/HYBRID_X86_ARM64 / unsupported hardware vvv
+#error Unsupported hardware
+#endif // hardware
+
+#define _MT_INCR(x) _INTRIN_RELAXED(_InterlockedIncrement)(reinterpret_cast<volatile long*>(&x))
+#define _MT_DECR(x) _INTRIN_ACQ_REL(_InterlockedDecrement)(reinterpret_cast<volatile long*>(&x))
+
+// The following macros are SHARED with vcruntime and any updates should be mirrored.
+// Also: if any macros are added they should be #undefed in vcruntime as well.
+#define _Compiler_barrier() _STL_DISABLE_DEPRECATED_WARNING _ReadWriteBarrier() _STL_RESTORE_DEPRECATED_WARNING
+
+#if defined(_M_ARM) || defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+#define _Memory_barrier()             __dmb(0xB) // inner shared data memory barrier
+#define _Compiler_or_memory_barrier() _Memory_barrier()
+#if defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+#define _Memory_load_acquire_barrier() __dmb(0x9) // inner shared data memory load barrier
+#else // ^^^ ARM64/ARM64EC/HYBRID_X86_ARM64 / ARM32 vvv
+#define _Memory_load_acquire_barrier() _Memory_barrier()
+#endif // ^^^ ARM32 ^^^
+#elif defined(_M_IX86) || defined(_M_X64)
+// x86/x64 hardware only emits memory barriers inside _Interlocked intrinsics
+#define _Compiler_or_memory_barrier() _Compiler_barrier()
+#else // ^^^ x86/x64 / unsupported hardware vvv
+#error Unsupported hardware
+#endif // hardware
+
+_STD_BEGIN
+
+#if _HAS_CXX20
+_EXPORT_STD enum class memory_order : int {
+    relaxed,
+    consume,
+    acquire,
+    release,
+    acq_rel,
+    seq_cst,
+
+    // LWG-3268
+    memory_order_relaxed = relaxed,
+    memory_order_consume = consume,
+    memory_order_acquire = acquire,
+    memory_order_release = release,
+    memory_order_acq_rel = acq_rel,
+    memory_order_seq_cst = seq_cst
+};
+_EXPORT_STD inline constexpr memory_order memory_order_relaxed = memory_order::relaxed;
+_EXPORT_STD inline constexpr memory_order memory_order_consume = memory_order::consume;
+_EXPORT_STD inline constexpr memory_order memory_order_acquire = memory_order::acquire;
+_EXPORT_STD inline constexpr memory_order memory_order_release = memory_order::release;
+_EXPORT_STD inline constexpr memory_order memory_order_acq_rel = memory_order::acq_rel;
+_EXPORT_STD inline constexpr memory_order memory_order_seq_cst = memory_order::seq_cst;
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+enum memory_order {
+    memory_order_relaxed,
+    memory_order_consume,
+    memory_order_acquire,
+    memory_order_release,
+    memory_order_acq_rel,
+    memory_order_seq_cst
+};
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+using _Atomic_counter_t = unsigned long;
+
+template <class _Integral, class _Ty>
+_NODISCARD volatile _Integral* _Atomic_address_as(_Ty& _Source) noexcept {
+    // gets a pointer to the argument as an integral type (to pass to intrinsics)
+    static_assert(is_integral_v<_Integral>, "Tried to reinterpret memory as non-integral");
+    return &reinterpret_cast<volatile _Integral&>(_Source);
+}
+
+template <class _Integral, class _Ty>
+_NODISCARD const volatile _Integral* _Atomic_address_as(const _Ty& _Source) noexcept {
+    // gets a pointer to the argument as an integral type (to pass to intrinsics)
+    static_assert(is_integral_v<_Integral>, "Tried to reinterpret memory as non-integral");
+    return &reinterpret_cast<const volatile _Integral&>(_Source);
+}
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XATOMIC_H

miniMSVC/VC/Tools/MSVC/14.42.34433/include/xatomic_wait.h

@@ -0,0 +1,70 @@
+// xatomic_wait.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XATOMIC_WAIT_H
+#define _XATOMIC_WAIT_H
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <cstdlib>
+#include <xatomic.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+extern "C" {
+inline constexpr unsigned long __std_atomic_wait_no_timeout = 0xFFFF'FFFF; // Pass as partial timeout
+
+enum class __std_atomic_api_level : unsigned long {
+    __not_set,
+    __detecting,
+    __has_srwlock,
+    __has_wait_on_address,
+};
+
+// This function allows testing the atomic wait support while always using the APIs for a platform with fewer
+// capabilities; it attempts to lock the APIs used to the level `_Requested_api_level`, and returns the actual API level
+// in use. Once the API level has been set by calling this function (or detected by a call to one of the atomic wait
+// functions), it can no longer be changed.
+__std_atomic_api_level __stdcall __std_atomic_set_api_level(__std_atomic_api_level _Requested_api_level) noexcept;
+
+// Support for atomic waits.
+// The "direct" functions are used when the underlying infrastructure can use WaitOnAddress directly; that is, _Size is
+// 1, 2, 4, or 8. The contract is the same as the WaitOnAddress function from the Windows SDK. If WaitOnAddress is not
+// available on the current platform, falls back to a similar solution based on SRWLOCK and CONDITION_VARIABLE.
+int __stdcall __std_atomic_wait_direct(
+    const void* _Storage, void* _Comparand, size_t _Size, unsigned long _Remaining_timeout) noexcept;
+void __stdcall __std_atomic_notify_one_direct(const void* _Storage) noexcept;
+void __stdcall __std_atomic_notify_all_direct(const void* _Storage) noexcept;
+
+// The "indirect" functions are used when the size is not 1, 2, 4, or 8; these notionally wait on another value which is
+// of one of those sizes whose value changes upon notify, hence "indirect". (As of 2020-07-24, this always uses the
+// fallback SRWLOCK and CONDITION_VARIABLE implementation but that is not contractual.)
+using _Atomic_wait_indirect_equal_callback_t = bool(__stdcall*)(
+    const void* _Storage, void* _Comparand, size_t _Size, void* _Param) _NOEXCEPT_FNPTR;
+
+int __stdcall __std_atomic_wait_indirect(const void* _Storage, void* _Comparand, size_t _Size, void* _Param,
+    _Atomic_wait_indirect_equal_callback_t _Are_equal, unsigned long _Remaining_timeout) noexcept;
+void __stdcall __std_atomic_notify_one_indirect(const void* _Storage) noexcept;
+void __stdcall __std_atomic_notify_all_indirect(const void* _Storage) noexcept;
+
+// These functions convert a duration into a time point in order to tolerate spurious wakes in atomic wait, and then
+// convert back from the time point to individual wait attempts (which are limited by DWORD milliseconds to a length of
+// ~49 days)
+unsigned long long __stdcall __std_atomic_wait_get_deadline(unsigned long long _Timeout) noexcept;
+unsigned long __stdcall __std_atomic_wait_get_remaining_timeout(unsigned long long _Deadline) noexcept;
+
+} // extern "C"
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XATOMIC_WAIT_H

miniMSVC/VC/Tools/MSVC/14.42.34433/include/xbit_ops.h

@@ -0,0 +1,97 @@
+// xbit_ops.h internal header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XBIT_OPS_H
+#define _XBIT_OPS_H
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <cstdint>
+
+#include _STL_INTRIN_HEADER
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+_NODISCARD inline unsigned long _Floor_of_log_2(size_t _Value) noexcept { // returns floor(log_2(_Value))
+    _Value |= size_t{1}; // avoid undefined answer from _BitScanReverse for 0
+    unsigned long _Result;
+
+#ifdef _M_CEE_PURE
+#ifdef _WIN64
+    _Result = 63;
+#else // ^^^ 64-bit / 32-bit vvv
+    _Result = 31;
+#endif // ^^^ 32-bit ^^^
+
+    while ((size_t{1} << _Result) > _Value) {
+        --_Result;
+    }
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+#ifdef _WIN64
+    // CodeQL [SM02313] _Result is always initialized: the code above guarantees that _Value is non-zero.
+    _BitScanReverse64(&_Result, _Value);
+#else // ^^^ 64-bit / 32-bit vvv
+    // CodeQL [SM02313] _Result is always initialized: the code above guarantees that _Value is non-zero.
+    _BitScanReverse(&_Result, _Value);
+#endif // ^^^ 32-bit ^^^
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+
+    return _Result;
+}
+
+_NODISCARD inline unsigned long _Ceiling_of_log_2(const size_t _Value) noexcept { // returns ceil(log_2(_Value))
+                                                                                  // pre: _Value > 1
+    return 1 + _Floor_of_log_2(_Value - 1);
+}
+
+_NODISCARD inline uint32_t _Bit_scan_reverse(const uint32_t _Value) noexcept {
+    unsigned long _Index; // Intentionally uninitialized for better codegen
+
+    if (_BitScanReverse(&_Index, _Value)) {
+        return _Index + 1;
+    }
+
+    return 0;
+}
+
+_NODISCARD inline uint32_t _Bit_scan_reverse(const uint64_t _Value) noexcept {
+    unsigned long _Index; // Intentionally uninitialized for better codegen
+
+#ifdef _WIN64
+    if (_BitScanReverse64(&_Index, _Value)) {
+        return _Index + 1;
+    }
+#else // ^^^ 64-bit / 32-bit vvv
+    uint32_t _Ui32 = static_cast<uint32_t>(_Value >> 32);
+
+    if (_BitScanReverse(&_Index, _Ui32)) {
+        return _Index + 1 + 32;
+    }
+
+    _Ui32 = static_cast<uint32_t>(_Value);
+
+    if (_BitScanReverse(&_Index, _Ui32)) {
+        return _Index + 1;
+    }
+#endif // ^^^ 32-bit ^^^
+
+    return 0;
+}
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XBIT_OPS_H

miniMSVC/VC/Tools/MSVC/14.42.34433/include/xcall_once.h

@@ -0,0 +1,117 @@
+// xcall_once.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XCALL_ONCE_H
+#define _XCALL_ONCE_H
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <cstdlib>
+#include <type_traits>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD struct once_flag { // opaque data structure for call_once()
+    constexpr once_flag() noexcept : _Opaque(nullptr) {}
+
+    once_flag(const once_flag&)            = delete;
+    once_flag& operator=(const once_flag&) = delete;
+
+    void* _Opaque;
+};
+
+template <class _Ty>
+union _Immortalizer_impl { // constructs _Ty, never destroys
+    constexpr _Immortalizer_impl() noexcept : _Storage{} {}
+    _Immortalizer_impl(const _Immortalizer_impl&)            = delete;
+    _Immortalizer_impl& operator=(const _Immortalizer_impl&) = delete;
+    ~_Immortalizer_impl() {
+        // do nothing
+    }
+
+    _Ty _Storage;
+};
+
+#if defined(_M_CEE) || defined(_M_ARM64EC) || defined(_M_HYBRID) \
+    || defined(__clang__) // TRANSITION, Clang doesn't recognize /ALTERNATENAME, not yet reported
+#define _WINDOWS_API              __stdcall
+#define _RENAME_WINDOWS_API(_Api) _Api##_clr
+#else // ^^^ use forwarders / use /ALTERNATENAME vvv
+#define _WINDOWS_API              __declspec(dllimport) __stdcall
+#define _RENAME_WINDOWS_API(_Api) _Api
+#endif // ^^^ use /ALTERNATENAME ^^^
+
+// WINBASEAPI
+// BOOL
+// WINAPI
+// InitOnceBeginInitialize(
+//     _Inout_ LPINIT_ONCE lpInitOnce,
+//     _In_ DWORD dwFlags,
+//     _Out_ PBOOL fPending,
+//     _Outptr_opt_result_maybenull_ LPVOID* lpContext
+//     );
+extern "C" _NODISCARD int _WINDOWS_API _RENAME_WINDOWS_API(__std_init_once_begin_initialize)(
+    void** _LpInitOnce, unsigned long _DwFlags, int* _FPending, void** _LpContext) noexcept;
+
+// WINBASEAPI
+// BOOL
+// WINAPI
+// InitOnceComplete(
+//     _Inout_ LPINIT_ONCE lpInitOnce,
+//     _In_ DWORD dwFlags,
+//     _In_opt_ LPVOID lpContext
+//     );
+extern "C" _NODISCARD int _WINDOWS_API _RENAME_WINDOWS_API(__std_init_once_complete)(
+    void** _LpInitOnce, unsigned long _DwFlags, void* _LpContext) noexcept;
+
+extern "C" [[noreturn]] void __stdcall __std_init_once_link_alternate_names_and_abort() noexcept;
+
+// #define RTL_RUN_ONCE_INIT_FAILED    0x00000004UL
+// #define INIT_ONCE_INIT_FAILED       RTL_RUN_ONCE_INIT_FAILED
+_INLINE_VAR constexpr unsigned long _Init_once_init_failed = 0x4UL;
+
+struct _Init_once_completer {
+    once_flag& _Once;
+    unsigned long _DwFlags;
+    ~_Init_once_completer() {
+        if (!_RENAME_WINDOWS_API(__std_init_once_complete)(&_Once._Opaque, _DwFlags, nullptr)) {
+            __std_init_once_link_alternate_names_and_abort();
+        }
+    }
+};
+
+_EXPORT_STD template <class _Fn, class... _Args>
+void(call_once)(once_flag& _Once, _Fn&& _Fx, _Args&&... _Ax) noexcept(
+    noexcept(_STD invoke(_STD forward<_Fn>(_Fx), _STD forward<_Args>(_Ax)...))) /* strengthened */ {
+    // call _Fx(_Ax...) once
+    // parentheses against common "#define call_once(flag,func) pthread_once(flag,func)"
+    int _Pending;
+    if (!_RENAME_WINDOWS_API(__std_init_once_begin_initialize)(&_Once._Opaque, 0, &_Pending, nullptr)) {
+        _CSTD abort();
+    }
+
+    if (_Pending != 0) {
+        _Init_once_completer _Op{_Once, _Init_once_init_failed};
+        _STD invoke(_STD forward<_Fn>(_Fx), _STD forward<_Args>(_Ax)...);
+        _Op._DwFlags = 0;
+    }
+}
+
+#undef _WINDOWS_API
+#undef _RENAME_WINDOWS_API
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XCALL_ONCE_H

miniMSVC/VC/Tools/MSVC/14.42.34433/include/xcharconv.h

@@ -0,0 +1,52 @@
+// xcharconv.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XCHARCONV_H
+#define _XCHARCONV_H
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX17
+#error The contents of <charconv> are only available with C++17. (Also, you should not include this internal header.)
+#endif // !_HAS_CXX17
+
+#include <cstdint>
+#include <type_traits>
+#include <xerrc.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD enum class chars_format {
+    scientific = 0b001,
+    fixed      = 0b010,
+    hex        = 0b100,
+    general    = fixed | scientific,
+};
+
+_BITMASK_OPS(_EXPORT_STD, chars_format)
+
+_EXPORT_STD struct to_chars_result {
+    char* ptr;
+    errc ec;
+#if _HAS_CXX20
+    _NODISCARD friend bool operator==(const to_chars_result&, const to_chars_result&) = default;
+#endif // _HAS_CXX20
+};
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XCHARCONV_H

miniMSVC/VC/Tools/MSVC/14.42.34433/include/xcharconv_ryu_tables.h

@@ -0,0 +1,157 @@
+// xcharconv_ryu_tables.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+
+// Copyright 2018 Ulf Adams
+// Copyright (c) Microsoft Corporation. All rights reserved.
+
+// Boost Software License - Version 1.0 - August 17th, 2003
+
+// Permission is hereby granted, free of charge, to any person or organization
+// obtaining a copy of the software and accompanying documentation covered by
+// this license (the "Software") to use, reproduce, display, distribute,
+// execute, and transmit the Software, and to prepare derivative works of the
+// Software, and to permit third-parties to whom the Software is furnished to
+// do so, all subject to the following:
+
+// The copyright notices in the Software and this entire statement, including
+// the above license grant, this restriction and the following disclaimer,
+// must be included in all copies of the Software, in whole or in part, and
+// all derivative works of the Software, unless such copies or derivative
+// works are solely in the form of machine-executable object code generated by
+// a source language processor.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+
+#ifndef _XCHARCONV_RYU_TABLES_H
+#define _XCHARCONV_RYU_TABLES_H
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX17
+#error The contents of <charconv> are only available with C++17. (Also, you should not include this internal header.)
+#endif // !_HAS_CXX17
+
+#include <cstdint>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+// https://github.com/ulfjack/ryu
+// See xcharconv_ryu.h for the exact commit.
+// (Keep the cgmanifest.json commitHash in sync.)
+
+// clang-format off
+
+// vvvvvvvvvv DERIVED FROM digit_table.h vvvvvvvvvv
+
+// A table of all two-digit numbers. This is used to speed up decimal digit
+// generation by copying pairs of digits into the final output.
+template <class _CharT> constexpr _CharT __DIGIT_TABLE[] = {_CharT{}};
+
+template <> inline constexpr char __DIGIT_TABLE<char>[200] = {
+  '0','0','0','1','0','2','0','3','0','4','0','5','0','6','0','7','0','8','0','9',
+  '1','0','1','1','1','2','1','3','1','4','1','5','1','6','1','7','1','8','1','9',
+  '2','0','2','1','2','2','2','3','2','4','2','5','2','6','2','7','2','8','2','9',
+  '3','0','3','1','3','2','3','3','3','4','3','5','3','6','3','7','3','8','3','9',
+  '4','0','4','1','4','2','4','3','4','4','4','5','4','6','4','7','4','8','4','9',
+  '5','0','5','1','5','2','5','3','5','4','5','5','5','6','5','7','5','8','5','9',
+  '6','0','6','1','6','2','6','3','6','4','6','5','6','6','6','7','6','8','6','9',
+  '7','0','7','1','7','2','7','3','7','4','7','5','7','6','7','7','7','8','7','9',
+  '8','0','8','1','8','2','8','3','8','4','8','5','8','6','8','7','8','8','8','9',
+  '9','0','9','1','9','2','9','3','9','4','9','5','9','6','9','7','9','8','9','9'
+};
+
+template <> inline constexpr wchar_t __DIGIT_TABLE<wchar_t>[200] = {
+  L'0',L'0',L'0',L'1',L'0',L'2',L'0',L'3',L'0',L'4',L'0',L'5',L'0',L'6',L'0',L'7',L'0',L'8',L'0',L'9',
+  L'1',L'0',L'1',L'1',L'1',L'2',L'1',L'3',L'1',L'4',L'1',L'5',L'1',L'6',L'1',L'7',L'1',L'8',L'1',L'9',
+  L'2',L'0',L'2',L'1',L'2',L'2',L'2',L'3',L'2',L'4',L'2',L'5',L'2',L'6',L'2',L'7',L'2',L'8',L'2',L'9',
+  L'3',L'0',L'3',L'1',L'3',L'2',L'3',L'3',L'3',L'4',L'3',L'5',L'3',L'6',L'3',L'7',L'3',L'8',L'3',L'9',
+  L'4',L'0',L'4',L'1',L'4',L'2',L'4',L'3',L'4',L'4',L'4',L'5',L'4',L'6',L'4',L'7',L'4',L'8',L'4',L'9',
+  L'5',L'0',L'5',L'1',L'5',L'2',L'5',L'3',L'5',L'4',L'5',L'5',L'5',L'6',L'5',L'7',L'5',L'8',L'5',L'9',
+  L'6',L'0',L'6',L'1',L'6',L'2',L'6',L'3',L'6',L'4',L'6',L'5',L'6',L'6',L'6',L'7',L'6',L'8',L'6',L'9',
+  L'7',L'0',L'7',L'1',L'7',L'2',L'7',L'3',L'7',L'4',L'7',L'5',L'7',L'6',L'7',L'7',L'7',L'8',L'7',L'9',
+  L'8',L'0',L'8',L'1',L'8',L'2',L'8',L'3',L'8',L'4',L'8',L'5',L'8',L'6',L'8',L'7',L'8',L'8',L'8',L'9',
+  L'9',L'0',L'9',L'1',L'9',L'2',L'9',L'3',L'9',L'4',L'9',L'5',L'9',L'6',L'9',L'7',L'9',L'8',L'9',L'9'
+};
+
+// ^^^^^^^^^^ DERIVED FROM digit_table.h ^^^^^^^^^^
+
+// vvvvvvvvvv DERIVED FROM d2s_full_table.h vvvvvvvvvv
+
+// These tables are generated by PrintDoubleLookupTable.
+extern const uint64_t __DOUBLE_POW5_INV_SPLIT[292][2];
+
+extern const uint64_t __DOUBLE_POW5_SPLIT[326][2];
+
+// ^^^^^^^^^^ DERIVED FROM d2s_full_table.h ^^^^^^^^^^
+
+// vvvvvvvvvv DERIVED FROM d2fixed_full_table.h vvvvvvvvvv
+
+inline constexpr int __TABLE_SIZE = 64;
+
+inline constexpr uint16_t __POW10_OFFSET[__TABLE_SIZE] = {
+  0, 2, 5, 8, 12, 16, 21, 26, 32, 39,
+  46, 54, 62, 71, 80, 90, 100, 111, 122, 134,
+  146, 159, 173, 187, 202, 217, 233, 249, 266, 283,
+  301, 319, 338, 357, 377, 397, 418, 440, 462, 485,
+  508, 532, 556, 581, 606, 632, 658, 685, 712, 740,
+  769, 798, 828, 858, 889, 920, 952, 984, 1017, 1050,
+  1084, 1118, 1153, 1188
+};
+
+extern const uint64_t __POW10_SPLIT[1224][3];
+
+inline constexpr int __TABLE_SIZE_2 = 69;
+inline constexpr int __ADDITIONAL_BITS_2 = 120;
+
+inline constexpr uint16_t __POW10_OFFSET_2[__TABLE_SIZE_2] = {
+     0,    2,    6,   12,   20,   29,   40,   52,   66,   80,
+    95,  112,  130,  150,  170,  192,  215,  240,  265,  292,
+   320,  350,  381,  413,  446,  480,  516,  552,  590,  629,
+   670,  712,  755,  799,  845,  892,  940,  989, 1040, 1092,
+  1145, 1199, 1254, 1311, 1369, 1428, 1488, 1550, 1613, 1678,
+  1743, 1810, 1878, 1947, 2017, 2088, 2161, 2235, 2311, 2387,
+  2465, 2544, 2625, 2706, 2789, 2873, 2959, 3046, 3133
+};
+
+inline constexpr uint8_t __MIN_BLOCK_2[__TABLE_SIZE_2] = {
+     0,    0,    0,    0,    0,    0,    1,    1,    2,    3,
+     3,    4,    4,    5,    5,    6,    6,    7,    7,    8,
+     8,    9,    9,   10,   11,   11,   12,   12,   13,   13,
+    14,   14,   15,   15,   16,   16,   17,   17,   18,   19,
+    19,   20,   20,   21,   21,   22,   22,   23,   23,   24,
+    24,   25,   26,   26,   27,   27,   28,   28,   29,   29,
+    30,   30,   31,   31,   32,   32,   33,   34,    0
+};
+
+extern const uint64_t __POW10_SPLIT_2[3133][3];
+
+// ^^^^^^^^^^ DERIVED FROM d2fixed_full_table.h ^^^^^^^^^^
+
+// clang-format on
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XCHARCONV_RYU_TABLES_H

miniMSVC/VC/Tools/MSVC/14.42.34433/include/xcharconv_tables.h

@@ -0,0 +1,113 @@
+// xcharconv_tables.h internal header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XCHARCONV_TABLES_H
+#define _XCHARCONV_TABLES_H
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX17
+#error The contents of <charconv> are only available with C++17. (Also, you should not include this internal header.)
+#endif // !_HAS_CXX17
+
+#include <cstdint>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// For general precision, we can use lookup tables to avoid performing trial formatting.
+
+// For a simple example, imagine counting the number of digits D in an integer, and needing to know
+// whether D is less than 3, equal to 3/4/5/6, or greater than 6. We could use a lookup table:
+// D | Largest integer with D digits
+// 2 |      99
+// 3 |     999
+// 4 |   9'999
+// 5 |  99'999
+// 6 | 999'999
+// 7 | table end
+// Looking up an integer in this table with lower_bound() will work:
+// * Too-small integers, like 7, 70, and 99, will cause lower_bound() to return the D == 2 row. (If all we care
+//   about is whether D is less than 3, then it's okay to smash the D == 1 and D == 2 cases together.)
+// * Integers in [100, 999] will cause lower_bound() to return the D == 3 row, and so forth.
+// * Too-large integers, like 1'000'000 and above, will cause lower_bound() to return the end of the table. If we
+//   compute D from that index, this will be considered D == 7, which will activate any "greater than 6" logic.
+
+// Floating-point is slightly more complicated.
+
+// The ordinary lookup tables are for X within [-5, 38] for float, and [-5, 308] for double.
+// (-5 absorbs too-negative exponents, outside the P > X >= -4 criterion. 38 and 308 are the maximum exponents.)
+// Due to the P > X condition, we can use a subset of the table for X within [-5, P - 1], suitably clamped.
+
+// When P is small, rounding can affect X. For example:
+// For P == 1, the largest double with X == 0 is: 9.4999999999999982236431605997495353221893310546875
+// For P == 2, the largest double with X == 0 is: 9.949999999999999289457264239899814128875732421875
+// For P == 3, the largest double with X == 0 is: 9.9949999999999992184029906638897955417633056640625
+
+// Exponent adjustment is a concern for P within [1, 7] for float, and [1, 15] for double (determined via
+// brute force). While larger values of P still perform rounding, they can't trigger exponent adjustment.
+// This is because only values with repeated '9' digits can undergo exponent adjustment during rounding,
+// and floating-point granularity limits the number of consecutive '9' digits that can appear.
+
+// So, we need special lookup tables for small values of P.
+// These tables have varying lengths due to the P > X >= -4 criterion. For example:
+// For P == 1, need table entries for X: -5, -4, -3, -2, -1, 0
+// For P == 2, need table entries for X: -5, -4, -3, -2, -1, 0, 1
+// For P == 3, need table entries for X: -5, -4, -3, -2, -1, 0, 1, 2
+// For P == 4, need table entries for X: -5, -4, -3, -2, -1, 0, 1, 2, 3
+
+// We can concatenate these tables for compact storage, using triangular numbers to access them.
+// The table for P begins at index (P - 1) * (P + 10) / 2 with length P + 5.
+
+// For both the ordinary and special lookup tables, after an index I is returned by lower_bound(), X is I - 5.
+
+// We need to special-case the floating-point value 0.0, which is considered to have X == 0.
+// Otherwise, the lookup tables would consider it to have a highly negative X.
+
+// Finally, because we're working with positive floating-point values,
+// representation comparisons behave identically to floating-point comparisons.
+
+// The generator is in /tools/scripts/charconv_tables_generate.cpp
+
+_STD_BEGIN
+
+template <class _Floating>
+struct _General_precision_tables_2;
+
+template <>
+struct _General_precision_tables_2<float> {
+    static constexpr int _Max_special_P = 7;
+
+    static const uint32_t _Special_X_table[63];
+
+    static constexpr int _Max_P = 39;
+
+    static const uint32_t _Ordinary_X_table[44];
+};
+
+template <>
+struct _General_precision_tables_2<double> {
+    static constexpr int _Max_special_P = 15;
+
+    static const uint64_t _Special_X_table[195];
+
+    static constexpr int _Max_P = 309;
+
+    static const uint64_t _Ordinary_X_table[314];
+};
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XCHARCONV_TABLES_H

miniMSVC/VC/Tools/MSVC/14.42.34433/include/xerrc.h

@@ -0,0 +1,108 @@
+// xerrc.h internal header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XERRC_H
+#define _XERRC_H
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD enum class errc { // names for generic error codes
+    address_family_not_supported                       = 102, // EAFNOSUPPORT
+    address_in_use                                     = 100, // EADDRINUSE
+    address_not_available                              = 101, // EADDRNOTAVAIL
+    already_connected                                  = 113, // EISCONN
+    argument_list_too_long                             = 7, // E2BIG
+    argument_out_of_domain                             = 33, // EDOM
+    bad_address                                        = 14, // EFAULT
+    bad_file_descriptor                                = 9, // EBADF
+    bad_message                                        = 104, // EBADMSG
+    broken_pipe                                        = 32, // EPIPE
+    connection_aborted                                 = 106, // ECONNABORTED
+    connection_already_in_progress                     = 103, // EALREADY
+    connection_refused                                 = 107, // ECONNREFUSED
+    connection_reset                                   = 108, // ECONNRESET
+    cross_device_link                                  = 18, // EXDEV
+    destination_address_required                       = 109, // EDESTADDRREQ
+    device_or_resource_busy                            = 16, // EBUSY
+    directory_not_empty                                = 41, // ENOTEMPTY
+    executable_format_error                            = 8, // ENOEXEC
+    file_exists                                        = 17, // EEXIST
+    file_too_large                                     = 27, // EFBIG
+    filename_too_long                                  = 38, // ENAMETOOLONG
+    function_not_supported                             = 40, // ENOSYS
+    host_unreachable                                   = 110, // EHOSTUNREACH
+    identifier_removed                                 = 111, // EIDRM
+    illegal_byte_sequence                              = 42, // EILSEQ
+    inappropriate_io_control_operation                 = 25, // ENOTTY
+    interrupted                                        = 4, // EINTR
+    invalid_argument                                   = 22, // EINVAL
+    invalid_seek                                       = 29, // ESPIPE
+    io_error                                           = 5, // EIO
+    is_a_directory                                     = 21, // EISDIR
+    message_size                                       = 115, // EMSGSIZE
+    network_down                                       = 116, // ENETDOWN
+    network_reset                                      = 117, // ENETRESET
+    network_unreachable                                = 118, // ENETUNREACH
+    no_buffer_space                                    = 119, // ENOBUFS
+    no_child_process                                   = 10, // ECHILD
+    no_link                                            = 121, // ENOLINK
+    no_lock_available                                  = 39, // ENOLCK
+    no_message_available _CXX23_DEPRECATE_UNIX_STREAMS = 120, // ENODATA
+    no_message                                         = 122, // ENOMSG
+    no_protocol_option                                 = 123, // ENOPROTOOPT
+    no_space_on_device                                 = 28, // ENOSPC
+    no_stream_resources _CXX23_DEPRECATE_UNIX_STREAMS  = 124, // ENOSR
+    no_such_device_or_address                          = 6, // ENXIO
+    no_such_device                                     = 19, // ENODEV
+    no_such_file_or_directory                          = 2, // ENOENT
+    no_such_process                                    = 3, // ESRCH
+    not_a_directory                                    = 20, // ENOTDIR
+    not_a_socket                                       = 128, // ENOTSOCK
+    not_a_stream _CXX23_DEPRECATE_UNIX_STREAMS         = 125, // ENOSTR
+    not_connected                                      = 126, // ENOTCONN
+    not_enough_memory                                  = 12, // ENOMEM
+    not_supported                                      = 129, // ENOTSUP
+    operation_canceled                                 = 105, // ECANCELED
+    operation_in_progress                              = 112, // EINPROGRESS
+    operation_not_permitted                            = 1, // EPERM
+    operation_not_supported                            = 130, // EOPNOTSUPP
+    operation_would_block                              = 140, // EWOULDBLOCK
+    owner_dead                                         = 133, // EOWNERDEAD
+    permission_denied                                  = 13, // EACCES
+    protocol_error                                     = 134, // EPROTO
+    protocol_not_supported                             = 135, // EPROTONOSUPPORT
+    read_only_file_system                              = 30, // EROFS
+    resource_deadlock_would_occur                      = 36, // EDEADLK
+    resource_unavailable_try_again                     = 11, // EAGAIN
+    result_out_of_range                                = 34, // ERANGE
+    state_not_recoverable                              = 127, // ENOTRECOVERABLE
+    stream_timeout _CXX23_DEPRECATE_UNIX_STREAMS       = 137, // ETIME
+    text_file_busy                                     = 139, // ETXTBSY
+    timed_out                                          = 138, // ETIMEDOUT
+    too_many_files_open_in_system                      = 23, // ENFILE
+    too_many_files_open                                = 24, // EMFILE
+    too_many_links                                     = 31, // EMLINK
+    too_many_symbolic_link_levels                      = 114, // ELOOP
+    value_too_large                                    = 132, // EOVERFLOW
+    wrong_protocol_type                                = 136 // EPROTOTYPE
+};
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XERRC_H

miniMSVC/VC/Tools/MSVC/14.42.34433/include/xfacet

@@ -0,0 +1,45 @@
+// xfacet internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// This header is used to compile the import library (via locale0_implib.cpp => locale0.cpp => xfacet).
+// MAJOR LIMITATIONS apply to what can be included here!
+// Before editing this file, read: /docs/import_library.md
+
+#ifndef _XFACET_
+#define _XFACET_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+extern "C++" class _CRTIMP2_PURE_IMPORT _Facet_base { // code for reference counting a facet
+public:
+    virtual __CLR_OR_THIS_CALL ~_Facet_base() noexcept {} // ensure that derived classes can be destroyed properly
+
+    // increment use count
+    virtual void __CLR_OR_THIS_CALL _Incref() noexcept = 0;
+
+    // decrement use count
+    virtual _Facet_base* __CLR_OR_THIS_CALL _Decref() noexcept = 0;
+};
+
+#if defined(_M_CEE)
+void __CLRCALL_OR_CDECL _Facet_Register_m(_Facet_base*);
+#else // ^^^ defined(_M_CEE) / !defined(_M_CEE) vvv
+extern "C++" void __CLRCALL_OR_CDECL _Facet_Register(_Facet_base*);
+#endif // ^^^ !defined(_M_CEE) ^^^
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XFACET_

miniMSVC/VC/Tools/MSVC/14.42.34433/include/xfilesystem_abi.h

@@ -0,0 +1,399 @@
+// xfilesystem_abi.h internal header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XFILESYSTEM_ABI_H
+#define _XFILESYSTEM_ABI_H
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <cstdint>
+#include <type_traits>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+extern "C" {
+inline constexpr size_t __std_fs_max_path      = 260; // #define MAX_PATH          260
+inline constexpr size_t __std_fs_temp_path_max = __std_fs_max_path + 1;
+
+enum class __std_win_error : unsigned long {
+    _Success                   = 0, // #define ERROR_SUCCESS                    0L
+    _Invalid_function          = 1, // #define ERROR_INVALID_FUNCTION           1L
+    _File_not_found            = 2, // #define ERROR_FILE_NOT_FOUND             2L
+    _Path_not_found            = 3, // #define ERROR_PATH_NOT_FOUND             3L
+    _Access_denied             = 5, // #define ERROR_ACCESS_DENIED              5L
+    _Not_enough_memory         = 8, // #define ERROR_NOT_ENOUGH_MEMORY          8L
+    _No_more_files             = 18, // #define ERROR_NO_MORE_FILES              18L
+    _Sharing_violation         = 32, // #define ERROR_SHARING_VIOLATION          32L
+    _Not_supported             = 50, // #define ERROR_NOT_SUPPORTED              50L
+    _Error_bad_netpath         = 53, // #define ERROR_BAD_NETPATH                53L
+    _File_exists               = 80, // #define ERROR_FILE_EXISTS                80L
+    _Invalid_parameter         = 87, // #define ERROR_INVALID_PARAMETER          87L
+    _Insufficient_buffer       = 122, // #define ERROR_INSUFFICIENT_BUFFER        122L
+    _Invalid_name              = 123, // #define ERROR_INVALID_NAME               123L
+    _Directory_not_empty       = 145, // #define ERROR_DIR_NOT_EMPTY              145L
+    _Already_exists            = 183, // #define ERROR_ALREADY_EXISTS             183L
+    _Filename_exceeds_range    = 206, // #define ERROR_FILENAME_EXCED_RANGE       206L
+    _Directory_name_is_invalid = 267, // #define ERROR_DIRECTORY                  267L
+    _Reparse_tag_invalid       = 4393L, // #define ERROR_REPARSE_TAG_INVALID        4393L
+    _Max                       = ~0UL // sentinel not used by Win32
+};
+
+#pragma warning(push)
+#pragma warning(disable : 4061) // enumerator not explicitly handled by switch label
+_NODISCARD inline bool __std_is_file_not_found(const __std_win_error _Error) noexcept {
+    switch (_Error) {
+    case __std_win_error::_File_not_found:
+    case __std_win_error::_Path_not_found:
+    case __std_win_error::_Error_bad_netpath:
+    case __std_win_error::_Invalid_name:
+    case __std_win_error::_Directory_name_is_invalid: // Windows 11 24H2
+        return true;
+    default:
+        return false;
+    }
+}
+#pragma warning(pop)
+
+enum class __std_fs_dir_handle : intptr_t { _Invalid = -1 };
+
+enum class __std_fs_file_attr : unsigned long {
+    _Readonly      = 0x00000001, // #define FILE_ATTRIBUTE_READONLY             0x00000001
+    _Hidden        = 0x00000002, // #define FILE_ATTRIBUTE_HIDDEN               0x00000002
+    _System        = 0x00000004, // #define FILE_ATTRIBUTE_SYSTEM               0x00000004
+    _Directory     = 0x00000010, // #define FILE_ATTRIBUTE_DIRECTORY            0x00000010
+    _Archive       = 0x00000020, // #define FILE_ATTRIBUTE_ARCHIVE              0x00000020
+    _Device        = 0x00000040, // #define FILE_ATTRIBUTE_DEVICE               0x00000040
+    _Normal        = 0x00000080, // #define FILE_ATTRIBUTE_NORMAL               0x00000080
+    _Temporary     = 0x00000100, // #define FILE_ATTRIBUTE_TEMPORARY            0x00000100
+    _Sparse_file   = 0x00000200, // #define FILE_ATTRIBUTE_SPARSE_FILE          0x00000200
+    _Reparse_point = 0x00000400, // #define FILE_ATTRIBUTE_REPARSE_POINT        0x00000400
+
+    _Invalid = 0xFFFFFFFF, // #define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
+};
+} // extern "C"
+
+_EXTERN_CXX_WORKAROUND
+_BITMASK_OPS(_EMPTY_ARGUMENT, __std_fs_file_attr)
+_END_EXTERN_CXX_WORKAROUND
+
+extern "C" {
+enum class __std_fs_reparse_tag : unsigned long {
+    _None        = 0,
+    _Mount_point = (0xA0000003L), // #define IO_REPARSE_TAG_MOUNT_POINT              (0xA0000003L)
+    _Symlink     = (0xA000000CL), // #define IO_REPARSE_TAG_SYMLINK                  (0xA000000CL)
+};
+
+struct __std_fs_filetime { // typedef struct _FILETIME {
+    unsigned long _Low; //     DWORD dwLowDateTime;
+    unsigned long _High; //     DWORD dwHighDateTime;
+}; // } FILETIME, *PFILETIME, *LPFILETIME;
+
+struct __std_fs_find_data { // typedef struct _WIN32_FIND_DATAW {
+    __std_fs_file_attr _Attributes; //     DWORD dwFileAttributes;
+    __std_fs_filetime _Creation_time; //     FILETIME ftCreationTime;
+    __std_fs_filetime _Last_access_time; //     FILETIME ftLastAccessTime;
+    __std_fs_filetime _Last_write_time; //     FILETIME ftLastWriteTime;
+    unsigned long _File_size_high; //     DWORD nFileSizeHigh;
+    unsigned long _File_size_low; //     DWORD nFileSizeLow;
+
+    // MSDN: dwReserved0 specifies the reparse point tag if
+    // MSDN:  (dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0
+
+    __std_fs_reparse_tag _Reparse_point_tag; //     DWORD dwReserved0;
+    unsigned long _Reserved1; //     DWORD dwReserved1;
+    wchar_t _File_name[__std_fs_max_path]; //     _Field_z_ WCHAR  cFileName[ MAX_PATH ];
+    wchar_t _Short_file_name[14]; //     _Field_z_ WCHAR  cAlternateFileName[ 14 ];
+}; // } WIN32_FIND_DATAW, ... ;
+
+enum class __std_fs_stats_flags : unsigned long {
+    _None = 0,
+
+    _Follow_symlinks = 0x01, // resolve symlink
+    _Attributes      = 0x02, // read/has attributes
+    _Reparse_tag     = 0x04, // read/has reparse_tag; may not be combined with _Follow_symlinks
+    _File_size       = 0x08, // read/has file size
+    _Link_count      = 0x10, // read/has link count
+    _Last_write_time = 0x20, // read/has last write time
+
+    _All_data = _Attributes | _Reparse_tag | _File_size | _Link_count | _Last_write_time
+};
+} // extern "C"
+
+_EXTERN_CXX_WORKAROUND
+_BITMASK_OPS(_EMPTY_ARGUMENT, __std_fs_stats_flags)
+_END_EXTERN_CXX_WORKAROUND
+
+extern "C" {
+struct __std_fs_stats {
+    long long _Last_write_time;
+    unsigned long long _File_size;
+    __std_fs_file_attr _Attributes;
+    __std_fs_reparse_tag _Reparse_point_tag;
+    unsigned long _Link_count;
+    __std_fs_stats_flags _Available; // which fields are available
+
+    _NODISCARD __std_fs_file_attr _Symlink_hint_attributes() const noexcept {
+        if (_STD _Bitmask_includes_any(_Available, __std_fs_stats_flags::_Attributes)) {
+            return _Attributes;
+        }
+
+        return __std_fs_file_attr::_Invalid;
+    }
+};
+
+struct __std_fs_reparse_data_buffer { // typedef struct _REPARSE_DATA_BUFFER
+    unsigned long _Reparse_tag;
+    unsigned short _Reparse_data_length;
+    unsigned short _Reserved;
+    union {
+        struct {
+            unsigned short _Substitute_name_offset;
+            unsigned short _Substitute_name_length;
+            unsigned short _Print_name_offset;
+            unsigned short _Print_name_length;
+            unsigned long _Flags;
+            wchar_t _Path_buffer[1];
+        } _Symbolic_link_reparse_buffer;
+        struct {
+            unsigned short _Substitute_name_offset;
+            unsigned short _Substitute_name_length;
+            unsigned short _Print_name_offset;
+            unsigned short _Print_name_length;
+            wchar_t _Path_buffer[1];
+        } _Mount_point_reparse_buffer;
+        struct {
+            unsigned char _Data_buffer[1];
+        } _Generic_reparse_buffer;
+    };
+};
+
+struct __std_ulong_and_error {
+    unsigned long _Size;
+    __std_win_error _Error;
+};
+
+enum class __std_fs_volume_name_kind : unsigned long {
+    _Dos  = 0, // #define VOLUME_NAME_DOS  0x0
+    _Guid = 1, // #define VOLUME_NAME_GUID 0x1
+    _Nt   = 2, // #define VOLUME_NAME_NT   0x2
+    _None = 4 // #define VOLUME_NAME_NONE 0x4
+};
+
+enum class __std_access_rights : unsigned long {
+    _Delete                = 0x00010000, // #define DELETE                           (0x00010000L)
+    _File_read_attributes  = 0x0080, // #define FILE_READ_ATTRIBUTES      ( 0x0080 )
+    _File_write_attributes = 0x0100, // #define FILE_WRITE_ATTRIBUTES     ( 0x0100 )
+
+    // #define READ_CONTROL          (0x00020000L)
+    // #define STANDARD_RIGHTS_WRITE (READ_CONTROL)
+    // #define FILE_WRITE_DATA       (0x0002)
+    // #define FILE_WRITE_ATTRIBUTES (0x0100)
+    // #define FILE_WRITE_EA         (0x0010)
+    // #define FILE_APPEND_DATA      (0x0004)
+    // #define SYNCHRONIZE           (0x00100000L)
+    // #define FILE_GENERIC_WRITE    (STANDARD_RIGHTS_WRITE | FILE_WRITE_DATA | FILE_WRITE_ATTRIBUTES
+    //                                   | FILE_WRITE_EA | FILE_APPEND_DATA | SYNCHRONIZE)
+    _File_generic_write = 0x00120116,
+};
+} // extern "C"
+
+_EXTERN_CXX_WORKAROUND
+_BITMASK_OPS(_EMPTY_ARGUMENT, __std_access_rights)
+_END_EXTERN_CXX_WORKAROUND
+
+extern "C" {
+enum class __std_fs_file_flags : unsigned long {
+    _None               = 0,
+    _Backup_semantics   = 0x02000000, // #define FILE_FLAG_BACKUP_SEMANTICS      0x02000000
+    _Open_reparse_point = 0x00200000, // #define FILE_FLAG_OPEN_REPARSE_POINT    0x00200000
+};
+} // extern "C"
+
+_EXTERN_CXX_WORKAROUND
+_BITMASK_OPS(_EMPTY_ARGUMENT, __std_fs_file_flags)
+_END_EXTERN_CXX_WORKAROUND
+
+extern "C" {
+enum class __std_fs_file_handle : intptr_t { _Invalid = -1 };
+
+enum class __std_code_page : unsigned int { _Acp = 0, _Utf8 = 65001 };
+
+struct __std_fs_convert_result {
+    int _Len;
+    __std_win_error _Err;
+};
+
+struct __std_fs_file_id { // typedef struct _FILE_ID_INFO {
+    unsigned long long _Volume_serial_number; //    ULONGLONG VolumeSerialNumber;
+    unsigned char _Id[16]; //    FILE_ID_128 FileId;
+}; // } FILE_ID_INFO, ...;
+
+enum class __std_fs_copy_options {
+    _None = 0x0,
+
+    _Existing_mask      = 0xF,
+    _Skip_existing      = 0x1,
+    _Overwrite_existing = 0x2,
+    _Update_existing    = 0x4,
+};
+} // extern "C"
+
+_EXTERN_CXX_WORKAROUND
+_BITMASK_OPS(_EMPTY_ARGUMENT, __std_fs_copy_options)
+_END_EXTERN_CXX_WORKAROUND
+
+extern "C" {
+_NODISCARD __std_ulong_and_error __stdcall __std_fs_get_full_path_name(_In_z_ const wchar_t* _Source,
+    _In_ unsigned long _Target_size, _Out_writes_z_(_Target_size) wchar_t* _Target) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_open_handle(_Out_ __std_fs_file_handle* _Handle,
+    _In_z_ const wchar_t* _File_name, _In_ __std_access_rights _Desired_access,
+    _In_ __std_fs_file_flags _Flags) noexcept;
+
+void __stdcall __std_fs_close_handle(__std_fs_file_handle _Handle) noexcept;
+
+_NODISCARD _Success_(return == __std_win_error::_Success) __std_win_error
+    __stdcall __std_fs_get_file_attributes_by_handle(
+        _In_ __std_fs_file_handle _Handle, _Out_ unsigned long* _File_attributes) noexcept;
+
+_NODISCARD __std_ulong_and_error __stdcall __std_fs_get_final_path_name_by_handle(_In_ __std_fs_file_handle _Handle,
+    _Out_writes_z_(_Target_size) wchar_t* _Target, _In_ unsigned long _Target_size,
+    _In_ __std_fs_volume_name_kind _Flags) noexcept;
+
+struct __std_fs_copy_file_result {
+    bool _Copied;
+    __std_win_error _Error;
+};
+
+_NODISCARD __std_fs_copy_file_result __stdcall __std_fs_copy_file(
+    _In_z_ const wchar_t* _Source, _In_z_ const wchar_t* _Target, _In_ __std_fs_copy_options _Options) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_directory_iterator_open(_In_z_ const wchar_t* _Path_spec,
+    _Inout_ __std_fs_dir_handle* _Handle, _Out_ __std_fs_find_data* _Results) noexcept;
+
+void __stdcall __std_fs_directory_iterator_close(_In_ __std_fs_dir_handle _Handle) noexcept;
+
+_NODISCARD _Success_(return == __std_win_error::_Success) __std_win_error
+    __stdcall __std_fs_get_stats(_In_z_ const wchar_t* _Path, __std_fs_stats* _Stats, _In_ __std_fs_stats_flags _Flags,
+        _In_ __std_fs_file_attr _Symlink_attribute_hint = __std_fs_file_attr::_Invalid) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_directory_iterator_advance(
+    _In_ __std_fs_dir_handle _Handle, _Out_ __std_fs_find_data* _Results) noexcept;
+
+_NODISCARD __std_code_page __stdcall __std_fs_code_page() noexcept;
+
+_NODISCARD __std_fs_convert_result __stdcall __std_fs_convert_narrow_to_wide(_In_ __std_code_page _Code_page,
+    _In_reads_(_Input_len) const char* _Input_str, _In_ int _Input_len,
+    _Out_writes_opt_(_Output_len) wchar_t* _Output_str, _In_ int _Output_len) noexcept;
+
+_NODISCARD __std_fs_convert_result __stdcall __std_fs_convert_wide_to_narrow(_In_ __std_code_page _Code_page,
+    _In_reads_(_Input_len) const wchar_t* _Input_str, _In_ int _Input_len,
+    _Out_writes_opt_(_Output_len) char* _Output_str, _In_ int _Output_len) noexcept;
+
+_NODISCARD __std_fs_convert_result __stdcall __std_fs_convert_wide_to_narrow_replace_chars(
+    _In_ __std_code_page _Code_page, _In_reads_(_Input_len) const wchar_t* _Input_str, _In_ int _Input_len,
+    _Out_writes_opt_(_Output_len) char* _Output_str, _In_ int _Output_len) noexcept;
+
+_NODISCARD _Success_(return == __std_win_error::_Success) __std_win_error
+    __stdcall __std_fs_get_file_id(_Out_ __std_fs_file_id* _Id, _In_z_ const wchar_t* _Path) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_set_last_write_time(
+    _In_ long long _Last_write_filetime, _In_z_ const wchar_t* _Path) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_change_permissions(
+    _In_z_ const wchar_t* _Path, _In_ bool _Follow_symlinks, _In_ bool _Readonly) noexcept;
+
+_NODISCARD _Success_(return._Error == __std_win_error::_Success) __std_ulong_and_error
+    __stdcall __std_fs_get_temp_path(_Out_writes_z_(__std_fs_temp_path_max) wchar_t* _Target) noexcept;
+
+_NODISCARD _Success_(return._Error == __std_win_error::_Success) __std_ulong_and_error
+    __stdcall __std_fs_get_current_path(
+        _In_ unsigned long _Target_size, _Out_writes_z_(_Target_size) wchar_t* _Target) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_set_current_path(_In_z_ const wchar_t* _Target) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_create_directory_symbolic_link(
+    _In_z_ const wchar_t* _Symlink_file_name, _In_z_ const wchar_t* _Target_file_name) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_create_hard_link(
+    _In_z_ const wchar_t* _File_name, _In_z_ const wchar_t* _Existing_file_name) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_create_symbolic_link(
+    _In_z_ const wchar_t* _Symlink_file_name, _In_z_ const wchar_t* _Target_file_name) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_read_reparse_data_buffer(_In_ __std_fs_file_handle _Handle,
+    _Out_writes_bytes_(_Buffer_size) void* _Buffer, _In_ unsigned long _Buffer_size) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_write_reparse_data_buffer(
+    _In_ __std_fs_file_handle _Handle, _In_ const __std_fs_reparse_data_buffer* _Buffer) noexcept;
+
+_NODISCARD bool __stdcall __std_fs_is_junction_from_reparse_data_buffer(
+    _In_ const __std_fs_reparse_data_buffer* _Buffer) noexcept;
+
+_NODISCARD _Success_(return == __std_win_error::_Success) __std_win_error
+    __stdcall __std_fs_read_name_from_reparse_data_buffer(
+        _In_ __std_fs_reparse_data_buffer* _Handle, _Out_ wchar_t** _Offset, _Out_ unsigned short* _Length) noexcept;
+
+struct __std_fs_create_directory_result {
+    bool _Created;
+    __std_win_error _Error;
+};
+
+_NODISCARD __std_fs_create_directory_result __stdcall __std_fs_create_directory(
+    _In_z_ const wchar_t* _New_directory) noexcept;
+
+struct __std_fs_remove_result {
+    bool _Removed;
+    __std_win_error _Error;
+};
+
+_NODISCARD __std_fs_remove_result __stdcall __std_fs_remove(_In_z_ const wchar_t* _Target) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_rename(
+    _In_z_ const wchar_t* _Source, _In_z_ const wchar_t* _Target) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_resize_file(_In_z_ const wchar_t* _Target, uintmax_t _New_size) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_space(_In_z_ const wchar_t* _Target, _Out_ uintmax_t* _Available,
+    _Out_ uintmax_t* _Total_bytes, _Out_ uintmax_t* _Free_bytes) noexcept;
+} // extern "C"
+
+_STD_BEGIN
+struct _Fs_file {
+    __std_fs_file_handle _Raw;
+
+    explicit _Fs_file(void* const _Handle) : _Raw{reinterpret_cast<intptr_t>(_Handle)} {}
+
+    _Fs_file(const wchar_t* const _File_name, const __std_access_rights _Desired_access,
+        const __std_fs_file_flags _Flags, __std_win_error* const _Err) {
+        *_Err = __std_fs_open_handle(&_Raw, _File_name, _Desired_access, _Flags);
+    }
+
+    _Fs_file(const _Fs_file&)            = delete;
+    _Fs_file& operator=(const _Fs_file&) = delete;
+
+    ~_Fs_file() {
+        __std_fs_close_handle(_Raw);
+    }
+
+    _NODISCARD void* _Get() const {
+        return reinterpret_cast<void*>(_Raw);
+    }
+};
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XFILESYSTEM_ABI_H