diff --git a/.gitattributes b/.gitattributes
index 9ffc0e77e93d4d6496fe1c96fcf6749b7521e0f2..f59a89fff2b8f3f58fce2d82eb91d8415ef7f310 100644
--- a/.gitattributes
+++ b/.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
diff --git a/miniCUDA124/lib/x64/nvfatbin_static.lib b/miniCUDA124/lib/x64/nvfatbin_static.lib
new file mode 100644
index 0000000000000000000000000000000000000000..55504180e445341083a4e25c387a6e21ce92e6ae
--- /dev/null
+++ b/miniCUDA124/lib/x64/nvfatbin_static.lib
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4b229fd6f7c3ccdd918b5f9a9e58d2974d67ff81c27d6f3729e463ea088d8ac6
+size 4004556
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/__msvc_all_public_headers.hpp b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/__msvc_all_public_headers.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..ad3e8286d980f81c834e4188284e8df8be01dd94
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/__msvc_bit_utils.hpp b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/__msvc_bit_utils.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..eb86c43d0f4faa7669861d372b85069f0cec58ec
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/__msvc_chrono.hpp b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/__msvc_chrono.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..08268b83b840cd699644b246ad412d7e921c2987
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/__msvc_cxx_stdatomic.hpp b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/__msvc_cxx_stdatomic.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..f6874f70a22c9847d02631461f1c9a6a0865c1a2
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/__msvc_filebuf.hpp b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/__msvc_filebuf.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..4d8e76dbc17c84d911bed2d7f5a03d763ce37a34
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/__msvc_format_ucd_tables.hpp b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/__msvc_format_ucd_tables.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..15699df88f101562183611209f3b9c1f6090b86a
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/__msvc_formatter.hpp b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/__msvc_formatter.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..5ff1bea2f4b24589e2d94ebb3e75bd550258f37f
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/system_error b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/system_error
new file mode 100644
index 0000000000000000000000000000000000000000..51ac72440b72592929669f4cf16c9bc911240b90
--- /dev/null
+++ b/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_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/thread b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/thread
new file mode 100644
index 0000000000000000000000000000000000000000..079f4b7af3638749b4bffbda632a4282799dce0a
--- /dev/null
+++ b/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_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/threads.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/threads.h
new file mode 100644
index 0000000000000000000000000000000000000000..ce426dc8c9a5cc7064a4f39484a89cdf259ba7be
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/tmmintrin.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/tmmintrin.h
new file mode 100644
index 0000000000000000000000000000000000000000..efd0c5781b4785db13f9ccb2d9ea38af8a56cd5f
--- /dev/null
+++ b/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 */
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/tuple b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/tuple
new file mode 100644
index 0000000000000000000000000000000000000000..0f79be7872e8cfc8bcf7f5e9689e971d10d5571e
--- /dev/null
+++ b/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_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/type_traits b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/type_traits
new file mode 100644
index 0000000000000000000000000000000000000000..3f941094cd803306936c2c56f78f4dbbf9f0b08c
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/type_traits
@@ -0,0 +1,2599 @@
+// type_traits standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _TYPE_TRAITS_
+#define _TYPE_TRAITS_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <cstddef>
+#include <cstdint>
+#include <xtr1common>
+
+#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")
+#undef msvc
+#undef intrinsic
+#undef known_semantics
+
+_STD_BEGIN
+template <class>
+constexpr bool _Always_false = false; // TRANSITION, needed by CUDA 12.4 in classes; see CWG-2518, VSO-2016422 (EDG)
+
+template <bool _First_value, class _First, class... _Rest>
+struct _Conjunction { // handle false trait or last trait
+    using type = _First;
+};
+
+template <class _True, class _Next, class... _Rest>
+struct _Conjunction<true, _True, _Next, _Rest...> { // the first trait is true, try the next one
+    using type = typename _Conjunction<static_cast<bool>(_Next::value), _Next, _Rest...>::type;
+};
+
+_EXPORT_STD template <class... _Traits>
+struct conjunction : true_type {}; // If _Traits is empty, true_type
+
+template <class _First, class... _Rest>
+struct conjunction<_First, _Rest...> : _Conjunction<static_cast<bool>(_First::value), _First, _Rest...>::type {
+    // the first false trait in _Traits, or the last trait if none are false
+};
+
+_EXPORT_STD template <class... _Traits>
+constexpr bool conjunction_v = conjunction<_Traits...>::value;
+
+_EXPORT_STD template <class _Trait>
+struct negation : bool_constant<!static_cast<bool>(_Trait::value)> {}; // The negated result of _Trait
+
+_EXPORT_STD template <class _Trait>
+constexpr bool negation_v = negation<_Trait>::value;
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_void_v = is_same_v<remove_cv_t<_Ty>, void>;
+
+_EXPORT_STD template <class _Ty>
+struct is_void : bool_constant<is_void_v<_Ty>> {};
+
+_EXPORT_STD template <class... _Types>
+using void_t = void;
+
+template <class _Ty>
+struct _Identity {
+    using type = _Ty;
+};
+template <class _Ty>
+using _Identity_t _MSVC_KNOWN_SEMANTICS = typename _Identity<_Ty>::type;
+
+// Type modifiers
+_EXPORT_STD template <class _Ty>
+struct add_const { // add top-level const qualifier
+    using type = const _Ty;
+};
+
+_EXPORT_STD template <class _Ty>
+using add_const_t = typename add_const<_Ty>::type;
+
+_EXPORT_STD template <class _Ty>
+struct add_volatile { // add top-level volatile qualifier
+    using type = volatile _Ty;
+};
+
+_EXPORT_STD template <class _Ty>
+using add_volatile_t = typename add_volatile<_Ty>::type;
+
+_EXPORT_STD template <class _Ty>
+struct add_cv { // add top-level const and volatile qualifiers
+    using type = const volatile _Ty;
+};
+
+_EXPORT_STD template <class _Ty>
+using add_cv_t = typename add_cv<_Ty>::type;
+
+template <class _Ty, class = void>
+struct _Add_reference { // add reference (non-referenceable type)
+    using _Lvalue = _Ty;
+    using _Rvalue = _Ty;
+};
+
+template <class _Ty>
+struct _Add_reference<_Ty, void_t<_Ty&>> { // (referenceable type)
+    using _Lvalue = _Ty&;
+    using _Rvalue = _Ty&&;
+};
+
+_EXPORT_STD template <class _Ty>
+struct add_lvalue_reference {
+    using type = typename _Add_reference<_Ty>::_Lvalue;
+};
+
+_EXPORT_STD template <class _Ty>
+using add_lvalue_reference_t = typename _Add_reference<_Ty>::_Lvalue;
+
+_EXPORT_STD template <class _Ty>
+struct add_rvalue_reference {
+    using type = typename _Add_reference<_Ty>::_Rvalue;
+};
+
+_EXPORT_STD template <class _Ty>
+using add_rvalue_reference_t = typename _Add_reference<_Ty>::_Rvalue;
+
+_EXPORT_STD template <class _Ty>
+add_rvalue_reference_t<_Ty> declval() noexcept {
+    static_assert(false, "Calling declval is ill-formed, see N4950 [declval]/2.");
+}
+
+_EXPORT_STD template <class _Ty>
+struct remove_extent { // remove array extent
+    using type = _Ty;
+};
+
+template <class _Ty, size_t _Ix>
+struct remove_extent<_Ty[_Ix]> {
+    using type = _Ty;
+};
+
+template <class _Ty>
+struct remove_extent<_Ty[]> {
+    using type = _Ty;
+};
+
+_EXPORT_STD template <class _Ty>
+using remove_extent_t = typename remove_extent<_Ty>::type;
+
+_EXPORT_STD template <class _Ty>
+struct remove_all_extents { // remove all array extents
+    using type = _Ty;
+};
+
+template <class _Ty, size_t _Ix>
+struct remove_all_extents<_Ty[_Ix]> {
+    using type = typename remove_all_extents<_Ty>::type;
+};
+
+template <class _Ty>
+struct remove_all_extents<_Ty[]> {
+    using type = typename remove_all_extents<_Ty>::type;
+};
+
+_EXPORT_STD template <class _Ty>
+using remove_all_extents_t = typename remove_all_extents<_Ty>::type;
+
+_EXPORT_STD template <class _Ty>
+struct remove_pointer {
+    using type = _Ty;
+};
+
+template <class _Ty>
+struct remove_pointer<_Ty*> {
+    using type = _Ty;
+};
+
+template <class _Ty>
+struct remove_pointer<_Ty* const> {
+    using type = _Ty;
+};
+
+template <class _Ty>
+struct remove_pointer<_Ty* volatile> {
+    using type = _Ty;
+};
+
+template <class _Ty>
+struct remove_pointer<_Ty* const volatile> {
+    using type = _Ty;
+};
+
+_EXPORT_STD template <class _Ty>
+using remove_pointer_t = typename remove_pointer<_Ty>::type;
+
+template <class _Ty, class = void>
+struct _Add_pointer { // add pointer (pointer type cannot be formed)
+    using type = _Ty;
+};
+
+template <class _Ty>
+struct _Add_pointer<_Ty, void_t<remove_reference_t<_Ty>*>> { // (pointer type can be formed)
+    using type = remove_reference_t<_Ty>*;
+};
+
+_EXPORT_STD template <class _Ty>
+struct add_pointer {
+    using type = typename _Add_pointer<_Ty>::type;
+};
+
+_EXPORT_STD template <class _Ty>
+using add_pointer_t = typename _Add_pointer<_Ty>::type;
+
+_EXPORT_STD template <class>
+constexpr bool is_array_v = false; // determine whether type argument is an array
+
+template <class _Ty, size_t _Nx>
+constexpr bool is_array_v<_Ty[_Nx]> = true;
+
+template <class _Ty>
+constexpr bool is_array_v<_Ty[]> = true;
+
+_EXPORT_STD template <class _Ty>
+struct is_array : bool_constant<is_array_v<_Ty>> {};
+
+#if _HAS_CXX20
+_EXPORT_STD template <class>
+constexpr bool is_bounded_array_v = false;
+
+template <class _Ty, size_t _Nx>
+constexpr bool is_bounded_array_v<_Ty[_Nx]> = true;
+
+_EXPORT_STD template <class _Ty>
+struct is_bounded_array : bool_constant<is_bounded_array_v<_Ty>> {};
+
+_EXPORT_STD template <class>
+constexpr bool is_unbounded_array_v = false;
+
+template <class _Ty>
+constexpr bool is_unbounded_array_v<_Ty[]> = true;
+
+_EXPORT_STD template <class _Ty>
+struct is_unbounded_array : bool_constant<is_unbounded_array_v<_Ty>> {};
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class>
+constexpr bool is_lvalue_reference_v = false; // determine whether type argument is an lvalue reference
+
+template <class _Ty>
+constexpr bool is_lvalue_reference_v<_Ty&> = true;
+
+_EXPORT_STD template <class _Ty>
+struct is_lvalue_reference : bool_constant<is_lvalue_reference_v<_Ty>> {};
+
+_EXPORT_STD template <class>
+constexpr bool is_rvalue_reference_v = false; // determine whether type argument is an rvalue reference
+
+template <class _Ty>
+constexpr bool is_rvalue_reference_v<_Ty&&> = true;
+
+_EXPORT_STD template <class _Ty>
+struct is_rvalue_reference : bool_constant<is_rvalue_reference_v<_Ty>> {};
+
+_EXPORT_STD template <class>
+constexpr bool is_reference_v = false; // determine whether type argument is a reference
+
+template <class _Ty>
+constexpr bool is_reference_v<_Ty&> = true;
+
+template <class _Ty>
+constexpr bool is_reference_v<_Ty&&> = true;
+
+_EXPORT_STD template <class _Ty>
+struct is_reference : bool_constant<is_reference_v<_Ty>> {};
+
+_EXPORT_STD template <class>
+constexpr bool is_pointer_v = false; // determine whether _Ty is a pointer
+
+template <class _Ty>
+constexpr bool is_pointer_v<_Ty*> = true;
+
+template <class _Ty>
+constexpr bool is_pointer_v<_Ty* const> = true;
+
+template <class _Ty>
+constexpr bool is_pointer_v<_Ty* volatile> = true;
+
+template <class _Ty>
+constexpr bool is_pointer_v<_Ty* const volatile> = true;
+
+_EXPORT_STD template <class _Ty>
+struct is_pointer : bool_constant<is_pointer_v<_Ty>> {};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_null_pointer_v =
+    is_same_v<remove_cv_t<_Ty>, nullptr_t>; // determine whether _Ty is cv-qualified nullptr_t
+
+_EXPORT_STD template <class _Ty>
+struct is_null_pointer : bool_constant<is_null_pointer_v<_Ty>> {};
+
+_EXPORT_STD template <class _Ty>
+struct is_union : bool_constant<__is_union(_Ty)> {}; // determine whether _Ty is a union
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_union_v = __is_union(_Ty);
+
+_EXPORT_STD template <class _Ty>
+struct is_class : bool_constant<__is_class(_Ty)> {}; // determine whether _Ty is a class
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_class_v = __is_class(_Ty);
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_fundamental_v = is_arithmetic_v<_Ty> || is_void_v<_Ty> || is_null_pointer_v<_Ty>;
+
+_EXPORT_STD template <class _Ty>
+struct is_fundamental : bool_constant<is_fundamental_v<_Ty>> {}; // determine whether _Ty is a fundamental type
+
+_EXPORT_STD template <class _From, class _To>
+struct is_convertible : bool_constant<__is_convertible_to(_From, _To)> {
+    // determine whether _From is convertible to _To
+};
+
+_EXPORT_STD template <class _From, class _To>
+constexpr bool is_convertible_v = __is_convertible_to(_From, _To);
+
+#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, DevCom-1627396
+template <class _Ty>
+struct is_convertible<_Ty&, volatile _Ty&> : true_type {};
+
+template <class _Ty>
+struct is_convertible<volatile _Ty&, volatile _Ty&> : true_type {};
+
+template <class _Ty>
+struct is_convertible<_Ty&, const volatile _Ty&> : true_type {};
+
+template <class _Ty>
+struct is_convertible<volatile _Ty&, const volatile _Ty&> : true_type {};
+
+template <class _Ty>
+constexpr bool is_convertible_v<_Ty&, volatile _Ty&> = true;
+
+template <class _Ty>
+constexpr bool is_convertible_v<volatile _Ty&, volatile _Ty&> = true;
+
+template <class _Ty>
+constexpr bool is_convertible_v<_Ty&, const volatile _Ty&> = true;
+
+template <class _Ty>
+constexpr bool is_convertible_v<volatile _Ty&, const volatile _Ty&> = true;
+#endif // ^^^ workaround ^^^
+
+_EXPORT_STD template <class _Ty>
+struct is_enum : bool_constant<__is_enum(_Ty)> {}; // determine whether _Ty is an enumerated type
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_enum_v = __is_enum(_Ty);
+
+#if _HAS_CXX23
+_EXPORT_STD template <class _Ty>
+constexpr bool is_scoped_enum_v = conjunction_v<is_enum<_Ty>, negation<is_convertible<_Ty, int>>>;
+
+_EXPORT_STD template <class _Ty>
+struct is_scoped_enum : bool_constant<is_scoped_enum_v<_Ty>> {};
+#endif // _HAS_CXX23
+
+_EXPORT_STD template <class _Ty>
+struct is_compound : bool_constant<!is_fundamental_v<_Ty>> {}; // determine whether _Ty is a compound type
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_compound_v = !is_fundamental_v<_Ty>;
+
+#define _EMIT_CDECL(FUNC, OPT1, OPT2, OPT3) FUNC(__cdecl, OPT1, OPT2, OPT3)
+
+#ifdef _M_CEE
+#define _EMIT_CLRCALL(FUNC, OPT1, OPT2, OPT3) FUNC(__clrcall, OPT1, OPT2, OPT3)
+#else // ^^^ __clrcall supported / __clrcall not supported vvv
+#define _EMIT_CLRCALL(FUNC, OPT1, OPT2, OPT3)
+#endif // ^^^ __clrcall not supported ^^^
+
+#if defined(_M_IX86) && !defined(_M_CEE)
+#define _EMIT_FASTCALL(FUNC, OPT1, OPT2, OPT3) FUNC(__fastcall, OPT1, OPT2, OPT3)
+#else // ^^^ __fastcall supported / __fastcall not supported vvv
+#define _EMIT_FASTCALL(FUNC, OPT1, OPT2, OPT3)
+#endif // ^^^ __fastcall not supported ^^^
+
+#ifdef _M_IX86
+#define _EMIT_STDCALL(FUNC, OPT1, OPT2, OPT3)  FUNC(__stdcall, OPT1, OPT2, OPT3)
+#define _EMIT_THISCALL(FUNC, OPT1, OPT2, OPT3) FUNC(__thiscall, OPT1, OPT2, OPT3)
+#else // ^^^ __stdcall and __thiscall supported / __stdcall and __thiscall not supported vvv
+#define _EMIT_STDCALL(FUNC, OPT1, OPT2, OPT3)
+#define _EMIT_THISCALL(FUNC, OPT1, OPT2, OPT3)
+#endif // ^^^ __stdcall and __thiscall not supported ^^^
+
+#if ((defined(_M_IX86) && _M_IX86_FP >= 2) || (defined(_M_X64) && !defined(_M_ARM64EC))) && !defined(_M_CEE)
+#define _EMIT_VECTORCALL(FUNC, OPT1, OPT2, OPT3) FUNC(__vectorcall, OPT1, OPT2, OPT3)
+#else // ^^^ __vectorcall supported / __vectorcall not supported vvv
+#define _EMIT_VECTORCALL(FUNC, OPT1, OPT2, OPT3)
+#endif // ^^^ __vectorcall not supported ^^^
+
+#define _NON_MEMBER_CALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT) \
+    _EMIT_CDECL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)          \
+    _EMIT_CLRCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)        \
+    _EMIT_FASTCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)       \
+    _EMIT_STDCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)        \
+    _EMIT_VECTORCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)
+
+#define _NON_MEMBER_CALL_CV(FUNC, REF_OPT, NOEXCEPT_OPT)    \
+    _NON_MEMBER_CALL(FUNC, , REF_OPT, NOEXCEPT_OPT)         \
+    _NON_MEMBER_CALL(FUNC, const, REF_OPT, NOEXCEPT_OPT)    \
+    _NON_MEMBER_CALL(FUNC, volatile, REF_OPT, NOEXCEPT_OPT) \
+    _NON_MEMBER_CALL(FUNC, const volatile, REF_OPT, NOEXCEPT_OPT)
+
+#define _NON_MEMBER_CALL_CV_REF(FUNC, NOEXCEPT_OPT) \
+    _NON_MEMBER_CALL_CV(FUNC, , NOEXCEPT_OPT)       \
+    _NON_MEMBER_CALL_CV(FUNC, &, NOEXCEPT_OPT)      \
+    _NON_MEMBER_CALL_CV(FUNC, &&, NOEXCEPT_OPT)
+
+#ifdef __cpp_noexcept_function_type
+#define _NON_MEMBER_CALL_CV_REF_NOEXCEPT(FUNC) \
+    _NON_MEMBER_CALL_CV_REF(FUNC, )            \
+    _NON_MEMBER_CALL_CV_REF(FUNC, noexcept)
+#else // ^^^ defined(__cpp_noexcept_function_type) / !defined(__cpp_noexcept_function_type) vvv
+#define _NON_MEMBER_CALL_CV_REF_NOEXCEPT(FUNC) _NON_MEMBER_CALL_CV_REF(FUNC, )
+#endif // ^^^ !defined(__cpp_noexcept_function_type) ^^^
+
+#define _MEMBER_CALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT) \
+    _EMIT_CDECL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)      \
+    _EMIT_CLRCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)    \
+    _EMIT_FASTCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)   \
+    _EMIT_STDCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)    \
+    _EMIT_THISCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)   \
+    _EMIT_VECTORCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)
+
+#define _MEMBER_CALL_CV(FUNC, REF_OPT, NOEXCEPT_OPT)    \
+    _MEMBER_CALL(FUNC, , REF_OPT, NOEXCEPT_OPT)         \
+    _MEMBER_CALL(FUNC, const, REF_OPT, NOEXCEPT_OPT)    \
+    _MEMBER_CALL(FUNC, volatile, REF_OPT, NOEXCEPT_OPT) \
+    _MEMBER_CALL(FUNC, const volatile, REF_OPT, NOEXCEPT_OPT)
+
+#define _MEMBER_CALL_CV_REF(FUNC, NOEXCEPT_OPT) \
+    _MEMBER_CALL_CV(FUNC, , NOEXCEPT_OPT)       \
+    _MEMBER_CALL_CV(FUNC, &, NOEXCEPT_OPT)      \
+    _MEMBER_CALL_CV(FUNC, &&, NOEXCEPT_OPT)
+
+#ifdef __cpp_noexcept_function_type
+#define _MEMBER_CALL_CV_REF_NOEXCEPT(FUNC) \
+    _MEMBER_CALL_CV_REF(FUNC, )            \
+    _MEMBER_CALL_CV_REF(FUNC, noexcept)
+#else // ^^^ defined(__cpp_noexcept_function_type) / !defined(__cpp_noexcept_function_type) vvv
+#define _MEMBER_CALL_CV_REF_NOEXCEPT(FUNC) _MEMBER_CALL_CV_REF(FUNC, )
+#endif // ^^^ !defined(__cpp_noexcept_function_type) ^^^
+
+#ifdef __cpp_noexcept_function_type
+#define _CLASS_DEFINE_CV_REF_NOEXCEPT(CLASS) \
+    CLASS(_EMPTY_ARGUMENT)                   \
+    CLASS(const)                             \
+    CLASS(volatile)                          \
+    CLASS(const volatile)                    \
+    CLASS(&)                                 \
+    CLASS(const&)                            \
+    CLASS(volatile&)                         \
+    CLASS(const volatile&)                   \
+    CLASS(&&)                                \
+    CLASS(const&&)                           \
+    CLASS(volatile&&)                        \
+    CLASS(const volatile&&)                  \
+    CLASS(noexcept)                          \
+    CLASS(const noexcept)                    \
+    CLASS(volatile noexcept)                 \
+    CLASS(const volatile noexcept)           \
+    CLASS(& noexcept)                        \
+    CLASS(const& noexcept)                   \
+    CLASS(volatile& noexcept)                \
+    CLASS(const volatile& noexcept)          \
+    CLASS(&& noexcept)                       \
+    CLASS(const&& noexcept)                  \
+    CLASS(volatile&& noexcept)               \
+    CLASS(const volatile&& noexcept)
+#else // ^^^ defined(__cpp_noexcept_function_type) / !defined(__cpp_noexcept_function_type) vvv
+#define _CLASS_DEFINE_CV_REF_NOEXCEPT(CLASS) \
+    CLASS(_EMPTY_ARGUMENT)                   \
+    CLASS(const)                             \
+    CLASS(volatile)                          \
+    CLASS(const volatile)                    \
+    CLASS(&)                                 \
+    CLASS(const&)                            \
+    CLASS(volatile&)                         \
+    CLASS(const volatile&)                   \
+    CLASS(&&)                                \
+    CLASS(const&&)                           \
+    CLASS(volatile&&)                        \
+    CLASS(const volatile&&)
+#endif // ^^^ !defined(__cpp_noexcept_function_type) ^^^
+
+template <class... _Types>
+struct _Arg_types {}; // provide argument_type, etc. when sizeof...(_Types) is 1 or 2
+
+template <class _Ty1>
+struct _Arg_types<_Ty1> {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty1;
+};
+
+template <class _Ty1, class _Ty2>
+struct _Arg_types<_Ty1, _Ty2> {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty1;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty2;
+};
+
+template <class _Ty>
+struct _Is_memfunptr { // base class for member function pointer predicates
+    using _Bool_type = false_type; // NB: members are user-visible via _Weak_types
+};
+
+#define _IS_MEMFUNPTR(CALL_OPT, CV_OPT, REF_OPT, NOEXCEPT_OPT)                            \
+    template <class _Ret, class _Arg0, class... _Types>                                   \
+    struct _Is_memfunptr<_Ret (CALL_OPT _Arg0::*)(_Types...) CV_OPT REF_OPT NOEXCEPT_OPT> \
+        : _Arg_types<CV_OPT _Arg0*, _Types...> {                                          \
+        using _Bool_type                                          = true_type;            \
+        using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ret;                 \
+        using _Class_type                                         = _Arg0;                \
+        using _Guide_type = enable_if<!is_same_v<int REF_OPT, int&&>, _Ret(_Types...)>;   \
+    };
+
+_MEMBER_CALL_CV_REF_NOEXCEPT(_IS_MEMFUNPTR)
+#undef _IS_MEMFUNPTR
+
+#define _IS_MEMFUNPTR_ELLIPSIS(CV_REF_NOEXCEPT_OPT)                                   \
+    template <class _Ret, class _Arg0, class... _Types>                               \
+    struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...)                              \
+            CV_REF_NOEXCEPT_OPT> { /* no calling conventions for ellipsis */          \
+        using _Bool_type                                          = true_type;        \
+        using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ret;             \
+        using _Class_type                                         = _Arg0;            \
+        using _Guide_type                                         = enable_if<false>; \
+    };
+
+_CLASS_DEFINE_CV_REF_NOEXCEPT(_IS_MEMFUNPTR_ELLIPSIS)
+#undef _IS_MEMFUNPTR_ELLIPSIS
+
+#if _HAS_CXX23 && !defined(__clang__) // TRANSITION, DevCom-10107077, Clang has not implemented Deducing this
+#define _IS_MEMFUNPTR_EXPLICIT_THIS_GUIDES(CALL_OPT, CV_OPT, REF_OPT, NOEXCEPT_OPT) \
+    template <class _Ret, class _Self, class... _Args>                              \
+    struct _Is_memfunptr<_Ret(CALL_OPT*)(_Self, _Args...) NOEXCEPT_OPT> {           \
+        using _Bool_type  = false_type;                                             \
+        using _Guide_type = _Identity<_Ret(_Args...)>;                              \
+    };
+
+_NON_MEMBER_CALL(_IS_MEMFUNPTR_EXPLICIT_THIS_GUIDES, , , )
+#ifdef __cpp_noexcept_function_type
+_NON_MEMBER_CALL(_IS_MEMFUNPTR_EXPLICIT_THIS_GUIDES, , , noexcept)
+#endif // defined(__cpp_noexcept_function_type)
+
+#undef _IS_MEMFUNPTR_EXPLICIT_THIS_GUIDES
+#endif // _HAS_CXX23 && !defined(__clang__)
+
+#ifdef __clang__
+_EXPORT_STD template <class _Ty>
+constexpr bool is_member_function_pointer_v = __is_member_function_pointer(_Ty);
+#else // ^^^ Clang / Other vvv
+_EXPORT_STD template <class _Ty>
+constexpr bool is_member_function_pointer_v = _Is_memfunptr<remove_cv_t<_Ty>>::_Bool_type::value;
+#endif // ^^^ Other ^^^
+
+_EXPORT_STD template <class _Ty>
+struct is_member_function_pointer : bool_constant<is_member_function_pointer_v<_Ty>> {};
+
+_EXPORT_STD template <class>
+constexpr bool is_const_v = false; // determine whether type argument is const qualified
+
+template <class _Ty>
+constexpr bool is_const_v<const _Ty> = true;
+
+_EXPORT_STD template <class _Ty>
+struct is_const : bool_constant<is_const_v<_Ty>> {};
+
+_EXPORT_STD template <class>
+constexpr bool is_volatile_v = false; // determine whether type argument is volatile qualified
+
+template <class _Ty>
+constexpr bool is_volatile_v<volatile _Ty> = true;
+
+_EXPORT_STD template <class _Ty>
+struct is_volatile : bool_constant<is_volatile_v<_Ty>> {};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_function_v = // only function types and reference types can't be const qualified
+    !is_const_v<const _Ty> && !is_reference_v<_Ty>;
+
+_EXPORT_STD template <class _Ty>
+struct is_function : bool_constant<is_function_v<_Ty>> {};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_object_v = // only function types and reference types can't be const qualified
+    is_const_v<const _Ty> && !is_void_v<_Ty>;
+
+_EXPORT_STD template <class _Ty>
+struct is_object : bool_constant<is_object_v<_Ty>> {};
+
+template <class>
+struct _Is_member_object_pointer {
+    static constexpr bool value = false;
+};
+
+template <class _Ty1, class _Ty2>
+struct _Is_member_object_pointer<_Ty1 _Ty2::*> {
+    static constexpr bool value = !is_function_v<_Ty1>;
+    using _Class_type           = _Ty2;
+};
+
+#ifdef __clang__
+_EXPORT_STD template <class _Ty>
+constexpr bool is_member_object_pointer_v = __is_member_object_pointer(_Ty);
+#else // ^^^ Clang / Other vvv
+_EXPORT_STD template <class _Ty>
+constexpr bool is_member_object_pointer_v = _Is_member_object_pointer<remove_cv_t<_Ty>>::value;
+#endif // ^^^ Other ^^^
+
+_EXPORT_STD template <class _Ty>
+struct is_member_object_pointer : bool_constant<is_member_object_pointer_v<_Ty>> {};
+
+#ifdef __clang__
+_EXPORT_STD template <class _Ty>
+constexpr bool is_member_pointer_v = __is_member_pointer(_Ty);
+#else // ^^^ Clang / Other vvv
+_EXPORT_STD template <class _Ty>
+constexpr bool is_member_pointer_v = is_member_object_pointer_v<_Ty> || is_member_function_pointer_v<_Ty>;
+#endif // ^^^ Other ^^^
+
+_EXPORT_STD template <class _Ty>
+struct is_member_pointer : bool_constant<is_member_pointer_v<_Ty>> {}; // determine whether _Ty is a pointer to member
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_scalar_v = // determine whether _Ty is a scalar type
+    is_arithmetic_v<_Ty> || is_enum_v<_Ty> || is_pointer_v<_Ty> || is_member_pointer_v<_Ty> || is_null_pointer_v<_Ty>;
+
+_EXPORT_STD template <class _Ty>
+struct is_scalar : bool_constant<is_scalar_v<_Ty>> {};
+
+_EXPORT_STD template <class _Ty>
+struct _CXX20_DEPRECATE_IS_POD is_pod : bool_constant<__is_pod(_Ty)> {}; // determine whether _Ty is a POD type
+
+_EXPORT_STD template <class _Ty>
+_CXX20_DEPRECATE_IS_POD constexpr bool is_pod_v = __is_pod(_Ty);
+
+_EXPORT_STD template <class _Ty>
+struct is_empty : bool_constant<__is_empty(_Ty)> {}; // determine whether _Ty is an empty class
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_empty_v = __is_empty(_Ty);
+
+_EXPORT_STD template <class _Ty>
+struct is_polymorphic : bool_constant<__is_polymorphic(_Ty)> {}; // determine whether _Ty is a polymorphic type
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_polymorphic_v = __is_polymorphic(_Ty);
+
+_EXPORT_STD template <class _Ty>
+struct is_abstract : bool_constant<__is_abstract(_Ty)> {}; // determine whether _Ty is an abstract class
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_abstract_v = __is_abstract(_Ty);
+
+_EXPORT_STD template <class _Ty>
+struct is_final : bool_constant<__is_final(_Ty)> {}; // determine whether _Ty is a final class
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_final_v = __is_final(_Ty);
+
+_EXPORT_STD template <class _Ty>
+struct is_standard_layout : bool_constant<__is_standard_layout(_Ty)> {}; // determine whether _Ty is standard layout
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_standard_layout_v = __is_standard_layout(_Ty);
+
+#if _HAS_DEPRECATED_IS_LITERAL_TYPE
+_EXPORT_STD template <class _Ty>
+struct _CXX17_DEPRECATE_IS_LITERAL_TYPE is_literal_type : bool_constant<__is_literal_type(_Ty)> {
+    // determine whether _Ty is a literal type
+};
+
+_EXPORT_STD template <class _Ty>
+_CXX17_DEPRECATE_IS_LITERAL_TYPE constexpr bool is_literal_type_v = __is_literal_type(_Ty);
+#endif // _HAS_DEPRECATED_IS_LITERAL_TYPE
+
+_EXPORT_STD template <class _Ty>
+struct is_trivial : bool_constant<__is_trivial(_Ty)> {}; // determine whether _Ty is a trivial type
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_trivial_v = __is_trivial(_Ty);
+
+_EXPORT_STD template <class _Ty>
+struct is_trivially_copyable : bool_constant<__is_trivially_copyable(_Ty)> {
+    // determine whether _Ty is a trivially copyable type
+};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Ty);
+
+_EXPORT_STD template <class _Ty>
+struct has_virtual_destructor : bool_constant<__has_virtual_destructor(_Ty)> {
+    // determine whether _Ty has a virtual destructor
+};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool has_virtual_destructor_v = __has_virtual_destructor(_Ty);
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _Ty>
+struct has_unique_object_representations : bool_constant<__has_unique_object_representations(_Ty)> {
+    // determine whether _Ty has unique object representations
+};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool has_unique_object_representations_v = __has_unique_object_representations(_Ty);
+
+#ifdef __EDG__ // TRANSITION, VSO-1690654
+template <class _Ty>
+struct _Is_aggregate_impl : bool_constant<__is_aggregate(_Ty)> {};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_aggregate_v = disjunction_v<is_array<_Ty>, _Is_aggregate_impl<_Ty>>;
+
+_EXPORT_STD template <class _Ty>
+struct is_aggregate : bool_constant<is_aggregate_v<_Ty>> {};
+#else // ^^^ workaround / no workaround vvv
+_EXPORT_STD template <class _Ty>
+struct is_aggregate : bool_constant<__is_aggregate(_Ty)> {};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_aggregate_v = __is_aggregate(_Ty);
+#endif // ^^^ no workaround ^^^
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Ty, class... _Args>
+struct is_constructible : bool_constant<__is_constructible(_Ty, _Args...)> {
+    // determine whether _Ty can be direct-initialized with _Args...
+};
+
+_EXPORT_STD template <class _Ty, class... _Args>
+constexpr bool is_constructible_v = __is_constructible(_Ty, _Args...);
+
+_EXPORT_STD template <class _Ty>
+struct is_copy_constructible : bool_constant<__is_constructible(_Ty, add_lvalue_reference_t<const _Ty>)> {
+    // determine whether _Ty can be direct-initialized with an lvalue const _Ty
+};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_copy_constructible_v = __is_constructible(_Ty, add_lvalue_reference_t<const _Ty>);
+
+_EXPORT_STD template <class _Ty>
+struct is_default_constructible : bool_constant<__is_constructible(_Ty)> {
+    // determine whether _Ty can be value-initialized
+};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_default_constructible_v = __is_constructible(_Ty);
+
+template <class _Ty, class = void>
+struct _Is_implicitly_default_constructible : false_type {
+    // determine whether _Ty can be copy-initialized with {}
+};
+
+template <class _Ty>
+void _Implicitly_default_construct(const _Ty&);
+
+template <class _Ty>
+struct _Is_implicitly_default_constructible<_Ty, void_t<decltype(_Implicitly_default_construct<_Ty>({}))>> : true_type {
+};
+
+_EXPORT_STD template <class _Ty>
+struct is_move_constructible : bool_constant<__is_constructible(_Ty, _Ty)> {
+    // determine whether _Ty can be direct-initialized from an rvalue _Ty
+};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_move_constructible_v = __is_constructible(_Ty, _Ty);
+
+_EXPORT_STD template <class _To, class _From>
+struct is_assignable : bool_constant<__is_assignable(_To, _From)> {}; // determine whether _From can be assigned to _To
+
+_EXPORT_STD template <class _To, class _From>
+constexpr bool is_assignable_v = __is_assignable(_To, _From);
+
+#if defined(_IS_ASSIGNABLE_NOCHECK_SUPPORTED) && !defined(__CUDACC__)
+template <class _To, class _From>
+struct _Is_assignable_no_precondition_check : bool_constant<__is_assignable_no_precondition_check(_To, _From)> {};
+#else // ^^^ Use intrinsic / intrinsic not supported vvv
+template <class _To, class _From>
+using _Is_assignable_no_precondition_check = is_assignable<_To, _From>;
+#endif // ^^^ intrinsic not supported ^^^
+
+_EXPORT_STD template <class _Ty>
+struct is_copy_assignable
+    : bool_constant<__is_assignable(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>)> {
+    // determine whether an lvalue const _Ty can be assigned to an lvalue _Ty
+};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_copy_assignable_v = __is_assignable(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>);
+
+#if defined(_IS_ASSIGNABLE_NOCHECK_SUPPORTED) && !defined(__CUDACC__)
+template <class _Ty>
+struct _Is_copy_assignable_no_precondition_check
+    : bool_constant<__is_assignable_no_precondition_check(
+          add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>)> {};
+
+template <class _Ty>
+constexpr bool _Is_copy_assignable_unchecked_v =
+    __is_assignable_no_precondition_check(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>);
+#else // ^^^ Use intrinsic / intrinsic not supported vvv
+template <class _Ty>
+using _Is_copy_assignable_no_precondition_check = is_copy_assignable<_Ty>;
+
+template <class _Ty>
+constexpr bool _Is_copy_assignable_unchecked_v = is_copy_assignable_v<_Ty>;
+#endif // ^^^ intrinsic not supported ^^^
+
+_EXPORT_STD template <class _Ty>
+struct is_move_assignable : bool_constant<__is_assignable(add_lvalue_reference_t<_Ty>, _Ty)> {
+    // determine whether an rvalue _Ty can be assigned to an lvalue _Ty
+};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_move_assignable_v = __is_assignable(add_lvalue_reference_t<_Ty>, _Ty);
+
+#if defined(_IS_ASSIGNABLE_NOCHECK_SUPPORTED) && !defined(__CUDACC__)
+template <class _Ty>
+struct _Is_move_assignable_no_precondition_check
+    : bool_constant<__is_assignable_no_precondition_check(add_lvalue_reference_t<_Ty>, _Ty)> {};
+
+template <class _Ty>
+constexpr bool _Is_move_assignable_unchecked_v =
+    __is_assignable_no_precondition_check(add_lvalue_reference_t<_Ty>, _Ty);
+#else // ^^^ Use intrinsic / intrinsic not supported vvv
+template <class _Ty>
+using _Is_move_assignable_no_precondition_check = is_move_assignable<_Ty>;
+
+template <class _Ty>
+constexpr bool _Is_move_assignable_unchecked_v = is_move_assignable_v<_Ty>;
+#endif // ^^^ intrinsic not supported ^^^
+
+_EXPORT_STD template <class _Ty>
+struct is_destructible : bool_constant<__is_destructible(_Ty)> {
+    // true iff remove_all_extents_t<_Ty> is a reference type, or can be explicitly destroyed
+};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_destructible_v = __is_destructible(_Ty);
+
+_EXPORT_STD template <class _Ty, class... _Args>
+struct is_trivially_constructible : bool_constant<__is_trivially_constructible(_Ty, _Args...)> {
+    // determine whether direct-initialization of _Ty with _Args... is trivial
+};
+
+_EXPORT_STD template <class _Ty, class... _Args>
+constexpr bool is_trivially_constructible_v = __is_trivially_constructible(_Ty, _Args...);
+
+_EXPORT_STD template <class _Ty>
+struct is_trivially_copy_constructible
+    : bool_constant<__is_trivially_constructible(_Ty, add_lvalue_reference_t<const _Ty>)> {
+    // determine whether direct-initialization of _Ty with an lvalue const _Ty is trivial
+};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_trivially_copy_constructible_v = __is_trivially_constructible(_Ty, add_lvalue_reference_t<const _Ty>);
+
+_EXPORT_STD template <class _Ty>
+struct is_trivially_default_constructible : bool_constant<__is_trivially_constructible(_Ty)> {
+    // determine whether value-initialization of _Ty is trivial
+};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_trivially_default_constructible_v = __is_trivially_constructible(_Ty);
+
+_EXPORT_STD template <class _Ty>
+struct is_trivially_move_constructible : bool_constant<__is_trivially_constructible(_Ty, _Ty)> {
+    // determine whether direct-initialization of _Ty with an rvalue _Ty is trivial
+};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_trivially_move_constructible_v = __is_trivially_constructible(_Ty, _Ty);
+
+_EXPORT_STD template <class _To, class _From>
+struct is_trivially_assignable : bool_constant<__is_trivially_assignable(_To, _From)> {
+    // determine whether _From can be trivially assigned to _To
+};
+
+_EXPORT_STD template <class _To, class _From>
+constexpr bool is_trivially_assignable_v = __is_trivially_assignable(_To, _From);
+
+_EXPORT_STD template <class _Ty>
+struct is_trivially_copy_assignable
+    : bool_constant<__is_trivially_assignable(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>)> {
+    // determine whether an lvalue const _Ty can be trivially assigned to an lvalue _Ty
+};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_trivially_copy_assignable_v =
+    __is_trivially_assignable(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>);
+
+_EXPORT_STD template <class _Ty>
+struct is_trivially_move_assignable : bool_constant<__is_trivially_assignable(add_lvalue_reference_t<_Ty>, _Ty)> {
+    // determine whether an rvalue _Ty can be trivially assigned to an lvalue _Ty
+};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_trivially_move_assignable_v = __is_trivially_assignable(add_lvalue_reference_t<_Ty>, _Ty);
+
+_EXPORT_STD template <class _Ty>
+struct is_trivially_destructible : bool_constant<__is_trivially_destructible(_Ty)> {
+    // determine whether remove_all_extents_t<_Ty> is a reference type or can trivially be explicitly destroyed
+};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_trivially_destructible_v = __is_trivially_destructible(_Ty);
+
+_EXPORT_STD template <class _Ty, class... _Args>
+struct is_nothrow_constructible : bool_constant<__is_nothrow_constructible(_Ty, _Args...)> {
+    // determine whether direct-initialization of _Ty from _Args... is both valid and not potentially-throwing
+};
+
+_EXPORT_STD template <class _Ty, class... _Args>
+constexpr bool is_nothrow_constructible_v = __is_nothrow_constructible(_Ty, _Args...);
+
+_EXPORT_STD template <class _Ty>
+struct is_nothrow_copy_constructible
+    : bool_constant<__is_nothrow_constructible(_Ty, add_lvalue_reference_t<const _Ty>)> {
+    // determine whether direct-initialization of _Ty from an lvalue const _Ty is both valid
+    // and not potentially-throwing
+};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_nothrow_copy_constructible_v = __is_nothrow_constructible(_Ty, add_lvalue_reference_t<const _Ty>);
+
+_EXPORT_STD template <class _Ty>
+struct is_nothrow_default_constructible : bool_constant<__is_nothrow_constructible(_Ty)> {
+    // determine whether value-initialization of _Ty is both valid and not potentially-throwing
+};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_nothrow_default_constructible_v = __is_nothrow_constructible(_Ty);
+
+_EXPORT_STD template <class _Ty>
+struct is_nothrow_move_constructible : bool_constant<__is_nothrow_constructible(_Ty, _Ty)> {
+    // determine whether direct-initialization of _Ty from an rvalue _Ty is both valid and not potentially-throwing
+};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_nothrow_move_constructible_v = __is_nothrow_constructible(_Ty, _Ty);
+
+_EXPORT_STD template <class _To, class _From>
+struct is_nothrow_assignable : bool_constant<__is_nothrow_assignable(_To, _From)> {
+    // determine whether assignment of _From to _To is both valid and not potentially-throwing
+};
+
+_EXPORT_STD template <class _To, class _From>
+constexpr bool is_nothrow_assignable_v = __is_nothrow_assignable(_To, _From);
+
+_EXPORT_STD template <class _Ty>
+struct is_nothrow_copy_assignable
+    : bool_constant<__is_nothrow_assignable(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>)> {
+    // determine whether assignment of an lvalue const _Ty to an lvalue _Ty is both valid and not potentially-throwing
+};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_nothrow_copy_assignable_v =
+    __is_nothrow_assignable(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>);
+
+_EXPORT_STD template <class _Ty>
+struct is_nothrow_move_assignable : bool_constant<__is_nothrow_assignable(add_lvalue_reference_t<_Ty>, _Ty)> {
+    // determine whether assignment of an rvalue _Ty to an lvalue _Ty is both valid and not potentially-throwing
+};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_nothrow_move_assignable_v = __is_nothrow_assignable(add_lvalue_reference_t<_Ty>, _Ty);
+
+_EXPORT_STD template <class _Ty>
+struct is_nothrow_destructible : bool_constant<__is_nothrow_destructible(_Ty)> {
+    // determine whether remove_all_extents_t<_Ty> is a reference type or has
+    // non-potentially-throwing explicit destruction
+};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_nothrow_destructible_v = __is_nothrow_destructible(_Ty);
+
+template <class _Ty, bool = is_integral_v<_Ty>>
+struct _Sign_base { // determine whether integral type _Ty is signed or unsigned
+    using _Uty = remove_cv_t<_Ty>;
+
+    static constexpr bool _Signed   = static_cast<_Uty>(-1) < static_cast<_Uty>(0);
+    static constexpr bool _Unsigned = !_Signed;
+};
+
+template <class _Ty>
+struct _Sign_base<_Ty, false> { // floating-point _Ty is signed
+                                // non-arithmetic _Ty is neither signed nor unsigned
+    static constexpr bool _Signed   = is_floating_point_v<_Ty>;
+    static constexpr bool _Unsigned = false;
+};
+
+_EXPORT_STD template <class _Ty>
+struct is_signed : bool_constant<_Sign_base<_Ty>::_Signed> {}; // determine whether _Ty is a signed type
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_signed_v = _Sign_base<_Ty>::_Signed;
+
+_EXPORT_STD template <class _Ty>
+struct is_unsigned : bool_constant<_Sign_base<_Ty>::_Unsigned> {}; // determine whether _Ty is an unsigned type
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_unsigned_v = _Sign_base<_Ty>::_Unsigned;
+
+template <class _Ty>
+constexpr bool _Is_nonbool_integral = is_integral_v<_Ty> && !is_same_v<remove_cv_t<_Ty>, bool>;
+
+template <bool>
+struct _Select { // Select between aliases that extract either their first or second parameter
+    template <class _Ty1, class>
+    using _Apply = _Ty1;
+};
+
+template <>
+struct _Select<false> {
+    template <class, class _Ty2>
+    using _Apply = _Ty2;
+};
+
+template <size_t>
+struct _Make_signed2; // Choose make_signed strategy by type size
+
+template <>
+struct _Make_signed2<1> {
+    template <class>
+    using _Apply = signed char;
+};
+
+template <>
+struct _Make_signed2<2> {
+    template <class>
+    using _Apply = short;
+};
+
+template <>
+struct _Make_signed2<4> {
+    template <class _Ty>
+    using _Apply = // assumes LLP64
+        typename _Select<is_same_v<_Ty, long> || is_same_v<_Ty, unsigned long>>::template _Apply<long, int>;
+};
+
+template <>
+struct _Make_signed2<8> {
+    template <class>
+    using _Apply = long long;
+};
+
+template <class _Ty>
+using _Make_signed1 = // signed partner to cv-unqualified _Ty
+    typename _Make_signed2<sizeof(_Ty)>::template _Apply<_Ty>;
+
+_EXPORT_STD template <class _Ty>
+struct make_signed { // signed partner to _Ty
+    static_assert(_Is_nonbool_integral<_Ty> || is_enum_v<_Ty>,
+        "make_signed<T> requires that T shall be a (possibly cv-qualified) "
+        "integral type or enumeration but not a bool type.");
+
+    using type = typename remove_cv<_Ty>::template _Apply<_Make_signed1>;
+};
+
+_EXPORT_STD template <class _Ty>
+using make_signed_t = typename make_signed<_Ty>::type;
+
+template <size_t>
+struct _Make_unsigned2; // Choose make_unsigned strategy by type size
+
+template <>
+struct _Make_unsigned2<1> {
+    template <class>
+    using _Apply = unsigned char;
+};
+
+template <>
+struct _Make_unsigned2<2> {
+    template <class>
+    using _Apply = unsigned short;
+};
+
+template <>
+struct _Make_unsigned2<4> {
+    template <class _Ty>
+    using _Apply = // assumes LLP64
+        typename _Select<is_same_v<_Ty, long> || is_same_v<_Ty, unsigned long>>::template _Apply<unsigned long,
+            unsigned int>;
+};
+
+template <>
+struct _Make_unsigned2<8> {
+    template <class>
+    using _Apply = unsigned long long;
+};
+
+template <class _Ty>
+using _Make_unsigned1 = // unsigned partner to cv-unqualified _Ty
+    typename _Make_unsigned2<sizeof(_Ty)>::template _Apply<_Ty>;
+
+_EXPORT_STD template <class _Ty>
+struct make_unsigned { // unsigned partner to _Ty
+    static_assert(_Is_nonbool_integral<_Ty> || is_enum_v<_Ty>,
+        "make_unsigned<T> requires that T shall be a (possibly cv-qualified) "
+        "integral type or enumeration but not a bool type.");
+
+    using type = typename remove_cv<_Ty>::template _Apply<_Make_unsigned1>;
+};
+
+_EXPORT_STD template <class _Ty>
+using make_unsigned_t = typename make_unsigned<_Ty>::type;
+
+template <class _Rep>
+constexpr make_unsigned_t<_Rep> _Unsigned_value(_Rep _Val) { // makes _Val unsigned
+    return static_cast<make_unsigned_t<_Rep>>(_Val);
+}
+
+_EXPORT_STD template <class _Ty>
+struct alignment_of : integral_constant<size_t, alignof(_Ty)> {}; // determine alignment of _Ty
+
+_EXPORT_STD template <class _Ty>
+constexpr size_t alignment_of_v = alignof(_Ty);
+
+template <class _Ty, size_t _Len>
+union _Align_type { // union with size _Len bytes and alignment of _Ty
+    _Ty _Val;
+    char _Pad[_Len];
+};
+
+template <size_t _Len, size_t _Align, class _Ty, bool _Ok>
+struct _Aligned; // define type with size _Len and alignment _Ty
+
+template <size_t _Len, size_t _Align, class _Ty>
+struct _Aligned<_Len, _Align, _Ty, true> {
+    using type = _Align_type<_Ty, _Len>;
+};
+
+template <size_t _Len, size_t _Align>
+struct _Aligned<_Len, _Align, double, false> {
+#ifdef _ENABLE_EXTENDED_ALIGNED_STORAGE
+    struct type {
+        alignas(_Align) char _Space[_Len];
+    };
+#else // ^^^ defined(_ENABLE_EXTENDED_ALIGNED_STORAGE) / !defined(_ENABLE_EXTENDED_ALIGNED_STORAGE) vvv
+#ifndef _DISABLE_EXTENDED_ALIGNED_STORAGE
+    static_assert(_Always_false<_Aligned>,
+        "You've instantiated std::aligned_storage<Len, Align> with an extended alignment (in other "
+        "words, Align > alignof(max_align_t)). Before VS 2017 15.8, the member \"type\" would "
+        "non-conformingly have an alignment of only alignof(max_align_t). VS 2017 15.8 was fixed to "
+        "handle this correctly, but the fix inherently changes layout and breaks binary compatibility "
+        "(*only* for uses of aligned_storage with extended alignments). "
+        "To suppress this error, please define either "
+        "(1) _ENABLE_EXTENDED_ALIGNED_STORAGE to confirm that you want a type with an extended alignment, or "
+        "(2) _DISABLE_EXTENDED_ALIGNED_STORAGE to get the old non-conforming behavior.");
+#endif // ^^^ !defined(_DISABLE_EXTENDED_ALIGNED_STORAGE) ^^^
+    using type = _Align_type<max_align_t, _Len>;
+#endif // ^^^ !defined(_ENABLE_EXTENDED_ALIGNED_STORAGE) ^^^
+};
+
+template <size_t _Len, size_t _Align>
+struct _Aligned<_Len, _Align, int, false> {
+    using _Next                 = double;
+    static constexpr bool _Fits = _Align <= alignof(_Next);
+    using type                  = typename _Aligned<_Len, _Align, _Next, _Fits>::type;
+};
+
+template <size_t _Len, size_t _Align>
+struct _Aligned<_Len, _Align, short, false> {
+    using _Next                 = int;
+    static constexpr bool _Fits = _Align <= alignof(_Next);
+    using type                  = typename _Aligned<_Len, _Align, _Next, _Fits>::type;
+};
+
+template <size_t _Len, size_t _Align>
+struct _Aligned<_Len, _Align, char, false> {
+    using _Next                 = short;
+    static constexpr bool _Fits = _Align <= alignof(_Next);
+    using type                  = typename _Aligned<_Len, _Align, _Next, _Fits>::type;
+};
+
+// TRANSITION, ABI: Internal non-deprecated version to avoid ABI changes due to deprecation
+template <size_t _Len, size_t _Align = alignof(max_align_t)>
+struct _Aligned_storage { // define type with size _Len and alignment _Align
+    using _Next                 = char;
+    static constexpr bool _Fits = _Align <= alignof(_Next);
+    using type                  = typename _Aligned<_Len, _Align, _Next, _Fits>::type;
+};
+
+template <size_t _Len, size_t _Align = alignof(max_align_t)>
+using _Aligned_storage_t = typename _Aligned_storage<_Len, _Align>::type;
+
+_EXPORT_STD template <size_t _Len, size_t _Align = alignof(max_align_t)>
+struct _CXX23_DEPRECATE_ALIGNED_STORAGE aligned_storage { // define type with size _Len and alignment _Align
+    using type = _Aligned_storage_t<_Len, _Align>;
+};
+
+_EXPORT_STD template <size_t _Len, size_t _Align = alignof(max_align_t)>
+using aligned_storage_t _CXX23_DEPRECATE_ALIGNED_STORAGE = _Aligned_storage_t<_Len, _Align>;
+
+template <size_t... _Vals>
+struct _Maximum;
+
+template <>
+struct _Maximum<> : integral_constant<size_t, 0> {}; // maximum of nothing is 0
+
+template <size_t _Val>
+struct _Maximum<_Val> : integral_constant<size_t, _Val> {}; // maximum of _Val is _Val
+
+template <size_t _First, size_t _Second, size_t... _Rest>
+struct _Maximum<_First, _Second, _Rest...> : _Maximum<(_First < _Second ? _Second : _First), _Rest...>::type {
+    // find maximum value in _First, _Second, _Rest...
+};
+
+_EXPORT_STD template <size_t _Len, class... _Types>
+struct _CXX23_DEPRECATE_ALIGNED_UNION aligned_union {
+    // define type with size at least _Len, for storing anything in _Types
+    static constexpr size_t _Max_len        = _Maximum<_Len, sizeof(_Types)...>::value; // NOT sizeof...(_Types)
+    static constexpr size_t alignment_value = _Maximum<alignof(_Types)...>::value;
+
+    using type = _Aligned_storage_t<_Max_len, alignment_value>;
+};
+
+_STL_DISABLE_DEPRECATED_WARNING
+_EXPORT_STD template <size_t _Len, class... _Types>
+using aligned_union_t _CXX23_DEPRECATE_ALIGNED_UNION = typename aligned_union<_Len, _Types...>::type;
+_STL_RESTORE_DEPRECATED_WARNING
+
+template <class _Ty, bool = is_enum_v<_Ty>>
+struct _Underlying_type {
+    using type = __underlying_type(_Ty);
+};
+
+template <class _Ty>
+struct _Underlying_type<_Ty, false> {};
+
+_EXPORT_STD template <class _Ty>
+struct underlying_type : _Underlying_type<_Ty> {}; // determine underlying type for enum
+
+_EXPORT_STD template <class _Ty>
+using underlying_type_t = typename _Underlying_type<_Ty>::type;
+
+_EXPORT_STD template <class _Ty>
+constexpr size_t rank_v = 0; // determine number of dimensions of array _Ty
+
+template <class _Ty, size_t _Nx>
+constexpr size_t rank_v<_Ty[_Nx]> = rank_v<_Ty> + 1;
+
+template <class _Ty>
+constexpr size_t rank_v<_Ty[]> = rank_v<_Ty> + 1;
+
+_EXPORT_STD template <class _Ty>
+struct rank : integral_constant<size_t, rank_v<_Ty>> {};
+
+_EXPORT_STD template <class _Ty, unsigned int _Ix = 0>
+constexpr size_t extent_v = 0; // determine extent of dimension _Ix of array _Ty
+
+template <class _Ty, size_t _Nx>
+constexpr size_t extent_v<_Ty[_Nx], 0> = _Nx;
+
+template <class _Ty, unsigned int _Ix, size_t _Nx>
+constexpr size_t extent_v<_Ty[_Nx], _Ix> = extent_v<_Ty, _Ix - 1>;
+
+template <class _Ty, unsigned int _Ix>
+constexpr size_t extent_v<_Ty[], _Ix> = extent_v<_Ty, _Ix - 1>;
+
+_EXPORT_STD template <class _Ty, unsigned int _Ix = 0>
+struct extent : integral_constant<size_t, extent_v<_Ty, _Ix>> {};
+
+_EXPORT_STD template <class _Base, class _Derived>
+struct is_base_of : bool_constant<__is_base_of(_Base, _Derived)> {
+    // determine whether _Base is a base of or the same as _Derived
+};
+
+_EXPORT_STD template <class _Base, class _Derived>
+constexpr bool is_base_of_v = __is_base_of(_Base, _Derived);
+
+_EXPORT_STD template <class _Ty>
+struct decay { // determines decayed version of _Ty
+    using _Ty1 = remove_reference_t<_Ty>;
+    using _Ty2 = typename _Select<is_function_v<_Ty1>>::template _Apply<add_pointer<_Ty1>, remove_cv<_Ty1>>;
+    using type = typename _Select<is_array_v<_Ty1>>::template _Apply<add_pointer<remove_extent_t<_Ty1>>, _Ty2>::type;
+};
+
+_EXPORT_STD template <class _Ty>
+using decay_t = typename decay<_Ty>::type;
+
+template <class _Ty1, class _Ty2>
+using _Conditional_type = decltype(false ? _STD declval<_Ty1>() : _STD declval<_Ty2>());
+
+#if _HAS_CXX20
+template <class _Ty1, class _Ty2>
+struct _Const_lvalue_cond_oper {};
+
+// N4950 [meta.trans.other]/3.3.4 (per the proposed resolution of LWG-3205): "Otherwise, if remove_cvref_t</**/> denotes
+// a type..."
+template <class _Ty1, class _Ty2>
+    requires requires { typename _Conditional_type<const _Ty1&, const _Ty2&>; }
+struct _Const_lvalue_cond_oper<_Ty1, _Ty2> {
+    using type = remove_cvref_t<_Conditional_type<const _Ty1&, const _Ty2&>>;
+};
+
+template <class _Ty1, class _Ty2, class = void>
+struct _Decayed_cond_oper : _Const_lvalue_cond_oper<_Ty1, _Ty2> {};
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Ty1, class _Ty2, class = void>
+struct _Decayed_cond_oper {};
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+template <class _Ty1, class _Ty2>
+struct _Decayed_cond_oper<_Ty1, _Ty2, void_t<_Conditional_type<_Ty1, _Ty2>>> {
+    using type = decay_t<_Conditional_type<_Ty1, _Ty2>>;
+};
+
+_EXPORT_STD template <class... _Ty>
+struct common_type;
+
+_EXPORT_STD template <class... _Ty>
+using common_type_t = typename common_type<_Ty...>::type;
+
+template <>
+struct common_type<> {};
+
+template <class _Ty1>
+struct common_type<_Ty1> : common_type<_Ty1, _Ty1> {};
+
+template <class _Ty1, class _Ty2, class _Decayed1 = decay_t<_Ty1>, class _Decayed2 = decay_t<_Ty2>>
+struct _Common_type2 : common_type<_Decayed1, _Decayed2> {};
+
+template <class _Ty1, class _Ty2>
+struct _Common_type2<_Ty1, _Ty2, _Ty1, _Ty2> : _Decayed_cond_oper<_Ty1, _Ty2> {};
+
+template <class _Ty1, class _Ty2>
+struct common_type<_Ty1, _Ty2> : _Common_type2<_Ty1, _Ty2> {};
+
+template <class _Void, class _Ty1, class _Ty2, class... _Rest>
+struct _Common_type3 {};
+
+template <class _Ty1, class _Ty2, class... _Rest>
+struct _Common_type3<void_t<common_type_t<_Ty1, _Ty2>>, _Ty1, _Ty2, _Rest...>
+    : common_type<common_type_t<_Ty1, _Ty2>, _Rest...> {};
+
+template <class _Ty1, class _Ty2, class... _Rest>
+struct common_type<_Ty1, _Ty2, _Rest...> : _Common_type3<void, _Ty1, _Ty2, _Rest...> {};
+
+template <class _Ty>
+_Ty _Returns_exactly() noexcept; // not defined
+
+#if _HAS_CXX20
+_EXPORT_STD template <class, class, template <class> class, template <class> class>
+struct basic_common_reference {};
+
+template <class _From>
+struct _Copy_cv_impl {
+    template <class _To>
+    using _Apply = _To;
+};
+template <class _From>
+struct _Copy_cv_impl<const _From> {
+    template <class _To>
+    using _Apply = const _To;
+};
+template <class _From>
+struct _Copy_cv_impl<volatile _From> {
+    template <class _To>
+    using _Apply = volatile _To;
+};
+template <class _From>
+struct _Copy_cv_impl<const volatile _From> {
+    template <class _To>
+    using _Apply = const volatile _To;
+};
+template <class _From, class _To>
+using _Copy_cv = // N4950 [meta.trans.other]/2.3
+    _Copy_cv_impl<_From>::template _Apply<_To>;
+
+template <class _Ty1>
+struct _Add_qualifiers { // _Add_qualifiers<A>::template _Apply is XREF(A) from N4950 [meta.trans.other]/2.2
+    template <class _Ty2>
+    using _Apply = _Copy_cv<_Ty1, _Ty2>;
+};
+template <class _Ty1>
+struct _Add_qualifiers<_Ty1&> {
+    template <class _Ty2>
+    using _Apply = add_lvalue_reference_t<_Copy_cv<_Ty1, _Ty2>>;
+};
+template <class _Ty1>
+struct _Add_qualifiers<_Ty1&&> {
+    template <class _Ty2>
+    using _Apply = add_rvalue_reference_t<_Copy_cv<_Ty1, _Ty2>>;
+};
+
+template <class _Ty1, class _Ty2>
+using _Cond_res = // N4950 [meta.trans.other]/2.4
+    decltype(false ? _Returns_exactly<_Ty1>() : _Returns_exactly<_Ty2>());
+
+_EXPORT_STD template <class...>
+struct common_reference;
+
+_EXPORT_STD template <class... _Types>
+using common_reference_t = common_reference<_Types...>::type;
+
+// N4950 [meta.trans.other]/5.1: "If sizeof...(T) is zero ..."
+template <>
+struct common_reference<> {};
+
+// N4950 [meta.trans.other]/5.2: "...if sizeof...(T) is one ..."
+template <class _Ty>
+struct common_reference<_Ty> {
+    using type = _Ty;
+};
+
+// N4950 [meta.trans.other]/5.3: "...if sizeof...(T) is two..."
+
+// N4950 [meta.trans.other]/5.3.4: "if common_type_t<T1, T2> is well-formed..."
+// N4950 [meta.trans.other]/5.3.5: "Otherwise, there shall be no member type."
+template <class _Ty1, class _Ty2>
+struct _Common_reference2C : common_type<_Ty1, _Ty2> {};
+
+// N4950 [meta.trans.other]/5.3.3: "if COND_RES(T1, T2) is well-formed..."
+template <class _Ty1, class _Ty2>
+    requires requires { typename _Cond_res<_Ty1, _Ty2>; }
+struct _Common_reference2C<_Ty1, _Ty2> {
+    using type = _Cond_res<_Ty1, _Ty2>;
+};
+
+// N4950 [meta.trans.other]/5.3.2: "if basic_common_reference<[...]>::type is well-formed..."
+template <class _Ty1, class _Ty2>
+using _Basic_specialization = basic_common_reference<remove_cvref_t<_Ty1>, remove_cvref_t<_Ty2>,
+    _Add_qualifiers<_Ty1>::template _Apply, _Add_qualifiers<_Ty2>::template _Apply>::type;
+
+template <class _Ty1, class _Ty2>
+struct _Common_reference2B : _Common_reference2C<_Ty1, _Ty2> {};
+
+template <class _Ty1, class _Ty2>
+    requires requires { typename _Basic_specialization<_Ty1, _Ty2>; }
+struct _Common_reference2B<_Ty1, _Ty2> {
+    using type = _Basic_specialization<_Ty1, _Ty2>;
+};
+
+// N4950 [meta.trans.other]/5.3.1: "Let R be COMMON-REF(T1, T2). If T1 and T2 are reference types, R is well-formed, and
+// is_convertible_v<add_pointer_t<T1>, add_pointer_t<R>> && is_convertible_v<add_pointer_t<T2>, add_pointer_t<R>> is
+// true, then the member typedef type denotes R."
+template <class _Ty1, class _Ty2>
+struct _Common_reference2A : _Common_reference2B<_Ty1, _Ty2> {};
+
+template <class _Ty1, class _Ty2>
+    requires is_lvalue_reference_v<_Cond_res<_Copy_cv<_Ty1, _Ty2>&, _Copy_cv<_Ty2, _Ty1>&>>
+using _LL_common_ref = _Cond_res<_Copy_cv<_Ty1, _Ty2>&, _Copy_cv<_Ty2, _Ty1>&>;
+
+template <class _Ty1, class _Ty2>
+struct _Common_reference2AX {};
+
+template <class _Ty1, class _Ty2>
+    requires requires { typename _LL_common_ref<_Ty1, _Ty2>; }
+struct _Common_reference2AX<_Ty1&, _Ty2&> {
+    using type = _LL_common_ref<_Ty1, _Ty2>; // "both lvalues" case from N4950 [meta.trans.other]/2.5
+};
+
+template <class _Ty1, class _Ty2>
+    requires is_convertible_v<_Ty1&&, _LL_common_ref<const _Ty1, _Ty2>>
+struct _Common_reference2AX<_Ty1&&, _Ty2&> {
+    using type = _LL_common_ref<const _Ty1, _Ty2>; // "rvalue and lvalue" case from N4950 [meta.trans.other]/2.7
+};
+
+template <class _Ty1, class _Ty2>
+    requires is_convertible_v<_Ty2&&, _LL_common_ref<const _Ty2, _Ty1>>
+struct _Common_reference2AX<_Ty1&, _Ty2&&> {
+    using type = _LL_common_ref<const _Ty2, _Ty1>; // "lvalue and rvalue" case from N4950 [meta.trans.other]/2.8
+};
+
+template <class _Ty1, class _Ty2>
+using _RR_common_ref = remove_reference_t<_LL_common_ref<_Ty1, _Ty2>>&&;
+
+template <class _Ty1, class _Ty2>
+    requires is_convertible_v<_Ty1&&, _RR_common_ref<_Ty1, _Ty2>>
+          && is_convertible_v<_Ty2&&, _RR_common_ref<_Ty1, _Ty2>>
+struct _Common_reference2AX<_Ty1&&, _Ty2&&> {
+    using type = _RR_common_ref<_Ty1, _Ty2>; // "both rvalues" case from N4950 [meta.trans.other]/2.6
+};
+
+template <class _Ty1, class _Ty2>
+using _Common_ref_2AX_t = _Common_reference2AX<_Ty1, _Ty2>::type;
+
+template <class _Ty1, class _Ty2>
+    requires is_convertible_v<add_pointer_t<_Ty1>, add_pointer_t<_Common_ref_2AX_t<_Ty1, _Ty2>>>
+          && is_convertible_v<add_pointer_t<_Ty2>, add_pointer_t<_Common_ref_2AX_t<_Ty1, _Ty2>>>
+struct _Common_reference2A<_Ty1, _Ty2> {
+    using type = _Common_ref_2AX_t<_Ty1, _Ty2>;
+};
+
+template <class _Ty1, class _Ty2>
+struct common_reference<_Ty1, _Ty2> : _Common_reference2A<_Ty1, _Ty2> {};
+
+// N4950 [meta.trans.other]/5.4: "if sizeof...(T) is greater than two..."
+template <class _Ty1, class _Ty2, class _Ty3, class... _Rest>
+struct common_reference<_Ty1, _Ty2, _Ty3, _Rest...> {};
+template <class _Ty1, class _Ty2, class _Ty3, class... _Rest>
+    requires requires { typename common_reference_t<_Ty1, _Ty2>; }
+struct common_reference<_Ty1, _Ty2, _Ty3, _Rest...> : common_reference<common_reference_t<_Ty1, _Ty2>, _Ty3, _Rest...> {
+};
+
+_EXPORT_STD template <class _Ty>
+struct type_identity {
+    using type = _Ty;
+};
+_EXPORT_STD template <class _Ty>
+using type_identity_t = type_identity<_Ty>::type;
+#endif // _HAS_CXX20
+
+template <class _Type, template <class...> class _Template>
+constexpr bool _Is_specialization_v = false; // true if and only if _Type is a specialization of _Template
+template <template <class...> class _Template, class... _Types>
+constexpr bool _Is_specialization_v<_Template<_Types...>, _Template> = true;
+
+template <class _Type, template <class...> class _Template>
+struct _Is_specialization : bool_constant<_Is_specialization_v<_Type, _Template>> {};
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _MSVC_INTRINSIC constexpr _Ty&& forward(remove_reference_t<_Ty>& _Arg) noexcept {
+    return static_cast<_Ty&&>(_Arg);
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _MSVC_INTRINSIC constexpr _Ty&& forward(remove_reference_t<_Ty>&& _Arg) noexcept {
+    static_assert(!is_lvalue_reference_v<_Ty>, "bad forward call");
+    return static_cast<_Ty&&>(_Arg);
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _MSVC_INTRINSIC constexpr remove_reference_t<_Ty>&& move(_Ty&& _Arg) noexcept {
+    return static_cast<remove_reference_t<_Ty>&&>(_Arg);
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _MSVC_INTRINSIC constexpr //
+    conditional_t<!is_nothrow_move_constructible_v<_Ty> && is_copy_constructible_v<_Ty>, const _Ty&, _Ty&&>
+    move_if_noexcept(_Ty& _Arg) noexcept {
+    return _STD move(_Arg);
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD constexpr _Ty* addressof(_Ty& _Val) noexcept {
+    return __builtin_addressof(_Val);
+}
+
+_EXPORT_STD template <class _Ty>
+const _Ty* addressof(const _Ty&&) = delete;
+
+#pragma warning(push)
+#pragma warning(disable : 5215) // '%s' a function parameter with a volatile qualified type is deprecated in C++20
+#pragma warning(disable : 5216) // '%s' a volatile qualified return type is deprecated in C++20
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-volatile"
+#endif // defined(__clang__)
+
+template <class _Ty>
+_NODISCARD _Ty _Fake_copy_init(_Ty) noexcept;
+// _Fake_copy_init<T>(E):
+// (1) has type T [decay_t<decltype((E))> if T is deduced],
+// (2) is well-formed if and only if E is implicitly convertible to T and T is destructible, and
+// (3) is non-throwing if and only if both conversion from decltype((E)) to T and destruction of T are non-throwing.
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+
+#pragma warning(pop)
+
+_EXPORT_STD template <class _Ty>
+class reference_wrapper;
+
+// std::invoke isn't constexpr in C++17, and normally implementers are forbidden from "strengthening" constexpr
+// (N4950 [constexpr.functions]/1), yet both std::apply and std::visit are required to be constexpr and have
+// invoke-like behavior. As a result, we've chosen to apply the part of P1065R2 resolving LWG-2894 as a defect report.
+
+enum class _Invoker_strategy {
+    _Functor,
+    _Pmf_object,
+    _Pmf_refwrap,
+    _Pmf_pointer,
+    _Pmd_object,
+    _Pmd_refwrap,
+    _Pmd_pointer
+};
+
+struct _Invoker_functor {
+    static constexpr _Invoker_strategy _Strategy = _Invoker_strategy::_Functor;
+
+    template <class _Callable, class... _Types>
+    static constexpr auto _Call(_Callable&& _Obj, _Types&&... _Args) noexcept(
+        noexcept(static_cast<_Callable&&>(_Obj)(static_cast<_Types&&>(_Args)...)))
+        -> decltype(static_cast<_Callable&&>(_Obj)(static_cast<_Types&&>(_Args)...)) {
+        return static_cast<_Callable&&>(_Obj)(static_cast<_Types&&>(_Args)...);
+    }
+};
+
+struct _Invoker_pmf_object {
+    static constexpr _Invoker_strategy _Strategy = _Invoker_strategy::_Pmf_object;
+
+    template <class _Decayed, class _Ty1, class... _Types2>
+    static constexpr auto _Call(_Decayed _Pmf, _Ty1&& _Arg1, _Types2&&... _Args2) noexcept(
+        noexcept((static_cast<_Ty1&&>(_Arg1).*_Pmf)(static_cast<_Types2&&>(_Args2)...)))
+        -> decltype((static_cast<_Ty1&&>(_Arg1).*_Pmf)(static_cast<_Types2&&>(_Args2)...)) {
+        return (static_cast<_Ty1&&>(_Arg1).*_Pmf)(static_cast<_Types2&&>(_Args2)...);
+    }
+};
+
+struct _Invoker_pmf_refwrap {
+    static constexpr _Invoker_strategy _Strategy = _Invoker_strategy::_Pmf_refwrap;
+
+    template <class _Decayed, class _Refwrap, class... _Types2>
+    static constexpr auto _Call(_Decayed _Pmf, _Refwrap _Rw, _Types2&&... _Args2) noexcept(
+        noexcept((_Rw.get().*_Pmf)(static_cast<_Types2&&>(_Args2)...)))
+        -> decltype((_Rw.get().*_Pmf)(static_cast<_Types2&&>(_Args2)...)) {
+        return (_Rw.get().*_Pmf)(static_cast<_Types2&&>(_Args2)...);
+    }
+};
+
+struct _Invoker_pmf_pointer {
+    static constexpr _Invoker_strategy _Strategy = _Invoker_strategy::_Pmf_pointer;
+
+    template <class _Decayed, class _Ty1, class... _Types2>
+    static constexpr auto _Call(_Decayed _Pmf, _Ty1&& _Arg1, _Types2&&... _Args2) noexcept(
+        noexcept(((*static_cast<_Ty1&&>(_Arg1)).*_Pmf)(static_cast<_Types2&&>(_Args2)...)))
+        -> decltype(((*static_cast<_Ty1&&>(_Arg1)).*_Pmf)(static_cast<_Types2&&>(_Args2)...)) {
+        return ((*static_cast<_Ty1&&>(_Arg1)).*_Pmf)(static_cast<_Types2&&>(_Args2)...);
+    }
+};
+
+struct _Invoker_pmd_object {
+    static constexpr _Invoker_strategy _Strategy = _Invoker_strategy::_Pmd_object;
+
+    template <class _Decayed, class _Ty1>
+    static constexpr auto _Call(_Decayed _Pmd, _Ty1&& _Arg1) noexcept -> decltype(static_cast<_Ty1&&>(_Arg1).*_Pmd) {
+        return static_cast<_Ty1&&>(_Arg1).*_Pmd;
+    }
+};
+
+struct _Invoker_pmd_refwrap {
+    static constexpr _Invoker_strategy _Strategy = _Invoker_strategy::_Pmd_refwrap;
+
+    template <class _Decayed, class _Refwrap>
+    static constexpr auto _Call(_Decayed _Pmd, _Refwrap _Rw) noexcept -> decltype(_Rw.get().*_Pmd) {
+        return _Rw.get().*_Pmd;
+    }
+};
+
+struct _Invoker_pmd_pointer {
+    static constexpr _Invoker_strategy _Strategy = _Invoker_strategy::_Pmd_pointer;
+
+    template <class _Decayed, class _Ty1>
+    static constexpr auto _Call(_Decayed _Pmd, _Ty1&& _Arg1) noexcept(noexcept((*static_cast<_Ty1&&>(_Arg1)).*_Pmd))
+        -> decltype((*static_cast<_Ty1&&>(_Arg1)).*_Pmd) {
+        return (*static_cast<_Ty1&&>(_Arg1)).*_Pmd;
+    }
+};
+
+template <class _Callable, class _Ty1, class _Removed_cvref = _Remove_cvref_t<_Callable>,
+    bool _Is_pmf = is_member_function_pointer_v<_Removed_cvref>,
+    bool _Is_pmd = is_member_object_pointer_v<_Removed_cvref>>
+struct _Invoker1;
+
+template <class _Callable, class _Ty1, class _Removed_cvref>
+struct _Invoker1<_Callable, _Ty1, _Removed_cvref, true, false>
+    : conditional_t<is_same_v<typename _Is_memfunptr<_Removed_cvref>::_Class_type, _Remove_cvref_t<_Ty1>>
+                        || is_base_of_v<typename _Is_memfunptr<_Removed_cvref>::_Class_type, _Remove_cvref_t<_Ty1>>,
+          _Invoker_pmf_object,
+          conditional_t<_Is_specialization_v<_Remove_cvref_t<_Ty1>, reference_wrapper>, _Invoker_pmf_refwrap,
+              _Invoker_pmf_pointer>> {}; // pointer to member function
+
+template <class _Callable, class _Ty1, class _Removed_cvref>
+struct _Invoker1<_Callable, _Ty1, _Removed_cvref, false, true>
+    : conditional_t<
+          is_same_v<typename _Is_member_object_pointer<_Removed_cvref>::_Class_type, _Remove_cvref_t<_Ty1>>
+              || is_base_of_v<typename _Is_member_object_pointer<_Removed_cvref>::_Class_type, _Remove_cvref_t<_Ty1>>,
+          _Invoker_pmd_object,
+          conditional_t<_Is_specialization_v<_Remove_cvref_t<_Ty1>, reference_wrapper>, _Invoker_pmd_refwrap,
+              _Invoker_pmd_pointer>> {}; // pointer to member data
+
+template <class _Callable, class _Ty1, class _Removed_cvref>
+struct _Invoker1<_Callable, _Ty1, _Removed_cvref, false, false> : _Invoker_functor {};
+
+_EXPORT_STD template <class _Callable>
+constexpr auto invoke(_Callable&& _Obj) noexcept(noexcept(static_cast<_Callable&&>(_Obj)()))
+    -> decltype(static_cast<_Callable&&>(_Obj)()) {
+    return static_cast<_Callable&&>(_Obj)();
+}
+
+_EXPORT_STD template <class _Callable, class _Ty1, class... _Types2>
+constexpr auto invoke(_Callable&& _Obj, _Ty1&& _Arg1, _Types2&&... _Args2) noexcept(
+    noexcept(_Invoker1<_Callable, _Ty1>::_Call(
+        static_cast<_Callable&&>(_Obj), static_cast<_Ty1&&>(_Arg1), static_cast<_Types2&&>(_Args2)...)))
+    -> decltype(_Invoker1<_Callable, _Ty1>::_Call(
+        static_cast<_Callable&&>(_Obj), static_cast<_Ty1&&>(_Arg1), static_cast<_Types2&&>(_Args2)...)) {
+    if constexpr (_Invoker1<_Callable, _Ty1>::_Strategy == _Invoker_strategy::_Functor) {
+        return static_cast<_Callable&&>(_Obj)(static_cast<_Ty1&&>(_Arg1), static_cast<_Types2&&>(_Args2)...);
+    } else if constexpr (_Invoker1<_Callable, _Ty1>::_Strategy == _Invoker_strategy::_Pmf_object) {
+        return (static_cast<_Ty1&&>(_Arg1).*_Obj)(static_cast<_Types2&&>(_Args2)...);
+    } else if constexpr (_Invoker1<_Callable, _Ty1>::_Strategy == _Invoker_strategy::_Pmf_refwrap) {
+        return (_Arg1.get().*_Obj)(static_cast<_Types2&&>(_Args2)...);
+    } else if constexpr (_Invoker1<_Callable, _Ty1>::_Strategy == _Invoker_strategy::_Pmf_pointer) {
+        return ((*static_cast<_Ty1&&>(_Arg1)).*_Obj)(static_cast<_Types2&&>(_Args2)...);
+    } else if constexpr (_Invoker1<_Callable, _Ty1>::_Strategy == _Invoker_strategy::_Pmd_object) {
+        return static_cast<_Ty1&&>(_Arg1).*_Obj;
+    } else if constexpr (_Invoker1<_Callable, _Ty1>::_Strategy == _Invoker_strategy::_Pmd_refwrap) {
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1956799
+        return _Arg1.get().*_Obj;
+#else // ^^^ no workaround / workaround vvv
+        auto& _Ref = _Arg1.get();
+        return _Ref.*_Obj;
+#endif // ^^^ workaround ^^^
+    } else {
+        _STL_INTERNAL_STATIC_ASSERT(_Invoker1<_Callable, _Ty1>::_Strategy == _Invoker_strategy::_Pmd_pointer);
+        return (*static_cast<_Ty1&&>(_Arg1)).*_Obj;
+    }
+}
+
+#pragma warning(push)
+#pragma warning(disable : 4242) // '%s': conversion from '%s' to '%s', possible loss of data (/Wall)
+#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 (/Wall)
+
+template <class _From, class _To, bool = is_convertible_v<_From, _To>, bool = is_void_v<_To>>
+constexpr bool _Is_nothrow_convertible_v = noexcept(_STD _Fake_copy_init<_To>(_STD declval<_From>()));
+
+#pragma warning(pop)
+
+template <class _From, class _To, bool _IsVoid>
+constexpr bool _Is_nothrow_convertible_v<_From, _To, false, _IsVoid> = false;
+
+template <class _From, class _To>
+constexpr bool _Is_nothrow_convertible_v<_From, _To, true, true> = true;
+
+template <class _From, class _To>
+struct _Is_nothrow_convertible : bool_constant<_Is_nothrow_convertible_v<_From, _To>> {
+    // determine whether _From is nothrow-convertible to _To
+};
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _From, class _To>
+constexpr bool is_nothrow_convertible_v = _Is_nothrow_convertible_v<_From, _To>;
+
+_EXPORT_STD template <class _From, class _To>
+struct is_nothrow_convertible : bool_constant<_Is_nothrow_convertible_v<_From, _To>> {};
+#endif // _HAS_CXX20
+
+template <class _From, class _To, class = void>
+struct _Invoke_convertible : false_type {};
+
+template <class _From, class _To>
+struct _Invoke_convertible<_From, _To, void_t<decltype(_STD _Fake_copy_init<_To>(_STD _Returns_exactly<_From>()))>>
+    : true_type {};
+
+template <class _From, class _To>
+struct _Invoke_nothrow_convertible
+    : bool_constant<noexcept(_STD _Fake_copy_init<_To>(_STD _Returns_exactly<_From>()))> {};
+
+template <class _Result, bool _Nothrow>
+struct _Invoke_traits_common {
+    using type                  = _Result;
+    using _Is_invocable         = true_type;
+    using _Is_nothrow_invocable = bool_constant<_Nothrow>;
+    template <class _Rx>
+    using _Is_invocable_r = bool_constant<disjunction_v<is_void<_Rx>, _Invoke_convertible<type, _Rx>>>;
+    template <class _Rx>
+    using _Is_nothrow_invocable_r = bool_constant<conjunction_v<_Is_nothrow_invocable,
+        disjunction<is_void<_Rx>,
+            conjunction<_Invoke_convertible<type, _Rx>, _Invoke_nothrow_convertible<type, _Rx>>>>>;
+};
+
+template <class _Void, class _Callable>
+struct _Invoke_traits_zero {
+    // selected when _Callable isn't callable with zero _Args
+    using _Is_invocable         = false_type;
+    using _Is_nothrow_invocable = false_type;
+    template <class _Rx>
+    using _Is_invocable_r = false_type;
+    template <class _Rx>
+    using _Is_nothrow_invocable_r = false_type;
+};
+
+template <class _Callable>
+using _Decltype_invoke_zero = decltype(_STD declval<_Callable>()());
+
+template <class _Callable>
+struct _Invoke_traits_zero<void_t<_Decltype_invoke_zero<_Callable>>, _Callable>
+    : _Invoke_traits_common<_Decltype_invoke_zero<_Callable>, noexcept(_STD declval<_Callable>()())> {};
+
+template <class _Void, class... _Types>
+struct _Invoke_traits_nonzero {
+    // selected when _Callable isn't callable with nonzero _Args
+    using _Is_invocable         = false_type;
+    using _Is_nothrow_invocable = false_type;
+    template <class _Rx>
+    using _Is_invocable_r = false_type;
+    template <class _Rx>
+    using _Is_nothrow_invocable_r = false_type;
+};
+
+template <class _Callable, class _Ty1, class... _Types2>
+using _Decltype_invoke_nonzero = decltype(_Invoker1<_Callable, _Ty1>::_Call(
+    _STD declval<_Callable>(), _STD declval<_Ty1>(), _STD declval<_Types2>()...));
+
+template <class _Callable, class _Ty1, class... _Types2>
+struct _Invoke_traits_nonzero<void_t<_Decltype_invoke_nonzero<_Callable, _Ty1, _Types2...>>, _Callable, _Ty1,
+    _Types2...> : _Invoke_traits_common<_Decltype_invoke_nonzero<_Callable, _Ty1, _Types2...>,
+                      noexcept(_Invoker1<_Callable, _Ty1>::_Call(
+                          _STD declval<_Callable>(), _STD declval<_Ty1>(), _STD declval<_Types2>()...))> {};
+
+template <class _Callable, class... _Args>
+using _Select_invoke_traits = conditional_t<sizeof...(_Args) == 0, _Invoke_traits_zero<void, _Callable>,
+    _Invoke_traits_nonzero<void, _Callable, _Args...>>;
+
+#if _HAS_DEPRECATED_RESULT_OF
+_EXPORT_STD template <class _Fty>
+struct _CXX17_DEPRECATE_RESULT_OF result_of { // explain usage
+    static_assert(_Always_false<_Fty>, "result_of<CallableType> is invalid; use "
+                                       "result_of<CallableType(zero or more argument types)> instead.");
+};
+
+#define _RESULT_OF(CALL_OPT, X1, X2, X3)                                                                    \
+    template <class _Callable, class... _Args>                                                              \
+    struct _CXX17_DEPRECATE_RESULT_OF result_of<_Callable CALL_OPT(_Args...)>                               \
+        : _Select_invoke_traits<_Callable, _Args...> { /* template to determine result of call operation */ \
+    };
+
+_NON_MEMBER_CALL(_RESULT_OF, X1, X2, X3)
+#undef _RESULT_OF
+
+_STL_DISABLE_DEPRECATED_WARNING
+_EXPORT_STD template <class _Ty>
+using result_of_t _CXX17_DEPRECATE_RESULT_OF = typename result_of<_Ty>::type;
+_STL_RESTORE_DEPRECATED_WARNING
+#endif // _HAS_DEPRECATED_RESULT_OF
+
+template <class _Callable, class... _Args>
+using _Invoke_result_t = typename _Select_invoke_traits<_Callable, _Args...>::type;
+
+template <class _Rx, class _Callable, class... _Args>
+using _Is_invocable_r_ = typename _Select_invoke_traits<_Callable, _Args...>::template _Is_invocable_r<_Rx>;
+
+template <class _Rx, class _Callable, class... _Args>
+struct _Is_invocable_r : _Is_invocable_r_<_Rx, _Callable, _Args...> {
+    // determines whether _Callable is callable with _Args and return type _Rx
+};
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _Callable, class... _Args>
+struct invoke_result : _Select_invoke_traits<_Callable, _Args...> {
+    // determine the result type of invoking _Callable with _Args
+};
+
+_EXPORT_STD template <class _Callable, class... _Args>
+using invoke_result_t = typename _Select_invoke_traits<_Callable, _Args...>::type;
+
+_EXPORT_STD template <class _Callable, class... _Args>
+struct is_invocable : _Select_invoke_traits<_Callable, _Args...>::_Is_invocable {
+    // determines whether _Callable is callable with _Args
+};
+
+_EXPORT_STD template <class _Callable, class... _Args>
+constexpr bool is_invocable_v = _Select_invoke_traits<_Callable, _Args...>::_Is_invocable::value;
+
+_EXPORT_STD template <class _Callable, class... _Args>
+struct is_nothrow_invocable : _Select_invoke_traits<_Callable, _Args...>::_Is_nothrow_invocable {
+    // determines whether _Callable is nothrow-callable with _Args
+};
+
+_EXPORT_STD template <class _Callable, class... _Args>
+constexpr bool is_nothrow_invocable_v = _Select_invoke_traits<_Callable, _Args...>::_Is_nothrow_invocable::value;
+
+_EXPORT_STD template <class _Rx, class _Callable, class... _Args>
+struct is_invocable_r : _Is_invocable_r_<_Rx, _Callable, _Args...> {
+    // determines whether _Callable is callable with _Args and return type _Rx
+};
+
+_EXPORT_STD template <class _Rx, class _Callable, class... _Args>
+constexpr bool is_invocable_r_v = _Is_invocable_r_<_Rx, _Callable, _Args...>::value;
+
+_EXPORT_STD template <class _Rx, class _Callable, class... _Args>
+struct is_nothrow_invocable_r : _Select_invoke_traits<_Callable, _Args...>::template _Is_nothrow_invocable_r<_Rx> {
+    // determines whether _Callable is nothrow-callable with _Args and return type _Rx
+};
+
+_EXPORT_STD template <class _Rx, class _Callable, class... _Args>
+constexpr bool is_nothrow_invocable_r_v =
+    _Select_invoke_traits<_Callable, _Args...>::template _Is_nothrow_invocable_r<_Rx>::value;
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+#ifndef __clang__ // TRANSITION, LLVM-48860
+_EXPORT_STD template <class _Ty1, class _Ty2>
+struct is_layout_compatible : bool_constant<__is_layout_compatible(_Ty1, _Ty2)> {};
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+constexpr bool is_layout_compatible_v = __is_layout_compatible(_Ty1, _Ty2);
+
+_EXPORT_STD template <class _Base, class _Derived>
+struct is_pointer_interconvertible_base_of : bool_constant<__is_pointer_interconvertible_base_of(_Base, _Derived)> {};
+
+_EXPORT_STD template <class _Base, class _Derived>
+constexpr bool is_pointer_interconvertible_base_of_v = __is_pointer_interconvertible_base_of(_Base, _Derived);
+
+_EXPORT_STD template <class _ClassTy, class _MemberTy>
+_NODISCARD constexpr bool is_pointer_interconvertible_with_class(_MemberTy _ClassTy::*_Pm) noexcept {
+    return __is_pointer_interconvertible_with_class(_ClassTy, _Pm);
+}
+
+_EXPORT_STD template <class _ClassTy1, class _ClassTy2, class _MemberTy1, class _MemberTy2>
+_NODISCARD constexpr bool is_corresponding_member(_MemberTy1 _ClassTy1::*_Pm1, _MemberTy2 _ClassTy2::*_Pm2) noexcept {
+    return __is_corresponding_member(_ClassTy1, _ClassTy2, _Pm1, _Pm2);
+}
+#endif // ^^^ no workaround ^^^
+#endif // _HAS_CXX20
+
+template <class _Ty>
+struct _Function_args {}; // determine whether _Ty is a function
+
+#define _FUNCTION_ARGS(CALL_OPT, CV_OPT, REF_OPT, NOEXCEPT_OPT)                                           \
+    template <class _Ret, class... _Types>                                                                \
+    struct _Function_args<_Ret CALL_OPT(_Types...) CV_OPT REF_OPT NOEXCEPT_OPT> : _Arg_types<_Types...> { \
+        using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ret;                                 \
+    };
+
+_NON_MEMBER_CALL_CV_REF_NOEXCEPT(_FUNCTION_ARGS)
+#undef _FUNCTION_ARGS
+
+#define _FUNCTION_ARGS_ELLIPSIS(CV_REF_NOEXCEPT_OPT)                                                            \
+    template <class _Ret, class... _Types>                                                                      \
+    struct _Function_args<_Ret(_Types..., ...) CV_REF_NOEXCEPT_OPT> { /* no calling conventions for ellipsis */ \
+        using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ret;                                       \
+    };
+
+_CLASS_DEFINE_CV_REF_NOEXCEPT(_FUNCTION_ARGS_ELLIPSIS)
+#undef _FUNCTION_ARGS_ELLIPSIS
+
+template <class _Ty, class = void>
+struct _Weak_result_type {}; // default definition
+
+_STL_DISABLE_DEPRECATED_WARNING
+template <class _Ty>
+struct _Weak_result_type<_Ty, void_t<typename _Ty::result_type>> { // defined if _Ty::result_type exists
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = typename _Ty::result_type;
+};
+_STL_RESTORE_DEPRECATED_WARNING
+
+template <class _Ty, class = void>
+struct _Weak_argument_type : _Weak_result_type<_Ty> {}; // default definition
+
+_STL_DISABLE_DEPRECATED_WARNING
+template <class _Ty>
+struct _Weak_argument_type<_Ty, void_t<typename _Ty::argument_type>> : _Weak_result_type<_Ty> {
+    // defined if _Ty::argument_type exists
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = typename _Ty::argument_type;
+};
+_STL_RESTORE_DEPRECATED_WARNING
+
+template <class _Ty, class = void>
+struct _Weak_binary_args : _Weak_argument_type<_Ty> {}; // default definition
+
+_STL_DISABLE_DEPRECATED_WARNING
+template <class _Ty>
+struct _Weak_binary_args<_Ty, void_t<typename _Ty::first_argument_type,
+                                  typename _Ty::second_argument_type>>
+    : _Weak_argument_type<_Ty> { // defined if both types exist
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = typename _Ty::first_argument_type;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = typename _Ty::second_argument_type;
+};
+_STL_RESTORE_DEPRECATED_WARNING
+
+template <class _Ty>
+using _Weak_types = conditional_t<is_function_v<remove_pointer_t<_Ty>>, _Function_args<remove_pointer_t<_Ty>>,
+    conditional_t<is_member_function_pointer_v<_Ty>, _Is_memfunptr<remove_cv_t<_Ty>>, _Weak_binary_args<_Ty>>>;
+
+template <class _Ty>
+void _Refwrap_ctor_fun(_Identity_t<_Ty&>) noexcept; // not defined
+template <class _Ty>
+void _Refwrap_ctor_fun(_Identity_t<_Ty&&>) = delete;
+
+template <class _Ty, class _Uty, class = void>
+struct _Refwrap_has_ctor_from : false_type {};
+
+template <class _Ty, class _Uty>
+struct _Refwrap_has_ctor_from<_Ty, _Uty, void_t<decltype(_STD _Refwrap_ctor_fun<_Ty>(_STD declval<_Uty>()))>>
+    : true_type {}; // _STD _Refwrap_ctor_fun is qualified: avoid ADL, handle incomplete types
+
+_EXPORT_STD template <class _Ty>
+class reference_wrapper
+#if !_HAS_CXX20
+    : public _Weak_types<_Ty>
+#endif // !_HAS_CXX20
+{
+public:
+    static_assert(is_object_v<_Ty> || is_function_v<_Ty>,
+        "reference_wrapper<T> requires T to be an object type or a function type.");
+
+    using type = _Ty;
+
+    template <class _Uty, enable_if_t<conjunction_v<negation<is_same<_Remove_cvref_t<_Uty>, reference_wrapper>>,
+                                          _Refwrap_has_ctor_from<_Ty, _Uty>>,
+                              int> = 0>
+    _CONSTEXPR20 reference_wrapper(_Uty&& _Val) noexcept(
+        noexcept(_STD _Refwrap_ctor_fun<_Ty>(_STD declval<_Uty>()))) { // qualified: avoid ADL, handle incomplete types
+        _Ty& _Ref = static_cast<_Uty&&>(_Val);
+        _Ptr      = _STD addressof(_Ref);
+    }
+
+    _CONSTEXPR20 operator _Ty&() const noexcept {
+        return *_Ptr;
+    }
+
+    _NODISCARD _CONSTEXPR20 _Ty& get() const noexcept {
+        return *_Ptr;
+    }
+
+private:
+    _Ty* _Ptr{};
+
+public:
+    template <class... _Types>
+    _CONSTEXPR20 auto operator()(_Types&&... _Args) const
+        noexcept(noexcept(_STD invoke(*_Ptr, static_cast<_Types&&>(_Args)...)))
+            -> decltype(_STD invoke(*_Ptr, static_cast<_Types&&>(_Args)...)) {
+        return _STD invoke(*_Ptr, static_cast<_Types&&>(_Args)...);
+    }
+};
+
+#if _HAS_CXX17
+template <class _Ty>
+reference_wrapper(_Ty&) -> reference_wrapper<_Ty>;
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _CONSTEXPR20 reference_wrapper<_Ty> ref(_Ty& _Val) noexcept {
+    return reference_wrapper<_Ty>(_Val);
+}
+
+_EXPORT_STD template <class _Ty>
+void ref(const _Ty&&) = delete;
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _CONSTEXPR20 reference_wrapper<_Ty> ref(reference_wrapper<_Ty> _Val) noexcept {
+    return _Val;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _CONSTEXPR20 reference_wrapper<const _Ty> cref(const _Ty& _Val) noexcept {
+    return reference_wrapper<const _Ty>(_Val);
+}
+
+_EXPORT_STD template <class _Ty>
+void cref(const _Ty&&) = delete;
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _CONSTEXPR20 reference_wrapper<const _Ty> cref(reference_wrapper<_Ty> _Val) noexcept {
+    return _Val;
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty>
+struct unwrap_reference {
+    using type = _Ty;
+};
+template <class _Ty>
+struct unwrap_reference<reference_wrapper<_Ty>> {
+    using type = _Ty&;
+};
+_EXPORT_STD template <class _Ty>
+using unwrap_reference_t = unwrap_reference<_Ty>::type;
+
+_EXPORT_STD template <class _Ty>
+using unwrap_ref_decay_t = unwrap_reference_t<decay_t<_Ty>>;
+_EXPORT_STD template <class _Ty>
+struct unwrap_ref_decay {
+    using type = unwrap_ref_decay_t<_Ty>;
+};
+#endif // _HAS_CXX20
+
+template <class _Ty>
+struct _Is_swappable;
+
+template <class _Ty>
+struct _Is_nothrow_swappable;
+
+#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&, _Ty&) noexcept(is_nothrow_move_constructible_v<_Ty> && is_nothrow_move_assignable_v<_Ty>);
+
+_EXPORT_STD template <class _Ty, size_t _Size, enable_if_t<_Is_swappable<_Ty>::value, int> = 0>
+_CONSTEXPR20 void swap(_Ty (&)[_Size], _Ty (&)[_Size]) noexcept(_Is_nothrow_swappable<_Ty>::value);
+
+template <class _Ty1, class _Ty2, class = void>
+struct _Swappable_with_helper : false_type {}; // swap(declval<_Ty1>(), declval<_Ty2>()) is not valid
+
+template <class _Ty1, class _Ty2>
+struct _Swappable_with_helper<_Ty1, _Ty2, void_t<decltype(swap(_STD declval<_Ty1>(), _STD declval<_Ty2>()))>>
+    : true_type {}; // swap(declval<_Ty1>(), declval<_Ty2>()) is valid
+
+template <class _Ty1, class _Ty2>
+struct _Is_swappable_with
+    : bool_constant<conjunction_v<_Swappable_with_helper<_Ty1, _Ty2>, _Swappable_with_helper<_Ty2, _Ty1>>> {
+    // Determine if expressions with type and value category _Ty1 and _Ty2 can be swapped (and vice versa)
+};
+
+template <class _Ty>
+struct _Is_swappable : _Is_swappable_with<add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<_Ty>>::type {
+    // Determine if _Ty lvalues satisfy is_swappable_with
+};
+
+template <class _Ty1, class _Ty2>
+struct _Swap_cannot_throw : bool_constant<noexcept(swap(_STD declval<_Ty1>(), _STD declval<_Ty2>()))
+                                          && noexcept(swap(_STD declval<_Ty2>(), _STD declval<_Ty1>()))> {
+    // Determine if expressions with type and value category _Ty1 and _Ty2
+    // (presumed to satisfy is_swappable_with) can be swapped without emitting exceptions
+};
+
+template <class _Ty1, class _Ty2>
+struct _Is_nothrow_swappable_with
+    : bool_constant<conjunction_v<_Is_swappable_with<_Ty1, _Ty2>, _Swap_cannot_throw<_Ty1, _Ty2>>> {
+    // Determine if expressions with type and value category _Ty1 and _Ty2
+    // satisfy is_swappable_with, and can be swapped without emitting exceptions
+};
+
+template <class _Ty>
+struct _Is_nothrow_swappable
+    : _Is_nothrow_swappable_with<add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<_Ty>>::type {
+    // Determine if _Ty lvalues satisfy is_nothrow_swappable_with
+};
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _Ty1, class _Ty2>
+struct is_swappable_with : _Is_swappable_with<_Ty1, _Ty2>::type {
+    // Determine if expressions with type and value category _Ty1 and _Ty2
+    // can be swapped (and vice versa)
+};
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+constexpr bool is_swappable_with_v =
+    conjunction_v<_Swappable_with_helper<_Ty1, _Ty2>, _Swappable_with_helper<_Ty2, _Ty1>>;
+
+_EXPORT_STD template <class _Ty>
+struct is_swappable : _Is_swappable<_Ty>::type {}; // Determine if _Ty lvalues satisfy is_swappable_with
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_swappable_v = _Is_swappable<_Ty>::value;
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+struct is_nothrow_swappable_with : _Is_nothrow_swappable_with<_Ty1, _Ty2>::type {
+    // Determine if expressions with type and value category _Ty1 and _Ty2
+    // satisfy is_swappable_with, and can be swapped without emitting exceptions
+};
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+constexpr bool is_nothrow_swappable_with_v = _Is_nothrow_swappable_with<_Ty1, _Ty2>::value;
+
+_EXPORT_STD template <class _Ty>
+struct is_nothrow_swappable : _Is_nothrow_swappable<_Ty>::type {
+    // Determine if _Ty lvalues satisfy is_nothrow_swappable_with
+};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_nothrow_swappable_v = _Is_nothrow_swappable<_Ty>::value;
+#endif // _HAS_CXX17
+
+namespace _Has_ADL_swap_detail {
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1681199
+    void swap() = delete; // Block unqualified name lookup
+#else // ^^^ no workaround / workaround vvv
+    void swap();
+#endif // ^^^ workaround ^^^
+
+    template <class, class = void>
+    struct _Has_ADL_swap : false_type {};
+    template <class _Ty>
+    struct _Has_ADL_swap<_Ty, void_t<decltype(swap(_STD declval<_Ty&>(), _STD declval<_Ty&>()))>> : true_type {};
+} // namespace _Has_ADL_swap_detail
+using _Has_ADL_swap_detail::_Has_ADL_swap;
+
+template <class _Ty>
+constexpr bool _Is_trivially_swappable_v = conjunction_v<is_trivially_destructible<_Ty>,
+    is_trivially_move_constructible<_Ty>, is_trivially_move_assignable<_Ty>, negation<_Has_ADL_swap<_Ty>>>;
+
+#ifdef __cpp_lib_byte
+template <>
+inline constexpr bool _Is_trivially_swappable_v<byte> = true;
+#endif // defined(__cpp_lib_byte)
+
+template <class _Ty>
+struct _Is_trivially_swappable : bool_constant<_Is_trivially_swappable_v<_Ty>> {
+    // true_type if and only if it is valid to swap two _Ty lvalues by exchanging object representations.
+};
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _From, class _To>
+concept convertible_to =
+#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, DevCom-1627396
+    is_convertible_v<_From, _To>
+#else // ^^^ workaround / no workaround vvv
+    __is_convertible_to(_From, _To)
+#endif // ^^^ no workaround ^^^
+    && requires { static_cast<_To>(_STD declval<_From>()); };
+
+template <class _RefWrap, class _Ty, class _RefWrapQ, class _TyQ>
+concept _Ref_wrap_common_reference_exists_with = _Is_specialization_v<_RefWrap, reference_wrapper> && requires {
+    typename common_reference_t<typename _RefWrap::type&, _TyQ>;
+} && convertible_to<_RefWrapQ, common_reference_t<typename _RefWrap::type&, _TyQ>>;
+
+template <class _RefWrap, class _Ty, template <class> class _RefWrapQual, template <class> class _TyQual>
+    requires (_Ref_wrap_common_reference_exists_with<_RefWrap, _Ty, _RefWrapQual<_RefWrap>, _TyQual<_Ty>>
+              && !_Ref_wrap_common_reference_exists_with<_Ty, _RefWrap, _TyQual<_Ty>, _RefWrapQual<_RefWrap>>)
+struct basic_common_reference<_RefWrap, _Ty, _RefWrapQual, _TyQual> {
+    using type = common_reference_t<typename _RefWrap::type&, _TyQual<_Ty>>;
+};
+
+template <class _Ty, class _RefWrap, template <class> class _TyQual, template <class> class _RefWrapQual>
+    requires (_Ref_wrap_common_reference_exists_with<_RefWrap, _Ty, _RefWrapQual<_RefWrap>, _TyQual<_Ty>>
+              && !_Ref_wrap_common_reference_exists_with<_Ty, _RefWrap, _TyQual<_Ty>, _RefWrapQual<_RefWrap>>)
+struct basic_common_reference<_Ty, _RefWrap, _TyQual, _RefWrapQual> {
+    using type = common_reference_t<typename _RefWrap::type&, _TyQual<_Ty>>;
+};
+#endif // _HAS_CXX20
+
+#define _BITMASK_OPS(_MAYBE_EXPORT, _BITMASK)                                                         \
+    _MAYBE_EXPORT _NODISCARD constexpr _BITMASK operator&(_BITMASK _Left, _BITMASK _Right) noexcept { \
+        using _IntTy = _STD underlying_type_t<_BITMASK>;                                              \
+        return static_cast<_BITMASK>(static_cast<_IntTy>(_Left) & static_cast<_IntTy>(_Right));       \
+    }                                                                                                 \
+                                                                                                      \
+    _MAYBE_EXPORT _NODISCARD constexpr _BITMASK operator|(_BITMASK _Left, _BITMASK _Right) noexcept { \
+        using _IntTy = _STD underlying_type_t<_BITMASK>;                                              \
+        return static_cast<_BITMASK>(static_cast<_IntTy>(_Left) | static_cast<_IntTy>(_Right));       \
+    }                                                                                                 \
+                                                                                                      \
+    _MAYBE_EXPORT _NODISCARD constexpr _BITMASK operator^(_BITMASK _Left, _BITMASK _Right) noexcept { \
+        using _IntTy = _STD underlying_type_t<_BITMASK>;                                              \
+        return static_cast<_BITMASK>(static_cast<_IntTy>(_Left) ^ static_cast<_IntTy>(_Right));       \
+    }                                                                                                 \
+                                                                                                      \
+    _MAYBE_EXPORT constexpr _BITMASK& operator&=(_BITMASK& _Left, _BITMASK _Right) noexcept {         \
+        return _Left = _Left & _Right;                                                                \
+    }                                                                                                 \
+                                                                                                      \
+    _MAYBE_EXPORT constexpr _BITMASK& operator|=(_BITMASK& _Left, _BITMASK _Right) noexcept {         \
+        return _Left = _Left | _Right;                                                                \
+    }                                                                                                 \
+                                                                                                      \
+    _MAYBE_EXPORT constexpr _BITMASK& operator^=(_BITMASK& _Left, _BITMASK _Right) noexcept {         \
+        return _Left = _Left ^ _Right;                                                                \
+    }                                                                                                 \
+                                                                                                      \
+    _MAYBE_EXPORT _NODISCARD constexpr _BITMASK operator~(_BITMASK _Left) noexcept {                  \
+        using _IntTy = _STD underlying_type_t<_BITMASK>;                                              \
+        return static_cast<_BITMASK>(~static_cast<_IntTy>(_Left));                                    \
+    }
+
+template <class _Bitmask>
+_NODISCARD constexpr bool _Bitmask_includes_any(_Bitmask _Left, _Bitmask _Elements) noexcept {
+    return (_Left & _Elements) != _Bitmask{};
+}
+
+template <class _Bitmask>
+_NODISCARD constexpr bool _Bitmask_includes_all(_Bitmask _Left, _Bitmask _Elements) noexcept {
+    return (_Left & _Elements) == _Elements;
+}
+
+// These FNV-1a utility functions are extremely performance sensitive,
+// check examples like that in VSO-653642 before making changes.
+#if defined(_WIN64)
+_INLINE_VAR constexpr size_t _FNV_offset_basis = 14695981039346656037ULL;
+_INLINE_VAR constexpr size_t _FNV_prime        = 1099511628211ULL;
+#else // ^^^ defined(_WIN64) / !defined(_WIN64) vvv
+_INLINE_VAR constexpr size_t _FNV_offset_basis = 2166136261U;
+_INLINE_VAR constexpr size_t _FNV_prime        = 16777619U;
+#endif // ^^^ !defined(_WIN64) ^^^
+
+_NODISCARD inline size_t _Fnv1a_append_bytes(size_t _Val, const unsigned char* const _First,
+    const size_t _Count) noexcept { // accumulate range [_First, _First + _Count) into partial FNV-1a hash _Val
+    for (size_t _Idx = 0; _Idx < _Count; ++_Idx) {
+        _Val ^= static_cast<size_t>(_First[_Idx]);
+        _Val *= _FNV_prime;
+    }
+
+    return _Val;
+}
+
+template <class _Ty>
+_NODISCARD size_t _Fnv1a_append_range(const size_t _Val, const _Ty* const _First,
+    const _Ty* const _Last) noexcept { // accumulate range [_First, _Last) into partial FNV-1a hash _Val
+    static_assert(is_trivial_v<_Ty>, "Only trivial types can be directly hashed.");
+    const auto _Firstb = reinterpret_cast<const unsigned char*>(_First);
+    const auto _Lastb  = reinterpret_cast<const unsigned char*>(_Last);
+    return _Fnv1a_append_bytes(_Val, _Firstb, static_cast<size_t>(_Lastb - _Firstb));
+}
+
+template <class _Kty>
+_NODISCARD size_t _Fnv1a_append_value(
+    const size_t _Val, const _Kty& _Keyval) noexcept { // accumulate _Keyval into partial FNV-1a hash _Val
+    static_assert(is_trivial_v<_Kty>, "Only trivial types can be directly hashed.");
+    return _Fnv1a_append_bytes(_Val, &reinterpret_cast<const unsigned char&>(_Keyval), sizeof(_Kty));
+}
+
+template <class _Kty>
+_NODISCARD size_t _Hash_representation(const _Kty& _Keyval) noexcept { // bitwise hashes the representation of a key
+    return _Fnv1a_append_value(_FNV_offset_basis, _Keyval);
+}
+
+template <class _Kty>
+_NODISCARD size_t _Hash_array_representation(
+    const _Kty* const _First, const size_t _Count) noexcept { // bitwise hashes the representation of an array
+    static_assert(is_trivial_v<_Kty>, "Only trivial types can be directly hashed.");
+    return _Fnv1a_append_bytes(
+        _FNV_offset_basis, reinterpret_cast<const unsigned char*>(_First), _Count * sizeof(_Kty));
+}
+
+_EXPORT_STD template <class _Kty>
+struct hash;
+
+template <class _Kty, bool _Enabled>
+struct _Conditionally_enabled_hash { // conditionally enabled hash base
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Kty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
+
+    _NODISCARD _STATIC_CALL_OPERATOR size_t operator()(const _Kty& _Keyval) _CONST_CALL_OPERATOR
+        noexcept(noexcept(hash<_Kty>::_Do_hash(_Keyval))) /* strengthened */ {
+        return hash<_Kty>::_Do_hash(_Keyval);
+    }
+};
+
+template <class _Kty>
+struct _Conditionally_enabled_hash<_Kty, false> { // conditionally disabled hash base
+    _Conditionally_enabled_hash()                                              = delete;
+    _Conditionally_enabled_hash(const _Conditionally_enabled_hash&)            = delete;
+    _Conditionally_enabled_hash(_Conditionally_enabled_hash&&)                 = delete;
+    _Conditionally_enabled_hash& operator=(const _Conditionally_enabled_hash&) = delete;
+    _Conditionally_enabled_hash& operator=(_Conditionally_enabled_hash&&)      = delete;
+};
+
+_EXPORT_STD template <class _Kty>
+struct hash : _Conditionally_enabled_hash<_Kty, !is_const_v<_Kty> && !is_volatile_v<_Kty>
+                                                    && (is_enum_v<_Kty> || is_integral_v<_Kty> || is_pointer_v<_Kty>)> {
+    // hash functor primary template (handles enums, integrals, and pointers)
+    static size_t _Do_hash(const _Kty& _Keyval) noexcept {
+        return _Hash_representation(_Keyval);
+    }
+};
+
+template <>
+struct hash<float> {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = float;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
+    _NODISCARD _STATIC_CALL_OPERATOR size_t operator()(const float _Keyval) _CONST_CALL_OPERATOR noexcept {
+        return _Hash_representation(_Keyval == 0.0F ? 0.0F : _Keyval); // map -0 to 0
+    }
+};
+
+template <>
+struct hash<double> {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = double;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
+    _NODISCARD _STATIC_CALL_OPERATOR size_t operator()(const double _Keyval) _CONST_CALL_OPERATOR noexcept {
+        return _Hash_representation(_Keyval == 0.0 ? 0.0 : _Keyval); // map -0 to 0
+    }
+};
+
+template <>
+struct hash<long double> {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = long double;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
+    _NODISCARD _STATIC_CALL_OPERATOR size_t operator()(const long double _Keyval) _CONST_CALL_OPERATOR noexcept {
+        return _Hash_representation(_Keyval == 0.0L ? 0.0L : _Keyval); // map -0 to 0
+    }
+};
+
+template <>
+struct hash<nullptr_t> {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = nullptr_t;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
+    _NODISCARD _STATIC_CALL_OPERATOR size_t operator()(nullptr_t) _CONST_CALL_OPERATOR noexcept {
+        void* _Null{};
+        return _Hash_representation(_Null);
+    }
+};
+
+template <class _Kty, class = void>
+struct _Is_nothrow_hashable : false_type {}; // tests if std::hash can hash _Kty with noexcept
+
+template <class _Kty>
+struct _Is_nothrow_hashable<_Kty, void_t<decltype(hash<_Kty>{}(_STD declval<const _Kty&>()))>>
+    : bool_constant<noexcept(hash<_Kty>{}(_STD declval<const _Kty&>()))> {};
+
+_EXPORT_STD template <class _Ty = void>
+struct less {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = bool;
+
+    _NODISCARD constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left < _Right))) /* strengthened */ {
+        return _Left < _Right;
+    }
+};
+
+template <>
+struct less<void> {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        noexcept(noexcept(static_cast<_Ty1&&>(_Left) < static_cast<_Ty2&&>(_Right))) // strengthened
+        -> decltype(static_cast<_Ty1&&>(_Left) < static_cast<_Ty2&&>(_Right)) {
+        return static_cast<_Ty1&&>(_Left) < static_cast<_Ty2&&>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+// vvvvvvvvvv DERIVED FROM corecrt_internal_fltintrn.h vvvvvvvvvv
+
+template <class _FloatingType>
+struct _Floating_type_traits;
+
+template <>
+struct _Floating_type_traits<float> {
+    static constexpr int32_t _Mantissa_bits           = 24; // FLT_MANT_DIG
+    static constexpr int32_t _Exponent_bits           = 8; // sizeof(float) * CHAR_BIT - FLT_MANT_DIG
+    static constexpr int32_t _Maximum_binary_exponent = 127; // FLT_MAX_EXP - 1
+    static constexpr int32_t _Minimum_binary_exponent = -126; // FLT_MIN_EXP - 1
+    static constexpr int32_t _Exponent_bias           = 127;
+    static constexpr int32_t _Sign_shift              = 31; // _Exponent_bits + _Mantissa_bits - 1
+    static constexpr int32_t _Exponent_shift          = 23; // _Mantissa_bits - 1
+
+    using _Uint_type = uint32_t;
+
+    static constexpr uint32_t _Exponent_mask             = 0x000000FFu; // (1u << _Exponent_bits) - 1
+    static constexpr uint32_t _Normal_mantissa_mask      = 0x00FFFFFFu; // (1u << _Mantissa_bits) - 1
+    static constexpr uint32_t _Denormal_mantissa_mask    = 0x007FFFFFu; // (1u << (_Mantissa_bits - 1)) - 1
+    static constexpr uint32_t _Special_nan_mantissa_mask = 0x00400000u; // 1u << (_Mantissa_bits - 2)
+    static constexpr uint32_t _Shifted_sign_mask         = 0x80000000u; // 1u << _Sign_shift
+    static constexpr uint32_t _Shifted_exponent_mask     = 0x7F800000u; // _Exponent_mask << _Exponent_shift
+
+    static constexpr float _Minimum_value = 0x1.000000p-126f; // FLT_MIN
+    static constexpr float _Maximum_value = 0x1.FFFFFEp+127f; // FLT_MAX
+};
+
+template <>
+struct _Floating_type_traits<double> {
+    static constexpr int32_t _Mantissa_bits           = 53; // DBL_MANT_DIG
+    static constexpr int32_t _Exponent_bits           = 11; // sizeof(double) * CHAR_BIT - DBL_MANT_DIG
+    static constexpr int32_t _Maximum_binary_exponent = 1023; // DBL_MAX_EXP - 1
+    static constexpr int32_t _Minimum_binary_exponent = -1022; // DBL_MIN_EXP - 1
+    static constexpr int32_t _Exponent_bias           = 1023;
+    static constexpr int32_t _Sign_shift              = 63; // _Exponent_bits + _Mantissa_bits - 1
+    static constexpr int32_t _Exponent_shift          = 52; // _Mantissa_bits - 1
+
+    using _Uint_type = uint64_t;
+
+    static constexpr uint64_t _Exponent_mask             = 0x00000000000007FFu; // (1ULL << _Exponent_bits) - 1
+    static constexpr uint64_t _Normal_mantissa_mask      = 0x001FFFFFFFFFFFFFu; // (1ULL << _Mantissa_bits) - 1
+    static constexpr uint64_t _Denormal_mantissa_mask    = 0x000FFFFFFFFFFFFFu; // (1ULL << (_Mantissa_bits - 1)) - 1
+    static constexpr uint64_t _Special_nan_mantissa_mask = 0x0008000000000000u; // 1ULL << (_Mantissa_bits - 2)
+    static constexpr uint64_t _Shifted_sign_mask         = 0x8000000000000000u; // 1ULL << _Sign_shift
+    static constexpr uint64_t _Shifted_exponent_mask     = 0x7FF0000000000000u; // _Exponent_mask << _Exponent_shift
+
+    static constexpr double _Minimum_value = 0x1.0000000000000p-1022; // DBL_MIN
+    static constexpr double _Maximum_value = 0x1.FFFFFFFFFFFFFp+1023; // DBL_MAX
+};
+
+template <>
+struct _Floating_type_traits<long double> : _Floating_type_traits<double> {};
+
+// ^^^^^^^^^^ DERIVED FROM corecrt_internal_fltintrn.h ^^^^^^^^^^
+
+template <class _To, class _From,
+    enable_if_t<conjunction_v<bool_constant<sizeof(_To) == sizeof(_From)>, is_trivially_copyable<_To>,
+                    is_trivially_copyable<_From>>,
+        int> = 0>
+_NODISCARD constexpr _To _Bit_cast(const _From& _Val) noexcept {
+    return __builtin_bit_cast(_To, _Val);
+}
+
+template <class _Ty, enable_if_t<is_floating_point_v<_Ty>, int> = 0>
+_NODISCARD constexpr auto _Float_abs_bits(const _Ty& _Xx) noexcept {
+    using _Traits    = _Floating_type_traits<_Ty>;
+    using _Uint_type = typename _Traits::_Uint_type;
+    const auto _Bits = _Bit_cast<_Uint_type>(_Xx);
+    return _Bits & ~_Traits::_Shifted_sign_mask;
+}
+
+template <class _Ty, enable_if_t<is_floating_point_v<_Ty>, int> = 0>
+_NODISCARD constexpr _Ty _Float_abs(const _Ty _Xx) noexcept { // constexpr floating-point abs()
+    return _Bit_cast<_Ty>(_Float_abs_bits(_Xx));
+}
+
+template <class _Ty, enable_if_t<is_floating_point_v<_Ty>, int> = 0>
+_NODISCARD constexpr bool _Is_nan(const _Ty _Xx) noexcept { // constexpr isnan()
+    using _Traits = _Floating_type_traits<_Ty>;
+    return _Float_abs_bits(_Xx) > _Traits::_Shifted_exponent_mask;
+}
+
+template <class _Ty, enable_if_t<is_floating_point_v<_Ty>, int> = 0>
+_NODISCARD constexpr bool _Is_finite(const _Ty _Xx) noexcept { // constexpr isfinite()
+    using _Traits = _Floating_type_traits<_Ty>;
+    return _Float_abs_bits(_Xx) < _Traits::_Shifted_exponent_mask;
+}
+
+template <bool _IsConst, class _Ty>
+using _Maybe_const = conditional_t<_IsConst, const _Ty, _Ty>;
+
+#if _HAS_TR1_NAMESPACE
+_STL_DISABLE_DEPRECATED_WARNING
+namespace _DEPRECATE_TR1_NAMESPACE tr1 {
+    using _STD add_const;
+    using _STD add_cv;
+    using _STD add_pointer;
+    using _STD add_volatile;
+    using _STD aligned_storage;
+    using _STD alignment_of;
+    using _STD conditional;
+    using _STD decay;
+    using _STD enable_if;
+    using _STD extent;
+    using _STD false_type;
+    using _STD has_virtual_destructor;
+    using _STD integral_constant;
+    using _STD is_abstract;
+    using _STD is_arithmetic;
+    using _STD is_array;
+    using _STD is_base_of;
+    using _STD is_class;
+    using _STD is_compound;
+    using _STD is_const;
+    using _STD is_convertible;
+    using _STD is_empty;
+    using _STD is_enum;
+    using _STD is_floating_point;
+    using _STD is_function;
+    using _STD is_fundamental;
+    using _STD is_integral;
+    using _STD is_member_function_pointer;
+    using _STD is_member_object_pointer;
+    using _STD is_member_pointer;
+    using _STD is_object;
+    using _STD is_pod;
+    using _STD is_pointer;
+    using _STD is_polymorphic;
+    using _STD is_reference;
+    using _STD is_same;
+    using _STD is_scalar;
+    using _STD is_signed;
+    using _STD is_union;
+    using _STD is_unsigned;
+    using _STD is_void;
+    using _STD is_volatile;
+    using _STD make_signed;
+    using _STD make_unsigned;
+    using _STD rank;
+    using _STD remove_all_extents;
+    using _STD remove_const;
+    using _STD remove_cv;
+    using _STD remove_extent;
+    using _STD remove_pointer;
+    using _STD remove_reference;
+    using _STD remove_volatile;
+    using _STD true_type;
+    using _STD cref;
+    using _STD ref;
+    using _STD reference_wrapper;
+#if _HAS_DEPRECATED_RESULT_OF
+    using _STD result_of;
+#endif // _HAS_DEPRECATED_RESULT_OF
+    using _STD hash;
+} // namespace _DEPRECATE_TR1_NAMESPACE tr1
+_STL_RESTORE_DEPRECATED_WARNING
+#endif // _HAS_TR1_NAMESPACE
+
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#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 // _TYPE_TRAITS_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/typeindex b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/typeindex
new file mode 100644
index 0000000000000000000000000000000000000000..7f74cde2a766cdf50ec9f827c61f81d2553938ce
--- /dev/null
+++ b/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_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/typeinfo b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/typeinfo
new file mode 100644
index 0000000000000000000000000000000000000000..e7df437d17a1e4faaea512af82472eb88e8c0e23
--- /dev/null
+++ b/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_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/unordered_map b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/unordered_map
new file mode 100644
index 0000000000000000000000000000000000000000..d0f0b2aa902a7501f183df3a11cbc87e24971834
--- /dev/null
+++ b/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_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/unordered_set b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/unordered_set
new file mode 100644
index 0000000000000000000000000000000000000000..e94e2b680625a8d2789a02b48722ac455cdb3341
--- /dev/null
+++ b/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_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/use_ansi.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/use_ansi.h
new file mode 100644
index 0000000000000000000000000000000000000000..d08a6b6a2f83043a0d933edb746436438e2b3235
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/utility b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/utility
new file mode 100644
index 0000000000000000000000000000000000000000..2281bf7c019a7deaacf4620d161ab9c4c71bdcf7
--- /dev/null
+++ b/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_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vadefs.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vadefs.h
new file mode 100644
index 0000000000000000000000000000000000000000..16d976ee8bc6cede6f6f5d7ef161dec922a6658e
--- /dev/null
+++ b/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)
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/valarray b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/valarray
new file mode 100644
index 0000000000000000000000000000000000000000..38303a6419a7fb581024b7a6eaa843d908843548
--- /dev/null
+++ b/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_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/varargs.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/varargs.h
new file mode 100644
index 0000000000000000000000000000000000000000..6ee069030c121e55293684eb9d8a4f48a8905e03
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/variant b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/variant
new file mode 100644
index 0000000000000000000000000000000000000000..f27bddbc91168fc9daeccf6fe5531b11ed0c76ff
--- /dev/null
+++ b/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_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcclr.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcclr.h
new file mode 100644
index 0000000000000000000000000000000000000000..2de69fb2f1f79581cd9e617118bee0f327958c12
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vccorlib.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vccorlib.h
new file mode 100644
index 0000000000000000000000000000000000000000..251cca45ae0b7a9dc65a71080d85b9a53962911f
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vccorlib.h
@@ -0,0 +1,3393 @@
+//
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+// This header is included by the compiler using /FI when /ZW is specified
+// Do not include any headers in this file
+#ifndef _VCCORLIB_H_
+#define _VCCORLIB_H_
+
+#ifdef _MSC_VER
+#pragma once
+
+#pragma push_macro("_STRINGIZEX")
+#pragma push_macro("_STRINGIZE")
+
+#undef _STRINGIZEX
+#undef _STRINGIZE
+
+#define _STRINGIZEX(x) #x
+#define _STRINGIZE(x) _STRINGIZEX(x)
+
+#pragma detect_mismatch("_VCCORLIB_VER", "1800." _STRINGIZE(__cplusplus_winrt)) // Detect vccorlib mismatch
+
+#pragma pop_macro("_STRINGIZE")
+#pragma pop_macro("_STRINGIZEX")
+#endif  // _MSC_VER
+
+#if !defined(__cplusplus_winrt)
+#error vccorlib.h can only be used with /ZW
+#endif
+
+#if defined(VCWINRT_DLL)
+#include <stdio.h>
+#include <Windows.h>
+#include <inspectable.h>
+#include <winstring.h>
+#endif
+
+// All WinRT types should have a packing (the default C++ packing).
+#ifdef  _WIN64
+#pragma pack(push, 16)
+#else
+#pragma pack(push, 8)
+#endif
+
+// <InternalComment>
+// READ THIS BEFORE MAKING CHANGES TO THIS FILE:
+//    This is a force-include file which is used by all /ZW compilations, and akin to a typesrc file.
+//    /ZW should be usable to build any existing body of C++ code (including Windows, SQL, Office etc.)
+//    As such, the following rules should be observed:
+//        * Do not include any header files that have any behavior that can be changed by the user (e.g. #ifdef)
+//        * Do not declare a method or typename that can conflict with an existing method or type that comes from a header
+//          if the header may modify that type based on user #defines.
+//    General rules:
+//        * Keep PDB sizes small. Don't overuse templates, and keep identifiers short.
+// </InternalComment>
+
+// <InternalComment>
+// Postconditions: ParsingInitTypes is set
+// </InternalComment>
+
+#if defined(__VCCORLIB_H_ENABLE_ALL_WARNINGS)
+#pragma warning(push)
+#endif
+
+// Following warnings disabled globally
+// To enable these warnings define __VCCORLIB_H_ENABLE_ALL_WARNINGS
+#pragma warning(disable: 4514) // unreferenced inline function has been removed
+#pragma warning(disable: 4710) // function not inlined
+#pragma warning(disable: 4711) // selected for automatic inline expansion
+
+// Following warnings disabled for this file
+#pragma warning( push )
+#pragma warning(disable: 4127) // conditional expression is constant
+#pragma warning(disable: 4483) // Allows us to use __identifier
+#pragma warning(disable: 4820) // bytes padding added after data member
+
+#define _VCCORLIB_THREADING_MODEL_DEFAULT  0
+#define _VCCORLIB_THREADING_MODEL_STA      1
+#define _VCCORLIB_THREADING_MODEL_MTA      2
+#define _VCCORLIB_THREADING_MODEL_OVERRIDE 3
+
+#pragma initialize_winrt_types_start
+
+struct HSTRING__;
+typedef HSTRING__* __abi_HSTRING;
+
+__declspec(noreturn) void __stdcall __abi_WinRTraiseException(long);
+
+#if !defined(VCWINRT_DLL)
+long __stdcall __abi_translateCurrentException(bool reserved);
+#else
+__declspec(dllexport) long __stdcall __abi_translateCurrentException(bool reserved);
+#endif
+
+inline void __abi_ThrowIfFailed(long __hrArg)
+{
+	if (__hrArg < 0)
+	{
+		__abi_WinRTraiseException(__hrArg);
+	}
+}
+
+#if !defined(VCWINRT_DLL)
+__declspec(dllimport) __declspec(noreturn) void __stdcall __abi_FailFast();
+#else
+__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_FailFast();
+#endif
+
+namespace __winRT
+{
+	long __stdcall __windowsCreateString(const __wchar_t*, int, __abi_HSTRING*);
+	long __stdcall __getActivationFactoryByPCWSTR(void*, ::Platform::Guid&, void**);
+	long __stdcall __getIids(int, unsigned long*, const __s_GUID*, ::Platform::Guid**);
+}
+
+namespace Windows
+{
+	namespace Foundation
+	{
+	}
+}
+
+struct __abi_WinClassInstrumentation
+{
+	__abi_WinClassInstrumentation* callback;
+
+	int numcalls_QueryInterface;
+	int numcalls_AddRef;
+	int numcalls_Release;
+	int numcalls_GetIids;
+	int numcalls_GetRuntimeClassName;
+	int numcalls_GetTrustLevel;
+	int numcalls_Other;
+	int destructed;
+	int refcount;
+
+	__abi_WinClassInstrumentation()
+	{
+		callback = nullptr;
+		numcalls_QueryInterface = 0;
+		numcalls_AddRef = 0;
+		numcalls_Release = 0;
+		numcalls_GetIids = 0;
+		numcalls_GetRuntimeClassName = 0;
+		numcalls_GetTrustLevel = 0;
+		numcalls_Other = 0;
+		destructed = 0;
+		refcount = 0;
+	}
+
+	void __abi_SetInstrumentationData(__abi_WinClassInstrumentation* __callbackArg)
+	{
+		callback = __callbackArg;
+		__abi_CopyToAttached();
+	}
+
+	void __abi_CopyToAttached()
+	{
+		if (callback)
+		{
+			callback->numcalls_QueryInterface     = numcalls_QueryInterface;
+			callback->numcalls_AddRef             = numcalls_AddRef;
+			callback->numcalls_Release            = numcalls_Release;
+			callback->numcalls_GetIids            = numcalls_GetIids;
+			callback->numcalls_GetRuntimeClassName= numcalls_GetRuntimeClassName;
+			callback->numcalls_GetTrustLevel      = numcalls_GetTrustLevel;
+			callback->numcalls_Other              = numcalls_Other;
+			callback->destructed                  = destructed;
+			callback->refcount                    = refcount;
+		}
+	}
+};
+
+//
+//// Don't want to define the real IUnknown from unknown.h here. That would means if the user has
+//// any broken code that uses it, compile errors will take the form of e.g.:
+////     predefined C++ WinRT types (compiler internal)(41) : see declaration of 'IUnknown::QueryInterface'
+//// This is not helpful. If they use IUnknown, we still need to point them to the actual unknown.h so
+//// that they can see the original definition.
+////
+//// For WinRT, we'll instead have a parallel COM interface hierarchy for basic interfaces starting with _.
+//// The type mismatch is not an issue. COM passes types through GUID / void* combos - the original type
+//// doesn't come into play unless the user static_casts an implementation type to one of these, but
+//// the WinRT implementation types are hidden.
+__interface __declspec(uuid("00000000-0000-0000-C000-000000000046")) __abi_IUnknown
+{
+public:
+	virtual long __stdcall __abi_QueryInterface(::Platform::Guid&, void**) = 0;
+	virtual unsigned long __stdcall __abi_AddRef() = 0;
+	virtual unsigned long __stdcall __abi_Release() = 0;
+};
+
+enum __abi_TrustLevel
+{
+	__abi_BaseTrust        = 0,
+	__abi_PartialTrust    = (__abi_BaseTrust    + 1) ,
+	__abi_FullTrust      = (__abi_PartialTrust + 1)
+};
+
+__interface __declspec(uuid("3C5C94E8-83BB-4622-B76A-B505AE96E0DF")) __abi_Module
+{
+public:
+	virtual unsigned long __stdcall __abi_IncrementObjectCount() = 0;
+	virtual unsigned long __stdcall __abi_DecrementObjectCount() = 0;
+};
+
+__interface __declspec(uuid("00000003-0000-0000-C000-000000000046")) __abi_IMarshal;
+
+extern __abi_Module* __abi_module;
+
+/* For compatibility with <winnt.h>, some intrinsics are __cdecl except on x64 */
+#if defined (_M_X64)
+extern "C" long _InterlockedIncrement(long volatile *);
+extern "C" long _InterlockedDecrement(long volatile *);
+extern "C" long _InterlockedCompareExchange(long volatile *, long, long);
+#else
+extern "C" long __cdecl _InterlockedIncrement(long volatile *);
+extern "C" long __cdecl _InterlockedDecrement(long volatile *);
+extern "C" long __cdecl _InterlockedCompareExchange(long volatile *, long, long);
+#endif
+
+extern "C" void* _InterlockedCompareExchangePointer(void* volatile *, void* , void*);
+
+#pragma intrinsic(_InterlockedIncrement)
+#pragma intrinsic(_InterlockedDecrement)
+#pragma intrinsic(_InterlockedCompareExchange)
+#pragma intrinsic(_InterlockedCompareExchangePointer)
+
+// A class that represents a volatile refcount, that gets initialized to 0.
+class __abi_MultiThreadedRefCount
+{
+	long __refcount;
+public:
+	__declspec(non_user_code) __abi_MultiThreadedRefCount() : __refcount(1)
+	{
+		if (__abi_module != nullptr)
+		{
+			__abi_module->__abi_IncrementObjectCount();
+		}
+	}
+
+	// called for a partially created ref class i.e. exception thrown from ctor
+	__declspec(non_user_code) void __abi_dtor()
+	{
+		if (__abi_module != nullptr)
+		{
+			__abi_module->__abi_DecrementObjectCount();
+		}
+	}
+
+	inline unsigned long Increment() volatile
+	{
+		return static_cast<unsigned long>(_InterlockedIncrement(&__refcount));
+	}
+
+	inline unsigned long Decrement() volatile
+	{
+		unsigned long __refCountLoc = static_cast<unsigned long>(_InterlockedDecrement(&__refcount));
+		if (__refCountLoc == 0)
+		{
+			// When destructing objects at the end of the program, we might be freeing
+			// objects across dlls, and the dll this object is in might have already freed its module object.
+			if (__abi_module != nullptr)
+			{
+				__abi_module->__abi_DecrementObjectCount();
+			}
+		}
+		return __refCountLoc;
+	}
+
+	inline unsigned long Get() volatile
+	{
+		return static_cast<unsigned long>(__refcount);
+	}
+	void ReleaseControlBlock() volatile
+	{
+	}
+};
+
+__interface __declspec(uuid("AF86E2E0-B12D-4c6a-9C5A-D7AA65101E90")) __abi_IInspectable : public __abi_IUnknown
+{
+	virtual long __stdcall __abi_GetIids(unsigned long*, ::Platform::Guid**) = 0;
+	virtual long __stdcall __abi_GetRuntimeClassName(__abi_HSTRING*) = 0;
+	virtual long __stdcall __abi_GetTrustLevel(__abi_TrustLevel*) = 0;
+};
+
+__interface __declspec(uuid("00000001-0000-0000-C000-000000000046")) __abi_IClassFactory : public __abi_IUnknown
+{
+	virtual long __stdcall __abi_CreateInstance(__abi_IUnknown*, ::Platform::Guid&, void**) = 0;
+	virtual long __stdcall __abi_LockServer(int) = 0;
+};
+
+__interface __declspec(uuid("00000035-0000-0000-C000-000000000046")) __abi_IActivationFactory : public __abi_IInspectable
+{
+	virtual long __stdcall __abi_ActivateInstance(__abi_IInspectable**) = 0;
+};
+
+__interface __declspec(uuid("00000037-0000-0000-C000-000000000046")) __abi_IWeakReference : public __abi_IUnknown
+{
+    virtual long __stdcall __abi_Resolve(::Platform::Guid&, __abi_IInspectable **) = 0;
+};
+
+#if !defined(VCWINRT_DLL)
+typedef struct __Platform_Details_HSTRING_HEADER
+{
+	int             __flags;             // Bit flags which used for storing extra information
+	unsigned int    __length;            // length of string's unicode code point
+	unsigned int    __padding;           // padding for future use
+	unsigned int    __morepadding;       // padding for future use
+	__wchar_t*      __stringRef;         // An address pointer which points to a string buffer.
+} __Platform_Details_HSTRING_HEADER;
+#else
+typedef HSTRING_HEADER __Platform_Details_HSTRING_HEADER;
+#endif
+
+namespace Platform { namespace Details {
+	struct EventLock
+	{
+		void* __targetsLock;
+		void* __addRemoveLock;
+	};
+
+	template<typename T>
+	EventLock* GetStaticEventLock()
+	{
+		static EventLock __eventLock = { nullptr, nullptr };
+		return &__eventLock;
+	}
+}} // namespace Platform::Details
+
+// <InternalComment>
+// Initialize a set of PCH global roots from some of the types defined above this point.
+// Preconditions: The following types must be defined before this point:
+//                     __abi_IUnknown
+//                     __abi_IInspectable
+//                     __abi_IClassFactory
+//                     __abi_IActivationFactory
+//                     HSTRING
+//                     __abi_TrustLevel
+//                     ::Platform::Guid
+//                     __abi_MultiThreadedRefCount
+// Postconditions: * The following PCH global roots are initialized
+//                     pWinRTIUnknown
+//                     pWinRTIInspectable
+//                     pWinRTIClassFactory
+//                     pWinRTIActivationFactory
+//                     pWinRTHSTRING
+//                     pWinRTTrustLevel
+//                     pWindowsFoundationGuid
+//                     pWinRTMultiThreadedRefCount
+//                  * Windows.Foundation.winmd is loaded
+//                  * From this point on WinRT types can be declared using 'ref class', 'interface class' etc. BUT must have __declspec(no_weak_ref)
+//                  * ParsingInitTypes is still set
+// </InternalComment>
+#pragma initialize_winrt_types_phase1
+
+namespace __abi_details
+{
+	// String^
+	__declspec(non_user_code) __declspec(no_refcount) void __abi_delete_String(::Platform::String^);
+
+#if !defined(VCWINRT_DLL)
+	__declspec(dllimport) __declspec(non_user_code) __declspec(no_refcount)
+		::Platform::Object ^ __stdcall __abi_cast_String_to_Object(::Platform::String^);
+
+	__declspec(dllimport) __declspec(non_user_code)
+		::Platform::String ^ __stdcall __abi_cast_Object_to_String(bool, ::Platform::Object^);
+
+	__declspec(dllimport) __declspec(non_user_code) ::Platform::String^ __stdcall __abi_ObjectToString(::Platform::Object^ o, bool useIPrintable);
+
+#else
+	__declspec(dllexport) __declspec(non_user_code) __declspec(no_refcount)
+		::Platform::Object ^ __stdcall __abi_cast_String_to_Object(::Platform::String^);
+
+	__declspec(dllexport) __declspec(non_user_code)
+		::Platform::String ^ __stdcall __abi_cast_Object_to_String(bool, ::Platform::Object^);
+
+	__declspec(dllexport) __declspec(non_user_code) ::Platform::String^ __stdcall __abi_ObjectToString(::Platform::Object^ o, bool useIPrintable);
+#endif
+} // namespace __abi_details
+
+__declspec(non_user_code) __declspec(no_refcount) __declspec(no_release_return)
+	inline void* __abi_winrt_ptr_ctor(const volatile ::Platform::Object^ const __objArg)
+{
+	__abi_IUnknown* __pUnknown = reinterpret_cast<__abi_IUnknown*>(const_cast< ::Platform::Object^>(__objArg));
+	if (__pUnknown) {
+		__pUnknown->__abi_AddRef();
+	}
+	return __pUnknown;
+}
+
+__declspec(non_user_code) __declspec(no_refcount)
+	inline void __abi_winrt_ptr_dtor(const volatile ::Platform::Object^ const __objArg)
+{
+	__abi_IUnknown* __pUnknown = reinterpret_cast<__abi_IUnknown*>(const_cast< ::Platform::Object^>(__objArg));
+	if (__pUnknown) {
+		__pUnknown->__abi_Release();
+	}
+}
+
+__declspec(non_user_code) __declspec(no_refcount) __declspec(no_release_return)
+	inline void* __abi_winrt_ptr_assign(void** __ppTargetArg, const volatile ::Platform::Object^ __objArg)
+{
+	__abi_IUnknown* __pUnknown = reinterpret_cast<__abi_IUnknown*>(const_cast< ::Platform::Object^>(__objArg));
+	__abi_IUnknown** __ppTargetUnknown = reinterpret_cast<__abi_IUnknown**>(__ppTargetArg);
+	if (__pUnknown != *__ppTargetUnknown)
+	{
+		if (__pUnknown) {
+			__pUnknown->__abi_AddRef();
+		}
+		if (*__ppTargetUnknown) {
+			(*__ppTargetUnknown)->__abi_Release();
+		}
+		*__ppTargetUnknown = __pUnknown;
+	}
+	return __pUnknown;
+}
+
+template<typename T>
+__declspec(non_user_code) __declspec(no_refcount) __declspec(no_release_return)
+	inline void* __abi_winrt_ptrto_delegate_ctor(const volatile T^ __objArg)
+{
+	return __abi_winrt_ptr_ctor(reinterpret_cast<const volatile ::Platform::Object^>(__objArg));
+}
+
+template<typename T>
+__declspec(non_user_code) __declspec(no_refcount) __declspec(no_release_return)
+	inline void __abi_winrt_ptrto_delegate_dtor(const volatile T^ __objArg)
+{
+	__abi_winrt_ptr_dtor(reinterpret_cast<const volatile ::Platform::Object^>(__objArg));
+}
+
+template<typename T>
+__declspec(non_user_code) __declspec(no_refcount) __declspec(no_release_return)
+	inline void* __abi_winrt_ptrto_delegate_assign(void** __ppTargetArg, const volatile T^ __objArg)
+{
+	return __abi_winrt_ptr_assign(__ppTargetArg, reinterpret_cast<const volatile ::Platform::Object^>(__objArg));
+}
+
+// Used for handle which is inside '__declspec(no_refcount)' function but still needs Release.
+struct __abi_dtor_helper {
+private:
+	__abi_IUnknown *__pUnknown;
+public:
+	__declspec(non_user_code) __abi_dtor_helper(const volatile ::Platform::Object^ __objArg) {
+		__pUnknown = reinterpret_cast<__abi_IUnknown*>(const_cast< ::Platform::Object^>(__objArg));
+	}
+	__declspec(non_user_code) ~__abi_dtor_helper() {
+		if (__pUnknown) {
+			__pUnknown->__abi_Release();
+		}
+	}
+};
+
+// The exceptions are split out explicitly in order to make them obvious from callstacks.
+#if !defined(VCWINRT_DLL)
+__declspec(dllimport) __declspec(noreturn) void __stdcall __abi_WinRTraiseNotImplementedException();
+__declspec(dllimport) __declspec(noreturn) void __stdcall __abi_WinRTraiseInvalidCastException();
+__declspec(dllimport) __declspec(noreturn) void __stdcall __abi_WinRTraiseNullReferenceException();
+__declspec(dllimport) __declspec(noreturn) void __stdcall __abi_WinRTraiseOperationCanceledException();
+__declspec(dllimport) __declspec(noreturn) void __stdcall __abi_WinRTraiseFailureException();
+__declspec(dllimport) __declspec(noreturn) void __stdcall __abi_WinRTraiseAccessDeniedException();
+__declspec(dllimport) __declspec(noreturn) void __stdcall __abi_WinRTraiseOutOfMemoryException();
+__declspec(dllimport) __declspec(noreturn) void __stdcall __abi_WinRTraiseInvalidArgumentException();
+__declspec(dllimport) __declspec(noreturn) void __stdcall __abi_WinRTraiseOutOfBoundsException();
+__declspec(dllimport) __declspec(noreturn) void __stdcall __abi_WinRTraiseChangedStateException();
+__declspec(dllimport) __declspec(noreturn) void __stdcall __abi_WinRTraiseClassNotRegisteredException();
+__declspec(dllimport) __declspec(noreturn) void __stdcall __abi_WinRTraiseWrongThreadException();
+__declspec(dllimport) __declspec(noreturn) void __stdcall __abi_WinRTraiseDisconnectedException();
+__declspec(dllimport) __declspec(noreturn) void __stdcall __abi_WinRTraiseObjectDisposedException();
+__declspec(dllimport) __declspec(noreturn) void __stdcall __abi_WinRTraiseCOMException(long);
+#else
+__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseNotImplementedException();
+__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseInvalidCastException();
+__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseNullReferenceException();
+__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseOperationCanceledException();
+__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseFailureException();
+__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseAccessDeniedException();
+__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseOutOfMemoryException();
+__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseInvalidArgumentException();
+__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseOutOfBoundsException();
+__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseChangedStateException();
+__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseClassNotRegisteredException();
+__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseWrongThreadException();
+__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseDisconnectedException();
+__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseObjectDisposedException();
+__declspec(dllexport) __declspec(noreturn) void __stdcall __abi_WinRTraiseCOMException(long);
+#endif
+
+__declspec(non_user_code) __declspec(no_refcount)
+	inline ::Platform::Object^ __abi_winrt_cast_to(bool __isDynamicCastArg, ::Platform::Object^ __objArg, const _GUID& __guidArg)
+{
+	void* __pTo = nullptr;
+	__abi_IUnknown* __pUnknown = reinterpret_cast<__abi_IUnknown*>(__objArg);
+
+	if (__pUnknown) {
+		// Cast to ::Platform::Guid instead of using conversion in order to avoid copy to temporary
+		long __hr = __pUnknown->__abi_QueryInterface(reinterpret_cast< ::Platform::Guid&>(const_cast<_GUID&>(__guidArg)), &__pTo);
+
+		if (__isDynamicCastArg && __hr != 0)
+			return nullptr;
+		// It will throw InvalidCastException on failure
+		__abi_ThrowIfFailed(__hr);
+	}
+
+	return reinterpret_cast< ::Platform::Object^>(__pTo);
+}
+
+__declspec(non_user_code) __declspec(no_refcount)
+	inline ::Platform::String^ __abi_winrt_cast_to_string(bool __isDynamicCast, ::Platform::Object^ __objArg)
+{
+	return __abi_details::__abi_cast_Object_to_String(__isDynamicCast, __objArg);
+}
+
+__declspec(non_user_code) __declspec(no_refcount)
+	inline ::Platform::Object^ __abi_winrt_cast_from_string_to_object(bool /*__isDynamicCastArg*/, ::Platform::String^ __objArg)
+{
+	return __abi_details::__abi_cast_String_to_Object(__objArg);
+}
+
+__declspec(non_user_code) __declspec(no_refcount)
+	inline ::Platform::Object^ __abi_winrt_cast_from_string_to_other(bool /*__isDynamicCastArg*/, ::Platform::String^ /*__objArg*/)
+{
+	__abi_WinRTraiseInvalidCastException();
+}
+
+template<typename T>
+__declspec(non_user_code) __declspec(no_refcount)
+	inline T^ __abi_winrt_cast_from_object_to_delegate(bool __isDynamicCast, ::Platform::Object^ __objArg);
+
+template<typename T>
+__declspec(non_user_code) __declspec(no_refcount)
+	inline ::Platform::Object^ __abi_winrt_cast_from_delegate_to_object(bool __isDynamicCastArg, T^ __objArg);
+
+template<typename T>
+__declspec(non_user_code) __declspec(no_refcount)
+	inline ::Platform::Object^ __abi_winrt_cast_from_delegate_to_other(bool __isDynamicCastArg, T^ __objArg, const _GUID& __guidArg)
+{
+	return __abi_winrt_cast_to(__isDynamicCastArg, reinterpret_cast< ::Platform::Object^>(__objArg), __guidArg);
+}
+
+inline void* __detach_as_voidptr(void** __ppObjArg)
+{
+	void* __pObj = *__ppObjArg;
+	*__ppObjArg = nullptr;
+	return __pObj;
+}
+
+__declspec(non_user_code) __declspec(no_refcount)
+	inline void __abi_winrt_ptrto_string_dtor(const volatile ::Platform::String^ const __objArg)
+{
+	__abi_details::__abi_delete_String(const_cast< ::Platform::String^>(__objArg));
+}
+
+__declspec(non_user_code) inline void __abi_winrt_throw_on_disposed(bool isDisposed)
+{
+	if (isDisposed)
+	{
+		__abi_WinRTraiseObjectDisposedException();
+	}
+}
+
+
+// Function declaration for types we use from Windows and CRT
+// This prevents pulling in the headers
+#if !defined(VCWINRT_DLL)
+extern "C" long __stdcall __Platform_CoCreateFreeThreadedMarshaler(::Platform::Object^, ::Platform::Object^*);
+#endif
+
+namespace Platform {
+	template <typename __TArg, unsigned int __dimension = 1>
+	ref class WriteOnlyArray;
+
+	template <typename __TArg, unsigned int __dimension = 1>
+	ref class Array;
+}
+
+template <typename __TArg, unsigned int __dimension>
+__declspec(non_user_code) __declspec(no_refcount) __declspec(no_release_return)
+	void* __abi_winrt_ptrto_array_ctor(const volatile ::Platform::Array<__TArg, __dimension>^ const);
+
+template<typename __TArg, unsigned int __dimension>
+__declspec(non_user_code) __declspec(no_refcount) __declspec(no_release_return)
+	void* __abi_winrt_ptrto_array_assign(void**, const volatile ::Platform::Array<__TArg, __dimension>^);
+
+__declspec(non_user_code) __declspec(no_refcount)
+	inline ::Platform::Object^ __abi_winrt_cast_use_helper(bool __isDynamicArg, void* __fromArg, const _GUID& __guidArg, __abi_IUnknown* __useresultArg)
+{
+	if (__useresultArg)
+	{
+		return reinterpret_cast< ::Platform::Object^>(__useresultArg);
+	}
+
+	return __abi_winrt_cast_to(__isDynamicArg, reinterpret_cast< ::Platform::Object^>(__fromArg), __guidArg);
+}
+
+__declspec(selectany) void * __forceInstantiate1 = &__abi_winrt_cast_use_helper;
+
+__declspec(non_user_code) __declspec(no_refcount)
+	inline void __abi_winrt_ptr_dispose(const volatile ::Platform::Object^ const __objArg)
+{
+	::Platform::IDisposable ^__dispose = dynamic_cast< ::Platform::IDisposable ^>(const_cast< ::Platform::Object^>(__objArg));
+	if (__dispose) {
+		__dispose->__identifier("<Dispose>")();
+		reinterpret_cast<__abi_IUnknown*>(__dispose)->__abi_Release();
+	}
+}
+
+__declspec(non_user_code) __declspec(no_refcount)
+	inline void __abi_winrt_ptr_dispose_dtor(const volatile ::Platform::Object^ const __objArg)
+{
+	__abi_winrt_ptr_dispose(__objArg);
+	__abi_winrt_ptr_dtor(__objArg);
+}
+
+class __abi_FTMWeakRefData;
+
+namespace Platform { namespace Details
+{
+	class ControlBlock sealed : public __abi_IWeakReference
+	{
+#if defined(VCWINRT_DLL)
+	public:
+#else
+	private:
+#endif
+		volatile long __weakRefCount;
+		volatile long __strongRefCount;
+		__abi_IUnknown* __target; // we shouldn't hold a strong reference to target, so grab an unaddref'd reference here.
+		bool __bSingleAllocation;
+		bool __bAlignedAllocation;
+		bool __bExceptionAllocation;
+
+	public:
+		// IWeakReference
+		virtual long __stdcall __abi_QueryInterface(::Platform::Guid& __riid, void** __ppvObject);
+
+		virtual unsigned long __stdcall __abi_AddRef()
+		{
+			return static_cast<unsigned long>(_InterlockedIncrement(&__weakRefCount));
+		}
+
+		virtual unsigned long __stdcall __abi_Release()
+		{
+			unsigned long __ref = static_cast<unsigned long>(_InterlockedDecrement(&__weakRefCount));
+			if (__ref == 0)
+			{
+				if (__bAlignedAllocation)
+				{
+					::Platform::Details::Heap::AlignedFree(this);
+				}
+				else
+				{
+					::Platform::Details::Heap::Free(this);
+				}
+			}
+			return __ref;
+		}
+
+#if !defined(VCWINRT_DLL)
+		__declspec(dllimport) virtual long __stdcall __abi_Resolve(::Platform::Guid& __riid, __abi_IInspectable ** __objectReference);
+#else
+		__declspec(dllexport) virtual long __stdcall __abi_Resolve(::Platform::Guid& __riid, __abi_IInspectable ** __objectReference);
+#endif
+
+	private:
+		unsigned long __stdcall IncrementStrongReference()
+		{
+			// InterlockedIncrement calls _InterlockedIncrement intrinsic thus we call directly _InterlockedIncrement to save the call
+			return static_cast<unsigned long>(_InterlockedIncrement(&__strongRefCount));
+		}
+
+		unsigned long __stdcall DecrementStrongReference()
+		{
+			// InterlockedDecrement calls _InterlockedDecrement intrinsic thus we call directly _InterlockedDecrement to save the call
+			unsigned long __ref = static_cast<unsigned long>(_InterlockedDecrement(&__strongRefCount));
+			if (__ref == 0)
+			{
+				__strongRefCount = static_cast<int>(0xC0000000); // LONG_MIN / 2
+			}
+			return __ref;
+		}
+
+		inline long __stdcall GetRefcount()
+		{
+			return __strongRefCount;
+		}
+
+		ControlBlock(){}
+
+#if !defined(VCWINRT_DLL)
+		__declspec(dllimport) void InitControlBlock(void* __object, bool __bSingleAllocationParam = true, bool __bAlignedAllocationParam = false, bool __bExceptionAllocationParam = false);
+		__declspec(dllimport) void ReleaseTarget();
+#else
+		__declspec(dllexport) void InitControlBlock(void* __object, bool __bSingleAllocationParam = true, bool __bAlignedAllocationParam = false, bool __bExceptionAllocationParam = false);
+		__declspec(dllexport) void ReleaseTarget();
+#endif
+
+		friend class __abi_FTMWeakRefData;
+		friend void* Details::Heap::Allocate(::Platform::SizeT, ::Platform::SizeT);
+		friend void* Details::Heap::AlignedAllocate(::Platform::SizeT, ::Platform::SizeT, ::Platform::SizeT);
+		friend void* Details::Heap::AllocateException(::Platform::SizeT __rcOffset, ::Platform::SizeT __sizeArg);
+		friend void* Details::Heap::AlignedAllocateException(::Platform::SizeT __rcOffset, ::Platform::SizeT __sizeArg, ::Platform::SizeT __alignment);
+	};
+}} // ::Platform::Details
+
+// A class that represents a volatile refcount, that gets initialized to 0.
+class __abi_FTMWeakRefData
+{
+#if defined(VCWINRT_DLL)
+public:
+#endif
+	::Platform::Details::ControlBlock* __weakRefSource;
+	__abi_IUnknown* volatile __pUnkMarshal;
+
+public:
+	__declspec(non_user_code) __abi_FTMWeakRefData(::Platform::Object^ __targetArg)
+	{
+		__pUnkMarshal = reinterpret_cast<__abi_IUnknown*>(-1);
+
+		if (__abi_module != nullptr)
+		{
+			__abi_module->__abi_IncrementObjectCount();
+		}
+	}
+
+	__declspec(non_user_code) __abi_FTMWeakRefData(::Platform::Object^ __targetArg, ::Platform::CallbackContext __contextArg)
+	{
+		if (__contextArg == ::Platform::CallbackContext::Any)
+		{
+			__pUnkMarshal = reinterpret_cast<__abi_IUnknown*>(-1);
+		}
+		else
+		{
+			__pUnkMarshal = nullptr;
+		}
+
+		if (__abi_module != nullptr)
+		{
+			__abi_module->__abi_IncrementObjectCount();
+		}
+	}
+
+	// called for a partially created ref class i.e. exception thrown from ctor
+	__declspec(non_user_code) void __abi_dtor()
+	{
+		if (__pUnkMarshal && __pUnkMarshal != reinterpret_cast<__abi_IUnknown*>(-1))
+		{
+			__pUnkMarshal->__abi_Release();
+			__pUnkMarshal = nullptr;
+		}
+
+		if (__abi_module != nullptr)
+		{
+			__abi_module->__abi_DecrementObjectCount();
+		}
+
+		__weakRefSource->DecrementStrongReference();
+		ReleaseControlBlock();
+	}
+
+	inline unsigned long __stdcall Increment() volatile
+	{
+		if (__weakRefSource == nullptr || __weakRefSource->GetRefcount() < 0)
+		{
+			return static_cast<unsigned long>(-1); // Called during destruction
+		}
+
+		return __weakRefSource->IncrementStrongReference();
+	}
+
+	inline unsigned long __stdcall Decrement() volatile
+	{
+		if (__weakRefSource == nullptr || __weakRefSource->GetRefcount() < 0)
+		{
+			return static_cast<unsigned long>(-1); // Called during destruction
+		}
+
+		unsigned long __refCount = __weakRefSource->DecrementStrongReference();
+		if (__refCount == 0)
+		{
+			if (__pUnkMarshal && __pUnkMarshal != reinterpret_cast<__abi_IUnknown*>(-1))
+			{
+				__pUnkMarshal->__abi_Release();
+				__pUnkMarshal = nullptr;
+			}
+
+			// When destructing objects at the end of the program, we might be freeing
+			// objects across dlls, and the dll this object is in might have already freed its module object.
+			if (__abi_module != nullptr)
+			{
+				__abi_module->__abi_DecrementObjectCount();
+			}
+		}
+
+		return __refCount;
+	}
+
+	inline __abi_FTMWeakRefData* GetFreeThreadedMarshaler()
+	{
+		if (__pUnkMarshal == nullptr)
+		{
+			return nullptr;
+		}
+		return this;
+	}
+
+	inline ::Platform::Details::IWeakReference^ GetWeakReference()
+	{
+		return reinterpret_cast< ::Platform::Details::IWeakReference^>(__weakRefSource);
+	}
+
+	inline long __stdcall Get() volatile
+	{
+		if (__weakRefSource == nullptr)
+		{
+			return static_cast<unsigned long>(-1); // Called during destruction
+		}
+		return __weakRefSource->GetRefcount();
+	}
+
+	long __stdcall __abi_QueryInterface(::Platform::Guid& __guid, void** __pOut);
+
+	void ReleaseControlBlock()
+	{
+		auto __localWeakRefSource = __weakRefSource;
+		__localWeakRefSource->ReleaseTarget();
+		__localWeakRefSource->__abi_Release();
+	}
+};
+
+namespace Platform { namespace Details
+{
+	struct __single_inheritance __abi_CaptureBase
+	{
+	protected:
+		virtual __stdcall ~__abi_CaptureBase()  {}
+
+	public:
+		static const size_t __smallCaptureSize = 4 * sizeof(void*);
+		void* operator new(size_t __sizeArg, void* __pSmallCaptureArg)
+		{
+			if (__sizeArg > __smallCaptureSize)
+			{
+				return reinterpret_cast<__abi_CaptureBase*>( ::Platform::Details::Heap::Allocate( __sizeArg ) );
+			}
+
+			return __pSmallCaptureArg;
+		}
+
+		void operator delete(void* __ptrArg, void* __pSmallCaptureArg)
+		{
+			__abi_CaptureBase* __pThis = static_cast<__abi_CaptureBase*>(__ptrArg);
+			__pThis->Delete(__pThis, __pSmallCaptureArg);
+		}
+
+		inline void* GetVFunction(int __slotArg)
+		{
+			return (*reinterpret_cast<void***>(this))[__slotArg];
+		}
+
+		void Delete(__abi_CaptureBase* __pThisArg, void* __pSmallCaptureArg)
+		{
+			__pThisArg->~__abi_CaptureBase();
+			if (__pThisArg != __pSmallCaptureArg)
+			{
+				::Platform::Details::Heap::Free(__pThisArg);
+			}
+		}
+	};
+
+	struct __abi_CapturePtr
+	{
+		char* smallCapture[__abi_CaptureBase::__smallCaptureSize];
+		__abi_CaptureBase* ptr;
+		__abi_CapturePtr() : ptr( reinterpret_cast<__abi_CaptureBase*>(smallCapture) )  {}
+		~__abi_CapturePtr()
+		{
+			ptr->Delete(ptr, smallCapture);
+		}
+	};
+
+	template <typename __TFunctor, typename __TReturnType, typename... __TArgs>
+	struct __abi_FunctorCapture : public ::Platform::Details::__abi_CaptureBase
+	{
+		__TFunctor functor;
+		__abi_FunctorCapture(__TFunctor __functor) : functor(__functor) {}
+		virtual __TReturnType __stdcall Invoke(__TArgs... __args) {return functor(__args...);}
+	};
+}} // namespace Platform::Details
+
+// <InternalComment>
+// Initialize a set of PCH global roots from some of the types defined above this point.
+// Preconditions: See initialize_winrt_types_phase1 preconditions:
+//                     __abi_FTMWeakRefData is now defined
+// Postconditions:  * From this point on WinRT types can be declared using 'ref class', 'interface class' etc.
+//                  * ParsingInitTypes is still set
+// </InternalComment>
+
+#pragma initialize_winrt_types_phase2
+
+namespace Platform
+{
+	template <typename __TArg, unsigned int __dimension = 1>
+	class ArrayReference;
+
+	namespace Details
+	{
+		template <typename __HighLevelType, unsigned int __dimension>
+		::Platform::Array<__HighLevelType, __dimension>^ __abi_array_attach(void* __src, unsigned int __size, bool __isFastPass, bool __needsInit);
+
+		template <typename __HighLevelType, unsigned int __dimension>
+		void __abi_array_copy_to_and_release(::Platform::Array<__HighLevelType, __dimension>^ __arr, void** __dest, unsigned int* __size);
+
+		template <typename __LowLevelType, typename __HighLevelType, unsigned int __dimension>
+		__LowLevelType* __abi_array_to_raw(const ::Platform::Array<__HighLevelType, __dimension>^);
+
+		template <typename __TArg, bool = __is_enum(__TArg)>
+		struct array_helper;
+	} // namespace Details
+
+#pragma warning(push)
+#pragma warning(disable: 4487)
+	// Partial specialization of one-dimensional Array
+	template <typename __TArg>
+	private ref class WriteOnlyArray<__TArg, 1>
+	{
+	protected private:
+		unsigned int   __size;         // number of elements
+		bool           __fastpassflag; // true if "fast pass", else false
+		__TArg*        __data;        // actual data buffer, alloc'd if not "fast-pass"
+
+	internal:
+		__TArg& set(unsigned int __indexArg, __TArg __valueArg);
+		property unsigned int Length {unsigned int get() const; }
+		property __TArg* Data { __TArg* get() const; }
+		property bool FastPass { bool get() const; }
+
+		__TArg* begin() const;
+		__TArg* end() const;
+
+	protected private:
+		WriteOnlyArray();
+		WriteOnlyArray(unsigned int __sizeArg);
+		WriteOnlyArray(__TArg* __dataArg, unsigned int __sizeArg);
+		void Clear();
+
+		__TArg& get(unsigned int __indexArg) const;
+
+		static __TArg* AllocateAndZeroInitialize(unsigned int __countArg);
+		static __TArg* AllocateAndCopyElements(const __TArg* __srcArg, unsigned int __countArg);
+
+#if defined(_PREFIX_) || defined(_PREFAST_)
+	internal:
+		__TArg& operator[](unsigned int __indexArg) const;
+#endif // defined(_PREFIX_) || defined(_PREFAST_)
+	public:
+		virtual ~WriteOnlyArray();
+	};
+
+	template <typename __TArg>
+	private ref class Array<__TArg,1> sealed :
+		public WriteOnlyArray<__TArg, 1>,
+			public [::Windows::Foundation::Metadata::Default] [::Platform::Metadata::RuntimeClassName] ::Platform::IBoxArray<__TArg>
+		{
+		public:
+			virtual property Array^ Value { virtual Array^ get(); }
+
+        internal:
+            Array(const Array<__TArg, 1>^ __source);
+            Array(unsigned int __sizeArg);
+			Array(__TArg* __dataArg, unsigned int __sizeArg);
+			__TArg& get(unsigned int __indexArg) const;
+#if defined(_PREFIX_) || defined(_PREFAST_)
+			__TArg& operator[](unsigned int __indexArg) const;
+#endif // defined(_PREFIX_) || defined(_PREFAST_)
+
+		private:
+			Array();
+			void Attach(__TArg* __srcArg, unsigned int __sizeArg);
+			void AttachFastPass(__TArg* __srcArg, unsigned int __sizeArg);
+			void CopyToOrDetach(__TArg** __destArg, unsigned int* __sizeArg);
+
+			template <typename __HighLevelType, unsigned int __dimension>
+			friend ::Platform::Array<__HighLevelType, __dimension>^ ::Platform::Details::__abi_array_attach(void* __src, unsigned int __size, bool __isFastPass, bool __needsInit);
+
+			template <typename __HighLevelType, unsigned int __dimension>
+			friend void ::Platform::Details::__abi_array_copy_to_and_release(::Platform::Array<__HighLevelType, __dimension>^ __arrArg, void** __destArg, unsigned int* __sizeArg);
+			template <typename __TArg, unsigned int __dimension> friend class ArrayReference;
+
+			void ArrayReferenceInit()
+			{
+				__vtable_initialize(Array<__TArg, 1>);
+			}
+		public:
+			virtual ~Array() {}
+		};
+
+#pragma warning(pop)
+} // namespace Platform
+
+template <typename __TArg, unsigned int __dimension>
+__declspec(non_user_code) __declspec(no_refcount) __declspec(no_release_return)
+	inline void* __abi_winrt_ptrto_array_ctor(const volatile ::Platform::Array<__TArg, __dimension>^ const __arrArg)
+{
+	__abi_IUnknown* __pUnknown = reinterpret_cast<__abi_IUnknown*>(const_cast< ::Platform::Array<__TArg, __dimension>^>(__arrArg));
+	if (__pUnknown)
+	{
+		auto __localArray = const_cast< ::Platform::Array<__TArg, __dimension>^>(const_cast< ::Platform::Array<__TArg, __dimension>^>(__arrArg));
+		if (__localArray->FastPass)
+		{
+			auto __ret = ref new ::Platform::Array<__TArg, __dimension>(__localArray->Data, __localArray->Length);
+			__pUnknown = reinterpret_cast<__abi_IUnknown*>(const_cast< ::Platform::Array<__TArg, __dimension>^>(__ret));
+		}
+		else
+		{
+			__pUnknown->__abi_AddRef();
+		}
+	}
+	return __pUnknown;
+}
+
+template<typename __TArg, unsigned int __dimension>
+__declspec(non_user_code) __declspec(no_refcount) __declspec(no_release_return)
+	void* __abi_winrt_ptrto_array_assign(void** __ppTarget, const volatile ::Platform::Array<__TArg, __dimension> ^__arrArg)
+{
+	__abi_IUnknown* __pUnknown = reinterpret_cast<__abi_IUnknown*>(const_cast< ::Platform::Array<__TArg, __dimension>^>(__arrArg));
+	__abi_IUnknown** __ppTargetUnknown = reinterpret_cast<__abi_IUnknown**>(__ppTarget);
+	if (__pUnknown != *__ppTargetUnknown)
+	{
+		if (__pUnknown)
+		{
+			auto __localArray = const_cast< ::Platform::Array<__TArg, __dimension>^>(__arrArg);
+			if (__localArray->FastPass)
+			{
+				auto __ret = ref new ::Platform::Array<__TArg>(__localArray->Data, __localArray->Length);
+				__pUnknown = reinterpret_cast<__abi_IUnknown*>(const_cast< ::Platform::Array<__TArg, __dimension>^>(__ret));
+			}
+			else
+			{
+				__pUnknown->__abi_AddRef();
+			}
+		}
+		if (*__ppTargetUnknown)
+		{
+			(*__ppTargetUnknown)->__abi_Release();
+		}
+		*__ppTargetUnknown = __pUnknown;
+	}
+	return __pUnknown;
+}
+
+template <typename __TArg>
+inline __TArg __winrt_Empty_Struct()
+{
+	unsigned char __bytes[sizeof(__TArg)];
+	__Platform_memset(__bytes, 0, sizeof(__TArg));
+
+	return (__TArg&)__bytes;
+}
+
+struct __abi___FactoryCache
+{
+	__abi_IUnknown* __factory;
+	void* __cookie;
+};
+
+__declspec(selectany) __abi___FactoryCache __abi_no_factory_cache = { nullptr, 0 };
+
+struct __abi___classObjectEntry
+{
+	// Factory creator function
+	long (__stdcall *__factoryCreator)(unsigned int*, __abi___classObjectEntry*, ::Platform::Guid&, __abi_IUnknown**);
+	// Object id
+	const __wchar_t* (__stdcall *__getRuntimeName)();
+	// Trust level for WinRT otherwise nullptr
+	int (__stdcall *__getTrustLevel)();
+	// Factory cache, group id data members
+	__abi___FactoryCache* __factoryCache;
+	const __wchar_t* __serverName;
+};
+
+// Section r is used to put WinRT objects to creator map
+#pragma section("minATL$__r", read)
+
+__declspec(noreturn) inline void __stdcall __abi_WinRTraiseException(long __hrArg)
+{
+	switch (__hrArg)
+	{
+	case 0x80004001L: // E_NOTIMPL
+		__abi_WinRTraiseNotImplementedException();
+
+	case 0x80004002L: // E_NOINTERFACE
+		__abi_WinRTraiseInvalidCastException();
+
+	case 0x80004003L: // E_POINTER
+		__abi_WinRTraiseNullReferenceException();
+
+	case 0x80004004L: // E_ABORT
+		__abi_WinRTraiseOperationCanceledException();
+
+	case 0x80004005L: // E_FAIL
+		__abi_WinRTraiseFailureException();
+
+	case 0x80070005L: // E_ACCESSDENIED
+		__abi_WinRTraiseAccessDeniedException();
+
+	case 0x8007000EL: // E_OUTOFMEMORY
+		__abi_WinRTraiseOutOfMemoryException();
+
+	case 0x80070057L: // E_INVALIDARG
+		__abi_WinRTraiseInvalidArgumentException();
+
+	case 0x8000000BL: // E_BOUNDS
+		__abi_WinRTraiseOutOfBoundsException();
+
+	case 0x8000000CL: // E_CHANGED_STATE
+		__abi_WinRTraiseChangedStateException();
+
+	case 0x80040154L: // REGDB_E_CLASSNOTREG
+		__abi_WinRTraiseClassNotRegisteredException();
+
+	case 0x8001010EL: // RPC_E_WRONG_THREAD
+		__abi_WinRTraiseWrongThreadException();
+
+	case 0x80010108L: // RPC_E_DISCONNECTED
+		__abi_WinRTraiseDisconnectedException();
+
+	case 0x80000013L: // RO_E_CLOSED
+		__abi_WinRTraiseObjectDisposedException();
+
+	default:
+		__abi_WinRTraiseCOMException(__hrArg);
+		break;
+	}
+}
+
+__declspec(non_user_code)
+	::Platform::String^ __abi_winrt_CreateSystemStringFromLiteral(const __wchar_t*);
+__declspec(non_user_code)
+	::Platform::String^ __abi_winrt_CreateSystemStringFromLiteral(const unsigned short*);
+
+#if defined(VCWINRT_DLL)
+#define __Platform_CoCreateFreeThreadedMarshaler(__punkOuter, __ppunkMarshal) CoCreateFreeThreadedMarshaler(reinterpret_cast<IUnknown*>(__punkOuter), reinterpret_cast<IUnknown**>(__ppunkMarshal))
+#endif
+
+#if defined(VCWINRT_DLL)
+#define __Platform_CoCreateFreeThreadedMarshaler(__punkOuter, __ppunkMarshal) CoCreateFreeThreadedMarshaler(reinterpret_cast<IUnknown*>(__punkOuter), reinterpret_cast<IUnknown**>(__ppunkMarshal))
+#endif
+
+// Postconditions: * ParsingInitTypes is cleared
+#pragma initialize_winrt_types_phase3
+
+#pragma region Define Common EnumResourceTypes
+// Define common types if not building vccorlib.dll
+#if !defined(VCWINRT_DLL)
+
+// Function decleration for types we use from Windows and CRT
+// This prevents pulling in the headers
+extern "C"
+{
+	long __stdcall __Platform_WindowsCreateString(const ::default::char16*, unsigned int, __abi_HSTRING*);
+	long __stdcall __Platform_WindowsDeleteString(__abi_HSTRING);
+	long __stdcall __Platform_WindowsDuplicateString(__abi_HSTRING, __abi_HSTRING*);
+	const ::default::char16* __stdcall __Platform_WindowsGetStringRawBuffer(__abi_HSTRING, unsigned int*);
+	unsigned int __stdcall __Platform_WindowsGetStringLen(__abi_HSTRING);
+	int __stdcall __Platform_WindowsIsStringEmpty(__abi_HSTRING);
+	long __stdcall __Platform_WindowsStringHasEmbeddedNull(__abi_HSTRING, int*);
+	long __stdcall __Platform_WindowsCompareStringOrdinal(__abi_HSTRING, __abi_HSTRING, int*);
+	long __stdcall __Platform_WindowsCreateStringReference(const ::default::char16*, unsigned int, __Platform_Details_HSTRING_HEADER*, __abi_HSTRING*);
+	long __stdcall __Platform_WindowsConcatString(__abi_HSTRING, __abi_HSTRING, __abi_HSTRING*);
+	void* __stdcall __Platform_CoTaskMemAlloc(size_t);
+	void __stdcall __Platform_CoTaskMemFree(void*);
+	size_t __cdecl __Platform_wcslen(const ::default::char16 *);
+	void * __cdecl __Platform_memset(void *, int, size_t);
+	void __stdcall __Platform_AcquireSRWLockShared(void*);
+	void __stdcall __Platform_ReleaseSRWLockShared(void*);
+}
+#else // VCWINRT_DLL
+#define __Platform_WindowsCreateString              WindowsCreateString
+#define __Platform_WindowsDeleteString              WindowsDeleteString
+#define __Platform_WindowsDuplicateString           WindowsDuplicateString
+#define __Platform_WindowsGetStringRawBuffer        WindowsGetStringRawBuffer
+#define __Platform_WindowsGetStringLen              WindowsGetStringLen
+#define __Platform_WindowsIsStringEmpty             WindowsIsStringEmpty
+#define __Platform_WindowsStringHasEmbeddedNull     WindowsStringHasEmbeddedNull
+#define __Platform_WindowsCompareStringOrdinal      WindowsCompareStringOrdinal
+#define __Platform_WindowsCreateStringReference     WindowsCreateStringReference
+#define __Platform_WindowsConcatString              WindowsConcatString
+#define __Platform_CoTaskMemAlloc                   CoTaskMemAlloc
+#define __Platform_CoTaskMemFree                    CoTaskMemFree
+#define __Platform_AcquireSRWLockShared             AcquireSRWLockShared;
+#define __Platform_ReleaseSRWLockShared             ReleaseSRWLockShared;
+
+#define __Platform_wcslen                           wcslen
+#define __Platform_memset                           memset
+
+#endif // VCWINRT_DLL
+
+#pragma endregion
+
+#pragma region String^ helpers
+namespace Platform
+{
+	// Convert failure HRESULT from Windows String API's to Exception
+	namespace Details
+	{
+		inline void CreateString(const ::default::char16* __bufferArg, unsigned int __lengthArg, __abi_HSTRING* __destArg)
+		{
+			__abi_ThrowIfFailed( __Platform_WindowsCreateString((const ::default::char16 *)__bufferArg, __lengthArg, __destArg) );
+		}
+
+		inline void CreateString(const ::default::char16* __sourceStringArg, __abi_HSTRING* __destArg)
+		{
+			__abi_ThrowIfFailed( __Platform_WindowsCreateString((const ::default::char16 *)__sourceStringArg, __sourceStringArg ? static_cast<unsigned int>(__Platform_wcslen((const ::default::char16 *)__sourceStringArg)) : 0u, __destArg) );
+		}
+
+		inline void DuplicateString(__abi_HSTRING __sourceArg, __abi_HSTRING* __destArg)
+		{
+			if (__sourceArg == nullptr)
+			{
+				*__destArg = __sourceArg;
+				return;
+			}
+
+			__abi_ThrowIfFailed( __Platform_WindowsDuplicateString(__sourceArg, __destArg) );
+		}
+
+		inline void CreateStringReference(const ::default::char16* __sourceStringArg, unsigned int __lengthArg, __Platform_Details_HSTRING_HEADER* __hstringHeaderArg, __abi_HSTRING* __stringArg)
+		{
+			__abi_ThrowIfFailed(__Platform_WindowsCreateStringReference(__sourceStringArg, __lengthArg, __hstringHeaderArg, __stringArg));
+		}
+	} // namepsace Details
+
+	// StringReference is used to hold onto a fast pass HSTRING.
+	class StringReference
+	{
+	public:
+		~StringReference()
+		{
+			Free();
+		}
+		StringReference()
+		{
+			Init();
+		}
+		StringReference(const StringReference& __fstrArg)
+		{
+			Init(__fstrArg);
+		}
+		StringReference& operator=(const StringReference& __fstrArg)
+		{
+			if(this != &__fstrArg)
+			{
+				Free();
+				Init(__fstrArg);
+			}
+			return *this;
+		}
+
+		StringReference(const ::default::char16* __strArg)
+		{
+			Init(__strArg, __Platform_wcslen(__strArg));
+		}
+		StringReference& operator=(const ::default::char16* __strArg)
+		{
+			Free();
+			Init(__strArg, __Platform_wcslen(__strArg));
+			return *this;
+		}
+		StringReference(const ::default::char16* __strArg, size_t __lenArg)
+		{
+			Init(__strArg, __lenArg);
+		}
+
+		const ::default::char16 * Data() const
+		{
+			return __Platform_WindowsGetStringRawBuffer(GetHSTRING(), nullptr);
+		}
+		unsigned int Length() const
+		{
+			return __Platform_WindowsGetStringLen(GetHSTRING());
+		}
+
+		__declspec(no_release_return) __declspec(no_refcount)
+			operator ::Platform::String^() const
+		{
+			return reinterpret_cast< ::Platform::String^>(__hString);
+		}
+		__declspec(no_release_return) __declspec(no_refcount)
+			::Platform::String^ GetString() const
+		{
+			return reinterpret_cast< ::Platform::String^>(__hString);
+		}
+		__abi_HSTRING GetHSTRING() const
+		{
+			return __hString;
+		}
+	private:
+		void Free()
+		{
+			__Platform_WindowsDeleteString(__hString);
+		}
+		void Init()
+		{
+			__Platform_memset(this, 0, sizeof(StringReference));
+		}
+		void Init(const StringReference& __fstrArg)
+		{
+			unsigned int __length = 0;
+			const ::default::char16* __source = __Platform_WindowsGetStringRawBuffer(__fstrArg.GetHSTRING(), &__length);
+			Init(__source, __length);
+		}
+		void Init(const ::default::char16* __strArg, unsigned __int64 __lenArg)
+		{
+			if ((__strArg == nullptr) || (__lenArg == 0))
+				Init();
+			else if (__lenArg > 0xffffffffLL) // check if it exceeds the size of an integer
+				__abi_WinRTraiseInvalidArgumentException();
+			else
+			{
+				unsigned int __length = (unsigned int) (__lenArg & 0xffffffffLL);
+				::Platform::Details::CreateStringReference(__strArg, __length, &__header, &__hString);
+			}
+		}
+		void Init(const ::default::char16* __strArg, unsigned int __lenArg)
+		{
+			if ((__strArg == nullptr) || (__lenArg == 0))
+				Init();
+			else
+			{
+				::Platform::Details::CreateStringReference(__strArg, __lenArg, &__header, &__hString);
+			}
+		}
+
+		__Platform_Details_HSTRING_HEADER __header;
+		__abi_HSTRING __hString;
+	};
+} // namespace Platform
+
+__declspec(non_user_code) __declspec(no_refcount) __declspec(no_release_return)
+	inline void* __abi_winrt_ptrto_string_ctor(const volatile ::Platform::String ^__strArg)
+{
+	if (__strArg)
+	{
+		__abi_HSTRING __hstr;
+		auto __pRaw = reinterpret_cast<__abi_HSTRING>((const_cast< ::Platform::String^>(__strArg)));
+		::Platform::Details::DuplicateString(__pRaw, &__hstr);
+		return __hstr;
+	}
+	return nullptr;
+}
+
+__declspec(non_user_code) __declspec(no_refcount) __declspec(no_release_return)
+	inline void* __abi_winrt_ptrto_string_assign(void** __ppTargetArg, const volatile ::Platform::String ^__pSourceArg)
+{
+	auto __pRaw = reinterpret_cast<__abi_HSTRING>((const_cast< ::Platform::String^>(__pSourceArg)));
+	if ( *__ppTargetArg != reinterpret_cast<void*>(__pRaw) )
+	{
+		if (*__ppTargetArg)
+		{
+			__abi_details::__abi_delete_String(reinterpret_cast< ::Platform::String^>(*__ppTargetArg));
+		}
+		*__ppTargetArg = nullptr;
+		if (__pSourceArg)
+		{
+			__abi_HSTRING __hstr;
+			::Platform::Details::DuplicateString(__pRaw, &__hstr);
+			*__ppTargetArg = __hstr;
+		}
+	}
+	return *__ppTargetArg;
+}
+
+namespace __abi_details
+{
+
+	__declspec(non_user_code) __declspec(no_refcount)
+		inline void __abi_delete_String(::Platform::String^ __strArg)
+	{
+		__Platform_WindowsDeleteString(reinterpret_cast<__abi_HSTRING>(__strArg));
+	}
+
+} // namespace __abi_details
+
+#pragma endregion
+
+
+struct __abi_type_descriptor
+{
+	const __wchar_t* __typeName;
+	int __typeId;
+};
+
+#if !defined(VCWINRT_DLL)
+__declspec(dllimport) ::Platform::Type^ __stdcall __abi_make_type_id(const __abi_type_descriptor&);
+#else
+__declspec(dllexport) ::Platform::Type^ __stdcall __abi_make_type_id(const __abi_type_descriptor&);
+#endif
+
+inline Platform::String^ __abi_CustomToString(void*)
+{
+    return nullptr;
+}
+
+namespace Platform
+{
+    namespace Details
+    {
+        void __cdecl ReportUnhandledError( ::Platform::Exception^);
+
+        __declspec(dllexport) long __stdcall ReCreateFromException(::Platform::Exception^);
+        __declspec(dllexport) ::Platform::Object^ __stdcall CreateValue(::Platform::TypeCode, const void*);
+        __declspec(dllexport) void* __stdcall GetIBoxArrayVtable(void*);
+        __declspec(dllexport) void* __stdcall GetIBoxVtable(void*);
+
+        template<typename T>
+        ref class
+            __declspec(no_empty_identity_interface)
+        CustomBox sealed :
+        public [::Windows::Foundation::Metadata::Default] [::Platform::Metadata::RuntimeClassName] ::Platform::IBox<T>,
+        public ::Platform::Details::IPrintable
+        {
+            T value_;
+        public:
+            CustomBox(T value) : value_(value)
+            {
+                *reinterpret_cast<void**>(static_cast< ::Platform::IValueType^>(this)) =
+                    GetIBoxVtable(reinterpret_cast<void*>(static_cast< ::Platform::IBox<T>^>(this)));
+            }
+
+            virtual property T Value
+            {
+                T get()
+                {
+                    return value_;
+                }
+            }
+
+            virtual Platform::String^ ToString()
+            {
+                return ToStringInternal<__is_enum(T)>();
+            }
+
+        private:
+            template<bool isEnum>
+            Platform::String^ ToStringInternal();
+
+            template<>
+            Platform::String^ ToStringInternal<true>()
+            {
+                String^ s = ::__abi_CustomToString(&value_);
+                if (s)
+                {
+                    return s;
+                }
+                return T::typeid->FullName;
+            }
+
+            template<>
+            Platform::String^ ToStringInternal<false>()
+            {
+                return ::__abi_details::__abi_ObjectToString(this, false);
+            }
+        };
+
+        ref class CustomValueType : public ::Platform::ValueType
+        {
+        };
+
+        ref class CustomEnum : public ::Platform::Enum
+        {
+        };
+
+		template<bool __isEnum>
+		struct BoxValueType
+		{
+			typedef CustomValueType Type;
+		};
+
+		template<>
+		struct BoxValueType<true>
+		{
+			typedef CustomEnum Type;
+		};
+
+		template<typename __TArg>
+		struct RemoveConst
+		{
+			typedef __TArg Type;
+		};
+
+		template<typename __TArg>
+		struct RemoveConst<const __TArg>
+		{
+			typedef __TArg Type;
+		};
+
+		template<typename __TArg>
+		struct RemoveVolatile
+		{
+			typedef __TArg Type;
+		};
+
+		template<typename __TArg>
+		struct RemoveVolatile<volatile __TArg>
+		{
+			typedef __TArg Type;
+		};
+
+		template<typename __TArg>
+		struct RemoveCV
+		{
+			typedef typename RemoveConst<typename RemoveVolatile<__TArg>::Type>::Type Type;
+		};
+
+		template<typename __TArg, typename __TArg2>
+		struct IsSame
+		{
+			static const bool value = false;
+		};
+
+		template<typename __TArg>
+		struct IsSame<__TArg, __TArg>
+		{
+			static const bool value = true;
+		};
+
+		template <typename T>
+		struct RemoveHat
+		{
+			typedef T type;
+		};
+		template <typename T>
+		struct RemoveHat<T^>
+		{
+			typedef T type;
+		};
+	} // namespace Details
+
+	template<typename __TArg>
+	ref class
+		__declspec(one_phase_constructed)
+		__declspec(layout_as_external)
+		__declspec(no_empty_identity_interface)
+		Box abstract :
+	public ::Platform::IBox<typename ::Platform::Details::RemoveCV<__TArg>::Type>,
+		public Details::BoxValueType<__is_enum(__TArg)>::Type
+	{
+		static_assert(__is_enum(__TArg) ||
+				::Platform::Details::IsSame<typename ::Platform::Details::RemoveCV<__TArg>::Type, ::Platform::String^>::value ||
+					__is_value_class(__TArg) ||
+						__is_trivial(__TArg), "__TArg type of Box<__TArg> must be either value, enum or Platform::String^ type");
+
+		typedef typename ::Platform::Details::RemoveCV<__TArg>::Type __TBoxValue;
+	internal:
+		Box(__TBoxValue __valueArg)
+		{
+			static auto __typeCode = ::Platform::Type::GetTypeCode(::Platform::Details::RemoveHat<__TBoxValue>::type::typeid);
+			::Platform::Object ^__boxValue = Details::CreateValue(__typeCode, &__valueArg);
+			if (__boxValue == nullptr)
+			{
+				__boxValue = ref new Details::CustomBox<__TBoxValue>(__valueArg);
+				return reinterpret_cast<Box^>(__boxValue);
+			}
+
+			return dynamic_cast<Box^>(__boxValue);
+		}
+
+		operator __TBoxValue()
+		{
+			if (this == nullptr)
+			{
+				throw ref new ::Platform::NullReferenceException();
+			}
+
+			return safe_cast< ::Platform::IBox<__TBoxValue>^>(this)->Value;
+		}
+
+		operator Box<const __TBoxValue>^()
+		{
+			return reinterpret_cast<Box<const __TBoxValue>^>(this);
+		}
+
+		operator Box<volatile __TBoxValue>^()
+		{
+			return reinterpret_cast<Box<volatile __TBoxValue>^>(this);
+		}
+
+		operator Box<const volatile __TBoxValue>^()
+		{
+			return reinterpret_cast<Box<const volatile __TBoxValue>^>(this);
+		}
+
+		static operator Box<__TArg>^( ::Platform::IBox<__TArg>^ __boxValueArg)
+		{
+			return reinterpret_cast<Box<__TArg>^>(__boxValueArg);
+		}
+
+	public:
+		virtual property __TBoxValue Value
+		{
+			__TBoxValue get()
+			{
+				if (this == nullptr)
+				{
+					throw ref new ::Platform::NullReferenceException();
+				}
+
+				return safe_cast< ::Platform::IBox<__TBoxValue>^>(this)->Value;
+			}
+		}
+	};
+
+
+	////////////////////////////////////////////////////////////////////////////////
+	inline Guid::Guid() : __a(0), __b(0), __c(0), __d(0), __e(0), __f(0), __g(0), __h(0), __i(0), __j(0), __k(0)
+	{
+	}
+
+	inline Guid::Guid(__rcGUID_t __guid) :
+	__a(reinterpret_cast<const __s_GUID&>(__guid).Data1),
+		__b(reinterpret_cast<const __s_GUID&>(__guid).Data2),
+		__c(reinterpret_cast<const __s_GUID&>(__guid).Data3),
+		__d(reinterpret_cast<const __s_GUID&>(__guid).Data4[0]),
+		__e(reinterpret_cast<const __s_GUID&>(__guid).Data4[1]),
+		__f(reinterpret_cast<const __s_GUID&>(__guid).Data4[2]),
+		__g(reinterpret_cast<const __s_GUID&>(__guid).Data4[3]),
+		__h(reinterpret_cast<const __s_GUID&>(__guid).Data4[4]),
+		__i(reinterpret_cast<const __s_GUID&>(__guid).Data4[5]),
+		__j(reinterpret_cast<const __s_GUID&>(__guid).Data4[6]),
+		__k(reinterpret_cast<const __s_GUID&>(__guid).Data4[7])
+	{
+	}
+
+	inline Guid::operator ::__rcGUID_t()
+	{
+		return reinterpret_cast<__rcGUID_t>(*this);
+	}
+
+	inline bool ::Platform::Guid::Equals(::Platform::Guid __guidArg)
+	{
+		auto __al = reinterpret_cast<const unsigned long*>(this);
+		auto __bl = reinterpret_cast<const unsigned long*>(&__guidArg);
+
+		return (__al[0] == __bl[0] && __al[1] == __bl[1] && __al[2] == __bl[2] && __al[3] == __bl[3]);
+	}
+
+	inline bool ::Platform::Guid::Equals(__rcGUID_t __guidArg)
+	{
+		auto __al = reinterpret_cast<const unsigned long*>(this);
+		auto __bl = reinterpret_cast<const unsigned long*>(&__guidArg);
+
+		return (__al[0] == __bl[0] && __al[1] == __bl[1] && __al[2] == __bl[2] && __al[3] == __bl[3]);
+	}
+
+	inline bool ::Platform::Guid::operator==(::Platform::Guid __aArg, ::Platform::Guid __bArg)
+	{
+		auto __al = reinterpret_cast<const unsigned long*>(&__aArg);
+		auto __bl = reinterpret_cast<const unsigned long*>(&__bArg);
+
+		return (__al[0] == __bl[0] && __al[1] == __bl[1] && __al[2] == __bl[2] && __al[3] == __bl[3]);
+	}
+
+	inline bool ::Platform::Guid::operator!=(::Platform::Guid __aArg, ::Platform::Guid __bArg)
+	{
+		return !(__aArg == __bArg);
+	}
+
+	inline bool ::Platform::Guid::operator<(::Platform::Guid __aArg, ::Platform::Guid __bArg)
+	{
+		auto __al = reinterpret_cast<const unsigned long*>(&__aArg);
+		auto __bl = reinterpret_cast<const unsigned long*>(&__bArg);
+
+		if (__al[0] != __bl[0])
+		{
+			return __al[0] < __bl[0];
+		}
+
+		if (__al[1] != __bl[1])
+		{
+			return __al[1] < __bl[1];
+		}
+
+		if (__al[2] != __bl[2])
+		{
+			return __al[2] < __bl[2];
+		}
+
+		if (__al[3] != __bl[3])
+		{
+			return __al[3] < __bl[3];
+		}
+
+		return false;
+	}
+
+	inline Guid::Guid(unsigned int __aArg, unsigned short __bArg, unsigned short __cArg, unsigned __int8 __dArg,
+		unsigned __int8 __eArg, unsigned __int8 __fArg, unsigned __int8 __gArg, unsigned __int8 __hArg,
+		unsigned __int8 __iArg, unsigned __int8 __jArg, unsigned __int8 __kArg) :
+	__a(__aArg), __b(__bArg), __c(__cArg), __d(__dArg), __e(__eArg), __f(__fArg), __g(__gArg), __h(__hArg), __i(__iArg), __j(__jArg), __k(__kArg)
+	{
+	}
+
+	inline Guid::Guid(unsigned int __aArg, unsigned short __bArg, unsigned short __cArg, const ::Platform::Array<unsigned __int8>^ __dArg) :
+	__a(__aArg), __b(__bArg), __c(__cArg)
+	{
+		if (__dArg == nullptr || __dArg->Length != 8)
+		{
+			__abi_WinRTraiseInvalidArgumentException();
+		}
+		__d = __dArg[0];
+		__e = __dArg[1];
+		__f = __dArg[2];
+		__g = __dArg[3];
+		__h = __dArg[4];
+		__i = __dArg[5];
+		__j = __dArg[6];
+		__k = __dArg[7];
+	}
+
+	__declspec(selectany) ::Platform::Guid __winrt_GUID_NULL = {0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+	////////////////////////////////////////////////////////////////////////////////
+	inline void* Details::Heap::Allocate(::Platform::SizeT /*__sizeArg*/, void* __pPlacementArg)
+	{
+		return __pPlacementArg;
+	}
+
+	inline void* Details::Heap::Allocate(::Platform::SizeT /*__rcOffset*/, ::Platform::SizeT /*__sizeArg*/, void* __pPlacementArg)
+	{
+		return __pPlacementArg;
+	}
+
+	inline void Details::Heap::PlacementFree(void* /*__pArg*/, void* /*__placementArg*/)
+	{
+	}
+} // namespace Platform
+
+template <typename __TArg>
+Platform::Box<typename ::Platform::Details::RemoveCV<__TArg>::Type>^ __abi_create_box(__TArg __boxValueArg)
+{
+	return ref new ::Platform::Box<__TArg>(__boxValueArg);
+}
+
+template <typename __TArg>
+__TArg __abi_unbox(::Platform::Object^ __objArg)
+{
+	return safe_cast< ::Platform::Box<__TArg>^>(__objArg);
+}
+
+template<typename T>
+__declspec(non_user_code)
+	inline T^ __abi_winrt_cast_from_object_to_delegate(bool __isDynamicCastArg, ::Platform::Object^ __objArg)
+{
+	if (__objArg == nullptr) {
+		return nullptr;
+	}
+
+	auto __p(dynamic_cast< ::Platform::Details::CustomBox<T^> ^>(__objArg));
+	if (__p == nullptr) {
+		if (__isDynamicCastArg) {
+			return nullptr;
+		}
+
+		__abi_WinRTraiseInvalidCastException();
+	} else {
+		return __p->Value;
+	}
+}
+
+template<typename T>
+__declspec(non_user_code) __declspec(no_refcount)
+	inline ::Platform::Object^ __abi_winrt_cast_from_delegate_to_object(bool /*__isDynamicCastArg*/, T^ __objArg)
+{
+	if (__objArg == nullptr) {
+		return nullptr;
+	} else {
+		return ref new ::Platform::Details::CustomBox<T^>(__objArg);
+	}
+}
+
+inline long __stdcall __abi_FTMWeakRefData::__abi_QueryInterface(::Platform::Guid& __guid, void** __pOut)
+{
+	if (__pUnkMarshal == nullptr || __guid.Equals(__uuidof(__abi_IMarshal)) == false)
+	{
+		return 0x80004002;
+	}
+	if (__pUnkMarshal == reinterpret_cast<__abi_IUnknown*>(-1))
+	{
+		__abi_IUnknown* __pUnkMarshalLocal;
+
+#if !defined(VCWINRT_DLL)
+		long __hr = ::__Platform_CoCreateFreeThreadedMarshaler(reinterpret_cast<::Platform::Object^>(__weakRefSource->__target),  reinterpret_cast< ::Platform::Object^*>(&__pUnkMarshalLocal));
+#else
+		long __hr = ::CoCreateFreeThreadedMarshaler(reinterpret_cast<IUnknown*>(__weakRefSource->__target),  reinterpret_cast<IUnknown**>(&__pUnkMarshalLocal));
+#endif
+		__abi_ThrowIfFailed(__hr);
+
+		if (::_InterlockedCompareExchangePointer(reinterpret_cast<void* volatile*>(&__pUnkMarshal), __pUnkMarshalLocal, reinterpret_cast<void*>(-1)) != reinterpret_cast<void*>(-1))
+		{
+			__pUnkMarshalLocal->__abi_Release();
+		}
+	}
+	return __pUnkMarshal->__abi_QueryInterface(__guid, __pOut);
+}
+
+inline long __stdcall ::Platform::Details::ControlBlock::__abi_QueryInterface(::Platform::Guid& __riid, void** __ppvObject)
+{
+	if (__riid.Equals(__uuidof(__abi_IUnknown)) ||
+		__riid.Equals(__uuidof(__abi_IWeakReference)))
+	{
+		__abi_AddRef();
+		*__ppvObject = this;
+		return 0;
+	}
+	*__ppvObject = nullptr;
+	return 0x80004002;
+}
+
+#pragma region String
+#pragma region String^ API
+
+namespace Platform
+{
+#if !defined(_PREFIX_) && !defined(_PREFAST_)
+
+	__declspec(no_refcount)
+		__declspec(no_release_return)
+		inline String::String()
+	{
+		return nullptr;
+	}
+
+	__declspec(no_refcount)
+		inline String::String(__abi_HSTRING __hstrArg)
+	{
+		__abi_HSTRING __hstr;
+		Details::DuplicateString(__hstrArg, &__hstr);
+		return *reinterpret_cast<String^*>(&__hstr);
+	}
+
+	__declspec(no_refcount)
+		inline String::String(const ::default::char16* __strArg)
+	{
+		if (__strArg == nullptr)
+			return nullptr;
+
+		__abi_HSTRING __hstr = nullptr;
+		::Platform::Details::CreateString(__strArg, (unsigned int)__Platform_wcslen(__strArg), &__hstr);
+		return *reinterpret_cast<String^*>(&__hstr);
+	}
+
+	__declspec(no_refcount)
+		inline String::String(const ::default::char16* __strArg, unsigned int __lenArg)
+	{
+		if ((__strArg == nullptr) || (__lenArg == 0))
+			return nullptr;
+
+		__abi_HSTRING __hstr = nullptr;
+		::Platform::Details::CreateString(__strArg, __lenArg, &__hstr);
+		return *reinterpret_cast<String^*>(&__hstr);
+	}
+
+#endif // !defined(_PREFIX_) && !defined(_PREFAST_)
+
+	inline const ::default::char16* String::Begin()
+	{
+		return Data();
+	}
+	inline const ::default::char16* String::End()
+	{
+		return Data() + Length();
+	}
+
+	inline Platform::String^ Object::ToString()
+	{
+		return ::__abi_details::__abi_ObjectToString(this, true);
+	}
+
+	inline const ::default::char16 * String::Data()
+	{
+		return __Platform_WindowsGetStringRawBuffer(reinterpret_cast<__abi_HSTRING>(this), nullptr);
+	}
+
+	inline unsigned int String::Length()
+	{
+		return __Platform_WindowsGetStringLen(reinterpret_cast<__abi_HSTRING>(this));
+	}
+	inline bool String::IsEmpty()
+	{
+		return __Platform_WindowsIsStringEmpty(reinterpret_cast<__abi_HSTRING>(this)) ? true : false;
+	}
+
+	inline bool String::IsFastPass()
+	{
+		return false;
+	}
+
+	inline bool String::Equals(Object^ __strArg)
+	{
+		int __result = 0;
+		__Platform_WindowsCompareStringOrdinal(reinterpret_cast<__abi_HSTRING>(this), reinterpret_cast<__abi_HSTRING>(((String^)__strArg)), &__result);
+		return (__result == 0);
+	}
+
+	inline bool String::Equals(String^ __str1Arg)
+	{
+		int __result = 0;
+		__Platform_WindowsCompareStringOrdinal(reinterpret_cast<__abi_HSTRING>(this), reinterpret_cast<__abi_HSTRING>(__str1Arg), &__result);
+		return (__result == 0);
+	}
+	inline int String::CompareOrdinal(String^ __str1Arg, String^ __str2Arg)
+	{
+		int __result = 0;
+		__Platform_WindowsCompareStringOrdinal(reinterpret_cast<__abi_HSTRING>(__str1Arg), reinterpret_cast<__abi_HSTRING>(__str2Arg), &__result);
+		return __result;
+	}
+	inline int String::GetHashCode()
+	{
+		int __hash = 0;
+		for (auto i = Begin(); i != End(); ++i)
+			__hash += *i;
+		return __hash;
+	}
+
+	inline bool ::Platform::String::operator==(::Platform::String^ __str1Arg, ::Platform::String^ __str2Arg)
+	{
+		int __result = 0;
+		__Platform_WindowsCompareStringOrdinal(reinterpret_cast<__abi_HSTRING>(__str1Arg), reinterpret_cast<__abi_HSTRING>(__str2Arg), &__result);
+		return (__result == 0);
+	}
+
+	inline bool ::Platform::String::operator!=(::Platform::String^ __str1Arg, ::Platform::String^ __str2Arg)
+	{
+		int __result = 0;
+		__Platform_WindowsCompareStringOrdinal(reinterpret_cast<__abi_HSTRING>(__str1Arg), reinterpret_cast<__abi_HSTRING>(__str2Arg), &__result);
+		return (__result != 0);
+	}
+
+	inline bool ::Platform::String::operator<(::Platform::String^ __str1Arg, ::Platform::String^ __str2Arg)
+	{
+		int __result = 0;
+		__Platform_WindowsCompareStringOrdinal(reinterpret_cast<__abi_HSTRING>(__str1Arg), reinterpret_cast<__abi_HSTRING>(__str2Arg), &__result);
+		return (__result < 0);
+	}
+
+	inline bool ::Platform::String::operator>(::Platform::String^ __str1Arg, ::Platform::String^ __str2Arg)
+	{
+		int __result = 0;
+		__Platform_WindowsCompareStringOrdinal(reinterpret_cast<__abi_HSTRING>(__str1Arg), reinterpret_cast<__abi_HSTRING>(__str2Arg), &__result);
+		return (__result > 0);
+	}
+
+	inline bool ::Platform::String::operator<=(::Platform::String^ __str1Arg, ::Platform::String^ __str2Arg)
+	{
+		int __result = 0;
+		__Platform_WindowsCompareStringOrdinal(reinterpret_cast<__abi_HSTRING>(__str1Arg), reinterpret_cast<__abi_HSTRING>(__str2Arg), &__result);
+		return (__result <= 0);
+	}
+
+	inline bool ::Platform::String::operator>=(::Platform::String^ __str1Arg, ::Platform::String^ __str2Arg)
+	{
+		int __result = 0;
+		__Platform_WindowsCompareStringOrdinal(reinterpret_cast<__abi_HSTRING>(__str1Arg), reinterpret_cast<__abi_HSTRING>(__str2Arg), &__result);
+		return (__result >= 0);
+	}
+
+	inline ::Platform::String ^ ::Platform::String::Concat(::Platform::String^ __str1Arg, ::Platform::String^ __str2Arg)
+	{
+		String^ __str = nullptr;
+		__abi_ThrowIfFailed(__Platform_WindowsConcatString(reinterpret_cast<__abi_HSTRING>(__str1Arg), reinterpret_cast<__abi_HSTRING>(__str2Arg), reinterpret_cast<__abi_HSTRING*>(&__str)));
+		return __str;
+	}
+
+	inline ::Platform::String ^ ::Platform::String::Concat(::Platform::Object^ __str1Arg, ::Platform::Object^ __str2Arg)
+	{
+		String^ __str = nullptr;
+#pragma warning (suppress:6011) // False positive because __str?Arg not evaluated
+		__abi_ThrowIfFailed(__Platform_WindowsConcatString(reinterpret_cast<__abi_HSTRING>(__str1Arg->ToString()), reinterpret_cast<__abi_HSTRING>(__str2Arg->ToString()), reinterpret_cast<__abi_HSTRING*>(&__str)));
+		return __str;
+	}
+
+	inline String^ String::ToString()
+	{
+		return ref new ::Platform::String(Data());
+	}
+
+#pragma region string iterators
+	inline const ::default::char16 * begin(::Platform::String^ __strArg)
+	{
+		return __strArg->Begin();
+	}
+
+	inline const ::default::char16 * end(::Platform::String^ __strArg)
+	{
+		return __strArg->End();
+	}
+#pragma endregion
+} // namespace Platform
+#pragma endregion
+
+__declspec(non_user_code)
+	inline ::Platform::String^ __abi_winrt_CreateSystemStringFromLiteral(const ::default::char16* __strArg)
+{
+	return ref new ::Platform::String(__strArg);
+}
+
+template<typename __TArg>
+inline ::Platform::Array<__TArg, 1>^ __abi_winrt_CreateArray(unsigned int __sizeArg)
+{
+	return ref new ::Platform::Array<__TArg, 1>(__sizeArg);
+}
+
+inline __declspec(no_refcount) __declspec(no_release_return) ::Platform::String^ __abi_winrt_CreateFastPassSystemStringFromLiteral(const ::default::char16* __strArg, unsigned int __lenArg, __Platform_Details_HSTRING_HEADER* __psheaderArg)
+{
+	__abi_HSTRING __hstr;
+	::Platform::Details::CreateStringReference(__strArg, __lenArg, __psheaderArg, &__hstr);
+	return *reinterpret_cast< ::Platform::String^*>(&__hstr);
+}
+
+inline __declspec(no_refcount) __declspec(no_release_return) ::Platform::String^ __abi_winrt_CreateFastPassSystemStringFromLiteral(const unsigned short* __strArg, unsigned int __lenArg, __Platform_Details_HSTRING_HEADER* __psheaderArg)
+{
+	return __abi_winrt_CreateFastPassSystemStringFromLiteral(reinterpret_cast<const ::default::char16*>(__strArg), __lenArg, __psheaderArg);
+}
+
+#pragma endregion
+
+#pragma region Array
+
+namespace Platform
+{
+	namespace Details
+	{
+		// Attach to the external buffer
+		template <typename __HighLevelType, unsigned int __dimension>
+		__declspec(no_refcount) ::Platform::Array<__HighLevelType, __dimension>^ __abi_array_attach(void* __srcArg, unsigned int __elementcountArg, bool __isFastPassArg, bool __needsInitArg)
+		{
+			if (static_cast<unsigned int>(-1) / sizeof(__HighLevelType) < __elementcountArg)
+			{
+				__abi_WinRTraiseInvalidArgumentException();
+			}
+			auto __arr = ref new ::Platform::Array<__HighLevelType, __dimension>(nullptr, 0);
+
+			if (__needsInitArg)
+			{
+				__Platform_memset(__srcArg, 0, sizeof(__HighLevelType) * __elementcountArg);
+			}
+			if (!__isFastPassArg)
+			{
+				__arr->Attach(reinterpret_cast<__HighLevelType*>(__srcArg), __elementcountArg);
+			}
+			else
+			{
+				__arr->AttachFastPass(reinterpret_cast<__HighLevelType*>(__srcArg), __elementcountArg);
+			}
+
+			return __arr;
+		}
+
+		template <typename __HighLevelType, unsigned int __dimension>
+		void __abi_array_copy_to_and_release(::Platform::Array<__HighLevelType, __dimension>^ __arrArg, void** __destArg, unsigned int* __sizeArg)
+		{
+			if (__arrArg == nullptr)
+			{
+				*__destArg = nullptr;
+				*__sizeArg = 0;
+				return;
+			}
+
+			__HighLevelType **__destHigh = reinterpret_cast<__HighLevelType **>(__destArg);
+			__arrArg->CopyToOrDetach(__destHigh, __sizeArg);
+
+			// __arrArg is a local variable declared in a wrapper marked with no_refcount
+			// This function is called from that function, have to release the Array^
+			reinterpret_cast<__abi_IUnknown*>(static_cast< ::Platform::Object^>(__arrArg))->__abi_Release();
+			// The caller will not use __arrArg after this function returns
+		}
+
+		// Convert ::Platform::Array to raw buffer
+		// It is called when we are converting in Array from high level to low level
+		template <typename __LowLevelType, typename __HighLevelType, unsigned int __dimension>
+		__LowLevelType* __abi_array_to_raw(const ::Platform::Array<__HighLevelType, __dimension>^ __arrArg)
+		{
+			if (__arrArg == nullptr)
+			{
+				return nullptr;
+			}
+			return reinterpret_cast<__LowLevelType*>(__arrArg->Data);
+		}
+
+		template <typename __TArg>
+		struct array_helper<__TArg, true>
+		{
+			static void DestructElementsAndFree(__TArg* __srcArg, unsigned int)
+			{
+				__Platform_CoTaskMemFree(__srcArg);
+			}
+		};
+
+		template <typename __TArg>
+		struct array_helper<__TArg, false>
+		{
+			static void DestructElementsAndFree(__TArg* __srcArg, unsigned int __countArg)
+			{
+				typedef __TArg typeT;
+				for (unsigned int __i = 0; __i < __countArg; __i++)
+				{
+					(&__srcArg[__i])->~typeT();
+				}
+				__Platform_CoTaskMemFree(__srcArg);
+			}
+		};
+	} // namespace Details
+
+	template <typename __TArg>
+	class ArrayReference<__TArg, 1>
+	{
+		default::uint8 __data[sizeof(Array<__TArg>)];
+			void Init(__TArg* __dataArg, unsigned int __sizeArg, bool __needsInitArg = false)
+			{
+				__Platform_memset(__data, 0, sizeof(Array<__TArg>));
+				ArrayReference* __pThis = this;
+				Array<__TArg>^* __pArrayThis = reinterpret_cast<Array<__TArg>^*>(&__pThis);
+				(*__pArrayThis)->ArrayReferenceInit();
+
+				if (__needsInitArg)
+				{
+					if (static_cast<unsigned int>(-1) / sizeof(__TArg) < __sizeArg)
+					{
+						__abi_WinRTraiseInvalidArgumentException();
+					}
+					__Platform_memset(__dataArg, 0, sizeof(__TArg) * __sizeArg);
+				}
+
+				(*__pArrayThis)->AttachFastPass(__dataArg, __sizeArg);
+			}
+	public:
+		ArrayReference(__TArg* __dataArg, unsigned int __sizeArg, bool __needsInitArg = false)
+		{
+			Init(__dataArg, __sizeArg, __needsInitArg);
+		}
+
+		ArrayReference(ArrayReference&& __otherArg)
+		{
+			Array<__TArg>^* __pOther = reinterpret_cast<Array<__TArg>^*>(&__otherArg);
+			Init((*__pOther)->__data, (*__pOther)->__size);
+		}
+
+		ArrayReference& operator=(ArrayReference&& __otherArg)
+		{
+			Array<__TArg>^* __pOther = reinterpret_cast<Array<__TArg>^*>(&__otherArg);
+			Init((*pOther)->__data, (*pOther)->__size);
+		}
+
+		__declspec(no_refcount) __declspec(no_release_return)
+			operator Array<__TArg>^()
+		{
+			ArrayReference* __pThis = this;
+			Array<__TArg>^* __pArrayThis = reinterpret_cast<Array<__TArg>^*>(&__pThis);
+
+			return *__pArrayThis;
+		}
+	private:
+		ArrayReference(const ArrayReference&);
+		ArrayReference& operator=(const ArrayReference&);
+	};
+
+#pragma region ::Platform::WriteOnlyArray
+	template <typename __TArg>
+	inline WriteOnlyArray<__TArg, 1>::WriteOnlyArray() : __size(0), __fastpassflag(false), __data(nullptr)
+	{
+	}
+
+	template <typename __TArg>
+	inline WriteOnlyArray<__TArg, 1>::WriteOnlyArray(unsigned int __sizeArg) : __size(0), __fastpassflag(false), __data(nullptr)
+	{
+		if (__sizeArg == 0)
+		{
+			return;
+		}
+		__data = AllocateAndZeroInitialize(__sizeArg);
+		__size = __sizeArg;
+	}
+
+	template <typename __TArg>
+	inline WriteOnlyArray<__TArg, 1>::WriteOnlyArray(__TArg* __dataArg, unsigned int __sizeArg) : __size(0), __fastpassflag(false), __data(nullptr)
+	{
+		if (__sizeArg == 0)
+		{
+			return;
+		}
+		__data = AllocateAndCopyElements(__dataArg, __sizeArg);
+		__size = __sizeArg;
+	}
+
+	template <typename __TArg>
+	inline WriteOnlyArray<__TArg, 1>::~WriteOnlyArray()
+	{
+		if ((__fastpassflag == false) && (__data != nullptr))
+		{
+			::Platform::Details::array_helper<__TArg>::DestructElementsAndFree(__data, __size);
+		}
+		Clear();
+	}
+
+	template <typename __TArg>
+	inline __TArg& WriteOnlyArray<__TArg, 1>::set(unsigned int __positionArg, __TArg __valueArg)
+	{
+		if (__data == nullptr)
+		{
+			__abi_WinRTraiseNullReferenceException();
+		}
+
+		if (__positionArg >= 0 && __positionArg < __size)
+		{
+			__data[__positionArg] = __valueArg;
+			return __data[__positionArg];
+		}
+
+		__abi_WinRTraiseOutOfBoundsException();
+	}
+
+	template <typename __TArg>
+	inline __TArg& WriteOnlyArray<__TArg, 1>::get(unsigned int __positionArg) const
+	{
+		if (__data == nullptr)
+		{
+			__abi_WinRTraiseNullReferenceException();
+		}
+
+		if (__positionArg >= 0 && __positionArg < __size)
+		{
+			return __data[__positionArg];
+		}
+
+		__abi_WinRTraiseOutOfBoundsException();
+	}
+
+#if defined(_PREFIX_) || defined(_PREFAST_)
+	template <typename __TArg>
+	inline __TArg& WriteOnlyArray<__TArg, 1>::operator [](unsigned int __positionArg) const
+	{
+		if (__data == nullptr)
+		{
+			__abi_WinRTraiseNullReferenceException();
+		}
+
+		if (__positionArg >= 0 && __positionArg < __size)
+		{
+			return __data[__positionArg];
+		}
+
+		__abi_WinRTraiseOutOfBoundsException();
+	}
+#endif // #if defined(_PREFIX_) || defined(_PREFAST_)
+
+	template <typename __TArg>
+	inline __TArg* WriteOnlyArray<__TArg, 1>::begin() const
+	{
+		if (__data == nullptr)
+		{
+			return nullptr;
+		}
+
+		return &(__data[0]);
+	}
+
+	template <typename __TArg>
+	inline __TArg* WriteOnlyArray<__TArg, 1>::end() const
+	{
+		if (__data == nullptr)
+		{
+			return nullptr;
+		}
+
+		return &(__data[__size]);
+	}
+
+	template <typename __TArg>
+	inline unsigned int  WriteOnlyArray<__TArg, 1>::Length::get() const
+	{
+		return __size;
+	}
+
+	template <typename __TArg>
+	inline __TArg* WriteOnlyArray<__TArg, 1>::Data::get() const
+	{
+		return this->begin();
+	}
+
+	template <typename __TArg>
+	inline bool WriteOnlyArray<__TArg, 1>::FastPass::get() const
+	{
+		return __fastpassflag;
+	}
+
+	template <typename __TArg>
+	inline void WriteOnlyArray<__TArg, 1>::Clear()
+	{
+		__size = 0;
+		__fastpassflag = false;
+		__data = nullptr;
+	}
+
+	template <typename __TArg>
+	inline __TArg* WriteOnlyArray<__TArg, 1>::AllocateAndZeroInitialize(unsigned int __countArg)
+	{
+		__TArg* __dest = nullptr;
+		if (__countArg == 0)
+		{
+			return __dest;
+		}
+
+		if (static_cast<unsigned int>(-1) / sizeof(__TArg) < __countArg)
+		{
+			__abi_WinRTraiseInvalidCastException();
+		}
+		__dest = (__TArg*)__Platform_CoTaskMemAlloc(__countArg * sizeof(__TArg));
+		if (__dest == nullptr)
+		{
+			__abi_WinRTraiseOutOfMemoryException();
+		}
+
+		__Platform_memset(__dest, 0, __countArg * sizeof(__TArg));
+		return __dest;
+	}
+
+	template <typename __TArg>
+	inline __TArg* WriteOnlyArray<__TArg, 1>::AllocateAndCopyElements(const __TArg* __srcArg, unsigned int __countArg)
+	{
+		__TArg* __dest = AllocateAndZeroInitialize(__countArg);
+		for (unsigned int __i = 0; __i < __countArg; ++__i)
+		{
+			__dest[__i] = __srcArg[__i];
+		}
+		return __dest;
+	}
+#pragma endregion
+
+#pragma region ::Platform::Array
+	template <typename __TArg>
+	inline Array<__TArg, 1>::Array() : WriteOnlyArray<__TArg, 1>()
+	{
+		*reinterpret_cast<void**>(static_cast< ::Platform::IValueType^ >(this)) =
+			Details::GetIBoxArrayVtable(reinterpret_cast<void*>(static_cast< ::Platform::IBoxArray<__TArg>^ >(this)));
+	}
+
+	template <typename __TArg>
+	inline Array<__TArg, 1>::Array(const Array<__TArg, 1>^ __source) : WriteOnlyArray<__TArg, 1>(__source ? __source->Data : nullptr, __source ? __source->Length : 0)
+	{
+		*reinterpret_cast<void**>(static_cast< ::Platform::IValueType^ >(this)) =
+			Details::GetIBoxArrayVtable(reinterpret_cast<void*>(static_cast< ::Platform::IBoxArray<__TArg>^ >(this)));
+    }
+
+	template <typename __TArg>
+	inline Array<__TArg, 1>::Array(unsigned int __sizeArg) : WriteOnlyArray<__TArg, 1>(__sizeArg)
+	{
+		*reinterpret_cast<void**>(static_cast< ::Platform::IValueType^ >(this)) =
+			Details::GetIBoxArrayVtable(reinterpret_cast<void*>(static_cast< ::Platform::IBoxArray<__TArg>^ >(this)));
+	}
+
+	template <typename __TArg>
+	inline Array<__TArg, 1>::Array(__TArg* __dataArg, unsigned int __sizeArg) : WriteOnlyArray<__TArg, 1>(__dataArg, __sizeArg)
+	{
+		*reinterpret_cast<void**>(static_cast< ::Platform::IValueType^ >(this)) =
+			Details::GetIBoxArrayVtable(reinterpret_cast<void*>(static_cast< ::Platform::IBoxArray<__TArg>^>(this)));
+	}
+
+	template <typename T>
+	inline T& Array<T, 1>::get(unsigned int __positionArg) const
+	{
+		return WriteOnlyArray<T, 1>::get(__positionArg);
+	}
+
+#if defined(_PREFIX_) || defined(_PREFAST_)
+	template <typename T>
+	inline T& Array<T, 1>::operator[](unsigned int __positionArg) const
+	{
+		return WriteOnlyArray<T, 1>::operator[](__positionArg);
+	}
+#endif // defined(_PREFIX_) || defined(_PREFAST_)
+
+	template <typename __TArg>
+	inline Array<__TArg, 1>^ Array<__TArg, 1>::Value::get()
+	{
+		return this;
+	}
+
+	template <typename __TArg>
+	inline void Array<__TArg, 1>::Attach(__TArg* __srcArg, unsigned int __sizeArg)
+	{
+		// Precondition:
+		//    default constructed object
+		// Postcondition:
+		//    _data = src
+		//    _size = size
+		//    _fastpassflag = false
+		//    _refcount = 1
+
+		if (this->__size == 0 && this->__data == nullptr)
+		{
+			this->__size = __sizeArg;
+			this->__fastpassflag = false;
+			this->__data = __srcArg;
+			return;
+		}
+
+		__abi_WinRTraiseFailureException();
+	}
+
+	template <typename __TArg>
+	inline void Array<__TArg, 1>::AttachFastPass(__TArg* __srcArg, unsigned int __sizeArg)
+	{
+		// Precondition:
+		//    default constructed object
+		// Postcondition:
+		//    _data = src
+		//    _size = size
+		//    _fastpassflag = true
+
+		if (this->__size == 0 && this->__data == nullptr)
+		{
+			this->__size = __sizeArg;
+			this->__fastpassflag = true;
+			this->__data = __srcArg;
+			return;
+		}
+
+		__abi_WinRTraiseFailureException();
+	}
+
+	template <typename __TArg>
+	inline void Array<__TArg, 1>::CopyToOrDetach(__TArg** __destArg, unsigned int* __sizeArg)
+	{
+		// Postcondition:
+		//    if (_refcount == 1 && !_fastpassflag)
+		//        *dest = _data
+		//        *size = _size
+		//          Clear()
+		//    if (_refcount > 1 || _fastpassflag)
+		//        *dest = new buffer with contents of _data
+		//        *size = _size
+
+		if ((__destArg == nullptr) || (__sizeArg == nullptr))
+		{
+			__abi_WinRTraiseNullReferenceException();
+		}
+
+		if (this->__size == 0)
+		{
+			*__destArg = nullptr;
+			*__sizeArg = 0;
+			return;
+		}
+
+		if(this->__data == nullptr)
+		{
+			__abi_WinRTraiseFailureException();
+		}
+
+		if (!this->__fastpassflag && this->__abi_reference_count.Get() == 1)
+		{
+			*__destArg = this->__data;
+			*__sizeArg = this->__size;
+			this->Clear();
+		}
+		else if (this->__fastpassflag || this->__abi_reference_count.Get() > 1)
+		{
+			*__destArg = this->AllocateAndCopyElements(this->__data, this->__size);
+			*__sizeArg = this->__size;
+		}
+		else
+		{
+			__abi_WinRTraiseFailureException();
+		}
+	}
+
+#pragma endregion
+
+#pragma region Array iterators
+	template<class __TArg>
+	__TArg * begin(const Array<__TArg, 1>^ __arrArg)
+	{
+		return __arrArg->begin();
+	}
+
+	template<class __TArg>
+	__TArg * end(const Array<__TArg, 1>^ __arrArg)
+	{
+		return __arrArg->end();
+	}
+#pragma endregion
+} // namespace Platform {
+#pragma endregion
+
+namespace Platform
+{
+	namespace Details
+	{
+#if !defined(VCWINRT_DLL)
+		__declspec(dllimport) void __stdcall EventSourceInitialize(void**);
+		__declspec(dllimport) void __stdcall EventSourceUninitialize(void**);
+		__declspec(dllimport) void* __stdcall EventSourceGetTargetArray(void*, EventLock*);
+		__declspec(dllimport) unsigned int __stdcall EventSourceGetTargetArraySize(void*);
+		__declspec(dllimport) void* __stdcall EventSourceGetTargetArrayEvent(void*, unsigned int, const void*, __int64*);
+		__declspec(dllimport) ::Windows::Foundation::EventRegistrationToken __stdcall EventSourceAdd(void**, EventLock*, ::Platform::Delegate^);
+		__declspec(dllimport) void __stdcall EventSourceRemove(void**, EventLock*, ::Windows::Foundation::EventRegistrationToken);
+		__declspec(dllimport) __abi_IUnknown* __stdcall GetWeakReference(const volatile ::Platform::Object^ const other);
+		__declspec(dllimport) __declspec(no_refcount) ::Platform::Object^ __stdcall ResolveWeakReference(const ::_GUID& guid, __abi_IUnknown** weakRef);
+#else
+		__declspec(dllexport) void __stdcall EventSourceInitialize(void**);
+		__declspec(dllexport) void __stdcall EventSourceUninitialize(void**);
+		__declspec(dllexport) void* __stdcall EventSourceGetTargetArray(void*, EventLock*);
+		__declspec(dllexport) unsigned int __stdcall EventSourceGetTargetArraySize(void*);
+		__declspec(dllexport) void* __stdcall EventSourceGetTargetArrayEvent(void*, unsigned int, const void*, __int64*);
+		__declspec(dllexport) ::Windows::Foundation::EventRegistrationToken __stdcall EventSourceAdd(void**, EventLock*, ::Platform::Delegate^);
+		__declspec(dllexport) void __stdcall EventSourceRemove(void**, EventLock*, ::Windows::Foundation::EventRegistrationToken);
+		__declspec(dllexport) __abi_IUnknown* __stdcall GetWeakReference(const volatile ::Platform::Object^ const other);
+		__declspec(dllexport) __declspec(no_refcount) ::Platform::Object^ __stdcall ResolveWeakReference(const ::_GUID& guid, __abi_IUnknown** weakRef);
+#endif
+	} // Details
+
+	class EventSource
+	{
+	public:
+		EventSource()
+		{
+			Details::EventSourceInitialize(&__targets);
+		}
+
+		~EventSource()
+		{
+			Details::EventSourceUninitialize(&__targets);
+		}
+
+		::Windows::Foundation::EventRegistrationToken Add(Details::EventLock* __lockArg, ::Platform::Object^ __delegateInterfaceArg)
+		{
+			return Details::EventSourceAdd(&__targets, __lockArg, reinterpret_cast< ::Platform::Delegate^>(__delegateInterfaceArg));
+		}
+
+		void Remove(Details::EventLock* __lockArg, ::Windows::Foundation::EventRegistrationToken __tokenArg)
+		{
+			Details::EventSourceRemove(&__targets, __lockArg, __tokenArg);
+		}
+	private:
+		// __TInvokeMethod is a functor that performs the appropriate invoke, depending on the
+		// number of arguments specified.
+		template <typename __TDelegate, typename __TReturnType, typename __TInvokeMethod>
+		typename __TReturnType DoInvoke(Details::EventLock* __lockArg, __TInvokeMethod __invokeOneArg)
+		{
+			// lock pointer exhange
+			//        targets = _targets
+			// unlock pointer exhange
+			// iterate all targets and do invoke
+
+			// The _targetsPointerLock protects the acquisition of an AddRef'd pointer to
+			// "current list".  An Add/Remove operation may occur during the
+			// firing of events (but occurs on a copy of the list).  i.e. both
+			// DoInvoke/invoke and Add/Remove are readers of the "current list".
+			// NOTE:  EventSource::Invoke(...) must never take the _addRemoveLock.
+			::Platform::Object^ __targetsLoc;
+			// Attaching Array without AddRef'ing
+
+			// In order to prevent a load of __targets while unprotected by __targetsLock,
+			// we must take the lock externally to the call to EventSourceGetTargetArray.
+			// We then pass in a dummy lock instead of the real lock in order to prevent
+			// recursive acquisition. This fix was made to avoid modifying vccorlib.dll.
+			// On the next binary breaking change, the Details::EventSourceGetTargetArray
+			// call interface should be modified to take __targets by pointer instead of
+			// by value.
+			Details::EventLock __dummylock = { nullptr, nullptr };
+			__Platform_AcquireSRWLockShared(&__lockArg->__targetsLock);
+			void* __EvSrcGTA_ret = Details::EventSourceGetTargetArray(__targets, &__dummylock);
+			__Platform_ReleaseSRWLockShared(&__lockArg->__targetsLock);
+			*reinterpret_cast<void**>(&__targetsLoc) = __EvSrcGTA_ret;
+
+			typename __TReturnType __returnVal = typename __TReturnType();
+			// The list may not exist if nobody has registered
+			if (__targetsLoc != nullptr)
+			{
+				const unsigned int __size = Details::EventSourceGetTargetArraySize(reinterpret_cast<void*>(__targetsLoc));
+
+				for (unsigned int __index = 0; __index < __size; __index++)
+				{
+					::Windows::Foundation::EventRegistrationToken __token = {};
+
+					try
+					{
+						__TDelegate^ __element;
+						*reinterpret_cast<void**>(&__element) = Details::EventSourceGetTargetArrayEvent(
+								reinterpret_cast<void*>(__targetsLoc),
+								__index,
+								reinterpret_cast<const void*>(&__uuidof(__TDelegate^)),
+								&__token.Value
+							);
+
+						__returnVal = (__invokeOneArg)(__element);
+					}
+					catch(::Platform::Exception^ e)
+					{
+						int __hr = e->HResult;
+						if (__hr == 0x800706BA /* HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE) */
+								|| __hr == 0x80010108 /* RPC_E_DISCONNECTED */
+									|| __hr == 0x89020001 /* JSCRIPT_E_CANTEXECUTE */)
+						{
+							Details::EventSourceRemove(&__targets, __lockArg, __token);
+						}
+						else
+						{
+							throw e;
+						}
+					}
+				}
+			}
+			return __returnVal;
+		}
+
+		// __TInvokeMethod is a functor that performs the appropriate invoke, depending on the
+		// number of arguments specified.
+		template <typename __TDelegate, typename __TInvokeMethod>
+		void DoInvokeVoid(Details::EventLock* __lockArg, __TInvokeMethod __invokeOneArg)
+		{
+			// lock pointer exhange
+			//        targets = _targets
+			// unlock pointer exhange
+			// iterate all targets and do invoke
+
+			// The _targetsPointerLock protects the acquisition of an AddRef'd pointer to
+			// "current list".  An Add/Remove operation may occur during the
+			// firing of events (but occurs on a copy of the list).  i.e. both
+			// Invoke/invoke and Add/Remove are readers of the "current list".
+			// NOTE:  EventSource::Invoke(...) must never take the _addRemoveLock.
+			::Platform::Object^ __targetsLoc;
+			// Attaching Array without AddRef'ing
+
+			// In order to prevent a load of __targets while unprotected by __targetsLock,
+			// we must take the lock externally to the call to EventSourceGetTargetArray.
+			// We then pass in a dummy lock instead of the real lock in order to prevent
+			// recursive acquisition. This fix was made to avoid modifying vccorlib.dll.
+			// On the next binary breaking change, the Details::EventSourceGetTargetArray
+			// call interface should be modified to take __targets by pointer instead of
+			// by value.
+			Details::EventLock __dummylock = { nullptr, nullptr };
+			__Platform_AcquireSRWLockShared(&__lockArg->__targetsLock);
+			void* __EvSrcGTA_ret = Details::EventSourceGetTargetArray(__targets, &__dummylock);
+			__Platform_ReleaseSRWLockShared(&__lockArg->__targetsLock);
+			*reinterpret_cast<void**>(&__targetsLoc) = __EvSrcGTA_ret;
+
+			// The list may not exist if nobody has registered
+			if (__targetsLoc != nullptr)
+			{
+				const unsigned int __size = Details::EventSourceGetTargetArraySize(reinterpret_cast<void*>(__targetsLoc));
+
+				for (unsigned int __index = 0; __index < __size; __index++)
+				{
+					::Windows::Foundation::EventRegistrationToken __token = {};
+
+					try
+					{
+						__TDelegate^ __element;
+						*reinterpret_cast<void**>(&__element) = Details::EventSourceGetTargetArrayEvent(
+								reinterpret_cast<void*>(__targetsLoc),
+								__index,
+								reinterpret_cast<const void*>(&__uuidof(__TDelegate^)),
+								&__token.Value
+							);
+
+						(__invokeOneArg)(__element);
+					}
+					catch(::Platform::Exception^ e)
+					{
+						int __hr = e->HResult;
+						if (__hr == 0x800706BA /* HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE) */
+								|| __hr == 0x80010108 /* RPC_E_DISCONNECTED */
+									|| __hr == 0x89020001 /* JSCRIPT_E_CANTEXECUTE */)
+						{
+							Details::EventSourceRemove(&__targets, __lockArg, __token);
+						}
+						else
+						{
+							throw e;
+						}
+					}
+				}
+			}
+		}
+
+	public:
+		template < typename __TLambda, typename... __TArgs >
+		void InvokeVoid(Details::EventLock* __lockArg, __TArgs... __args)
+		{
+			DoInvokeVoid<__TLambda>(__lockArg, [__args...](__TLambda^ __lambda) -> void { __lambda(__args...); });
+		}
+
+		template < typename __TLambda, typename __TReturnType, typename... __TArgs >
+		__TReturnType Invoke(Details::EventLock* __lockArg, __TArgs... __args)
+		{
+			return DoInvoke<__TLambda, __TReturnType>(__lockArg, [__args...](__TLambda^ __lambda) -> __TReturnType { return __lambda(__args...); });
+		}
+
+	protected:
+		void* __targets;
+	};
+
+	class Module
+	{
+	public:
+		typedef void (__stdcall *UnregisterCallback)();
+		static ::Platform::Object^ __stdcall RegisterFactories(UnregisterCallback callback = nullptr);
+		static void __stdcall RunServer(const ::default::char16* __serverName = nullptr);
+		static ::Platform::Details::IActivationFactory^ __stdcall GetActivationFactory(::Platform::String^);
+		static bool __stdcall CanUnloadNow();
+		static void __stdcall FlushFactoryCache();
+	};
+
+	inline ::default::int32 Exception::HResult::get()
+	{
+		return __hresult;
+	}
+
+	class WeakReference
+	{
+	private:
+		mutable __abi_IUnknown* __weakPtr;
+
+		void InternalAddRef()
+		{
+			if (__weakPtr != nullptr)
+			{
+				__weakPtr->__abi_AddRef();
+			}
+		}
+
+		void InternalRelease()
+		{
+			__abi_IUnknown* __tmp = __weakPtr;
+			if (__tmp != nullptr)
+			{
+				__weakPtr = nullptr;
+				__tmp->__abi_Release();
+			}
+		}
+	public:
+		struct BoolStruct
+		{
+			int Member;
+		};
+
+		typedef int BoolStruct::* BoolType;
+
+		WeakReference() throw() : __weakPtr(nullptr)
+		{
+		}
+
+		WeakReference(decltype(__nullptr)) throw() : __weakPtr(nullptr)
+		{
+		}
+
+		WeakReference(const WeakReference& __otherArg) throw() : __weakPtr(__otherArg.__weakPtr)
+		{
+			InternalAddRef();
+		}
+
+		WeakReference(WeakReference&& __otherArg) throw() : __weakPtr(__otherArg.__weakPtr)
+		{
+			__otherArg.__weakPtr = nullptr;
+		}
+
+		explicit WeakReference(const volatile ::Platform::Object^ const __otherArg) : __weakPtr(nullptr)
+		{
+			__weakPtr = Details::GetWeakReference(__otherArg);
+		}
+
+		~WeakReference() throw()
+		{
+			InternalRelease();
+		}
+
+		WeakReference& operator=(decltype(__nullptr)) throw()
+		{
+			InternalRelease();
+			return *this;
+		}
+
+		WeakReference& operator=(const WeakReference& __otherArg) throw()
+		{
+			if (&__otherArg != this)
+			{
+				InternalRelease();
+				__weakPtr = __otherArg.__weakPtr;
+				InternalAddRef();
+			}
+			return *this;
+		}
+
+		WeakReference& operator=(WeakReference&& __otherArg) throw()
+		{
+			InternalRelease();
+			__weakPtr = __otherArg.__weakPtr;
+			__otherArg.__weakPtr = nullptr;
+			return *this;
+		}
+
+		WeakReference& operator=(const volatile ::Platform::Object^ const __otherArg)
+		{
+			__abi_IUnknown* __weakPtrLoc = Details::GetWeakReference(__otherArg);
+			InternalRelease();
+			__weakPtr = __weakPtrLoc;
+			return *this;
+		}
+
+		template<typename __TArg>
+		__declspec(no_refcount)
+			__TArg^ Resolve() const
+		{
+			return reinterpret_cast<__TArg^>(Details::ResolveWeakReference(__uuidof(__TArg^), &__weakPtr));
+		}
+
+		operator BoolType() const throw()
+		{
+			return __weakPtr != nullptr ? &BoolStruct::Member : nullptr;
+		}
+
+		friend bool operator==(const WeakReference&, const WeakReference&) throw();
+		friend bool operator==(const WeakReference&, decltype(__nullptr)) throw();
+		friend bool operator==(decltype(__nullptr), const WeakReference&) throw();
+		friend bool operator!=(const WeakReference&, const WeakReference&) throw();
+		friend bool operator!=(const WeakReference&, decltype(__nullptr)) throw();
+		friend bool operator!=(decltype(__nullptr), const WeakReference&) throw();
+		friend bool operator<(const WeakReference&, const WeakReference&) throw();
+	};
+
+	inline bool operator==(const WeakReference& __aArg, const WeakReference& __bArg) throw()
+	{
+		return __aArg.__weakPtr == __bArg.__weakPtr;
+	}
+
+	inline bool operator==(const WeakReference& __aArg, decltype(__nullptr)) throw()
+	{
+		return __aArg.__weakPtr == nullptr;
+	}
+
+	inline bool operator==(decltype(__nullptr), const WeakReference& __bArg) throw()
+	{
+		return __bArg.__weakPtr == nullptr;
+	}
+
+	inline bool operator!=(const WeakReference& __aArg, const WeakReference& __bArg) throw()
+	{
+		return __aArg.__weakPtr != __bArg.__weakPtr;
+	}
+
+	inline bool operator!=(const WeakReference& __aArg, decltype(__nullptr)) throw()
+	{
+		return __aArg.__weakPtr != nullptr;
+	}
+
+	inline bool operator!=(decltype(__nullptr), const WeakReference& __bArg) throw()
+	{
+		return __bArg.__weakPtr != nullptr;
+	}
+
+	inline bool operator<(const WeakReference& __aArg, const WeakReference& __bArg) throw()
+	{
+		return __aArg.__weakPtr < __bArg.__weakPtr;
+	}
+} // namespace Platform
+
+namespace Windows { namespace Foundation
+{
+	inline Point::Point(float __xArg, float __yArg) : X(__xArg), Y(__yArg)
+	{
+	}
+
+	inline bool Point::operator ==(Point __point1Arg, Point __point2Arg)
+	{
+		return __point1Arg.X == __point2Arg.X && __point1Arg.Y == __point2Arg.Y;
+	}
+
+	inline bool Point::operator !=(Point __point1Arg, Point __point2Arg)
+	{
+		return !(__point1Arg == __point2Arg);
+	}
+
+	// Size
+	inline Size::Size(float __widthArg, float __heightArg)
+	{
+		if (__widthArg < 0 || __heightArg < 0)
+		{
+			__abi_WinRTraiseInvalidArgumentException();
+		}
+
+		Width = __widthArg;
+		Height = __heightArg;
+	}
+
+	inline bool Size::IsEmpty::get()
+	{
+		return Width < 0;
+	}
+
+	inline bool Size::operator ==(Size __size1Arg, Size __size2Arg)
+	{
+		return __size1Arg.Height == __size2Arg.Height && __size1Arg.Width == __size2Arg.Width;
+	}
+
+	inline bool Size::operator !=(Size __size1Arg, Size __size2Arg)
+	{
+		return !(__size1Arg == __size2Arg);
+	}
+
+	inline Rect::Rect(float __xArg, float __yArg, float __widthArg, float __heightArg)
+	{
+		if (__widthArg < 0 || __heightArg < 0)
+		{
+			__abi_WinRTraiseInvalidArgumentException();
+		}
+
+		X = __xArg;
+		Y = __yArg;
+		Width = __widthArg;
+		Height = __heightArg;
+	}
+
+	inline bool Rect::IsEmpty::get()
+	{
+		return Width < 0;
+	}
+
+	inline float Rect::Left::get()
+	{
+		return X;
+	}
+
+	inline float Rect::Top::get()
+	{
+		return Y;
+	}
+
+	inline bool Rect::operator ==(Rect __rect1Arg, Rect __rect2Arg)
+	{
+		return __rect1Arg.X == __rect2Arg.X
+			&& __rect1Arg.Y == __rect2Arg.Y
+			&& __rect1Arg.Width == __rect2Arg.Width
+			&& __rect1Arg.Height == __rect2Arg.Height;
+	}
+
+	inline bool Rect::operator !=(Rect __rect1Arg, Rect __rect2Arg)
+	{
+		return !(__rect1Arg == __rect2Arg);
+	}
+} } // namespace Windows::Foundation
+
+namespace Windows { namespace UI { namespace Xaml
+{
+	inline Thickness::Thickness(double __uniformLengthArg)
+	{
+		Left = Top = Right = Bottom = __uniformLengthArg;
+	}
+
+	inline Thickness::Thickness(double __leftArg, double __topArg, double __rightArg, double __bottomArg)
+	{
+		Left = __leftArg;
+		Top = __topArg;
+		Right = __rightArg;
+		Bottom = __bottomArg;
+	}
+
+	inline bool Thickness::operator==(Thickness __thickness1Arg, Thickness __thickness2Arg)
+	{
+		return __thickness1Arg.Left == __thickness2Arg.Left &&
+			__thickness1Arg.Top == __thickness2Arg.Top &&
+			__thickness1Arg.Right == __thickness2Arg.Right &&
+			__thickness1Arg.Bottom == __thickness2Arg.Bottom;
+	}
+
+	inline bool Thickness::operator!=(Thickness __thickness1Arg, Thickness __thickness2Arg)
+	{
+		return !(__thickness1Arg == __thickness2Arg);
+	}
+
+	inline CornerRadius::CornerRadius(double __uniformRadiusArg)
+	{
+		TopLeft = TopRight = BottomRight = BottomLeft = __uniformRadiusArg;
+	}
+
+	inline CornerRadius::CornerRadius(double __topLeftArg, double __topRightArg, double __bottomRightArg, double __bottomLeftArg)
+	{
+		TopLeft = __topLeftArg;
+		TopRight = __topRightArg;
+		BottomRight = __bottomRightArg;
+		BottomLeft = __bottomLeftArg;
+	}
+
+	inline bool CornerRadius::operator==(CornerRadius __cornerRadius1Arg, CornerRadius __cornerRadius2Arg)
+	{
+		return __cornerRadius1Arg.TopLeft == __cornerRadius2Arg.TopLeft &&
+			__cornerRadius1Arg.TopRight == __cornerRadius2Arg.TopRight &&
+			__cornerRadius1Arg.BottomRight == __cornerRadius2Arg.BottomRight &&
+			__cornerRadius1Arg.BottomLeft == __cornerRadius2Arg.BottomLeft;
+	}
+
+	inline bool CornerRadius::operator!=(CornerRadius __cornerRadius1Arg, CornerRadius __cornerRadius2Arg)
+	{
+		return !(__cornerRadius1Arg == __cornerRadius2Arg);
+	}
+
+	namespace Media
+	{
+		inline Matrix Matrix::Identity::get()
+		{
+			return Matrix(1, 0, 0, 1, 0, 0);
+		}
+
+		inline bool Matrix::IsIdentity::get()
+		{
+			return M11 == 1 &&
+				M12 == 0 &&
+				M21 == 0 &&
+				M22 == 1 &&
+				OffsetX == 0 &&
+				OffsetY == 0;
+		}
+
+		inline Windows::Foundation::Point Matrix::Transform(Windows::Foundation::Point __pointArg)
+		{
+			float x = __pointArg.X;
+			float y = __pointArg.Y;
+			double num = (y * M21) + OffsetX;
+			double num2 = (x * M12) + OffsetY;
+			x *= (float)M11;
+			x += (float)num;
+			y *= (float)M22;
+			y += (float)num2;
+			return Windows::Foundation::Point(x, y);
+		}
+
+		inline Matrix::Matrix(double __m11Arg, double __m12Arg, double __m21Arg, double __m22Arg, double __offsetXArg, double __offsetYArg)
+		{
+			M11 = __m11Arg;
+			M12 = __m12Arg;
+			M21 = __m21Arg;
+			M22 = __m22Arg;
+			OffsetX = __offsetXArg;
+			OffsetY = __offsetYArg;
+		}
+
+		inline bool Matrix::operator==(Matrix __matrix1Arg, Matrix __matrix2Arg)
+		{
+			return
+				__matrix1Arg.M11 == __matrix2Arg.M11 &&
+				__matrix1Arg.M12 == __matrix2Arg.M12 &&
+				__matrix1Arg.M21 == __matrix2Arg.M21 &&
+				__matrix1Arg.M22 == __matrix2Arg.M22 &&
+				__matrix1Arg.OffsetX == __matrix2Arg.OffsetX &&
+				__matrix1Arg.OffsetY == __matrix2Arg.OffsetY;
+		}
+
+		inline bool Matrix::operator!=(Matrix __matrix1Arg, Matrix __matrix2Arg)
+		{
+			return !(__matrix1Arg == __matrix2Arg);
+		}
+
+		namespace Media3D
+		{
+			inline Matrix3D Matrix3D::Identity::get()
+			{
+				return Matrix3D(1, 0, 0, 0,
+					0, 1, 0, 0,
+					0, 0, 1, 0,
+					0, 0, 0, 1);
+			}
+
+			inline bool Matrix3D::IsIdentity::get()
+			{
+				return M11 == 1 && M12 == 0 && M13 == 0 && M14 == 0 &&
+					M21 == 0 && M22 == 1 && M23 == 0 && M24 == 0 &&
+					M31 == 0 && M32 == 0 && M33 == 1 && M34 == 0 &&
+					OffsetX == 0 && OffsetY == 0 && OffsetZ == 0 && M44 == 1;
+			}
+
+			inline Matrix3D::Matrix3D(double __m11Arg, double __m12Arg, double __m13Arg, double __m14Arg,
+				double __m21Arg, double __m22Arg, double __m23Arg, double __m24Arg,
+				double __m31Arg, double __m32Arg, double __m33Arg, double __m34Arg,
+				double __offsetXArg, double __offsetYArg, double __offsetZArg, double __m44Arg)
+			{
+				M11 = __m11Arg;
+				M12 = __m12Arg;
+				M13 = __m13Arg;
+				M14 = __m14Arg;
+				M21 = __m21Arg;
+				M22 = __m22Arg;
+				M23 = __m23Arg;
+				M24 = __m24Arg;
+				M31 = __m31Arg;
+				M32 = __m32Arg;
+				M33 = __m33Arg;
+				M34 = __m34Arg;
+				OffsetX = __offsetXArg;
+				OffsetY = __offsetYArg;
+				OffsetZ = __offsetZArg;
+				M44 = __m44Arg;
+			}
+
+			inline bool Matrix3D::operator==(Matrix3D __matrix1Arg, Matrix3D __matrix2Arg)
+			{
+				return
+					__matrix1Arg.M11 == __matrix2Arg.M11 &&
+					__matrix1Arg.M12 == __matrix2Arg.M12 &&
+					__matrix1Arg.M13 == __matrix2Arg.M13 &&
+					__matrix1Arg.M14 == __matrix2Arg.M14 &&
+					__matrix1Arg.M21 == __matrix2Arg.M21 &&
+					__matrix1Arg.M22 == __matrix2Arg.M22 &&
+					__matrix1Arg.M23 == __matrix2Arg.M23 &&
+					__matrix1Arg.M24 == __matrix2Arg.M24 &&
+					__matrix1Arg.M31 == __matrix2Arg.M31 &&
+					__matrix1Arg.M32 == __matrix2Arg.M32 &&
+					__matrix1Arg.M33 == __matrix2Arg.M33 &&
+					__matrix1Arg.M34 == __matrix2Arg.M34 &&
+					__matrix1Arg.OffsetX == __matrix2Arg.OffsetX &&
+					__matrix1Arg.OffsetY == __matrix2Arg.OffsetY &&
+					__matrix1Arg.OffsetZ == __matrix2Arg.OffsetZ &&
+					__matrix1Arg.M44 == __matrix2Arg.M44;
+			}
+
+			inline bool Matrix3D::operator!=(Matrix3D __matrix1Arg, Matrix3D __matrix2Arg)
+			{
+				return !(__matrix1Arg == __matrix2Arg);
+			}
+		} // Media3D
+
+		namespace Animation
+		{
+			inline KeyTime::KeyTime(Windows::Foundation::TimeSpan __timeSpanArg)
+			{
+				if (__timeSpanArg.Duration < 0 )
+				{
+					__abi_WinRTraiseInvalidArgumentException();
+				}
+				TimeSpan = __timeSpanArg;
+			}
+
+			inline bool KeyTime::operator==(KeyTime __keyTime1Arg, KeyTime __keyTime2Arg)
+			{
+				return __keyTime1Arg.TimeSpan.Duration == __keyTime2Arg.TimeSpan.Duration;
+			}
+
+			inline bool KeyTime::operator!=(KeyTime __keyTime1Arg, KeyTime __keyTime2Arg)
+			{
+				return !(__keyTime1Arg == __keyTime2Arg);
+			}
+
+			inline RepeatBehavior::RepeatBehavior(Windows::Foundation::TimeSpan __durationArg)
+			{
+				if (__durationArg.Duration < 0 )
+				{
+					__abi_WinRTraiseInvalidArgumentException();
+				}
+
+				__duration = __durationArg;
+				__count = 0.0;
+				__type = RepeatBehaviorType::Duration;
+			}
+
+			inline double RepeatBehavior::Count::get()
+			{
+				return __count;
+			}
+
+			inline Windows::Foundation::TimeSpan RepeatBehavior::Duration::get()
+			{
+				return __duration;
+			}
+
+			inline RepeatBehaviorType RepeatBehavior::Type::get()
+			{
+				return __type;
+			}
+
+			inline RepeatBehavior RepeatBehavior::Forever::get()
+			{
+				RepeatBehavior forever;
+				Windows::Foundation::TimeSpan ts = {0};
+				forever.__duration = ts;
+				forever.__count = 0.0;
+				forever.__type = RepeatBehaviorType::Forever;
+
+				return forever;
+			}
+
+			inline bool RepeatBehavior::HasCount::get()
+			{
+				return __type == RepeatBehaviorType::Count;
+			}
+
+			inline bool RepeatBehavior::HasDuration::get()
+			{
+				return __type == RepeatBehaviorType::Duration;
+			}
+
+
+			inline bool RepeatBehavior::operator ==(RepeatBehavior __repeatBehavior1Arg, RepeatBehavior __repeatBehavior2Arg)
+			{
+				if (__repeatBehavior1Arg.__type == __repeatBehavior2Arg.__type)
+				{
+					switch (__repeatBehavior1Arg.__type)
+					{
+					case RepeatBehaviorType::Forever:
+						return true;
+
+					case RepeatBehaviorType::Count:
+						return __repeatBehavior1Arg.__count == __repeatBehavior2Arg.__count;
+
+					case RepeatBehaviorType::Duration:
+
+						return __repeatBehavior1Arg.__duration.Duration == __repeatBehavior2Arg.__duration.Duration;
+
+					default:
+						return false;
+					}
+				}
+				else
+				{
+					return false;
+				}
+			}
+
+			inline bool RepeatBehavior::operator !=(RepeatBehavior __repeatBehavior1Arg, RepeatBehavior __repeatBehavior2Arg)
+			{
+				return !(__repeatBehavior1Arg == __repeatBehavior2Arg);
+			}
+
+		} // Animation
+	} // Media
+
+	inline Duration::Duration(Windows::Foundation::TimeSpan __timeSpanArg)
+	{
+		__durationType = DurationType::TimeSpan;
+		__timeSpan = __timeSpanArg;
+	}
+
+	inline bool Duration::operator ==(Duration __t1Arg, Duration __t2Arg)
+	{
+		if (__t1Arg.HasTimeSpan)
+		{
+			if (__t2Arg.HasTimeSpan)
+			{
+				return __t1Arg.__timeSpan.Duration == __t2Arg.__timeSpan.Duration;
+			}
+			else
+			{
+				return false;
+			}
+		}
+		else
+		{
+			return __t1Arg.__durationType == __t2Arg.__durationType;
+		}
+	}
+
+	inline bool Duration::operator !=(Duration __t1Arg, Duration __t2Arg)
+	{
+		return !(__t1Arg == __t2Arg);
+	}
+
+	inline bool Duration::HasTimeSpan::get()
+	{
+		return (__durationType == DurationType::TimeSpan);
+	}
+
+	inline Duration Duration::Automatic::get()
+	{
+		Duration __duration;
+		__duration.__durationType = DurationType::Automatic;
+
+		return __duration;
+	}
+
+	inline Duration Duration::Forever::get()
+	{
+		Duration __duration;
+		__duration.__durationType = DurationType::Forever;
+
+		return __duration;
+	}
+
+	inline Windows::Foundation::TimeSpan Duration::TimeSpan::get()
+	{
+		if (HasTimeSpan)
+		{
+			return __timeSpan;
+		}
+		else
+		{
+			Windows::Foundation::TimeSpan __timeSpanLoc;
+			__timeSpanLoc.Duration = 0;
+			return __timeSpanLoc;
+		}
+	}
+
+	inline GridLength::GridLength(double __pixelsArg)
+	{
+		*this = GridLength(__pixelsArg, Windows::UI::Xaml::GridUnitType::Pixel);
+	}
+
+	inline double GridLength::Value::get()
+	{
+		return (__unitType == Windows::UI::Xaml::GridUnitType::Auto ) ? GridLength(1.0, Windows::UI::Xaml::GridUnitType::Auto).__unitValue : __unitValue;
+	}
+
+	inline Windows::UI::Xaml::GridUnitType GridLength::GridUnitType::get()
+	{
+		return (__unitType);
+	}
+
+	inline bool GridLength::IsAbsolute::get()
+	{
+		return (__unitType == Windows::UI::Xaml::GridUnitType::Pixel);
+	}
+
+	inline bool GridLength::IsAuto::get()
+	{
+		return (__unitType == Windows::UI::Xaml::GridUnitType::Auto);
+	}
+
+	inline bool GridLength::IsStar::get()
+	{
+		return (__unitType == Windows::UI::Xaml::GridUnitType::Star) ;
+	}
+
+	inline GridLength GridLength::Auto::get()
+	{
+		return ( GridLength(1.0, Windows::UI::Xaml::GridUnitType::Auto));
+	}
+
+	inline bool GridLength::operator ==(GridLength __gridLength1Arg, GridLength __gridLength2Arg)
+	{
+		if (__gridLength1Arg.GridUnitType == __gridLength2Arg.GridUnitType)
+		{
+			if (__gridLength1Arg.IsAuto || __gridLength1Arg.__unitValue == __gridLength2Arg.__unitValue)
+			{
+				return true;
+			}
+		}
+		return false;
+	}
+
+	inline bool GridLength::operator !=(GridLength __gridLength1Arg, GridLength __gridLength2Arg)
+	{
+		return !(__gridLength1Arg == __gridLength2Arg);
+	}
+} } } // Windows::UI::Xaml
+
+// Don't pull in any symbols if it's vccorlib compiled
+#if !defined(VCWINRT_DLL)
+#ifdef _WINRT_DLL
+	// DLL
+	#ifdef _M_IX86
+		#pragma comment(linker, "/EXPORT:DllGetActivationFactory=_DllGetActivationFactory@8,PRIVATE")
+		#pragma comment(linker, "/EXPORT:DllCanUnloadNow=_DllCanUnloadNow@0,PRIVATE")
+	#else
+		#pragma comment(linker, "/EXPORT:DllGetActivationFactory=DllGetActivationFactory,PRIVATE")
+		#pragma comment(linker, "/EXPORT:DllCanUnloadNow,PRIVATE")
+	#endif
+#else
+	#ifdef _M_IX86
+		#pragma comment(linker, "/INCLUDE:___abi__initialize")
+	#else
+		#pragma comment(linker, "/INCLUDE:__abi__initialize")
+	#endif // _M_IX86
+#endif // _WINRT_DLL
+
+#if defined(_DEBUG)
+	#pragma comment(lib, "vccorlibd.lib")
+#else
+	#pragma comment(lib, "vccorlib.lib")
+#endif  // DEBUG
+#endif  // !defined(VCWINRT_DLL)
+
+#pragma pack(pop)
+
+#pragma initialize_winrt_types_done
+
+// Restore warnings disabled for this file to their original settings
+#pragma warning( pop )
+
+#if defined(__VCCORLIB_H_ENABLE_ALL_WARNINGS)
+#pragma warning(pop)
+#endif
+
+#endif // _VCCORLIB_H_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime.h
new file mode 100644
index 0000000000000000000000000000000000000000..4d95b1be0498df70d17a460547b66371bfbe46cb
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime_c11_atomic_support.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime_c11_atomic_support.h
new file mode 100644
index 0000000000000000000000000000000000000000..0b649ed0eae3eb532a425039df44d0d8e02b7044
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime_c11_stdatomic.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime_c11_stdatomic.h
new file mode 100644
index 0000000000000000000000000000000000000000..45baf04a52c36b57bbfda9e2eef282345fca46fd
--- /dev/null
+++ b/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)
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime_exception.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime_exception.h
new file mode 100644
index 0000000000000000000000000000000000000000..9d51cbb35388e0ff3620313a42de97036c34df0d
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime_new.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime_new.h
new file mode 100644
index 0000000000000000000000000000000000000000..de4f2629a0ded8aeb57148ebe6b0c8832769c17d
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime_new_debug.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime_new_debug.h
new file mode 100644
index 0000000000000000000000000000000000000000..14a75005df6fe99d421d6f7dd2193277670fe863
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime_startup.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime_startup.h
new file mode 100644
index 0000000000000000000000000000000000000000..bb8e89a8b384b58cfde01e31fa619633d2242b3d
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime_string.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime_string.h
new file mode 100644
index 0000000000000000000000000000000000000000..3cc25d467673e6fb3227616712ca822b5e0ada2b
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime_typeinfo.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vcruntime_typeinfo.h
new file mode 100644
index 0000000000000000000000000000000000000000..6736f61774b65c63c810d2897db596fd569d2381
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vector b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vector
new file mode 100644
index 0000000000000000000000000000000000000000..141068db91667062c749eeb4a5385433e4fa0630
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/vector
@@ -0,0 +1,3928 @@
+// vector standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _VECTOR_
+#define _VECTOR_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <__msvc_bit_utils.hpp>
+#include <__msvc_sanitizer_annotate_container.hpp>
+#include <xmemory>
+
+#if _HAS_CXX17
+#include <xpolymorphic_allocator.h>
+#endif // _HAS_CXX17
+
+#if _HAS_CXX23
+#include <__msvc_formatter.hpp>
+#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
+template <class _Myvec>
+class _Vector_const_iterator : public _Iterator_base {
+public:
+#if _HAS_CXX20
+    using iterator_concept = contiguous_iterator_tag;
+#endif // _HAS_CXX20
+    using iterator_category = random_access_iterator_tag;
+    using value_type        = typename _Myvec::value_type;
+    using difference_type   = typename _Myvec::difference_type;
+    using pointer           = typename _Myvec::const_pointer;
+    using reference         = const value_type&;
+
+    using _Tptr = typename _Myvec::pointer;
+
+    _CONSTEXPR20 _Vector_const_iterator() noexcept : _Ptr() {}
+
+    _CONSTEXPR20 _Vector_const_iterator(_Tptr _Parg, const _Container_base* _Pvector) noexcept : _Ptr(_Parg) {
+        this->_Adopt(_Pvector);
+    }
+
+    _NODISCARD _CONSTEXPR20 reference operator*() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Mycont = static_cast<const _Myvec*>(this->_Getcont());
+        _STL_VERIFY(_Ptr, "can't dereference value-initialized vector iterator");
+        _STL_VERIFY(_Mycont, "can't dereference invalidated vector iterator");
+        _STL_VERIFY(
+            _Mycont->_Myfirst <= _Ptr && _Ptr < _Mycont->_Mylast, "can't dereference out of range vector iterator");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        return *_Ptr;
+    }
+
+    _NODISCARD _CONSTEXPR20 pointer operator->() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Mycont = static_cast<const _Myvec*>(this->_Getcont());
+        _STL_VERIFY(_Ptr, "can't dereference value-initialized vector iterator");
+        _STL_VERIFY(_Mycont, "can't dereference invalidated vector iterator");
+        _STL_VERIFY(
+            _Mycont->_Myfirst <= _Ptr && _Ptr < _Mycont->_Mylast, "can't dereference out of range vector iterator");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        return _Ptr;
+    }
+
+    _CONSTEXPR20 _Vector_const_iterator& operator++() noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Mycont = static_cast<const _Myvec*>(this->_Getcont());
+        _STL_VERIFY(_Ptr, "can't increment value-initialized vector iterator");
+        _STL_VERIFY(_Mycont, "can't increment invalidated vector iterator");
+        _STL_VERIFY(_Ptr < _Mycont->_Mylast, "can't increment vector iterator past end");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        ++_Ptr;
+        return *this;
+    }
+
+    _CONSTEXPR20 _Vector_const_iterator operator++(int) noexcept {
+        _Vector_const_iterator _Tmp = *this;
+        ++*this;
+        return _Tmp;
+    }
+
+    _CONSTEXPR20 _Vector_const_iterator& operator--() noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Mycont = static_cast<const _Myvec*>(this->_Getcont());
+        _STL_VERIFY(_Ptr, "can't decrement value-initialized vector iterator");
+        _STL_VERIFY(_Mycont, "can't decrement invalidated vector iterator");
+        _STL_VERIFY(_Mycont->_Myfirst < _Ptr, "can't decrement vector iterator before begin");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        --_Ptr;
+        return *this;
+    }
+
+    _CONSTEXPR20 _Vector_const_iterator operator--(int) noexcept {
+        _Vector_const_iterator _Tmp = *this;
+        --*this;
+        return _Tmp;
+    }
+
+    _CONSTEXPR20 void _Verify_offset(const difference_type _Off) const noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 0
+        (void) _Off;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 0 / _ITERATOR_DEBUG_LEVEL != 0 vvv
+        const auto _Mycont = static_cast<const _Myvec*>(this->_Getcont());
+        _STL_VERIFY(_Off == 0 || _Ptr, "cannot seek value-initialized vector iterator");
+        _STL_VERIFY(_Off == 0 || _Mycont, "cannot seek invalidated vector iterator");
+        if (_Off < 0) {
+            _STL_VERIFY(_Off >= _Mycont->_Myfirst - _Ptr, "cannot seek vector iterator before begin");
+        }
+
+        if (_Off > 0) {
+            _STL_VERIFY(_Off <= _Mycont->_Mylast - _Ptr, "cannot seek vector iterator after end");
+        }
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 0 ^^^
+    }
+
+    _CONSTEXPR20 _Vector_const_iterator& operator+=(const difference_type _Off) noexcept {
+        _Verify_offset(_Off);
+        _Ptr += _Off;
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR20 _Vector_const_iterator operator+(const difference_type _Off) const noexcept {
+        _Vector_const_iterator _Tmp = *this;
+        _Tmp += _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD friend _CONSTEXPR20 _Vector_const_iterator operator+(
+        const difference_type _Off, _Vector_const_iterator _Next) noexcept {
+        _Next += _Off;
+        return _Next;
+    }
+
+    _CONSTEXPR20 _Vector_const_iterator& operator-=(const difference_type _Off) noexcept {
+        return *this += -_Off;
+    }
+
+    _NODISCARD _CONSTEXPR20 _Vector_const_iterator operator-(const difference_type _Off) const noexcept {
+        _Vector_const_iterator _Tmp = *this;
+        _Tmp -= _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD _CONSTEXPR20 difference_type operator-(const _Vector_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return static_cast<difference_type>(_Ptr - _Right._Ptr);
+    }
+
+    _NODISCARD _CONSTEXPR20 reference operator[](const difference_type _Off) const noexcept {
+        return *(*this + _Off);
+    }
+
+    _NODISCARD _CONSTEXPR20 bool operator==(const _Vector_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return _Ptr == _Right._Ptr;
+    }
+
+#if _HAS_CXX20
+    _NODISCARD constexpr strong_ordering operator<=>(const _Vector_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return _STD _Unfancy_maybe_null(_Ptr) <=> _STD _Unfancy_maybe_null(_Right._Ptr);
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD bool operator!=(const _Vector_const_iterator& _Right) const noexcept {
+        return !(*this == _Right);
+    }
+
+    _NODISCARD bool operator<(const _Vector_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return _Ptr < _Right._Ptr;
+    }
+
+    _NODISCARD bool operator>(const _Vector_const_iterator& _Right) const noexcept {
+        return _Right < *this;
+    }
+
+    _NODISCARD bool operator<=(const _Vector_const_iterator& _Right) const noexcept {
+        return !(_Right < *this);
+    }
+
+    _NODISCARD bool operator>=(const _Vector_const_iterator& _Right) const noexcept {
+        return !(*this < _Right);
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    _CONSTEXPR20 void _Compat(const _Vector_const_iterator& _Right) const noexcept {
+        // test for compatible iterator pair
+#if _ITERATOR_DEBUG_LEVEL == 0
+        (void) _Right;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 0 / _ITERATOR_DEBUG_LEVEL != 0 vvv
+        _STL_VERIFY(this->_Getcont() == _Right._Getcont(), "vector iterators incompatible");
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 0 ^^^
+    }
+
+#if _ITERATOR_DEBUG_LEVEL != 0
+    friend _CONSTEXPR20 void _Verify_range(
+        const _Vector_const_iterator& _First, const _Vector_const_iterator& _Last) noexcept {
+        _STL_VERIFY(_First._Getcont() == _Last._Getcont(), "vector iterators in range are from different containers");
+        _STL_VERIFY(_First._Ptr <= _Last._Ptr, "vector iterator range transposed");
+    }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+    using _Prevent_inheriting_unwrap = _Vector_const_iterator;
+
+    _NODISCARD _CONSTEXPR20 const value_type* _Unwrapped() const noexcept {
+        return _STD _Unfancy_maybe_null(_Ptr);
+    }
+
+    _CONSTEXPR20 void _Seek_to(const value_type* _It) noexcept {
+        _Ptr = _STD _Refancy_maybe_null<_Tptr>(const_cast<value_type*>(_It));
+    }
+
+    _Tptr _Ptr; // pointer to element in vector
+};
+
+#if _HAS_CXX20
+template <class _Myvec>
+struct pointer_traits<_Vector_const_iterator<_Myvec>> {
+    using pointer         = _Vector_const_iterator<_Myvec>;
+    using element_type    = const pointer::value_type;
+    using difference_type = pointer::difference_type;
+
+    _NODISCARD static constexpr element_type* to_address(const pointer _Iter) noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        // A value-initialized iterator is in the domain of to_address. An invalidated end iterator for a vector with
+        // capacity() of 0 is not. This function cannot distinguish those two cases, so it incorrectly does not diagnose
+        // the latter. In practice, this isn't a significant problem since to_address returns nullptr for such an
+        // iterator.
+        const auto _Mycont = static_cast<const _Myvec*>(_Iter._Getcont());
+        if (_Mycont) {
+            _STL_VERIFY(_Mycont->_Myfirst <= _Iter._Ptr && _Iter._Ptr <= _Mycont->_Mylast,
+                "can't convert out-of-range vector iterator to pointer");
+        } else {
+            _STL_VERIFY(!_Iter._Ptr, "can't convert invalid vector iterator to pointer");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        return _STD to_address(_Iter._Ptr);
+    }
+};
+#endif // _HAS_CXX20
+
+template <class _Myvec>
+class _Vector_iterator : public _Vector_const_iterator<_Myvec> {
+public:
+    using _Mybase = _Vector_const_iterator<_Myvec>;
+
+#if _HAS_CXX20
+    using iterator_concept = contiguous_iterator_tag;
+#endif // _HAS_CXX20
+    using iterator_category = random_access_iterator_tag;
+    using value_type        = typename _Myvec::value_type;
+    using difference_type   = typename _Myvec::difference_type;
+    using pointer           = typename _Myvec::pointer;
+    using reference         = value_type&;
+
+    using _Mybase::_Mybase;
+
+    _NODISCARD _CONSTEXPR20 reference operator*() const noexcept {
+        return const_cast<reference>(_Mybase::operator*());
+    }
+
+    _NODISCARD _CONSTEXPR20 pointer operator->() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Mycont = static_cast<const _Myvec*>(this->_Getcont());
+        _STL_VERIFY(this->_Ptr, "can't dereference value-initialized vector iterator");
+        _STL_VERIFY(_Mycont, "can't dereference invalidated vector iterator");
+        _STL_VERIFY(_Mycont->_Myfirst <= this->_Ptr && this->_Ptr < _Mycont->_Mylast,
+            "can't dereference out of range vector iterator");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        return this->_Ptr;
+    }
+
+    _CONSTEXPR20 _Vector_iterator& operator++() noexcept {
+        _Mybase::operator++();
+        return *this;
+    }
+
+    _CONSTEXPR20 _Vector_iterator operator++(int) noexcept {
+        _Vector_iterator _Tmp = *this;
+        _Mybase::operator++();
+        return _Tmp;
+    }
+
+    _CONSTEXPR20 _Vector_iterator& operator--() noexcept {
+        _Mybase::operator--();
+        return *this;
+    }
+
+    _CONSTEXPR20 _Vector_iterator operator--(int) noexcept {
+        _Vector_iterator _Tmp = *this;
+        _Mybase::operator--();
+        return _Tmp;
+    }
+
+    _CONSTEXPR20 _Vector_iterator& operator+=(const difference_type _Off) noexcept {
+        _Mybase::operator+=(_Off);
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR20 _Vector_iterator operator+(const difference_type _Off) const noexcept {
+        _Vector_iterator _Tmp = *this;
+        _Tmp += _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD friend _CONSTEXPR20 _Vector_iterator operator+(
+        const difference_type _Off, _Vector_iterator _Next) noexcept {
+        _Next += _Off;
+        return _Next;
+    }
+
+    _CONSTEXPR20 _Vector_iterator& operator-=(const difference_type _Off) noexcept {
+        _Mybase::operator-=(_Off);
+        return *this;
+    }
+
+    using _Mybase::operator-;
+
+    _NODISCARD _CONSTEXPR20 _Vector_iterator operator-(const difference_type _Off) const noexcept {
+        _Vector_iterator _Tmp = *this;
+        _Tmp -= _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD _CONSTEXPR20 reference operator[](const difference_type _Off) const noexcept {
+        return const_cast<reference>(_Mybase::operator[](_Off));
+    }
+
+    using _Prevent_inheriting_unwrap = _Vector_iterator;
+
+    _NODISCARD _CONSTEXPR20 value_type* _Unwrapped() const noexcept {
+        return _STD _Unfancy_maybe_null(this->_Ptr);
+    }
+};
+
+#if _HAS_CXX20
+template <class _Myvec>
+struct pointer_traits<_Vector_iterator<_Myvec>> {
+    using pointer         = _Vector_iterator<_Myvec>;
+    using element_type    = pointer::value_type;
+    using difference_type = pointer::difference_type;
+
+    _NODISCARD static constexpr element_type* to_address(const pointer _Iter) noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        // A value-initialized iterator is in the domain of to_address. An invalidated end iterator for a vector with
+        // capacity() of 0 is not. This function cannot distinguish those two cases, so it incorrectly does not diagnose
+        // the latter. In practice, this isn't a significant problem since to_address returns nullptr for such an
+        // iterator.
+        const auto _Mycont = static_cast<const _Myvec*>(_Iter._Getcont());
+        if (_Mycont) {
+            _STL_VERIFY(_Mycont->_Myfirst <= _Iter._Ptr && _Iter._Ptr <= _Mycont->_Mylast,
+                "can't convert out-of-range vector iterator to pointer");
+        } else {
+            _STL_VERIFY(!_Iter._Ptr, "can't convert invalid vector iterator to pointer");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        return _STD to_address(_Iter._Ptr);
+    }
+};
+#endif // _HAS_CXX20
+
+template <class _Value_type, class _Size_type, class _Difference_type, class _Pointer, class _Const_pointer>
+struct _Vec_iter_types {
+    using value_type      = _Value_type;
+    using size_type       = _Size_type;
+    using difference_type = _Difference_type;
+    using pointer         = _Pointer;
+    using const_pointer   = _Const_pointer;
+};
+
+struct _Value_init_tag { // tag to request value-initialization
+    explicit _Value_init_tag() = default;
+};
+
+template <class _Val_types>
+class _Vector_val : public _Container_base {
+public:
+    using value_type      = typename _Val_types::value_type;
+    using size_type       = typename _Val_types::size_type;
+    using difference_type = typename _Val_types::difference_type;
+    using pointer         = typename _Val_types::pointer;
+    using const_pointer   = typename _Val_types::const_pointer;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+
+    _CONSTEXPR20 _Vector_val() noexcept : _Myfirst(), _Mylast(), _Myend() {}
+
+    _CONSTEXPR20 _Vector_val(pointer _First, pointer _Last, pointer _End) noexcept
+        : _Myfirst(_First), _Mylast(_Last), _Myend(_End) {}
+
+    _CONSTEXPR20 void _Swap_val(_Vector_val& _Right) noexcept {
+        this->_Swap_proxy_and_iterators(_Right);
+        swap(_Myfirst, _Right._Myfirst); // intentional ADL
+        swap(_Mylast, _Right._Mylast); // intentional ADL
+        swap(_Myend, _Right._Myend); // intentional ADL
+    }
+
+    _CONSTEXPR20 void _Take_contents(_Vector_val& _Right) noexcept {
+        this->_Swap_proxy_and_iterators(_Right);
+        _Myfirst = _Right._Myfirst;
+        _Mylast  = _Right._Mylast;
+        _Myend   = _Right._Myend;
+
+        _Right._Myfirst = nullptr;
+        _Right._Mylast  = nullptr;
+        _Right._Myend   = nullptr;
+    }
+
+    pointer _Myfirst; // pointer to beginning of array
+    pointer _Mylast; // pointer to current end of sequence
+    pointer _Myend; // pointer to end of array
+};
+
+_EXPORT_STD template <class _Ty, class _Alloc = allocator<_Ty>>
+class vector { // varying size array of values
+private:
+    template <class>
+    friend class _Vb_val;
+    friend _Tidy_guard<vector>;
+
+    using _Alty        = _Rebind_alloc_t<_Alloc, _Ty>;
+    using _Alty_traits = allocator_traits<_Alty>;
+
+public:
+    static_assert(!_ENFORCE_MATCHING_ALLOCATORS || is_same_v<_Ty, typename _Alloc::value_type>,
+        _MISMATCHED_ALLOCATOR_MESSAGE("vector<T, Allocator>", "T"));
+    static_assert(is_object_v<_Ty>, "The C++ Standard forbids containers of non-object types "
+                                    "because of [container.requirements].");
+
+    using value_type      = _Ty;
+    using allocator_type  = _Alloc;
+    using pointer         = typename _Alty_traits::pointer;
+    using const_pointer   = typename _Alty_traits::const_pointer;
+    using reference       = _Ty&;
+    using const_reference = const _Ty&;
+    using size_type       = typename _Alty_traits::size_type;
+    using difference_type = typename _Alty_traits::difference_type;
+
+private:
+#ifdef _INSERT_VECTOR_ANNOTATION
+    _CONSTEXPR20 void _Create_annotation() const noexcept {
+        // Annotates the shadow memory of the valid range
+        auto& _My_data = _Mypair._Myval2;
+        _Apply_annotation(_My_data._Myfirst, _My_data._Myend, _My_data._Myend, _My_data._Mylast);
+    }
+
+    _CONSTEXPR20 void _Remove_annotation() const noexcept {
+        // Removes the shadow memory annotation of the range
+        auto& _My_data = _Mypair._Myval2;
+        _Apply_annotation(_My_data._Myfirst, _My_data._Myend, _My_data._Mylast, _My_data._Myend);
+    }
+
+    _CONSTEXPR20 void _Modify_annotation(const difference_type _Count) const noexcept {
+        // Extends/shrinks the annotated range by _Count
+        if (_Count == 0) { // nothing to do
+            // This also avoids calling _Apply_annotation() with null pointers
+            // when the vector has zero capacity, see GH-2464.
+            return;
+        }
+
+        auto& _My_data = _Mypair._Myval2;
+        _Apply_annotation(_My_data._Myfirst, _My_data._Myend, _My_data._Mylast, _My_data._Mylast + _Count);
+    }
+
+    static _CONSTEXPR20 void _Apply_annotation(
+        pointer _First_, pointer _End_, pointer _Old_last_, pointer _New_last_) noexcept {
+        _STL_INTERNAL_CHECK(_First_ != nullptr);
+        _STL_INTERNAL_CHECK(_End_ != nullptr);
+        _STL_INTERNAL_CHECK(_Old_last_ != nullptr);
+        _STL_INTERNAL_CHECK(_New_last_ != nullptr);
+
+#if _HAS_CXX20
+        if (_STD is_constant_evaluated()) {
+            return;
+        }
+#endif // _HAS_CXX20
+
+        if (!_Asan_vector_should_annotate) {
+            return;
+        }
+
+        const void* const _First    = _STD _Unfancy(_First_);
+        const void* const _End      = _STD _Unfancy(_End_);
+        const void* const _Old_last = _STD _Unfancy(_Old_last_);
+        const void* const _New_last = _STD _Unfancy(_New_last_);
+        if constexpr ((_Container_allocation_minimum_asan_alignment<vector>) >= _Asan_granularity) {
+            // old state:
+            //   [_First, _Old_last) valid
+            //   [_Old_last, _End) poison
+            // new state:
+            //   [_First, _New_last) valid
+            //   [_New_last, asan_aligned_after(_End)) poison
+            _CSTD __sanitizer_annotate_contiguous_container(
+                _First, _STD _Get_asan_aligned_after(_End), _Old_last, _New_last);
+        } else {
+            const auto _Aligned = _STD _Get_asan_aligned_first_end(_First, _End);
+            if (_Aligned._First == _Aligned._End) {
+                // The buffer does not end at least one shadow memory section; nothing to do.
+                return;
+            }
+
+            const void* const _Old_fixed = _Aligned._Clamp_to_end(_Old_last);
+            const void* const _New_fixed = _Aligned._Clamp_to_end(_New_last);
+
+            // old state:
+            //   [_Aligned._First, _Old_fixed) valid
+            //   [_Old_fixed, _Aligned._End) poison
+            //   [_Aligned._End, _End) valid
+            // new state:
+            //   [_Aligned._First, _New_fixed) valid
+            //   [_New_fixed, _Aligned._End) poison
+            //   [_Aligned._End, _End) valid
+            _CSTD __sanitizer_annotate_contiguous_container(_Aligned._First, _Aligned._End, _Old_fixed, _New_fixed);
+        }
+    }
+
+    class _NODISCARD _Asan_extend_guard {
+    public:
+        _Asan_extend_guard(const _Asan_extend_guard&)            = delete;
+        _Asan_extend_guard& operator=(const _Asan_extend_guard&) = delete;
+
+        constexpr explicit _Asan_extend_guard(vector* _Myvec_, size_type _Target_size_) noexcept
+            : _Myvec(_Myvec_), _Target_size(_Target_size_) {
+            _STL_INTERNAL_CHECK(_Myvec != nullptr);
+            auto& _My_data = _Myvec->_Mypair._Myval2;
+            _Apply_annotation(_My_data._Myfirst, _My_data._Myend, _My_data._Mylast, _My_data._Myfirst + _Target_size);
+        }
+
+        _CONSTEXPR20 ~_Asan_extend_guard() {
+            if (!_Myvec) { // Operation succeeded, no modification to the shadow memory required.
+                return;
+            }
+
+            // Shrinks the shadow memory to the current size of the vector.
+            auto& _My_data = _Myvec->_Mypair._Myval2;
+            _Apply_annotation(_My_data._Myfirst, _My_data._Myend, _My_data._Myfirst + _Target_size, _My_data._Mylast);
+        }
+
+        _CONSTEXPR20 void _Release() noexcept {
+            _Myvec = nullptr;
+        }
+
+    private:
+        vector* _Myvec;
+        size_type _Target_size;
+    };
+
+    class _NODISCARD _Asan_create_guard {
+    public:
+        _Asan_create_guard(const _Asan_create_guard&)            = delete;
+        _Asan_create_guard& operator=(const _Asan_create_guard&) = delete;
+
+        constexpr explicit _Asan_create_guard(const vector& _Myvec_) noexcept : _Myvec(_Myvec_) {}
+
+        _CONSTEXPR20 ~_Asan_create_guard() {
+            _Myvec._Create_annotation();
+        }
+
+    private:
+        const vector& _Myvec;
+    };
+
+#define _ASAN_VECTOR_MODIFY(n)       _Modify_annotation((n))
+#define _ASAN_VECTOR_REMOVE          _Remove_annotation()
+#define _ASAN_VECTOR_CREATE          _Create_annotation()
+#define _ASAN_VECTOR_CREATE_GUARD    _Asan_create_guard _Annotator(*this)
+#define _ASAN_VECTOR_EXTEND_GUARD(n) _Asan_extend_guard _Annotator(this, (n))
+#define _ASAN_VECTOR_RELEASE_GUARD   _Annotator._Release()
+#else // ^^^ _INSERT_VECTOR_ANNOTATION / !_INSERT_VECTOR_ANNOTATION vvv
+#define _ASAN_VECTOR_MODIFY(n)
+#define _ASAN_VECTOR_REMOVE
+#define _ASAN_VECTOR_CREATE
+#define _ASAN_VECTOR_CREATE_GUARD
+#define _ASAN_VECTOR_EXTEND_GUARD(n)
+#define _ASAN_VECTOR_RELEASE_GUARD
+#endif // ^^^ !_INSERT_VECTOR_ANNOTATION ^^^
+
+    using _Scary_val = _Vector_val<conditional_t<_Is_simple_alloc_v<_Alty>, _Simple_types<_Ty>,
+        _Vec_iter_types<_Ty, size_type, difference_type, pointer, const_pointer>>>;
+
+public:
+    using iterator               = _Vector_iterator<_Scary_val>;
+    using const_iterator         = _Vector_const_iterator<_Scary_val>;
+    using reverse_iterator       = _STD reverse_iterator<iterator>;
+    using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
+
+    _CONSTEXPR20 vector() noexcept(is_nothrow_default_constructible_v<_Alty>) : _Mypair(_Zero_then_variadic_args_t{}) {
+        _Mypair._Myval2._Alloc_proxy(_GET_PROXY_ALLOCATOR(_Alty, _Getal()));
+    }
+
+    _CONSTEXPR20 explicit vector(const _Alloc& _Al) noexcept : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Mypair._Myval2._Alloc_proxy(_GET_PROXY_ALLOCATOR(_Alty, _Getal()));
+    }
+
+    _CONSTEXPR20 explicit vector(_CRT_GUARDOVERFLOW const size_type _Count, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Construct_n(_Count);
+    }
+
+#if _HAS_CXX17
+    template <class _Alloc2 = _Alloc, enable_if_t<_Is_allocator<_Alloc2>::value, int> = 0>
+#endif // _HAS_CXX17
+    _CONSTEXPR20 vector(_CRT_GUARDOVERFLOW const size_type _Count, const _Ty& _Val, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Construct_n(_Count, _Val);
+    }
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    _CONSTEXPR20 vector(_Iter _First, _Iter _Last, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _STD _Adl_verify_range(_First, _Last);
+        auto _UFirst = _STD _Get_unwrapped(_First);
+        auto _ULast  = _STD _Get_unwrapped(_Last);
+        if constexpr (_Is_cpp17_fwd_iter_v<_Iter>) {
+            const auto _Length = static_cast<size_t>(_STD distance(_UFirst, _ULast));
+            const auto _Count  = _STD _Convert_size<size_type>(_Length);
+            _Construct_n(_Count, _STD move(_UFirst), _STD move(_ULast));
+#if _HAS_CXX20
+        } else if constexpr (forward_iterator<_Iter>) {
+            const auto _Length = _STD _To_unsigned_like(_RANGES distance(_UFirst, _ULast));
+            const auto _Count  = _STD _Convert_size<size_type>(_Length);
+            _Construct_n(_Count, _STD move(_UFirst), _STD move(_ULast));
+#endif // _HAS_CXX20
+        } else {
+            auto&& _Alproxy = _GET_PROXY_ALLOCATOR(_Alty, _Getal());
+            _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
+            _Tidy_guard<vector> _Guard{this};
+
+            _Append_uncounted_range(_STD move(_UFirst), _STD move(_ULast));
+
+            _Guard._Target = nullptr;
+            _Proxy._Release();
+        }
+    }
+
+    _CONSTEXPR20 vector(initializer_list<_Ty> _Ilist, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Construct_n(_Convert_size<size_type>(_Ilist.size()), _Ilist.begin(), _Ilist.end());
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng>
+    constexpr vector(from_range_t, _Rng&& _Range, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        if constexpr (_RANGES sized_range<_Rng> || _RANGES forward_range<_Rng>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_Range));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            _Construct_n(_Count, _RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        } else {
+            auto&& _Alproxy = _GET_PROXY_ALLOCATOR(_Alty, _Getal());
+            _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
+            _Tidy_guard<vector> _Guard{this};
+
+            _Append_uncounted_range(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+
+            _Guard._Target = nullptr;
+            _Proxy._Release();
+        }
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 vector(const vector& _Right)
+        : _Mypair(_One_then_variadic_args_t{}, _Alty_traits::select_on_container_copy_construction(_Right._Getal())) {
+        const auto& _Right_data = _Right._Mypair._Myval2;
+        const auto _Count       = static_cast<size_type>(_Right_data._Mylast - _Right_data._Myfirst);
+        _Construct_n(_Count, _Right_data._Myfirst, _Right_data._Mylast);
+    }
+
+    _CONSTEXPR20 vector(const vector& _Right, const _Identity_t<_Alloc>& _Al)
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        const auto& _Right_data = _Right._Mypair._Myval2;
+        const auto _Count       = static_cast<size_type>(_Right_data._Mylast - _Right_data._Myfirst);
+        _Construct_n(_Count, _Right_data._Myfirst, _Right_data._Mylast);
+    }
+
+    _CONSTEXPR20 vector(vector&& _Right) noexcept
+        : _Mypair(_One_then_variadic_args_t{}, _STD move(_Right._Getal()),
+            _STD exchange(_Right._Mypair._Myval2._Myfirst, nullptr),
+            _STD exchange(_Right._Mypair._Myval2._Mylast, nullptr),
+            _STD exchange(_Right._Mypair._Myval2._Myend, nullptr)) {
+        _Mypair._Myval2._Alloc_proxy(_GET_PROXY_ALLOCATOR(_Alty, _Getal()));
+        _Mypair._Myval2._Swap_proxy_and_iterators(_Right._Mypair._Myval2);
+    }
+
+    _CONSTEXPR20 vector(vector&& _Right, const _Identity_t<_Alloc>& _Al_) noexcept(
+        _Alty_traits::is_always_equal::value) // strengthened
+        : _Mypair(_One_then_variadic_args_t{}, _Al_) {
+        _Alty& _Al        = _Getal();
+        auto&& _Alproxy   = _GET_PROXY_ALLOCATOR(_Alty, _Al);
+        auto& _My_data    = _Mypair._Myval2;
+        auto& _Right_data = _Right._Mypair._Myval2;
+        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _My_data);
+
+        if constexpr (!_Alty_traits::is_always_equal::value) {
+            if (_Al != _Right._Getal()) {
+                const auto _Count = static_cast<size_type>(_Right_data._Mylast - _Right_data._Myfirst);
+                if (_Count != 0) {
+                    _Buy_raw(_Count);
+                    _Tidy_guard<vector> _Guard{this};
+                    _My_data._Mylast =
+                        _Uninitialized_move(_Right_data._Myfirst, _Right_data._Mylast, _My_data._Myfirst, _Al);
+
+                    _ASAN_VECTOR_CREATE;
+                    _Guard._Target = nullptr;
+                }
+                _Proxy._Release();
+                return;
+            }
+        }
+
+        _My_data._Take_contents(_Right_data);
+        _Proxy._Release();
+    }
+
+    _CONSTEXPR20 vector& operator=(vector&& _Right) noexcept(
+        _Choose_pocma_v<_Alty> != _Pocma_values::_No_propagate_allocators) {
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+        _Alty& _Al                = _Getal();
+        _Alty& _Right_al          = _Right._Getal();
+        constexpr auto _Pocma_val = _Choose_pocma_v<_Alty>;
+        if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
+            if (_Al != _Right_al) {
+                _Move_assign_unequal_alloc(_Right);
+                return *this;
+            }
+        }
+
+        _Tidy();
+#if _ITERATOR_DEBUG_LEVEL != 0
+        if constexpr (_Pocma_val == _Pocma_values::_Propagate_allocators) {
+            if (_Al != _Right_al) {
+                // intentionally slams into noexcept on OOM, TRANSITION, VSO-466800
+                _Mypair._Myval2._Reload_proxy(_GET_PROXY_ALLOCATOR(_Alty, _Al), _GET_PROXY_ALLOCATOR(_Alty, _Right_al));
+            }
+        }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        _Pocma(_Al, _Right_al);
+        _Mypair._Myval2._Take_contents(_Right._Mypair._Myval2);
+        return *this;
+    }
+
+    _CONSTEXPR20 ~vector() noexcept {
+        _Tidy();
+#if _ITERATOR_DEBUG_LEVEL != 0
+        auto&& _Alproxy = _GET_PROXY_ALLOCATOR(_Alty, _Getal());
+        _Delete_plain_internal(_Alproxy, _STD exchange(_Mypair._Myval2._Myproxy, nullptr));
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+private:
+    template <class... _Valty>
+    _CONSTEXPR20 _Ty& _Emplace_one_at_back(_Valty&&... _Val) {
+        // insert by perfectly forwarding into element at end, provide strong guarantee
+        auto& _My_data   = _Mypair._Myval2;
+        pointer& _Mylast = _My_data._Mylast;
+
+        if (_Mylast != _My_data._Myend) {
+            return _Emplace_back_with_unused_capacity(_STD forward<_Valty>(_Val)...);
+        }
+
+        return *_Emplace_reallocate(_Mylast, _STD forward<_Valty>(_Val)...);
+    }
+
+    template <class... _Valty>
+    _CONSTEXPR20 _Ty& _Emplace_back_with_unused_capacity(_Valty&&... _Val) {
+        // insert by perfectly forwarding into element at end, provide strong guarantee
+        auto& _My_data   = _Mypair._Myval2;
+        pointer& _Mylast = _My_data._Mylast;
+        _STL_INTERNAL_CHECK(_Mylast != _My_data._Myend); // check that we have unused capacity
+        if constexpr (conjunction_v<is_nothrow_constructible<_Ty, _Valty...>,
+                          _Uses_default_construct<_Alloc, _Ty*, _Valty...>>) {
+            _ASAN_VECTOR_MODIFY(1);
+            _STD _Construct_in_place(*_Mylast, _STD forward<_Valty>(_Val)...);
+        } else {
+            _ASAN_VECTOR_EXTEND_GUARD(static_cast<size_type>(_Mylast - _My_data._Myfirst) + 1);
+            _Alty_traits::construct(_Getal(), _Unfancy(_Mylast), _STD forward<_Valty>(_Val)...);
+            _ASAN_VECTOR_RELEASE_GUARD;
+        }
+
+        _Orphan_range(_Mylast, _Mylast);
+        _Ty& _Result = *_Mylast;
+        ++_Mylast;
+
+        return _Result;
+    }
+
+    template <class... _Valty>
+    _CONSTEXPR20 pointer _Emplace_reallocate(const pointer _Whereptr, _Valty&&... _Val) {
+        // reallocate and insert by perfectly forwarding _Val at _Whereptr
+        _Alty& _Al        = _Getal();
+        auto& _My_data    = _Mypair._Myval2;
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+
+        _STL_INTERNAL_CHECK(_Mylast == _My_data._Myend); // check that we have no unused capacity
+
+        const auto _Whereoff = static_cast<size_type>(_Whereptr - _Myfirst);
+        const auto _Oldsize  = static_cast<size_type>(_Mylast - _Myfirst);
+
+        if (_Oldsize == max_size()) {
+            _Xlength();
+        }
+
+        const size_type _Newsize = _Oldsize + 1;
+        size_type _Newcapacity   = _Calculate_growth(_Newsize);
+
+        const pointer _Newvec           = _STD _Allocate_at_least_helper(_Al, _Newcapacity);
+        const pointer _Constructed_last = _Newvec + _Whereoff + 1;
+        pointer _Constructed_first      = _Constructed_last;
+
+        _TRY_BEGIN
+        _Alty_traits::construct(_Al, _STD _Unfancy(_Newvec + _Whereoff), _STD forward<_Valty>(_Val)...);
+        _Constructed_first = _Newvec + _Whereoff;
+
+        if (_Whereptr == _Mylast) { // at back, provide strong guarantee
+            if constexpr (is_nothrow_move_constructible_v<_Ty> || !is_copy_constructible_v<_Ty>) {
+                _STD _Uninitialized_move(_Myfirst, _Mylast, _Newvec, _Al);
+            } else {
+                _STD _Uninitialized_copy(_Myfirst, _Mylast, _Newvec, _Al);
+            }
+        } else { // provide basic guarantee
+            _STD _Uninitialized_move(_Myfirst, _Whereptr, _Newvec, _Al);
+            _Constructed_first = _Newvec;
+            _STD _Uninitialized_move(_Whereptr, _Mylast, _Newvec + _Whereoff + 1, _Al);
+        }
+        _CATCH_ALL
+        _STD _Destroy_range(_Constructed_first, _Constructed_last, _Al);
+        _Al.deallocate(_Newvec, _Newcapacity);
+        _RERAISE;
+        _CATCH_END
+
+        _Change_array(_Newvec, _Newsize, _Newcapacity);
+        return _Newvec + _Whereoff;
+    }
+
+public:
+    template <class... _Valty>
+    _CONSTEXPR20 decltype(auto) emplace_back(_Valty&&... _Val) {
+        // insert by perfectly forwarding into element at end, provide strong guarantee
+        _Ty& _Result = _Emplace_one_at_back(_STD forward<_Valty>(_Val)...);
+#if _HAS_CXX17
+        return _Result;
+#else // ^^^ _HAS_CXX17 / !_HAS_CXX17 vvv
+        (void) _Result;
+#endif // ^^^ !_HAS_CXX17 ^^^
+    }
+
+    _CONSTEXPR20 void push_back(const _Ty& _Val) { // insert element at end, provide strong guarantee
+        _Emplace_one_at_back(_Val);
+    }
+
+    _CONSTEXPR20 void push_back(_Ty&& _Val) {
+        // insert by moving into element at end, provide strong guarantee
+        _Emplace_one_at_back(_STD move(_Val));
+    }
+
+private:
+    template <class _Iter, class _Sent>
+    _CONSTEXPR20 void _Append_uncounted_range(_Iter _First, const _Sent _Last) {
+        // insert range [_First, _Last) at end
+
+        // For one-at-back, provide strong guarantee.
+        // Otherwise, provide basic guarantee (despite N4950 [vector.modifiers]/2).
+        // Performance note: except for one-at-back, _Emplace_one_at_back()'s strong guarantee is unnecessary here.
+
+        for (; _First != _Last; ++_First) {
+            _Emplace_one_at_back(*_First);
+        }
+    }
+
+#if _HAS_CXX23
+    template <class _Iter>
+    _CONSTEXPR20 void _Append_counted_range(_Iter _First, const size_type _Count) {
+        // insert counted range _First + [0, _Count) at end
+        auto& _Al        = _Getal();
+        auto& _My_data   = _Mypair._Myval2;
+        pointer& _Mylast = _My_data._Mylast;
+
+        const pointer _Oldfirst     = _My_data._Myfirst;
+        const pointer _Oldlast      = _Mylast;
+        const auto _Unused_capacity = static_cast<size_type>(_My_data._Myend - _Oldlast);
+
+        if (_Count == 0) { // nothing to do, avoid invalidating iterators
+        } else if (_Count > _Unused_capacity) { // reallocate
+            const auto _Oldsize = static_cast<size_type>(_Oldlast - _Oldfirst);
+
+            if (_Count > max_size() - _Oldsize) {
+                _Xlength();
+            }
+
+            const size_type _Newsize = _Oldsize + _Count;
+            size_type _Newcapacity   = _Calculate_growth(_Newsize);
+
+            const pointer _Newvec           = _Allocate_at_least_helper(_Al, _Newcapacity);
+            const pointer _Constructed_last = _Newvec + _Oldsize + _Count;
+            pointer _Constructed_first      = _Constructed_last;
+
+            _TRY_BEGIN
+            _Uninitialized_copy_n(_STD move(_First), _Count, _Newvec + _Oldsize, _Al);
+            _Constructed_first = _Newvec + _Oldsize;
+
+            if (_Count == 1) { // one at back, provide strong guarantee
+                if constexpr (is_nothrow_move_constructible_v<_Ty> || !is_copy_constructible_v<_Ty>) {
+                    _Uninitialized_move(_Oldfirst, _Oldlast, _Newvec, _Al);
+                } else {
+                    _Uninitialized_copy(_Oldfirst, _Oldlast, _Newvec, _Al);
+                }
+            } else { // provide basic guarantee
+                _Uninitialized_move(_Oldfirst, _Oldlast, _Newvec, _Al);
+            }
+            _CATCH_ALL
+            _Destroy_range(_Constructed_first, _Constructed_last, _Al);
+            _Al.deallocate(_Newvec, _Newcapacity);
+            _RERAISE;
+            _CATCH_END
+
+            _Change_array(_Newvec, _Newsize, _Newcapacity);
+        } else { // Provide the strong guarantee.
+                 // Performance note: except for one-at-back, the strong guarantee is unnecessary here.
+
+            _ASAN_VECTOR_EXTEND_GUARD(static_cast<size_type>(_Oldlast - _Oldfirst) + _Count);
+            _Mylast = _Uninitialized_copy_n(_STD move(_First), _Count, _Oldlast, _Al);
+            _ASAN_VECTOR_RELEASE_GUARD;
+
+            _Orphan_range(_Oldlast, _Oldlast);
+        }
+    }
+#endif // _HAS_CXX23
+
+public:
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng>
+    constexpr void append_range(_Rng&& _Range) {
+        if constexpr (_RANGES forward_range<_Rng> || _RANGES sized_range<_Rng>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_Range));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            _Append_counted_range(_RANGES _Ubegin(_Range), _Count);
+        } else {
+            _Append_uncounted_range(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        }
+    }
+#endif // _HAS_CXX23
+
+    template <class... _Valty>
+    _CONSTEXPR20 iterator emplace(const_iterator _Where, _Valty&&... _Val) {
+        // insert by perfectly forwarding _Val at _Where
+        const pointer _Whereptr = _Where._Ptr;
+        auto& _My_data          = _Mypair._Myval2;
+        const pointer _Oldlast  = _My_data._Mylast;
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(
+            _Where._Getcont() == _STD addressof(_My_data) && _Whereptr >= _My_data._Myfirst && _Oldlast >= _Whereptr,
+            "vector emplace iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        if (_Oldlast != _My_data._Myend) {
+            if (_Whereptr == _Oldlast) { // at back, provide strong guarantee
+                _Emplace_back_with_unused_capacity(_STD forward<_Valty>(_Val)...);
+            } else {
+                auto& _Al = _Getal();
+                _Alloc_temporary2<_Alty> _Obj(_Al, _STD forward<_Valty>(_Val)...); // handle aliasing
+                // after constructing _Obj, provide basic guarantee
+                _Orphan_range(_Whereptr, _Oldlast);
+                _ASAN_VECTOR_EXTEND_GUARD(static_cast<size_type>(_Oldlast - _My_data._Myfirst) + 1);
+                _Alty_traits::construct(_Al, _Unfancy(_Oldlast), _STD move(_Oldlast[-1]));
+                _ASAN_VECTOR_RELEASE_GUARD;
+                ++_My_data._Mylast;
+                _Move_backward_unchecked(_Whereptr, _Oldlast - 1, _Oldlast);
+                *_Whereptr = _STD move(_Obj._Get_value());
+            }
+
+            return _Make_iterator(_Whereptr);
+        }
+
+        return _Make_iterator(_Emplace_reallocate(_Whereptr, _STD forward<_Valty>(_Val)...));
+    }
+
+    _CONSTEXPR20 iterator insert(const_iterator _Where, const _Ty& _Val) { // insert _Val at _Where
+        return emplace(_Where, _Val);
+    }
+
+    _CONSTEXPR20 iterator insert(const_iterator _Where, _Ty&& _Val) { // insert by moving _Val at _Where
+        return emplace(_Where, _STD move(_Val));
+    }
+
+    _CONSTEXPR20 iterator insert(const_iterator _Where, _CRT_GUARDOVERFLOW const size_type _Count, const _Ty& _Val) {
+        // insert _Count * _Val at _Where
+        const pointer _Whereptr = _Where._Ptr;
+
+        auto& _Al        = _Getal();
+        auto& _My_data   = _Mypair._Myval2;
+        pointer& _Mylast = _My_data._Mylast;
+
+        const pointer _Oldfirst = _My_data._Myfirst;
+        const pointer _Oldlast  = _Mylast;
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_My_data) && _Whereptr >= _Oldfirst && _Oldlast >= _Whereptr,
+            "vector insert iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        const auto _Whereoff        = static_cast<size_type>(_Whereptr - _Oldfirst);
+        const auto _Unused_capacity = static_cast<size_type>(_My_data._Myend - _Oldlast);
+        const bool _One_at_back     = _Count == 1 && _Whereptr == _Oldlast;
+        if (_Count == 0) { // nothing to do, avoid invalidating iterators
+        } else if (_Count > _Unused_capacity) { // reallocate
+            const auto _Oldsize = static_cast<size_type>(_Oldlast - _Oldfirst);
+
+            if (_Count > max_size() - _Oldsize) {
+                _Xlength();
+            }
+
+            const size_type _Newsize = _Oldsize + _Count;
+            size_type _Newcapacity   = _Calculate_growth(_Newsize);
+
+            const pointer _Newvec           = _Allocate_at_least_helper(_Al, _Newcapacity);
+            const pointer _Constructed_last = _Newvec + _Whereoff + _Count;
+            pointer _Constructed_first      = _Constructed_last;
+
+            _TRY_BEGIN
+            _Uninitialized_fill_n(_Newvec + _Whereoff, _Count, _Val, _Al);
+            _Constructed_first = _Newvec + _Whereoff;
+
+            if (_One_at_back) { // provide strong guarantee
+                if constexpr (is_nothrow_move_constructible_v<_Ty> || !is_copy_constructible_v<_Ty>) {
+                    _Uninitialized_move(_Oldfirst, _Oldlast, _Newvec, _Al);
+                } else {
+                    _Uninitialized_copy(_Oldfirst, _Oldlast, _Newvec, _Al);
+                }
+            } else { // provide basic guarantee
+                _Uninitialized_move(_Oldfirst, _Whereptr, _Newvec, _Al);
+                _Constructed_first = _Newvec;
+                _Uninitialized_move(_Whereptr, _Oldlast, _Newvec + _Whereoff + _Count, _Al);
+            }
+            _CATCH_ALL
+            _Destroy_range(_Constructed_first, _Constructed_last, _Al);
+            _Al.deallocate(_Newvec, _Newcapacity);
+            _RERAISE;
+            _CATCH_END
+
+            _Change_array(_Newvec, _Newsize, _Newcapacity);
+        } else if (_One_at_back) { // provide strong guarantee
+            _Emplace_back_with_unused_capacity(_Val);
+        } else { // provide basic guarantee
+            const _Alloc_temporary2<_Alty> _Tmp_storage(_Al, _Val); // handle aliasing
+            const auto& _Tmp              = _Tmp_storage._Get_value();
+            const auto _Affected_elements = static_cast<size_type>(_Oldlast - _Whereptr);
+            _Orphan_range(_Whereptr, _Oldlast);
+
+            _ASAN_VECTOR_EXTEND_GUARD(static_cast<size_type>(_Oldlast - _My_data._Myfirst) + _Count);
+            if (_Count > _Affected_elements) { // new stuff spills off end
+                _Mylast = _Uninitialized_fill_n(_Oldlast, _Count - _Affected_elements, _Tmp, _Al);
+                _Mylast = _Uninitialized_move(_Whereptr, _Oldlast, _Mylast, _Al);
+                _STD fill(_Whereptr, _Oldlast, _Tmp);
+            } else { // new stuff can all be assigned
+                _Mylast = _Uninitialized_move(_Oldlast - _Count, _Oldlast, _Oldlast, _Al);
+                _Move_backward_unchecked(_Whereptr, _Oldlast - _Count, _Oldlast);
+                _STD fill_n(_Whereptr, _Count, _Tmp);
+            }
+            _ASAN_VECTOR_RELEASE_GUARD;
+        }
+
+        return _Make_iterator_offset(_Whereoff);
+    }
+
+private:
+    template <class _Iter, class _Sent>
+    _CONSTEXPR20 void _Insert_uncounted_range(const_iterator _Where, _Iter _First, _Sent _Last) {
+        // insert range [_First, _Last) at _Where
+        if (_First == _Last) {
+            return; // nothing to do, avoid invalidating iterators
+        }
+
+        auto& _My_data       = _Mypair._Myval2;
+        pointer& _Myfirst    = _My_data._Myfirst;
+        pointer& _Mylast     = _My_data._Mylast;
+        const auto _Whereoff = static_cast<size_type>(_Where._Ptr - _Myfirst);
+        const auto _Oldsize  = static_cast<size_type>(_Mylast - _Myfirst);
+
+        _Append_uncounted_range(_STD move(_First), _STD move(_Last));
+
+        _Orphan_range(_Myfirst + _Whereoff, _Myfirst + _Oldsize);
+
+        _STD rotate(_Myfirst + _Whereoff, _Myfirst + _Oldsize, _Mylast);
+    }
+
+    template <class _Iter>
+    _CONSTEXPR20 void _Insert_counted_range(const_iterator _Where, _Iter _First, const size_type _Count) {
+        // insert counted range _First + [0, _Count) at _Where
+        const pointer _Whereptr = _Where._Ptr;
+
+        auto& _Al        = _Getal();
+        auto& _My_data   = _Mypair._Myval2;
+        pointer& _Mylast = _My_data._Mylast;
+
+        const pointer _Oldfirst     = _My_data._Myfirst;
+        const pointer _Oldlast      = _Mylast;
+        const auto _Unused_capacity = static_cast<size_type>(_My_data._Myend - _Oldlast);
+
+        if (_Count == 0) { // nothing to do, avoid invalidating iterators
+        } else if (_Count > _Unused_capacity) { // reallocate
+            const auto _Oldsize = static_cast<size_type>(_Oldlast - _Oldfirst);
+
+            if (_Count > max_size() - _Oldsize) {
+                _Xlength();
+            }
+
+            const size_type _Newsize = _Oldsize + _Count;
+            size_type _Newcapacity   = _Calculate_growth(_Newsize);
+
+            const pointer _Newvec           = _STD _Allocate_at_least_helper(_Al, _Newcapacity);
+            const auto _Whereoff            = static_cast<size_type>(_Whereptr - _Oldfirst);
+            const pointer _Constructed_last = _Newvec + _Whereoff + _Count;
+            pointer _Constructed_first      = _Constructed_last;
+
+            _TRY_BEGIN
+            _STD _Uninitialized_copy_n(_STD move(_First), _Count, _Newvec + _Whereoff, _Al);
+            _Constructed_first = _Newvec + _Whereoff;
+
+            if (_Count == 1 && _Whereptr == _Oldlast) { // one at back, provide strong guarantee
+                if constexpr (is_nothrow_move_constructible_v<_Ty> || !is_copy_constructible_v<_Ty>) {
+                    _STD _Uninitialized_move(_Oldfirst, _Oldlast, _Newvec, _Al);
+                } else {
+                    _STD _Uninitialized_copy(_Oldfirst, _Oldlast, _Newvec, _Al);
+                }
+            } else { // provide basic guarantee
+                _STD _Uninitialized_move(_Oldfirst, _Whereptr, _Newvec, _Al);
+                _Constructed_first = _Newvec;
+                _STD _Uninitialized_move(_Whereptr, _Oldlast, _Newvec + _Whereoff + _Count, _Al);
+            }
+            _CATCH_ALL
+            _STD _Destroy_range(_Constructed_first, _Constructed_last, _Al);
+            _Al.deallocate(_Newvec, _Newcapacity);
+            _RERAISE;
+            _CATCH_END
+
+            _Change_array(_Newvec, _Newsize, _Newcapacity);
+        } else { // Attempt to provide the strong guarantee for EmplaceConstructible failure.
+                 // If we encounter copy/move construction/assignment failure, provide the basic guarantee.
+                 // (For one-at-back, this provides the strong guarantee.)
+
+            const auto _Affected_elements = static_cast<size_type>(_Oldlast - _Whereptr);
+
+            _ASAN_VECTOR_EXTEND_GUARD(static_cast<size_type>(_Oldlast - _Oldfirst) + _Count);
+            if (_Count < _Affected_elements) { // some affected elements must be assigned
+                _Mylast = _STD _Uninitialized_move(_Oldlast - _Count, _Oldlast, _Oldlast, _Al);
+                _STD _Move_backward_unchecked(_Whereptr, _Oldlast - _Count, _Oldlast);
+                _STD _Destroy_range(_Whereptr, _Whereptr + _Count, _Al);
+
+                _TRY_BEGIN
+                _STD _Uninitialized_copy_n(_STD move(_First), _Count, _Whereptr, _Al);
+                _CATCH_ALL
+                // glue the broken pieces back together
+
+                _TRY_BEGIN
+                _STD _Uninitialized_move(_Whereptr + _Count, _Whereptr + 2 * _Count, _Whereptr, _Al);
+                _CATCH_ALL
+                // vaporize the detached piece
+                _Orphan_range(_Whereptr, _Oldlast);
+                _STD _Destroy_range(_Whereptr + _Count, _Mylast, _Al);
+                _Mylast = _Whereptr;
+                _RERAISE;
+                _CATCH_END
+
+                _STD _Move_unchecked(_Whereptr + 2 * _Count, _Mylast, _Whereptr + _Count);
+                _STD _Destroy_range(_Oldlast, _Mylast, _Al);
+                _Mylast = _Oldlast;
+                _RERAISE;
+                _CATCH_END
+            } else { // affected elements don't overlap before/after
+                const pointer _Relocated = _Whereptr + _Count;
+                _Mylast                  = _STD _Uninitialized_move(_Whereptr, _Oldlast, _Relocated, _Al);
+                _STD _Destroy_range(_Whereptr, _Oldlast, _Al);
+
+                _TRY_BEGIN
+                _STD _Uninitialized_copy_n(_STD move(_First), _Count, _Whereptr, _Al);
+                _CATCH_ALL
+                // glue the broken pieces back together
+
+                _TRY_BEGIN
+                _STD _Uninitialized_move(_Relocated, _Mylast, _Whereptr, _Al);
+                _CATCH_ALL
+                // vaporize the detached piece
+                _Orphan_range(_Whereptr, _Oldlast);
+                _STD _Destroy_range(_Relocated, _Mylast, _Al);
+                _Mylast = _Whereptr;
+                _RERAISE;
+                _CATCH_END
+
+                _STD _Destroy_range(_Relocated, _Mylast, _Al);
+                _Mylast = _Oldlast;
+                _RERAISE;
+                _CATCH_END
+            }
+
+            _Orphan_range(_Whereptr, _Oldlast);
+            _ASAN_VECTOR_RELEASE_GUARD;
+        }
+    }
+
+public:
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    _CONSTEXPR20 iterator insert(const_iterator _Where, _Iter _First, _Iter _Last) {
+        const pointer _Whereptr = _Where._Ptr;
+        auto& _My_data          = _Mypair._Myval2;
+        const pointer _Oldfirst = _My_data._Myfirst;
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(
+            _Where._Getcont() == _STD addressof(_My_data) && _Whereptr >= _Oldfirst && _My_data._Mylast >= _Whereptr,
+            "vector insert iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        _STD _Adl_verify_range(_First, _Last);
+        auto _UFirst         = _STD _Get_unwrapped(_First);
+        auto _ULast          = _STD _Get_unwrapped(_Last);
+        const auto _Whereoff = static_cast<size_type>(_Whereptr - _Oldfirst);
+        if constexpr (_Is_cpp17_fwd_iter_v<_Iter>) {
+            const auto _Length = static_cast<size_t>(_STD distance(_UFirst, _ULast));
+            const auto _Count  = _STD _Convert_size<size_type>(_Length);
+            _Insert_counted_range(_Where, _UFirst, _Count);
+#if _HAS_CXX20
+        } else if constexpr (forward_iterator<_Iter>) {
+            const auto _Length = _STD _To_unsigned_like(_RANGES distance(_UFirst, _ULast));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            _Insert_counted_range(_Where, _UFirst, _Count);
+#endif // _HAS_CXX20
+        } else {
+            _Insert_uncounted_range(_Where, _UFirst, _ULast);
+        }
+        return _Make_iterator_offset(_Whereoff);
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng>
+    constexpr iterator insert_range(const_iterator _Where, _Rng&& _Range) {
+        const pointer _Whereptr = _Where._Ptr;
+        auto& _My_data          = _Mypair._Myval2;
+        const pointer _Oldfirst = _My_data._Myfirst;
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(
+            _Where._Getcont() == _STD addressof(_My_data) && _Whereptr >= _Oldfirst && _My_data._Mylast >= _Whereptr,
+            "vector insert_range iterator out-of-range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        const auto _Whereoff = static_cast<size_type>(_Whereptr - _Oldfirst);
+
+        if constexpr (_RANGES forward_range<_Rng> || _RANGES sized_range<_Rng>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_Range));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            _Insert_counted_range(_Where, _RANGES _Ubegin(_Range), _Count);
+        } else {
+            _Insert_uncounted_range(_Where, _RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        }
+        return _Make_iterator_offset(_Whereoff);
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 iterator insert(const_iterator _Where, initializer_list<_Ty> _Ilist) {
+        const pointer _Whereptr = _Where._Ptr;
+        auto& _My_data          = _Mypair._Myval2;
+        const pointer _Oldfirst = _My_data._Myfirst;
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(
+            _Where._Getcont() == _STD addressof(_My_data) && _Whereptr >= _Oldfirst && _My_data._Mylast >= _Whereptr,
+            "vector insert iterator out-of-range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        const auto _Whereoff = static_cast<size_type>(_Whereptr - _Oldfirst);
+
+        const auto _Count = _Convert_size<size_type>(_Ilist.size());
+        _Insert_counted_range(_Where, _Ilist.begin(), _Count);
+        return _Make_iterator_offset(_Whereoff);
+    }
+
+    _CONSTEXPR20 void assign(_CRT_GUARDOVERFLOW const size_type _Newsize, const _Ty& _Val) {
+        // assign _Newsize * _Val
+        auto& _Al         = _Getal();
+        auto& _My_data    = _Mypair._Myval2;
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            const auto _Valptr = _STD addressof(_Val);
+            _STL_VERIFY(!(_Unfancy(_Myfirst) <= _Valptr && _Valptr < _Unfancy(_Mylast)),
+                "assignment value cannot be a reference into the container");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        constexpr bool _Nothrow_construct =
+            conjunction_v<is_nothrow_copy_constructible<_Ty>, _Uses_default_construct<_Alloc, _Ty*, const _Ty&>>;
+
+        _My_data._Orphan_all();
+        const auto _Oldcapacity = static_cast<size_type>(_My_data._Myend - _Myfirst);
+        if (_Newsize > _Oldcapacity) { // reallocate
+            _Clear_and_reserve_geometric(_Newsize);
+            if constexpr (_Nothrow_construct) {
+                _Mylast = _Uninitialized_fill_n(_Myfirst, _Newsize, _Val, _Al);
+                _ASAN_VECTOR_CREATE;
+            } else {
+                _ASAN_VECTOR_CREATE_GUARD;
+                _Mylast = _Uninitialized_fill_n(_Myfirst, _Newsize, _Val, _Al);
+            }
+
+            return;
+        }
+
+        const auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
+        if (_Newsize > _Oldsize) {
+            _STD fill(_Myfirst, _Mylast, _Val);
+            if constexpr (_Nothrow_construct) {
+                _ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Newsize - _Oldsize));
+                _Mylast = _Uninitialized_fill_n(_Mylast, _Newsize - _Oldsize, _Val, _Al);
+            } else {
+                _ASAN_VECTOR_EXTEND_GUARD(_Newsize);
+                _Mylast = _Uninitialized_fill_n(_Mylast, _Newsize - _Oldsize, _Val, _Al);
+                _ASAN_VECTOR_RELEASE_GUARD;
+            }
+        } else {
+            const pointer _Newlast = _Myfirst + _Newsize;
+            _STD fill(_Myfirst, _Newlast, _Val);
+            _Destroy_range(_Newlast, _Mylast, _Al);
+            _ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Newsize - _Oldsize));
+            _Mylast = _Newlast;
+        }
+    }
+
+private:
+    template <class _Iter, class _Sent>
+    _CONSTEXPR20 void _Assign_uncounted_range(_Iter _First, _Sent _Last) {
+        // assign unknown number of elements from [_First, _Last)
+        auto& _My_data    = _Mypair._Myval2;
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+
+        _My_data._Orphan_all();
+
+        pointer _Next = _Myfirst;
+        for (; _First != _Last && _Next != _Mylast; ++_First, (void) ++_Next) {
+            *_Next = *_First;
+        }
+
+        // Code size optimization: we've exhausted only the source, only the dest, or both.
+        // If we've exhausted only the source: we Trim, then Append does nothing.
+        // If we've exhausted only the dest: Trim does nothing, then we Append.
+        // If we've exhausted both: Trim does nothing, then Append does nothing.
+
+        // Trim.
+        _Destroy_range(_Next, _Mylast, _Getal());
+        _ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Next - _Mylast)); // negative when destroying elements
+        _Mylast = _Next;
+
+        _Append_uncounted_range(_STD move(_First), _STD move(_Last));
+    }
+
+    template <class _Iter>
+    _CONSTEXPR20 void _Assign_counted_range(_Iter _First, const size_type _Newsize) {
+        // assign elements from counted range _First + [0, _Newsize)
+        auto& _Al         = _Getal();
+        auto& _My_data    = _Mypair._Myval2;
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+        pointer& _Myend   = _My_data._Myend;
+
+        constexpr bool _Nothrow_construct = conjunction_v<is_nothrow_constructible<_Ty, _Iter_ref_t<_Iter>>,
+            _Uses_default_construct<_Alloc, _Ty*, _Iter_ref_t<_Iter>>>;
+
+        _My_data._Orphan_all();
+        const auto _Oldcapacity = static_cast<size_type>(_Myend - _Myfirst);
+        if (_Newsize > _Oldcapacity) {
+            _Clear_and_reserve_geometric(_Newsize);
+            if constexpr (_Nothrow_construct) {
+                _Mylast = _STD _Uninitialized_copy_n(_STD move(_First), _Newsize, _Myfirst, _Al);
+                _ASAN_VECTOR_CREATE;
+            } else {
+                _ASAN_VECTOR_CREATE_GUARD;
+                _Mylast = _STD _Uninitialized_copy_n(_STD move(_First), _Newsize, _Myfirst, _Al);
+            }
+            return;
+        }
+
+        const auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
+        if (_Newsize > _Oldsize) {
+            bool _Copied = false;
+            if constexpr (_Iter_copy_cat<_Iter, pointer>::_Bitcopy_assignable) {
+#if _HAS_CXX20
+                if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+                {
+                    _Copy_memmove_n(_First, static_cast<size_t>(_Oldsize), _Myfirst);
+                    _First += _Oldsize;
+                    _Copied = true;
+                }
+            }
+
+            if (!_Copied) {
+                for (auto _Mid = _Myfirst; _Mid != _Mylast; ++_Mid, (void) ++_First) {
+                    *_Mid = *_First;
+                }
+            }
+
+            if constexpr (_Nothrow_construct) {
+                _ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Newsize - _Oldsize));
+                _Mylast = _STD _Uninitialized_copy_n(_STD move(_First), _Newsize - _Oldsize, _Mylast, _Al);
+            } else {
+                _ASAN_VECTOR_EXTEND_GUARD(_Newsize);
+                _Mylast = _STD _Uninitialized_copy_n(_STD move(_First), _Newsize - _Oldsize, _Mylast, _Al);
+                _ASAN_VECTOR_RELEASE_GUARD;
+            }
+        } else {
+            const pointer _Newlast = _Myfirst + _Newsize;
+            _STD _Copy_n_unchecked4(_STD move(_First), _Newsize, _Myfirst);
+            _STD _Destroy_range(_Newlast, _Mylast, _Al);
+            _ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Newsize - _Oldsize));
+            _Mylast = _Newlast;
+        }
+    }
+
+public:
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    _CONSTEXPR20 void assign(_Iter _First, _Iter _Last) {
+        _STD _Adl_verify_range(_First, _Last);
+        auto _UFirst = _STD _Get_unwrapped(_First);
+        auto _ULast  = _STD _Get_unwrapped(_Last);
+        if constexpr (_Is_cpp17_fwd_iter_v<_Iter>) {
+            const auto _Length = static_cast<size_t>(_STD distance(_UFirst, _ULast));
+            const auto _Count  = _STD _Convert_size<size_type>(_Length);
+            _Assign_counted_range(_UFirst, _Count);
+#if _HAS_CXX20
+        } else if constexpr (forward_iterator<_Iter>) {
+            const auto _Length = _STD _To_unsigned_like(_RANGES distance(_UFirst, _ULast));
+            const auto _Count  = _STD _Convert_size<size_type>(_Length);
+            _Assign_counted_range(_UFirst, _Count);
+#endif // _HAS_CXX20
+        } else {
+            _Assign_uncounted_range(_UFirst, _ULast);
+        }
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng>
+    constexpr void assign_range(_Rng&& _Range) {
+        if constexpr (_RANGES sized_range<_Rng> || _RANGES forward_range<_Rng>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_Range));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            _Assign_counted_range(_RANGES _Ubegin(_Range), _Count);
+        } else {
+            _Assign_uncounted_range(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        }
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 void assign(const initializer_list<_Ty> _Ilist) {
+        const auto _Count = _Convert_size<size_type>(_Ilist.size());
+        _Assign_counted_range(_Ilist.begin(), _Count);
+    }
+
+    _CONSTEXPR20 vector& operator=(const vector& _Right) {
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+        auto& _Al       = _Getal();
+        auto& _Right_al = _Right._Getal();
+        if constexpr (_Choose_pocca_v<_Alty>) {
+            if (_Al != _Right_al) {
+                _Tidy();
+                _Mypair._Myval2._Reload_proxy(_GET_PROXY_ALLOCATOR(_Alty, _Al), _GET_PROXY_ALLOCATOR(_Alty, _Right_al));
+            }
+        }
+
+        _Pocca(_Al, _Right_al);
+        auto& _Right_data = _Right._Mypair._Myval2;
+        _Assign_counted_range(_Right_data._Myfirst, static_cast<size_type>(_Right_data._Mylast - _Right_data._Myfirst));
+
+        return *this;
+    }
+
+    _CONSTEXPR20 vector& operator=(initializer_list<_Ty> _Ilist) {
+        const auto _Count = _Convert_size<size_type>(_Ilist.size());
+        _Assign_counted_range(_Ilist.begin(), _Count);
+        return *this;
+    }
+
+private:
+    template <class _Ty2>
+    _CONSTEXPR20 void _Resize_reallocate(const size_type _Newsize, const _Ty2& _Val) {
+        if (_Newsize > max_size()) {
+            _Xlength();
+        }
+
+        auto& _Al         = _Getal();
+        auto& _My_data    = _Mypair._Myval2;
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+
+        const auto _Oldsize    = static_cast<size_type>(_Mylast - _Myfirst);
+        size_type _Newcapacity = _Calculate_growth(_Newsize);
+
+        const pointer _Newvec         = _Allocate_at_least_helper(_Al, _Newcapacity);
+        const pointer _Appended_first = _Newvec + _Oldsize;
+        pointer _Appended_last        = _Appended_first;
+
+        _TRY_BEGIN
+        if constexpr (is_same_v<_Ty2, _Ty>) {
+            _Appended_last = _Uninitialized_fill_n(_Appended_first, _Newsize - _Oldsize, _Val, _Al);
+        } else {
+            _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Ty2, _Value_init_tag>);
+            _Appended_last = _Uninitialized_value_construct_n(_Appended_first, _Newsize - _Oldsize, _Al);
+        }
+
+        if constexpr (is_nothrow_move_constructible_v<_Ty> || !is_copy_constructible_v<_Ty>) {
+            _Uninitialized_move(_Myfirst, _Mylast, _Newvec, _Al);
+        } else {
+            _Uninitialized_copy(_Myfirst, _Mylast, _Newvec, _Al);
+        }
+        _CATCH_ALL
+        _Destroy_range(_Appended_first, _Appended_last, _Al);
+        _Al.deallocate(_Newvec, _Newcapacity);
+        _RERAISE;
+        _CATCH_END
+
+        _Change_array(_Newvec, _Newsize, _Newcapacity);
+    }
+
+    template <class _Ty2>
+    _CONSTEXPR20 void _Resize(const size_type _Newsize, const _Ty2& _Val) {
+        // trim or append elements, provide strong guarantee
+        auto& _Al           = _Getal();
+        auto& _My_data      = _Mypair._Myval2;
+        pointer& _Myfirst   = _My_data._Myfirst;
+        pointer& _Mylast    = _My_data._Mylast;
+        const auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
+        if (_Newsize < _Oldsize) { // trim
+            const pointer _Newlast = _Myfirst + _Newsize;
+            _Orphan_range(_Newlast, _Mylast);
+            _Destroy_range(_Newlast, _Mylast, _Al);
+            _ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Newsize - _Oldsize));
+            _Mylast = _Newlast;
+            return;
+        }
+
+        if (_Newsize > _Oldsize) { // append
+            const auto _Oldcapacity = static_cast<size_type>(_My_data._Myend - _Myfirst);
+            if (_Newsize > _Oldcapacity) { // reallocate
+                _Resize_reallocate(_Newsize, _Val);
+                return;
+            }
+
+            _ASAN_VECTOR_EXTEND_GUARD(_Newsize);
+            const pointer _Oldlast = _Mylast;
+            if constexpr (is_same_v<_Ty2, _Ty>) {
+                _Mylast = _Uninitialized_fill_n(_Oldlast, _Newsize - _Oldsize, _Val, _Al);
+            } else {
+                _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Ty2, _Value_init_tag>);
+                _Mylast = _Uninitialized_value_construct_n(_Oldlast, _Newsize - _Oldsize, _Al);
+            }
+            _ASAN_VECTOR_RELEASE_GUARD;
+            _Orphan_range(_Oldlast, _Oldlast);
+        }
+
+        // if _Newsize == _Oldsize, do nothing; avoid invalidating iterators
+    }
+
+public:
+    _CONSTEXPR20 void resize(_CRT_GUARDOVERFLOW const size_type _Newsize) {
+        // trim or append value-initialized elements, provide strong guarantee
+        _Resize(_Newsize, _Value_init_tag{});
+    }
+
+    _CONSTEXPR20 void resize(_CRT_GUARDOVERFLOW const size_type _Newsize, const _Ty& _Val) {
+        // trim or append copies of _Val, provide strong guarantee
+        _Resize(_Newsize, _Val);
+    }
+
+private:
+    enum class _Reallocation_policy { _At_least, _Exactly };
+
+    template <_Reallocation_policy _Policy>
+    _CONSTEXPR20 void _Reallocate(size_type& _Newcapacity) {
+        // set capacity to _Newcapacity (without geometric growth), provide strong guarantee
+        auto& _Al         = _Getal();
+        auto& _My_data    = _Mypair._Myval2;
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+
+        const auto _Size = static_cast<size_type>(_Mylast - _Myfirst);
+
+        pointer _Newvec;
+        if constexpr (_Policy == _Reallocation_policy::_At_least) {
+            _Newvec = _Allocate_at_least_helper(_Al, _Newcapacity);
+        } else {
+            _STL_INTERNAL_STATIC_ASSERT(_Policy == _Reallocation_policy::_Exactly);
+            _Newvec = _Al.allocate(_Newcapacity);
+        }
+
+        _TRY_BEGIN
+        if constexpr (is_nothrow_move_constructible_v<_Ty> || !is_copy_constructible_v<_Ty>) {
+            _Uninitialized_move(_Myfirst, _Mylast, _Newvec, _Al);
+        } else {
+            _Uninitialized_copy(_Myfirst, _Mylast, _Newvec, _Al);
+        }
+        _CATCH_ALL
+        _Al.deallocate(_Newvec, _Newcapacity);
+        _RERAISE;
+        _CATCH_END
+
+        _Change_array(_Newvec, _Size, _Newcapacity);
+    }
+
+#if _ITERATOR_DEBUG_LEVEL != 0 && defined(_ENABLE_STL_INTERNAL_CHECK)
+    void _Check_all_orphaned_locked() const noexcept {
+        _Lockit _Lock(_LOCK_DEBUG);
+        auto& _My_data = _Mypair._Myval2;
+        _STL_INTERNAL_CHECK(!_My_data._Myproxy->_Myfirstiter);
+    }
+
+    _CONSTEXPR20 void _Check_all_orphaned() const noexcept {
+#if _HAS_CXX20
+        if (_STD is_constant_evaluated()) {
+            auto& _My_data = _Mypair._Myval2;
+            _STL_INTERNAL_CHECK(!_My_data._Myproxy->_Myfirstiter);
+        } else
+#endif // _HAS_CXX20
+        {
+            _Check_all_orphaned_locked();
+        }
+    }
+#endif // _ITERATOR_DEBUG_LEVEL != 0 && defined(_ENABLE_STL_INTERNAL_CHECK)
+
+    _CONSTEXPR20 void _Clear_and_reserve_geometric(const size_type _Newsize) {
+        auto& _Al         = _Getal();
+        auto& _My_data    = _Mypair._Myval2;
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+        pointer& _Myend   = _My_data._Myend;
+
+#if _ITERATOR_DEBUG_LEVEL != 0 && defined(_ENABLE_STL_INTERNAL_CHECK)
+        _STL_INTERNAL_CHECK(_Newsize != 0);
+        _Check_all_orphaned();
+#endif // _ITERATOR_DEBUG_LEVEL != 0 && defined(_ENABLE_STL_INTERNAL_CHECK)
+
+        if (_Newsize > max_size()) {
+            _Xlength();
+        }
+
+        const size_type _Newcapacity = _Calculate_growth(_Newsize);
+
+        if (_Myfirst) { // destroy and deallocate old array
+            _Destroy_range(_Myfirst, _Mylast, _Al);
+            _ASAN_VECTOR_REMOVE;
+            _Al.deallocate(_Myfirst, static_cast<size_type>(_Myend - _Myfirst));
+
+            _Myfirst = nullptr;
+            _Mylast  = nullptr;
+            _Myend   = nullptr;
+        }
+
+        _Buy_raw(_Newcapacity);
+    }
+
+public:
+    _CONSTEXPR20 void reserve(_CRT_GUARDOVERFLOW size_type _Newcapacity) {
+        // increase capacity to _Newcapacity (without geometric growth), provide strong guarantee
+        if (_Newcapacity > capacity()) { // something to do (reserve() never shrinks)
+            if (_Newcapacity > max_size()) {
+                _Xlength();
+            }
+
+            _Reallocate<_Reallocation_policy::_At_least>(_Newcapacity);
+        }
+    }
+
+    _CONSTEXPR20 void shrink_to_fit() { // reduce capacity to size, provide strong guarantee
+        auto& _My_data         = _Mypair._Myval2;
+        const pointer _Oldlast = _My_data._Mylast;
+        if (_Oldlast != _My_data._Myend) { // something to do
+            const pointer _Oldfirst = _My_data._Myfirst;
+            if (_Oldfirst == _Oldlast) {
+                _Tidy();
+            } else {
+                size_type _Newcapacity = static_cast<size_type>(_Oldlast - _Oldfirst);
+                _Reallocate<_Reallocation_policy::_Exactly>(_Newcapacity);
+            }
+        }
+    }
+
+    _CONSTEXPR20 void pop_back() noexcept /* strengthened */ {
+        auto& _My_data   = _Mypair._Myval2;
+        pointer& _Mylast = _My_data._Mylast;
+
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_My_data._Myfirst != _Mylast, "vector empty before pop");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+
+        _Orphan_range(_Mylast - 1, _Mylast);
+        _Alty_traits::destroy(_Getal(), _Unfancy(_Mylast - 1));
+        _ASAN_VECTOR_MODIFY(-1);
+        --_Mylast;
+    }
+
+    _CONSTEXPR20 iterator erase(const_iterator _Where) noexcept(
+        is_nothrow_move_assignable_v<value_type>) /* strengthened */ {
+        const pointer _Whereptr = _Where._Ptr;
+        auto& _My_data          = _Mypair._Myval2;
+        pointer& _Mylast        = _My_data._Mylast;
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(
+            _Where._Getcont() == _STD addressof(_My_data) && _Whereptr >= _My_data._Myfirst && _Mylast > _Whereptr,
+            "vector erase iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        _Orphan_range(_Whereptr, _Mylast);
+        _STD _Move_unchecked(_Whereptr + 1, _Mylast, _Whereptr);
+        _Alty_traits::destroy(_Getal(), _Unfancy(_Mylast - 1));
+        _ASAN_VECTOR_MODIFY(-1);
+        --_Mylast;
+        return iterator(_Whereptr, _STD addressof(_My_data));
+    }
+
+    _CONSTEXPR20 iterator erase(const_iterator _First, const_iterator _Last) noexcept(
+        is_nothrow_move_assignable_v<value_type>) /* strengthened */ {
+        const pointer _Firstptr = _First._Ptr;
+        const pointer _Lastptr  = _Last._Ptr;
+        auto& _My_data          = _Mypair._Myval2;
+        pointer& _Mylast        = _My_data._Mylast;
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_First._Getcont() == _STD addressof(_My_data) && _Last._Getcont() == _STD addressof(_My_data)
+                        && _Firstptr >= _My_data._Myfirst && _Lastptr >= _Firstptr && _Mylast >= _Lastptr,
+            "vector erase iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        if (_Firstptr != _Lastptr) { // something to do, invalidate iterators
+            _Orphan_range(_Firstptr, _Mylast);
+
+            const pointer _Newlast = _STD _Move_unchecked(_Lastptr, _Mylast, _Firstptr);
+            _Destroy_range(_Newlast, _Mylast, _Getal());
+            _ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Newlast - _Mylast)); // negative when destroying elements
+            _Mylast = _Newlast;
+        }
+
+        return iterator(_Firstptr, _STD addressof(_My_data));
+    }
+
+    _CONSTEXPR20 void clear() noexcept { // erase all
+        auto& _My_data    = _Mypair._Myval2;
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+
+        if (_Myfirst == _Mylast) { // already empty, nothing to do
+            // This is an optimization for debug mode: we can avoid taking the debug lock to invalidate iterators.
+            // Note that when clearing an empty vector, this will preserve past-the-end iterators, which is allowed by
+            // N4950 [sequence.reqmts]/54 "a.clear() [...] may invalidate the past-the-end iterator".
+            return;
+        }
+
+        _My_data._Orphan_all();
+        _Destroy_range(_Myfirst, _Mylast, _Getal());
+        _ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Myfirst - _Mylast)); // negative when destroying elements
+        _Mylast = _Myfirst;
+    }
+
+    _CONSTEXPR20 void swap(vector& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _Pocs(_Getal(), _Right._Getal());
+            _Mypair._Myval2._Swap_val(_Right._Mypair._Myval2);
+        }
+    }
+
+    _NODISCARD _CONSTEXPR20 _Ty* data() noexcept {
+        return _STD _Unfancy_maybe_null(_Mypair._Myval2._Myfirst);
+    }
+
+    _NODISCARD _CONSTEXPR20 const _Ty* data() const noexcept {
+        return _STD _Unfancy_maybe_null(_Mypair._Myval2._Myfirst);
+    }
+
+    _NODISCARD _CONSTEXPR20 iterator begin() noexcept {
+        auto& _My_data = _Mypair._Myval2;
+        return iterator(_My_data._Myfirst, _STD addressof(_My_data));
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator begin() const noexcept {
+        auto& _My_data = _Mypair._Myval2;
+        return const_iterator(_My_data._Myfirst, _STD addressof(_My_data));
+    }
+
+    _NODISCARD _CONSTEXPR20 iterator end() noexcept {
+        auto& _My_data = _Mypair._Myval2;
+        return iterator(_My_data._Mylast, _STD addressof(_My_data));
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator end() const noexcept {
+        auto& _My_data = _Mypair._Myval2;
+        return const_iterator(_My_data._Mylast, _STD addressof(_My_data));
+    }
+
+    _NODISCARD _CONSTEXPR20 reverse_iterator rbegin() noexcept {
+        return reverse_iterator(end());
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reverse_iterator rbegin() const noexcept {
+        return const_reverse_iterator(end());
+    }
+
+    _NODISCARD _CONSTEXPR20 reverse_iterator rend() noexcept {
+        return reverse_iterator(begin());
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reverse_iterator rend() const noexcept {
+        return const_reverse_iterator(begin());
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator cbegin() const noexcept {
+        return begin();
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator cend() const noexcept {
+        return end();
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reverse_iterator crbegin() const noexcept {
+        return rbegin();
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reverse_iterator crend() const noexcept {
+        return rend();
+    }
+
+    _NODISCARD _CONSTEXPR20 _Ty* _Unchecked_begin() noexcept {
+        return _Unfancy_maybe_null(_Mypair._Myval2._Myfirst);
+    }
+
+    _NODISCARD _CONSTEXPR20 const _Ty* _Unchecked_begin() const noexcept {
+        return _Unfancy_maybe_null(_Mypair._Myval2._Myfirst);
+    }
+
+    _NODISCARD _CONSTEXPR20 _Ty* _Unchecked_end() noexcept {
+        return _Unfancy_maybe_null(_Mypair._Myval2._Mylast);
+    }
+
+    _NODISCARD _CONSTEXPR20 const _Ty* _Unchecked_end() const noexcept {
+        return _Unfancy_maybe_null(_Mypair._Myval2._Mylast);
+    }
+
+    _NODISCARD_EMPTY_MEMBER _CONSTEXPR20 bool empty() const noexcept {
+        auto& _My_data = _Mypair._Myval2;
+        return _My_data._Myfirst == _My_data._Mylast;
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type size() const noexcept {
+        auto& _My_data = _Mypair._Myval2;
+        return static_cast<size_type>(_My_data._Mylast - _My_data._Myfirst);
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type max_size() const noexcept {
+        return (_STD min)(static_cast<size_type>(_STD _Max_limit<difference_type>()), _Alty_traits::max_size(_Getal()));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type capacity() const noexcept {
+        auto& _My_data = _Mypair._Myval2;
+        return static_cast<size_type>(_My_data._Myend - _My_data._Myfirst);
+    }
+
+    _NODISCARD _CONSTEXPR20 _Ty& operator[](const size_type _Pos) noexcept /* strengthened */ {
+        auto& _My_data = _Mypair._Myval2;
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(
+            _Pos < static_cast<size_type>(_My_data._Mylast - _My_data._Myfirst), "vector subscript out of range");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+
+        return _My_data._Myfirst[_Pos];
+    }
+
+    _NODISCARD _CONSTEXPR20 const _Ty& operator[](const size_type _Pos) const noexcept /* strengthened */ {
+        auto& _My_data = _Mypair._Myval2;
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(
+            _Pos < static_cast<size_type>(_My_data._Mylast - _My_data._Myfirst), "vector subscript out of range");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+
+        return _My_data._Myfirst[_Pos];
+    }
+
+    _NODISCARD _CONSTEXPR20 _Ty& at(const size_type _Pos) {
+        auto& _My_data = _Mypair._Myval2;
+        if (static_cast<size_type>(_My_data._Mylast - _My_data._Myfirst) <= _Pos) {
+            _Xrange();
+        }
+
+        return _My_data._Myfirst[_Pos];
+    }
+
+    _NODISCARD _CONSTEXPR20 const _Ty& at(const size_type _Pos) const {
+        auto& _My_data = _Mypair._Myval2;
+        if (static_cast<size_type>(_My_data._Mylast - _My_data._Myfirst) <= _Pos) {
+            _Xrange();
+        }
+
+        return _My_data._Myfirst[_Pos];
+    }
+
+    _NODISCARD _CONSTEXPR20 _Ty& front() noexcept /* strengthened */ {
+        auto& _My_data = _Mypair._Myval2;
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_My_data._Myfirst != _My_data._Mylast, "front() called on empty vector");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+
+        return *_My_data._Myfirst;
+    }
+
+    _NODISCARD _CONSTEXPR20 const _Ty& front() const noexcept /* strengthened */ {
+        auto& _My_data = _Mypair._Myval2;
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_My_data._Myfirst != _My_data._Mylast, "front() called on empty vector");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+
+        return *_My_data._Myfirst;
+    }
+
+    _NODISCARD _CONSTEXPR20 _Ty& back() noexcept /* strengthened */ {
+        auto& _My_data = _Mypair._Myval2;
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_My_data._Myfirst != _My_data._Mylast, "back() called on empty vector");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+
+        return _My_data._Mylast[-1];
+    }
+
+    _NODISCARD _CONSTEXPR20 const _Ty& back() const noexcept /* strengthened */ {
+        auto& _My_data = _Mypair._Myval2;
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_My_data._Myfirst != _My_data._Mylast, "back() called on empty vector");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+
+        return _My_data._Mylast[-1];
+    }
+
+    _NODISCARD _CONSTEXPR20 allocator_type get_allocator() const noexcept {
+        return static_cast<allocator_type>(_Getal());
+    }
+
+private:
+    _CONSTEXPR20 size_type _Calculate_growth(const size_type _Newsize) const {
+        // given _Oldcapacity and _Newsize, calculate geometric growth
+        const size_type _Oldcapacity = capacity();
+        const auto _Max              = max_size();
+
+        if (_Oldcapacity > _Max - _Oldcapacity / 2) {
+            return _Max; // geometric growth would overflow
+        }
+
+        const size_type _Geometric = _Oldcapacity + _Oldcapacity / 2;
+
+        if (_Geometric < _Newsize) {
+            return _Newsize; // geometric growth would be insufficient
+        }
+
+        return _Geometric; // geometric growth is sufficient
+    }
+
+    _CONSTEXPR20 void _Buy_raw(size_type _Newcapacity) {
+        // allocate array with _Newcapacity elements
+        auto& _My_data    = _Mypair._Myval2;
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+        pointer& _Myend   = _My_data._Myend;
+
+        _STL_INTERNAL_CHECK(!_Myfirst && !_Mylast && !_Myend); // check that *this is tidy
+        _STL_INTERNAL_CHECK(0 < _Newcapacity && _Newcapacity <= max_size());
+
+        const pointer _Newvec = _STD _Allocate_at_least_helper(_Getal(), _Newcapacity);
+        _Myfirst              = _Newvec;
+        _Mylast               = _Newvec;
+        _Myend                = _Newvec + _Newcapacity;
+    }
+
+    _CONSTEXPR20 void _Buy_nonzero(const size_type _Newcapacity) {
+        // allocate array with _Newcapacity elements
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+        auto& _My_data    = _Mypair._Myval2;
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+        pointer& _Myend   = _My_data._Myend;
+        _STL_INTERNAL_CHECK(!_Myfirst && !_Mylast && !_Myend); // check that *this is tidy
+        _STL_INTERNAL_CHECK(0 < _Newcapacity);
+#endif // _ENABLE_STL_INTERNAL_CHECK
+
+        if (_Newcapacity > max_size()) {
+            _Xlength();
+        }
+
+        _Buy_raw(_Newcapacity);
+    }
+
+    _CONSTEXPR20 void _Change_array(const pointer _Newvec, const size_type _Newsize, const size_type _Newcapacity) {
+        // orphan all iterators, discard old array, acquire new array
+        auto& _Al         = _Getal();
+        auto& _My_data    = _Mypair._Myval2;
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+        pointer& _Myend   = _My_data._Myend;
+
+        _My_data._Orphan_all();
+
+        if (_Myfirst) { // destroy and deallocate old array
+            _STD _Destroy_range(_Myfirst, _Mylast, _Al);
+            _ASAN_VECTOR_REMOVE;
+            _Al.deallocate(_Myfirst, static_cast<size_type>(_Myend - _Myfirst));
+        }
+
+        _Myfirst = _Newvec;
+        _Mylast  = _Newvec + _Newsize;
+        _Myend   = _Newvec + _Newcapacity;
+        _ASAN_VECTOR_CREATE;
+    }
+
+    _CONSTEXPR20 void _Tidy() noexcept { // free all storage
+        auto& _Al         = _Getal();
+        auto& _My_data    = _Mypair._Myval2;
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+        pointer& _Myend   = _My_data._Myend;
+
+        _My_data._Orphan_all();
+
+        if (_Myfirst) { // destroy and deallocate old array
+            _STD _Destroy_range(_Myfirst, _Mylast, _Al);
+            _ASAN_VECTOR_REMOVE;
+            _Al.deallocate(_Myfirst, static_cast<size_type>(_Myend - _Myfirst));
+
+            _Myfirst = nullptr;
+            _Mylast  = nullptr;
+            _Myend   = nullptr;
+        }
+    }
+
+    template <class... _Valty>
+    _CONSTEXPR20 void _Construct_n(_CRT_GUARDOVERFLOW const size_type _Count, _Valty&&... _Val) {
+        // Dispatches between the three sized constructions.
+        // 1-arg -> value-construction, e.g. vector(5)
+        // 2-arg -> fill, e.g. vector(5, "meow")
+        // 3-arg -> sized range construction, e.g. vector{"Hello", "Fluffy", "World"}
+        auto& _Al       = _Getal();
+        auto&& _Alproxy = _GET_PROXY_ALLOCATOR(_Alty, _Al);
+        auto& _My_data  = _Mypair._Myval2;
+        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _My_data);
+        if (_Count != 0) {
+            _Buy_nonzero(_Count);
+            _Tidy_guard<vector> _Guard{this};
+            if constexpr (sizeof...(_Val) == 0) {
+                _My_data._Mylast = _STD _Uninitialized_value_construct_n(_My_data._Myfirst, _Count, _Al);
+            } else if constexpr (sizeof...(_Val) == 1) {
+                _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Valty..., const _Ty&>);
+                _My_data._Mylast = _STD _Uninitialized_fill_n(_My_data._Myfirst, _Count, _Val..., _Al);
+            } else if constexpr (sizeof...(_Val) == 2) {
+                _My_data._Mylast = _STD _Uninitialized_copy(_STD forward<_Valty>(_Val)..., _My_data._Myfirst, _Al);
+            } else {
+                _STL_INTERNAL_STATIC_ASSERT(false); // unexpected number of arguments
+            }
+            _ASAN_VECTOR_CREATE;
+            _Guard._Target = nullptr;
+        }
+
+        _Proxy._Release();
+    }
+
+    _CONSTEXPR20 void _Move_assign_unequal_alloc(vector& _Right) {
+        auto& _Al         = _Getal();
+        auto& _My_data    = _Mypair._Myval2;
+        auto& _Right_data = _Right._Mypair._Myval2;
+
+        const pointer _First = _Right_data._Myfirst;
+        const pointer _Last  = _Right_data._Mylast;
+        const auto _Newsize  = static_cast<size_type>(_Last - _First);
+
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+
+        constexpr bool _Nothrow_construct =
+            conjunction_v<is_nothrow_move_constructible<_Ty>, _Uses_default_construct<_Alloc, _Ty*, _Ty>>;
+
+        _My_data._Orphan_all();
+        const auto _Oldcapacity = static_cast<size_type>(_My_data._Myend - _Myfirst);
+        if (_Newsize > _Oldcapacity) {
+            _Clear_and_reserve_geometric(_Newsize);
+            if constexpr (_Nothrow_construct) {
+                _Mylast = _Uninitialized_move(_First, _Last, _Myfirst, _Al);
+                _ASAN_VECTOR_CREATE;
+            } else {
+                _ASAN_VECTOR_CREATE_GUARD;
+                _Mylast = _Uninitialized_move(_First, _Last, _Myfirst, _Al);
+            }
+
+            return;
+        }
+
+        const auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
+        if (_Newsize > _Oldsize) {
+            const pointer _Mid = _First + _Oldsize;
+            _STD _Move_unchecked(_First, _Mid, _Myfirst);
+
+            if constexpr (_Nothrow_construct) {
+                _ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Newsize - _Oldsize));
+                _Mylast = _Uninitialized_move(_Mid, _Last, _Mylast, _Al);
+            } else {
+                _ASAN_VECTOR_EXTEND_GUARD(_Newsize);
+                _Mylast = _Uninitialized_move(_Mid, _Last, _Mylast, _Al);
+                _ASAN_VECTOR_RELEASE_GUARD;
+            }
+        } else {
+            const pointer _Newlast = _Myfirst + _Newsize;
+            _STD _Move_unchecked(_First, _Last, _Myfirst);
+            _Destroy_range(_Newlast, _Mylast, _Al);
+            _ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Newsize - _Oldsize));
+            _Mylast = _Newlast;
+        }
+    }
+
+    [[noreturn]] static void _Xlength() {
+        _Xlength_error("vector too long");
+    }
+
+    [[noreturn]] static void _Xrange() {
+        _Xout_of_range("invalid vector subscript");
+    }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+    _CONSTEXPR20 void _Orphan_range_unlocked(pointer _First, pointer _Last) const {
+        _Iterator_base12** _Pnext = &_Mypair._Myval2._Myproxy->_Myfirstiter;
+        while (*_Pnext) {
+            const auto _Pnextptr = static_cast<const_iterator&>(**_Pnext)._Ptr;
+            const auto _Temp     = *_Pnext;
+            if (_Pnextptr < _First || _Last < _Pnextptr) { // skip the iterator
+                _Pnext = &_Temp->_Mynextiter;
+            } else { // orphan the iterator
+                _Temp->_Myproxy = nullptr;
+                *_Pnext         = _Temp->_Mynextiter;
+            }
+        }
+    }
+
+    void _Orphan_range_locked(pointer _First, pointer _Last) const {
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Orphan_range_unlocked(_First, _Last);
+    }
+
+    _CONSTEXPR20 void _Orphan_range(pointer _First, pointer _Last) const {
+        // orphan iterators within specified (inclusive) range
+#if _HAS_CXX20
+        if (_STD is_constant_evaluated()) {
+            _Orphan_range_unlocked(_First, _Last);
+        } else
+#endif // _HAS_CXX20
+        {
+            _Orphan_range_locked(_First, _Last);
+        }
+    }
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 2 / _ITERATOR_DEBUG_LEVEL != 2 vvv
+    _CONSTEXPR20 void _Orphan_range(pointer, pointer) const {}
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 2 ^^^
+
+    _NODISCARD _CONSTEXPR20 _Alty& _Getal() noexcept {
+        return _Mypair._Get_first();
+    }
+
+    _NODISCARD _CONSTEXPR20 const _Alty& _Getal() const noexcept {
+        return _Mypair._Get_first();
+    }
+
+    _NODISCARD _CONSTEXPR20 iterator _Make_iterator(const pointer _Ptr) noexcept {
+        return iterator(_Ptr, _STD addressof(_Mypair._Myval2));
+    }
+
+    _NODISCARD _CONSTEXPR20 iterator _Make_iterator_offset(const size_type _Offset) noexcept {
+        // return the iterator begin() + _Offset without a debugging check
+        auto& _My_data = _Mypair._Myval2;
+        return iterator(_My_data._Myfirst + _Offset, _STD addressof(_My_data));
+    }
+
+    _Compressed_pair<_Alty, _Scary_val> _Mypair;
+};
+
+#if _HAS_CXX17
+template <class _Iter, class _Alloc = allocator<_Iter_value_t<_Iter>>,
+    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
+vector(_Iter, _Iter, _Alloc = _Alloc()) -> vector<_Iter_value_t<_Iter>, _Alloc>;
+#endif // _HAS_CXX17
+
+#if _HAS_CXX23
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc = allocator<_RANGES range_value_t<_Rng>>>
+vector(from_range_t, _Rng&&, _Alloc = _Alloc()) -> vector<_RANGES range_value_t<_Rng>, _Alloc>;
+#endif // _HAS_CXX23
+
+template <class _Alloc>
+class vector<bool, _Alloc>;
+
+using _Vbase = unsigned int; // word type for vector<bool> representation
+
+_INLINE_VAR constexpr int _VBITS = 8 * sizeof(_Vbase); // at least CHAR_BITS bits per word
+
+_EXPORT_STD template <class _Ty, class _Alloc>
+_NODISCARD _CONSTEXPR20 bool operator==(const vector<_Ty, _Alloc>& _Left, const vector<_Ty, _Alloc>& _Right) {
+    if (_Left.size() != _Right.size()) {
+        return false;
+    }
+
+    if constexpr (is_same_v<_Ty, bool>) {
+        return _STD equal(
+            _Left._Myvec._Unchecked_begin(), _Left._Myvec._Unchecked_end(), _Right._Myvec._Unchecked_begin());
+    } else {
+        return _STD equal(_Left._Unchecked_begin(), _Left._Unchecked_end(), _Right._Unchecked_begin());
+    }
+}
+
+#if !_HAS_CXX20
+template <class _Ty, class _Alloc>
+_NODISCARD bool operator!=(const vector<_Ty, _Alloc>& _Left, const vector<_Ty, _Alloc>& _Right) {
+    return !(_Left == _Right);
+}
+#endif // !_HAS_CXX20
+
+// Optimize vector<bool> lexicographical comparisons.
+
+// There are several endianness/ordering issues to consider here.
+// * Machine endianness is irrelevant. (That affects how an unsigned int is stored
+//   as a sequence of bytes. While all of our supported architectures are little-endian,
+//   that's irrelevant as long as we avoid reinterpreting unsigned int as a sequence of bytes.)
+// * Appending bits to vector<bool> eventually appends words to its underlying storage.
+//   For example, vb[10] is stored within vb._Myvec[0], while vb[100] is stored within vb._Myvec[3].
+//   This allows us to translate lexicographical comparisons from theoretical bits to physical words.
+// * Unsigned integers are written and compared as big-endian (most significant bit first).
+//   For example, 0x10u > 0x07u.
+// * However, vector<bool> packs bits into words as little-endian (least significant bit first).
+//   For example, vector<bool>{false, true, true, true} stores 0b0000'0000'0000'0000'0000'0000'0000'1110u.
+// We could bit-reverse words before comparing, but we just need to find the least significant bit that differs.
+
+template <class _Ret>
+struct _Vbase_compare_three_way {
+    _NODISCARD _STATIC_CALL_OPERATOR constexpr _Ret operator()(
+        const _Vbase _Left, const _Vbase _Right) _CONST_CALL_OPERATOR noexcept {
+        const _Vbase _Differing_bits = _Left ^ _Right;
+
+        if (_Differing_bits == 0) { // improves _Countr_zero codegen below
+#if _HAS_CXX20
+            return strong_ordering::equal;
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+            return 0;
+#endif // ^^^ !_HAS_CXX20 ^^^
+        }
+
+        const int _Bit_index = _Countr_zero(_Differing_bits); // number of least significant bits that match
+        _STL_INTERNAL_CHECK(_Bit_index < _VBITS); // because we return early for equality
+
+        const _Vbase _Mask = _Vbase{1} << _Bit_index; // selects the least significant bit that differs
+
+        // Instead of comparing (_Left & _Mask) to (_Right & _Mask), we know that exactly one side will be zero.
+#if _HAS_CXX20
+        return (_Left & _Mask) == 0 ? strong_ordering::less : strong_ordering::greater;
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+        return (_Left & _Mask) == 0 ? -1 : 1;
+#endif // ^^^ !_HAS_CXX20 ^^^
+    }
+};
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty, class _Alloc>
+_NODISCARD constexpr _Synth_three_way_result<_Ty> operator<=>(
+    const vector<_Ty, _Alloc>& _Left, const vector<_Ty, _Alloc>& _Right) {
+    if constexpr (is_same_v<_Ty, bool>) {
+        // This optimization works because vector<bool> "trims" its underlying storage by zeroing out unused bits.
+        const auto _Min_word_size = (_STD min)(_Left._Myvec.size(), _Right._Myvec.size());
+        const auto _Left_words    = _Left._Myvec._Unchecked_begin();
+        const auto _Right_words   = _Right._Myvec._Unchecked_begin();
+
+        using _Comp = _Vbase_compare_three_way<strong_ordering>;
+
+        const strong_ordering _Word_comparison = _STD lexicographical_compare_three_way(
+            _Left_words, _Left_words + _Min_word_size, _Right_words, _Right_words + _Min_word_size, _Comp{});
+
+        if (_Word_comparison != 0) {
+            return _Word_comparison;
+        }
+
+        return _Left.size() <=> _Right.size();
+    } else {
+        return _STD lexicographical_compare_three_way(_Left._Unchecked_begin(), _Left._Unchecked_end(),
+            _Right._Unchecked_begin(), _Right._Unchecked_end(), _Synth_three_way{});
+    }
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Ty, class _Alloc>
+_NODISCARD _CONSTEXPR20 bool operator<(const vector<_Ty, _Alloc>& _Left, const vector<_Ty, _Alloc>& _Right) {
+    if constexpr (is_same_v<_Ty, bool>) {
+        // This optimization works because vector<bool> "trims" its underlying storage by zeroing out unused bits.
+        auto _First = _Left._Myvec._Unchecked_begin();
+        auto _Other = _Right._Myvec._Unchecked_begin();
+
+        const auto _Last = _First + (_STD min)(_Left._Myvec.size(), _Right._Myvec.size());
+
+        for (; _First != _Last; ++_First, (void) ++_Other) {
+            using _Comp        = _Vbase_compare_three_way<signed char>;
+            const auto _Result = _Comp{}(*_First, *_Other);
+
+            if (_Result < 0) {
+                return true;
+            } else if (_Result > 0) {
+                return false;
+            }
+        }
+
+        return _Left.size() < _Right.size();
+    } else {
+        return _STD lexicographical_compare(
+            _Left._Unchecked_begin(), _Left._Unchecked_end(), _Right._Unchecked_begin(), _Right._Unchecked_end());
+    }
+}
+
+template <class _Ty, class _Alloc>
+_NODISCARD _CONSTEXPR20 bool operator>(const vector<_Ty, _Alloc>& _Left, const vector<_Ty, _Alloc>& _Right) {
+    return _Right < _Left;
+}
+
+template <class _Ty, class _Alloc>
+_NODISCARD _CONSTEXPR20 bool operator<=(const vector<_Ty, _Alloc>& _Left, const vector<_Ty, _Alloc>& _Right) {
+    return !(_Right < _Left);
+}
+
+template <class _Ty, class _Alloc>
+_NODISCARD _CONSTEXPR20 bool operator>=(const vector<_Ty, _Alloc>& _Left, const vector<_Ty, _Alloc>& _Right) {
+    return !(_Left < _Right);
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+_EXPORT_STD template <class _Ty, class _Alloc>
+_CONSTEXPR20 void swap(vector<_Ty, _Alloc>& _Left, vector<_Ty, _Alloc>& _Right) noexcept /* strengthened */ {
+    _Left.swap(_Right);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty, class _Alloc, class _Uty>
+constexpr vector<_Ty, _Alloc>::size_type erase(vector<_Ty, _Alloc>& _Cont, const _Uty& _Val) {
+    return _STD _Erase_remove(_Cont, _Val);
+}
+
+_EXPORT_STD template <class _Ty, class _Alloc, class _Pr>
+constexpr vector<_Ty, _Alloc>::size_type erase_if(vector<_Ty, _Alloc>& _Cont, _Pr _Pred) {
+    return _STD _Erase_remove_if(_Cont, _STD _Pass_fn(_Pred));
+}
+#endif // _HAS_CXX20
+
+template <class _Alloc0>
+struct _Wrap_alloc { // TRANSITION, ABI compat, preserves symbol names of vector<bool>::iterator
+    using _Alloc = _Alloc0;
+};
+
+template <class _Alvbase_wrapped>
+class _Vb_iter_base : public _Iterator_base {
+    // store information common to reference and iterators
+public:
+    using _Alvbase         = typename _Alvbase_wrapped::_Alloc;
+    using _Size_type       = typename allocator_traits<_Alvbase>::size_type;
+    using _Difference_type = typename allocator_traits<_Alvbase>::difference_type;
+    using _Mycont          = vector<bool, _Rebind_alloc_t<_Alvbase, bool>>;
+
+    static constexpr _Difference_type _VBITS_DIFF = _VBITS;
+
+    _CONSTEXPR20 _Vb_iter_base() = default;
+
+    _CONSTEXPR20 _Vb_iter_base(const _Vbase* _Ptr, _Size_type _Off, const _Container_base* _Mypvbool) noexcept
+        : _Myptr(_Ptr), _Myoff(_Off) {
+        this->_Adopt(_Mypvbool);
+    }
+
+    _CONSTEXPR20 void _Advance(_Size_type _Off) noexcept {
+        _Myoff += _Off;
+        _Myptr += _Myoff / _VBITS;
+        _Myoff %= _VBITS;
+    }
+
+#if _ITERATOR_DEBUG_LEVEL != 0
+    _CONSTEXPR20 _Difference_type _Total_off(const _Mycont* _Cont) const noexcept {
+        return static_cast<_Difference_type>(_VBITS_DIFF * (_Myptr - _Cont->_Myvec.data()) + _Myoff);
+    }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+    const _Vbase* _Myptr = nullptr;
+    _Size_type _Myoff    = 0;
+};
+
+template <class _Alvbase_wrapped>
+class _Vb_reference : public _Vb_iter_base<_Alvbase_wrapped> {
+    // reference to a bit within a base word
+private:
+    using _Mybase          = _Vb_iter_base<_Alvbase_wrapped>;
+    using _Mycont          = typename _Mybase::_Mycont;
+    using _Difference_type = typename _Mybase::_Difference_type;
+
+    // TRANSITION, ABI: non-trivial constructor
+    _CONSTEXPR20 _Vb_reference() = default;
+
+public:
+    _CONSTEXPR20 _Vb_reference(const _Vb_reference&) = default;
+
+    _CONSTEXPR20 _Vb_reference(const _Mybase& _Right) noexcept
+        : _Mybase(_Right._Myptr, _Right._Myoff, _Right._Getcont()) {}
+
+    _CONSTEXPR20 _Vb_reference& operator=(const _Vb_reference& _Right) noexcept {
+        return *this = static_cast<bool>(_Right);
+    }
+
+    _CONSTEXPR20 _Vb_reference& operator=(bool _Val) noexcept {
+        if (_Val) {
+            *const_cast<_Vbase*>(_Getptr()) |= _Mask();
+        } else {
+            *const_cast<_Vbase*>(_Getptr()) &= ~_Mask();
+        }
+
+        return *this;
+    }
+
+#if _HAS_CXX23
+    constexpr const _Vb_reference& operator=(bool _Val) const noexcept {
+        if (_Val) {
+            *const_cast<_Vbase*>(_Getptr()) |= _Mask();
+        } else {
+            *const_cast<_Vbase*>(_Getptr()) &= ~_Mask();
+        }
+
+        return *this;
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 void flip() noexcept {
+        *const_cast<_Vbase*>(_Getptr()) ^= _Mask();
+    }
+
+    _CONSTEXPR20 operator bool() const noexcept {
+        return (*_Getptr() & _Mask()) != 0;
+    }
+
+    _CONSTEXPR20 const _Vbase* _Getptr() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Cont = static_cast<const _Mycont*>(this->_Getcont());
+        _STL_VERIFY(_Cont, "cannot dereference value-initialized vector<bool> iterator");
+        _STL_VERIFY(this->_Total_off(_Cont) <= static_cast<_Difference_type>(_Cont->_Mysize),
+            "vector<bool> iterator not dereferenceable");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        return this->_Myptr;
+    }
+
+    friend _CONSTEXPR20 void swap(_Vb_reference _Left, _Vb_reference _Right) noexcept {
+        bool _Val = _Left; // NOT _STD swap
+        _Left     = _Right;
+        _Right    = _Val;
+    }
+
+protected:
+    _CONSTEXPR20 _Vbase _Mask() const noexcept {
+        return static_cast<_Vbase>(1) << this->_Myoff;
+    }
+};
+
+template <class _Alvbase_wrapped>
+class _Vb_const_iterator : public _Vb_iter_base<_Alvbase_wrapped> {
+public:
+    using _Mybase         = _Vb_iter_base<_Alvbase_wrapped>;
+    using _Mycont         = typename _Mybase::_Mycont;
+    using _Size_type      = typename _Mybase::_Size_type;
+    using _Reft           = _Vb_reference<_Alvbase_wrapped>;
+    using const_reference = bool;
+
+    using iterator_category = random_access_iterator_tag;
+    using value_type        = bool;
+    using difference_type   = typename _Mybase::_Difference_type;
+    using pointer           = const_reference*;
+    using reference         = const_reference;
+
+    _CONSTEXPR20 _Vb_const_iterator() = default;
+
+    _CONSTEXPR20 _Vb_const_iterator(const _Vbase* _Ptr, const _Container_base* _Mypvbool) noexcept
+        : _Mybase(_Ptr, 0, _Mypvbool) {}
+
+    _NODISCARD _CONSTEXPR20 const_reference operator*() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Cont = static_cast<const _Mycont*>(this->_Getcont());
+        _STL_VERIFY(_Cont, "cannot dereference value-initialized vector<bool> iterator");
+        _STL_VERIFY(this->_Total_off(_Cont) < static_cast<difference_type>(_Cont->_Mysize),
+            "vector<bool> iterator not dereferenceable");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        return _Reft(*this);
+    }
+
+    _CONSTEXPR20 _Vb_const_iterator& operator++() noexcept {
+        _Inc();
+        return *this;
+    }
+
+    _CONSTEXPR20 _Vb_const_iterator operator++(int) noexcept {
+        _Vb_const_iterator _Tmp = *this;
+        _Inc();
+        return _Tmp;
+    }
+
+    _CONSTEXPR20 _Vb_const_iterator& operator--() noexcept {
+        _Dec();
+        return *this;
+    }
+
+    _CONSTEXPR20 _Vb_const_iterator operator--(int) noexcept {
+        _Vb_const_iterator _Tmp = *this;
+        _Dec();
+        return _Tmp;
+    }
+
+    _CONSTEXPR20 _Vb_const_iterator& operator+=(const difference_type _Off) noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        if (_Off != 0) {
+            const auto _Cont = static_cast<const _Mycont*>(this->_Getcont());
+            _STL_VERIFY(_Cont, "cannot seek value-initialized vector<bool> iterator");
+            const auto _Start_offset = this->_Total_off(_Cont);
+            if (_Off < 0) {
+                _STL_VERIFY(-_Start_offset <= _Off, "cannot seek vector<bool> iterator before begin");
+            } else if (0 < _Off) {
+                _STL_VERIFY(_Off <= static_cast<difference_type>(_Cont->_Mysize - _Start_offset),
+                    "cannot seek vector<bool> iterator after end");
+            }
+        }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        if (_Off < 0 && this->_Myoff < 0 - static_cast<_Size_type>(_Off)) { // add negative increment
+            this->_Myoff += static_cast<_Size_type>(_Off);
+            this->_Myptr -= 1 + (static_cast<_Size_type>(-1) - this->_Myoff) / _VBITS;
+            this->_Myoff %= _VBITS;
+        } else { // add non-negative increment
+            this->_Myoff += static_cast<_Size_type>(_Off);
+            this->_Myptr += this->_Myoff / _VBITS;
+            this->_Myoff %= _VBITS;
+        }
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR20 _Vb_const_iterator operator+(const difference_type _Off) const noexcept {
+        _Vb_const_iterator _Tmp = *this;
+        _Tmp += _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD friend _CONSTEXPR20 _Vb_const_iterator operator+(
+        const difference_type _Off, _Vb_const_iterator _Right) noexcept {
+        _Right += _Off;
+        return _Right;
+    }
+
+    _CONSTEXPR20 _Vb_const_iterator& operator-=(const difference_type _Off) noexcept {
+        return *this += -_Off;
+    }
+
+    _NODISCARD _CONSTEXPR20 _Vb_const_iterator operator-(const difference_type _Off) const noexcept {
+        _Vb_const_iterator _Tmp = *this;
+        _Tmp -= _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD _CONSTEXPR20 difference_type operator-(const _Vb_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return static_cast<difference_type>(_Mybase::_VBITS_DIFF * (this->_Myptr - _Right._Myptr))
+             + static_cast<difference_type>(this->_Myoff) - static_cast<difference_type>(_Right._Myoff);
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reference operator[](const difference_type _Off) const noexcept {
+        return *(*this + _Off);
+    }
+
+    _NODISCARD _CONSTEXPR20 bool operator==(const _Vb_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return this->_Myptr == _Right._Myptr && this->_Myoff == _Right._Myoff;
+    }
+
+#if _HAS_CXX20
+    _NODISCARD constexpr strong_ordering operator<=>(const _Vb_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        if (const auto _CmpResult = this->_Myptr <=> _Right._Myptr; _CmpResult != 0) {
+            return _CmpResult;
+        }
+        return this->_Myoff <=> _Right._Myoff;
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD bool operator!=(const _Vb_const_iterator& _Right) const noexcept {
+        return !(*this == _Right);
+    }
+
+    _NODISCARD bool operator<(const _Vb_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return this->_Myptr < _Right._Myptr || (this->_Myptr == _Right._Myptr && this->_Myoff < _Right._Myoff);
+    }
+
+    _NODISCARD bool operator>(const _Vb_const_iterator& _Right) const noexcept {
+        return _Right < *this;
+    }
+
+    _NODISCARD bool operator<=(const _Vb_const_iterator& _Right) const noexcept {
+        return !(_Right < *this);
+    }
+
+    _NODISCARD bool operator>=(const _Vb_const_iterator& _Right) const noexcept {
+        return !(*this < _Right);
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    _CONSTEXPR20 void _Compat(const _Vb_const_iterator& _Right) const noexcept {
+        // test for compatible iterator pair
+#if _ITERATOR_DEBUG_LEVEL == 0
+        (void) _Right;
+#else
+        _STL_VERIFY(this->_Getcont() == _Right._Getcont(), "vector<bool> iterators incompatible");
+#endif
+    }
+
+#if _ITERATOR_DEBUG_LEVEL != 0
+    using _Prevent_inheriting_unwrap = _Vb_const_iterator;
+
+    friend _CONSTEXPR20 void _Verify_range(const _Vb_const_iterator& _First, const _Vb_const_iterator& _Last) noexcept {
+        // note _Compat check inside <=
+        _STL_VERIFY(_First <= _Last, "vector<bool> iterator range transposed");
+    }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+    _CONSTEXPR20 void _Dec() noexcept { // decrement bit position
+#if _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Cont = static_cast<const _Mycont*>(this->_Getcont());
+        _STL_VERIFY(_Cont, "cannot decrement value-initialized vector<bool> iterator");
+        _STL_VERIFY(this->_Total_off(_Cont) > 0, "cannot decrement vector<bool> begin iterator");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        if (this->_Myoff != 0) {
+            --this->_Myoff;
+        } else { // move to previous word
+            this->_Myoff = _VBITS - 1;
+            --this->_Myptr;
+        }
+    }
+
+    _CONSTEXPR20 void _Inc() noexcept { // increment bit position
+#if _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Cont = static_cast<const _Mycont*>(this->_Getcont());
+        _STL_VERIFY(_Cont, "cannot increment value-initialized vector<bool> iterator");
+        _STL_VERIFY(this->_Total_off(_Cont) < static_cast<difference_type>(_Cont->_Mysize),
+            "cannot increment vector<bool> end iterator");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        if (this->_Myoff < _VBITS - 1) {
+            ++this->_Myoff;
+        } else { // move to next word
+            this->_Myoff = 0;
+            ++this->_Myptr;
+        }
+    }
+};
+
+template <class _Alvbase_wrapped>
+class _Vb_iterator : public _Vb_const_iterator<_Alvbase_wrapped> {
+public:
+    using _Mybase = _Vb_const_iterator<_Alvbase_wrapped>;
+    using _Mycont = typename _Mybase::_Mycont;
+
+    using _Reft           = _Vb_reference<_Alvbase_wrapped>;
+    using const_reference = bool;
+
+    using iterator_category = random_access_iterator_tag;
+    using value_type        = bool;
+    using difference_type   = typename _Mybase::difference_type;
+    using pointer           = _Reft*;
+    using reference         = _Reft;
+
+    using _Mybase::_Mybase;
+
+    _NODISCARD _CONSTEXPR20 reference operator*() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Cont = static_cast<const _Mycont*>(this->_Getcont());
+        _STL_VERIFY(_Cont, "cannot dereference value-initialized vector<bool> iterator");
+        _STL_VERIFY(this->_Total_off(_Cont) < static_cast<difference_type>(_Cont->_Mysize),
+            "vector<bool> iterator not dereferenceable");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        return _Reft(*this);
+    }
+
+    _CONSTEXPR20 _Vb_iterator& operator++() noexcept {
+        _Mybase::operator++();
+        return *this;
+    }
+
+    _CONSTEXPR20 _Vb_iterator operator++(int) noexcept {
+        _Vb_iterator _Tmp = *this;
+        _Mybase::operator++();
+        return _Tmp;
+    }
+
+    _CONSTEXPR20 _Vb_iterator& operator--() noexcept {
+        _Mybase::operator--();
+        return *this;
+    }
+
+    _CONSTEXPR20 _Vb_iterator operator--(int) noexcept {
+        _Vb_iterator _Tmp = *this;
+        _Mybase::operator--();
+        return _Tmp;
+    }
+
+    _CONSTEXPR20 _Vb_iterator& operator+=(const difference_type _Off) noexcept {
+        _Mybase::operator+=(_Off);
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR20 _Vb_iterator operator+(const difference_type _Off) const noexcept {
+        _Vb_iterator _Tmp = *this;
+        _Tmp += _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD friend _CONSTEXPR20 _Vb_iterator operator+(const difference_type _Off, _Vb_iterator _Right) noexcept {
+        _Right += _Off;
+        return _Right;
+    }
+
+    _CONSTEXPR20 _Vb_iterator& operator-=(const difference_type _Off) noexcept {
+        _Mybase::operator-=(_Off);
+        return *this;
+    }
+
+    using _Mybase::operator-;
+
+    _NODISCARD _CONSTEXPR20 _Vb_iterator operator-(const difference_type _Off) const noexcept {
+        _Vb_iterator _Tmp = *this;
+        _Tmp -= _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD _CONSTEXPR20 reference operator[](const difference_type _Off) const noexcept {
+        return *(*this + _Off);
+    }
+
+    using _Prevent_inheriting_unwrap = _Vb_iterator;
+};
+
+template <class _Alloc>
+class _Vb_val : public _Container_base {
+public:
+    using _Alvbase         = _Rebind_alloc_t<_Alloc, _Vbase>;
+    using _Alvbase_traits  = allocator_traits<_Alvbase>;
+    using _Vectype         = vector<_Vbase, _Alvbase>;
+    using _Alvbase_wrapped = _Wrap_alloc<_Alvbase>;
+    using size_type        = typename _Alvbase_traits::size_type;
+
+    _CONSTEXPR20 _Vb_val() noexcept(is_nothrow_default_constructible_v<_Vectype>) : _Myvec(), _Mysize(0) {
+        this->_Alloc_proxy(_GET_PROXY_ALLOCATOR(_Alvbase, _Getal()));
+    }
+
+    _CONSTEXPR20 _Vb_val(const _Alloc& _Al) noexcept : _Myvec(static_cast<_Alvbase>(_Al)), _Mysize(0) {
+        this->_Alloc_proxy(_GET_PROXY_ALLOCATOR(_Alvbase, _Getal()));
+    }
+
+    _CONSTEXPR20 _Vb_val(size_type _Count, const bool& _Val)
+        : _Myvec(_Nw(_Count), static_cast<_Vbase>(_Val ? -1 : 0)), _Mysize(0) {
+        this->_Alloc_proxy(_GET_PROXY_ALLOCATOR(_Alvbase, _Getal()));
+    }
+
+    _CONSTEXPR20 _Vb_val(size_type _Count, const bool& _Val, const _Alloc& _Al)
+        : _Myvec(_Nw(_Count), static_cast<_Vbase>(_Val ? -1 : 0), static_cast<_Alvbase>(_Al)), _Mysize(0) {
+        this->_Alloc_proxy(_GET_PROXY_ALLOCATOR(_Alvbase, _Getal()));
+    }
+
+    _CONSTEXPR20 _Vb_val(const _Vb_val& _Right) : _Myvec(_Right._Myvec), _Mysize(_Right._Mysize) {
+        this->_Alloc_proxy(_GET_PROXY_ALLOCATOR(_Alvbase, _Getal()));
+    }
+
+    _CONSTEXPR20 _Vb_val(const _Vb_val& _Right, const _Alloc& _Al)
+        : _Myvec(_Right._Myvec, static_cast<_Alvbase>(_Al)), _Mysize(_Right._Mysize) {
+        this->_Alloc_proxy(_GET_PROXY_ALLOCATOR(_Alvbase, _Getal()));
+    }
+
+    _CONSTEXPR20 _Vb_val(_Vb_val&& _Right) noexcept(is_nothrow_move_constructible_v<_Vectype>)
+        : _Myvec(_STD move(_Right._Myvec)), _Mysize(_STD exchange(_Right._Mysize, size_type{0})) {
+        this->_Alloc_proxy(_GET_PROXY_ALLOCATOR(_Alvbase, _Getal()));
+    }
+
+    _CONSTEXPR20 _Vb_val(_Vb_val&& _Right, const _Alloc& _Al) noexcept(
+        is_nothrow_constructible_v<_Vectype, _Vectype, _Alvbase>)
+        : _Myvec(_STD move(_Right._Myvec), static_cast<_Alvbase>(_Al)), _Mysize(_Right._Mysize) {
+        if (_Right._Myvec.empty()) {
+            // we took _Right's buffer, so zero out size
+            _Right._Mysize = 0;
+        }
+
+        this->_Alloc_proxy(_GET_PROXY_ALLOCATOR(_Alvbase, _Getal()));
+    }
+
+    _CONSTEXPR20 ~_Vb_val() noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        this->_Orphan_all();
+        auto&& _Alproxy = _GET_PROXY_ALLOCATOR(_Alvbase, this->_Getal());
+        _Delete_plain_internal(_Alproxy, _STD exchange(this->_Myproxy, nullptr));
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+    _CONSTEXPR20 _Alvbase& _Getal() noexcept {
+        return _Myvec._Getal();
+    }
+
+    _CONSTEXPR20 const _Alvbase& _Getal() const noexcept {
+        return _Myvec._Getal();
+    }
+
+    static _CONSTEXPR20 size_type _Nw(size_type _Count) noexcept {
+        return (_Count + _VBITS - 1) / _VBITS;
+    }
+
+    _CONSTEXPR20 void _Emplace_back_unchecked(const _Vbase _Val) noexcept {
+        _STL_INTERNAL_CHECK(_Myvec.size() < _Myvec.capacity());
+        _Myvec._Emplace_back_with_unused_capacity(_Val);
+    }
+
+    _Vectype _Myvec; // base vector of words
+    size_type _Mysize; // current length of sequence
+};
+
+template <class _Alloc>
+class vector<bool, _Alloc> : public _Vb_val<_Alloc> {
+public:
+    static_assert(!_ENFORCE_MATCHING_ALLOCATORS || is_same_v<bool, typename _Alloc::value_type>,
+        _MISMATCHED_ALLOCATOR_MESSAGE("vector<bool, Allocator>", "bool"));
+
+    using _Mybase          = _Vb_val<_Alloc>;
+    using _Alvbase_wrapped = typename _Mybase::_Alvbase_wrapped;
+    using _Alvbase         = typename _Mybase::_Alvbase;
+    using _Alvbase_traits  = typename _Mybase::_Alvbase_traits;
+
+    using size_type       = typename _Alvbase_traits::size_type;
+    using difference_type = typename _Alvbase_traits::difference_type;
+    using allocator_type  = _Alloc;
+
+    using reference       = _Vb_reference<_Alvbase_wrapped>;
+    using const_reference = bool;
+    using value_type      = bool;
+
+    using _Reft          = reference;
+    using iterator       = _Vb_iterator<_Alvbase_wrapped>;
+    using const_iterator = _Vb_const_iterator<_Alvbase_wrapped>;
+
+    using pointer                = iterator;
+    using const_pointer          = const_iterator;
+    using reverse_iterator       = _STD reverse_iterator<iterator>;
+    using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
+
+    enum { _EEN_VBITS = _VBITS }; // helper for expression evaluator
+
+    _CONSTEXPR20 vector() noexcept(is_nothrow_default_constructible_v<_Alloc>) : _Mybase(_Alloc()) {}
+
+    _CONSTEXPR20 explicit vector(const _Alloc& _Al) noexcept : _Mybase(_Al) {}
+
+    _CONSTEXPR20 explicit vector(_CRT_GUARDOVERFLOW size_type _Count, const _Alloc& _Al = _Alloc())
+        : _Mybase(_Count, false, _Al) {
+        _Trim(_Count);
+    }
+
+    _CONSTEXPR20 vector(_CRT_GUARDOVERFLOW size_type _Count, const bool& _Val, const _Alloc& _Al = _Alloc())
+        : _Mybase(_Count, _Val, _Al) {
+        _Trim(_Count);
+    }
+
+    _CONSTEXPR20 vector(const vector& _Right) : _Mybase(_Right) {}
+
+    _CONSTEXPR20 vector(const vector& _Right, const _Identity_t<_Alloc>& _Al) : _Mybase(_Right, _Al) {}
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    _CONSTEXPR20 vector(_Iter _First, _Iter _Last, const _Alloc& _Al = _Alloc()) : _Mybase(_Al) {
+        insert(begin(), _First, _Last);
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<bool> _Rng>
+    constexpr vector(from_range_t, _Rng&& _Range, const _Alloc& _Al = _Alloc()) : _Mybase(_Al) {
+        if constexpr (_RANGES forward_range<_Rng> || _RANGES sized_range<_Rng>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_Range));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            _Assign_counted_range(_RANGES _Ubegin(_Range), _Count);
+        } else {
+            _Assign_uncounted_range(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        }
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 vector(vector&& _Right) noexcept : _Mybase(_STD move(_Right)) {
+        this->_Swap_proxy_and_iterators(_Right);
+    }
+
+    _CONSTEXPR20 vector(vector&& _Right, const _Identity_t<_Alloc>& _Al) noexcept(
+        is_nothrow_constructible_v<_Mybase, _Mybase, const _Alloc&>) // strengthened
+        : _Mybase(_STD move(_Right), _Al) {
+        if constexpr (!_Alvbase_traits::is_always_equal::value) {
+            if (this->_Getal() != _Right._Getal()) {
+                return;
+            }
+        }
+
+        this->_Swap_proxy_and_iterators(_Right);
+    }
+
+    _CONSTEXPR20 vector& operator=(vector&& _Right) noexcept(
+        _Choose_pocma_v<_Alvbase> != _Pocma_values::_No_propagate_allocators) {
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+#if _ITERATOR_DEBUG_LEVEL == 0
+        this->_Myvec  = _STD move(_Right._Myvec);
+        this->_Mysize = _STD exchange(_Right._Mysize, size_type{0});
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 0 / _ITERATOR_DEBUG_LEVEL != 0 vvv
+        this->_Orphan_all();
+        auto& _Al                 = this->_Getal();
+        auto& _Right_al           = _Right._Getal();
+        constexpr auto _Pocma_val = _Choose_pocma_v<_Alvbase>;
+        if constexpr (_Pocma_val == _Pocma_values::_Propagate_allocators) {
+            using _Alproxy_type = _Rebind_alloc_t<_Alvbase, _Container_proxy>;
+            if (_Al != _Right_al) { // reload proxy
+                // intentionally slams into noexcept on OOM, TRANSITION, VSO-466800
+                _Alproxy_type _Oldal(_Al);
+                _Alproxy_type _Right_proxy_al(_Right_al);
+                _Container_proxy_ptr<_Alvbase> _Proxy(_Right_proxy_al, _Leave_proxy_unbound{});
+                this->_Myvec  = _STD move(_Right._Myvec);
+                this->_Mysize = _STD exchange(_Right._Mysize, size_type{0});
+                _Proxy._Bind(_Oldal, this);
+                this->_Swap_proxy_and_iterators(_Right);
+                return *this;
+            }
+        } else if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
+            this->_Myvec  = _STD move(_Right._Myvec);
+            this->_Mysize = _Right._Mysize;
+            if (_Right._Myvec.empty()) {
+                // we took _Right's buffer, so zero out size
+                _Right._Mysize = 0;
+            }
+
+            if (_Al == _Right_al) {
+                this->_Swap_proxy_and_iterators(_Right);
+            }
+            return *this;
+        }
+
+        this->_Myvec  = _STD move(_Right._Myvec);
+        this->_Mysize = _STD exchange(_Right._Mysize, size_type{0});
+        this->_Swap_proxy_and_iterators(_Right);
+
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 0 ^^^
+        return *this;
+    }
+
+    template <class... _Valty>
+    _CONSTEXPR20 decltype(auto) emplace_back(_Valty&&... _Val) {
+        bool _Tmp(_STD forward<_Valty>(_Val)...);
+        push_back(_Tmp);
+
+#if _HAS_CXX17
+        return back();
+#endif // _HAS_CXX17
+    }
+
+    template <class... _Valty>
+    _CONSTEXPR20 iterator emplace(const_iterator _Where, _Valty&&... _Val) {
+        bool _Tmp(_STD forward<_Valty>(_Val)...);
+        return insert(_Where, _Tmp);
+    }
+
+    _CONSTEXPR20 vector(initializer_list<bool> _Ilist, const _Alloc& _Al = allocator_type()) : _Mybase(0, false, _Al) {
+        insert(begin(), _Ilist.begin(), _Ilist.end());
+    }
+
+    _CONSTEXPR20 vector& operator=(initializer_list<bool> _Ilist) {
+        assign(_Ilist.begin(), _Ilist.end());
+        return *this;
+    }
+
+    _CONSTEXPR20 void assign(initializer_list<bool> _Ilist) {
+        assign(_Ilist.begin(), _Ilist.end());
+    }
+
+    _CONSTEXPR20 iterator insert(const_iterator _Where, initializer_list<bool> _Ilist) {
+        return insert(_Where, _Ilist.begin(), _Ilist.end());
+    }
+
+    _CONSTEXPR20 ~vector() noexcept {}
+
+    _CONSTEXPR20 vector& operator=(const vector& _Right) {
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+#if _ITERATOR_DEBUG_LEVEL == 0
+        this->_Myvec  = _Right._Myvec;
+        this->_Mysize = _Right._Mysize;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 0 / _ITERATOR_DEBUG_LEVEL != 0 vvv
+        this->_Orphan_all();
+        auto& _Al       = this->_Getal();
+        auto& _Right_al = _Right._Getal();
+        if constexpr (_Choose_pocca_v<_Alvbase>) {
+            if (_Al != _Right_al) {
+                // reload proxy
+                using _Alproxy_type = _Rebind_alloc_t<_Alvbase, _Container_proxy>;
+                _Alproxy_type _Oldal(_Al);
+                _Alproxy_type _Right_proxy_al(_Right_al);
+                _Container_proxy_ptr<_Alvbase> _Proxy(_Right_proxy_al, _Leave_proxy_unbound{});
+                this->_Myvec  = _Right._Myvec;
+                this->_Mysize = _Right._Mysize;
+                _Proxy._Bind(_Oldal, this);
+                return *this;
+            }
+        }
+
+        this->_Myvec  = _Right._Myvec;
+        this->_Mysize = _Right._Mysize;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 0 ^^^
+
+        return *this;
+    }
+
+    _CONSTEXPR20 void reserve(_CRT_GUARDOVERFLOW size_type _Count) {
+        this->_Myvec.reserve(this->_Nw(_Count));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type capacity() const noexcept {
+        return this->_Myvec.capacity() * _VBITS;
+    }
+
+    _NODISCARD _CONSTEXPR20 iterator begin() noexcept {
+        return iterator(this->_Myvec.data(), this);
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator begin() const noexcept {
+        return const_iterator(this->_Myvec.data(), this);
+    }
+
+    _NODISCARD _CONSTEXPR20 iterator end() noexcept {
+        return begin() + static_cast<difference_type>(this->_Mysize);
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator end() const noexcept {
+        return begin() + static_cast<difference_type>(this->_Mysize);
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator cbegin() const noexcept {
+        return begin();
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator cend() const noexcept {
+        return end();
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reverse_iterator crbegin() const noexcept {
+        return rbegin();
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reverse_iterator crend() const noexcept {
+        return rend();
+    }
+
+    _NODISCARD _CONSTEXPR20 iterator _Unchecked_begin() noexcept {
+        return iterator(this->_Myvec.data(), this);
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator _Unchecked_begin() const noexcept {
+        return const_iterator(this->_Myvec.data(), this);
+    }
+
+    _NODISCARD _CONSTEXPR20 iterator _Unchecked_end() noexcept {
+        return _Unchecked_begin() + static_cast<difference_type>(this->_Mysize);
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator _Unchecked_end() const noexcept {
+        return _Unchecked_begin() + static_cast<difference_type>(this->_Mysize);
+    }
+
+    _CONSTEXPR20 void shrink_to_fit() {
+        if (this->_Myvec.capacity() != this->_Myvec.size()) {
+            this->_Orphan_all();
+            this->_Myvec.shrink_to_fit();
+        }
+    }
+
+    _CONSTEXPR20 iterator _Make_iter(const_iterator _Where) noexcept {
+        iterator _Tmp = begin();
+        if (0 < this->_Mysize) {
+            _Tmp += _Where - begin();
+        }
+
+        return _Tmp;
+    }
+
+    _NODISCARD _CONSTEXPR20 reverse_iterator rbegin() noexcept {
+        return reverse_iterator(end());
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reverse_iterator rbegin() const noexcept {
+        return const_reverse_iterator(end());
+    }
+
+    _NODISCARD _CONSTEXPR20 reverse_iterator rend() noexcept {
+        return reverse_iterator(begin());
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reverse_iterator rend() const noexcept {
+        return const_reverse_iterator(begin());
+    }
+
+    _CONSTEXPR20 void resize(_CRT_GUARDOVERFLOW size_type _Newsize, bool _Val = false) {
+        if (size() < _Newsize) {
+            _Insert_n(end(), _Newsize - size(), _Val);
+        } else if (_Newsize < size()) {
+            erase(begin() + static_cast<difference_type>(_Newsize), end());
+        }
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type size() const noexcept {
+        return this->_Mysize;
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type max_size() const noexcept {
+        constexpr auto _Diff_max  = static_cast<size_type>(_STD _Max_limit<difference_type>());
+        const size_type _Ints_max = this->_Myvec.max_size();
+        if (_Ints_max > _Diff_max / _VBITS) { // max_size bound by difference_type limits
+            return _Diff_max;
+        }
+
+        // max_size bound by underlying storage limits
+        return _Ints_max * _VBITS;
+    }
+
+    _NODISCARD_EMPTY_MEMBER _CONSTEXPR20 bool empty() const noexcept {
+        return this->_Mysize == 0;
+    }
+
+    _NODISCARD _CONSTEXPR20 allocator_type get_allocator() const noexcept {
+        return static_cast<allocator_type>(this->_Myvec.get_allocator());
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reference at(size_type _Off) const {
+        if (size() <= _Off) {
+            _Xran();
+        }
+
+        return (*this)[_Off];
+    }
+
+    _NODISCARD _CONSTEXPR20 reference at(size_type _Off) {
+        if (size() <= _Off) {
+            _Xran();
+        }
+
+        return (*this)[_Off];
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reference operator[](size_type _Off) const noexcept /* strengthened */ {
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_Off < this->_Mysize, "vector<bool> subscript out of range");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+
+        const_iterator _It = begin();
+        _It._Advance(_Off);
+        return *_It;
+    }
+
+    _NODISCARD _CONSTEXPR20 reference operator[](size_type _Off) noexcept /* strengthened */ {
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_Off < this->_Mysize, "vector<bool> subscript out of range");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+
+        iterator _It = begin();
+        _It._Advance(_Off);
+        return *_It;
+    }
+
+    _NODISCARD _CONSTEXPR20 reference front() noexcept /* strengthened */ {
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(this->_Mysize != 0, "front() called on empty vector<bool>");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+
+        return *begin();
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reference front() const noexcept /* strengthened */ {
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(this->_Mysize != 0, "front() called on empty vector<bool>");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+
+        return *begin();
+    }
+
+    _NODISCARD _CONSTEXPR20 reference back() noexcept /* strengthened */ {
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(this->_Mysize != 0, "back() called on empty vector<bool>");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+
+        return *(end() - 1);
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reference back() const noexcept /* strengthened */ {
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(this->_Mysize != 0, "back() called on empty vector<bool>");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+
+        return *(end() - 1);
+    }
+
+    _CONSTEXPR20 void push_back(const bool& _Val) {
+        insert(end(), _Val);
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<bool> _Rng>
+    constexpr void append_range(_Rng&& _Range) {
+        insert_range(end(), _STD forward<_Rng>(_Range));
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 void pop_back() noexcept /* strengthened */ {
+        erase(end() - 1);
+    }
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    _CONSTEXPR20 void assign(_Iter _First, _Iter _Last) {
+        clear();
+        insert(begin(), _First, _Last);
+    }
+
+#if _HAS_CXX23
+    template <class _Iter>
+    constexpr void _Assign_counted_range(_Iter _First, const size_type _Count) {
+        _STL_INTERNAL_CHECK(this->_Myvec.empty());
+        this->_Myvec.reserve(this->_Nw(_Count));
+        _Vbase _Accum = 0;
+        _Vbase _Mask  = 1;
+        for (size_type _Idx = 0; _Idx < _Count; ++_Idx) {
+            const bool _Tmp = *_First;
+            ++_First;
+            _Accum |= _Tmp ? _Mask : _Vbase{0};
+            if ((_Mask <<= 1) == 0) {
+                this->_Emplace_back_unchecked(_Accum);
+                _Accum = 0;
+                _Mask  = 1;
+            }
+        }
+
+        if (_Count % _VBITS != 0) {
+            this->_Emplace_back_unchecked(_Accum);
+        }
+        this->_Mysize = _Count;
+    }
+
+    template <class _Iter, class _Sent>
+    constexpr void _Assign_uncounted_range(_Iter _First, const _Sent _Last) {
+        _STL_INTERNAL_CHECK(this->_Myvec.empty());
+        size_type _Count = 0;
+        _Vbase _Accum    = 0;
+        _Vbase _Mask     = 1;
+        for (; _First != _Last; ++_Count) {
+            const bool _Tmp = *_First;
+            ++_First;
+            _Accum |= _Tmp ? _Mask : _Vbase{0};
+            if ((_Mask <<= 1) == 0) {
+                this->_Myvec.push_back(_Accum);
+                _Accum = 0;
+                _Mask  = 1;
+            }
+        }
+
+        if (_Count % _VBITS != 0) {
+            this->_Myvec.push_back(_Accum);
+        }
+        this->_Mysize = _Count;
+    }
+
+    template <_Container_compatible_range<bool> _Rng>
+    constexpr void assign_range(_Rng&& _Range) {
+        clear();
+        if constexpr (_RANGES forward_range<_Rng> || _RANGES sized_range<_Rng>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_Range));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            _Assign_counted_range(_RANGES _Ubegin(_Range), _Count);
+        } else {
+            _Assign_uncounted_range(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        }
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 void assign(_CRT_GUARDOVERFLOW size_type _Count, const bool& _Val) {
+        clear();
+        _Insert_n(begin(), _Count, _Val);
+    }
+
+    _CONSTEXPR20 iterator insert(const_iterator _Where, const bool& _Val) {
+        return _Insert_n(_Where, size_type{1}, _Val);
+    }
+
+    _CONSTEXPR20 iterator insert(const_iterator _Where, _CRT_GUARDOVERFLOW size_type _Count, const bool& _Val) {
+        return _Insert_n(_Where, _Count, _Val);
+    }
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    _CONSTEXPR20 iterator insert(const_iterator _Where, _Iter _First, _Iter _Last) {
+        const difference_type _Saved_offset = _Where - begin();
+        _STD _Adl_verify_range(_First, _Last);
+        auto _UFirst      = _STD _Get_unwrapped(_First);
+        const auto _ULast = _STD _Get_unwrapped(_Last);
+
+        if constexpr (_Is_cpp17_fwd_iter_v<_Iter>) {
+            const auto _Length = static_cast<size_t>(_STD distance(_UFirst, _ULast));
+            const auto _Count  = _STD _Convert_size<size_type>(_Length);
+            const auto _Off    = static_cast<difference_type>(_Insert_x(_Where, _Count));
+            _STD _Copy_unchecked(_UFirst, _ULast, begin() + _Off);
+#if _HAS_CXX20
+        } else if constexpr (forward_iterator<_Iter>) {
+            const auto _Length = _STD _To_unsigned_like(_RANGES distance(_UFirst, _ULast));
+            const auto _Count  = _STD _Convert_size<size_type>(_Length);
+            const auto _Off    = static_cast<difference_type>(_Insert_x(_Where, _Count));
+            _STD _Copy_unchecked(_UFirst, _ULast, begin() + _Off);
+#endif // _HAS_CXX20
+        } else {
+            const auto _Old_size = this->_Mysize;
+            for (; _UFirst != _ULast; ++_UFirst) {
+                emplace_back(*_UFirst);
+            }
+#if _ITERATOR_DEBUG_LEVEL == 2
+            _Orphan_range(static_cast<size_type>(_Saved_offset), _Old_size);
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+            _STD rotate(begin() + _Saved_offset, begin() + static_cast<difference_type>(_Old_size), end());
+        }
+
+        return begin() + _Saved_offset;
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<bool> _Rng>
+    constexpr iterator insert_range(const_iterator _Where, _Rng&& _Range) {
+        const difference_type _Old_off = _Where - begin();
+
+        if constexpr (_RANGES forward_range<_Rng> || _RANGES sized_range<_Rng>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_Range));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            const auto _Off    = static_cast<difference_type>(_Insert_x(_Where, _Count));
+            _Copy_n_unchecked4(_RANGES _Ubegin(_Range), _Count, begin() + _Off);
+        } else {
+            auto _UFirst         = _RANGES _Ubegin(_Range);
+            const auto _ULast    = _RANGES _Uend(_Range);
+            const auto _Old_size = this->_Mysize;
+            for (; _UFirst != _ULast; ++_UFirst) {
+                emplace_back(*_UFirst);
+            }
+#if _ITERATOR_DEBUG_LEVEL == 2
+            _Orphan_range(static_cast<size_type>(_Old_off), _Old_size);
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+            _STD rotate(begin() + _Old_off, begin() + static_cast<difference_type>(_Old_size), end());
+        }
+
+        return begin() + _Old_off;
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 iterator erase(const_iterator _Where_arg) noexcept /* strengthened */ {
+        iterator _Where      = _Make_iter(_Where_arg);
+        difference_type _Off = _Where - begin();
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(end() > _Where, "vector<bool> erase iterator outside range");
+        _STD copy(_Next_iter(_Where), end(), _Where);
+        _Orphan_range(static_cast<size_type>(_Off), this->_Mysize);
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 2 / _ITERATOR_DEBUG_LEVEL < 2 vvv
+        _STD copy(_Next_iter(_Where), end(), _Where);
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL < 2 ^^^
+
+        _Trim(this->_Mysize - 1);
+        return begin() + _Off;
+    }
+
+    _CONSTEXPR20 iterator erase(const_iterator _First_arg, const_iterator _Last_arg) noexcept
+    /* strengthened */ {
+        iterator _First      = _Make_iter(_First_arg);
+        iterator _Last       = _Make_iter(_Last_arg);
+        difference_type _Off = _First - begin();
+
+        if (_First != _Last) { // worth doing, copy down over hole
+#if _ITERATOR_DEBUG_LEVEL == 2
+            _STL_VERIFY(_Last >= _First && end() >= _Last, "vector<bool> erase iterator outside range");
+            iterator _Next      = _STD copy(_Last, end(), _First);
+            const auto _Newsize = static_cast<size_type>(_Next - begin());
+            _Orphan_range(_Newsize, this->_Mysize);
+            _Trim(_Newsize);
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 2 / _ITERATOR_DEBUG_LEVEL < 2 vvv
+            iterator _Next = _STD copy(_Last, end(), _First);
+            _Trim(static_cast<size_type>(_Next - begin()));
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL < 2 ^^^
+        }
+        return begin() + _Off;
+    }
+
+    _CONSTEXPR20 void clear() noexcept {
+        this->_Orphan_all();
+        this->_Myvec.clear();
+        this->_Mysize = 0;
+    }
+
+    _CONSTEXPR20 void flip() noexcept { // toggle all elements
+        for (auto& _Elem : this->_Myvec) {
+            _Elem = ~_Elem;
+        }
+
+        _Trim(this->_Mysize);
+    }
+
+    _CONSTEXPR20 void swap(vector& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            this->_Swap_proxy_and_iterators(_Right);
+            this->_Myvec.swap(_Right._Myvec);
+            _STD swap(this->_Mysize, _Right._Mysize);
+        }
+    }
+
+    static _CONSTEXPR20 void swap(reference _Left, reference _Right) noexcept {
+        bool _Val = _Left; // NOT _STD swap
+        _Left     = _Right;
+        _Right    = _Val;
+    }
+
+    friend hash<vector<bool, _Alloc>>;
+
+    _CONSTEXPR20 iterator _Insert_n(const_iterator _Where, size_type _Count, const bool& _Val) {
+        size_type _Off     = _Insert_x(_Where, _Count);
+        const auto _Result = begin() + static_cast<difference_type>(_Off);
+        _STD fill_n(_Result, _Count, _Val);
+        return _Result;
+    }
+
+    _CONSTEXPR20 size_type _Insert_x(const_iterator _Where, size_type _Count) {
+        const difference_type _Off = _Where - begin();
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(end() >= _Where, "vector<bool> insert iterator outside range");
+        const bool _Realloc = capacity() - size() < _Count;
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        if (_Count != 0) {
+            if (max_size() - size() < _Count) {
+                _Xlen(); // result too long
+            }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+            _Orphan_range(static_cast<size_type>(_Realloc ? 0 : _Off), this->_Mysize);
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+            this->_Myvec.resize(this->_Nw(size() + _Count), 0);
+            if (empty()) {
+                this->_Mysize += _Count;
+            } else { // make room and copy down suffix
+                iterator _Oldend = end();
+                this->_Mysize += _Count;
+                _STD copy_backward(begin() + _Off, _Oldend, end());
+            }
+        }
+
+        return static_cast<size_type>(_Off);
+    }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+    _CONSTEXPR20 void _Orphan_range_unlocked(size_type _Offlo, size_type _Offhi) const {
+        const auto _Base = this->_Myvec.data();
+
+        _Iterator_base12** _Pnext = &this->_Myproxy->_Myfirstiter;
+        while (*_Pnext) { // test offset from beginning of vector
+            const auto& _Pnextiter = static_cast<typename const_iterator::_Mybase&>(**_Pnext);
+            const auto _Temp       = *_Pnext;
+            if (!_Pnextiter._Myptr) { // orphan the iterator
+                _Temp->_Myproxy = nullptr;
+                *_Pnext         = _Temp->_Mynextiter;
+                continue;
+            }
+            const auto _Off =
+                static_cast<size_type>(const_iterator::_VBITS_DIFF * (_Pnextiter._Myptr - _Base)) + _Pnextiter._Myoff;
+            if (_Off < _Offlo || _Offhi < _Off) {
+                _Pnext = &_Temp->_Mynextiter;
+            } else { // orphan the iterator
+                _Temp->_Myproxy = nullptr;
+                *_Pnext         = _Temp->_Mynextiter;
+            }
+        }
+    }
+
+    void _Orphan_range_locked(size_type _Offlo, size_type _Offhi) const {
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Orphan_range_unlocked(_Offlo, _Offhi);
+    }
+
+    _CONSTEXPR20 void _Orphan_range(size_type _Offlo, size_type _Offhi) const {
+#if _HAS_CXX20
+        if (_STD is_constant_evaluated()) {
+            _Orphan_range_unlocked(_Offlo, _Offhi);
+        } else
+#endif // _HAS_CXX20
+        {
+            _Orphan_range_locked(_Offlo, _Offhi);
+        }
+    }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+    _CONSTEXPR20 void _Trim(size_type _Size) {
+        if (max_size() < _Size) {
+            _Xlen(); // result too long
+        }
+
+        const size_type _Words = this->_Nw(_Size);
+        if (_Words < this->_Myvec.size()) {
+            this->_Myvec.erase(this->_Myvec.begin() + static_cast<difference_type>(_Words), this->_Myvec.end());
+        }
+
+        this->_Mysize = _Size;
+        _Size %= _VBITS;
+        if (0 < _Size) {
+            this->_Myvec[_Words - 1] &= (static_cast<_Vbase>(1) << _Size) - 1;
+        }
+    }
+
+    [[noreturn]] static void _Xlen() {
+        _Xlength_error("vector<bool> too long");
+    }
+
+    [[noreturn]] static void _Xran() {
+        _Xout_of_range("invalid vector<bool> subscript");
+    }
+};
+
+template <class _Alloc>
+struct hash<vector<bool, _Alloc>> {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = vector<bool, _Alloc>;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
+
+    _NODISCARD _STATIC_CALL_OPERATOR size_t operator()(
+        const vector<bool, _Alloc>& _Keyval) _CONST_CALL_OPERATOR noexcept {
+        return _Hash_array_representation(_Keyval._Myvec.data(), _Keyval._Myvec.size());
+    }
+};
+
+#if _HAS_CXX17
+namespace pmr {
+    _EXPORT_STD template <class _Ty>
+    using vector = _STD vector<_Ty, polymorphic_allocator<_Ty>>;
+} // namespace pmr
+#endif // _HAS_CXX17
+
+#if _HAS_CXX23
+// Per LWG-3997, `_CharT` in library-provided `formatter` specializations is
+// constrained to character types supported by `format`.
+template <class _Ty, _Format_supported_charT _CharT>
+    requires _Is_specialization_v<_Ty, _Vb_reference>
+struct formatter<_Ty, _CharT> {
+private:
+    formatter<bool, _CharT> _Underlying;
+
+public:
+    template <class _ParseContext>
+    constexpr _ParseContext::iterator parse(_ParseContext& _Ctx) {
+        return _Underlying.parse(_Ctx);
+    }
+
+    template <class _FormatContext>
+    _FormatContext::iterator format(const _Ty& _Ref, _FormatContext& _Ctx) const {
+        return _Underlying.format(_Ref, _Ctx);
+    }
+};
+#endif // _HAS_CXX23
+
+template <class _Alloc, bool _RequiresMutable>
+constexpr bool _Is_vb_iterator<_Vb_iterator<_Alloc>, _RequiresMutable> = true;
+
+template <class _Alloc>
+constexpr bool _Is_vb_iterator<_Vb_const_iterator<_Alloc>, false> = true;
+
+template <class _VbIt>
+_CONSTEXPR20 void _Fill_vbool(_VbIt _First, const _VbIt _Last, const bool _Val) noexcept {
+    // Set [_First, _Last) to _Val
+    if (_First == _Last) {
+        return;
+    }
+
+    _Vbase* _VbFirst      = const_cast<_Vbase*>(_First._Myptr);
+    _Vbase* const _VbLast = const_cast<_Vbase*>(_Last._Myptr);
+
+    const auto _FirstSourceMask = static_cast<_Vbase>(-1) << _First._Myoff;
+    const auto _FirstDestMask   = ~_FirstSourceMask;
+    const auto _FillVal         = static_cast<_Vbase>(_Val ? -1 : 0);
+
+    if (_VbFirst == _VbLast) {
+        // We already excluded _First == _Last, so here _Last._Myoff > 0 and the shift is safe
+        const auto _LastSourceMask = static_cast<_Vbase>(-1) >> (_VBITS - _Last._Myoff);
+        const auto _LastDestMask   = ~_LastSourceMask;
+        const auto _SourceMask     = _FirstSourceMask & _LastSourceMask;
+        const auto _DestMask       = _FirstDestMask | _LastDestMask;
+        *_VbFirst                  = (*_VbFirst & _DestMask) | (_FillVal & _SourceMask);
+        return;
+    }
+
+    *_VbFirst = (*_VbFirst & _FirstDestMask) | (_FillVal & _FirstSourceMask);
+    ++_VbFirst;
+
+#if _HAS_CXX20
+    if (_STD is_constant_evaluated()) {
+        for (; _VbFirst != _VbLast; ++_VbFirst) {
+            *_VbFirst = _FillVal;
+        }
+    } else
+#endif // _HAS_CXX20
+    {
+        const auto _VbFirst_ch = reinterpret_cast<const char*>(_VbFirst);
+        const auto _VbLast_ch  = reinterpret_cast<const char*>(_VbLast);
+        const auto _Count_ch   = static_cast<size_t>(_VbLast_ch - _VbFirst_ch);
+        const auto _ValChar    = static_cast<unsigned char>(_Val ? -1 : 0);
+        _CSTD memset(_VbFirst, _ValChar, _Count_ch);
+        _VbFirst = _VbLast;
+    }
+
+    if (_Last._Myoff != 0) {
+        const auto _LastSourceMask = static_cast<_Vbase>(-1) >> (_VBITS - _Last._Myoff);
+        const auto _LastDestMask   = ~_LastSourceMask;
+        *_VbFirst                  = (*_VbFirst & _LastDestMask) | (_FillVal & _LastSourceMask);
+    }
+}
+
+template <class _VbIt>
+_NODISCARD _CONSTEXPR20 _VbIt _Find_vbool(_VbIt _First, const _VbIt _Last, const bool _Val) noexcept {
+    // Find _Val in [_First, _Last)
+    if (_First == _Last) {
+        return _First;
+    }
+
+    const _Vbase* _VbFirst      = _First._Myptr;
+    const _Vbase* const _VbLast = _Last._Myptr;
+
+    const auto _FirstSourceMask = static_cast<_Vbase>(-1) << _First._Myoff;
+
+    if (_VbFirst == _VbLast) {
+        // We already excluded _First == _Last, so here _Last._Myoff > 0 and the shift is safe
+        const auto _LastSourceMask = static_cast<_Vbase>(-1) >> (_VBITS - _Last._Myoff);
+        const auto _SourceMask     = _FirstSourceMask & _LastSourceMask;
+        const auto _SelectVal      = (_Val ? *_VbFirst : ~*_VbFirst) & _SourceMask;
+        const auto _Count          = _Countr_zero(_SelectVal);
+        return _Count == _VBITS ? _Last : _First + static_cast<ptrdiff_t>(_Count - _First._Myoff);
+    }
+
+    const auto _FirstVal   = (_Val ? *_VbFirst : ~*_VbFirst) & _FirstSourceMask;
+    const auto _FirstCount = _Countr_zero(_FirstVal);
+    if (_FirstCount != _VBITS) {
+        return _First + static_cast<ptrdiff_t>(_FirstCount - _First._Myoff);
+    }
+    ++_VbFirst;
+
+    _Iter_diff_t<_VbIt> _TotalCount = static_cast<ptrdiff_t>(_VBITS - _First._Myoff);
+    for (; _VbFirst != _VbLast; ++_VbFirst, _TotalCount += _VBITS) {
+        const auto _SelectVal = _Val ? *_VbFirst : ~*_VbFirst;
+        const auto _Count     = _Countr_zero(_SelectVal);
+        if (_Count != _VBITS) {
+            return _First + (_TotalCount + _Count);
+        }
+    }
+
+    if (_Last._Myoff != 0) {
+        const auto _LastSourceMask = static_cast<_Vbase>(-1) >> (_VBITS - _Last._Myoff);
+        const auto _LastVal        = (_Val ? *_VbFirst : ~*_VbFirst) & _LastSourceMask;
+        const auto _Count          = _Countr_zero(_LastVal);
+        if (_Count != _VBITS) {
+            return _First + (_TotalCount + _Count);
+        }
+    }
+
+    return _Last;
+}
+
+template <class _VbIt>
+_NODISCARD _CONSTEXPR20 _Iter_diff_t<_VbIt> _Count_vbool(_VbIt _First, const _VbIt _Last, const bool _Val) noexcept {
+    if (_First == _Last) {
+        return 0;
+    }
+
+    const _Vbase* _VbFirst      = _First._Myptr;
+    const _Vbase* const _VbLast = _Last._Myptr;
+
+    const auto _FirstSourceMask = static_cast<_Vbase>(-1) << _First._Myoff;
+
+    if (_VbFirst == _VbLast) {
+        // We already excluded _First == _Last, so here _Last._Myoff > 0 and the shift is safe
+        const auto _LastSourceMask = static_cast<_Vbase>(-1) >> (_VBITS - _Last._Myoff);
+        const auto _SourceMask     = _FirstSourceMask & _LastSourceMask;
+        const auto _SelectVal      = (_Val ? *_VbFirst : ~*_VbFirst) & _SourceMask;
+        return _Popcount(_SelectVal);
+    }
+
+    return _Select_popcount_impl<_Vbase>(
+        [_Last, _Val, _VbFirst, _VbLast, _FirstSourceMask](auto _Popcount_impl) mutable noexcept {
+            const auto _FirstVal       = (_Val ? *_VbFirst : ~*_VbFirst) & _FirstSourceMask;
+            _Iter_diff_t<_VbIt> _Count = _Popcount_impl(_FirstVal);
+            ++_VbFirst;
+
+            for (; _VbFirst != _VbLast; ++_VbFirst) {
+                const auto _SelectVal = _Val ? *_VbFirst : ~*_VbFirst;
+                _Count += _Popcount_impl(_SelectVal);
+            }
+
+            if (_Last._Myoff != 0) {
+                const auto _LastSourceMask = static_cast<_Vbase>(-1) >> (_VBITS - _Last._Myoff);
+                const auto _LastVal        = (_Val ? *_VbFirst : ~*_VbFirst) & _LastSourceMask;
+                _Count += _Popcount_impl(_LastVal);
+            }
+
+            return _Count;
+        });
+}
+
+template <class _VbIt, class _OutIt>
+_CONSTEXPR20 _OutIt _Copy_vbool(_VbIt _First, _VbIt _Last, _OutIt _Dest) {
+    // copy [_First, _Last) to [_Dest, ...)
+    if (_First == _Last) {
+        return _Dest;
+    }
+
+    auto _VbFirst       = _First._Myptr;
+    const auto _VbLast  = _Last._Myptr;
+    auto _VbDest        = const_cast<_Vbase*>(_Dest._Myptr);
+    const auto _DestEnd = _Dest + (_Last - _First);
+
+    const auto _FirstSourceMask = static_cast<_Vbase>(-1) << _First._Myoff;
+    const auto _FirstDestMask   = _Dest._Myoff == 0 ? 0 : (static_cast<_Vbase>(-1) >> (_VBITS - _Dest._Myoff));
+    const auto _LastSourceMask  = static_cast<_Vbase>(-1) >> (_VBITS - _Last._Myoff);
+    const auto _LastDestMask    = static_cast<_Vbase>(-1) << _DestEnd._Myoff;
+
+    const bool _IsSingleBlockSource = _VbFirst == _VbLast;
+    const bool _IsSingleBlockDest   = _VbDest == _DestEnd._Myptr - (_DestEnd._Myoff == 0 ? 1 : 0);
+    const bool _IsRightShift        = _Dest._Myoff < _First._Myoff;
+    if (_IsSingleBlockSource) {
+        // We already excluded _First == _Last, so here _Last._Myoff > 0 and the shift is safe
+        const auto _SourceMask  = _FirstSourceMask & _LastSourceMask;
+        const auto _SourceShift = _IsRightShift ? _First._Myoff - _Dest._Myoff : _Dest._Myoff - _First._Myoff;
+        const auto _SourceVal   = _IsRightShift ? (*_VbFirst & _SourceMask) >> _SourceShift //
+                                                : (*_VbFirst & _SourceMask) << _SourceShift;
+        if (_IsSingleBlockDest) {
+            const auto _DestMask = _FirstDestMask | (_DestEnd._Myoff == 0 ? 0 : _LastDestMask);
+            *_VbDest             = (*_VbDest & _DestMask) | _SourceVal;
+        } else {
+            *_VbDest = (*_VbDest & _FirstDestMask) | _SourceVal;
+            ++_VbDest;
+
+            const auto _LastShift     = _Last._Myoff - _DestEnd._Myoff;
+            const auto _LastSourceVal = (*_VbFirst & _SourceMask) >> _LastShift;
+            *_VbDest                  = (*_VbDest & _LastDestMask) | _LastSourceVal;
+        }
+
+        return _DestEnd;
+    } else if (_IsSingleBlockDest) {
+        const auto _SourceShift = _IsRightShift ? _First._Myoff - _Dest._Myoff : _Dest._Myoff - _First._Myoff;
+        const auto _SourceVal   = _IsRightShift ? (*_VbFirst & _FirstSourceMask) >> _SourceShift //
+                                                : (*_VbFirst & _FirstSourceMask) << _SourceShift;
+
+        const auto _DestMask = _FirstDestMask | (_DestEnd._Myoff == 0 ? 0 : _LastDestMask);
+        if (_Last._Myoff != 0) {
+            const auto _LastShift     = _DestEnd._Myoff - _Last._Myoff;
+            const auto _LastSourceVal = (*_VbLast & _LastSourceMask) << _LastShift;
+            *_VbDest                  = (*_VbDest & _DestMask) | _SourceVal | _LastSourceVal;
+        } else {
+            *_VbDest = (*_VbDest & _DestMask) | _SourceVal;
+        }
+
+        return _DestEnd;
+    }
+
+#if _HAS_CXX20
+    if (!_STD is_constant_evaluated())
+#endif
+    {
+        // If _First and _Dest have matching char alignment, use memmove
+        const auto _UnalignedFirstBits = _First._Myoff & _Vbase{7};
+        const auto _UnalignedDestBits  = _Dest._Myoff & _Vbase{7};
+        if (_UnalignedFirstBits == _UnalignedDestBits) {
+            const auto _UnalignedLastBits = _Last._Myoff & _Vbase{7};
+
+            auto _VbFirst_ch      = reinterpret_cast<const char*>(_VbFirst) + (_First._Myoff - _UnalignedFirstBits) / 8;
+            const auto _VbLast_ch = reinterpret_cast<const char*>(_VbLast) + (_Last._Myoff - _UnalignedLastBits) / 8;
+            auto _VbDest_ch       = reinterpret_cast<char*>(_VbDest) + (_Dest._Myoff - _UnalignedDestBits) / 8;
+
+            // Copy bits until the next char alignment
+            if (_UnalignedFirstBits != 0) {
+                const auto _SourceBitMask = static_cast<char>(UCHAR_MAX << _UnalignedFirstBits);
+                const auto _DestBitMask   = static_cast<char>(UCHAR_MAX >> (8 - _UnalignedFirstBits));
+                *_VbDest_ch               = (*_VbDest_ch & _DestBitMask) | (*_VbFirst_ch & _SourceBitMask);
+                ++_VbFirst_ch;
+                ++_VbDest_ch;
+            }
+
+            _VbDest_ch = _Copy_unchecked(_VbFirst_ch, _VbLast_ch, _VbDest_ch);
+
+            // Copy remaining last bits
+            if (_UnalignedLastBits != 0) {
+                const auto _SourceBitMask = static_cast<char>(UCHAR_MAX >> (8 - _UnalignedLastBits));
+                const auto _DestBitMask   = static_cast<char>(UCHAR_MAX << _UnalignedLastBits);
+                *_VbDest_ch               = (*_VbDest_ch & _DestBitMask) | (*_VbLast_ch & _SourceBitMask);
+            }
+
+            return _DestEnd;
+        }
+    }
+
+    // Unaligned _VbFirst and _VbLast require a two step copy with carry
+    if (_IsRightShift) {
+        const auto _SourceShift = _First._Myoff - _Dest._Myoff;
+        const auto _CarryShift  = _VBITS - _SourceShift;
+        const auto _CarryMask   = static_cast<_Vbase>(-1) >> _SourceShift;
+        const auto _DestMask    = ~_CarryMask;
+
+        const auto _FirstSourceVal = (*_VbFirst & _FirstSourceMask) >> _SourceShift;
+        *_VbDest                   = (*_VbDest & _FirstDestMask) | _FirstSourceVal;
+
+        ++_VbFirst;
+        for (; _VbFirst != _VbLast; ++_VbFirst) {
+            const auto _CarryVal = *_VbFirst << _CarryShift;
+            *_VbDest             = (*_VbDest & _CarryMask) | _CarryVal;
+
+            ++_VbDest;
+            const auto _SourceVal = *_VbFirst >> _SourceShift;
+            *_VbDest              = (*_VbDest & _DestMask) | _SourceVal;
+        }
+
+        if (_Last._Myoff != 0) {
+            const auto _CarryVal = (*_VbFirst & _LastSourceMask) << _CarryShift;
+            if (_Last._Myoff >= _SourceShift) {
+                *_VbDest = (*_VbDest & _CarryMask) | _CarryVal;
+
+                // We have more bits remaining than the final block has left
+                if (_Last._Myoff != _SourceShift) {
+                    ++_VbDest;
+                    const auto _SourceVal = (*_VbFirst & _LastSourceMask) >> _SourceShift;
+                    *_VbDest              = (*_VbDest & _LastDestMask) | _SourceVal;
+                }
+            } else {
+                // There are not enough bits to fill the final block so we need to mask both ends
+                const auto _FinalMask = _CarryMask | _LastDestMask;
+                *_VbDest              = (*_VbDest & _FinalMask) | _CarryVal;
+            }
+        }
+    } else {
+        const auto _SourceShift = _Dest._Myoff - _First._Myoff;
+        const auto _CarryShift  = _VBITS - _SourceShift;
+
+        const auto _FirstSourceVal = (*_VbFirst & _FirstSourceMask) << _SourceShift;
+        *_VbDest                   = (*_VbDest & _FirstDestMask) | _FirstSourceVal;
+        auto _CarryVal             = *_VbFirst >> _CarryShift;
+
+        ++_VbFirst;
+        ++_VbDest;
+        for (; _VbFirst != _VbLast; ++_VbFirst, ++_VbDest) {
+            const auto _SourceVal = *_VbFirst << _SourceShift;
+            *_VbDest              = _CarryVal | _SourceVal;
+            _CarryVal             = *_VbFirst >> _CarryShift;
+        }
+
+        if (_Last._Myoff >= _CarryShift) {
+            const auto _SourceVal = *_VbFirst << _SourceShift;
+            *_VbDest              = _CarryVal | _SourceVal;
+            _CarryVal             = *_VbFirst >> _CarryShift;
+
+            // We have more bits remaining than the final block has left
+            if (_Last._Myoff != _CarryShift) {
+                ++_VbDest;
+                const auto _LastCarryMask = ~_LastDestMask;
+                *_VbDest                  = (*_VbDest & _LastDestMask) | (_CarryVal & _LastCarryMask);
+            }
+        } else if (_Last._Myoff != 0) {
+            // There are not enough bits to fill the final block so we need to mask both ends
+            const auto _LastSourceVal = (*_VbFirst & _LastSourceMask) << _SourceShift;
+            *_VbDest                  = (*_VbDest & _LastDestMask) | _CarryVal | _LastSourceVal;
+        } else {
+            // No new bits, just copy the carry
+            *_VbDest = (*_VbDest & _LastDestMask) | _CarryVal;
+        }
+    }
+
+    return _DestEnd;
+}
+
+#undef _ASAN_VECTOR_MODIFY
+#undef _ASAN_VECTOR_REMOVE
+#undef _ASAN_VECTOR_CREATE
+#undef _ASAN_VECTOR_CREATE_GUARD
+#undef _ASAN_VECTOR_EXTEND_GUARD
+#undef _ASAN_VECTOR_RELEASE_GUARD
+#undef _INSERT_VECTOR_ANNOTATION
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _VECTOR_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/version b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/version
new file mode 100644
index 0000000000000000000000000000000000000000..fb45f31d7bee2f717fcb7e0292455494a7f98ae3
--- /dev/null
+++ b/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_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/wmmintrin.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/wmmintrin.h
new file mode 100644
index 0000000000000000000000000000000000000000..a7ddfa65b91e911b5c4bb508753ba4e85c7df1ce
--- /dev/null
+++ b/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 */
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xatomic.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xatomic.h
new file mode 100644
index 0000000000000000000000000000000000000000..156cf525c4ccf2e4ebe4a4e6f3f1eff3f8c943c4
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xatomic_wait.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xatomic_wait.h
new file mode 100644
index 0000000000000000000000000000000000000000..178f91fa9e803536fdbeac559c3aa0f349087081
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xbit_ops.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xbit_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..e1ce38f279d482751946e6d79a3f40607ae75993
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xcall_once.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xcall_once.h
new file mode 100644
index 0000000000000000000000000000000000000000..3a99d9bc033739e8157d8ecb144e53e0818b4ab1
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xcharconv.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xcharconv.h
new file mode 100644
index 0000000000000000000000000000000000000000..7140f489ca1f608c68da602f4f7769fbd1191a6a
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xcharconv_ryu.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xcharconv_ryu.h
new file mode 100644
index 0000000000000000000000000000000000000000..4b944ff380c3fbef805e624d2c6db24d2c4a6dad
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xcharconv_ryu.h
@@ -0,0 +1,2425 @@
+// xcharconv_ryu.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_H
+#define _XCHARCONV_RYU_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 <cstring>
+#include <type_traits>
+#include <utility>
+#include <xcharconv.h>
+#include <xcharconv_ryu_tables.h>
+#include <xutility>
+
+#if defined(_M_X64) || defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+#define _HAS_CHARCONV_INTRINSICS 1
+#else // ^^^ intrinsics available / intrinsics unavailable vvv
+#define _HAS_CHARCONV_INTRINSICS 0
+#endif // ^^^ intrinsics unavailable ^^^
+
+#if _HAS_CHARCONV_INTRINSICS
+#if defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+#include <intrin.h> // TRANSITION, VSO-1918426
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64) / defined(_M_X64) vvv
+#include _STL_INTRIN_HEADER // for _umul128(), __umulh(), and __shiftright128()
+#endif // ^^^ defined(_M_X64) ^^^
+#endif // ^^^ intrinsics available ^^^
+
+#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/tree/59661c3/ryu
+// (Keep the cgmanifest.json commitHash in sync.)
+
+// clang-format off
+
+// vvvvvvvvvv DERIVED FROM common.h vvvvvvvvvv
+
+_NODISCARD inline uint32_t __decimalLength9(const uint32_t __v) {
+  // Function precondition: __v is not a 10-digit number.
+  // (f2s: 9 digits are sufficient for round-tripping.)
+  // (d2fixed: We print 9-digit blocks.)
+  _STL_INTERNAL_CHECK(__v < 1000000000);
+  if (__v >= 100000000) { return 9; }
+  if (__v >= 10000000) { return 8; }
+  if (__v >= 1000000) { return 7; }
+  if (__v >= 100000) { return 6; }
+  if (__v >= 10000) { return 5; }
+  if (__v >= 1000) { return 4; }
+  if (__v >= 100) { return 3; }
+  if (__v >= 10) { return 2; }
+  return 1;
+}
+
+// Returns __e == 0 ? 1 : ceil(log_2(5^__e)).
+_NODISCARD inline int32_t __pow5bits(const int32_t __e) {
+  // This approximation works up to the point that the multiplication overflows at __e = 3529.
+  // If the multiplication were done in 64 bits, it would fail at 5^4004 which is just greater
+  // than 2^9297.
+  _STL_INTERNAL_CHECK(__e >= 0);
+  _STL_INTERNAL_CHECK(__e <= 3528);
+  return static_cast<int32_t>(((static_cast<uint32_t>(__e) * 1217359) >> 19) + 1);
+}
+
+// Returns floor(log_10(2^__e)).
+_NODISCARD inline uint32_t __log10Pow2(const int32_t __e) {
+  // The first value this approximation fails for is 2^1651 which is just greater than 10^297.
+  _STL_INTERNAL_CHECK(__e >= 0);
+  _STL_INTERNAL_CHECK(__e <= 1650);
+  return (static_cast<uint32_t>(__e) * 78913) >> 18;
+}
+
+// Returns floor(log_10(5^__e)).
+_NODISCARD inline uint32_t __log10Pow5(const int32_t __e) {
+  // The first value this approximation fails for is 5^2621 which is just greater than 10^1832.
+  _STL_INTERNAL_CHECK(__e >= 0);
+  _STL_INTERNAL_CHECK(__e <= 2620);
+  return (static_cast<uint32_t>(__e) * 732923) >> 20;
+}
+
+_NODISCARD inline uint32_t __float_to_bits(const float __f) {
+  uint32_t __bits = 0;
+  _CSTD memcpy(&__bits, &__f, sizeof(float));
+  return __bits;
+}
+
+_NODISCARD inline uint64_t __double_to_bits(const double __d) {
+  uint64_t __bits = 0;
+  _CSTD memcpy(&__bits, &__d, sizeof(double));
+  return __bits;
+}
+
+// ^^^^^^^^^^ DERIVED FROM common.h ^^^^^^^^^^
+
+// vvvvvvvvvv DERIVED FROM d2s.h vvvvvvvvvv
+
+inline constexpr int __DOUBLE_MANTISSA_BITS = 52;
+inline constexpr int __DOUBLE_BIAS = 1023;
+
+inline constexpr int __DOUBLE_POW5_INV_BITCOUNT = 122;
+inline constexpr int __DOUBLE_POW5_BITCOUNT = 121;
+
+// ^^^^^^^^^^ DERIVED FROM d2s.h ^^^^^^^^^^
+
+// vvvvvvvvvv DERIVED FROM d2s_intrinsics.h vvvvvvvvvv
+
+#if _HAS_CHARCONV_INTRINSICS
+
+_NODISCARD inline uint64_t __ryu_umul128(const uint64_t __a, const uint64_t __b, uint64_t* const __productHi) {
+#if defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+  *__productHi = __umulh(__a, __b);
+  return __a * __b;
+#else // ^^^ not native X64 / native X64 vvv
+  return _umul128(__a, __b, __productHi);
+#endif // defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+}
+
+#else // ^^^ intrinsics available / intrinsics unavailable vvv
+
+_NODISCARD __forceinline uint64_t __ryu_umul128(const uint64_t __a, const uint64_t __b, uint64_t* const __productHi) {
+  // TRANSITION, VSO-634761
+  // The casts here help MSVC to avoid calls to the __allmul library function.
+  const uint32_t __aLo = static_cast<uint32_t>(__a);
+  const uint32_t __aHi = static_cast<uint32_t>(__a >> 32);
+  const uint32_t __bLo = static_cast<uint32_t>(__b);
+  const uint32_t __bHi = static_cast<uint32_t>(__b >> 32);
+
+  const uint64_t __b00 = static_cast<uint64_t>(__aLo) * __bLo;
+  const uint64_t __b01 = static_cast<uint64_t>(__aLo) * __bHi;
+  const uint64_t __b10 = static_cast<uint64_t>(__aHi) * __bLo;
+  const uint64_t __b11 = static_cast<uint64_t>(__aHi) * __bHi;
+
+  const uint32_t __b00Lo = static_cast<uint32_t>(__b00);
+  const uint32_t __b00Hi = static_cast<uint32_t>(__b00 >> 32);
+
+  const uint64_t __mid1 = __b10 + __b00Hi;
+  const uint32_t __mid1Lo = static_cast<uint32_t>(__mid1);
+  const uint32_t __mid1Hi = static_cast<uint32_t>(__mid1 >> 32);
+
+  const uint64_t __mid2 = __b01 + __mid1Lo;
+  const uint32_t __mid2Lo = static_cast<uint32_t>(__mid2);
+  const uint32_t __mid2Hi = static_cast<uint32_t>(__mid2 >> 32);
+
+  const uint64_t __pHi = __b11 + __mid1Hi + __mid2Hi;
+  const uint64_t __pLo = (static_cast<uint64_t>(__mid2Lo) << 32) | __b00Lo;
+
+  *__productHi = __pHi;
+  return __pLo;
+}
+
+#endif // ^^^ intrinsics unavailable ^^^
+
+_NODISCARD inline uint64_t __ryu_shiftright128(const uint64_t __lo, const uint64_t __hi, const uint32_t __dist) {
+  // In the current implementation, the shift value is always < 64.
+  // If larger shift values are ever required, this function will need to be adjusted.
+  _STL_INTERNAL_CHECK(__dist < 64);
+
+#if defined(_M_X64) && !defined(_M_ARM64EC)
+  return __shiftright128(__lo, __hi, static_cast<unsigned char>(__dist));
+#else // ^^^ __shiftright128 intrinsic available / __shiftright128 intrinsic unavailable vvv
+  if (__dist == 0) {
+    return __lo;
+  }
+
+  return (__hi << (64 - __dist)) | (__lo >> __dist);
+#endif // ^^^ __shiftright128 intrinsic unavailable ^^^
+}
+
+
+#ifndef _WIN64
+
+#if !defined(_M_HYBRID_X86_ARM64)
+// Returns the high 64 bits of the 128-bit product of __a and __b.
+_NODISCARD inline uint64_t __umulh(const uint64_t __a, const uint64_t __b) {
+  // Reuse the __ryu_umul128 implementation.
+  // Optimizers will likely eliminate the instructions used to compute the
+  // low part of the product.
+  uint64_t __hi;
+  (void) __ryu_umul128(__a, __b, &__hi);
+  return __hi;
+}
+#endif // ^^^ !defined(_M_HYBRID_X86_ARM64) ^^^
+
+// On 32-bit platforms, compilers typically generate calls to library
+// functions for 64-bit divisions, even if the divisor is a constant.
+//
+// TRANSITION, LLVM-37932
+//
+// The functions here perform division-by-constant using multiplications
+// in the same way as 64-bit compilers would do.
+//
+// NB:
+// The multipliers and shift values are the ones generated by clang x64
+// for expressions like x/5, x/10, etc.
+
+_NODISCARD inline uint64_t __div5(const uint64_t __x) {
+  return __umulh(__x, 0xCCCCCCCCCCCCCCCDu) >> 2;
+}
+
+_NODISCARD inline uint64_t __div10(const uint64_t __x) {
+  return __umulh(__x, 0xCCCCCCCCCCCCCCCDu) >> 3;
+}
+
+_NODISCARD inline uint64_t __div100(const uint64_t __x) {
+  return __umulh(__x >> 2, 0x28F5C28F5C28F5C3u) >> 2;
+}
+
+_NODISCARD inline uint64_t __div1e8(const uint64_t __x) {
+  return __umulh(__x, 0xABCC77118461CEFDu) >> 26;
+}
+
+_NODISCARD inline uint64_t __div1e9(const uint64_t __x) {
+  return __umulh(__x >> 9, 0x44B82FA09B5A53u) >> 11;
+}
+
+_NODISCARD inline uint32_t __mod1e9(const uint64_t __x) {
+  // Avoid 64-bit math as much as possible.
+  // Returning static_cast<uint32_t>(__x - 1000000000 * __div1e9(__x)) would
+  // perform 32x64-bit multiplication and 64-bit subtraction.
+  // __x and 1000000000 * __div1e9(__x) are guaranteed to differ by
+  // less than 10^9, so their highest 32 bits must be identical,
+  // so we can truncate both sides to uint32_t before subtracting.
+  // We can also simplify static_cast<uint32_t>(1000000000 * __div1e9(__x)).
+  // We can truncate before multiplying instead of after, as multiplying
+  // the highest 32 bits of __div1e9(__x) can't affect the lowest 32 bits.
+  return static_cast<uint32_t>(__x) - 1000000000 * static_cast<uint32_t>(__div1e9(__x));
+}
+
+#else // ^^^ 32-bit / 64-bit vvv
+
+_NODISCARD inline uint64_t __div5(const uint64_t __x) {
+  return __x / 5;
+}
+
+_NODISCARD inline uint64_t __div10(const uint64_t __x) {
+  return __x / 10;
+}
+
+_NODISCARD inline uint64_t __div100(const uint64_t __x) {
+  return __x / 100;
+}
+
+_NODISCARD inline uint64_t __div1e8(const uint64_t __x) {
+  return __x / 100000000;
+}
+
+_NODISCARD inline uint64_t __div1e9(const uint64_t __x) {
+  return __x / 1000000000;
+}
+
+_NODISCARD inline uint32_t __mod1e9(const uint64_t __x) {
+  return static_cast<uint32_t>(__x - 1000000000 * __div1e9(__x));
+}
+
+#endif // ^^^ 64-bit ^^^
+
+_NODISCARD inline uint32_t __pow5Factor(uint64_t __value) {
+  uint32_t __count = 0;
+  for (;;) {
+    _STL_INTERNAL_CHECK(__value != 0);
+    const uint64_t __q = __div5(__value);
+    const uint32_t __r = static_cast<uint32_t>(__value) - 5 * static_cast<uint32_t>(__q);
+    if (__r != 0) {
+      break;
+    }
+    __value = __q;
+    ++__count;
+  }
+  return __count;
+}
+
+// Returns true if __value is divisible by 5^__p.
+_NODISCARD inline bool __multipleOfPowerOf5(const uint64_t __value, const uint32_t __p) {
+  // I tried a case distinction on __p, but there was no performance difference.
+  return __pow5Factor(__value) >= __p;
+}
+
+// Returns true if __value is divisible by 2^__p.
+_NODISCARD inline bool __multipleOfPowerOf2(const uint64_t __value, const uint32_t __p) {
+  _STL_INTERNAL_CHECK(__value != 0);
+  _STL_INTERNAL_CHECK(__p < 64);
+  // return __builtin_ctzll(__value) >= __p;
+  return (__value & ((1ull << __p) - 1)) == 0;
+}
+
+// ^^^^^^^^^^ DERIVED FROM d2s_intrinsics.h ^^^^^^^^^^
+
+// vvvvvvvvvv DERIVED FROM d2fixed.c vvvvvvvvvv
+
+inline constexpr int __POW10_ADDITIONAL_BITS = 120;
+
+#if _HAS_CHARCONV_INTRINSICS
+// Returns the low 64 bits of the high 128 bits of the 256-bit product of a and b.
+_NODISCARD inline uint64_t __umul256_hi128_lo64(
+  const uint64_t __aHi, const uint64_t __aLo, const uint64_t __bHi, const uint64_t __bLo) {
+  uint64_t __b00Hi;
+  const uint64_t __b00Lo = __ryu_umul128(__aLo, __bLo, &__b00Hi);
+  uint64_t __b01Hi;
+  const uint64_t __b01Lo = __ryu_umul128(__aLo, __bHi, &__b01Hi);
+  uint64_t __b10Hi;
+  const uint64_t __b10Lo = __ryu_umul128(__aHi, __bLo, &__b10Hi);
+  uint64_t __b11Hi;
+  const uint64_t __b11Lo = __ryu_umul128(__aHi, __bHi, &__b11Hi);
+  (void) __b00Lo; // unused
+  (void) __b11Hi; // unused
+  const uint64_t __temp1Lo = __b10Lo + __b00Hi;
+  const uint64_t __temp1Hi = __b10Hi + (__temp1Lo < __b10Lo);
+  const uint64_t __temp2Lo = __b01Lo + __temp1Lo;
+  const uint64_t __temp2Hi = __b01Hi + (__temp2Lo < __b01Lo);
+  return __b11Lo + __temp1Hi + __temp2Hi;
+}
+
+_NODISCARD inline uint32_t __uint128_mod1e9(const uint64_t __vHi, const uint64_t __vLo) {
+  // After multiplying, we're going to shift right by 29, then truncate to uint32_t.
+  // This means that we need only 29 + 32 = 61 bits, so we can truncate to uint64_t before shifting.
+  const uint64_t __multiplied = __umul256_hi128_lo64(__vHi, __vLo, 0x89705F4136B4A597u, 0x31680A88F8953031u);
+
+  // For uint32_t truncation, see the __mod1e9() comment in d2s_intrinsics.h.
+  const uint32_t __shifted = static_cast<uint32_t>(__multiplied >> 29);
+
+  return static_cast<uint32_t>(__vLo) - 1000000000 * __shifted;
+}
+#endif // ^^^ intrinsics available ^^^
+
+_NODISCARD inline uint32_t __mulShift_mod1e9(const uint64_t __m, const uint64_t* const __mul, const int32_t __j) {
+  uint64_t __high0;                                               // 64
+  const uint64_t __low0 = __ryu_umul128(__m, __mul[0], &__high0); // 0
+  uint64_t __high1;                                               // 128
+  const uint64_t __low1 = __ryu_umul128(__m, __mul[1], &__high1); // 64
+  uint64_t __high2;                                               // 192
+  const uint64_t __low2 = __ryu_umul128(__m, __mul[2], &__high2); // 128
+  const uint64_t __s0low = __low0;                  // 0
+  (void) __s0low; // unused
+  const uint64_t __s0high = __low1 + __high0;       // 64
+  const uint32_t __c1 = __s0high < __low1;
+  const uint64_t __s1low = __low2 + __high1 + __c1; // 128
+  const uint32_t __c2 = __s1low < __low2; // __high1 + __c1 can't overflow, so compare against __low2
+  const uint64_t __s1high = __high2 + __c2;         // 192
+  _STL_INTERNAL_CHECK(__j >= 128);
+  _STL_INTERNAL_CHECK(__j <= 180);
+#if _HAS_CHARCONV_INTRINSICS
+  const uint32_t __dist = static_cast<uint32_t>(__j - 128); // __dist: [0, 52]
+  const uint64_t __shiftedhigh = __s1high >> __dist;
+  const uint64_t __shiftedlow = __ryu_shiftright128(__s1low, __s1high, __dist);
+  return __uint128_mod1e9(__shiftedhigh, __shiftedlow);
+#else // ^^^ intrinsics available / intrinsics unavailable vvv
+  if (__j < 160) { // __j: [128, 160)
+    const uint64_t __r0 = __mod1e9(__s1high);
+    const uint64_t __r1 = __mod1e9((__r0 << 32) | (__s1low >> 32));
+    const uint64_t __r2 = ((__r1 << 32) | (__s1low & 0xffffffff));
+    return __mod1e9(__r2 >> (__j - 128));
+  } else { // __j: [160, 192)
+    const uint64_t __r0 = __mod1e9(__s1high);
+    const uint64_t __r1 = ((__r0 << 32) | (__s1low >> 32));
+    return __mod1e9(__r1 >> (__j - 160));
+  }
+#endif // ^^^ intrinsics unavailable ^^^
+}
+
+#define _WIDEN(_TYPE, _CHAR) static_cast<_TYPE>(is_same_v<_TYPE, char> ? _CHAR : L##_CHAR)
+
+template <class _CharT>
+void __append_n_digits(const uint32_t __olength, uint32_t __digits, _CharT* const __result) {
+  uint32_t __i = 0;
+  while (__digits >= 10000) {
+#ifdef __clang__ // TRANSITION, LLVM-38217
+    const uint32_t __c = __digits - 10000 * (__digits / 10000);
+#else
+    const uint32_t __c = __digits % 10000;
+#endif
+    __digits /= 10000;
+    const uint32_t __c0 = (__c % 100) << 1;
+    const uint32_t __c1 = (__c / 100) << 1;
+    _CSTD memcpy(__result + __olength - __i - 2, __DIGIT_TABLE<_CharT> + __c0, 2 * sizeof(_CharT));
+    _CSTD memcpy(__result + __olength - __i - 4, __DIGIT_TABLE<_CharT> + __c1, 2 * sizeof(_CharT));
+    __i += 4;
+  }
+  if (__digits >= 100) {
+    const uint32_t __c = (__digits % 100) << 1;
+    __digits /= 100;
+    _CSTD memcpy(__result + __olength - __i - 2, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
+    __i += 2;
+  }
+  if (__digits >= 10) {
+    const uint32_t __c = __digits << 1;
+    _CSTD memcpy(__result + __olength - __i - 2, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
+  } else {
+    __result[0] = static_cast<_CharT>(_WIDEN(_CharT, '0') + __digits);
+  }
+}
+
+inline void __append_d_digits(const uint32_t __olength, uint32_t __digits, char* const __result) {
+  uint32_t __i = 0;
+  while (__digits >= 10000) {
+#ifdef __clang__ // TRANSITION, LLVM-38217
+    const uint32_t __c = __digits - 10000 * (__digits / 10000);
+#else
+    const uint32_t __c = __digits % 10000;
+#endif
+    __digits /= 10000;
+    const uint32_t __c0 = (__c % 100) << 1;
+    const uint32_t __c1 = (__c / 100) << 1;
+    _CSTD memcpy(__result + __olength + 1 - __i - 2, __DIGIT_TABLE<char> + __c0, 2);
+    _CSTD memcpy(__result + __olength + 1 - __i - 4, __DIGIT_TABLE<char> + __c1, 2);
+    __i += 4;
+  }
+  if (__digits >= 100) {
+    const uint32_t __c = (__digits % 100) << 1;
+    __digits /= 100;
+    _CSTD memcpy(__result + __olength + 1 - __i - 2, __DIGIT_TABLE<char> + __c, 2);
+    __i += 2;
+  }
+  if (__digits >= 10) {
+    const uint32_t __c = __digits << 1;
+    __result[2] = __DIGIT_TABLE<char>[__c + 1];
+    __result[1] = '.';
+    __result[0] = __DIGIT_TABLE<char>[__c];
+  } else {
+    __result[1] = '.';
+    __result[0] = static_cast<char>('0' + __digits);
+  }
+}
+
+template <class _CharT>
+void __append_c_digits(const uint32_t __count, uint32_t __digits, _CharT* const __result) {
+  uint32_t __i = 0;
+  for (; __i < __count - 1; __i += 2) {
+    const uint32_t __c = (__digits % 100) << 1;
+    __digits /= 100;
+    _CSTD memcpy(__result + __count - __i - 2, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
+  }
+  if (__i < __count) {
+    const _CharT __c = static_cast<_CharT>(_WIDEN(_CharT, '0') + (__digits % 10));
+    __result[__count - __i - 1] = __c;
+  }
+}
+
+template <class _CharT>
+void __append_nine_digits(uint32_t __digits, _CharT* const __result) {
+  if (__digits == 0) {
+    _STD fill_n(__result, 9, _WIDEN(_CharT, '0'));
+    return;
+  }
+
+  for (uint32_t __i = 0; __i < 5; __i += 4) {
+#ifdef __clang__ // TRANSITION, LLVM-38217
+    const uint32_t __c = __digits - 10000 * (__digits / 10000);
+#else
+    const uint32_t __c = __digits % 10000;
+#endif
+    __digits /= 10000;
+    const uint32_t __c0 = (__c % 100) << 1;
+    const uint32_t __c1 = (__c / 100) << 1;
+    _CSTD memcpy(__result + 7 - __i, __DIGIT_TABLE<_CharT> + __c0, 2 * sizeof(_CharT));
+    _CSTD memcpy(__result + 5 - __i, __DIGIT_TABLE<_CharT> + __c1, 2 * sizeof(_CharT));
+  }
+  __result[0] = static_cast<_CharT>(_WIDEN(_CharT, '0') + __digits);
+}
+
+_NODISCARD inline uint32_t __indexForExponent(const uint32_t __e) {
+  return (__e + 15) / 16;
+}
+
+_NODISCARD inline uint32_t __pow10BitsForIndex(const uint32_t __idx) {
+  return 16 * __idx + __POW10_ADDITIONAL_BITS;
+}
+
+_NODISCARD inline uint32_t __lengthForIndex(const uint32_t __idx) {
+  // +1 for ceil, +16 for mantissa, +8 to round up when dividing by 9
+  return (__log10Pow2(16 * static_cast<int32_t>(__idx)) + 1 + 16 + 8) / 9;
+}
+
+template <class _CharT>
+_NODISCARD pair<_CharT*, errc> __d2fixed_buffered_n(_CharT* _First, _CharT* const _Last, const double __d,
+  const uint32_t __precision) {
+  _CharT* const _Original_first = _First;
+
+  const uint64_t __bits = __double_to_bits(__d);
+
+  // Case distinction; exit early for the easy cases.
+  if (__bits == 0) {
+    const int32_t _Total_zero_length = 1 // leading zero
+      + static_cast<int32_t>(__precision != 0) // possible decimal point
+      + static_cast<int32_t>(__precision); // zeroes after decimal point
+
+    if (_Last - _First < _Total_zero_length) {
+      return { _Last, errc::value_too_large };
+    }
+
+    *_First++ = _WIDEN(_CharT, '0');
+    if (__precision > 0) {
+      *_First++ = _WIDEN(_CharT, '.');
+      _STD fill_n(_First, __precision, _WIDEN(_CharT, '0'));
+      _First += __precision;
+    }
+    return { _First, errc{} };
+  }
+
+  // Decode __bits into mantissa and exponent.
+  const uint64_t __ieeeMantissa = __bits & ((1ull << __DOUBLE_MANTISSA_BITS) - 1);
+  const uint32_t __ieeeExponent = static_cast<uint32_t>(__bits >> __DOUBLE_MANTISSA_BITS);
+
+  int32_t __e2;
+  uint64_t __m2;
+  if (__ieeeExponent == 0) {
+    __e2 = 1 - __DOUBLE_BIAS - __DOUBLE_MANTISSA_BITS;
+    __m2 = __ieeeMantissa;
+  } else {
+    __e2 = static_cast<int32_t>(__ieeeExponent) - __DOUBLE_BIAS - __DOUBLE_MANTISSA_BITS;
+    __m2 = (1ull << __DOUBLE_MANTISSA_BITS) | __ieeeMantissa;
+  }
+
+  bool __nonzero = false;
+  if (__e2 >= -52) {
+    const uint32_t __idx = __e2 < 0 ? 0 : __indexForExponent(static_cast<uint32_t>(__e2));
+    const uint32_t __p10bits = __pow10BitsForIndex(__idx);
+    const int32_t __len = static_cast<int32_t>(__lengthForIndex(__idx));
+    for (int32_t __i = __len - 1; __i >= 0; --__i) {
+      const uint32_t __j = __p10bits - __e2;
+      // Temporary: __j is usually around 128, and by shifting a bit, we push it to 128 or above, which is
+      // a slightly faster code path in __mulShift_mod1e9. Instead, we can just increase the multipliers.
+      const uint32_t __digits = __mulShift_mod1e9(__m2 << 8, __POW10_SPLIT[__POW10_OFFSET[__idx] + __i],
+        static_cast<int32_t>(__j + 8));
+      if (__nonzero) {
+        if (_Last - _First < 9) {
+          return { _Last, errc::value_too_large };
+        }
+        __append_nine_digits(__digits, _First);
+        _First += 9;
+      } else if (__digits != 0) {
+        const uint32_t __olength = __decimalLength9(__digits);
+        if (_Last - _First < static_cast<ptrdiff_t>(__olength)) {
+          return { _Last, errc::value_too_large };
+        }
+        __append_n_digits(__olength, __digits, _First);
+        _First += __olength;
+        __nonzero = true;
+      }
+    }
+  }
+  if (!__nonzero) {
+    if (_First == _Last) {
+      return { _Last, errc::value_too_large };
+    }
+    *_First++ = _WIDEN(_CharT, '0');
+  }
+  if (__precision > 0) {
+    if (_First == _Last) {
+      return { _Last, errc::value_too_large };
+    }
+    *_First++ = _WIDEN(_CharT, '.');
+  }
+  if (__e2 < 0) {
+    const int32_t __idx = -__e2 / 16;
+    const uint32_t __blocks = __precision / 9 + 1;
+    // 0 = don't round up; 1 = round up unconditionally; 2 = round up if odd.
+    int __roundUp = 0;
+    uint32_t __i = 0;
+    if (__blocks <= __MIN_BLOCK_2[__idx]) {
+      __i = __blocks;
+      if (_Last - _First < static_cast<ptrdiff_t>(__precision)) {
+        return { _Last, errc::value_too_large };
+      }
+      _STD fill_n(_First, __precision, _WIDEN(_CharT, '0'));
+      _First += __precision;
+    } else if (__i < __MIN_BLOCK_2[__idx]) {
+      __i = __MIN_BLOCK_2[__idx];
+      if (_Last - _First < static_cast<ptrdiff_t>(9 * __i)) {
+        return { _Last, errc::value_too_large };
+      }
+      _STD fill_n(_First, 9 * __i, _WIDEN(_CharT, '0'));
+      _First += 9 * __i;
+    }
+    for (; __i < __blocks; ++__i) {
+      const int32_t __j = __ADDITIONAL_BITS_2 + (-__e2 - 16 * __idx);
+      const uint32_t __p = __POW10_OFFSET_2[__idx] + __i - __MIN_BLOCK_2[__idx];
+      if (__p >= __POW10_OFFSET_2[__idx + 1]) {
+        // If the remaining digits are all 0, then we might as well use memset.
+        // No rounding required in this case.
+        const uint32_t __fill = __precision - 9 * __i;
+        if (_Last - _First < static_cast<ptrdiff_t>(__fill)) {
+          return { _Last, errc::value_too_large };
+        }
+        _STD fill_n(_First, __fill, _WIDEN(_CharT, '0'));
+        _First += __fill;
+        break;
+      }
+      // Temporary: __j is usually around 128, and by shifting a bit, we push it to 128 or above, which is
+      // a slightly faster code path in __mulShift_mod1e9. Instead, we can just increase the multipliers.
+      uint32_t __digits = __mulShift_mod1e9(__m2 << 8, __POW10_SPLIT_2[__p], __j + 8);
+      if (__i < __blocks - 1) {
+        if (_Last - _First < 9) {
+          return { _Last, errc::value_too_large };
+        }
+        __append_nine_digits(__digits, _First);
+        _First += 9;
+      } else {
+        const uint32_t __maximum = __precision - 9 * __i;
+        uint32_t __lastDigit = 0;
+        for (uint32_t __k = 0; __k < 9 - __maximum; ++__k) {
+          __lastDigit = __digits % 10;
+          __digits /= 10;
+        }
+        if (__lastDigit != 5) {
+          __roundUp = __lastDigit > 5;
+        } else {
+          // Is m * 10^(additionalDigits + 1) / 2^(-__e2) integer?
+          const int32_t __requiredTwos = -__e2 - static_cast<int32_t>(__precision) - 1;
+          const bool __trailingZeros = __requiredTwos <= 0
+            || (__requiredTwos < 60 && __multipleOfPowerOf2(__m2, static_cast<uint32_t>(__requiredTwos)));
+          __roundUp = __trailingZeros ? 2 : 1;
+        }
+        if (__maximum > 0) {
+          if (_Last - _First < static_cast<ptrdiff_t>(__maximum)) {
+            return { _Last, errc::value_too_large };
+          }
+          __append_c_digits(__maximum, __digits, _First);
+          _First += __maximum;
+        }
+        break;
+      }
+    }
+    if (__roundUp != 0) {
+      _CharT* _Round = _First;
+      _CharT* _Dot = _Last;
+      while (true) {
+        if (_Round == _Original_first) {
+          _Round[0] = _WIDEN(_CharT, '1');
+          if (_Dot != _Last) {
+            _Dot[0] = _WIDEN(_CharT, '0');
+            _Dot[1] = _WIDEN(_CharT, '.');
+          }
+          if (_First == _Last) {
+            return { _Last, errc::value_too_large };
+          }
+          *_First++ = _WIDEN(_CharT, '0');
+          break;
+        }
+        --_Round;
+        const _CharT __c = _Round[0];
+        if (__c == _WIDEN(_CharT, '.')) {
+          _Dot = _Round;
+        } else if (__c == _WIDEN(_CharT, '9')) {
+          _Round[0] = _WIDEN(_CharT, '0');
+          __roundUp = 1;
+        } else {
+          if (__roundUp == 1 || __c % 2 != 0) {
+            _Round[0] = static_cast<_CharT>(__c + 1);
+          }
+          break;
+        }
+      }
+    }
+  } else {
+    if (_Last - _First < static_cast<ptrdiff_t>(__precision)) {
+      return { _Last, errc::value_too_large };
+    }
+    _STD fill_n(_First, __precision, _WIDEN(_CharT, '0'));
+    _First += __precision;
+  }
+  return { _First, errc{} };
+}
+
+_NODISCARD inline to_chars_result __d2exp_buffered_n(char* _First, char* const _Last, const double __d,
+  uint32_t __precision) {
+  char* const _Original_first = _First;
+
+  const uint64_t __bits = __double_to_bits(__d);
+
+  // Case distinction; exit early for the easy cases.
+  if (__bits == 0) {
+    const int32_t _Total_zero_length = 1 // leading zero
+      + static_cast<int32_t>(__precision != 0) // possible decimal point
+      + static_cast<int32_t>(__precision) // zeroes after decimal point
+      + 4; // "e+00"
+    if (_Last - _First < _Total_zero_length) {
+      return { _Last, errc::value_too_large };
+    }
+    *_First++ = '0';
+    if (__precision > 0) {
+      *_First++ = '.';
+      _CSTD memset(_First, '0', __precision);
+      _First += __precision;
+    }
+    _CSTD memcpy(_First, "e+00", 4);
+    _First += 4;
+    return { _First, errc{} };
+  }
+
+  // Decode __bits into mantissa and exponent.
+  const uint64_t __ieeeMantissa = __bits & ((1ull << __DOUBLE_MANTISSA_BITS) - 1);
+  const uint32_t __ieeeExponent = static_cast<uint32_t>(__bits >> __DOUBLE_MANTISSA_BITS);
+
+  int32_t __e2;
+  uint64_t __m2;
+  if (__ieeeExponent == 0) {
+    __e2 = 1 - __DOUBLE_BIAS - __DOUBLE_MANTISSA_BITS;
+    __m2 = __ieeeMantissa;
+  } else {
+    __e2 = static_cast<int32_t>(__ieeeExponent) - __DOUBLE_BIAS - __DOUBLE_MANTISSA_BITS;
+    __m2 = (1ull << __DOUBLE_MANTISSA_BITS) | __ieeeMantissa;
+  }
+
+  const bool __printDecimalPoint = __precision > 0;
+  ++__precision;
+  uint32_t __digits = 0;
+  uint32_t __printedDigits = 0;
+  uint32_t __availableDigits = 0;
+  int32_t __exp = 0;
+  if (__e2 >= -52) {
+    const uint32_t __idx = __e2 < 0 ? 0 : __indexForExponent(static_cast<uint32_t>(__e2));
+    const uint32_t __p10bits = __pow10BitsForIndex(__idx);
+    const int32_t __len = static_cast<int32_t>(__lengthForIndex(__idx));
+    for (int32_t __i = __len - 1; __i >= 0; --__i) {
+      const uint32_t __j = __p10bits - __e2;
+      // Temporary: __j is usually around 128, and by shifting a bit, we push it to 128 or above, which is
+      // a slightly faster code path in __mulShift_mod1e9. Instead, we can just increase the multipliers.
+      __digits = __mulShift_mod1e9(__m2 << 8, __POW10_SPLIT[__POW10_OFFSET[__idx] + __i],
+        static_cast<int32_t>(__j + 8));
+      if (__printedDigits != 0) {
+        if (__printedDigits + 9 > __precision) {
+          __availableDigits = 9;
+          break;
+        }
+        if (_Last - _First < 9) {
+          return { _Last, errc::value_too_large };
+        }
+        __append_nine_digits(__digits, _First);
+        _First += 9;
+        __printedDigits += 9;
+      } else if (__digits != 0) {
+        __availableDigits = __decimalLength9(__digits);
+        __exp = __i * 9 + static_cast<int32_t>(__availableDigits) - 1;
+        if (__availableDigits > __precision) {
+          break;
+        }
+        if (__printDecimalPoint) {
+          if (_Last - _First < static_cast<ptrdiff_t>(__availableDigits + 1)) {
+            return { _Last, errc::value_too_large };
+          }
+          __append_d_digits(__availableDigits, __digits, _First);
+          _First += __availableDigits + 1; // +1 for decimal point
+        } else {
+          if (_First == _Last) {
+            return { _Last, errc::value_too_large };
+          }
+          *_First++ = static_cast<char>('0' + __digits);
+        }
+        __printedDigits = __availableDigits;
+        __availableDigits = 0;
+      }
+    }
+  }
+
+  if (__e2 < 0 && __availableDigits == 0) {
+    const int32_t __idx = -__e2 / 16;
+    for (int32_t __i = __MIN_BLOCK_2[__idx]; __i < 200; ++__i) {
+      const int32_t __j = __ADDITIONAL_BITS_2 + (-__e2 - 16 * __idx);
+      const uint32_t __p = __POW10_OFFSET_2[__idx] + static_cast<uint32_t>(__i) - __MIN_BLOCK_2[__idx];
+      // Temporary: __j is usually around 128, and by shifting a bit, we push it to 128 or above, which is
+      // a slightly faster code path in __mulShift_mod1e9. Instead, we can just increase the multipliers.
+      __digits = (__p >= __POW10_OFFSET_2[__idx + 1]) ? 0 : __mulShift_mod1e9(__m2 << 8, __POW10_SPLIT_2[__p], __j + 8);
+      if (__printedDigits != 0) {
+        if (__printedDigits + 9 > __precision) {
+          __availableDigits = 9;
+          break;
+        }
+        if (_Last - _First < 9) {
+          return { _Last, errc::value_too_large };
+        }
+        __append_nine_digits(__digits, _First);
+        _First += 9;
+        __printedDigits += 9;
+      } else if (__digits != 0) {
+        __availableDigits = __decimalLength9(__digits);
+        __exp = -(__i + 1) * 9 + static_cast<int32_t>(__availableDigits) - 1;
+        if (__availableDigits > __precision) {
+          break;
+        }
+        if (__printDecimalPoint) {
+          if (_Last - _First < static_cast<ptrdiff_t>(__availableDigits + 1)) {
+            return { _Last, errc::value_too_large };
+          }
+          __append_d_digits(__availableDigits, __digits, _First);
+          _First += __availableDigits + 1; // +1 for decimal point
+        } else {
+          if (_First == _Last) {
+            return { _Last, errc::value_too_large };
+          }
+          *_First++ = static_cast<char>('0' + __digits);
+        }
+        __printedDigits = __availableDigits;
+        __availableDigits = 0;
+      }
+    }
+  }
+
+  const uint32_t __maximum = __precision - __printedDigits;
+  if (__availableDigits == 0) {
+    __digits = 0;
+  }
+  uint32_t __lastDigit = 0;
+  if (__availableDigits > __maximum) {
+    for (uint32_t __k = 0; __k < __availableDigits - __maximum; ++__k) {
+      __lastDigit = __digits % 10;
+      __digits /= 10;
+    }
+  }
+  // 0 = don't round up; 1 = round up unconditionally; 2 = round up if odd.
+  int __roundUp = 0;
+  if (__lastDigit != 5) {
+    __roundUp = __lastDigit > 5;
+  } else {
+    // Is m * 2^__e2 * 10^(__precision + 1 - __exp) integer?
+    // __precision was already increased by 1, so we don't need to write + 1 here.
+    const int32_t __rexp = static_cast<int32_t>(__precision) - __exp;
+    const int32_t __requiredTwos = -__e2 - __rexp;
+    bool __trailingZeros = __requiredTwos <= 0
+      || (__requiredTwos < 60 && __multipleOfPowerOf2(__m2, static_cast<uint32_t>(__requiredTwos)));
+    if (__rexp < 0) {
+      const int32_t __requiredFives = -__rexp;
+      __trailingZeros = __trailingZeros && __multipleOfPowerOf5(__m2, static_cast<uint32_t>(__requiredFives));
+    }
+    __roundUp = __trailingZeros ? 2 : 1;
+  }
+  if (__printedDigits != 0) {
+    if (_Last - _First < static_cast<ptrdiff_t>(__maximum)) {
+      return { _Last, errc::value_too_large };
+    }
+    if (__digits == 0) {
+      _CSTD memset(_First, '0', __maximum);
+    } else {
+      __append_c_digits(__maximum, __digits, _First);
+    }
+    _First += __maximum;
+  } else {
+    if (__printDecimalPoint) {
+      if (_Last - _First < static_cast<ptrdiff_t>(__maximum + 1)) {
+        return { _Last, errc::value_too_large };
+      }
+      __append_d_digits(__maximum, __digits, _First);
+      _First += __maximum + 1; // +1 for decimal point
+    } else {
+      if (_First == _Last) {
+        return { _Last, errc::value_too_large };
+      }
+      *_First++ = static_cast<char>('0' + __digits);
+    }
+  }
+  if (__roundUp != 0) {
+    char* _Round = _First;
+    while (true) {
+      if (_Round == _Original_first) {
+        _Round[0] = '1';
+        ++__exp;
+        break;
+      }
+      --_Round;
+      const char __c = _Round[0];
+      if (__c == '.') {
+        // Keep going.
+      } else if (__c == '9') {
+        _Round[0] = '0';
+        __roundUp = 1;
+      } else {
+        if (__roundUp == 1 || __c % 2 != 0) {
+          _Round[0] = static_cast<char>(__c + 1);
+        }
+        break;
+      }
+    }
+  }
+
+  char _Sign_character;
+
+  if (__exp < 0) {
+    _Sign_character = '-';
+    __exp = -__exp;
+  } else {
+    _Sign_character = '+';
+  }
+
+  const int _Exponent_part_length = __exp >= 100
+    ? 5 // "e+NNN"
+    : 4; // "e+NN"
+
+  if (_Last - _First < _Exponent_part_length) {
+    return { _Last, errc::value_too_large };
+  }
+
+  *_First++ = 'e';
+  *_First++ = _Sign_character;
+
+  if (__exp >= 100) {
+    const int32_t __c = __exp % 10;
+    _CSTD memcpy(_First, __DIGIT_TABLE<char> + 2 * (__exp / 10), 2);
+    _First[2] = static_cast<char>('0' + __c);
+    _First += 3;
+  } else {
+    _CSTD memcpy(_First, __DIGIT_TABLE<char> + 2 * __exp, 2);
+    _First += 2;
+  }
+
+  return { _First, errc{} };
+}
+
+// ^^^^^^^^^^ DERIVED FROM d2fixed.c ^^^^^^^^^^
+
+// vvvvvvvvvv DERIVED FROM f2s.c vvvvvvvvvv
+
+inline constexpr int __FLOAT_MANTISSA_BITS = 23;
+inline constexpr int __FLOAT_BIAS = 127;
+
+// This table is generated by PrintFloatLookupTable.
+inline constexpr int __FLOAT_POW5_INV_BITCOUNT = 59;
+inline constexpr uint64_t __FLOAT_POW5_INV_SPLIT[31] = {
+  576460752303423489u, 461168601842738791u, 368934881474191033u, 295147905179352826u,
+  472236648286964522u, 377789318629571618u, 302231454903657294u, 483570327845851670u,
+  386856262276681336u, 309485009821345069u, 495176015714152110u, 396140812571321688u,
+  316912650057057351u, 507060240091291761u, 405648192073033409u, 324518553658426727u,
+  519229685853482763u, 415383748682786211u, 332306998946228969u, 531691198313966350u,
+  425352958651173080u, 340282366920938464u, 544451787073501542u, 435561429658801234u,
+  348449143727040987u, 557518629963265579u, 446014903970612463u, 356811923176489971u,
+  570899077082383953u, 456719261665907162u, 365375409332725730u
+};
+inline constexpr int __FLOAT_POW5_BITCOUNT = 61;
+inline constexpr uint64_t __FLOAT_POW5_SPLIT[47] = {
+  1152921504606846976u, 1441151880758558720u, 1801439850948198400u, 2251799813685248000u,
+  1407374883553280000u, 1759218604441600000u, 2199023255552000000u, 1374389534720000000u,
+  1717986918400000000u, 2147483648000000000u, 1342177280000000000u, 1677721600000000000u,
+  2097152000000000000u, 1310720000000000000u, 1638400000000000000u, 2048000000000000000u,
+  1280000000000000000u, 1600000000000000000u, 2000000000000000000u, 1250000000000000000u,
+  1562500000000000000u, 1953125000000000000u, 1220703125000000000u, 1525878906250000000u,
+  1907348632812500000u, 1192092895507812500u, 1490116119384765625u, 1862645149230957031u,
+  1164153218269348144u, 1455191522836685180u, 1818989403545856475u, 2273736754432320594u,
+  1421085471520200371u, 1776356839400250464u, 2220446049250313080u, 1387778780781445675u,
+  1734723475976807094u, 2168404344971008868u, 1355252715606880542u, 1694065894508600678u,
+  2117582368135750847u, 1323488980084844279u, 1654361225106055349u, 2067951531382569187u,
+  1292469707114105741u, 1615587133892632177u, 2019483917365790221u
+};
+
+_NODISCARD inline uint32_t __pow5Factor(uint32_t __value) {
+  uint32_t __count = 0;
+  for (;;) {
+    _STL_INTERNAL_CHECK(__value != 0);
+    const uint32_t __q = __value / 5;
+    const uint32_t __r = __value % 5;
+    if (__r != 0) {
+      break;
+    }
+    __value = __q;
+    ++__count;
+  }
+  return __count;
+}
+
+// Returns true if __value is divisible by 5^__p.
+_NODISCARD inline bool __multipleOfPowerOf5(const uint32_t __value, const uint32_t __p) {
+  return __pow5Factor(__value) >= __p;
+}
+
+// Returns true if __value is divisible by 2^__p.
+_NODISCARD inline bool __multipleOfPowerOf2(const uint32_t __value, const uint32_t __p) {
+  _STL_INTERNAL_CHECK(__value != 0);
+  _STL_INTERNAL_CHECK(__p < 32);
+  // return __builtin_ctz(__value) >= __p;
+  return (__value & ((1u << __p) - 1)) == 0;
+}
+
+_NODISCARD inline uint32_t __mulShift(const uint32_t __m, const uint64_t __factor, const int32_t __shift) {
+  _STL_INTERNAL_CHECK(__shift > 32);
+
+  // The casts here help MSVC to avoid calls to the __allmul library
+  // function.
+  const uint32_t __factorLo = static_cast<uint32_t>(__factor);
+  const uint32_t __factorHi = static_cast<uint32_t>(__factor >> 32);
+  const uint64_t __bits0 = static_cast<uint64_t>(__m) * __factorLo;
+  const uint64_t __bits1 = static_cast<uint64_t>(__m) * __factorHi;
+
+#ifndef _WIN64
+  // On 32-bit platforms we can avoid a 64-bit shift-right since we only
+  // need the upper 32 bits of the result and the shift value is > 32.
+  const uint32_t __bits0Hi = static_cast<uint32_t>(__bits0 >> 32);
+  uint32_t __bits1Lo = static_cast<uint32_t>(__bits1);
+  uint32_t __bits1Hi = static_cast<uint32_t>(__bits1 >> 32);
+  __bits1Lo += __bits0Hi;
+  __bits1Hi += (__bits1Lo < __bits0Hi);
+  const int32_t __s = __shift - 32;
+  return (__bits1Hi << (32 - __s)) | (__bits1Lo >> __s);
+#else // ^^^ 32-bit / 64-bit vvv
+  const uint64_t __sum = (__bits0 >> 32) + __bits1;
+  const uint64_t __shiftedSum = __sum >> (__shift - 32);
+  _STL_INTERNAL_CHECK(__shiftedSum <= UINT32_MAX);
+  return static_cast<uint32_t>(__shiftedSum);
+#endif // ^^^ 64-bit ^^^
+}
+
+_NODISCARD inline uint32_t __mulPow5InvDivPow2(const uint32_t __m, const uint32_t __q, const int32_t __j) {
+  return __mulShift(__m, __FLOAT_POW5_INV_SPLIT[__q], __j);
+}
+
+_NODISCARD inline uint32_t __mulPow5divPow2(const uint32_t __m, const uint32_t __i, const int32_t __j) {
+  return __mulShift(__m, __FLOAT_POW5_SPLIT[__i], __j);
+}
+
+// A floating decimal representing m * 10^e.
+struct __floating_decimal_32 {
+  uint32_t __mantissa;
+  int32_t __exponent;
+};
+
+_NODISCARD inline __floating_decimal_32 __f2d(const uint32_t __ieeeMantissa, const uint32_t __ieeeExponent) {
+  int32_t __e2;
+  uint32_t __m2;
+  if (__ieeeExponent == 0) {
+    // We subtract 2 so that the bounds computation has 2 additional bits.
+    __e2 = 1 - __FLOAT_BIAS - __FLOAT_MANTISSA_BITS - 2;
+    __m2 = __ieeeMantissa;
+  } else {
+    __e2 = static_cast<int32_t>(__ieeeExponent) - __FLOAT_BIAS - __FLOAT_MANTISSA_BITS - 2;
+    __m2 = (1u << __FLOAT_MANTISSA_BITS) | __ieeeMantissa;
+  }
+  const bool __even = (__m2 & 1) == 0;
+  const bool __acceptBounds = __even;
+
+  // Step 2: Determine the interval of valid decimal representations.
+  const uint32_t __mv = 4 * __m2;
+  const uint32_t __mp = 4 * __m2 + 2;
+  // Implicit bool -> int conversion. True is 1, false is 0.
+  const uint32_t __mmShift = __ieeeMantissa != 0 || __ieeeExponent <= 1;
+  const uint32_t __mm = 4 * __m2 - 1 - __mmShift;
+
+  // Step 3: Convert to a decimal power base using 64-bit arithmetic.
+  uint32_t __vr, __vp, __vm;
+  int32_t __e10;
+  bool __vmIsTrailingZeros = false;
+  bool __vrIsTrailingZeros = false;
+  uint8_t __lastRemovedDigit = 0;
+  if (__e2 >= 0) {
+    const uint32_t __q = __log10Pow2(__e2);
+    __e10 = static_cast<int32_t>(__q);
+    const int32_t __k = __FLOAT_POW5_INV_BITCOUNT + __pow5bits(static_cast<int32_t>(__q)) - 1;
+    const int32_t __i = -__e2 + static_cast<int32_t>(__q) + __k;
+    __vr = __mulPow5InvDivPow2(__mv, __q, __i);
+    __vp = __mulPow5InvDivPow2(__mp, __q, __i);
+    __vm = __mulPow5InvDivPow2(__mm, __q, __i);
+    if (__q != 0 && (__vp - 1) / 10 <= __vm / 10) {
+      // We need to know one removed digit even if we are not going to loop below. We could use
+      // __q = X - 1 above, except that would require 33 bits for the result, and we've found that
+      // 32-bit arithmetic is faster even on 64-bit machines.
+      const int32_t __l = __FLOAT_POW5_INV_BITCOUNT + __pow5bits(static_cast<int32_t>(__q - 1)) - 1;
+      __lastRemovedDigit = static_cast<uint8_t>(__mulPow5InvDivPow2(__mv, __q - 1,
+        -__e2 + static_cast<int32_t>(__q) - 1 + __l) % 10);
+    }
+    if (__q <= 9) {
+      // The largest power of 5 that fits in 24 bits is 5^10, but __q <= 9 seems to be safe as well.
+      // Only one of __mp, __mv, and __mm can be a multiple of 5, if any.
+      if (__mv % 5 == 0) {
+        __vrIsTrailingZeros = __multipleOfPowerOf5(__mv, __q);
+      } else if (__acceptBounds) {
+        __vmIsTrailingZeros = __multipleOfPowerOf5(__mm, __q);
+      } else {
+        __vp -= __multipleOfPowerOf5(__mp, __q);
+      }
+    }
+  } else {
+    const uint32_t __q = __log10Pow5(-__e2);
+    __e10 = static_cast<int32_t>(__q) + __e2;
+    const int32_t __i = -__e2 - static_cast<int32_t>(__q);
+    const int32_t __k = __pow5bits(__i) - __FLOAT_POW5_BITCOUNT;
+    int32_t __j = static_cast<int32_t>(__q) - __k;
+    __vr = __mulPow5divPow2(__mv, static_cast<uint32_t>(__i), __j);
+    __vp = __mulPow5divPow2(__mp, static_cast<uint32_t>(__i), __j);
+    __vm = __mulPow5divPow2(__mm, static_cast<uint32_t>(__i), __j);
+    if (__q != 0 && (__vp - 1) / 10 <= __vm / 10) {
+      __j = static_cast<int32_t>(__q) - 1 - (__pow5bits(__i + 1) - __FLOAT_POW5_BITCOUNT);
+      __lastRemovedDigit = static_cast<uint8_t>(__mulPow5divPow2(__mv, static_cast<uint32_t>(__i + 1), __j) % 10);
+    }
+    if (__q <= 1) {
+      // {__vr,__vp,__vm} is trailing zeros if {__mv,__mp,__mm} has at least __q trailing 0 bits.
+      // __mv = 4 * __m2, so it always has at least two trailing 0 bits.
+      __vrIsTrailingZeros = true;
+      if (__acceptBounds) {
+        // __mm = __mv - 1 - __mmShift, so it has 1 trailing 0 bit iff __mmShift == 1.
+        __vmIsTrailingZeros = __mmShift == 1;
+      } else {
+        // __mp = __mv + 2, so it always has at least one trailing 0 bit.
+        --__vp;
+      }
+    } else if (__q < 31) { // TRANSITION(ulfjack): Use a tighter bound here.
+      __vrIsTrailingZeros = __multipleOfPowerOf2(__mv, __q - 1);
+    }
+  }
+
+  // Step 4: Find the shortest decimal representation in the interval of valid representations.
+  int32_t __removed = 0;
+  uint32_t _Output;
+  if (__vmIsTrailingZeros || __vrIsTrailingZeros) {
+    // General case, which happens rarely (~4.0%).
+    while (__vp / 10 > __vm / 10) {
+#ifdef __clang__ // TRANSITION, LLVM-23106
+      __vmIsTrailingZeros &= __vm - (__vm / 10) * 10 == 0;
+#else
+      __vmIsTrailingZeros &= __vm % 10 == 0;
+#endif
+      __vrIsTrailingZeros &= __lastRemovedDigit == 0;
+      __lastRemovedDigit = static_cast<uint8_t>(__vr % 10);
+      __vr /= 10;
+      __vp /= 10;
+      __vm /= 10;
+      ++__removed;
+    }
+    if (__vmIsTrailingZeros) {
+      while (__vm % 10 == 0) {
+        __vrIsTrailingZeros &= __lastRemovedDigit == 0;
+        __lastRemovedDigit = static_cast<uint8_t>(__vr % 10);
+        __vr /= 10;
+        __vp /= 10;
+        __vm /= 10;
+        ++__removed;
+      }
+    }
+    if (__vrIsTrailingZeros && __lastRemovedDigit == 5 && __vr % 2 == 0) {
+      // Round even if the exact number is .....50..0.
+      __lastRemovedDigit = 4;
+    }
+    // We need to take __vr + 1 if __vr is outside bounds or we need to round up.
+    _Output = __vr + ((__vr == __vm && (!__acceptBounds || !__vmIsTrailingZeros)) || __lastRemovedDigit >= 5);
+  } else {
+    // Specialized for the common case (~96.0%). Percentages below are relative to this.
+    // Loop iterations below (approximately):
+    // 0: 13.6%, 1: 70.7%, 2: 14.1%, 3: 1.39%, 4: 0.14%, 5+: 0.01%
+    while (__vp / 10 > __vm / 10) {
+      __lastRemovedDigit = static_cast<uint8_t>(__vr % 10);
+      __vr /= 10;
+      __vp /= 10;
+      __vm /= 10;
+      ++__removed;
+    }
+    // We need to take __vr + 1 if __vr is outside bounds or we need to round up.
+    _Output = __vr + (__vr == __vm || __lastRemovedDigit >= 5);
+  }
+  const int32_t __exp = __e10 + __removed;
+
+  __floating_decimal_32 __fd;
+  __fd.__exponent = __exp;
+  __fd.__mantissa = _Output;
+  return __fd;
+}
+
+template <class _CharT>
+_NODISCARD pair<_CharT*, errc> _Large_integer_to_chars(_CharT* const _First, _CharT* const _Last,
+  const uint32_t _Mantissa2, const int32_t _Exponent2) {
+
+  // Print the integer _Mantissa2 * 2^_Exponent2 exactly.
+
+  // For nonzero integers, _Exponent2 >= -23. (The minimum value occurs when _Mantissa2 * 2^_Exponent2 is 1.
+  // In that case, _Mantissa2 is the implicit 1 bit followed by 23 zeros, so _Exponent2 is -23 to shift away
+  // the zeros.) The dense range of exactly representable integers has negative or zero exponents
+  // (as positive exponents make the range non-dense). For that dense range, Ryu will always be used:
+  // every digit is necessary to uniquely identify the value, so Ryu must print them all.
+
+  // Positive exponents are the non-dense range of exactly representable integers.
+  // This contains all of the values for which Ryu can't be used (and a few Ryu-friendly values).
+
+  // Performance note: Long division appears to be faster than losslessly widening float to double and calling
+  // __d2fixed_buffered_n(). If __f2fixed_buffered_n() is implemented, it might be faster than long division.
+
+  _STL_INTERNAL_CHECK(_Exponent2 > 0);
+  _STL_INTERNAL_CHECK(_Exponent2 <= 104); // because __ieeeExponent <= 254
+
+  // Manually represent _Mantissa2 * 2^_Exponent2 as a large integer. _Mantissa2 is always 24 bits
+  // (due to the implicit bit), while _Exponent2 indicates a shift of at most 104 bits.
+  // 24 + 104 equals 128 equals 4 * 32, so we need exactly 4 32-bit elements.
+  // We use a little-endian representation, visualized like this:
+
+  // << left shift <<
+  // most significant
+  // _Data[3] _Data[2] _Data[1] _Data[0]
+  //                   least significant
+  //                   >> right shift >>
+
+  constexpr uint32_t _Data_size = 4;
+  uint32_t _Data[_Data_size]{};
+
+  // _Maxidx is the index of the most significant nonzero element.
+  uint32_t _Maxidx = ((24 + static_cast<uint32_t>(_Exponent2) + 31) / 32) - 1;
+  _STL_INTERNAL_CHECK(_Maxidx < _Data_size);
+
+  const uint32_t _Bit_shift = static_cast<uint32_t>(_Exponent2) % 32;
+  if (_Bit_shift <= 8) { // _Mantissa2's 24 bits don't cross an element boundary
+    _Data[_Maxidx] = _Mantissa2 << _Bit_shift;
+  } else { // _Mantissa2's 24 bits cross an element boundary
+    _Data[_Maxidx - 1] = _Mantissa2 << _Bit_shift;
+    _Data[_Maxidx] = _Mantissa2 >> (32 - _Bit_shift);
+  }
+
+  // If Ryu hasn't determined the total output length, we need to buffer the digits generated from right to left
+  // by long division. The largest possible float is: 340'282346638'528859811'704183484'516925440
+  uint32_t _Blocks[4];
+  int32_t _Filled_blocks = 0;
+  // From left to right, we're going to print:
+  // _Data[0] will be [1, 10] digits.
+  // Then if _Filled_blocks > 0:
+  // _Blocks[_Filled_blocks - 1], ..., _Blocks[0] will be 0-filled 9-digit blocks.
+
+  if (_Maxidx != 0) { // If the integer is actually large, perform long division.
+                      // Otherwise, skip to printing _Data[0].
+    for (;;) {
+      // Loop invariant: _Maxidx != 0 (i.e. the integer is actually large)
+
+      const uint32_t _Most_significant_elem = _Data[_Maxidx];
+      const uint32_t _Initial_remainder = _Most_significant_elem % 1000000000;
+      const uint32_t _Initial_quotient = _Most_significant_elem / 1000000000;
+      _Data[_Maxidx] = _Initial_quotient;
+      uint64_t _Remainder = _Initial_remainder;
+
+      // Process less significant elements.
+      uint32_t _Idx = _Maxidx;
+      do {
+        --_Idx; // Initially, _Remainder is at most 10^9 - 1.
+
+        // Now, _Remainder is at most (10^9 - 1) * 2^32 + 2^32 - 1, simplified to 10^9 * 2^32 - 1.
+        _Remainder = (_Remainder << 32) | _Data[_Idx];
+
+        // floor((10^9 * 2^32 - 1) / 10^9) == 2^32 - 1, so uint32_t _Quotient is lossless.
+        const uint32_t _Quotient = static_cast<uint32_t>(__div1e9(_Remainder));
+
+        // _Remainder is at most 10^9 - 1 again.
+        // For uint32_t truncation, see the __mod1e9() comment in d2s_intrinsics.h.
+        _Remainder = static_cast<uint32_t>(_Remainder) - 1000000000u * _Quotient;
+
+        _Data[_Idx] = _Quotient;
+      } while (_Idx != 0);
+
+      // Store a 0-filled 9-digit block.
+      _Blocks[_Filled_blocks++] = static_cast<uint32_t>(_Remainder);
+
+      if (_Initial_quotient == 0) { // Is the large integer shrinking?
+        --_Maxidx; // log2(10^9) is 29.9, so we can't shrink by more than one element.
+        if (_Maxidx == 0) {
+          break; // We've finished long division. Now we need to print _Data[0].
+        }
+      }
+    }
+  }
+
+  _STL_INTERNAL_CHECK(_Data[0] != 0);
+  for (uint32_t _Idx = 1; _Idx < _Data_size; ++_Idx) {
+    _STL_INTERNAL_CHECK(_Data[_Idx] == 0);
+  }
+
+  const uint32_t _Data_olength = _Data[0] >= 1000000000 ? 10 : __decimalLength9(_Data[0]);
+  const uint32_t _Total_fixed_length = _Data_olength + 9 * _Filled_blocks;
+
+  if (_Last - _First < static_cast<ptrdiff_t>(_Total_fixed_length)) {
+    return { _Last, errc::value_too_large };
+  }
+
+  _CharT* _Result = _First;
+
+  // Print _Data[0]. While it's up to 10 digits,
+  // which is more than Ryu generates, the code below can handle this.
+  __append_n_digits(_Data_olength, _Data[0], _Result);
+  _Result += _Data_olength;
+
+  // Print 0-filled 9-digit blocks.
+  for (int32_t _Idx = _Filled_blocks - 1; _Idx >= 0; --_Idx) {
+    __append_nine_digits(_Blocks[_Idx], _Result);
+    _Result += 9;
+  }
+
+  return { _Result, errc{} };
+}
+
+template <class _CharT>
+_NODISCARD pair<_CharT*, errc> __to_chars(_CharT* const _First, _CharT* const _Last, const __floating_decimal_32 __v,
+  chars_format _Fmt, const uint32_t __ieeeMantissa, const uint32_t __ieeeExponent) {
+  // Step 5: Print the decimal representation.
+  uint32_t _Output = __v.__mantissa;
+  const int32_t _Ryu_exponent = __v.__exponent;
+  const uint32_t __olength = __decimalLength9(_Output);
+  int32_t _Scientific_exponent = _Ryu_exponent + static_cast<int32_t>(__olength) - 1;
+
+  if (_Fmt == chars_format{}) {
+    int32_t _Lower;
+    int32_t _Upper;
+
+    if (__olength == 1) {
+      // Value | Fixed   | Scientific
+      // 1e-3  | "0.001" | "1e-03"
+      // 1e4   | "10000" | "1e+04"
+      _Lower = -3;
+      _Upper = 4;
+    } else {
+      // Value   | Fixed       | Scientific
+      // 1234e-7 | "0.0001234" | "1.234e-04"
+      // 1234e5  | "123400000" | "1.234e+08"
+      _Lower = -static_cast<int32_t>(__olength + 3);
+      _Upper = 5;
+    }
+
+    if (_Lower <= _Ryu_exponent && _Ryu_exponent <= _Upper) {
+      _Fmt = chars_format::fixed;
+    } else {
+      _Fmt = chars_format::scientific;
+    }
+  } else if (_Fmt == chars_format::general) {
+    // C11 7.21.6.1 "The fprintf function"/8:
+    // "Let P equal [...] 6 if the precision is omitted [...].
+    // Then, if a conversion with style E would have an exponent of X:
+    // - if P > X >= -4, the conversion is with style f [...].
+    // - otherwise, the conversion is with style e [...]."
+    if (-4 <= _Scientific_exponent && _Scientific_exponent < 6) {
+      _Fmt = chars_format::fixed;
+    } else {
+      _Fmt = chars_format::scientific;
+    }
+  }
+
+  if (_Fmt == chars_format::fixed) {
+    // Example: _Output == 1729, __olength == 4
+
+    // _Ryu_exponent | Printed  | _Whole_digits | _Total_fixed_length  | Notes
+    // --------------|----------|---------------|----------------------|---------------------------------------
+    //             2 | 172900   |  6            | _Whole_digits        | Ryu can't be used for printing
+    //             1 | 17290    |  5            | (sometimes adjusted) | when the trimmed digits are nonzero.
+    // --------------|----------|---------------|----------------------|---------------------------------------
+    //             0 | 1729     |  4            | _Whole_digits        | Unified length cases.
+    // --------------|----------|---------------|----------------------|---------------------------------------
+    //            -1 | 172.9    |  3            | __olength + 1        | This case can't happen for
+    //            -2 | 17.29    |  2            |                      | __olength == 1, but no additional
+    //            -3 | 1.729    |  1            |                      | code is needed to avoid it.
+    // --------------|----------|---------------|----------------------|---------------------------------------
+    //            -4 | 0.1729   |  0            | 2 - _Ryu_exponent    | C11 7.21.6.1 "The fprintf function"/8:
+    //            -5 | 0.01729  | -1            |                      | "If a decimal-point character appears,
+    //            -6 | 0.001729 | -2            |                      | at least one digit appears before it."
+
+    const int32_t _Whole_digits = static_cast<int32_t>(__olength) + _Ryu_exponent;
+
+    uint32_t _Total_fixed_length;
+    if (_Ryu_exponent >= 0) { // cases "172900" and "1729"
+      _Total_fixed_length = static_cast<uint32_t>(_Whole_digits);
+      if (_Output == 1) {
+        // Rounding can affect the number of digits.
+        // For example, 1e11f is exactly "99999997952" which is 11 digits instead of 12.
+        // We can use a lookup table to detect this and adjust the total length.
+        static constexpr uint8_t _Adjustment[39] = {
+          0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,0,1,1,1,0,0,1,1,0,1,0,1,1,0,0,1,0,1,1,0,1,1,1 };
+        _Total_fixed_length -= _Adjustment[_Ryu_exponent];
+        // _Whole_digits doesn't need to be adjusted because these cases won't refer to it later.
+      }
+    } else if (_Whole_digits > 0) { // case "17.29"
+      _Total_fixed_length = __olength + 1;
+    } else { // case "0.001729"
+      _Total_fixed_length = static_cast<uint32_t>(2 - _Ryu_exponent);
+    }
+
+    if (_Last - _First < static_cast<ptrdiff_t>(_Total_fixed_length)) {
+      return { _Last, errc::value_too_large };
+    }
+
+    _CharT* _Mid;
+    if (_Ryu_exponent > 0) { // case "172900"
+      bool _Can_use_ryu;
+
+      if (_Ryu_exponent > 10) { // 10^10 is the largest power of 10 that's exactly representable as a float.
+        _Can_use_ryu = false;
+      } else {
+        // Ryu generated X: __v.__mantissa * 10^_Ryu_exponent
+        // __v.__mantissa == 2^_Trailing_zero_bits * (__v.__mantissa >> _Trailing_zero_bits)
+        // 10^_Ryu_exponent == 2^_Ryu_exponent * 5^_Ryu_exponent
+
+        // _Trailing_zero_bits is [0, 29] (aside: because 2^29 is the largest power of 2
+        // with 9 decimal digits, which is float's round-trip limit.)
+        // _Ryu_exponent is [1, 10].
+        // Normalization adds [2, 23] (aside: at least 2 because the pre-normalized mantissa is at least 5).
+        // This adds up to [3, 62], which is well below float's maximum binary exponent 127.
+
+        // Therefore, we just need to consider (__v.__mantissa >> _Trailing_zero_bits) * 5^_Ryu_exponent.
+
+        // If that product would exceed 24 bits, then X can't be exactly represented as a float.
+        // (That's not a problem for round-tripping, because X is close enough to the original float,
+        // but X isn't mathematically equal to the original float.) This requires a high-precision fallback.
+
+        // If the product is 24 bits or smaller, then X can be exactly represented as a float (and we don't
+        // need to re-synthesize it; the original float must have been X, because Ryu wouldn't produce the
+        // same output for two different floats X and Y). This allows Ryu's output to be used (zero-filled).
+
+        // (2^24 - 1) / 5^0 (for indexing), (2^24 - 1) / 5^1, ..., (2^24 - 1) / 5^10
+        static constexpr uint32_t _Max_shifted_mantissa[11] = {
+          16777215, 3355443, 671088, 134217, 26843, 5368, 1073, 214, 42, 8, 1 };
+
+        unsigned long _Trailing_zero_bits;
+        (void) _BitScanForward(&_Trailing_zero_bits, __v.__mantissa); // __v.__mantissa is guaranteed nonzero
+        const uint32_t _Shifted_mantissa = __v.__mantissa >> _Trailing_zero_bits;
+        _Can_use_ryu = _Shifted_mantissa <= _Max_shifted_mantissa[_Ryu_exponent];
+      }
+
+      if (!_Can_use_ryu) {
+        const uint32_t _Mantissa2 = __ieeeMantissa | (1u << __FLOAT_MANTISSA_BITS); // restore implicit bit
+        const int32_t _Exponent2 = static_cast<int32_t>(__ieeeExponent)
+          - __FLOAT_BIAS - __FLOAT_MANTISSA_BITS; // bias and normalization
+
+        // Performance note: We've already called Ryu, so this will redundantly perform buffering and bounds checking.
+        return _Large_integer_to_chars(_First, _Last, _Mantissa2, _Exponent2);
+      }
+
+      // _Can_use_ryu
+      // Print the decimal digits, left-aligned within [_First, _First + _Total_fixed_length).
+      _Mid = _First + __olength;
+    } else { // cases "1729", "17.29", and "0.001729"
+      // Print the decimal digits, right-aligned within [_First, _First + _Total_fixed_length).
+      _Mid = _First + _Total_fixed_length;
+    }
+
+    while (_Output >= 10000) {
+#ifdef __clang__ // TRANSITION, LLVM-38217
+      const uint32_t __c = _Output - 10000 * (_Output / 10000);
+#else
+      const uint32_t __c = _Output % 10000;
+#endif
+      _Output /= 10000;
+      const uint32_t __c0 = (__c % 100) << 1;
+      const uint32_t __c1 = (__c / 100) << 1;
+      _CSTD memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c0, 2 * sizeof(_CharT));
+      _CSTD memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c1, 2 * sizeof(_CharT));
+    }
+    if (_Output >= 100) {
+      const uint32_t __c = (_Output % 100) << 1;
+      _Output /= 100;
+      _CSTD memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
+    }
+    if (_Output >= 10) {
+      const uint32_t __c = _Output << 1;
+      _CSTD memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
+    } else {
+      *--_Mid = static_cast<_CharT>(_WIDEN(_CharT, '0') + _Output);
+    }
+
+    if (_Ryu_exponent > 0) { // case "172900" with _Can_use_ryu
+      // Performance note: it might be more efficient to do this immediately after setting _Mid.
+      _STD fill_n(_First + __olength, _Ryu_exponent, _WIDEN(_CharT, '0'));
+    } else if (_Ryu_exponent == 0) { // case "1729"
+      // Done!
+    } else if (_Whole_digits > 0) { // case "17.29"
+      // Performance note: moving digits might not be optimal.
+      _CSTD memmove(_First, _First + 1, static_cast<size_t>(_Whole_digits) * sizeof(_CharT));
+      _First[_Whole_digits] = _WIDEN(_CharT, '.');
+    } else { // case "0.001729"
+      // Performance note: a larger memset() followed by overwriting '.' might be more efficient.
+      _First[0] = _WIDEN(_CharT, '0');
+      _First[1] = _WIDEN(_CharT, '.');
+      _STD fill_n(_First + 2, -_Whole_digits, _WIDEN(_CharT, '0'));
+    }
+
+    return { _First + _Total_fixed_length, errc{} };
+  }
+
+  const uint32_t _Total_scientific_length =
+    __olength + (__olength > 1) + 4; // digits + possible decimal point + scientific exponent
+  if (_Last - _First < static_cast<ptrdiff_t>(_Total_scientific_length)) {
+    return { _Last, errc::value_too_large };
+  }
+  _CharT* const __result = _First;
+
+  // Print the decimal digits.
+  uint32_t __i = 0;
+  while (_Output >= 10000) {
+#ifdef __clang__ // TRANSITION, LLVM-38217
+    const uint32_t __c = _Output - 10000 * (_Output / 10000);
+#else
+    const uint32_t __c = _Output % 10000;
+#endif
+    _Output /= 10000;
+    const uint32_t __c0 = (__c % 100) << 1;
+    const uint32_t __c1 = (__c / 100) << 1;
+    _CSTD memcpy(__result + __olength - __i - 1, __DIGIT_TABLE<_CharT> + __c0, 2 * sizeof(_CharT));
+    _CSTD memcpy(__result + __olength - __i - 3, __DIGIT_TABLE<_CharT> + __c1, 2 * sizeof(_CharT));
+    __i += 4;
+  }
+  if (_Output >= 100) {
+    const uint32_t __c = (_Output % 100) << 1;
+    _Output /= 100;
+    _CSTD memcpy(__result + __olength - __i - 1, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
+    __i += 2;
+  }
+  if (_Output >= 10) {
+    const uint32_t __c = _Output << 1;
+    // We can't use memcpy here: the decimal dot goes between these two digits.
+    __result[2] = __DIGIT_TABLE<_CharT>[__c + 1];
+    __result[0] = __DIGIT_TABLE<_CharT>[__c];
+  } else {
+    __result[0] = static_cast<_CharT>(_WIDEN(_CharT, '0') + _Output);
+  }
+
+  // Print decimal point if needed.
+  uint32_t __index;
+  if (__olength > 1) {
+    __result[1] = _WIDEN(_CharT, '.');
+    __index = __olength + 1;
+  } else {
+    __index = 1;
+  }
+
+  // Print the exponent.
+  __result[__index++] = _WIDEN(_CharT, 'e');
+  if (_Scientific_exponent < 0) {
+    __result[__index++] = _WIDEN(_CharT, '-');
+    _Scientific_exponent = -_Scientific_exponent;
+  } else {
+    __result[__index++] = _WIDEN(_CharT, '+');
+  }
+
+  _CSTD memcpy(__result + __index, __DIGIT_TABLE<_CharT> + 2 * _Scientific_exponent, 2 * sizeof(_CharT));
+  __index += 2;
+
+  return { _First + _Total_scientific_length, errc{} };
+}
+
+_NODISCARD inline to_chars_result _Convert_to_chars_result(const pair<char*, errc>& _Pair) {
+    return {_Pair.first, _Pair.second};
+}
+
+template <class _CharT>
+_NODISCARD pair<_CharT*, errc> __f2s_buffered_n(_CharT* const _First, _CharT* const _Last, const float __f,
+  const chars_format _Fmt) {
+
+  // Step 1: Decode the floating-point number, and unify normalized and subnormal cases.
+  const uint32_t __bits = __float_to_bits(__f);
+
+  // Case distinction; exit early for the easy cases.
+  if (__bits == 0) {
+    if (_Fmt == chars_format::scientific) {
+      if (_Last - _First < 5) {
+        return { _Last, errc::value_too_large };
+      }
+
+      if constexpr (is_same_v<_CharT, char>) {
+        _CSTD memcpy(_First, "0e+00", 5);
+      } else {
+        _CSTD memcpy(_First, L"0e+00", 5 * sizeof(wchar_t));
+      }
+
+      return { _First + 5, errc{} };
+    }
+
+    // Print "0" for chars_format::fixed, chars_format::general, and chars_format{}.
+    if (_First == _Last) {
+      return { _Last, errc::value_too_large };
+    }
+
+    *_First = _WIDEN(_CharT, '0');
+
+    return { _First + 1, errc{} };
+  }
+
+  // Decode __bits into mantissa and exponent.
+  const uint32_t __ieeeMantissa = __bits & ((1u << __FLOAT_MANTISSA_BITS) - 1);
+  const uint32_t __ieeeExponent = __bits >> __FLOAT_MANTISSA_BITS;
+
+  // When _Fmt == chars_format::fixed and the floating-point number is a large integer,
+  // it's faster to skip Ryu and immediately print the integer exactly.
+  if (_Fmt == chars_format::fixed) {
+    const uint32_t _Mantissa2 = __ieeeMantissa | (1u << __FLOAT_MANTISSA_BITS); // restore implicit bit
+    const int32_t _Exponent2 = static_cast<int32_t>(__ieeeExponent)
+      - __FLOAT_BIAS - __FLOAT_MANTISSA_BITS; // bias and normalization
+
+    // Normal values are equal to _Mantissa2 * 2^_Exponent2.
+    // (Subnormals are different, but they'll be rejected by the _Exponent2 test here, so they can be ignored.)
+
+    if (_Exponent2 > 0) {
+      return _Large_integer_to_chars(_First, _Last, _Mantissa2, _Exponent2);
+    }
+  }
+
+  const __floating_decimal_32 __v = __f2d(__ieeeMantissa, __ieeeExponent);
+  return __to_chars(_First, _Last, __v, _Fmt, __ieeeMantissa, __ieeeExponent);
+}
+
+// ^^^^^^^^^^ DERIVED FROM f2s.c ^^^^^^^^^^
+
+// vvvvvvvvvv DERIVED FROM d2s.c vvvvvvvvvv
+
+// We need a 64x128-bit multiplication and a subsequent 128-bit shift.
+// Multiplication:
+//   The 64-bit factor is variable and passed in, the 128-bit factor comes
+//   from a lookup table. We know that the 64-bit factor only has 55
+//   significant bits (i.e., the 9 topmost bits are zeros). The 128-bit
+//   factor only has 124 significant bits (i.e., the 4 topmost bits are
+//   zeros).
+// Shift:
+//   In principle, the multiplication result requires 55 + 124 = 179 bits to
+//   represent. However, we then shift this value to the right by __j, which is
+//   at least __j >= 115, so the result is guaranteed to fit into 179 - 115 = 64
+//   bits. This means that we only need the topmost 64 significant bits of
+//   the 64x128-bit multiplication.
+//
+// There are several ways to do this:
+// 1. Best case: the compiler exposes a 128-bit type.
+//    We perform two 64x64-bit multiplications, add the higher 64 bits of the
+//    lower result to the higher result, and shift by __j - 64 bits.
+//
+//    We explicitly cast from 64-bit to 128-bit, so the compiler can tell
+//    that these are only 64-bit inputs, and can map these to the best
+//    possible sequence of assembly instructions.
+//    x64 machines happen to have matching assembly instructions for
+//    64x64-bit multiplications and 128-bit shifts.
+//
+// 2. Second best case: the compiler exposes intrinsics for the x64 assembly
+//    instructions mentioned in 1.
+//
+// 3. We only have 64x64 bit instructions that return the lower 64 bits of
+//    the result, i.e., we have to use plain C.
+//    Our inputs are less than the full width, so we have three options:
+//    a. Ignore this fact and just implement the intrinsics manually.
+//    b. Split both into 31-bit pieces, which guarantees no internal overflow,
+//       but requires extra work upfront (unless we change the lookup table).
+//    c. Split only the first factor into 31-bit pieces, which also guarantees
+//       no internal overflow, but requires extra work since the intermediate
+//       results are not perfectly aligned.
+#if _HAS_CHARCONV_INTRINSICS
+
+_NODISCARD inline uint64_t __mulShift(const uint64_t __m, const uint64_t* const __mul, const int32_t __j) {
+  // __m is maximum 55 bits
+  uint64_t __high1;                                               // 128
+  const uint64_t __low1 = __ryu_umul128(__m, __mul[1], &__high1); // 64
+  uint64_t __high0;                                               // 64
+  (void) __ryu_umul128(__m, __mul[0], &__high0);                  // 0
+  const uint64_t __sum = __high0 + __low1;
+  if (__sum < __high0) {
+    ++__high1; // overflow into __high1
+  }
+  return __ryu_shiftright128(__sum, __high1, static_cast<uint32_t>(__j - 64));
+}
+
+_NODISCARD inline uint64_t __mulShiftAll(const uint64_t __m, const uint64_t* const __mul, const int32_t __j,
+  uint64_t* const __vp, uint64_t* const __vm, const uint32_t __mmShift) {
+  *__vp = __mulShift(4 * __m + 2, __mul, __j);
+  *__vm = __mulShift(4 * __m - 1 - __mmShift, __mul, __j);
+  return __mulShift(4 * __m, __mul, __j);
+}
+
+#else // ^^^ intrinsics available / intrinsics unavailable vvv
+
+_NODISCARD __forceinline uint64_t __mulShiftAll(uint64_t __m, const uint64_t* const __mul, const int32_t __j,
+  uint64_t* const __vp, uint64_t* const __vm, const uint32_t __mmShift) { // TRANSITION, VSO-634761
+  __m <<= 1;
+  // __m is maximum 55 bits
+  uint64_t __tmp;
+  const uint64_t __lo = __ryu_umul128(__m, __mul[0], &__tmp);
+  uint64_t __hi;
+  const uint64_t __mid = __tmp + __ryu_umul128(__m, __mul[1], &__hi);
+  __hi += __mid < __tmp; // overflow into __hi
+
+  const uint64_t __lo2 = __lo + __mul[0];
+  const uint64_t __mid2 = __mid + __mul[1] + (__lo2 < __lo);
+  const uint64_t __hi2 = __hi + (__mid2 < __mid);
+  *__vp = __ryu_shiftright128(__mid2, __hi2, static_cast<uint32_t>(__j - 64 - 1));
+
+  if (__mmShift == 1) {
+    const uint64_t __lo3 = __lo - __mul[0];
+    const uint64_t __mid3 = __mid - __mul[1] - (__lo3 > __lo);
+    const uint64_t __hi3 = __hi - (__mid3 > __mid);
+    *__vm = __ryu_shiftright128(__mid3, __hi3, static_cast<uint32_t>(__j - 64 - 1));
+  } else {
+    const uint64_t __lo3 = __lo + __lo;
+    const uint64_t __mid3 = __mid + __mid + (__lo3 < __lo);
+    const uint64_t __hi3 = __hi + __hi + (__mid3 < __mid);
+    const uint64_t __lo4 = __lo3 - __mul[0];
+    const uint64_t __mid4 = __mid3 - __mul[1] - (__lo4 > __lo3);
+    const uint64_t __hi4 = __hi3 - (__mid4 > __mid3);
+    *__vm = __ryu_shiftright128(__mid4, __hi4, static_cast<uint32_t>(__j - 64));
+  }
+
+  return __ryu_shiftright128(__mid, __hi, static_cast<uint32_t>(__j - 64 - 1));
+}
+
+#endif // ^^^ intrinsics unavailable ^^^
+
+_NODISCARD inline uint32_t __decimalLength17(const uint64_t __v) {
+  // This is slightly faster than a loop.
+  // The average output length is 16.38 digits, so we check high-to-low.
+  // Function precondition: __v is not an 18, 19, or 20-digit number.
+  // (17 digits are sufficient for round-tripping.)
+  _STL_INTERNAL_CHECK(__v < 100000000000000000u);
+  if (__v >= 10000000000000000u) { return 17; }
+  if (__v >= 1000000000000000u) { return 16; }
+  if (__v >= 100000000000000u) { return 15; }
+  if (__v >= 10000000000000u) { return 14; }
+  if (__v >= 1000000000000u) { return 13; }
+  if (__v >= 100000000000u) { return 12; }
+  if (__v >= 10000000000u) { return 11; }
+  if (__v >= 1000000000u) { return 10; }
+  if (__v >= 100000000u) { return 9; }
+  if (__v >= 10000000u) { return 8; }
+  if (__v >= 1000000u) { return 7; }
+  if (__v >= 100000u) { return 6; }
+  if (__v >= 10000u) { return 5; }
+  if (__v >= 1000u) { return 4; }
+  if (__v >= 100u) { return 3; }
+  if (__v >= 10u) { return 2; }
+  return 1;
+}
+
+// A floating decimal representing m * 10^e.
+struct __floating_decimal_64 {
+  uint64_t __mantissa;
+  int32_t __exponent;
+};
+
+_NODISCARD inline __floating_decimal_64 __d2d(const uint64_t __ieeeMantissa, const uint32_t __ieeeExponent) {
+  int32_t __e2;
+  uint64_t __m2;
+  if (__ieeeExponent == 0) {
+    // We subtract 2 so that the bounds computation has 2 additional bits.
+    __e2 = 1 - __DOUBLE_BIAS - __DOUBLE_MANTISSA_BITS - 2;
+    __m2 = __ieeeMantissa;
+  } else {
+    __e2 = static_cast<int32_t>(__ieeeExponent) - __DOUBLE_BIAS - __DOUBLE_MANTISSA_BITS - 2;
+    __m2 = (1ull << __DOUBLE_MANTISSA_BITS) | __ieeeMantissa;
+  }
+  const bool __even = (__m2 & 1) == 0;
+  const bool __acceptBounds = __even;
+
+  // Step 2: Determine the interval of valid decimal representations.
+  const uint64_t __mv = 4 * __m2;
+  // Implicit bool -> int conversion. True is 1, false is 0.
+  const uint32_t __mmShift = __ieeeMantissa != 0 || __ieeeExponent <= 1;
+  // We would compute __mp and __mm like this:
+  // uint64_t __mp = 4 * __m2 + 2;
+  // uint64_t __mm = __mv - 1 - __mmShift;
+
+  // Step 3: Convert to a decimal power base using 128-bit arithmetic.
+  uint64_t __vr, __vp, __vm;
+  int32_t __e10;
+  bool __vmIsTrailingZeros = false;
+  bool __vrIsTrailingZeros = false;
+  if (__e2 >= 0) {
+    // I tried special-casing __q == 0, but there was no effect on performance.
+    // This expression is slightly faster than max(0, __log10Pow2(__e2) - 1).
+    const uint32_t __q = __log10Pow2(__e2) - (__e2 > 3);
+    __e10 = static_cast<int32_t>(__q);
+    const int32_t __k = __DOUBLE_POW5_INV_BITCOUNT + __pow5bits(static_cast<int32_t>(__q)) - 1;
+    const int32_t __i = -__e2 + static_cast<int32_t>(__q) + __k;
+    __vr = __mulShiftAll(__m2, __DOUBLE_POW5_INV_SPLIT[__q], __i, &__vp, &__vm, __mmShift);
+    if (__q <= 21) {
+      // This should use __q <= 22, but I think 21 is also safe. Smaller values
+      // may still be safe, but it's more difficult to reason about them.
+      // Only one of __mp, __mv, and __mm can be a multiple of 5, if any.
+      const uint32_t __mvMod5 = static_cast<uint32_t>(__mv) - 5 * static_cast<uint32_t>(__div5(__mv));
+      if (__mvMod5 == 0) {
+        __vrIsTrailingZeros = __multipleOfPowerOf5(__mv, __q);
+      } else if (__acceptBounds) {
+        // Same as min(__e2 + (~__mm & 1), __pow5Factor(__mm)) >= __q
+        // <=> __e2 + (~__mm & 1) >= __q && __pow5Factor(__mm) >= __q
+        // <=> true && __pow5Factor(__mm) >= __q, since __e2 >= __q.
+        __vmIsTrailingZeros = __multipleOfPowerOf5(__mv - 1 - __mmShift, __q);
+      } else {
+        // Same as min(__e2 + 1, __pow5Factor(__mp)) >= __q.
+        __vp -= __multipleOfPowerOf5(__mv + 2, __q);
+      }
+    }
+  } else {
+    // This expression is slightly faster than max(0, __log10Pow5(-__e2) - 1).
+    const uint32_t __q = __log10Pow5(-__e2) - (-__e2 > 1);
+    __e10 = static_cast<int32_t>(__q) + __e2;
+    const int32_t __i = -__e2 - static_cast<int32_t>(__q);
+    const int32_t __k = __pow5bits(__i) - __DOUBLE_POW5_BITCOUNT;
+    const int32_t __j = static_cast<int32_t>(__q) - __k;
+    __vr = __mulShiftAll(__m2, __DOUBLE_POW5_SPLIT[__i], __j, &__vp, &__vm, __mmShift);
+    if (__q <= 1) {
+      // {__vr,__vp,__vm} is trailing zeros if {__mv,__mp,__mm} has at least __q trailing 0 bits.
+      // __mv = 4 * __m2, so it always has at least two trailing 0 bits.
+      __vrIsTrailingZeros = true;
+      if (__acceptBounds) {
+        // __mm = __mv - 1 - __mmShift, so it has 1 trailing 0 bit iff __mmShift == 1.
+        __vmIsTrailingZeros = __mmShift == 1;
+      } else {
+        // __mp = __mv + 2, so it always has at least one trailing 0 bit.
+        --__vp;
+      }
+    } else if (__q < 63) { // TRANSITION(ulfjack): Use a tighter bound here.
+      // We need to compute min(ntz(__mv), __pow5Factor(__mv) - __e2) >= __q - 1
+      // <=> ntz(__mv) >= __q - 1 && __pow5Factor(__mv) - __e2 >= __q - 1
+      // <=> ntz(__mv) >= __q - 1 (__e2 is negative and -__e2 >= __q)
+      // <=> (__mv & ((1 << (__q - 1)) - 1)) == 0
+      // We also need to make sure that the left shift does not overflow.
+      __vrIsTrailingZeros = __multipleOfPowerOf2(__mv, __q - 1);
+    }
+  }
+
+  // Step 4: Find the shortest decimal representation in the interval of valid representations.
+  int32_t __removed = 0;
+  uint8_t __lastRemovedDigit = 0;
+  uint64_t _Output;
+  // On average, we remove ~2 digits.
+  if (__vmIsTrailingZeros || __vrIsTrailingZeros) {
+    // General case, which happens rarely (~0.7%).
+    for (;;) {
+      const uint64_t __vpDiv10 = __div10(__vp);
+      const uint64_t __vmDiv10 = __div10(__vm);
+      if (__vpDiv10 <= __vmDiv10) {
+        break;
+      }
+      const uint32_t __vmMod10 = static_cast<uint32_t>(__vm) - 10 * static_cast<uint32_t>(__vmDiv10);
+      const uint64_t __vrDiv10 = __div10(__vr);
+      const uint32_t __vrMod10 = static_cast<uint32_t>(__vr) - 10 * static_cast<uint32_t>(__vrDiv10);
+      __vmIsTrailingZeros &= __vmMod10 == 0;
+      __vrIsTrailingZeros &= __lastRemovedDigit == 0;
+      __lastRemovedDigit = static_cast<uint8_t>(__vrMod10);
+      __vr = __vrDiv10;
+      __vp = __vpDiv10;
+      __vm = __vmDiv10;
+      ++__removed;
+    }
+    if (__vmIsTrailingZeros) {
+      for (;;) {
+        const uint64_t __vmDiv10 = __div10(__vm);
+        const uint32_t __vmMod10 = static_cast<uint32_t>(__vm) - 10 * static_cast<uint32_t>(__vmDiv10);
+        if (__vmMod10 != 0) {
+          break;
+        }
+        const uint64_t __vpDiv10 = __div10(__vp);
+        const uint64_t __vrDiv10 = __div10(__vr);
+        const uint32_t __vrMod10 = static_cast<uint32_t>(__vr) - 10 * static_cast<uint32_t>(__vrDiv10);
+        __vrIsTrailingZeros &= __lastRemovedDigit == 0;
+        __lastRemovedDigit = static_cast<uint8_t>(__vrMod10);
+        __vr = __vrDiv10;
+        __vp = __vpDiv10;
+        __vm = __vmDiv10;
+        ++__removed;
+      }
+    }
+    if (__vrIsTrailingZeros && __lastRemovedDigit == 5 && __vr % 2 == 0) {
+      // Round even if the exact number is .....50..0.
+      __lastRemovedDigit = 4;
+    }
+    // We need to take __vr + 1 if __vr is outside bounds or we need to round up.
+    _Output = __vr + ((__vr == __vm && (!__acceptBounds || !__vmIsTrailingZeros)) || __lastRemovedDigit >= 5);
+  } else {
+    // Specialized for the common case (~99.3%). Percentages below are relative to this.
+    bool __roundUp = false;
+    const uint64_t __vpDiv100 = __div100(__vp);
+    const uint64_t __vmDiv100 = __div100(__vm);
+    if (__vpDiv100 > __vmDiv100) { // Optimization: remove two digits at a time (~86.2%).
+      const uint64_t __vrDiv100 = __div100(__vr);
+      const uint32_t __vrMod100 = static_cast<uint32_t>(__vr) - 100 * static_cast<uint32_t>(__vrDiv100);
+      __roundUp = __vrMod100 >= 50;
+      __vr = __vrDiv100;
+      __vp = __vpDiv100;
+      __vm = __vmDiv100;
+      __removed += 2;
+    }
+    // Loop iterations below (approximately), without optimization above:
+    // 0: 0.03%, 1: 13.8%, 2: 70.6%, 3: 14.0%, 4: 1.40%, 5: 0.14%, 6+: 0.02%
+    // Loop iterations below (approximately), with optimization above:
+    // 0: 70.6%, 1: 27.8%, 2: 1.40%, 3: 0.14%, 4+: 0.02%
+    for (;;) {
+      const uint64_t __vpDiv10 = __div10(__vp);
+      const uint64_t __vmDiv10 = __div10(__vm);
+      if (__vpDiv10 <= __vmDiv10) {
+        break;
+      }
+      const uint64_t __vrDiv10 = __div10(__vr);
+      const uint32_t __vrMod10 = static_cast<uint32_t>(__vr) - 10 * static_cast<uint32_t>(__vrDiv10);
+      __roundUp = __vrMod10 >= 5;
+      __vr = __vrDiv10;
+      __vp = __vpDiv10;
+      __vm = __vmDiv10;
+      ++__removed;
+    }
+    // We need to take __vr + 1 if __vr is outside bounds or we need to round up.
+    _Output = __vr + (__vr == __vm || __roundUp);
+  }
+  const int32_t __exp = __e10 + __removed;
+
+  __floating_decimal_64 __fd;
+  __fd.__exponent = __exp;
+  __fd.__mantissa = _Output;
+  return __fd;
+}
+
+template <class _CharT>
+_NODISCARD pair<_CharT*, errc> __to_chars(_CharT* const _First, _CharT* const _Last, const __floating_decimal_64 __v,
+  chars_format _Fmt, const double __f) {
+  // Step 5: Print the decimal representation.
+  uint64_t _Output = __v.__mantissa;
+  const int32_t _Ryu_exponent = __v.__exponent;
+  const uint32_t __olength = __decimalLength17(_Output);
+  int32_t _Scientific_exponent = _Ryu_exponent + static_cast<int32_t>(__olength) - 1;
+
+  if (_Fmt == chars_format{}) {
+    int32_t _Lower;
+    int32_t _Upper;
+
+    if (__olength == 1) {
+      // Value | Fixed   | Scientific
+      // 1e-3  | "0.001" | "1e-03"
+      // 1e4   | "10000" | "1e+04"
+      _Lower = -3;
+      _Upper = 4;
+    } else {
+      // Value   | Fixed       | Scientific
+      // 1234e-7 | "0.0001234" | "1.234e-04"
+      // 1234e5  | "123400000" | "1.234e+08"
+      _Lower = -static_cast<int32_t>(__olength + 3);
+      _Upper = 5;
+    }
+
+    if (_Lower <= _Ryu_exponent && _Ryu_exponent <= _Upper) {
+      _Fmt = chars_format::fixed;
+    } else {
+      _Fmt = chars_format::scientific;
+    }
+  } else if (_Fmt == chars_format::general) {
+    // C11 7.21.6.1 "The fprintf function"/8:
+    // "Let P equal [...] 6 if the precision is omitted [...].
+    // Then, if a conversion with style E would have an exponent of X:
+    // - if P > X >= -4, the conversion is with style f [...].
+    // - otherwise, the conversion is with style e [...]."
+    if (-4 <= _Scientific_exponent && _Scientific_exponent < 6) {
+      _Fmt = chars_format::fixed;
+    } else {
+      _Fmt = chars_format::scientific;
+    }
+  }
+
+  if (_Fmt == chars_format::fixed) {
+    // Example: _Output == 1729, __olength == 4
+
+    // _Ryu_exponent | Printed  | _Whole_digits | _Total_fixed_length  | Notes
+    // --------------|----------|---------------|----------------------|---------------------------------------
+    //             2 | 172900   |  6            | _Whole_digits        | Ryu can't be used for printing
+    //             1 | 17290    |  5            | (sometimes adjusted) | when the trimmed digits are nonzero.
+    // --------------|----------|---------------|----------------------|---------------------------------------
+    //             0 | 1729     |  4            | _Whole_digits        | Unified length cases.
+    // --------------|----------|---------------|----------------------|---------------------------------------
+    //            -1 | 172.9    |  3            | __olength + 1        | This case can't happen for
+    //            -2 | 17.29    |  2            |                      | __olength == 1, but no additional
+    //            -3 | 1.729    |  1            |                      | code is needed to avoid it.
+    // --------------|----------|---------------|----------------------|---------------------------------------
+    //            -4 | 0.1729   |  0            | 2 - _Ryu_exponent    | C11 7.21.6.1 "The fprintf function"/8:
+    //            -5 | 0.01729  | -1            |                      | "If a decimal-point character appears,
+    //            -6 | 0.001729 | -2            |                      | at least one digit appears before it."
+
+    const int32_t _Whole_digits = static_cast<int32_t>(__olength) + _Ryu_exponent;
+
+    uint32_t _Total_fixed_length;
+    if (_Ryu_exponent >= 0) { // cases "172900" and "1729"
+      _Total_fixed_length = static_cast<uint32_t>(_Whole_digits);
+      if (_Output == 1) {
+        // Rounding can affect the number of digits.
+        // For example, 1e23 is exactly "99999999999999991611392" which is 23 digits instead of 24.
+        // We can use a lookup table to detect this and adjust the total length.
+        static constexpr uint8_t _Adjustment[309] = {
+          0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,1,1,0,1,0,1,1,1,0,1,1,1,0,0,0,0,0,
+          1,1,0,0,1,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,1,0,1,0,1,1,0,0,0,0,1,1,1,
+          1,0,0,0,0,0,0,0,1,1,0,1,1,0,0,1,0,1,0,1,0,1,1,0,0,0,0,0,1,1,1,0,0,1,1,1,1,1,0,1,0,1,1,0,1,
+          1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,1,0,0,1,0,0,1,1,1,1,0,0,1,1,0,1,1,0,1,1,0,1,0,0,0,1,0,0,0,1,
+          0,1,0,1,0,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,1,0,1,1,1,0,0,0,1,0,1,1,1,1,1,1,0,1,0,1,1,0,0,0,1,
+          1,1,0,1,1,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,1,1,0,0,1,1,1,0,0,0,1,0,1,0,0,0,0,0,1,1,0,
+          0,1,0,1,1,1,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,1,1,0,1,0,0,0,0,0,1,1,0,1,0 };
+        _Total_fixed_length -= _Adjustment[_Ryu_exponent];
+        // _Whole_digits doesn't need to be adjusted because these cases won't refer to it later.
+      }
+    } else if (_Whole_digits > 0) { // case "17.29"
+      _Total_fixed_length = __olength + 1;
+    } else { // case "0.001729"
+      _Total_fixed_length = static_cast<uint32_t>(2 - _Ryu_exponent);
+    }
+
+    if (_Last - _First < static_cast<ptrdiff_t>(_Total_fixed_length)) {
+      return { _Last, errc::value_too_large };
+    }
+
+    _CharT* _Mid;
+    if (_Ryu_exponent > 0) { // case "172900"
+      bool _Can_use_ryu;
+
+      if (_Ryu_exponent > 22) { // 10^22 is the largest power of 10 that's exactly representable as a double.
+        _Can_use_ryu = false;
+      } else {
+        // Ryu generated X: __v.__mantissa * 10^_Ryu_exponent
+        // __v.__mantissa == 2^_Trailing_zero_bits * (__v.__mantissa >> _Trailing_zero_bits)
+        // 10^_Ryu_exponent == 2^_Ryu_exponent * 5^_Ryu_exponent
+
+        // _Trailing_zero_bits is [0, 56] (aside: because 2^56 is the largest power of 2
+        // with 17 decimal digits, which is double's round-trip limit.)
+        // _Ryu_exponent is [1, 22].
+        // Normalization adds [2, 52] (aside: at least 2 because the pre-normalized mantissa is at least 5).
+        // This adds up to [3, 130], which is well below double's maximum binary exponent 1023.
+
+        // Therefore, we just need to consider (__v.__mantissa >> _Trailing_zero_bits) * 5^_Ryu_exponent.
+
+        // If that product would exceed 53 bits, then X can't be exactly represented as a double.
+        // (That's not a problem for round-tripping, because X is close enough to the original double,
+        // but X isn't mathematically equal to the original double.) This requires a high-precision fallback.
+
+        // If the product is 53 bits or smaller, then X can be exactly represented as a double (and we don't
+        // need to re-synthesize it; the original double must have been X, because Ryu wouldn't produce the
+        // same output for two different doubles X and Y). This allows Ryu's output to be used (zero-filled).
+
+        // (2^53 - 1) / 5^0 (for indexing), (2^53 - 1) / 5^1, ..., (2^53 - 1) / 5^22
+        static constexpr uint64_t _Max_shifted_mantissa[23] = {
+          9007199254740991u, 1801439850948198u, 360287970189639u, 72057594037927u, 14411518807585u,
+          2882303761517u, 576460752303u, 115292150460u, 23058430092u, 4611686018u, 922337203u, 184467440u,
+          36893488u, 7378697u, 1475739u, 295147u, 59029u, 11805u, 2361u, 472u, 94u, 18u, 3u };
+
+        unsigned long _Trailing_zero_bits;
+#ifdef _WIN64
+        (void) _BitScanForward64(&_Trailing_zero_bits, __v.__mantissa); // __v.__mantissa is guaranteed nonzero
+#else // ^^^ 64-bit / 32-bit vvv
+        const uint32_t _Low_mantissa = static_cast<uint32_t>(__v.__mantissa);
+        if (_Low_mantissa != 0) {
+          (void) _BitScanForward(&_Trailing_zero_bits, _Low_mantissa);
+        } else {
+          const uint32_t _High_mantissa = static_cast<uint32_t>(__v.__mantissa >> 32); // nonzero here
+          (void) _BitScanForward(&_Trailing_zero_bits, _High_mantissa);
+          _Trailing_zero_bits += 32;
+        }
+#endif // ^^^ 32-bit ^^^
+        const uint64_t _Shifted_mantissa = __v.__mantissa >> _Trailing_zero_bits;
+        _Can_use_ryu = _Shifted_mantissa <= _Max_shifted_mantissa[_Ryu_exponent];
+      }
+
+      if (!_Can_use_ryu) {
+        // Print the integer exactly.
+        // Performance note: This will redundantly perform bounds checking.
+        // Performance note: This will redundantly decompose the IEEE representation.
+        return __d2fixed_buffered_n(_First, _Last, __f, 0);
+      }
+
+      // _Can_use_ryu
+      // Print the decimal digits, left-aligned within [_First, _First + _Total_fixed_length).
+      _Mid = _First + __olength;
+    } else { // cases "1729", "17.29", and "0.001729"
+      // Print the decimal digits, right-aligned within [_First, _First + _Total_fixed_length).
+      _Mid = _First + _Total_fixed_length;
+    }
+
+    // We prefer 32-bit operations, even on 64-bit platforms.
+    // We have at most 17 digits, and uint32_t can store 9 digits.
+    // If _Output doesn't fit into uint32_t, we cut off 8 digits,
+    // so the rest will fit into uint32_t.
+    if ((_Output >> 32) != 0) {
+      // Expensive 64-bit division.
+      const uint64_t __q = __div1e8(_Output);
+      uint32_t __output2 = static_cast<uint32_t>(_Output - 100000000 * __q);
+      _Output = __q;
+
+      const uint32_t __c = __output2 % 10000;
+      __output2 /= 10000;
+      const uint32_t __d = __output2 % 10000;
+      const uint32_t __c0 = (__c % 100) << 1;
+      const uint32_t __c1 = (__c / 100) << 1;
+      const uint32_t __d0 = (__d % 100) << 1;
+      const uint32_t __d1 = (__d / 100) << 1;
+
+      _CSTD memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c0, 2 * sizeof(_CharT));
+      _CSTD memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c1, 2 * sizeof(_CharT));
+      _CSTD memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __d0, 2 * sizeof(_CharT));
+      _CSTD memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __d1, 2 * sizeof(_CharT));
+    }
+    uint32_t __output2 = static_cast<uint32_t>(_Output);
+    while (__output2 >= 10000) {
+#ifdef __clang__ // TRANSITION, LLVM-38217
+      const uint32_t __c = __output2 - 10000 * (__output2 / 10000);
+#else
+      const uint32_t __c = __output2 % 10000;
+#endif
+      __output2 /= 10000;
+      const uint32_t __c0 = (__c % 100) << 1;
+      const uint32_t __c1 = (__c / 100) << 1;
+      _CSTD memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c0, 2 * sizeof(_CharT));
+      _CSTD memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c1, 2 * sizeof(_CharT));
+    }
+    if (__output2 >= 100) {
+      const uint32_t __c = (__output2 % 100) << 1;
+      __output2 /= 100;
+      _CSTD memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
+    }
+    if (__output2 >= 10) {
+      const uint32_t __c = __output2 << 1;
+      _CSTD memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
+    } else {
+      *--_Mid = static_cast<_CharT>(_WIDEN(_CharT, '0') + __output2);
+    }
+
+    if (_Ryu_exponent > 0) { // case "172900" with _Can_use_ryu
+      // Performance note: it might be more efficient to do this immediately after setting _Mid.
+      _STD fill_n(_First + __olength, _Ryu_exponent, _WIDEN(_CharT, '0'));
+    } else if (_Ryu_exponent == 0) { // case "1729"
+      // Done!
+    } else if (_Whole_digits > 0) { // case "17.29"
+      // Performance note: moving digits might not be optimal.
+      _CSTD memmove(_First, _First + 1, static_cast<size_t>(_Whole_digits) * sizeof(_CharT));
+      _First[_Whole_digits] = _WIDEN(_CharT, '.');
+    } else { // case "0.001729"
+      // Performance note: a larger memset() followed by overwriting '.' might be more efficient.
+      _First[0] = _WIDEN(_CharT, '0');
+      _First[1] = _WIDEN(_CharT, '.');
+      _STD fill_n(_First + 2, -_Whole_digits, _WIDEN(_CharT, '0'));
+    }
+
+    return { _First + _Total_fixed_length, errc{} };
+  }
+
+  const uint32_t _Total_scientific_length = __olength + (__olength > 1) // digits + possible decimal point
+    + (-100 < _Scientific_exponent && _Scientific_exponent < 100 ? 4 : 5); // + scientific exponent
+  if (_Last - _First < static_cast<ptrdiff_t>(_Total_scientific_length)) {
+    return { _Last, errc::value_too_large };
+  }
+  _CharT* const __result = _First;
+
+  // Print the decimal digits.
+  uint32_t __i = 0;
+  // We prefer 32-bit operations, even on 64-bit platforms.
+  // We have at most 17 digits, and uint32_t can store 9 digits.
+  // If _Output doesn't fit into uint32_t, we cut off 8 digits,
+  // so the rest will fit into uint32_t.
+  if ((_Output >> 32) != 0) {
+    // Expensive 64-bit division.
+    const uint64_t __q = __div1e8(_Output);
+    uint32_t __output2 = static_cast<uint32_t>(_Output) - 100000000 * static_cast<uint32_t>(__q);
+    _Output = __q;
+
+    const uint32_t __c = __output2 % 10000;
+    __output2 /= 10000;
+    const uint32_t __d = __output2 % 10000;
+    const uint32_t __c0 = (__c % 100) << 1;
+    const uint32_t __c1 = (__c / 100) << 1;
+    const uint32_t __d0 = (__d % 100) << 1;
+    const uint32_t __d1 = (__d / 100) << 1;
+    _CSTD memcpy(__result + __olength - __i - 1, __DIGIT_TABLE<_CharT> + __c0, 2 * sizeof(_CharT));
+    _CSTD memcpy(__result + __olength - __i - 3, __DIGIT_TABLE<_CharT> + __c1, 2 * sizeof(_CharT));
+    _CSTD memcpy(__result + __olength - __i - 5, __DIGIT_TABLE<_CharT> + __d0, 2 * sizeof(_CharT));
+    _CSTD memcpy(__result + __olength - __i - 7, __DIGIT_TABLE<_CharT> + __d1, 2 * sizeof(_CharT));
+    __i += 8;
+  }
+  uint32_t __output2 = static_cast<uint32_t>(_Output);
+  while (__output2 >= 10000) {
+#ifdef __clang__ // TRANSITION, LLVM-38217
+    const uint32_t __c = __output2 - 10000 * (__output2 / 10000);
+#else
+    const uint32_t __c = __output2 % 10000;
+#endif
+    __output2 /= 10000;
+    const uint32_t __c0 = (__c % 100) << 1;
+    const uint32_t __c1 = (__c / 100) << 1;
+    _CSTD memcpy(__result + __olength - __i - 1, __DIGIT_TABLE<_CharT> + __c0, 2 * sizeof(_CharT));
+    _CSTD memcpy(__result + __olength - __i - 3, __DIGIT_TABLE<_CharT> + __c1, 2 * sizeof(_CharT));
+    __i += 4;
+  }
+  if (__output2 >= 100) {
+    const uint32_t __c = (__output2 % 100) << 1;
+    __output2 /= 100;
+    _CSTD memcpy(__result + __olength - __i - 1, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
+    __i += 2;
+  }
+  if (__output2 >= 10) {
+    const uint32_t __c = __output2 << 1;
+    // We can't use memcpy here: the decimal dot goes between these two digits.
+    __result[2] = __DIGIT_TABLE<_CharT>[__c + 1];
+    __result[0] = __DIGIT_TABLE<_CharT>[__c];
+  } else {
+    __result[0] = static_cast<_CharT>(_WIDEN(_CharT, '0') + __output2);
+  }
+
+  // Print decimal point if needed.
+  uint32_t __index;
+  if (__olength > 1) {
+    __result[1] = _WIDEN(_CharT, '.');
+    __index = __olength + 1;
+  } else {
+    __index = 1;
+  }
+
+  // Print the exponent.
+  __result[__index++] = _WIDEN(_CharT, 'e');
+  if (_Scientific_exponent < 0) {
+    __result[__index++] = _WIDEN(_CharT, '-');
+    _Scientific_exponent = -_Scientific_exponent;
+  } else {
+    __result[__index++] = _WIDEN(_CharT, '+');
+  }
+
+  if (_Scientific_exponent >= 100) {
+    const int32_t __c = _Scientific_exponent % 10;
+    _CSTD memcpy(__result + __index, __DIGIT_TABLE<_CharT> + 2 * (_Scientific_exponent / 10), 2 * sizeof(_CharT));
+    __result[__index + 2] = static_cast<_CharT>(_WIDEN(_CharT, '0') + __c);
+    __index += 3;
+  } else {
+    _CSTD memcpy(__result + __index, __DIGIT_TABLE<_CharT> + 2 * _Scientific_exponent, 2 * sizeof(_CharT));
+    __index += 2;
+  }
+
+  return { _First + _Total_scientific_length, errc{} };
+}
+
+_NODISCARD inline bool __d2d_small_int(const uint64_t __ieeeMantissa, const uint32_t __ieeeExponent,
+  __floating_decimal_64* const __v) {
+  const uint64_t __m2 = (1ull << __DOUBLE_MANTISSA_BITS) | __ieeeMantissa;
+  const int32_t __e2 = static_cast<int32_t>(__ieeeExponent) - __DOUBLE_BIAS - __DOUBLE_MANTISSA_BITS;
+
+  if (__e2 > 0) {
+    // f = __m2 * 2^__e2 >= 2^53 is an integer.
+    // Ignore this case for now.
+    return false;
+  }
+
+  if (__e2 < -52) {
+    // f < 1.
+    return false;
+  }
+
+  // Since 2^52 <= __m2 < 2^53 and 0 <= -__e2 <= 52: 1 <= f = __m2 / 2^-__e2 < 2^53.
+  // Test if the lower -__e2 bits of the significand are 0, i.e. whether the fraction is 0.
+  const uint64_t __mask = (1ull << -__e2) - 1;
+  const uint64_t __fraction = __m2 & __mask;
+  if (__fraction != 0) {
+    return false;
+  }
+
+  // f is an integer in the range [1, 2^53).
+  // Note: __mantissa might contain trailing (decimal) 0's.
+  // Note: since 2^53 < 10^16, there is no need to adjust __decimalLength17().
+  __v->__mantissa = __m2 >> -__e2;
+  __v->__exponent = 0;
+  return true;
+}
+
+template <class _CharT>
+_NODISCARD pair<_CharT*, errc> __d2s_buffered_n(_CharT* const _First, _CharT* const _Last, const double __f,
+  const chars_format _Fmt) {
+
+  // Step 1: Decode the floating-point number, and unify normalized and subnormal cases.
+  const uint64_t __bits = __double_to_bits(__f);
+
+  // Case distinction; exit early for the easy cases.
+  if (__bits == 0) {
+    if (_Fmt == chars_format::scientific) {
+      if (_Last - _First < 5) {
+        return { _Last, errc::value_too_large };
+      }
+
+      if constexpr (is_same_v<_CharT, char>) {
+        _CSTD memcpy(_First, "0e+00", 5);
+      } else {
+        _CSTD memcpy(_First, L"0e+00", 5 * sizeof(wchar_t));
+      }
+
+      return { _First + 5, errc{} };
+    }
+
+    // Print "0" for chars_format::fixed, chars_format::general, and chars_format{}.
+    if (_First == _Last) {
+      return { _Last, errc::value_too_large };
+    }
+
+    *_First = _WIDEN(_CharT, '0');
+
+    return { _First + 1, errc{} };
+  }
+
+  // Decode __bits into mantissa and exponent.
+  const uint64_t __ieeeMantissa = __bits & ((1ull << __DOUBLE_MANTISSA_BITS) - 1);
+  const uint32_t __ieeeExponent = static_cast<uint32_t>(__bits >> __DOUBLE_MANTISSA_BITS);
+
+  if (_Fmt == chars_format::fixed) {
+    // const uint64_t _Mantissa2 = __ieeeMantissa | (1ull << __DOUBLE_MANTISSA_BITS); // restore implicit bit
+    const int32_t _Exponent2 = static_cast<int32_t>(__ieeeExponent)
+      - __DOUBLE_BIAS - __DOUBLE_MANTISSA_BITS; // bias and normalization
+
+    // Normal values are equal to _Mantissa2 * 2^_Exponent2.
+    // (Subnormals are different, but they'll be rejected by the _Exponent2 test here, so they can be ignored.)
+
+    // For nonzero integers, _Exponent2 >= -52. (The minimum value occurs when _Mantissa2 * 2^_Exponent2 is 1.
+    // In that case, _Mantissa2 is the implicit 1 bit followed by 52 zeros, so _Exponent2 is -52 to shift away
+    // the zeros.) The dense range of exactly representable integers has negative or zero exponents
+    // (as positive exponents make the range non-dense). For that dense range, Ryu will always be used:
+    // every digit is necessary to uniquely identify the value, so Ryu must print them all.
+
+    // Positive exponents are the non-dense range of exactly representable integers. This contains all of the values
+    // for which Ryu can't be used (and a few Ryu-friendly values). We can save time by detecting positive
+    // exponents here and skipping Ryu. Calling __d2fixed_buffered_n() with precision 0 is valid for all integers
+    // (so it's okay if we call it with a Ryu-friendly value).
+    if (_Exponent2 > 0) {
+      return __d2fixed_buffered_n(_First, _Last, __f, 0);
+    }
+  }
+
+  __floating_decimal_64 __v;
+  const bool __isSmallInt = __d2d_small_int(__ieeeMantissa, __ieeeExponent, &__v);
+  if (__isSmallInt) {
+    // For small integers in the range [1, 2^53), __v.__mantissa might contain trailing (decimal) zeros.
+    // For scientific notation we need to move these zeros into the exponent.
+    // (This is not needed for fixed-point notation, so it might be beneficial to trim
+    // trailing zeros in __to_chars only if needed - once fixed-point notation output is implemented.)
+    for (;;) {
+      const uint64_t __q = __div10(__v.__mantissa);
+      const uint32_t __r = static_cast<uint32_t>(__v.__mantissa) - 10 * static_cast<uint32_t>(__q);
+      if (__r != 0) {
+        break;
+      }
+      __v.__mantissa = __q;
+      ++__v.__exponent;
+    }
+  } else {
+    __v = __d2d(__ieeeMantissa, __ieeeExponent);
+  }
+
+  return __to_chars(_First, _Last, __v, _Fmt, __f);
+}
+
+// ^^^^^^^^^^ DERIVED FROM d2s.c ^^^^^^^^^^
+
+// clang-format on
+
+template <class _Floating>
+_NODISCARD to_chars_result _Floating_to_chars_ryu(
+    char* const _First, char* const _Last, const _Floating _Value, const chars_format _Fmt) noexcept {
+    if constexpr (is_same_v<_Floating, float>) {
+        return _Convert_to_chars_result(__f2s_buffered_n(_First, _Last, _Value, _Fmt));
+    } else {
+        return _Convert_to_chars_result(__d2s_buffered_n(_First, _Last, _Value, _Fmt));
+    }
+}
+
+template <class _Floating>
+_NODISCARD to_chars_result _Floating_to_chars_scientific_precision(
+    char* const _First, char* const _Last, const _Floating _Value, int _Precision) noexcept {
+
+    // C11 7.21.6.1 "The fprintf function"/5:
+    // "A negative precision argument is taken as if the precision were omitted."
+    // /8: "e,E [...] if the precision is missing, it is taken as 6"
+
+    if (_Precision < 0) {
+        _Precision = 6;
+    } else if (_Precision < 1'000'000'000) {
+        // _Precision is ok.
+    } else {
+        // Avoid integer overflow.
+        // (This defensive check is slightly nonconformant; it can be carefully improved in the future.)
+        return {_Last, errc::value_too_large};
+    }
+
+    return __d2exp_buffered_n(_First, _Last, _Value, static_cast<uint32_t>(_Precision));
+}
+
+template <class _Floating>
+_NODISCARD to_chars_result _Floating_to_chars_fixed_precision(
+    char* const _First, char* const _Last, const _Floating _Value, int _Precision) noexcept {
+
+    // C11 7.21.6.1 "The fprintf function"/5:
+    // "A negative precision argument is taken as if the precision were omitted."
+    // /8: "f,F [...] If the precision is missing, it is taken as 6"
+
+    if (_Precision < 0) {
+        _Precision = 6;
+    } else if (_Precision < 1'000'000'000) {
+        // _Precision is ok.
+    } else {
+        // Avoid integer overflow.
+        // (This defensive check is slightly nonconformant; it can be carefully improved in the future.)
+        return {_Last, errc::value_too_large};
+    }
+
+    return _Convert_to_chars_result(__d2fixed_buffered_n(_First, _Last, _Value, static_cast<uint32_t>(_Precision)));
+}
+
+_STD_END
+
+#undef _HAS_CHARCONV_INTRINSICS
+#undef _WIDEN
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XCHARCONV_RYU_H
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xcharconv_ryu_tables.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xcharconv_ryu_tables.h
new file mode 100644
index 0000000000000000000000000000000000000000..a9aa5c3b3a3eb9434455dc3cfa179a96987b4efc
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xcharconv_tables.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xcharconv_tables.h
new file mode 100644
index 0000000000000000000000000000000000000000..0ce4f3dd765a4dcc213c81ba01cd282fb1b2c2b8
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xerrc.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xerrc.h
new file mode 100644
index 0000000000000000000000000000000000000000..7bd9001ff0c70fc78353c5c3cd42a5799094240f
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xfacet b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xfacet
new file mode 100644
index 0000000000000000000000000000000000000000..0e989a8be422ba899ea960b85b7bcba9e115f87a
--- /dev/null
+++ b/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_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xfilesystem_abi.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xfilesystem_abi.h
new file mode 100644
index 0000000000000000000000000000000000000000..f11c87024c0b5a39a83e5095c6ef216cc7532c14
--- /dev/null
+++ b/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
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xhash b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xhash
new file mode 100644
index 0000000000000000000000000000000000000000..dfa0cf3f2b8a45679a6632fe2178591f8ce1bf10
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xhash
@@ -0,0 +1,2016 @@
+// xhash internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XHASH_
+#define _XHASH_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <cmath>
+#include <list>
+#include <tuple>
+#include <vector>
+#include <xbit_ops.h>
+
+#ifdef _SILENCE_STDEXT_HASH_DEPRECATION_WARNINGS
+#include <cstring>
+#include <cwchar>
+#include <xstring>
+#endif // _SILENCE_STDEXT_HASH_DEPRECATION_WARNINGS
+
+#if _HAS_CXX17
+#include <xnode_handle.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
+
+#ifdef _SILENCE_STDEXT_HASH_DEPRECATION_WARNINGS
+_STDEXT_BEGIN
+template <class _Kty>
+_NODISCARD size_t hash_value(const _Kty& _Keyval) noexcept {
+    if constexpr (_STD is_pointer_v<_Kty> || _STD is_null_pointer_v<_Kty>) {
+        return reinterpret_cast<size_t>(_Keyval) ^ 0xdeadbeefu;
+    } else {
+        return static_cast<size_t>(_Keyval) ^ 0xdeadbeefu;
+    }
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD size_t hash_value(const _STD basic_string<_Elem, _Traits, _Alloc>& _Str) noexcept {
+    return _STD _Hash_array_representation(_Str.c_str(), _Str.size());
+}
+
+_NODISCARD inline size_t hash_value(_In_z_ const char* _Str) noexcept {
+    return _STD _Hash_array_representation(_Str, _CSTD strlen(_Str));
+}
+
+_NODISCARD inline size_t hash_value(_In_z_ const wchar_t* _Str) noexcept {
+    return _STD _Hash_array_representation(_Str, _CSTD wcslen(_Str));
+}
+
+template <class _Kty, class _Pr = _STD less<_Kty>>
+class hash_compare { // traits class for hash containers
+public:
+    enum { // parameters for hash table
+        bucket_size = 1 // 0 < bucket_size
+    };
+
+    hash_compare() = default;
+    hash_compare(const _Pr& _Pred) noexcept(_STD is_nothrow_copy_constructible_v<_Pr>) : comp(_Pred) {}
+
+    _NODISCARD size_t operator()(const _Kty& _Keyval) const noexcept(noexcept(hash_value(_Keyval))) {
+        long _Quot   = static_cast<long>(hash_value(_Keyval) & LONG_MAX); // TRANSITION, ADL?
+        ldiv_t _Qrem = _CSTD ldiv(_Quot, 127773);
+
+        _Qrem.rem = 16807 * _Qrem.rem - 2836 * _Qrem.quot;
+        if (_Qrem.rem < 0) {
+            _Qrem.rem += LONG_MAX;
+        }
+
+        return static_cast<size_t>(_Qrem.rem);
+    }
+
+    _NODISCARD bool operator()(const _Kty& _Keyval1, const _Kty& _Keyval2) const
+        noexcept(noexcept(comp(_Keyval1, _Keyval2))) {
+        // test if _Keyval1 ordered before _Keyval2
+        return comp(_Keyval1, _Keyval2);
+    }
+
+    _Pr comp{}; // the comparator object
+};
+_STDEXT_END
+
+_STD_BEGIN
+using stdext::hash_compare; // Non-Standard, for legacy source compatibility
+_STD_END
+
+#endif // _SILENCE_STDEXT_HASH_DEPRECATION_WARNINGS
+
+_STD_BEGIN
+template <class _Kty, class _Hasher, class _Keyeq>
+struct _Uhash_choose_transparency {
+    // transparency selector for non-transparent hashed containers
+    template <class>
+    using _Deduce_key = const _Kty&;
+
+#if _HAS_CXX20 && defined(__EDG__) // TRANSITION, DevCom-10678753
+    template <class, class>
+    static constexpr bool _Supports_transparency = false;
+#endif // ^^^ workaround ^^^
+};
+
+#if _HAS_CXX20
+template <class _Kty, class _Hasher, class _Keyeq>
+    requires _Is_transparent_v<_Hasher> && _Is_transparent_v<_Keyeq>
+struct _Uhash_choose_transparency<_Kty, _Hasher, _Keyeq> {
+    // transparency selector for transparent hashed containers
+    template <class _Keyty>
+    using _Deduce_key = const _Keyty&;
+
+    template <class _Container, class _Kx>
+    static constexpr bool _Supports_transparency =
+        !disjunction_v<is_convertible<_Kx, typename _Container::const_iterator>,
+            is_convertible<_Kx, typename _Container::iterator>>;
+};
+#endif // _HAS_CXX20
+
+template <class _Hasher, class _Kty>
+constexpr bool _Nothrow_hash =
+    noexcept(static_cast<size_t>(_STD declval<const _Hasher&>()(_STD declval<const _Kty&>())));
+
+template <class _Kty, class _Hasher, class _Keyeq>
+class _Uhash_compare
+    : public _Uhash_choose_transparency<_Kty, _Hasher, _Keyeq> { // traits class for unordered containers
+public:
+    enum { // parameters for hash table
+        bucket_size = 1 // 0 < bucket_size
+    };
+
+    _Uhash_compare() noexcept(
+        conjunction_v<is_nothrow_default_constructible<_Hasher>, is_nothrow_default_constructible<_Keyeq>>)
+        : _Mypair(_Zero_then_variadic_args_t{}, _Zero_then_variadic_args_t{}, 0.0f) {}
+
+    explicit _Uhash_compare(const _Hasher& _Hasharg) noexcept(
+        conjunction_v<is_nothrow_copy_constructible<_Hasher>, is_nothrow_default_constructible<_Keyeq>>)
+        : _Mypair(_One_then_variadic_args_t{}, _Hasharg, _Zero_then_variadic_args_t{}, 0.0f) {}
+
+    explicit _Uhash_compare(const _Hasher& _Hasharg, const _Keyeq& _Keyeqarg) noexcept(
+        conjunction_v<is_nothrow_copy_constructible<_Hasher>, is_nothrow_copy_constructible<_Keyeq>>)
+        : _Mypair(_One_then_variadic_args_t{}, _Hasharg, _One_then_variadic_args_t{}, _Keyeqarg, 0.0f) {}
+
+    template <class _Keyty>
+    _NODISCARD size_t operator()(const _Keyty& _Keyval) const noexcept(_Nothrow_hash<_Hasher, _Keyty>) {
+        // hash _Keyval to size_t value
+        return static_cast<size_t>(_Mypair._Get_first()(_Keyval));
+    }
+
+    template <class _Keyty1, class _Keyty2>
+    _NODISCARD bool operator()(const _Keyty1& _Keyval1, const _Keyty2& _Keyval2) const
+        noexcept(_Nothrow_compare<_Keyeq, _Keyty1, _Keyty2>) {
+        // test if _Keyval1 NOT equal to _Keyval2
+        return !static_cast<bool>(_Mypair._Myval2._Get_first()(_Keyval1, _Keyval2));
+    }
+
+    _NODISCARD float& _Get_max_bucket_size() noexcept {
+        return _Mypair._Myval2._Myval2;
+    }
+
+    _NODISCARD const float& _Get_max_bucket_size() const noexcept {
+        return _Mypair._Myval2._Myval2;
+    }
+
+    void swap(_Uhash_compare& _Rhs) noexcept(
+        conjunction_v<_Is_nothrow_swappable<_Hasher>, _Is_nothrow_swappable<_Keyeq>>) {
+        using _STD swap;
+        swap(_Mypair._Get_first(), _Rhs._Mypair._Get_first()); // intentional ADL
+        auto& _Lsecond = _Mypair._Myval2;
+        auto& _Rsecond = _Rhs._Mypair._Myval2;
+        swap(_Lsecond._Get_first(), _Rsecond._Get_first()); // intentional ADL
+        _STD swap(_Lsecond._Myval2, _Rsecond._Myval2);
+    }
+
+    _Compressed_pair<_Hasher, _Compressed_pair<_Keyeq, float>> _Mypair;
+};
+
+template <class _Iter, class _Val>
+struct _Reinterpret_move_iter {
+    _Iter _Base;
+
+    using iterator_category = input_iterator_tag;
+    using value_type        = typename iterator_traits<_Iter>::value_type;
+    using difference_type   = typename iterator_traits<_Iter>::difference_type;
+    using reference         = _Val&&;
+    // pointer intentionally omitted
+
+    reference operator*() const {
+        return static_cast<reference>(reinterpret_cast<_Val&>(*_Base));
+    }
+
+    _Reinterpret_move_iter& operator++() {
+        ++_Base;
+        return *this;
+    }
+
+    // post ++ intentionally omitted
+
+    _NODISCARD friend bool operator==(const _Reinterpret_move_iter& _Lhs, const _Reinterpret_move_iter& _Rhs) {
+        return _Lhs._Base == _Rhs._Base;
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(const _Reinterpret_move_iter& _Lhs, const _Reinterpret_move_iter& _Rhs) {
+        return _Lhs._Base != _Rhs._Base;
+    }
+#endif // !_HAS_CXX20
+};
+
+template <class _Alnode>
+struct _List_head_construct_ptr {
+    using value_type = typename _Alnode::value_type;
+    static_assert(_Is_specialization_v<value_type, _List_node>, "_List_head_construct_ptr allocator not rebound");
+    using _Alnode_traits = allocator_traits<_Alnode>;
+    using pointer        = typename _Alnode_traits::pointer;
+    _Alnode& _Al;
+    pointer _Newhead;
+
+    explicit _List_head_construct_ptr(_Alnode& _Al_) : _Al(_Al_), _Newhead(value_type::_Buyheadnode(_Al)) {}
+
+    template <class _Val_types>
+    _List_head_construct_ptr(_Alnode& _Al_, _List_val<_Val_types>& _Mycont)
+        : _Al(_Al_), _Newhead(value_type::_Buyheadnode(_Al)) {
+        _Mycont._Myhead = _Newhead;
+    }
+
+    _List_head_construct_ptr(const _List_head_construct_ptr&)            = delete;
+    _List_head_construct_ptr& operator=(const _List_head_construct_ptr&) = delete;
+
+    _NODISCARD pointer _Release() noexcept {
+        return _STD exchange(_Newhead, nullptr);
+    }
+
+    ~_List_head_construct_ptr() {
+        if (_Newhead) {
+            value_type::_Freenode0(_Al, _Newhead);
+        }
+    }
+};
+
+template <class _Nodeptr>
+struct _Hash_find_last_result {
+    _Nodeptr _Insert_before;
+    _Nodeptr _Duplicate;
+};
+
+template <class _Aliter>
+struct _Hash_vec {
+    // TRANSITION, ABI: "vector" for ABI compatibility that doesn't call allocator::construct
+    using _Aliter_traits    = allocator_traits<_Aliter>;
+    using value_type        = typename _Aliter::value_type;
+    using size_type         = typename _Aliter_traits::size_type;
+    using difference_type   = typename _Aliter_traits::difference_type;
+    using pointer           = typename _Aliter_traits::pointer;
+    using _Aliter_scary_val = _Vector_val<conditional_t<_Is_simple_alloc_v<_Aliter>, _Simple_types<value_type>,
+        _Vec_iter_types<value_type, size_type, difference_type, pointer, typename _Aliter_traits::const_pointer>>>;
+
+    _Hash_vec() : _Mypair(_Zero_then_variadic_args_t{}) {
+        _Mypair._Myval2._Alloc_proxy(_GET_PROXY_ALLOCATOR(_Aliter, _Mypair._Get_first()));
+    }
+
+    template <class _Any_alloc, enable_if_t<!is_same_v<_Remove_cvref_t<_Any_alloc>, _Hash_vec>, int> = 0>
+    explicit _Hash_vec(_Any_alloc&& _Al) noexcept
+        : _Mypair(_One_then_variadic_args_t{}, _STD forward<_Any_alloc>(_Al)) { // construct empty vector, allocator
+        _Mypair._Myval2._Alloc_proxy(_GET_PROXY_ALLOCATOR(_Aliter, _Mypair._Get_first()));
+    }
+
+    _Hash_vec(const _Hash_vec&)            = delete;
+    _Hash_vec& operator=(const _Hash_vec&) = delete;
+
+    _NODISCARD size_type size() const noexcept {
+        return static_cast<size_type>(_Mypair._Myval2._Mylast - _Mypair._Myval2._Myfirst);
+    }
+
+    _NODISCARD size_type max_size() const noexcept {
+        return (_STD min)(
+            static_cast<size_type>(_STD _Max_limit<difference_type>()), _Aliter_traits::max_size(_Mypair._Get_first()));
+    }
+
+    _NODISCARD size_type capacity() const noexcept {
+        // This implementation never has capacity() differ from size(), but the previous implementation could.
+        // We need to handle that situation gracefully since we may link to old code (See GH-2774).
+        return static_cast<size_type>(_Mypair._Myval2._Myend - _Mypair._Myval2._Myfirst);
+    }
+
+    void _Assign_grow(const size_type _Cells, const value_type _Val) {
+        // set the elements stored here to _Cells copies of _Val, leaving the value unchanged if an exception is thrown
+        const auto _Oldsize = size();
+        _STL_INTERNAL_CHECK(_Oldsize <= _Cells);
+        auto& _Alvec = _Mypair._Get_first();
+        if (_Oldsize < _Cells) {
+            const auto _Newvec = _Alvec.allocate(_Cells); // throws
+            // nothrow hereafter
+            const auto _Oldcapacity = capacity();
+            if (_Oldcapacity != 0) {
+                _Destroy_range(_Mypair._Myval2._Myfirst, _Mypair._Myval2._Mylast);
+                _Alvec.deallocate(_Mypair._Myval2._Myfirst, _Oldcapacity);
+            }
+
+            _Mypair._Myval2._Myfirst = _Newvec;
+            const auto _Newend       = _Newvec + _Cells;
+            _Mypair._Myval2._Mylast  = _Newend;
+            _Mypair._Myval2._Myend   = _Newend;
+            _STD uninitialized_fill(_Newvec, _Newend, _Val);
+        } else {
+            _STD fill(_Mypair._Myval2._Myfirst, _Mypair._Myval2._Mylast, _Val);
+        }
+    }
+
+    void _Tidy() noexcept {
+        if (_Mypair._Myval2._Myfirst != nullptr) {
+            _Destroy_range(_Mypair._Myval2._Myfirst, _Mypair._Myval2._Mylast);
+            _Mypair._Get_first().deallocate(_Mypair._Myval2._Myfirst, capacity());
+            _Mypair._Myval2._Myfirst = nullptr;
+            _Mypair._Myval2._Mylast  = nullptr;
+            _Mypair._Myval2._Myend   = nullptr;
+        }
+    }
+
+    ~_Hash_vec() {
+        _Tidy();
+#if _ITERATOR_DEBUG_LEVEL != 0
+        auto&& _Alproxy = _GET_PROXY_ALLOCATOR(_Aliter, _Mypair._Get_first());
+        _Delete_plain_internal(_Alproxy, _STD exchange(_Mypair._Myval2._Myproxy, nullptr));
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+    _Compressed_pair<_Aliter, _Aliter_scary_val> _Mypair;
+};
+
+template <class _Traits>
+class _Hash { // hash table -- list with vector of iterators for quick access
+protected:
+    using _Mylist             = list<typename _Traits::value_type, typename _Traits::allocator_type>;
+    using _Alnode             = typename _Mylist::_Alnode;
+    using _Alnode_traits      = typename _Mylist::_Alnode_traits;
+    using _Node               = typename _Mylist::_Node;
+    using _Nodeptr            = typename _Mylist::_Nodeptr;
+    using _Mutable_value_type = typename _Traits::_Mutable_value_type;
+
+    using _Key_compare   = typename _Traits::key_compare;
+    using _Value_compare = typename _Traits::value_compare;
+
+public:
+    using key_type = typename _Traits::key_type;
+
+    using value_type      = typename _Mylist::value_type;
+    using allocator_type  = typename _Mylist::allocator_type;
+    using size_type       = typename _Mylist::size_type;
+    using difference_type = typename _Mylist::difference_type;
+    using pointer         = typename _Mylist::pointer;
+    using const_pointer   = typename _Mylist::const_pointer;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+
+    using iterator =
+        conditional_t<is_same_v<key_type, value_type>, typename _Mylist::const_iterator, typename _Mylist::iterator>;
+    using const_iterator = typename _Mylist::const_iterator;
+
+    using _Unchecked_iterator       = conditional_t<is_same_v<key_type, value_type>,
+        typename _Mylist::_Unchecked_const_iterator, typename _Mylist::_Unchecked_iterator>;
+    using _Unchecked_const_iterator = typename _Mylist::_Unchecked_const_iterator;
+
+    using _Aliter = _Rebind_alloc_t<_Alnode, _Unchecked_iterator>;
+
+    static constexpr size_type _Bucket_size = _Key_compare::bucket_size;
+    static constexpr size_type _Min_buckets = 8; // must be a positive power of 2
+    static constexpr bool _Multi            = _Traits::_Multi;
+
+    template <class _TraitsT>
+    friend bool _Hash_equal(const _Hash<_TraitsT>& _Left, const _Hash<_TraitsT>& _Right);
+
+protected:
+    _Hash(const _Key_compare& _Parg, const allocator_type& _Al)
+        : _Traitsobj(_Parg), _List(_Al), _Vec(_Al), _Mask(_Min_buckets - 1), _Maxidx(_Min_buckets) {
+        // construct empty hash table
+        _Max_bucket_size() = _Bucket_size;
+        _Vec._Assign_grow(_Min_buckets * 2, _List._Unchecked_end());
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+        _Stl_internal_check_container_invariants();
+#endif // _ENABLE_STL_INTERNAL_CHECK
+    }
+
+    template <class _Any_alloc>
+    _Hash(const _Hash& _Right, const _Any_alloc& _Al)
+        : _Traitsobj(_Right._Traitsobj), _List(static_cast<allocator_type>(_Al)), _Vec(_Al), _Mask(_Right._Mask),
+          _Maxidx(_Right._Maxidx) {
+        // construct hash table by copying _Right
+        _Vec._Assign_grow(_Right._Vec.size(), _List._Unchecked_end());
+        _Insert_range_unchecked(_Right._Unchecked_begin(), _Right._Unchecked_end());
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+        _Stl_internal_check_container_invariants();
+        _Right._Stl_internal_check_container_invariants();
+#endif // _ENABLE_STL_INTERNAL_CHECK
+    }
+
+    _Hash(_Hash&& _Right)
+        : _Traitsobj(_Right._Traitsobj), _List(_Move_allocator_tag{}, _Right._List._Getal()),
+          _Vec(_STD move(_Right._Vec._Mypair._Get_first())) {
+        _Vec._Assign_grow(_Min_buckets * 2, _Unchecked_end());
+        _List._Swap_val(_Right._List);
+        _Vec._Mypair._Myval2._Swap_val(_Right._Vec._Mypair._Myval2);
+        _Mask   = _STD exchange(_Right._Mask, _Min_buckets - 1);
+        _Maxidx = _STD exchange(_Right._Maxidx, _Min_buckets);
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+        _Stl_internal_check_container_invariants();
+        _Right._Stl_internal_check_container_invariants();
+#endif // _ENABLE_STL_INTERNAL_CHECK
+    }
+
+private:
+    void _Move_construct_equal_alloc(_Hash& _Right) {
+        _Vec._Assign_grow(_Min_buckets * 2, _Unchecked_end());
+        _List._Swap_val(_Right._List);
+        _Vec._Mypair._Myval2._Swap_val(_Right._Vec._Mypair._Myval2);
+        _Mask   = _STD exchange(_Right._Mask, _Min_buckets - 1);
+        _Maxidx = _STD exchange(_Right._Maxidx, _Min_buckets);
+    }
+
+public:
+    _Hash(_Hash&& _Right, const allocator_type& _Al) : _Traitsobj(_Right._Traitsobj), _List(_Al), _Vec(_Al) {
+        // construct hash table by moving _Right, allocator
+        if constexpr (_Alnode_traits::is_always_equal::value) {
+            _Move_construct_equal_alloc(_Right);
+        } else if (_List._Getal() == _Right._List._Getal()) {
+            _Move_construct_equal_alloc(_Right);
+        } else {
+            _Maxidx            = _Min_buckets;
+            const auto _Myhead = _List._Mypair._Myval2._Myhead;
+            for (auto& _Val : _Right._List) {
+                _List._Emplace(_Myhead, reinterpret_cast<_Mutable_value_type&&>(_Val));
+            }
+            _Reinsert_with_invalid_vec();
+            _Right.clear();
+        }
+
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+        _Stl_internal_check_container_invariants();
+        _Right._Stl_internal_check_container_invariants();
+#endif // _ENABLE_STL_INTERNAL_CHECK
+    }
+
+private:
+    void _Swap_val(_Hash& _Right) noexcept { // swap contents with equal allocator _Hash _Right
+        _List._Swap_val(_Right._List);
+        _Vec._Mypair._Myval2._Swap_val(_Right._Vec._Mypair._Myval2);
+        _STD swap(_Mask, _Right._Mask);
+        _STD swap(_Maxidx, _Right._Maxidx);
+    }
+
+    struct _Min_buckets_construct_ptr {
+        using pointer = typename allocator_traits<_Aliter>::pointer;
+        _Aliter& _Al;
+        pointer _Base;
+        _Min_buckets_construct_ptr(_Aliter& _Al_) : _Al(_Al_), _Base(_Al.allocate(_Min_buckets * 2)) {}
+        _Min_buckets_construct_ptr(const _Min_buckets_construct_ptr&) = delete;
+        _NODISCARD pointer _Release(_Unchecked_iterator _Newend) noexcept {
+            _STD uninitialized_fill(_Base, _Base + _Min_buckets * 2, _Newend);
+            return _STD exchange(_Base, nullptr);
+        }
+        ~_Min_buckets_construct_ptr() {
+            if (_Base) {
+                _Al.deallocate(_Base, _Min_buckets * 2);
+            }
+        }
+    };
+
+    void _Pocma_both(_Hash& _Right) {
+        _Pocma(_List._Getal(), _Right._List._Getal());
+        _Pocma(_Vec._Mypair._Get_first(), _Right._Vec._Mypair._Get_first());
+    }
+
+    struct _NODISCARD _Clear_guard {
+        _Hash* _Target;
+
+        explicit _Clear_guard(_Hash* const _Target_) : _Target(_Target_) {}
+
+        _Clear_guard(const _Clear_guard&)            = delete;
+        _Clear_guard& operator=(const _Clear_guard&) = delete;
+
+        ~_Clear_guard() {
+            if (_Target) {
+                _Target->clear();
+            }
+        }
+    };
+
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+    struct _NODISCARD _Check_container_invariants_guard {
+        const _Hash& _Target;
+
+        explicit _Check_container_invariants_guard(const _Hash& _Target_) : _Target(_Target_) {}
+
+        _Check_container_invariants_guard(const _Check_container_invariants_guard&)            = delete;
+        _Check_container_invariants_guard& operator=(const _Check_container_invariants_guard&) = delete;
+
+        ~_Check_container_invariants_guard() {
+            _Target._Stl_internal_check_container_invariants();
+        }
+    };
+#endif // _ENABLE_STL_INTERNAL_CHECK
+
+public:
+    _Hash& operator=(_Hash&& _Right) { // assign by moving _Right
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+        _Check_container_invariants_guard _Check_self{*this};
+        _Check_container_invariants_guard _Check_right{_Right};
+#endif // _ENABLE_STL_INTERNAL_CHECK
+
+        auto& _Al                 = _Getal();
+        auto& _Right_al           = _Right._Getal();
+        constexpr auto _Pocma_val = _Choose_pocma_v<_Alnode>;
+        if constexpr (_Pocma_val == _Pocma_values::_Propagate_allocators) {
+            if (_Al != _Right_al) {
+                // allocate all the parts necessary to maintain _Hash invariants using _Right's allocator
+                auto&& _Alproxy       = _GET_PROXY_ALLOCATOR(_Alnode, _Al);
+                auto&& _Right_alproxy = _GET_PROXY_ALLOCATOR(_Alnode, _Right_al);
+                _Container_proxy_ptr<_Alnode> _List_proxy(_Right_alproxy, _Leave_proxy_unbound{});
+                _Container_proxy_ptr<_Alnode> _Vec_proxy(_Right_alproxy, _Leave_proxy_unbound{});
+                _List_head_construct_ptr<_Alnode> _Newhead(_Right_al);
+                _Min_buckets_construct_ptr _Buckets(_Right._Vec._Mypair._Get_first());
+
+                // assign the hash/compare ops; we have no control over whether this throws, and if it does we want
+                // to do nothing
+                _Traitsobj = _Right._Traitsobj;
+
+                // nothrow hereafter
+
+                // release any state we are currently owning, and propagate the allocators
+                _List._Tidy();
+                _Vec._Tidy();
+                _Pocma_both(_Right);
+
+                // assign the empty list to _Right._List (except the allocators), and take _Right's _List data
+                auto& _List_data       = _List._Mypair._Myval2;
+                auto& _Right_list_data = _Right._List._Mypair._Myval2;
+                _List_data._Myhead     = _STD exchange(_Right_list_data._Myhead, _Newhead._Release());
+                _List_data._Mysize     = _STD exchange(_Right_list_data._Mysize, size_type{0});
+                _List_proxy._Bind(_Alproxy, _STD addressof(_List_data));
+                _List_data._Swap_proxy_and_iterators(_Right_list_data);
+
+                // assign the _Min_buckets into _Right's _Vec data and take _Right's _Vec data
+                auto& _Vec_data       = _Vec._Mypair._Myval2;
+                auto& _Right_vec_data = _Right._Vec._Mypair._Myval2;
+
+                const auto _Newfirst = _Buckets._Release(_Right._Unchecked_end());
+                const auto _Newlast  = _Newfirst + _Min_buckets * 2;
+
+                _Vec_data._Myfirst = _STD exchange(_Right_vec_data._Myfirst, _Newfirst);
+                _Vec_data._Mylast  = _STD exchange(_Right_vec_data._Mylast, _Newlast);
+                _Vec_data._Myend   = _STD exchange(_Right_vec_data._Myend, _Newlast);
+                _Vec_proxy._Bind(_Alproxy, _STD addressof(_Vec_data));
+                _Vec_data._Swap_proxy_and_iterators(_Right_vec_data);
+
+                // give _Right the default _Mask and _Maxidx values and take its former values
+                _Mask   = _STD exchange(_Right._Mask, _Min_buckets - 1);
+                _Maxidx = _STD exchange(_Right._Maxidx, _Min_buckets);
+
+                return *this;
+            }
+        } else if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
+            if (_Al != _Right_al) {
+                _Clear_guard _Guard{this};
+                _Traitsobj     = _Right._Traitsobj;
+                using _Adapter = _Reinterpret_move_iter<typename _Mylist::_Unchecked_iterator, _Mutable_value_type>;
+                _List.template _Assign_cast<_Mutable_value_type&>(
+                    _Adapter{_Right._List._Unchecked_begin()}, _Adapter{_Right._List._Unchecked_end()});
+                _Reinsert_with_invalid_vec();
+                _Guard._Target = nullptr;
+
+                return *this;
+            }
+        }
+
+        clear();
+        _Traitsobj = _Right._Traitsobj;
+        _Pocma_both(_Right);
+        _Swap_val(_Right);
+
+        return *this;
+    }
+
+    template <class... _Valtys>
+    conditional_t<_Multi, iterator, pair<iterator, bool>> emplace(_Valtys&&... _Vals) {
+        // try to insert value_type(_Vals...)
+        using _In_place_key_extractor = typename _Traits::template _In_place_key_extractor<_Remove_cvref_t<_Valtys>...>;
+        if constexpr (_Multi) {
+            _Check_max_size();
+            _List_node_emplace_op2<_Alnode> _Newnode(_List._Getal(), _STD forward<_Valtys>(_Vals)...);
+            const auto& _Keyval = _Traits::_Kfn(_Newnode._Ptr->_Myval);
+            const auto _Hashval = _Traitsobj(_Keyval);
+            if (_Check_rehash_required_1()) {
+                _Rehash_for_1();
+            }
+
+            const auto _Target = _Find_last(_Keyval, _Hashval);
+            return _List._Make_iter(_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release()));
+        } else if constexpr (_In_place_key_extractor::_Extractable) {
+            const auto& _Keyval = _In_place_key_extractor::_Extract(_Vals...);
+            const auto _Hashval = _Traitsobj(_Keyval);
+            auto _Target        = _Find_last(_Keyval, _Hashval);
+            if (_Target._Duplicate) {
+                return {_List._Make_iter(_Target._Duplicate), false};
+            }
+
+            _Check_max_size();
+            // invalidates _Keyval:
+            _List_node_emplace_op2<_Alnode> _Newnode(_List._Getal(), _STD forward<_Valtys>(_Vals)...);
+            if (_Check_rehash_required_1()) {
+                _Rehash_for_1();
+                _Target = _Find_last(_Traits::_Kfn(_Newnode._Ptr->_Myval), _Hashval);
+            }
+
+            return {
+                _List._Make_iter(_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release())), true};
+        } else {
+            _List_node_emplace_op2<_Alnode> _Newnode(_List._Getal(), _STD forward<_Valtys>(_Vals)...);
+            const auto& _Keyval = _Traits::_Kfn(_Newnode._Ptr->_Myval);
+            const auto _Hashval = _Traitsobj(_Keyval);
+            auto _Target        = _Find_last(_Keyval, _Hashval);
+            if (_Target._Duplicate) {
+                return {_List._Make_iter(_Target._Duplicate), false};
+            }
+
+            _Check_max_size();
+            if (_Check_rehash_required_1()) {
+                _Rehash_for_1();
+                _Target = _Find_last(_Traits::_Kfn(_Newnode._Ptr->_Myval), _Hashval);
+            }
+
+            return {
+                _List._Make_iter(_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release())), true};
+        }
+    }
+
+    template <class... _Valtys>
+    iterator emplace_hint(const_iterator _Hint, _Valtys&&... _Vals) { // try to insert value_type(_Vals...)
+        using _In_place_key_extractor = typename _Traits::template _In_place_key_extractor<_Remove_cvref_t<_Valtys>...>;
+        if constexpr (_Multi) {
+            _Check_max_size();
+            _List_node_emplace_op2<_Alnode> _Newnode(_List._Getal(), _STD forward<_Valtys>(_Vals)...);
+            const auto& _Keyval = _Traits::_Kfn(_Newnode._Ptr->_Myval);
+            const auto _Hashval = _Traitsobj(_Keyval);
+            if (_Check_rehash_required_1()) {
+                _Rehash_for_1();
+            }
+
+            const auto _Target = _Find_hint(_Hint._Ptr, _Keyval, _Hashval);
+            return _List._Make_iter(_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release()));
+        } else if constexpr (_In_place_key_extractor::_Extractable) {
+            const auto& _Keyval = _In_place_key_extractor::_Extract(_Vals...);
+            const auto _Hashval = _Traitsobj(_Keyval);
+            auto _Target        = _Find_hint(_Hint._Ptr, _Keyval, _Hashval);
+            if (_Target._Duplicate) {
+                return _List._Make_iter(_Target._Duplicate);
+            }
+
+            _Check_max_size();
+            // invalidates _Keyval:
+            _List_node_emplace_op2<_Alnode> _Newnode(_List._Getal(), _STD forward<_Valtys>(_Vals)...);
+            if (_Check_rehash_required_1()) {
+                _Rehash_for_1();
+                _Target = _Find_hint(_Hint._Ptr, _Traits::_Kfn(_Newnode._Ptr->_Myval), _Hashval);
+            }
+
+            return _List._Make_iter(_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release()));
+        } else {
+            _List_node_emplace_op2<_Alnode> _Newnode(_List._Getal(), _STD forward<_Valtys>(_Vals)...);
+            const auto& _Keyval = _Traits::_Kfn(_Newnode._Ptr->_Myval);
+            const auto _Hashval = _Traitsobj(_Keyval);
+            auto _Target        = _Find_hint(_Hint._Ptr, _Keyval, _Hashval);
+            if (_Target._Duplicate) {
+                return _List._Make_iter(_Target._Duplicate);
+            }
+
+            _Check_max_size();
+            if (_Check_rehash_required_1()) {
+                _Rehash_for_1();
+                _Target = _Find_hint(_Hint._Ptr, _Traits::_Kfn(_Newnode._Ptr->_Myval), _Hashval);
+            }
+
+            return _List._Make_iter(_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release()));
+        }
+    }
+
+protected:
+    template <class _Keyty, class... _Mappedty>
+    pair<_Nodeptr, bool> _Try_emplace(_Keyty&& _Keyval_arg, _Mappedty&&... _Mapval) {
+        const auto& _Keyval = _Keyval_arg;
+        const auto _Hashval = _Traitsobj(_Keyval);
+        auto _Target        = _Find_last(_Keyval, _Hashval);
+        if (_Target._Duplicate) {
+            return {_Target._Duplicate, false};
+        }
+
+        _Check_max_size();
+        _List_node_emplace_op2<_Alnode> _Newnode(_List._Getal(), piecewise_construct,
+            _STD forward_as_tuple(_STD forward<_Keyty>(_Keyval_arg)),
+            _STD forward_as_tuple(_STD forward<_Mappedty>(_Mapval)...));
+        if (_Check_rehash_required_1()) {
+            _Rehash_for_1();
+            _Target = _Find_last(_Traits::_Kfn(_Newnode._Ptr->_Myval), _Hashval);
+        }
+
+        return {_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release()), true};
+    }
+
+    template <class _Keyty, class... _Mappedty>
+    _Nodeptr _Try_emplace_hint(const _Nodeptr _Hint, _Keyty&& _Keyval_arg, _Mappedty&&... _Mapval) {
+        const auto& _Keyval = _Keyval_arg;
+        const auto _Hashval = _Traitsobj(_Keyval);
+        auto _Target        = _Find_hint(_Hint, _Keyval, _Hashval);
+        if (_Target._Duplicate) {
+            return _Target._Duplicate;
+        }
+
+        _Check_max_size();
+        // might invalidate _Keyval:
+        _List_node_emplace_op2<_Alnode> _Newnode(_List._Getal(), piecewise_construct,
+            _STD forward_as_tuple(_STD forward<_Keyty>(_Keyval_arg)),
+            _STD forward_as_tuple(_STD forward<_Mappedty>(_Mapval)...));
+        if (_Check_rehash_required_1()) {
+            _Rehash_for_1();
+            _Target = _Find_hint(_Hint, _Traits::_Kfn(_Newnode._Ptr->_Myval), _Hashval);
+        }
+
+        return _Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release());
+    }
+
+private:
+    void _Pocca_both(const _Hash& _Right) {
+        _Pocca(_List._Getal(), _Right._List._Getal());
+        _Pocca(_Vec._Mypair._Get_first(), _Right._Vec._Mypair._Get_first());
+    }
+
+public:
+    _Hash& operator=(const _Hash& _Right) {
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+        _Check_container_invariants_guard _Check_self{*this};
+        _Check_container_invariants_guard _Check_right{_Right};
+#endif // _ENABLE_STL_INTERNAL_CHECK
+
+        if constexpr (_Choose_pocca_v<_Alnode>) {
+            auto& _Al             = _Getal();
+            const auto& _Right_al = _Right._Getal();
+            if (_Al != _Right_al) {
+                auto&& _Alproxy       = _GET_PROXY_ALLOCATOR(_Alnode, _Al);
+                auto&& _Right_alproxy = _GET_PROXY_ALLOCATOR(_Alnode, _Right_al);
+                _Container_proxy_ptr<_Alnode> _Vec_proxy(_Right_alproxy, _Leave_proxy_unbound{});
+                _List._Reload_sentinel_and_proxy(_Right._List);
+                _Vec._Tidy();
+                _Pocca_both(_Right);
+                _Vec_proxy._Bind(_Alproxy, _STD addressof(_Vec._Mypair._Myval2));
+
+                _Clear_guard _Guard{this};
+                _Traitsobj = _Right._Traitsobj;
+                _List.template _Assign_cast<_Mutable_value_type&>(
+                    _Right._List._Unchecked_begin(), _Right._List._Unchecked_end());
+                _Reinsert_with_invalid_vec();
+                _Guard._Target = nullptr;
+
+                return *this;
+            }
+        }
+
+        _Clear_guard _Guard{this};
+        _Traitsobj = _Right._Traitsobj;
+        _Pocca_both(_Right);
+        _List.template _Assign_cast<_Mutable_value_type&>(
+            _Right._List._Unchecked_begin(), _Right._List._Unchecked_end());
+        _Reinsert_with_invalid_vec();
+        _Guard._Target = nullptr;
+
+        return *this;
+    }
+
+    _NODISCARD iterator begin() noexcept {
+        return _List.begin();
+    }
+
+    _NODISCARD const_iterator begin() const noexcept {
+        return _List.begin();
+    }
+
+    _NODISCARD iterator end() noexcept {
+        return _List.end();
+    }
+
+    _NODISCARD const_iterator end() const noexcept {
+        return _List.end();
+    }
+
+    _Unchecked_iterator _Unchecked_begin() noexcept {
+        return _List._Unchecked_begin();
+    }
+
+    _Unchecked_const_iterator _Unchecked_begin() const noexcept {
+        return _List._Unchecked_begin();
+    }
+
+    _Unchecked_iterator _Unchecked_end() noexcept {
+        return _List._Unchecked_end();
+    }
+
+    _Unchecked_const_iterator _Unchecked_end() const noexcept {
+        return _List._Unchecked_end();
+    }
+
+    _NODISCARD const_iterator cbegin() const noexcept {
+        return begin();
+    }
+
+    _NODISCARD const_iterator cend() const noexcept {
+        return end();
+    }
+
+    _NODISCARD size_type size() const noexcept {
+        return _List.size();
+    }
+
+    _NODISCARD size_type max_size() const noexcept {
+        return _List.max_size();
+    }
+
+    _NODISCARD_EMPTY_MEMBER bool empty() const noexcept {
+        return _List.empty();
+    }
+
+    _NODISCARD allocator_type get_allocator() const noexcept {
+        return static_cast<allocator_type>(_List.get_allocator());
+    }
+
+    using local_iterator       = iterator;
+    using const_local_iterator = const_iterator;
+
+    _NODISCARD size_type bucket_count() const noexcept {
+        return _Maxidx;
+    }
+
+    _NODISCARD size_type max_bucket_count() const noexcept {
+        return _Vec.max_size() >> 1;
+    }
+
+    _NODISCARD size_type bucket(const key_type& _Keyval) const
+        noexcept(_Nothrow_hash<_Traits, key_type>) /* strengthened */ {
+        return _Traitsobj(_Keyval) & _Mask;
+    }
+
+    _NODISCARD size_type bucket_size(size_type _Bucket) const noexcept /* strengthened */ {
+        _Unchecked_iterator _Bucket_lo = _Vec._Mypair._Myval2._Myfirst[_Bucket << 1];
+        if (_Bucket_lo == _Unchecked_end()) {
+            return 0;
+        }
+
+        return static_cast<size_type>(_STD distance(_Bucket_lo, _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1])) + 1;
+    }
+
+    _NODISCARD local_iterator begin(size_type _Bucket) noexcept /* strengthened */ {
+        return _List._Make_iter(_Vec._Mypair._Myval2._Myfirst[_Bucket << 1]._Ptr);
+    }
+
+    _NODISCARD const_local_iterator begin(size_type _Bucket) const noexcept /* strengthened */ {
+        return _List._Make_const_iter(_Vec._Mypair._Myval2._Myfirst[_Bucket << 1]._Ptr);
+    }
+
+    _NODISCARD local_iterator end(size_type _Bucket) noexcept /* strengthened */ {
+        _Nodeptr _Bucket_hi = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1]._Ptr;
+        if (_Bucket_hi != _List._Mypair._Myval2._Myhead) {
+            _Bucket_hi = _Bucket_hi->_Next;
+        }
+
+        return _List._Make_iter(_Bucket_hi);
+    }
+
+    _NODISCARD const_local_iterator end(size_type _Bucket) const noexcept /* strengthened */ {
+        _Nodeptr _Bucket_hi = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1]._Ptr;
+        if (_Bucket_hi != _List._Mypair._Myval2._Myhead) {
+            _Bucket_hi = _Bucket_hi->_Next;
+        }
+
+        return _List._Make_const_iter(_Bucket_hi);
+    }
+
+    _NODISCARD const_local_iterator cbegin(size_type _Bucket) const noexcept /* strengthened */ {
+        return _List._Make_const_iter(_Vec._Mypair._Myval2._Myfirst[_Bucket << 1]._Ptr);
+    }
+
+    _NODISCARD const_local_iterator cend(size_type _Bucket) const noexcept /* strengthened */ {
+        _Nodeptr _Bucket_hi = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1]._Ptr;
+        if (_Bucket_hi != _List._Mypair._Myval2._Myhead) {
+            _Bucket_hi = _Bucket_hi->_Next;
+        }
+
+        return _List._Make_const_iter(_Bucket_hi);
+    }
+
+    _NODISCARD float load_factor() const noexcept {
+        return static_cast<float>(size()) / static_cast<float>(bucket_count());
+    }
+
+    _NODISCARD float max_load_factor() const noexcept {
+        return _Max_bucket_size();
+    }
+
+    void max_load_factor(float _Newmax) noexcept /* strengthened */ {
+        _STL_ASSERT(!(_CSTD isnan)(_Newmax) && _Newmax > 0, "invalid hash load factor");
+        _Max_bucket_size() = _Newmax;
+    }
+
+    void rehash(size_type _Buckets) { // rebuild table with at least _Buckets buckets
+        // don't violate a.bucket_count() >= a.size() / a.max_load_factor() invariant:
+        _Buckets = (_STD max)(_Min_load_factor_buckets(_List.size()), _Buckets);
+        if (_Buckets <= _Maxidx) { // we already have enough buckets; nothing to do
+            return;
+        }
+
+        _Forced_rehash(_Buckets);
+    }
+
+    void reserve(size_type _Maxcount) { // rebuild table with room for _Maxcount elements
+        rehash(_Min_load_factor_buckets(_Maxcount));
+    }
+
+    conditional_t<_Multi, iterator, pair<iterator, bool>> insert(const value_type& _Val) {
+        return emplace(_Val);
+    }
+
+    conditional_t<_Multi, iterator, pair<iterator, bool>> insert(value_type&& _Val) {
+        return emplace(_STD move(_Val));
+    }
+
+    iterator insert(const_iterator _Hint, const value_type& _Val) {
+        return emplace_hint(_Hint, _Val);
+    }
+
+    iterator insert(const_iterator _Hint, value_type&& _Val) {
+        return emplace_hint(_Hint, _STD move(_Val));
+    }
+
+protected:
+    template <class _Iter, class _Sent>
+    void _Insert_range_unchecked(_Iter _First, const _Sent _Last) {
+        for (; _First != _Last; ++_First) {
+            emplace(*_First);
+        }
+    }
+
+public:
+    template <class _Iter>
+    void insert(_Iter _First, _Iter _Last) {
+        _STD _Adl_verify_range(_First, _Last);
+        _Insert_range_unchecked(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last));
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<value_type> _Rng>
+    void insert_range(_Rng&& _Range) {
+        _Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // _HAS_CXX23
+
+    void insert(initializer_list<value_type> _Ilist) {
+        _Insert_range_unchecked(_Ilist.begin(), _Ilist.end());
+    }
+
+private:
+    _Nodeptr _Unchecked_erase(_Nodeptr _Plist) noexcept(_Nothrow_hash<_Traits, key_type>) {
+        size_type _Bucket = bucket(_Traits::_Kfn(_Plist->_Myval));
+        _Erase_bucket(_Plist, _Bucket);
+        return _List._Unchecked_erase(_Plist);
+    }
+
+    struct _Range_eraser {
+        _Range_eraser(const _Range_eraser&)            = delete;
+        _Range_eraser& operator=(const _Range_eraser&) = delete;
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        // Keep the list nodes around until we have found all those we will erase, for an O(iterators + erasures) update
+        // of the iterator chain.
+        _Range_eraser(_Mylist& _List_, const _Nodeptr _First_) noexcept
+            : _List(_List_), _First(_First_), _Next(_First_) {}
+
+        void _Bump_erased() noexcept {
+            _Next = _Next->_Next;
+        }
+
+        ~_Range_eraser() noexcept {
+            _List._Unchecked_erase(_First, _Next);
+        }
+
+        _Mylist& _List;
+        const _Nodeptr _First;
+        _Nodeptr _Next;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 2 / _ITERATOR_DEBUG_LEVEL != 2 vvv
+      // Destroy the nodes as we encounter them to avoid a second traversal of the linked list.
+        _Range_eraser(_Mylist& _List_, const _Nodeptr _First_) noexcept
+            : _List(_List_), _Predecessor(_First_->_Prev), _Next(_First_) {}
+
+        void _Bump_erased() noexcept {
+            const auto _Oldnext = _Next;
+            _Next               = _Oldnext->_Next;
+            _Node::_Freenode(_List._Getal(), _Oldnext);
+            --_List._Mypair._Myval2._Mysize;
+        }
+
+        ~_Range_eraser() noexcept {
+            _Predecessor->_Next = _Next;
+            _Next->_Prev        = _Predecessor;
+        }
+
+        _Mylist& _List;
+        const _Nodeptr _Predecessor;
+        _Nodeptr _Next;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 2 ^^^
+    };
+
+    _Nodeptr _Unchecked_erase(_Nodeptr _First, const _Nodeptr _Last) noexcept(_Nothrow_hash<_Traits, key_type>) {
+        if (_First == _Last) {
+            return _Last;
+        }
+
+        const auto _End           = _List._Mypair._Myval2._Myhead;
+        const auto _Bucket_bounds = _Vec._Mypair._Myval2._Myfirst;
+        _Range_eraser _Eraser{_List, _First};
+        {
+            // process the first bucket, which is special because here _First might not be the beginning of the bucket
+            const auto _Predecessor = _First->_Prev;
+            const size_type _Bucket = bucket(_Traits::_Kfn(_Eraser._Next->_Myval)); // throws
+            // nothrow hereafter this block
+            _Nodeptr& _Bucket_lo   = _Bucket_bounds[_Bucket << 1]._Ptr;
+            _Nodeptr& _Bucket_hi   = _Bucket_bounds[(_Bucket << 1) + 1]._Ptr;
+            const bool _Update_lo  = _Bucket_lo == _Eraser._Next;
+            const _Nodeptr _Old_hi = _Bucket_hi;
+            for (;;) { // remove elements until we hit the end of the bucket
+                const bool _At_bucket_back = _Eraser._Next == _Old_hi;
+                _Eraser._Bump_erased();
+                if (_At_bucket_back) {
+                    break;
+                }
+
+                if (_Eraser._Next == _Last) {
+                    if (_Update_lo) {
+                        // erased the bucket's prefix
+                        _Bucket_lo = _Eraser._Next;
+                    }
+
+                    return _Last;
+                }
+            }
+
+            if (_Update_lo) {
+                // emptied the bucket
+                _Bucket_lo = _End;
+                _Bucket_hi = _End;
+            } else {
+                _Bucket_hi = _Predecessor;
+            }
+        }
+
+        // hereafter we are always erasing buckets' prefixes
+        while (_Eraser._Next != _Last) {
+            const size_type _Bucket = bucket(_Traits::_Kfn(_Eraser._Next->_Myval)); // throws
+            // nothrow hereafter this block
+            _Nodeptr& _Bucket_lo   = _Bucket_bounds[_Bucket << 1]._Ptr;
+            _Nodeptr& _Bucket_hi   = _Bucket_bounds[(_Bucket << 1) + 1]._Ptr;
+            const _Nodeptr _Old_hi = _Bucket_hi;
+            for (;;) { // remove elements until we hit the end of the bucket
+                const bool _At_bucket_back = _Eraser._Next == _Old_hi;
+                _Eraser._Bump_erased();
+                if (_At_bucket_back) {
+                    break;
+                }
+
+                if (_Eraser._Next == _Last) {
+                    // erased the bucket's prefix
+                    _Bucket_lo = _Eraser._Next;
+                    return _Last;
+                }
+            }
+
+            // emptied the bucket
+            _Bucket_lo = _End;
+            _Bucket_hi = _End;
+        }
+
+        return _Last;
+    }
+
+    template <class _Kx>
+    static constexpr bool _Noexcept_heterogeneous_erasure() {
+        return _Nothrow_hash<_Traits, _Kx>
+            && (!_Multi || (_Nothrow_compare<_Traits, key_type, _Kx> && _Nothrow_compare<_Traits, _Kx, key_type>) );
+    }
+
+    template <class _Keytype>
+    size_type _Erase(const _Keytype& _Keyval) noexcept(_Noexcept_heterogeneous_erasure<_Keytype>()) /* strengthened */ {
+        const size_t _Hashval = _Traitsobj(_Keyval);
+        if constexpr (_Multi) {
+            const auto _Where = _Equal_range(_Keyval, _Hashval);
+            _Unchecked_erase(_Where._First._Ptr, _Where._Last._Ptr);
+            return _Where._Distance;
+        } else {
+            const auto _Target = _Find_last(_Keyval, _Hashval)._Duplicate;
+            if (_Target) {
+                _Erase_bucket(_Target, _Hashval & _Mask);
+                _List._Unchecked_erase(_Target);
+                return 1;
+            }
+
+            return 0;
+        }
+    }
+
+public:
+    template <class _Iter = iterator, enable_if_t<!is_same_v<_Iter, const_iterator>, int> = 0>
+    iterator erase(iterator _Plist) noexcept(_Nothrow_hash<_Traits, key_type>) /* strengthened */ {
+        return _List._Make_iter(_Unchecked_erase(_Plist._Ptr));
+    }
+
+    iterator erase(const_iterator _Plist) noexcept(_Nothrow_hash<_Traits, key_type>) /* strengthened */ {
+        return _List._Make_iter(_Unchecked_erase(_Plist._Ptr));
+    }
+
+    iterator erase(const_iterator _First, const_iterator _Last) noexcept(
+        _Nothrow_hash<_Traits, key_type>) /* strengthened */ {
+        return _List._Make_iter(_Unchecked_erase(_First._Ptr, _Last._Ptr));
+    }
+
+    size_type erase(const key_type& _Keyval) noexcept(noexcept(_Erase(_Keyval))) /* strengthened */ {
+        return _Erase(_Keyval);
+    }
+
+#if _HAS_CXX23
+    template <class _Kx>
+        requires (_Traits::template _Supports_transparency<_Hash, _Kx>)
+    size_type erase(_Kx&& _Keyval) noexcept(noexcept(_Erase(_Keyval))) /* strengthened */ {
+        return _Erase(_Keyval);
+    }
+#endif // _HAS_CXX23
+
+    void clear() noexcept {
+        // TRANSITION, ABI:
+        // LWG-2550 requires implementations to make clear() O(size()), independent of bucket_count().
+        // Unfortunately our current data structure / ABI does not allow achieving this in the general case because:
+        //   (1) Finding the bucket that goes with an element requires running the hash function
+        //   (2) The hash function operator() may throw exceptions, and
+        //   (3) clear() is a noexcept function.
+        // We do comply with LWG-2550 if the hash function is noexcept, or if the container was empty.
+        const auto _Oldsize = _List._Mypair._Myval2._Mysize;
+        if (_Oldsize == 0) {
+            return;
+        }
+
+        if constexpr (_Nothrow_hash<_Traits, key_type>) {
+            // In testing, hash<size_t>{}(size_t{}) takes about 14 times as much time as assigning a pointer, or
+            // ~7-8 times as much as clearing a bucket. Therefore, if we would need to assign over more than 8 times
+            // as many buckets as elements, remove element-by-element.
+            if (bucket_count() / 8 > _Oldsize) {
+                const auto _Head = _List._Mypair._Myval2._Myhead;
+                _Unchecked_erase(_Head->_Next, _Head);
+                return;
+            }
+        }
+
+        // Bulk destroy items and reset buckets
+        _List.clear();
+        _STD fill(_Vec._Mypair._Myval2._Myfirst, _Vec._Mypair._Myval2._Mylast, _Unchecked_end());
+    }
+
+private:
+    template <class _Keyty>
+    _NODISCARD _Nodeptr _Find_first(const _Keyty& _Keyval, const size_t _Hashval) const {
+        // find node pointer to first node matching _Keyval (with hash _Hashval) if it exists; otherwise, end
+        const size_type _Bucket = _Hashval & _Mask;
+        _Nodeptr _Where         = _Vec._Mypair._Myval2._Myfirst[_Bucket << 1]._Ptr;
+        const _Nodeptr _End     = _List._Mypair._Myval2._Myhead;
+        if (_Where == _End) {
+            return _End;
+        }
+
+        const _Nodeptr _Bucket_hi = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1]._Ptr;
+        for (;;) {
+            if (!_Traitsobj(_Traits::_Kfn(_Where->_Myval), _Keyval)) {
+                if constexpr (!_Traits::_Standard) {
+                    if (_Traitsobj(_Keyval, _Traits::_Kfn(_Where->_Myval))) {
+                        return _End;
+                    }
+                }
+
+                return _Where;
+            }
+
+            if (_Where == _Bucket_hi) {
+                return _End;
+            }
+
+            _Where = _Where->_Next;
+        }
+    }
+
+    template <class _Keyty>
+    _Nodeptr _Find(const _Keyty& _Keyval, const size_t _Hashval) const {
+        if constexpr (_Traits::_Multi) {
+            return _Find_first(_Keyval, _Hashval);
+        } else {
+            // use _Find_last for unique containers to avoid increase in code size of instantiating _Find_first
+            auto _Target = _Find_last(_Keyval, _Hashval)._Duplicate;
+            if (_Target) {
+                return _Target;
+            }
+
+            return _List._Mypair._Myval2._Myhead;
+        }
+    }
+
+public:
+    template <class _Keyty = void>
+    _NODISCARD iterator find(typename _Traits::template _Deduce_key<_Keyty> _Keyval) {
+        return _List._Make_iter(_Find(_Keyval, _Traitsobj(_Keyval)));
+    }
+
+    template <class _Keyty = void>
+    _NODISCARD const_iterator find(typename _Traits::template _Deduce_key<_Keyty> _Keyval) const {
+        return _List._Make_const_iter(_Find(_Keyval, _Traitsobj(_Keyval)));
+    }
+
+#if _HAS_CXX20
+    template <class _Keyty = void>
+    _NODISCARD bool contains(_Traits::template _Deduce_key<_Keyty> _Keyval) const {
+        return static_cast<bool>(_Find_last(_Keyval, _Traitsobj(_Keyval))._Duplicate);
+    }
+#endif // _HAS_CXX20
+
+    template <class _Keyty = void>
+    _NODISCARD size_type count(typename _Traits::template _Deduce_key<_Keyty> _Keyval) const {
+        const size_t _Hashval = _Traitsobj(_Keyval);
+        if constexpr (_Multi) {
+            return _Equal_range(_Keyval, _Hashval)._Distance;
+        } else {
+            return static_cast<bool>(_Find_last(_Keyval, _Hashval)._Duplicate);
+        }
+    }
+
+private:
+    struct _Equal_range_result {
+        _Unchecked_const_iterator _First;
+        _Unchecked_const_iterator _Last;
+        size_type _Distance;
+    };
+
+    template <class _Keyty>
+    _NODISCARD _Equal_range_result _Equal_range(const _Keyty& _Keyval, const size_t _Hashval) const
+        noexcept(_Nothrow_compare<_Traits, key_type, _Keyty> && _Nothrow_compare<_Traits, _Keyty, key_type>) {
+        const size_type _Bucket              = _Hashval & _Mask;
+        _Unchecked_const_iterator _Where     = _Vec._Mypair._Myval2._Myfirst[_Bucket << 1];
+        const _Unchecked_const_iterator _End = _Unchecked_end();
+        if (_Where == _End) {
+            return {_End, _End, 0};
+        }
+
+        const _Unchecked_const_iterator _Bucket_hi = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1];
+        for (; _Traitsobj(_Traits::_Kfn(*_Where), _Keyval); ++_Where) {
+            if (_Where == _Bucket_hi) {
+                return {_End, _End, 0};
+            }
+        }
+
+        if constexpr (!_Traits::_Standard) {
+            if (_Traitsobj(_Keyval, _Traits::_Kfn(*_Where))) {
+                return {_End, _End, 0};
+            }
+        }
+
+        const _Unchecked_const_iterator _First = _Where;
+        if constexpr (_Multi) {
+            size_type _Distance = 0;
+            for (;;) {
+                ++_Distance;
+
+                const bool _At_bucket_end = _Where == _Bucket_hi;
+                ++_Where;
+                if (_At_bucket_end) {
+                    break;
+                }
+
+                if (_Traitsobj(_Keyval, _Traits::_Kfn(*_Where))) {
+                    break;
+                }
+            }
+
+            return {_First, _Where, _Distance};
+        } else {
+            ++_Where; // found the unique element
+            return {_First, _Where, 1};
+        }
+    }
+
+public:
+    template <class _Keyty = void>
+    _NODISCARD pair<iterator, iterator> equal_range(typename _Traits::template _Deduce_key<_Keyty> _Keyval) {
+        const auto _Result = _Equal_range(_Keyval, _Traitsobj(_Keyval));
+        return {_List._Make_iter(_Result._First._Ptr), _List._Make_iter(_Result._Last._Ptr)};
+    }
+
+    template <class _Keyty = void>
+    _NODISCARD pair<const_iterator, const_iterator> equal_range(
+        typename _Traits::template _Deduce_key<_Keyty> _Keyval) const {
+        const auto _Result = _Equal_range(_Keyval, _Traitsobj(_Keyval));
+        return {_List._Make_const_iter(_Result._First._Ptr), _List._Make_const_iter(_Result._Last._Ptr)};
+    }
+
+    void swap(_Hash& _Right) noexcept(noexcept(_Traitsobj.swap(_Right._Traitsobj))) /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _Traitsobj.swap(_Right._Traitsobj);
+            _Pocs(_List._Getal(), _Right._List._Getal());
+            _Pocs(_Vec._Mypair._Get_first(), _Right._Vec._Mypair._Get_first());
+            _Swap_val(_Right);
+        }
+    }
+
+#if _HAS_CXX17
+    using node_type = typename _Traits::node_type;
+
+    node_type extract(const const_iterator _Where) {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        const auto _List_data = _STD addressof(_List._Mypair._Myval2);
+        _STL_VERIFY(_Where._Getcont() == _List_data, "extract mismatched container");
+        _STL_VERIFY(_Where._Ptr != _List_data->_Myhead, "cannot extract end()");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        return node_type::_Make(_Extract(_Where._Unwrapped()), _List._Getal());
+    }
+
+    node_type extract(const key_type& _Keyval) {
+        const auto _Ptr = _Extract(_Keyval);
+        if (!_Ptr) {
+            return node_type{};
+        }
+
+        return node_type::_Make(_Ptr, _List._Getal());
+    }
+
+#if _HAS_CXX23
+    template <class _Kx>
+        requires (_Traits::template _Supports_transparency<_Hash, _Kx>)
+    node_type extract(_Kx&& _Keyval) {
+        const auto _Ptr = _Extract(_Keyval);
+        if (!_Ptr) {
+            return node_type{};
+        }
+
+        return node_type::_Make(_Ptr, _List._Getal());
+    }
+#endif // _HAS_CXX23
+
+    iterator insert(const_iterator _Hint, node_type&& _Handle) {
+        if (_Handle.empty()) {
+            return end();
+        }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_List.get_allocator() == _Handle._Getal(), "node handle allocator incompatible for insert");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        const auto& _Keyval   = _Traits::_Kfn(_Handle._Getptr()->_Myval);
+        const size_t _Hashval = _Traitsobj(_Keyval);
+        auto _Target          = _Find_hint(_Hint._Ptr, _Keyval, _Hashval);
+        if constexpr (!_Traits::_Multi) {
+            if (_Target._Duplicate) {
+                return _List._Make_iter(_Target._Duplicate);
+            }
+        }
+
+        _Check_max_size();
+        if (_Check_rehash_required_1()) {
+            _Rehash_for_1();
+            _Target = _Find_hint(_Hint._Ptr, _Keyval, _Hashval);
+        }
+
+        const auto _Released = _Handle._Release();
+        _Destroy_in_place(_Released->_Next); // TRANSITION, ABI
+        _Destroy_in_place(_Released->_Prev);
+        return _List._Make_iter(_Insert_new_node_before(_Hashval, _Target._Insert_before, _Released));
+    }
+
+    template <class>
+    friend class _Hash;
+
+    template <class _Other_traits>
+    void merge(_Hash<_Other_traits>& _That) { // transfer all nodes from _That into *this
+        static_assert(is_same_v<_Nodeptr, typename _Hash<_Other_traits>::_Nodeptr>,
+            "merge() requires an argument with a compatible node type.");
+
+        static_assert(is_same_v<allocator_type, typename _Hash<_Other_traits>::allocator_type>,
+            "merge() requires an argument with the same allocator type.");
+
+        if constexpr (is_same_v<_Hash, _Hash<_Other_traits>>) {
+            if (this == _STD addressof(_That)) {
+                return;
+            }
+        }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        if constexpr (!_Alnode_traits::is_always_equal::value) {
+            _STL_VERIFY(_List._Getal() == _That._List._Getal(), "allocator incompatible for merge");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        auto _First      = _That._Unchecked_begin();
+        const auto _Last = _That._Unchecked_end();
+        while (_First != _Last) {
+            const auto _Candidate = _First._Ptr;
+            ++_First;
+            const auto& _Keyval   = _Traits::_Kfn(_Candidate->_Myval);
+            const size_t _Hashval = _Traitsobj(_Keyval);
+            auto _Target          = _Find_last(_Keyval, _Hashval);
+            if constexpr (!_Traits::_Multi) {
+                if (_Target._Duplicate) {
+                    continue;
+                }
+            }
+
+            _Check_max_size();
+            if (_Check_rehash_required_1()) {
+                _Rehash_for_1();
+                _Target = _Find_last(_Keyval, _Hashval);
+            }
+
+            // nothrow hereafter this iteration
+            const auto _Source_bucket = _Hashval & _That._Mask;
+            _That._Erase_bucket(_Candidate, _Source_bucket);
+            _Candidate->_Prev->_Next = _Candidate->_Next;
+            _Candidate->_Next->_Prev = _Candidate->_Prev;
+            --_That._List._Mypair._Myval2._Mysize;
+            _Destroy_in_place(_Candidate->_Next); // TRANSITION, ABI
+            _Destroy_in_place(_Candidate->_Prev);
+#if _ITERATOR_DEBUG_LEVEL == 2
+            _List._Mypair._Myval2._Adopt_unique(_That._List._Mypair._Myval2, _Candidate);
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+            (void) _Insert_new_node_before(_Hashval, _Target._Insert_before, _Candidate);
+        }
+    }
+
+    template <class _Other_traits>
+    void merge(_Hash<_Other_traits>&& _That) { // transfer all nodes from _That into *this
+        static_assert(is_same_v<_Nodeptr, typename _Hash<_Other_traits>::_Nodeptr>,
+            "merge() requires an argument with a compatible node type.");
+
+        static_assert(is_same_v<allocator_type, typename _Hash<_Other_traits>::allocator_type>,
+            "merge() requires an argument with the same allocator type.");
+
+        merge(_That);
+    }
+
+protected:
+    _Nodeptr _Extract(const _Unchecked_const_iterator _Where) {
+        const size_type _Bucket = bucket(_Traits::_Kfn(*_Where));
+        _Erase_bucket(_Where._Ptr, _Bucket);
+        return _List._Mypair._Myval2._Unlinknode(_Where._Ptr);
+    }
+
+    template <class _Kx>
+    _Nodeptr _Extract(const _Kx& _Keyval) {
+        const size_t _Hashval = _Traitsobj(_Keyval);
+        _Nodeptr _Target;
+        if constexpr (_Traits::_Multi) {
+            _Target = _Find_first(_Keyval, _Hashval);
+            if (_Target == _List._Mypair._Myval2._Myhead) {
+                return _Nodeptr{};
+            }
+        } else {
+            _Target = _Find_last(_Keyval, _Hashval)._Duplicate;
+            if (_Target == nullptr) {
+                return _Nodeptr{};
+            }
+        }
+
+        _Erase_bucket(_Target, _Hashval & _Mask);
+        return _List._Mypair._Myval2._Unlinknode(_Target);
+    }
+
+public:
+    conditional_t<_Traits::_Multi, iterator, _Insert_return_type<iterator, node_type>> insert(node_type&& _Handle) {
+        // insert the node (if any) held in _Handle
+        if (_Handle.empty()) {
+            if constexpr (_Traits::_Multi) {
+                return end();
+            } else {
+                return {end(), false, _STD move(_Handle)};
+            }
+        }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_List.get_allocator() == _Handle._Getal(), "node handle allocator incompatible for insert");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        const auto& _Keyval   = _Traits::_Kfn(_Handle._Getptr()->_Myval);
+        const size_t _Hashval = _Traitsobj(_Keyval);
+        auto _Target          = _Find_last(_Keyval, _Hashval);
+        if constexpr (!_Traits::_Multi) {
+            if (_Target._Duplicate) {
+                return {_List._Make_iter(_Target._Duplicate), false, _STD move(_Handle)};
+            }
+        }
+
+        _Check_max_size();
+        if (_Check_rehash_required_1()) {
+            _Rehash_for_1();
+            _Target = _Find_last(_Keyval, _Hashval);
+        }
+
+        const auto _Released = _Handle._Release();
+        _Destroy_in_place(_Released->_Next); // TRANSITION, ABI
+        _Destroy_in_place(_Released->_Prev);
+        const auto _Newnode = _Insert_new_node_before(_Hashval, _Target._Insert_before, _Released);
+        if constexpr (_Traits::_Multi) {
+            return _List._Make_iter(_Newnode);
+        } else {
+            return {_List._Make_iter(_Newnode), true, node_type{}};
+        }
+    }
+#endif // _HAS_CXX17
+
+protected:
+    template <class _Keyty>
+    _NODISCARD _Hash_find_last_result<_Nodeptr> _Find_last(const _Keyty& _Keyval, const size_t _Hashval) const {
+        // find the insertion point for _Keyval and whether an element identical to _Keyval is already in the container
+        const size_type _Bucket = _Hashval & _Mask;
+        _Nodeptr _Where         = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1]._Ptr;
+        const _Nodeptr _End     = _List._Mypair._Myval2._Myhead;
+        if (_Where == _End) {
+            return {_End, _Nodeptr{}};
+        }
+
+        const _Nodeptr _Bucket_lo = _Vec._Mypair._Myval2._Myfirst[_Bucket << 1]._Ptr;
+        for (;;) {
+            // Search backwards to maintain sorted [_Bucket_lo, _Bucket_hi] when !_Standard
+            if (!_Traitsobj(_Keyval, _Traits::_Kfn(_Where->_Myval))) {
+                if constexpr (!_Traits::_Standard) {
+                    if (_Traitsobj(_Traits::_Kfn(_Where->_Myval), _Keyval)) {
+                        return {_Where->_Next, _Nodeptr{}};
+                    }
+                }
+
+                return {_Where->_Next, _Where};
+            }
+
+            if (_Where == _Bucket_lo) {
+                return {_Where, _Nodeptr{}};
+            }
+
+            _Where = _Where->_Prev;
+        }
+    }
+
+    template <class _Keyty>
+    _NODISCARD _Hash_find_last_result<_Nodeptr> _Find_hint(
+        const _Nodeptr _Hint, const _Keyty& _Keyval, const size_t _Hashval) const {
+        // if _Hint points to an element equivalent to _Keyval, returns _Hint; otherwise,
+        // returns _Find_last(_Keyval, _Hashval)
+        if (_Hint != _List._Mypair._Myval2._Myhead && !_Traitsobj(_Traits::_Kfn(_Hint->_Myval), _Keyval)) {
+            if constexpr (!_Traits::_Standard) {
+                if (_Traitsobj(_Keyval, _Traits::_Kfn(_Hint->_Myval))) {
+                    return _Find_last(_Keyval, _Hashval);
+                }
+            }
+
+            return {_Hint->_Next, _Hint};
+        }
+
+        return _Find_last(_Keyval, _Hashval);
+    }
+
+    _Nodeptr _Insert_new_node_before(
+        const size_t _Hashval, const _Nodeptr _Insert_before, const _Nodeptr _Newnode) noexcept {
+        const _Nodeptr _Insert_after = _Insert_before->_Prev;
+        ++_List._Mypair._Myval2._Mysize;
+        _Construct_in_place(_Newnode->_Next, _Insert_before);
+        _Construct_in_place(_Newnode->_Prev, _Insert_after);
+        _Insert_after->_Next  = _Newnode;
+        _Insert_before->_Prev = _Newnode;
+
+        const auto _Head                = _List._Mypair._Myval2._Myhead;
+        const auto _Bucket_array        = _Vec._Mypair._Myval2._Myfirst;
+        const size_type _Bucket         = _Hashval & _Mask;
+        _Unchecked_iterator& _Bucket_lo = _Bucket_array[_Bucket << 1];
+        _Unchecked_iterator& _Bucket_hi = _Bucket_array[(_Bucket << 1) + 1];
+        if (_Bucket_lo._Ptr == _Head) {
+            // bucket is empty, set both
+            _Bucket_lo._Ptr = _Newnode;
+            _Bucket_hi._Ptr = _Newnode;
+        } else if (_Bucket_lo._Ptr == _Insert_before) {
+            // new node is the lowest element in the bucket
+            _Bucket_lo._Ptr = _Newnode;
+        } else if (_Bucket_hi._Ptr == _Insert_after) {
+            // new node is the highest element in the bucket
+            _Bucket_hi._Ptr = _Newnode;
+        }
+
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+        _Stl_internal_check_container_invariants();
+#endif // _ENABLE_STL_INTERNAL_CHECK
+        return _Newnode;
+    }
+
+    void _Check_max_size() const {
+        const size_type _Oldsize = _List._Mypair._Myval2._Mysize;
+        if (_Oldsize == _List.max_size()) {
+            _Xlength_error("unordered_map/set too long");
+        }
+    }
+
+    bool _Check_rehash_required_1() const noexcept {
+        const size_type _Oldsize = _List._Mypair._Myval2._Mysize;
+        const auto _Newsize      = _Oldsize + 1;
+        return max_load_factor() < static_cast<float>(_Newsize) / static_cast<float>(bucket_count());
+    }
+
+    void _Rehash_for_1() {
+        const auto _Oldsize = _List._Mypair._Myval2._Mysize;
+        const auto _Newsize = _Oldsize + 1;
+        _Forced_rehash(_Desired_grow_bucket_count(_Newsize));
+    }
+
+    void _Erase_bucket(_Nodeptr _Plist, size_type _Bucket) noexcept {
+        // remove the node _Plist from its bucket
+        _Nodeptr& _Bucket_lo = _Vec._Mypair._Myval2._Myfirst[_Bucket << 1]._Ptr;
+        _Nodeptr& _Bucket_hi = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1]._Ptr;
+        if (_Bucket_hi == _Plist) {
+            if (_Bucket_lo == _Plist) { // make bucket empty
+                const auto _End = _List._Mypair._Myval2._Myhead;
+
+                _Bucket_lo = _End;
+                _Bucket_hi = _End;
+            } else {
+                _Bucket_hi = _Plist->_Prev; // move end back one element
+            }
+        } else if (_Bucket_lo == _Plist) {
+            _Bucket_lo = _Plist->_Next; // move beginning up one element
+        }
+    }
+
+    _NODISCARD size_type _Min_load_factor_buckets(const size_type _For_size) const noexcept {
+        // returns the minimum number of buckets necessary for the elements in _List
+        return static_cast<size_type>(_CSTD ceilf(static_cast<float>(_For_size) / max_load_factor()));
+    }
+
+    _NODISCARD size_type _Desired_grow_bucket_count(const size_type _For_size) const noexcept {
+        const size_type _Old_buckets = bucket_count();
+        const size_type _Req_buckets = (_STD max)(_Min_buckets, _Min_load_factor_buckets(_For_size));
+        if (_Old_buckets >= _Req_buckets) {
+            // we already have enough buckets so there's no need to change the count
+            return _Old_buckets;
+        }
+
+        if (_Old_buckets < 512 && _Old_buckets * 8 >= _Req_buckets) {
+            // if we are changing the bucket count and have less than 512 buckets, use 8x more buckets
+            return _Old_buckets * 8;
+        }
+
+        // power of 2 invariant means this will result in at least 2*_Old_buckets after round up in _Forced_rehash
+        return _Req_buckets;
+    }
+
+    void _Reinsert_with_invalid_vec() { // insert elements in [begin(), end()), distrusting existing _Vec elements
+        _Forced_rehash(_Desired_grow_bucket_count(_List.size()));
+    }
+
+    void _Forced_rehash(size_type _Buckets) {
+        // Force rehash of elements in _List, distrusting existing bucket assignments in _Vec.
+        // Assumes _Buckets is greater than _Min_buckets, and that changing to that many buckets doesn't violate
+        // load_factor() <= max_load_factor().
+
+        // Don't violate power of 2, fits in half the bucket vector invariant:
+        // (we assume because vector must use single allocations; as a result, its max_size fits in a size_t)
+        const unsigned long _Max_storage_buckets_log2 = _Floor_of_log_2(static_cast<size_t>(_Vec.max_size() >> 1));
+        const auto _Max_storage_buckets               = static_cast<size_type>(1) << _Max_storage_buckets_log2;
+        if (_Buckets > _Max_storage_buckets) {
+            _Xlength_error("invalid hash bucket count");
+        }
+
+        // The above test also means that we won't perform a forbidden full shift when restoring the power of
+        // 2 invariant
+        // this round up to power of 2 in addition to the _Buckets > _Maxidx above means
+        // we'll at least double in size (the next power of 2 above _Maxidx)
+        _Buckets                       = static_cast<size_type>(1) << _Ceiling_of_log_2(static_cast<size_t>(_Buckets));
+        const _Unchecked_iterator _End = _Unchecked_end();
+
+        _Vec._Assign_grow(_Buckets << 1, _End);
+        _Mask   = _Buckets - 1;
+        _Maxidx = _Buckets;
+
+        _Clear_guard _Guard{this};
+
+        _Unchecked_iterator _Inserted = _Unchecked_begin();
+
+        // Remember the next _Inserted value as splices will change _Inserted's position arbitrarily.
+        for (_Unchecked_iterator _Next_inserted = _Inserted; _Inserted != _End; _Inserted = _Next_inserted) {
+            ++_Next_inserted;
+
+            auto& _Inserted_key     = _Traits::_Kfn(*_Inserted);
+            const size_type _Bucket = bucket(_Inserted_key);
+
+            // _Bucket_lo and _Bucket_hi are the *inclusive* range of elements in the bucket, or _Unchecked_end() if
+            // the bucket is empty; if !_Standard then [_Bucket_lo, _Bucket_hi] is a sorted range.
+            _Unchecked_iterator& _Bucket_lo = _Vec._Mypair._Myval2._Myfirst[_Bucket << 1];
+            _Unchecked_iterator& _Bucket_hi = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1];
+
+            if (_Bucket_lo == _End) {
+                // The bucket was empty, set it to the inserted element.
+                _Bucket_lo = _Inserted;
+                _Bucket_hi = _Inserted;
+                continue;
+            }
+
+            // Search the bucket for the insertion location and move element if necessary.
+            _Unchecked_const_iterator _Insert_before = _Bucket_hi;
+            if (!_Traitsobj(_Inserted_key, _Traits::_Kfn(*_Insert_before))) {
+                // The inserted element belongs at the end of the bucket; splice it there and set _Bucket_hi to the
+                // new bucket inclusive end.
+                ++_Insert_before;
+                if (_Insert_before != _Inserted) { // avoid splice on element already in position
+                    _Mylist::_Scary_val::_Unchecked_splice(_Insert_before._Ptr, _Inserted._Ptr, _Next_inserted._Ptr);
+                }
+
+                _Bucket_hi = _Inserted;
+                continue;
+            }
+
+            // The insertion point isn't *_Bucket_hi, so search [_Bucket_lo, _Bucket_hi) for insertion point; we
+            // go backwards to maintain sortedness when !_Standard.
+            for (;;) {
+                if (_Bucket_lo == _Insert_before) {
+                    // There are no equivalent keys in the bucket, so insert it at the beginning.
+                    // Element can't be already in position here because:
+                    // * (for !_Standard) _Inserted_key < *_Insert_before or
+                    // * (for _Standard) _Inserted_key != *_Insert_before
+                    _Mylist::_Scary_val::_Unchecked_splice(_Insert_before._Ptr, _Inserted._Ptr, _Next_inserted._Ptr);
+                    _Bucket_lo = _Inserted;
+                    break;
+                }
+
+                if (!_Traitsobj(_Inserted_key, _Traits::_Kfn(*--_Insert_before))) {
+                    // Found insertion point, move the element here, bucket bounds are already okay.
+                    ++_Insert_before;
+                    // Element can't be already in position here because all elements we're inserting are after all
+                    // the elements already in buckets, and *_Insert_before isn't the highest element in the bucket.
+                    _Mylist::_Scary_val::_Unchecked_splice(_Insert_before._Ptr, _Inserted._Ptr, _Next_inserted._Ptr);
+                    break;
+                }
+            }
+        }
+
+        _Guard._Target = nullptr;
+
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+        _Stl_internal_check_container_invariants();
+#endif // _ENABLE_STL_INTERNAL_CHECK
+    }
+
+    float& _Max_bucket_size() noexcept {
+        return _Traitsobj._Get_max_bucket_size();
+    }
+
+    const float& _Max_bucket_size() const noexcept {
+        return _Traitsobj._Get_max_bucket_size();
+    }
+
+    _Alnode& _Getal() noexcept {
+        return _List._Getal();
+    }
+
+    const _Alnode& _Getal() const noexcept {
+        return _List._Getal();
+    }
+
+    struct _Multi_equal_check_result {
+        bool _Equal_possible = false;
+        _Unchecked_const_iterator _Subsequent_first{}; // only useful if _Equal_possible
+    };
+
+    _NODISCARD _Multi_equal_check_result _Multi_equal_check_equal_range(
+        const _Hash& _Right, _Unchecked_const_iterator _First1) const {
+        // check that an equal_range of elements starting with *_First1 are a permutation of the corresponding
+        // equal_range of elements in _Right
+        auto& _Keyval = _Traits::_Kfn(*_First1);
+        // find the start of the matching run in the other container
+        const size_t _Hashval   = _Right._Traitsobj(_Keyval);
+        const size_type _Bucket = _Hashval & _Right._Mask;
+        auto _First2            = _Right._Vec._Mypair._Myval2._Myfirst[_Bucket << 1];
+        if (_First2 == _Right._Unchecked_end()) {
+            // no matching bucket, therefore no matching run
+            return {};
+        }
+
+        const auto _Bucket_hi = _Right._Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1];
+        for (; _Right._Traitsobj(_Traits::_Kfn(*_First2), _Keyval); ++_First2) {
+            // find first matching element in _Right
+            if (_First2 == _Bucket_hi) {
+                return {};
+            }
+        }
+
+        _Unchecked_const_iterator _Left_stop_at;
+        if constexpr (_Traits::_Standard) {
+            _Left_stop_at = _Unchecked_end();
+        } else {
+            // check the first elements for equivalence when !_Standard
+            if (_Right._Traitsobj(_Keyval, _Traits::_Kfn(*_First2))) {
+                return {};
+            }
+
+            const size_t _LHashval   = _Traitsobj(_Keyval);
+            const size_type _LBucket = _LHashval & _Mask;
+            const auto _LBucket_hi   = _Vec._Mypair._Myval2._Myfirst[(_LBucket << 1) + 1];
+            _Left_stop_at            = _LBucket_hi;
+            ++_Left_stop_at;
+        }
+
+        // trim matching prefixes
+        while (*_First1 == *_First2) {
+            // the right equal_range ends at the end of the bucket or on the first nonequal element
+            bool _Right_range_end = _First2 == _Bucket_hi;
+            ++_First2;
+            if (!_Right_range_end) {
+                _Right_range_end = _Right._Traitsobj(_Keyval, _Traits::_Kfn(*_First2));
+            }
+
+            // the left equal_range ends at the end of the container or on the first nonequal element
+            ++_First1;
+            const bool _Left_range_end = _First1 == _Left_stop_at || _Traitsobj(_Keyval, _Traits::_Kfn(*_First1));
+
+            if (_Left_range_end && _Right_range_end) {
+                // the equal_ranges were completely equal
+                return {true, _First1};
+            }
+
+            if (_Left_range_end || _Right_range_end) {
+                // one equal_range is a prefix of the other; not equal
+                return {};
+            }
+        }
+
+        // found a mismatched element, find the end of the equal_ranges and dispatch to _Check_match_counts
+        auto _Last1 = _First1;
+        auto _Last2 = _First2;
+        for (;;) {
+            bool _Right_range_end = _Last2 == _Bucket_hi;
+            ++_Last2;
+            if (!_Right_range_end) {
+                _Right_range_end = _Right._Traitsobj(_Keyval, _Traits::_Kfn(*_Last2));
+            }
+
+            ++_Last1;
+            const bool _Left_range_end = _Last1 == _Left_stop_at || _Traitsobj(_Keyval, _Traits::_Kfn(*_Last1));
+
+            if (_Left_range_end && _Right_range_end) {
+                // equal_ranges had the same length, check for permutation
+                return {_Check_match_counts(_First1, _Last1, _First2, _Last2, equal_to<>{}), _Last1};
+            }
+
+            if (_Left_range_end || _Right_range_end) {
+                // different number of elements in the range, not a permutation
+                return {};
+            }
+        }
+    }
+
+    template <bool _Multi2 = _Traits::_Multi, enable_if_t<_Multi2, int> = 0>
+    _NODISCARD bool _Multi_equal(const _Hash& _Right) const {
+        static_assert(_Traits::_Multi, "This function only works with multi containers");
+        _STL_INTERNAL_CHECK(this->size() == _Right.size());
+        const auto _Last1 = _Unchecked_end();
+        auto _First1      = _Unchecked_begin();
+        while (_First1 != _Last1) {
+            const auto _Result = _Multi_equal_check_equal_range(_Right, _First1);
+            if (!_Result._Equal_possible) {
+                return false;
+            }
+
+            _First1 = _Result._Subsequent_first;
+        }
+
+        return true;
+    }
+
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+public:
+    void _Stl_internal_check_container_invariants() const noexcept {
+        const size_type _Vecsize = _Vec.size();
+        _STL_INTERNAL_CHECK(_Vec._Mypair._Myval2._Mylast == _Vec._Mypair._Myval2._Myend);
+        _STL_INTERNAL_CHECK(_Vecsize >= _Min_buckets * 2);
+        _STL_INTERNAL_CHECK(_Maxidx == (_Vecsize >> 1));
+        _STL_INTERNAL_CHECK(_Maxidx - 1 == _Mask);
+        _STL_INTERNAL_CHECK(_Maxidx >= _Min_load_factor_buckets(_List.size()));
+        // asserts that bucket count is a power of 2:
+        _STL_INTERNAL_CHECK((static_cast<size_type>(1) << _Floor_of_log_2(_Vecsize)) == _Vecsize);
+        _STL_INTERNAL_CHECK(load_factor() <= max_load_factor());
+        // In the test that counts number of allocator copies, avoid an extra rebind that would incorrectly count as
+        // a copy; otherwise, allow allocators that support only homogeneous compare.
+#ifdef _USE_HETEROGENEOUS_ALLOCATOR_COMPARE_IN_INTERNAL_CHECK
+        _STL_INTERNAL_CHECK(_List._Getal() == _Vec._Mypair._Get_first());
+#else
+        _STL_INTERNAL_CHECK(static_cast<_Aliter>(_List._Getal()) == _Vec._Mypair._Get_first());
+#endif
+#ifdef _STL_INTERNAL_CHECK_EXHAUSTIVE
+        size_type _Elements = 0;
+        const auto _End     = _Unchecked_end();
+        for (size_type _Bucket = 0; _Bucket < _Maxidx; ++_Bucket) {
+            _Unchecked_const_iterator _Where           = _Vec._Mypair._Myval2._Myfirst[_Bucket << 1];
+            const _Unchecked_const_iterator _Bucket_hi = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1];
+            if (_Where != _End) {
+                // check that the bucket is sorted for legacy hash_meow:
+                if constexpr (!_Traits::_Standard) {
+                    if (_Where != _Bucket_hi) {
+                        auto _SFirst = _Where;
+                        auto _SNext  = _Where;
+                        for (;;) {
+                            ++_SNext;
+                            if constexpr (_Traits::_Multi) {
+                                _STL_INTERNAL_CHECK(!_Traitsobj(_Traits::_Kfn(*_SNext), _Traits::_Kfn(*_SFirst)));
+                            } else {
+                                _STL_INTERNAL_CHECK(_Traitsobj(_Traits::_Kfn(*_SFirst), _Traits::_Kfn(*_SNext)));
+                            }
+
+                            if (_SNext == _Bucket_hi) {
+                                break;
+                            }
+
+                            _SFirst = _SNext;
+                        }
+                    }
+                }
+                // check that all the elements in the bucket belong in the bucket:
+                for (;;) {
+                    ++_Elements;
+                    _STL_INTERNAL_CHECK(bucket(_Traits::_Kfn(*_Where)) == _Bucket);
+                    if (_Where == _Bucket_hi) {
+                        break;
+                    }
+
+                    ++_Where;
+                }
+            }
+        }
+
+        _STL_INTERNAL_CHECK(_List.size() == _Elements);
+#endif // _STL_INTERNAL_CHECK_EXHAUSTIVE
+    }
+
+protected:
+#endif // _ENABLE_STL_INTERNAL_CHECK
+
+    _Traits _Traitsobj; // traits to customize behavior
+    _Mylist _List; // list of elements, must initialize before _Vec
+    _Hash_vec<_Aliter> _Vec; // "vector" of list iterators for buckets:
+                             // each bucket is 2 iterators denoting the closed range of elements in the bucket,
+                             // or both iterators set to _Unchecked_end() if the bucket is empty.
+    size_type _Mask; // the key mask
+    size_type _Maxidx; // current maximum key value, must be a power of 2
+};
+
+#if _HAS_CXX17
+// For constraining deduction guides (N4981 [unord.req.general]/248.3)
+#if _HAS_CXX23
+template <class _Hasher>
+concept _Hasher_for_container = !integral<_Hasher> && !_Allocator_for_container<_Hasher>;
+
+template <class _Hasher>
+using _Is_hasher = bool_constant<_Hasher_for_container<_Hasher>>;
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+template <class _Hasher>
+using _Is_hasher = negation<disjunction<is_integral<_Hasher>, _Is_allocator<_Hasher>>>;
+#endif // ^^^ !_HAS_CXX23 ^^^
+#endif // _HAS_CXX17
+
+template <class _Traits>
+_NODISCARD bool _Hash_equal(const _Hash<_Traits>& _Left, const _Hash<_Traits>& _Right) {
+    if (_Left.size() != _Right.size()) {
+        return false;
+    }
+
+    if constexpr (_Traits::_Multi) {
+        return _Left._Multi_equal(_Right);
+    } else {
+        for (const auto& _LVal : _Left) {
+            // look for element with equivalent key
+            const auto& _Keyval = _Traits::_Kfn(_LVal);
+            const auto _Next2   = _Right._Find_last(_Keyval, _Right._Traitsobj(_Keyval))._Duplicate;
+            if (!(static_cast<bool>(_Next2) && _LVal == _Next2->_Myval)) {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XHASH_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xiosbase b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xiosbase
new file mode 100644
index 0000000000000000000000000000000000000000..3d19d5969a252af3a50f1f6f3938b68bb6c68f8b
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xiosbase
@@ -0,0 +1,483 @@
+// xiosbase internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XIOSBASE_
+#define _XIOSBASE_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <share.h>
+#include <system_error>
+#include <xlocale>
+
+#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 _Dummy>
+class _Iosb { // define templatized bitmask/enumerated types, instantiate on demand
+public:
+    enum _Fmtflags { // constants for formatting options
+        _Fmtmask = 0xffff,
+        _Fmtzero = 0
+    };
+
+    static constexpr int skipws     = 0x0001;
+    static constexpr int unitbuf    = 0x0002;
+    static constexpr int uppercase  = 0x0004;
+    static constexpr int showbase   = 0x0008;
+    static constexpr int showpoint  = 0x0010;
+    static constexpr int showpos    = 0x0020;
+    static constexpr int left       = 0x0040;
+    static constexpr int right      = 0x0080;
+    static constexpr int internal   = 0x0100;
+    static constexpr int dec        = 0x0200;
+    static constexpr int oct        = 0x0400;
+    static constexpr int hex        = 0x0800;
+    static constexpr int scientific = 0x1000;
+    static constexpr int fixed      = 0x2000;
+
+    static constexpr int boolalpha   = 0x4000;
+    static constexpr int adjustfield = left | right | internal;
+    static constexpr int basefield   = dec | oct | hex;
+    static constexpr int floatfield  = scientific | fixed;
+
+    enum _Iostate { // constants for stream states
+        _Statmask = 0x17
+    };
+
+    static constexpr int goodbit = 0x0;
+    static constexpr int eofbit  = 0x1;
+    static constexpr int failbit = 0x2;
+    static constexpr int badbit  = 0x4;
+
+    static constexpr int in         = 0x01;
+    static constexpr int out        = 0x02;
+    static constexpr int ate        = 0x04;
+    static constexpr int app        = 0x08;
+    static constexpr int trunc      = 0x10;
+    static constexpr int binary     = 0x20;
+    static constexpr int _Nocreate  = 0x40;
+    static constexpr int _Noreplace = 0x80;
+#if _HAS_CXX23
+    static constexpr int noreplace = _Noreplace;
+#endif
+
+    static constexpr int beg = 0;
+    static constexpr int cur = 1;
+    static constexpr int end = 2;
+
+    static constexpr int _Default_open_prot = _SH_DENYNO; // constant for default file opening protection
+
+    // TRANSITION, ABI: These enums don't appear in the STL DLL's export surface, but MaxMPDCompat
+    // in the MSVC-internal build detects that they appear in the CompatibilityData baseline.
+    enum _Dummy_enum { _Dummy_enum_val = 1 };
+    enum _Openmode { _Openmask = 0xff };
+    enum _Seekdir { _Seekbeg, _Seekcur, _Seekend };
+    enum { _Openprot = _SH_DENYNO };
+};
+
+_EXPORT_STD extern "C++" class _CRTIMP2_PURE_IMPORT ios_base : public _Iosb<int> { // base class for ios
+public:
+    using fmtflags = int;
+    using iostate  = int;
+    using openmode = int;
+    using seekdir  = int;
+
+#if _HAS_OLD_IOSTREAMS_MEMBERS
+    using streamoff = _STD streamoff;
+    using streampos = _STD streampos;
+#endif // _HAS_OLD_IOSTREAMS_MEMBERS
+
+    enum event { // constants for ios events
+        erase_event,
+        imbue_event,
+        copyfmt_event
+    };
+
+    using event_callback = void(__CLRCALL_OR_CDECL*)(event, ios_base&, int);
+
+#if _HAS_OLD_IOSTREAMS_MEMBERS
+    using io_state  = unsigned int;
+    using open_mode = unsigned int;
+    using seek_dir  = unsigned int;
+#endif // _HAS_OLD_IOSTREAMS_MEMBERS
+
+    class failure : public system_error { // base of all iostreams exceptions
+    public:
+        explicit failure(const string& _Message, const error_code& _Errcode = _STD make_error_code(io_errc::stream))
+            : system_error(_Errcode, _Message) {} // construct with message
+
+        explicit failure(const char* _Message, const error_code& _Errcode = _STD make_error_code(io_errc::stream))
+            : system_error(_Errcode, _Message) {} // construct with message
+
+#if !_HAS_EXCEPTIONS
+    protected:
+        void _Doraise() const override { // report the exception
+            _RAISE(*this);
+        }
+#endif // !_HAS_EXCEPTIONS
+    };
+
+    class _CRTIMP2_PURE_IMPORT Init { // controller for standard-stream initialization
+    public:
+        __CLR_OR_THIS_CALL Init() { // initialize standard streams on first construction
+            _Init_ctor(this);
+        }
+
+        __CLR_OR_THIS_CALL ~Init() noexcept { // flush standard streams on last destruction
+            _Init_dtor(this);
+        }
+
+    private:
+        static void __cdecl _Init_ctor(Init*);
+        static void __cdecl _Init_dtor(Init*);
+
+        __PURE_APPDOMAIN_GLOBAL static int _Init_cnt; // net ctor count
+
+        static int& __cdecl _Init_cnt_func();
+    };
+
+    explicit __CLR_OR_THIS_CALL operator bool() const noexcept /* strengthened */ {
+        return !fail();
+    }
+
+    _NODISCARD bool __CLR_OR_THIS_CALL operator!() const noexcept /* strengthened */ {
+        return fail();
+    }
+
+    void __CLR_OR_THIS_CALL clear(iostate _State, bool _Reraise) { // set state, possibly reraise exception
+        _State &= _Statmask;
+        _Mystate             = _State;
+        const auto _Filtered = _State & _Except;
+        if (_Filtered) {
+            if (_Reraise) {
+                _RERAISE;
+            }
+
+            const char* _Msg;
+            if (_Filtered & ios_base::badbit) {
+                _Msg = "ios_base::badbit set";
+            } else if (_Filtered & ios_base::failbit) {
+                _Msg = "ios_base::failbit set";
+            } else {
+                _Msg = "ios_base::eofbit set";
+            }
+
+            _THROW(failure(_Msg));
+        }
+    }
+
+    void __CLR_OR_THIS_CALL clear(iostate _State = goodbit) { // set state to argument
+        clear(_State, false);
+    }
+
+#if _HAS_OLD_IOSTREAMS_MEMBERS
+    void __CLR_OR_THIS_CALL clear(io_state _State) { // set state to argument, old-style
+        clear(static_cast<iostate>(_State));
+    }
+#endif // _HAS_OLD_IOSTREAMS_MEMBERS
+
+    _NODISCARD iostate __CLR_OR_THIS_CALL rdstate() const noexcept /* strengthened */ {
+        return _Mystate;
+    }
+
+    void __CLR_OR_THIS_CALL setstate(
+        iostate _State, bool _Exreraise) { // merge in state argument, possibly reraise exception
+        clear(rdstate() | _State, _Exreraise);
+    }
+
+    void __CLR_OR_THIS_CALL setstate(iostate _State) { // merge in state argument
+        clear(rdstate() | _State, false);
+    }
+
+#if _HAS_OLD_IOSTREAMS_MEMBERS
+    void __CLR_OR_THIS_CALL setstate(io_state _State) { // merge in state argument, old style
+        setstate(static_cast<iostate>(_State));
+    }
+#endif // _HAS_OLD_IOSTREAMS_MEMBERS
+
+    _NODISCARD bool __CLR_OR_THIS_CALL good() const noexcept /* strengthened */ {
+        return rdstate() == ios_base::goodbit;
+    }
+
+    _NODISCARD bool __CLR_OR_THIS_CALL eof() const noexcept /* strengthened */ {
+        return rdstate() & ios_base::eofbit;
+    }
+
+    _NODISCARD bool __CLR_OR_THIS_CALL fail() const noexcept /* strengthened */ {
+        return rdstate() & (ios_base::badbit | ios_base::failbit);
+    }
+
+    _NODISCARD bool __CLR_OR_THIS_CALL bad() const noexcept /* strengthened */ {
+        return rdstate() & ios_base::badbit;
+    }
+
+    _NODISCARD iostate __CLR_OR_THIS_CALL exceptions() const noexcept /* strengthened */ {
+        return _Except;
+    }
+
+    void __CLR_OR_THIS_CALL exceptions(iostate _Newexcept) { // set exception mask to argument
+        _Except = _Newexcept & _Statmask;
+        clear(rdstate());
+    }
+
+#if _HAS_OLD_IOSTREAMS_MEMBERS
+    void __CLR_OR_THIS_CALL exceptions(io_state _State) { // set exception mask to argument, old style
+        exceptions(static_cast<iostate>(_State));
+    }
+#endif // _HAS_OLD_IOSTREAMS_MEMBERS
+
+    _NODISCARD fmtflags __CLR_OR_THIS_CALL flags() const noexcept /* strengthened */ {
+        return _Fmtfl;
+    }
+
+    fmtflags __CLR_OR_THIS_CALL flags(fmtflags _Newfmtflags) noexcept /* strengthened */ {
+        // set format flags to argument
+        const fmtflags _Oldfmtflags = _Fmtfl;
+        _Fmtfl                      = _Newfmtflags & _Fmtmask;
+        return _Oldfmtflags;
+    }
+
+    fmtflags __CLR_OR_THIS_CALL setf(fmtflags _Newfmtflags) noexcept /* strengthened */ {
+        // merge in format flags argument
+        const ios_base::fmtflags _Oldfmtflags = _Fmtfl;
+        _Fmtfl |= _Newfmtflags & _Fmtmask;
+        return _Oldfmtflags;
+    }
+
+    fmtflags __CLR_OR_THIS_CALL setf(fmtflags _Newfmtflags, fmtflags _Mask) noexcept /* strengthened */ {
+        // merge in format flags argument under mask argument
+        const ios_base::fmtflags _Oldfmtflags = _Fmtfl;
+        _Fmtfl                                = (_Oldfmtflags & ~_Mask) | (_Newfmtflags & _Mask & _Fmtmask);
+        return _Oldfmtflags;
+    }
+
+    void __CLR_OR_THIS_CALL unsetf(fmtflags _Mask) noexcept /* strengthened */ {
+        // clear format flags under mask argument
+        _Fmtfl &= ~_Mask;
+    }
+
+    _NODISCARD streamsize __CLR_OR_THIS_CALL precision() const noexcept /* strengthened */ {
+        return _Prec;
+    }
+
+    streamsize __CLR_OR_THIS_CALL precision(streamsize _Newprecision) noexcept /* strengthened */ {
+        // set precision to argument
+        const streamsize _Oldprecision = _Prec;
+        _Prec                          = _Newprecision;
+        return _Oldprecision;
+    }
+
+    _NODISCARD streamsize __CLR_OR_THIS_CALL width() const noexcept /* strengthened */ {
+        return _Wide;
+    }
+
+    streamsize __CLR_OR_THIS_CALL width(streamsize _Newwidth) noexcept /* strengthened */ {
+        // set width to argument
+        const streamsize _Oldwidth = _Wide;
+        _Wide                      = _Newwidth;
+        return _Oldwidth;
+    }
+
+    _NODISCARD locale __CLR_OR_THIS_CALL getloc() const noexcept /* strengthened */ { // get locale
+        return *_Ploc;
+    }
+
+    locale __CLR_OR_THIS_CALL imbue(const locale& _Loc) { // set locale to argument
+        locale _Oldlocale = *_Ploc;
+        *_Ploc            = _Loc;
+        _Callfns(imbue_event);
+        return _Oldlocale;
+    }
+
+    _NODISCARD static int __CLRCALL_OR_CDECL xalloc() { // allocate new iword/pword index
+        _BEGIN_LOCK(_LOCK_STREAM) // lock thread to ensure atomicity
+        return _Index++;
+        _END_LOCK()
+    }
+
+    _NODISCARD long& __CLR_OR_THIS_CALL iword(int _Idx) {
+        return _Findarr(_Idx)._Lo;
+    }
+
+    _NODISCARD void*& __CLR_OR_THIS_CALL pword(int _Idx) {
+        return _Findarr(_Idx)._Vp;
+    }
+
+    void __CLR_OR_THIS_CALL register_callback(event_callback _Pfn, int _Idx) {
+        // register event handler
+        _Calls = new _Fnarray(_Idx, _Pfn, _Calls);
+    }
+
+    ios_base& __CLR_OR_THIS_CALL copyfmt(const ios_base& _Other) { // copy format stuff
+        if (this != _STD addressof(_Other)) { // copy all but _Mystate
+            _Tidy();
+            *_Ploc          = *_Other._Ploc;
+            _Fmtfl          = _Other._Fmtfl;
+            _Prec           = _Other._Prec;
+            _Wide           = _Other._Wide;
+            _Iosarray* _Ptr = _Other._Arr;
+
+            for (_Arr = nullptr; _Ptr; _Ptr = _Ptr->_Next) {
+                if (_Ptr->_Lo != 0 || _Ptr->_Vp) { // copy over nonzero array values
+                    iword(_Ptr->_Index) = _Ptr->_Lo;
+                    pword(_Ptr->_Index) = _Ptr->_Vp;
+                }
+            }
+
+            for (_Fnarray* _Pfa = _Other._Calls; _Pfa; _Pfa = _Pfa->_Next) {
+                register_callback(_Pfa->_Pfn, _Pfa->_Index);
+            }
+
+            _Callfns(copyfmt_event); // call callbacks
+            exceptions(_Other._Except); // cause any throw at end
+        }
+        return *this;
+    }
+
+    static bool __CLRCALL_OR_CDECL sync_with_stdio(bool _Newsync = true) {
+        // set C/C++ synchronization flag from argument
+        _BEGIN_LOCK(_LOCK_STREAM) // lock thread to ensure atomicity
+        const bool _Oldsync = _Sync;
+        _Sync               = _Newsync;
+        return _Oldsync;
+        _END_LOCK()
+    }
+
+    void __CLR_OR_THIS_CALL swap(ios_base& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _STD swap(_Mystate, _Right._Mystate);
+            _STD swap(_Except, _Right._Except);
+            _STD swap(_Fmtfl, _Right._Fmtfl);
+            _STD swap(_Prec, _Right._Prec);
+            _STD swap(_Wide, _Right._Wide);
+
+            _STD swap(_Arr, _Right._Arr);
+            _STD swap(_Calls, _Right._Calls);
+            _STD swap(_Ploc, _Right._Ploc);
+        }
+    }
+
+    virtual __CLR_OR_THIS_CALL ~ios_base() noexcept {
+        _Ios_base_dtor(this);
+    }
+
+    static void __CLRCALL_PURE_OR_CDECL _Addstd(ios_base*); // add standard stream
+
+    size_t _Stdstr{0}; // if > 0 index of standard stream to suppress destruction
+
+protected:
+    __CLR_OR_THIS_CALL ios_base() {}
+
+    void __CLR_OR_THIS_CALL _Init() { // initialize a new ios_base
+        _Ploc   = nullptr;
+        _Stdstr = 0;
+        _Except = goodbit;
+        _Fmtfl  = skipws | dec;
+        _Prec   = 6;
+        _Wide   = 0;
+        _Arr    = nullptr;
+        _Calls  = nullptr;
+        clear(goodbit);
+        _Ploc = new locale;
+    }
+
+private:
+    struct _Iosarray : _Crt_new_delete { // list element for open-ended sparse array of longs/pointers
+    public:
+        __CLR_OR_THIS_CALL _Iosarray(int _Idx, _Iosarray* _Link)
+            : _Next(_Link), _Index(_Idx), _Lo(0), _Vp(nullptr) {} // construct node for index _Idx and link it in
+
+        _Iosarray* _Next; // pointer to next node
+        int _Index; // index of this node
+        long _Lo; // stored long value
+        void* _Vp; // stored pointer value
+    };
+
+    struct _Fnarray : _Crt_new_delete { // list element for open-ended sparse array of event handlers
+        __CLR_OR_THIS_CALL _Fnarray(int _Idx, event_callback _Pnew, _Fnarray* _Link)
+            : _Next(_Link), _Index(_Idx), _Pfn(_Pnew) {} // construct node for index _Idx and link it in
+
+        _Fnarray* _Next; // pointer to next node
+        int _Index; // index of this node
+        event_callback _Pfn; // pointer to event handler
+    };
+
+    void __CLR_OR_THIS_CALL _Callfns(event _Ev) { // call all event handlers, reporting event
+        for (_Fnarray* _Pfa = _Calls; _Pfa; _Pfa = _Pfa->_Next) {
+            (*_Pfa->_Pfn)(_Ev, *this, _Pfa->_Index);
+        }
+    }
+
+    _Iosarray& __CLR_OR_THIS_CALL _Findarr(int _Idx) { // locate or make a variable array element
+        _Iosarray* _Ptr1;
+        _Iosarray* _Ptr2;
+
+        for (_Ptr1 = _Arr, _Ptr2 = nullptr; _Ptr1; _Ptr1 = _Ptr1->_Next) {
+            if (_Ptr1->_Index == _Idx) {
+                return *_Ptr1; // found element, return it
+            } else if (!_Ptr2 && _Ptr1->_Lo == 0 && !_Ptr1->_Vp) {
+                _Ptr2 = _Ptr1; // found recycling candidate
+            }
+        }
+
+        if (_Ptr2) { // recycle existing element
+            _Ptr2->_Index = _Idx;
+            return *_Ptr2;
+        }
+
+        _Arr = new _Iosarray(_Idx, _Arr); // make a new element
+        return *_Arr;
+    }
+
+    void __CLR_OR_THIS_CALL _Tidy() noexcept { // discard storage for an ios_base
+        _Callfns(erase_event);
+        _Iosarray* _Ptr1;
+        _Iosarray* _Ptr2;
+
+        for (_Ptr1 = _Arr; _Ptr1; _Ptr1 = _Ptr2) { // delete array element
+            _Ptr2 = _Ptr1->_Next;
+            delete _Ptr1;
+        }
+        _Arr = nullptr;
+
+        _Fnarray* _Pfa1;
+        _Fnarray* _Pfa2;
+        for (_Pfa1 = _Calls; _Pfa1; _Pfa1 = _Pfa2) { // delete callback element
+            _Pfa2 = _Pfa1->_Next;
+            delete _Pfa1;
+        }
+        _Calls = nullptr;
+    }
+
+    iostate _Mystate{}; // stream state
+    iostate _Except{}; // exception mask
+    fmtflags _Fmtfl{}; // format flags
+    streamsize _Prec{}; // field precision
+    streamsize _Wide{}; // field width
+    _Iosarray* _Arr{nullptr}; // pointer to first node of long/pointer array
+    _Fnarray* _Calls{nullptr}; // pointer to first node of call list
+    locale* _Ploc{nullptr}; // pointer to locale
+
+    __PURE_APPDOMAIN_GLOBAL static int _Index;
+    __PURE_APPDOMAIN_GLOBAL static bool _Sync;
+
+    static void __CLRCALL_PURE_OR_CDECL _Ios_base_dtor(ios_base*);
+
+public:
+    ios_base(const ios_base&)            = delete;
+    ios_base& operator=(const ios_base&) = delete;
+};
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XIOSBASE_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xkeycheck.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xkeycheck.h
new file mode 100644
index 0000000000000000000000000000000000000000..24c0d0c15f272fb0e9b418da41dcd5a190e6c9c7
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xkeycheck.h
@@ -0,0 +1,589 @@
+// xkeycheck.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XKEYCHECK_H
+#define _XKEYCHECK_H
+
+// xkeycheck.h assumes that it's being included by yvals_core.h in a specific order.
+// Nothing else should include xkeycheck.h.
+
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !defined(_ALLOW_KEYWORD_MACROS) && !defined(__INTELLISENSE__)
+
+// clang-format off
+// #if defined($KEYWORD)
+// #define $KEYWORD EMIT WARNING C4005
+// #error The C++ Standard Library forbids macroizing the keyword "$KEYWORD". \
+// Enable warning C4005 to find the forbidden define.
+// #endif // $KEYWORD
+// clang-format on
+
+// *don't* check the "alternative token representations"
+
+// keywords:
+#if defined(alignas)
+#define alignas EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "alignas". \
+Enable warning C4005 to find the forbidden define.
+#endif // alignas
+
+#if defined(alignof)
+#define alignof EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "alignof". \
+Enable warning C4005 to find the forbidden define.
+#endif // alignof
+
+#if defined(asm)
+#define asm EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "asm". \
+Enable warning C4005 to find the forbidden define.
+#endif // asm
+
+#if defined(auto)
+#define auto EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "auto". \
+Enable warning C4005 to find the forbidden define.
+#endif // auto
+
+#if defined(bool)
+#define bool EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "bool". \
+Enable warning C4005 to find the forbidden define.
+#endif // bool
+
+#if defined(break)
+#define break EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "break". \
+Enable warning C4005 to find the forbidden define.
+#endif // break
+
+#if defined(case)
+#define case EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "case". \
+Enable warning C4005 to find the forbidden define.
+#endif // case
+
+#if defined(catch)
+#define catch EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "catch". \
+Enable warning C4005 to find the forbidden define.
+#endif // catch
+
+#if defined(char)
+#define char EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "char". \
+Enable warning C4005 to find the forbidden define.
+#endif // char
+
+#if defined(char8_t) && _HAS_CXX20
+#define char8_t EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "char8_t". \
+Enable warning C4005 to find the forbidden define.
+#endif // char8_t
+
+#if defined(char16_t)
+#define char16_t EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "char16_t". \
+Enable warning C4005 to find the forbidden define.
+#endif // char16_t
+
+#if defined(char32_t)
+#define char32_t EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "char32_t". \
+Enable warning C4005 to find the forbidden define.
+#endif // char32_t
+
+#if defined(class)
+#define class EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "class". \
+Enable warning C4005 to find the forbidden define.
+#endif // class
+
+#if defined(concept) && _HAS_CXX20
+#define concept EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "concept". \
+Enable warning C4005 to find the forbidden define.
+#endif // concept
+
+#if defined(const)
+#define const EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "const". \
+Enable warning C4005 to find the forbidden define.
+#endif // const
+
+#if defined(consteval) && _HAS_CXX20
+#define consteval EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "consteval". \
+Enable warning C4005 to find the forbidden define.
+#endif // consteval
+
+#if defined(constexpr)
+#define constexpr EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "constexpr". \
+Enable warning C4005 to find the forbidden define.
+#endif // constexpr
+
+#if defined(constinit) && _HAS_CXX20
+#define constinit EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "constinit". \
+Enable warning C4005 to find the forbidden define.
+#endif // constinit
+
+#if defined(const_cast)
+#define const_cast EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "const_cast". \
+Enable warning C4005 to find the forbidden define.
+#endif // const_cast
+
+#if defined(continue)
+#define continue EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "continue". \
+Enable warning C4005 to find the forbidden define.
+#endif // continue
+
+#if defined(co_await) && _HAS_CXX20
+#define co_await EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "co_await". \
+Enable warning C4005 to find the forbidden define.
+#endif // co_await
+
+#if defined(co_return) && _HAS_CXX20
+#define co_return EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "co_return". \
+Enable warning C4005 to find the forbidden define.
+#endif // co_return
+
+#if defined(co_yield) && _HAS_CXX20
+#define co_yield EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "co_yield". \
+Enable warning C4005 to find the forbidden define.
+#endif // co_yield
+
+#if defined(decltype)
+#define decltype EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "decltype". \
+Enable warning C4005 to find the forbidden define.
+#endif // decltype
+
+#if defined(default)
+#define default EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "default". \
+Enable warning C4005 to find the forbidden define.
+#endif // default
+
+#if defined(delete)
+#define delete EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "delete". \
+Enable warning C4005 to find the forbidden define.
+#endif // delete
+
+#if defined(do)
+#define do EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "do". \
+Enable warning C4005 to find the forbidden define.
+#endif // do
+
+#if defined(double)
+#define double EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "double". \
+Enable warning C4005 to find the forbidden define.
+#endif // double
+
+#if defined(dynamic_cast)
+#define dynamic_cast EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "dynamic_cast". \
+Enable warning C4005 to find the forbidden define.
+#endif // dynamic_cast
+
+#if defined(else)
+#define else EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "else". \
+Enable warning C4005 to find the forbidden define.
+#endif // else
+
+#if defined(enum)
+#define enum EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "enum". \
+Enable warning C4005 to find the forbidden define.
+#endif // enum
+
+#if defined(explicit)
+#define explicit EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "explicit". \
+Enable warning C4005 to find the forbidden define.
+#endif // explicit
+
+#if defined(export)
+#define export EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "export". \
+Enable warning C4005 to find the forbidden define.
+#endif // export
+
+#if defined(extern)
+#define extern EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "extern". \
+Enable warning C4005 to find the forbidden define.
+#endif // extern
+
+#if defined(false)
+#define false EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "false". \
+Enable warning C4005 to find the forbidden define.
+#endif // false
+
+#if defined(float)
+#define float EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "float". \
+Enable warning C4005 to find the forbidden define.
+#endif // float
+
+#if defined(for)
+#define for EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "for". \
+Enable warning C4005 to find the forbidden define.
+#endif // for
+
+#if defined(friend)
+#define friend EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "friend". \
+Enable warning C4005 to find the forbidden define.
+#endif // friend
+
+#if defined(goto)
+#define goto EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "goto". \
+Enable warning C4005 to find the forbidden define.
+#endif // goto
+
+#if defined(if)
+#define if EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "if". \
+Enable warning C4005 to find the forbidden define.
+#endif // if
+
+#if defined(inline)
+#define inline EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "inline". \
+Enable warning C4005 to find the forbidden define.
+#endif // inline
+
+#if defined(int)
+#define int EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "int". \
+Enable warning C4005 to find the forbidden define.
+#endif // int
+
+#if defined(long)
+#define long EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "long". \
+Enable warning C4005 to find the forbidden define.
+#endif // long
+
+#if defined(mutable)
+#define mutable EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "mutable". \
+Enable warning C4005 to find the forbidden define.
+#endif // mutable
+
+#if defined(namespace)
+#define namespace EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "namespace". \
+Enable warning C4005 to find the forbidden define.
+#endif // namespace
+
+#if defined(new) && defined(_ENFORCE_BAN_OF_MACRO_NEW)
+#define new EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "new", though macroized new is supported on this \
+implementation as a nonstandard extension. Enable warning C4005 to find the forbidden define, or re-enable the \
+extension by removing _ENFORCE_BAN_OF_MACRO_NEW.
+#endif // new
+
+#if defined(noexcept)
+#define noexcept EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "noexcept". \
+Enable warning C4005 to find the forbidden define.
+#endif // noexcept
+
+#if defined(nullptr)
+#define nullptr EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "nullptr". \
+Enable warning C4005 to find the forbidden define.
+#endif // nullptr
+
+#if defined(operator)
+#define operator EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "operator". \
+Enable warning C4005 to find the forbidden define.
+#endif // operator
+
+#if defined(private)
+#define private EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "private". \
+Enable warning C4005 to find the forbidden define.
+#endif // private
+
+#if defined(protected)
+#define protected EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "protected". \
+Enable warning C4005 to find the forbidden define.
+#endif // protected
+
+#if defined(public)
+#define public EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "public". \
+Enable warning C4005 to find the forbidden define.
+#endif // public
+
+#if defined(register)
+#define register EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "register". \
+Enable warning C4005 to find the forbidden define.
+#endif // register
+
+#if defined(reinterpret_cast)
+#define reinterpret_cast EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "reinterpret_cast". \
+Enable warning C4005 to find the forbidden define.
+#endif // reinterpret_cast
+
+#if defined(requires) && _HAS_CXX20
+#define requires EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "requires". \
+Enable warning C4005 to find the forbidden define.
+#endif // requires
+
+#if defined(return)
+#define return EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "return". \
+Enable warning C4005 to find the forbidden define.
+#endif // return
+
+#if defined(short)
+#define short EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "short". \
+Enable warning C4005 to find the forbidden define.
+#endif // short
+
+#if defined(signed)
+#define signed EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "signed". \
+Enable warning C4005 to find the forbidden define.
+#endif // signed
+
+#if defined(sizeof)
+#define sizeof EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "sizeof". \
+Enable warning C4005 to find the forbidden define.
+#endif // sizeof
+
+#if defined(static)
+#define static EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "static". \
+Enable warning C4005 to find the forbidden define.
+#endif // static
+
+#if defined(static_assert)
+#define static_assert EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "static_assert". \
+Enable warning C4005 to find the forbidden define.
+#endif // static_assert
+
+#if defined(static_cast)
+#define static_cast EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "static_cast". \
+Enable warning C4005 to find the forbidden define.
+#endif // static_cast
+
+#if defined(struct)
+#define struct EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "struct". \
+Enable warning C4005 to find the forbidden define.
+#endif // struct
+
+#if defined(switch)
+#define switch EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "switch". \
+Enable warning C4005 to find the forbidden define.
+#endif // switch
+
+#if defined(template)
+#define template EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "template". \
+Enable warning C4005 to find the forbidden define.
+#endif // template
+
+#if defined(this)
+#define this EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "this". \
+Enable warning C4005 to find the forbidden define.
+#endif // this
+
+#if defined(thread_local)
+#define thread_local EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "thread_local". \
+Enable warning C4005 to find the forbidden define.
+#endif // thread_local
+
+#if defined(throw)
+#define throw EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "throw". \
+Enable warning C4005 to find the forbidden define.
+#endif // throw
+
+#if defined(true)
+#define true EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "true". \
+Enable warning C4005 to find the forbidden define.
+#endif // true
+
+#if defined(try)
+#define try EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "try". \
+Enable warning C4005 to find the forbidden define.
+#endif // try
+
+#if defined(typedef)
+#define typedef EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "typedef". \
+Enable warning C4005 to find the forbidden define.
+#endif // typedef
+
+#if defined(typeid)
+#define typeid EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "typeid". \
+Enable warning C4005 to find the forbidden define.
+#endif // typeid
+
+#if defined(typename)
+#define typename EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "typename". \
+Enable warning C4005 to find the forbidden define.
+#endif // typename
+
+#if defined(union)
+#define union EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "union". \
+Enable warning C4005 to find the forbidden define.
+#endif // union
+
+#if defined(unsigned)
+#define unsigned EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "unsigned". \
+Enable warning C4005 to find the forbidden define.
+#endif // unsigned
+
+#if defined(using)
+#define using EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "using". \
+Enable warning C4005 to find the forbidden define.
+#endif // using
+
+#if defined(virtual)
+#define virtual EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "virtual". \
+Enable warning C4005 to find the forbidden define.
+#endif // virtual
+
+#if defined(void)
+#define void EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "void". \
+Enable warning C4005 to find the forbidden define.
+#endif // void
+
+#if defined(volatile)
+#define volatile EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "volatile". \
+Enable warning C4005 to find the forbidden define.
+#endif // volatile
+
+#if defined(wchar_t)
+#define wchar_t EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "wchar_t". \
+Enable warning C4005 to find the forbidden define.
+#endif // wchar_t
+
+#if defined(while)
+#define while EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "while". \
+Enable warning C4005 to find the forbidden define.
+#endif // while
+
+// contextual keywords (a.k.a. "identifiers with special meaning"):
+#if defined(final)
+#define final EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the contextual keyword "final". \
+Enable warning C4005 to find the forbidden define.
+#endif // final
+
+#if defined(import) && _HAS_CXX20
+#define import EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the contextual keyword "import". \
+Enable warning C4005 to find the forbidden define.
+#endif // import
+
+#if defined(module) && _HAS_CXX20
+#define module EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the contextual keyword "module". \
+Enable warning C4005 to find the forbidden define.
+#endif // module
+
+#if defined(override)
+#define override EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the contextual keyword "override". \
+Enable warning C4005 to find the forbidden define.
+#endif // override
+
+// attribute-tokens:
+#if defined(carries_dependency)
+#define carries_dependency EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the attribute-token "carries_dependency". \
+Enable warning C4005 to find the forbidden define.
+#endif // carries_dependency
+
+#if defined(deprecated)
+#define deprecated EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the attribute-token "deprecated". \
+Enable warning C4005 to find the forbidden define.
+#endif // deprecated
+
+#if defined(fallthrough) && _HAS_CXX17
+#define fallthrough EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the attribute-token "fallthrough". \
+Enable warning C4005 to find the forbidden define.
+#endif // fallthrough
+
+// not checking "likely" because it is commonly defined as a function-like macro
+
+#if defined(maybe_unused) && _HAS_CXX17
+#define maybe_unused EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the attribute-token "maybe_unused". \
+Enable warning C4005 to find the forbidden define.
+#endif // maybe_unused
+
+#if defined(nodiscard) // C++17 attribute-token, also enforced in C++14 mode
+#define nodiscard EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the attribute-token "nodiscard". \
+Enable warning C4005 to find the forbidden define.
+#endif // nodiscard
+
+#if defined(noreturn)
+#define noreturn EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the attribute-token "noreturn". \
+Enable warning C4005 to find the forbidden define.
+#endif // noreturn
+
+#if defined(no_unique_address) && _HAS_CXX20
+#define no_unique_address EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the attribute-token "no_unique_address". \
+Enable warning C4005 to find the forbidden define.
+#endif // no_unique_address
+
+// not checking "unlikely" because it is commonly defined as a function-like macro
+
+#endif // !defined(_ALLOW_KEYWORD_MACROS) && !defined(__INTELLISENSE__)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XKEYCHECK_H
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xlocale b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xlocale
new file mode 100644
index 0000000000000000000000000000000000000000..f1f84c8bc75acfa76a7bbf01f6d357a7e5c11568
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xlocale
@@ -0,0 +1,3354 @@
+// xlocale internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XLOCALE_
+#define _XLOCALE_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <climits>
+#include <cstring>
+#include <memory>
+#include <typeinfo>
+#include <xfacet>
+#include <xlocinfo>
+
+#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 _Dummy>
+class _Locbase {}; // TRANSITION, ABI, affects sizeof(locale)
+
+_EXPORT_STD template <class _Elem>
+class collate;
+
+extern "C++" struct _CRTIMP2_PURE_IMPORT _Crt_new_delete { // base class for marking allocations as CRT blocks
+#ifdef _DEBUG
+    void* __CLRCALL_OR_CDECL operator new(size_t _Size) { // replace operator new
+        void* _Ptr = operator new(_Size, nothrow);
+        if (!_Ptr) {
+            _Xbad_alloc();
+        }
+
+        return _Ptr;
+    }
+
+    void* __CLRCALL_OR_CDECL operator new(size_t _Size, const nothrow_t&) noexcept { // replace nothrow operator new
+        return _malloc_dbg(_Size > 0 ? _Size : 1, _CRT_BLOCK, __FILE__, __LINE__);
+    }
+
+    void __CLRCALL_OR_CDECL operator delete(void* _Ptr) noexcept { // replace operator delete
+        _CSTD free(_Ptr);
+    }
+
+    void __CLRCALL_OR_CDECL operator delete(void* _Ptr, const nothrow_t&) noexcept { // replace nothrow operator delete
+        operator delete(_Ptr);
+    }
+
+    void* __CLRCALL_OR_CDECL operator new(size_t, void* _Ptr) noexcept { // imitate True Placement New
+        return _Ptr;
+    }
+
+    void __CLRCALL_OR_CDECL operator delete(void*, void*) noexcept {} // imitate True Placement Delete
+#endif // _DEBUG
+};
+
+_EXPORT_STD extern "C++" class locale : public _Locbase<int>, public _Crt_new_delete {
+public:
+    using category = int;
+
+    static constexpr category collate  = _M_COLLATE;
+    static constexpr category ctype    = _M_CTYPE;
+    static constexpr category monetary = _M_MONETARY;
+    static constexpr category numeric  = _M_NUMERIC;
+    static constexpr category time     = _M_TIME;
+    static constexpr category messages = _M_MESSAGES;
+    static constexpr category all      = _M_ALL;
+    static constexpr category none     = 0;
+
+    class _CRTIMP2_PURE_IMPORT id { // identifier stamp, unique for each distinct kind of facet
+    public:
+        __CLR_OR_THIS_CALL id(size_t _Val = 0) : _Id(_Val) {}
+
+        id(const id&)            = delete;
+        id& operator=(const id&) = delete;
+
+        __CLR_OR_THIS_CALL operator size_t() { // get stamp, with lazy allocation
+            if (_Id == 0) { // still zero, allocate stamp
+                _BEGIN_LOCK(_LOCK_LOCALE)
+                if (_Id == 0) {
+                    _Id = static_cast<size_t>(++_Id_cnt);
+                }
+                _END_LOCK()
+            }
+            return _Id;
+        }
+
+    private:
+        size_t _Id; // the identifier stamp
+
+        __PURE_APPDOMAIN_GLOBAL static int _Id_cnt;
+    };
+
+    struct _Facet_guard;
+
+    class _CRTIMP2_PURE_IMPORT facet : public _Facet_base, public _Crt_new_delete {
+        // base class for all locale facets, performs reference counting
+    private:
+        friend _Facet_guard;
+
+    public:
+        static size_t __CLRCALL_OR_CDECL _Getcat(const facet** = nullptr, const locale* = nullptr) {
+            // get category value, or -1 if no corresponding C category
+            return static_cast<size_t>(-1);
+        }
+
+        void __CLR_OR_THIS_CALL _Incref() noexcept override { // increment use count
+            _MT_INCR(_Myrefs);
+        }
+
+        _Facet_base* __CLR_OR_THIS_CALL _Decref() noexcept override { // decrement use count
+            if (_MT_DECR(_Myrefs) == 0) {
+                return this;
+            }
+
+            return nullptr;
+        }
+
+    private:
+        _Atomic_counter_t _Myrefs; // the reference count
+
+    protected:
+        explicit __CLR_OR_THIS_CALL facet(size_t _Initrefs = 0) noexcept // strengthened
+            : _Myrefs(static_cast<_Atomic_counter_t>(_Initrefs)) // non-atomic initialization
+        {}
+
+        __CLR_OR_THIS_CALL ~facet() noexcept override {}
+
+    public:
+        __CLR_OR_THIS_CALL facet(const facet&)            = delete;
+        facet& __CLR_OR_THIS_CALL operator=(const facet&) = delete;
+    };
+
+    struct _NODISCARD _Facet_guard {
+        facet* _Target;
+        ~_Facet_guard() {
+            if (_Target) {
+                delete _Target->_Decref();
+            }
+        }
+    };
+
+    class _CRTIMP2_PURE_IMPORT _Locimp : public facet { // reference-counted actual implementation of a locale
+    protected:
+        __CLR_OR_THIS_CALL ~_Locimp() noexcept {
+            _Locimp_dtor(this);
+        }
+
+    private:
+        static _Locimp* __CLRCALL_PURE_OR_CDECL _New_Locimp(bool _Transparent = false);
+        static _Locimp* __CLRCALL_PURE_OR_CDECL _New_Locimp(const _Locimp& _Right);
+
+        static void __CLRCALL_PURE_OR_CDECL _Locimp_dtor(_Locimp*);
+        static void __CLRCALL_PURE_OR_CDECL _Locimp_Addfac(_Locimp*, facet*, size_t); // add a facet
+        static void __CLRCALL_PURE_OR_CDECL _Locimp_ctor(_Locimp*, const _Locimp&);
+
+        friend locale;
+
+        __CLR_OR_THIS_CALL _Locimp(bool _Transparent)
+            : locale::facet(1), _Facetvec(nullptr), _Facetcount(0), _Catmask(none), _Xparent(_Transparent), _Name("*") {
+        }
+
+        __CLR_OR_THIS_CALL _Locimp(const _Locimp& _Right)
+            : locale::facet(1), _Facetvec(nullptr), _Facetcount(_Right._Facetcount), _Catmask(_Right._Catmask),
+              _Xparent(_Right._Xparent), _Name(_Right._Name.c_str()) {
+            _Locimp_ctor(this, _Right);
+        }
+
+        void __CLR_OR_THIS_CALL _Addfac(facet* _Pfacet, size_t _Id) { // add a facet
+            _Locimp_Addfac(this, _Pfacet, _Id);
+        }
+
+        static _Locimp* __CLRCALL_OR_CDECL _Makeloc(
+            const _Locinfo&, category, _Locimp*, const locale*); // make essential facets
+
+        static void __CLRCALL_OR_CDECL _Makewloc(
+            const _Locinfo&, category, _Locimp*, const locale*); // make wchar_t facets
+
+#if defined(_NATIVE_WCHAR_T_DEFINED) && !_ENFORCE_FACET_SPECIALIZATIONS
+        static void __CLRCALL_OR_CDECL _Makeushloc(
+            const _Locinfo&, category, _Locimp*, const locale*); // make ushort facets
+#endif // defined(_NATIVE_WCHAR_T_DEFINED) && !_ENFORCE_FACET_SPECIALIZATIONS
+
+        static void __CLRCALL_OR_CDECL _Makexloc(
+            const _Locinfo&, category, _Locimp*, const locale*); // make remaining facets
+
+        facet** _Facetvec; // pointer to vector of facets
+        size_t _Facetcount; // size of vector of facets
+        category _Catmask; // mask describing implemented categories
+        bool _Xparent; // true if locale is transparent
+        _Yarn<char> _Name; // locale name, or "*" if not known
+
+        __PURE_APPDOMAIN_GLOBAL static _Locimp* _Clocptr;
+
+    public:
+        _Locimp& __CLR_OR_THIS_CALL operator=(const _Locimp&) = delete;
+    };
+
+    template <class _Elem, class _Traits, class _Alloc>
+    bool operator()(
+        const basic_string<_Elem, _Traits, _Alloc>& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) const {
+        // compare _Left and _Right strings using collate facet in locale
+        const auto& _Coll_fac = _STD use_facet<_STD collate<_Elem>>(*this);
+
+        const _Elem* const _Left_data  = _Left.data();
+        const _Elem* const _Right_data = _Right.data();
+        return _Coll_fac.compare(_Left_data, _Left_data + _Left.size(), _Right_data, _Right_data + _Right.size()) < 0;
+    }
+
+    template <class _Facet>
+    locale combine(const locale& _Loc) const { // combine two locales
+        _Facet* _Facptr;
+
+        _TRY_BEGIN
+        _Facptr = const_cast<_Facet*>(_STD addressof(_STD use_facet<_Facet>(_Loc)));
+        _CATCH_ALL
+        _Xruntime_error("locale::combine facet missing");
+        _CATCH_END
+
+        _Locimp* _Newimp = _Locimp::_New_Locimp(*_Ptr);
+        _Newimp->_Addfac(_Facptr, _Facet::id);
+        _Newimp->_Catmask = none;
+        _Newimp->_Name    = "*";
+        return locale{_Secret_locale_construct_tag{}, _Newimp};
+    }
+
+    template <class _Facet>
+    locale(const locale& _Loc, const _Facet* _Facptr) : _Ptr(_Locimp::_New_Locimp(*_Loc._Ptr)) {
+        if (_Facptr) { // replace facet
+            _Ptr->_Addfac(const_cast<_Facet*>(_Facptr), _Facet::id);
+            _Ptr->_Catmask = none;
+            _Ptr->_Name    = "*";
+        }
+    }
+
+#pragma warning(push)
+#pragma warning(disable : 26495) // Variable 'std::locale::_Ptr' is uninitialized.
+                                 // Always initialize a member variable (type.6).
+
+    // We must not explicitly initialize _Ptr here; we rely on it maintaining the value
+    // previously created in its storage. To be precise:
+    // In locale0.cpp, locale::_Init() uses True Placement New at classic_locale's address,
+    // and classic_locale is constructed from the _Noinit enumerator of type _Uninitialized.
+    // The sequencing is highly unusual; the True Placement New happens before the _Uninitialized construction,
+    // so while _Ptr here formally has indeterminate value, we expect it to actually keep the previous value.
+    locale(_Uninitialized) {} // defer construction
+#pragma warning(pop)
+
+    locale(const locale& _Right) noexcept : _Ptr(_Right._Ptr) {
+        _Ptr->_Incref();
+    }
+
+    locale() noexcept : _Ptr(_Init(true)) {}
+
+#if !defined(MRTDLL) || !defined(_CRTBLD)
+    locale(const locale& _Loc, const locale& _Other, category _Cat) : _Ptr(_Locimp::_New_Locimp(*_Loc._Ptr)) {
+        // construct a locale by copying named facets
+        if (_Cat != none) { // worth adding, do it
+            _STL_ASSERT((_Cat & all) == _Cat, "the bitmask value specifying category must be valid");
+            _Facet_guard _Guard{_Ptr};
+            _BEGIN_LOCINFO(_Lobj)
+            _Locimp::_Makeloc(_Lobj, _Cat, _Ptr, &_Other);
+            _Lobj._Addcats(_Loc._Ptr->_Catmask, _Loc.name().c_str());
+            _Lobj._Addcats(_Other._Ptr->_Catmask, _Other.name().c_str());
+            _Ptr->_Catmask = _Loc._Ptr->_Catmask | _Other._Ptr->_Catmask;
+            _Ptr->_Name    = _Lobj._Getname();
+            _END_LOCINFO()
+            _Guard._Target = nullptr;
+        }
+    }
+
+private:
+    void _Construct(const string& _Str, category _Cat) {
+        _STL_ASSERT((_Cat & all) == _Cat, "the bitmask value specifying category must be valid");
+        // construct a locale with named facets
+        bool _Bad = false;
+        _Init();
+        if (_Cat != none) { // worth adding, do it
+            _Facet_guard _Guard{_Ptr};
+            _BEGIN_LOCINFO(_Lobj(_Cat, _Str.c_str()))
+            if (_Badname(_Lobj)) {
+                _Bad = true;
+            } else { // name okay, build the locale
+                _Locimp::_Makeloc(_Lobj, _Cat, _Ptr, nullptr);
+                _Ptr->_Catmask = _Cat;
+                _Ptr->_Name    = _Str.c_str();
+            }
+            _END_LOCINFO()
+            _Guard._Target = nullptr;
+        }
+
+        if (_Bad) { // Don't throw within _BEGIN_LOCINFO if we can avoid it
+            delete _Ptr->_Decref();
+            _Xruntime_error("bad locale name");
+        }
+    }
+
+public:
+    explicit locale(const char* _Locname, category _Cat = all) : _Ptr(_Locimp::_New_Locimp()) {
+        // construct a locale with named facets
+        // _Locname might have been returned from setlocale().
+        // Therefore, _Construct() takes const string&.
+        if (_Locname) {
+            _Construct(_Locname, _Cat);
+            return;
+        }
+
+        _Xruntime_error("bad locale name");
+    }
+
+    locale(const locale& _Loc, const char* _Locname, category _Cat) : _Ptr(_Locimp::_New_Locimp(*_Loc._Ptr)) {
+        // construct a locale by copying, replacing named facets
+        // _Locname might have been returned from setlocale().
+        // Therefore, _Construct() takes const string&.
+        if (_Locname) {
+            _Construct(_Locname, _Cat);
+            return;
+        }
+
+        _Xruntime_error("bad locale name");
+    }
+
+    explicit locale(const string& _Str, category _Cat = all) : _Ptr(_Locimp::_New_Locimp()) {
+        // construct a locale with named facets
+        _Construct(_Str, _Cat);
+    }
+
+    locale(const locale& _Loc, const string& _Str, category _Cat) : _Ptr(_Locimp::_New_Locimp(*_Loc._Ptr)) {
+        // construct a locale by copying, replacing named facets
+        _Construct(_Str, _Cat);
+    }
+#endif // !MRTDLL || !_CRTBLD
+
+    ~locale() noexcept {
+        if (_Ptr) {
+            delete _Ptr->_Decref();
+        }
+    }
+
+    const locale& operator=(const locale& _Right) noexcept {
+        if (_Ptr != _Right._Ptr) { // different implementation, point at new one
+            delete _Ptr->_Decref();
+            _Ptr = _Right._Ptr;
+            _Ptr->_Incref();
+        }
+        return *this;
+    }
+
+    string name() const {
+        return _Ptr ? _Ptr->_Name.c_str() : string{};
+    }
+
+    _Ret_z_ const char* _C_str() const noexcept {
+        return _Ptr ? _Ptr->_Name.c_str() : "";
+    }
+
+    const facet* _Getfacet(size_t _Id) const { // look up a facet in locale object
+        const facet* _Facptr = _Id < _Ptr->_Facetcount ? _Ptr->_Facetvec[_Id] : nullptr; // null if id off end
+        if (_Facptr || !_Ptr->_Xparent) {
+            return _Facptr; // found facet or not transparent
+        }
+
+        // look in current locale
+        locale::_Locimp* _Ptr0 = _Getgloballocale();
+        if (_Id < _Ptr0->_Facetcount) {
+            return _Ptr0->_Facetvec[_Id]; // get from current locale
+        }
+
+        return nullptr; // no entry in current locale
+    }
+
+    _NODISCARD bool operator==(const locale& _Loc) const noexcept /* strengthened */ { // compare locales for equality
+        return _Ptr == _Loc._Ptr || (_CSTD strcmp(_C_str(), "*") != 0 && _CSTD strcmp(_C_str(), _Loc._C_str()) == 0);
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD bool operator!=(const locale& _Right) const noexcept /* strengthened */ {
+        return !(*this == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    static _MRTIMP2_PURE const locale& __CLRCALL_PURE_OR_CDECL classic(); // classic "C" locale
+
+    static _MRTIMP2_PURE locale __CLRCALL_PURE_OR_CDECL global(const locale&); // current locale
+
+    static _MRTIMP2_PURE locale __CLRCALL_PURE_OR_CDECL empty(); // empty (transparent) locale
+
+private:
+    struct _Secret_locale_construct_tag {
+        explicit _Secret_locale_construct_tag() = default;
+    };
+
+    explicit locale(_Secret_locale_construct_tag, _Locimp* _Ptrimp) : _Ptr(_Ptrimp) {}
+
+    static _MRTIMP2_PURE _Locimp* __CLRCALL_PURE_OR_CDECL _Init(bool _Do_incref = false); // initialize locale
+    static _MRTIMP2_PURE _Locimp* __CLRCALL_PURE_OR_CDECL _Getgloballocale();
+    static _MRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Setgloballocale(void*);
+
+    bool _Badname(const _Locinfo& _Lobj) { // test if name is "*"
+        return _CSTD strcmp(_Lobj._Getname(), "*") == 0;
+    }
+
+    _Locimp* _Ptr; // pointer to locale implementation object
+};
+
+template <class _Facet>
+struct _Facetptr { // store pointer to lazy facet for use_facet
+    __PURE_APPDOMAIN_GLOBAL static const locale::facet* _Psave;
+};
+
+template <class _Facet>
+__PURE_APPDOMAIN_GLOBAL const locale::facet* _Facetptr<_Facet>::_Psave = nullptr;
+
+_EXPORT_STD template <class _Facet>
+const _Facet& __CRTDECL use_facet(const locale& _Loc) { // get facet reference from locale
+    _BEGIN_LOCK(_LOCK_LOCALE) // the thread lock, make get atomic
+    const locale::facet* _Psave = _Facetptr<_Facet>::_Psave; // static pointer to lazy facet
+
+    const size_t _Id         = _Facet::id;
+    const locale::facet* _Pf = _Loc._Getfacet(_Id);
+
+    if (!_Pf) {
+        if (_Psave) {
+            _Pf = _Psave; // lazy facet already allocated
+        } else if (_Facet::_Getcat(&_Psave, &_Loc) == static_cast<size_t>(-1)) {
+#if _HAS_EXCEPTIONS
+            _Throw_bad_cast(); // lazy disallowed
+#else
+            _CSTD abort(); // lazy disallowed
+#endif
+        } else { // queue up lazy facet for destruction
+            auto _Pfmod = const_cast<locale::facet*>(_Psave);
+            unique_ptr<_Facet_base> _Psave_guard(static_cast<_Facet_base*>(_Pfmod));
+
+#if defined(_M_CEE)
+            _Facet_Register_m(_Pfmod);
+#else // ^^^ defined(_M_CEE) / !defined(_M_CEE) vvv
+            _Facet_Register(_Pfmod);
+#endif // ^^^ !defined(_M_CEE) ^^^
+
+            _Pfmod->_Incref();
+            _Facetptr<_Facet>::_Psave = _Psave;
+            _Pf                       = _Psave;
+
+            (void) _Psave_guard.release();
+        }
+    }
+
+    return static_cast<const _Facet&>(*_Pf); // should be dynamic_cast
+    _END_LOCK()
+} // end of use_facet body
+
+template <class _Elem>
+char __CRTDECL _Maklocbyte(_Elem _Char, const _Locinfo::_Cvtvec&) {
+    // convert _Elem to char using _Cvtvec
+    return static_cast<char>(static_cast<unsigned char>(_Char));
+}
+
+template <>
+inline char __CRTDECL _Maklocbyte(wchar_t _Char, const _Locinfo::_Cvtvec& _Cvt) {
+    // convert wchar_t to char using _Cvtvec
+    char _Byte       = '\0';
+    mbstate_t _Mbst1 = {};
+    _Wcrtomb(&_Byte, _Char, &_Mbst1, &_Cvt);
+    return _Byte;
+}
+
+#if defined(_NATIVE_WCHAR_T_DEFINED) && !_ENFORCE_FACET_SPECIALIZATIONS
+template <>
+inline char __CRTDECL _Maklocbyte(unsigned short _Char, const _Locinfo::_Cvtvec& _Cvt) {
+    // convert unsigned short to char using _Cvtvec
+    char _Byte       = '\0';
+    mbstate_t _Mbst1 = {};
+    _Wcrtomb(&_Byte, static_cast<wchar_t>(_Char), &_Mbst1, &_Cvt);
+    return _Byte;
+}
+#endif // defined(_NATIVE_WCHAR_T_DEFINED) && !_ENFORCE_FACET_SPECIALIZATIONS
+
+template <class _Elem>
+_Elem __CRTDECL _Maklocchr(char _Byte, _Elem*, const _Locinfo::_Cvtvec&) {
+    // convert char to _Elem using _Cvtvec
+    return static_cast<_Elem>(static_cast<unsigned char>(_Byte));
+}
+
+template <>
+inline wchar_t __CRTDECL _Maklocchr(char _Byte, wchar_t*, const _Locinfo::_Cvtvec& _Cvt) {
+    // convert char to wchar_t using _Cvtvec
+    wchar_t _Wc      = L'\0';
+    mbstate_t _Mbst1 = {};
+    _Mbrtowc(&_Wc, &_Byte, 1, &_Mbst1, &_Cvt);
+    return _Wc;
+}
+
+#if defined(_NATIVE_WCHAR_T_DEFINED) && !_ENFORCE_FACET_SPECIALIZATIONS
+template <>
+inline unsigned short __CRTDECL _Maklocchr(char _Byte, unsigned short*, const _Locinfo::_Cvtvec& _Cvt) {
+    // convert char to unsigned short using _Cvtvec
+    unsigned short _Wc = 0;
+    mbstate_t _Mbst1   = {};
+    _Mbrtowc(reinterpret_cast<wchar_t*>(&_Wc), &_Byte, 1, &_Mbst1, &_Cvt);
+    return _Wc;
+}
+#endif // defined(_NATIVE_WCHAR_T_DEFINED) && !_ENFORCE_FACET_SPECIALIZATIONS
+
+template <class _Elem>
+_Elem* __CRTDECL _Maklocstr(const char* _Ptr, _Elem*, const _Locinfo::_Cvtvec&) {
+    // convert C string to _Elem sequence using _Cvtvec
+    size_t _Count = _CSTD strlen(_Ptr) + 1;
+
+    _Elem* _Ptrdest = static_cast<_Elem*>(_calloc_dbg(_Count, sizeof(_Elem), _CRT_BLOCK, __FILE__, __LINE__));
+
+    if (!_Ptrdest) {
+        _Xbad_alloc();
+    }
+
+    for (_Elem* _Ptrnext = _Ptrdest; 0 < _Count; --_Count, ++_Ptrnext, ++_Ptr) {
+        *_Ptrnext = static_cast<_Elem>(static_cast<unsigned char>(*_Ptr));
+    }
+
+    return _Ptrdest;
+}
+
+template <>
+inline wchar_t* __CRTDECL _Maklocstr(const char* _Ptr, wchar_t*, const _Locinfo::_Cvtvec& _Cvt) {
+    // convert C string to wchar_t sequence using _Cvtvec
+    size_t _Count;
+    size_t _Count1;
+    size_t _Wchars;
+    const char* _Ptr1;
+    int _Bytes;
+    wchar_t _Wc;
+    mbstate_t _Mbst1 = {};
+
+    _Count1 = _CSTD strlen(_Ptr) + 1;
+    for (_Count = _Count1, _Wchars = 0, _Ptr1 = _Ptr; 0 < _Count; _Count -= _Bytes, _Ptr1 += _Bytes, ++_Wchars) {
+        if ((_Bytes = _Mbrtowc(&_Wc, _Ptr1, _Count, &_Mbst1, &_Cvt)) <= 0) {
+            break;
+        }
+    }
+
+    ++_Wchars; // count terminating nul
+
+    wchar_t* _Ptrdest = static_cast<wchar_t*>(_calloc_dbg(_Wchars, sizeof(wchar_t), _CRT_BLOCK, __FILE__, __LINE__));
+
+    if (!_Ptrdest) {
+        _Xbad_alloc();
+    }
+
+    wchar_t* _Ptrnext = _Ptrdest;
+    mbstate_t _Mbst2  = {};
+
+    for (; 0 < _Wchars; _Count -= _Bytes, _Ptr += _Bytes, --_Wchars, ++_Ptrnext) {
+        if ((_Bytes = _Mbrtowc(_Ptrnext, _Ptr, _Count1, &_Mbst2, &_Cvt)) <= 0) {
+            break;
+        }
+    }
+
+    *_Ptrnext = L'\0';
+
+    return _Ptrdest;
+}
+
+#if defined(_NATIVE_WCHAR_T_DEFINED) && !_ENFORCE_FACET_SPECIALIZATIONS
+template <>
+inline unsigned short* __CRTDECL _Maklocstr(const char* _Ptr, unsigned short*, const _Locinfo::_Cvtvec& _Cvt) {
+    // convert C string to unsigned short sequence using _Cvtvec
+    size_t _Count;
+    size_t _Count1;
+    size_t _Wchars;
+    const char* _Ptr1;
+    int _Bytes;
+    unsigned short _Wc;
+    mbstate_t _Mbst1 = {};
+
+    _Count1 = _CSTD strlen(_Ptr) + 1;
+    for (_Count = _Count1, _Wchars = 0, _Ptr1 = _Ptr; 0 < _Count; _Count -= _Bytes, _Ptr1 += _Bytes, ++_Wchars) {
+        if ((_Bytes = _Mbrtowc(reinterpret_cast<wchar_t*>(&_Wc), _Ptr1, _Count, &_Mbst1, &_Cvt)) <= 0) {
+            break;
+        }
+    }
+
+    ++_Wchars; // count terminating nul
+
+    wchar_t* _Ptrdest = static_cast<wchar_t*>(_calloc_dbg(_Wchars, sizeof(wchar_t), _CRT_BLOCK, __FILE__, __LINE__));
+
+    if (!_Ptrdest) {
+        _Xbad_alloc();
+    }
+
+    wchar_t* _Ptrnext = _Ptrdest;
+    mbstate_t _Mbst2  = {};
+    for (; 0 < _Wchars; _Count -= _Bytes, _Ptr += _Bytes, --_Wchars, ++_Ptrnext) {
+        if ((_Bytes = _Mbrtowc(_Ptrnext, _Ptr, _Count1, &_Mbst2, &_Cvt)) <= 0) {
+            break;
+        }
+    }
+
+    *_Ptrnext = L'\0';
+    return reinterpret_cast<unsigned short*>(_Ptrdest);
+}
+#endif // defined(_NATIVE_WCHAR_T_DEFINED) && !_ENFORCE_FACET_SPECIALIZATIONS
+
+_EXPORT_STD extern "C++" class _CRTIMP2_PURE_IMPORT codecvt_base // base class for codecvt
+    : public locale::facet // TRANSITION, ABI, shouldn't be derived from locale::facet
+{
+public:
+    enum { // constants for different parse states
+        ok,
+        partial,
+        error,
+        noconv
+    };
+    using result = int;
+
+    __CLR_OR_THIS_CALL codecvt_base(size_t _Refs = 0) noexcept // strengthened
+        : locale::facet(_Refs) {}
+
+    bool __CLR_OR_THIS_CALL always_noconv() const noexcept {
+        // return true if conversions never change input (from codecvt)
+        return do_always_noconv();
+    }
+
+    int __CLR_OR_THIS_CALL max_length() const noexcept {
+        // return maximum length required for a conversion (from codecvt)
+        return do_max_length();
+    }
+
+    int __CLR_OR_THIS_CALL encoding() const noexcept {
+        return do_encoding();
+    }
+
+    __CLR_OR_THIS_CALL ~codecvt_base() noexcept {}
+
+protected:
+    virtual bool __CLR_OR_THIS_CALL do_always_noconv() const noexcept {
+        // return true if conversions never change input (from codecvt)
+        return false;
+    }
+
+    virtual int __CLR_OR_THIS_CALL do_max_length() const noexcept {
+        // return maximum length required for a conversion (from codecvt)
+        return 1;
+    }
+
+    virtual int __CLR_OR_THIS_CALL do_encoding() const noexcept {
+        return 1; // -1 ==> state dependent, 0 ==> varying length
+    }
+};
+
+template <class _Ty>
+constexpr bool _Is_one_byte_char_like_v = _Is_any_of_v<remove_cv_t<_Ty>, signed char, unsigned char,
+#ifdef __cpp_lib_byte
+    byte,
+#endif // defined(__cpp_lib_byte)
+#ifdef __cpp_char8_t
+    char8_t,
+#endif // defined(__cpp_char8_t)
+    char>;
+
+template <class _Elem, class _Byte>
+constexpr bool _Is_codecvt_do_always_noconv_v =
+    is_same_v<_Byte, _Elem> || (_Is_one_byte_char_like_v<_Byte> && _Is_one_byte_char_like_v<_Elem>);
+
+_EXPORT_STD extern "C++" template <class _Elem, class _Byte, class _Statype>
+class codecvt : public codecvt_base { // facet for converting between _Elem and _Byte sequences
+public:
+    // Explicitly specialized below:
+    // codecvt<wchar_t, char, mbstate_t>
+    // codecvt<unsigned short, char, mbstate_t> (extension)
+    // codecvt<char16_t, char, mbstate_t>
+    // codecvt<char32_t, char, mbstate_t>
+    // codecvt<char16_t, char8_t, mbstate_t>
+    // codecvt<char32_t, char8_t, mbstate_t>
+
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || is_same_v<codecvt, codecvt<char, char, mbstate_t>>,
+        _FACET_SPECIALIZATION_MESSAGE);
+
+    using intern_type = _Elem;
+    using extern_type = _Byte;
+    using state_type  = _Statype;
+
+    result __CLR_OR_THIS_CALL in(_Statype& _State, const _Byte* _First1, const _Byte* _Last1, const _Byte*& _Mid1,
+        _Elem* _First2, _Elem* _Last2, _Elem*& _Mid2) const { // convert bytes [_First1, _Last1) to [_First2, _Last2)
+        return do_in(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result __CLR_OR_THIS_CALL out(_Statype& _State, const _Elem* _First1, const _Elem* _Last1, const _Elem*& _Mid1,
+        _Byte* _First2, _Byte* _Last2, _Byte*& _Mid2) const { // convert [_First1, _Last1) to bytes [_First2, _Last2)
+        return do_out(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result __CLR_OR_THIS_CALL unshift(_Statype& _State, _Byte* _First2, _Byte* _Last2, _Byte*& _Mid2) const {
+        // generate bytes to return to default shift state
+        return do_unshift(_State, _First2, _Last2, _Mid2);
+    }
+
+    int __CLR_OR_THIS_CALL length(_Statype& _State, const _Byte* _First1, const _Byte* _Last1, size_t _Count) const {
+        // return p - _First1, for the largest value p in [_First1, _Last1] such that [_First1, p) successfully
+        // converts to at most _Count _Elems
+        return do_length(_State, _First1, _Last1, _Count);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id; // unique facet id
+
+    explicit __CLR_OR_THIS_CALL codecvt(size_t _Refs = 0) : codecvt_base(_Refs) {
+        _Init(_Locinfo());
+    }
+
+    explicit __CLR_OR_THIS_CALL codecvt(const _Locinfo& _Lobj, size_t _Refs = 0) : codecvt_base(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new codecvt(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_CTYPE;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt() noexcept override {}
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo&) {} // initialize from _Locinfo object
+
+    bool __CLR_OR_THIS_CALL do_always_noconv() const noexcept override {
+        // return true if conversions never change input (from codecvt)
+        return _Is_codecvt_do_always_noconv_v<_Elem, _Byte>;
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_in(_Statype&, const _Byte* _First1, const _Byte* _Last1, const _Byte*& _Mid1,
+        _Elem* _First2, _Elem* _Last2, _Elem*& _Mid2) const { // convert bytes [_First1, _Last1) to [_First2, _Last2)
+        _Mid1 = _First1;
+        _Mid2 = _First2;
+        if constexpr (_Is_codecvt_do_always_noconv_v<_Elem, _Byte>) {
+            return noconv; // convert nothing
+        } else {
+            // types differ, copy one for one
+            for (; _Mid1 != _Last1; ++_Mid1, ++_Mid2) {
+                if (_Mid2 == _Last2) {
+                    return partial;
+                }
+                *_Mid2 = static_cast<_Elem>(*_Mid1);
+            }
+
+            return ok;
+        }
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_out(_Statype&, const _Elem* _First1, const _Elem* _Last1, const _Elem*& _Mid1,
+        _Byte* _First2, _Byte* _Last2, _Byte*& _Mid2) const { // convert [_First1, _Last1) to bytes [_First2, _Last2)
+        _Mid1 = _First1;
+        _Mid2 = _First2;
+        if constexpr (_Is_codecvt_do_always_noconv_v<_Elem, _Byte>) {
+            return noconv; // convert nothing
+        } else {
+            // types differ, copy one for one
+            for (; _Mid1 != _Last1; ++_Mid1, ++_Mid2) {
+                if (_Mid2 == _Last2) {
+                    return partial;
+                }
+                *_Mid2 = static_cast<_Byte>(*_Mid1);
+            }
+
+            return ok;
+        }
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_unshift(_Statype&, _Byte* _First2, _Byte*, _Byte*& _Mid2) const {
+        // generate bytes to return to default shift state
+        _Mid2 = _First2;
+        return noconv; // no termination required
+    }
+
+    virtual int __CLR_OR_THIS_CALL do_length(
+        _Statype&, const _Byte* _First1, const _Byte* _Last1, size_t _Count) const {
+        // return p - _First1, for the largest value p in [_First1, _Last1] such that [_First1, p) successfully
+        // converts to at most _Count _Elems
+        // assumes 1:1 conversion
+        const auto _Dist = static_cast<size_t>((_STD min)(_Last1 - _First1, ptrdiff_t{INT_MAX}));
+        return static_cast<int>((_STD min)(_Count, _Dist));
+    }
+};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _Elem, class _Byte, class _Statype>
+__PURE_APPDOMAIN_GLOBAL locale::id codecvt<_Elem, _Byte, _Statype>::id;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+
+template <class _CvtTy, class _Byte, class _Statype>
+_NODISCARD int _Codecvt_do_length(
+    const _CvtTy& _Cvt, _Statype& _State, const _Byte* _First1, const _Byte* _Last1, size_t _Count) {
+    // return p - _First1, for the largest value p in [_First1, _Last1] such that _Cvt will successfully convert
+    // [_First1, p) to at most _Count wide characters
+
+    _STL_DISABLE_DEPRECATED_WARNING
+    using _Elem = typename _CvtTy::intern_type;
+    _STL_RESTORE_DEPRECATED_WARNING
+
+    _Adl_verify_range(_First1, _Last1);
+    const auto _Old_first1 = _First1;
+
+    while (_Count > 0 && _First1 != _Last1) { // convert another wide character
+        const _Byte* _Mid1;
+        _Elem* _Mid2;
+        _Elem _Ch;
+
+        // test result of single wide-char conversion
+
+        _STL_DISABLE_DEPRECATED_WARNING
+        const auto _Result = _Cvt._CvtTy::do_in(_State, _First1, _Last1, _Mid1, &_Ch, &_Ch + 1, _Mid2);
+        _STL_RESTORE_DEPRECATED_WARNING
+
+        if (_Result != codecvt_base::ok) {
+            if (_Result == codecvt_base::noconv) {
+                _First1 += (_STD min)(static_cast<size_t>(_Last1 - _First1), _Count);
+            }
+
+            break; // error, noconv, or partial
+        }
+
+        if (_Mid2 == &_Ch + 1) {
+            --_Count; // do_in converted an output character
+        }
+
+        _First1 = _Mid1;
+    }
+
+    return static_cast<int>((_STD min)(_First1 - _Old_first1, ptrdiff_t{INT_MAX}));
+}
+
+enum _Codecvt_mode { _Consume_header = 4, _Generate_header = 2 };
+
+extern "C++" template <>
+class _CRTIMP2_PURE_IMPORT_UNLESS_CODECVT_ID_SATELLITE _CXX20_DEPRECATE_CODECVT_FACETS
+    codecvt<char16_t, char, mbstate_t> : public codecvt_base {
+    // facet for converting between char16_t and UTF-8 byte sequences
+public:
+    using intern_type = char16_t;
+    using extern_type = char;
+    using state_type  = mbstate_t;
+
+    result __CLR_OR_THIS_CALL in(mbstate_t& _State, const char* _First1, const char* _Last1, const char*& _Mid1,
+        char16_t* _First2, char16_t* _Last2, char16_t*& _Mid2) const {
+        // convert bytes [_First1, _Last1) to [_First2, _Last2)
+        return do_in(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result __CLR_OR_THIS_CALL out(mbstate_t& _State, const char16_t* _First1, const char16_t* _Last1,
+        const char16_t*& _Mid1, char* _First2, char* _Last2, char*& _Mid2) const {
+        // convert [_First1, _Last1) to bytes [_First2, _Last2)
+        return do_out(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result __CLR_OR_THIS_CALL unshift(mbstate_t& _State, char* _First2, char* _Last2, char*& _Mid2) const {
+        // generate bytes to return to default shift state
+        return do_unshift(_State, _First2, _Last2, _Mid2);
+    }
+
+    int __CLR_OR_THIS_CALL length(mbstate_t& _State, const char* _First1, const char* _Last1, size_t _Count) const {
+        // return p - _First1, for the largest value p in [_First1, _Last1] such that [_First1, p) successfully
+        // converts to at most _Count UTF-16 code units
+        return do_length(_State, _First1, _Last1, _Count);
+    }
+
+    _CRT_SATELLITE_CODECVT_IDS_NOIMPORT static locale::id id;
+
+    explicit __CLR_OR_THIS_CALL codecvt(size_t _Refs = 0)
+        : codecvt_base(_Refs), _Maxcode(0x10ffff), _Mode(_Consume_header) {
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    explicit __CLR_OR_THIS_CALL codecvt(const _Locinfo& _Lobj, size_t _Refs = 0)
+        : codecvt_base(_Refs), _Maxcode(0x10ffff), _Mode(_Consume_header) {
+        _Init(_Lobj);
+    }
+
+    __CLR_OR_THIS_CALL codecvt(
+        const _Locinfo& _Lobj, unsigned long _Maxcode_arg, _Codecvt_mode _Mode_arg, size_t _Refs = 0)
+        : codecvt_base(_Refs), _Maxcode(_Maxcode_arg), _Mode(_Mode_arg) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            _STL_DISABLE_DEPRECATED_WARNING
+            *_Ppf = new codecvt(_Locinfo(_Ploc->_C_str()));
+            _STL_RESTORE_DEPRECATED_WARNING
+        }
+
+        return _X_CTYPE;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt() noexcept override {}
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo&) {} // initialize
+
+    virtual result __CLR_OR_THIS_CALL do_in(mbstate_t& _State, const char* _First1, const char* _Last1,
+        const char*& _Mid1, char16_t* _First2, char16_t* _Last2, char16_t*& _Mid2) const {
+        // convert bytes [_First1, _Last1) to [_First2, _Last2)
+        unsigned short* _Pstate = reinterpret_cast<unsigned short*>(&_State);
+        _Mid1                   = _First1;
+        _Mid2                   = _First2;
+
+        while (_Mid1 != _Last1 && _Mid2 != _Last2) { // convert a multibyte sequence
+            unsigned char _By = static_cast<unsigned char>(*_Mid1);
+            unsigned long _Ch;
+            int _Nextra;
+            int _Nskip;
+
+            if (*_Pstate > 1) {
+                if (_By < 0x80 || 0xc0 <= _By) {
+                    return codecvt::error; // not continuation byte
+                }
+
+                // deliver second half of two-word value
+                ++_Mid1;
+                *_Mid2++ = static_cast<char16_t>(*_Pstate | (_By & 0x3f));
+                *_Pstate = 1;
+                continue;
+            }
+
+            if (_By < 0x80u) {
+                _Ch     = _By;
+                _Nextra = 0;
+            } else if (_By < 0xc0u) { // 0x80-0xbf not first byte
+                ++_Mid1;
+                return codecvt::error;
+            } else if (_By < 0xe0u) {
+                _Ch     = static_cast<unsigned long>(_By & 0x1f);
+                _Nextra = 1;
+            } else if (_By < 0xf0u) {
+                _Ch     = static_cast<unsigned long>(_By & 0x0f);
+                _Nextra = 2;
+            } else if (_By < 0xf8u) {
+                _Ch     = static_cast<unsigned long>(_By & 0x07);
+                _Nextra = 3;
+            } else {
+                _Ch     = static_cast<unsigned long>(_By & 0x03);
+                _Nextra = _By < 0xfc ? 4 : 5;
+            }
+
+            _Nskip  = _Nextra < 3 ? 0 : 1; // leave a byte for 2nd word
+            _First1 = _Mid1; // roll back point
+
+            if (_Nextra == 0) {
+                ++_Mid1;
+            } else if (_Last1 - _Mid1 < _Nextra + 1 - _Nskip) {
+                break; // not enough input
+            } else {
+                for (++_Mid1; _Nskip < _Nextra; --_Nextra, ++_Mid1) {
+                    if ((_By = static_cast<unsigned char>(*_Mid1)) < 0x80u || 0xc0u <= _By) {
+                        return codecvt::error; // not continuation byte
+                    } else {
+                        _Ch = _Ch << 6 | (_By & 0x3f);
+                    }
+                }
+            }
+
+            if (0 < _Nskip) {
+                _Ch <<= 6; // get last byte on next call
+            }
+
+            if ((_Maxcode < 0x10ffffu ? _Maxcode : 0x10ffffu) < _Ch) {
+                return codecvt::error; // value too large
+            }
+
+            if (0xffffu < _Ch) { // deliver first half of two-word value, save second word
+                unsigned short _Ch0 = static_cast<unsigned short>(0xd800 | (_Ch >> 10) - 0x0040);
+
+                *_Mid2++ = static_cast<char16_t>(_Ch0);
+                *_Pstate = static_cast<unsigned short>(0xdc00 | (_Ch & 0x03ff));
+                continue;
+            }
+
+            if (_Nskip != 0) {
+                if (_Mid1 == _Last1) { // not enough bytes, noncanonical value
+                    _Mid1 = _First1;
+                    break;
+                }
+
+                if ((_By = static_cast<unsigned char>(*_Mid1++)) < 0x80u || 0xc0u <= _By) {
+                    return codecvt::error; // not continuation byte
+                }
+
+                _Ch |= _By & 0x3f; // complete noncanonical value
+            }
+
+            if (*_Pstate == 0u) { // first time, maybe look for and consume header
+                *_Pstate = 1;
+
+                if ((_Mode & _Consume_header) != 0 && _Ch == 0xfeffu) { // drop header and retry
+                    const result _Ans = do_in(_State, _Mid1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+
+                    if (_Ans == codecvt::partial) { // roll back header determination
+                        *_Pstate = 0;
+                        _Mid1    = _First1;
+                    }
+
+                    return _Ans;
+                }
+            }
+
+            *_Mid2++ = static_cast<char16_t>(_Ch);
+        }
+
+        return _First1 == _Mid1 ? codecvt::partial : codecvt::ok;
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_out(mbstate_t& _State, const char16_t* _First1, const char16_t* _Last1,
+        const char16_t*& _Mid1, char* _First2, char* _Last2, char*& _Mid2) const {
+        // convert [_First1, _Last1) to bytes [_First2, _Last2)
+        unsigned short* _Pstate = reinterpret_cast<unsigned short*>(&_State);
+        _Mid1                   = _First1;
+        _Mid2                   = _First2;
+
+        while (_Mid1 != _Last1 && _Mid2 != _Last2) { // convert and put a wide char
+            unsigned long _Ch;
+            const unsigned short _Ch1 = static_cast<unsigned short>(*_Mid1);
+            bool _Save                = false;
+
+            if (1 < *_Pstate) { // get saved MS 11 bits from *_Pstate
+                if (_Ch1 < 0xdc00u || 0xe000u <= _Ch1) {
+                    return codecvt::error; // bad second word
+                }
+
+                _Ch = static_cast<unsigned long>((*_Pstate << 10) | (_Ch1 - 0xdc00));
+            } else if (0xd800u <= _Ch1 && _Ch1 < 0xdc00u) { // get new first word
+                _Ch   = static_cast<unsigned long>((_Ch1 - 0xd800 + 0x0040) << 10);
+                _Save = true; // put only first byte, rest with second word
+            } else {
+                _Ch = _Ch1; // not first word, just put it
+            }
+
+            char _By;
+            int _Nextra;
+
+            if (_Ch < 0x0080u) {
+                _By     = static_cast<char>(_Ch);
+                _Nextra = 0;
+            } else if (_Ch < 0x0800u) {
+                _By     = static_cast<char>(0xc0 | _Ch >> 6);
+                _Nextra = 1;
+            } else if (_Ch < 0x10000u) {
+                _By     = static_cast<char>(0xe0 | _Ch >> 12);
+                _Nextra = 2;
+            } else {
+                _By     = static_cast<char>(0xf0 | _Ch >> 18);
+                _Nextra = 3;
+            }
+
+            int _Nput = _Nextra < 3 ? _Nextra + 1 : _Save ? 1 : 3;
+
+            if (_Last2 - _Mid2 < _Nput) {
+                break; // not enough room, even without header
+            }
+
+            if (*_Pstate == 0u && (_Mode & _Generate_header) != 0) {
+                if (_Last2 - _Mid2 < 3 + _Nput) {
+                    break; // not enough room for header + output
+                }
+
+                // prepend header
+                *_Mid2++ = '\xef';
+                *_Mid2++ = '\xbb';
+                *_Mid2++ = '\xbf';
+            }
+
+            ++_Mid1;
+            if (_Save || _Nextra < 3) { // put first byte of sequence, if not already put
+                *_Mid2++ = _By;
+                --_Nput;
+            }
+
+            for (; 0 < _Nput; --_Nput) {
+                *_Mid2++ = static_cast<char>((_Ch >> 6 * --_Nextra & 0x3f) | 0x80);
+            }
+
+            *_Pstate = static_cast<unsigned short>(_Save ? _Ch >> 10 : 1);
+        }
+
+        return _First1 == _Mid1 ? codecvt::partial : codecvt::ok;
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_unshift(mbstate_t& _State, char* _First2, char*, char*& _Mid2) const {
+        // generate bytes to return to default shift state
+        unsigned short* _Pstate = reinterpret_cast<unsigned short*>(&_State);
+        _Mid2                   = _First2;
+
+        return 1u < *_Pstate ? codecvt::error : codecvt::ok; // fail if trailing first word
+    }
+
+    friend int _Codecvt_do_length<>(const codecvt&, mbstate_t&, const char*, const char*, size_t);
+
+    virtual int __CLR_OR_THIS_CALL do_length(
+        mbstate_t& _State, const char* _First1, const char* _Last1, size_t _Count) const {
+        return _Codecvt_do_length(*this, _State, _First1, _Last1, _Count);
+    }
+
+    bool __CLR_OR_THIS_CALL do_always_noconv() const noexcept override {
+        // return true if conversions never change input
+        return false;
+    }
+
+    int __CLR_OR_THIS_CALL do_max_length() const noexcept override {
+        // return maximum length required for a conversion
+
+        if ((_Mode & _Consume_header) != 0) {
+            return 9; // header + max input
+        }
+
+        if ((_Mode & _Generate_header) != 0) {
+            return 7; // header + max output
+        }
+
+        return 6; // 6-byte max input sequence, no 3-byte header
+    }
+
+    int do_encoding() const noexcept override {
+        return 0; // 0 => varying length
+    }
+
+private:
+    unsigned long _Maxcode; // default: 0x10ffff
+    _Codecvt_mode _Mode; // default: _Consume_header
+};
+
+extern "C++" template <>
+class _CRTIMP2_PURE_IMPORT_UNLESS_CODECVT_ID_SATELLITE _CXX20_DEPRECATE_CODECVT_FACETS
+    codecvt<char32_t, char, mbstate_t> : public codecvt_base {
+    // facet for converting between char32_t and UTF-8 byte sequences
+public:
+    using intern_type = char32_t;
+    using extern_type = char;
+    using state_type  = mbstate_t;
+
+    result __CLR_OR_THIS_CALL in(mbstate_t& _State, const char* _First1, const char* _Last1, const char*& _Mid1,
+        char32_t* _First2, char32_t* _Last2, char32_t*& _Mid2) const {
+        // convert bytes [_First1, _Last1) to [_First2, _Last2)
+        return do_in(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result __CLR_OR_THIS_CALL out(mbstate_t& _State, const char32_t* _First1, const char32_t* _Last1,
+        const char32_t*& _Mid1, char* _First2, char* _Last2, char*& _Mid2) const {
+        // convert [_First1, _Last1) to bytes [_First2, _Last2)
+        return do_out(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result __CLR_OR_THIS_CALL unshift(mbstate_t& _State, char* _First2, char* _Last2, char*& _Mid2) const {
+        // generate bytes to return to default shift state
+        return do_unshift(_State, _First2, _Last2, _Mid2);
+    }
+
+    int __CLR_OR_THIS_CALL length(mbstate_t& _State, const char* _First1, const char* _Last1, size_t _Count) const {
+        // return p - _First1, for the largest value p in [_First1, _Last1] such that [_First1, p) successfully
+        // converts to at most _Count UTF-32 code units
+        return do_length(_State, _First1, _Last1, _Count);
+    }
+
+    _CRT_SATELLITE_CODECVT_IDS_NOIMPORT static locale::id id;
+
+    explicit __CLR_OR_THIS_CALL codecvt(size_t _Refs = 0)
+        : codecvt_base(_Refs), _Maxcode(0xffffffff), _Mode(_Consume_header) {
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    explicit __CLR_OR_THIS_CALL codecvt(const _Locinfo& _Lobj, size_t _Refs = 0)
+        : codecvt_base(_Refs), _Maxcode(0xffffffff), _Mode(_Consume_header) {
+        _Init(_Lobj);
+    }
+
+    __CLR_OR_THIS_CALL codecvt(
+        const _Locinfo& _Lobj, unsigned long _Maxcode_arg, _Codecvt_mode _Mode_arg, size_t _Refs = 0)
+        : codecvt_base(_Refs), _Maxcode(_Maxcode_arg), _Mode(_Mode_arg) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            _STL_DISABLE_DEPRECATED_WARNING
+            *_Ppf = new codecvt(_Locinfo(_Ploc->_C_str()));
+            _STL_RESTORE_DEPRECATED_WARNING
+        }
+
+        return _X_CTYPE;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt() noexcept override {}
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo&) {} // initialize
+
+    virtual result __CLR_OR_THIS_CALL do_in(mbstate_t& _State, const char* _First1, const char* _Last1,
+        const char*& _Mid1, char32_t* _First2, char32_t* _Last2, char32_t*& _Mid2) const {
+        // convert bytes [_First1, _Last1) to [_First2, _Last2)
+        char* _Pstate = reinterpret_cast<char*>(&_State);
+        _Mid1         = _First1;
+        _Mid2         = _First2;
+
+        while (_Mid1 != _Last1 && _Mid2 != _Last2) { // convert a multibyte sequence
+            unsigned char _By = static_cast<unsigned char>(*_Mid1);
+            unsigned long _Ch;
+            int _Nextra;
+
+            if (_By < 0x80u) {
+                _Ch     = _By;
+                _Nextra = 0;
+            } else if (_By < 0xc0u) { // 0x80-0xbf not first byte
+                ++_Mid1;
+                return codecvt::error;
+            } else if (_By < 0xe0u) {
+                _Ch     = static_cast<unsigned long>(_By & 0x1f);
+                _Nextra = 1;
+            } else if (_By < 0xf0u) {
+                _Ch     = static_cast<unsigned long>(_By & 0x0f);
+                _Nextra = 2;
+            } else if (_By < 0xf8u) {
+                _Ch     = static_cast<unsigned long>(_By & 0x07);
+                _Nextra = 3;
+            } else {
+                _Ch     = static_cast<unsigned long>(_By & 0x03);
+                _Nextra = _By < 0xfc ? 4 : 5;
+            }
+
+            if (_Nextra == 0) {
+                ++_Mid1;
+            } else if (_Last1 - _Mid1 < _Nextra + 1) {
+                break; // not enough input
+            } else {
+                for (++_Mid1; 0 < _Nextra; --_Nextra, ++_Mid1) {
+                    if ((_By = static_cast<unsigned char>(*_Mid1)) < 0x80u || 0xc0u <= _By) {
+                        return codecvt::error; // not continuation byte
+                    } else {
+                        _Ch = _Ch << 6 | (_By & 0x3f);
+                    }
+                }
+            }
+
+            if (*_Pstate == 0) { // first time, maybe look for and consume header
+                *_Pstate = 1;
+
+                if ((_Mode & _Consume_header) != 0 && _Ch == 0xfeffu) { // drop header and retry
+                    const result _Ans = do_in(_State, _Mid1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+
+                    if (_Ans == codecvt::partial) { // roll back header determination
+                        *_Pstate = 0;
+                        _Mid1    = _First1;
+                    }
+                    return _Ans;
+                }
+            }
+
+            if (_Maxcode < _Ch) {
+                return codecvt::error; // code too large
+            }
+
+            *_Mid2++ = static_cast<char32_t>(_Ch);
+        }
+
+        return _First1 == _Mid1 ? codecvt::partial : codecvt::ok;
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_out(mbstate_t& _State, const char32_t* _First1, const char32_t* _Last1,
+        const char32_t*& _Mid1, char* _First2, char* _Last2, char*& _Mid2) const {
+        // convert [_First1, _Last1) to bytes [_First2, _Last2)
+        char* _Pstate = reinterpret_cast<char*>(&_State);
+        _Mid1         = _First1;
+        _Mid2         = _First2;
+
+        while (_Mid1 != _Last1 && _Mid2 != _Last2) { // convert and put a wide char
+            char _By;
+            int _Nextra;
+            unsigned long _Ch = static_cast<unsigned long>(*_Mid1);
+
+            if (_Maxcode < _Ch) {
+                return codecvt::error;
+            }
+
+            if (_Ch < 0x0080u) {
+                _By     = static_cast<char>(_Ch);
+                _Nextra = 0;
+            } else if (_Ch < 0x0800u) {
+                _By     = static_cast<char>(0xc0 | _Ch >> 6);
+                _Nextra = 1;
+            } else if (_Ch < 0x00010000u) {
+                _By     = static_cast<char>(0xe0 | _Ch >> 12);
+                _Nextra = 2;
+            } else if (_Ch < 0x00200000u) {
+                _By     = static_cast<char>(0xf0 | _Ch >> 18);
+                _Nextra = 3;
+            } else if (_Ch < 0x04000000u) {
+                _By     = static_cast<char>(0xf8 | _Ch >> 24);
+                _Nextra = 4;
+            } else {
+                _By     = static_cast<char>(0xfc | (_Ch >> 30 & 0x03));
+                _Nextra = 5;
+            }
+
+            if (*_Pstate == 0) { // first time, maybe generate header
+                *_Pstate = 1;
+                if ((_Mode & _Generate_header) != 0) {
+                    if (_Last2 - _Mid2 < 3 + 1 + _Nextra) {
+                        return codecvt::partial; // not enough room for both
+                    }
+
+                    // prepend header
+                    *_Mid2++ = '\xef';
+                    *_Mid2++ = '\xbb';
+                    *_Mid2++ = '\xbf';
+                }
+            }
+
+            if (_Last2 - _Mid2 < 1 + _Nextra) {
+                break; // not enough room for output
+            }
+
+            ++_Mid1;
+            for (*_Mid2++ = _By; 0 < _Nextra;) {
+                *_Mid2++ = static_cast<char>((_Ch >> 6 * --_Nextra & 0x3f) | 0x80);
+            }
+        }
+        return _First1 == _Mid1 ? codecvt::partial : codecvt::ok;
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_unshift(mbstate_t&, char* _First2, char*, char*& _Mid2) const {
+        // generate bytes to return to default shift state
+        _Mid2 = _First2;
+        return codecvt::noconv;
+    }
+
+    friend int _Codecvt_do_length<>(const codecvt&, mbstate_t&, const char*, const char*, size_t);
+
+    virtual int __CLR_OR_THIS_CALL do_length(
+        mbstate_t& _State, const char* _First1, const char* _Last1, size_t _Count) const {
+        return _Codecvt_do_length(*this, _State, _First1, _Last1, _Count);
+    }
+
+    bool __CLR_OR_THIS_CALL do_always_noconv() const noexcept override {
+        // return true if conversions never change input
+        return false;
+    }
+
+    int __CLR_OR_THIS_CALL do_max_length() const noexcept override {
+        // return maximum length required for a conversion
+        return (_Mode & (_Consume_header | _Generate_header)) != 0 ? 9 : 6;
+    }
+
+    int __CLR_OR_THIS_CALL do_encoding() const noexcept override {
+        // return length of code sequence (from codecvt)
+        return (_Mode & (_Consume_header | _Generate_header)) != 0 ? -1
+                                                                   : 0; // -1 => state dependent, 0 => varying length
+    }
+
+private:
+    unsigned long _Maxcode; // default: 0xffffffff
+    _Codecvt_mode _Mode; // default: _Consume_header
+};
+
+#if defined(__cpp_char8_t) && !defined(_M_CEE_PURE)
+template <class _From, class _To>
+struct _NODISCARD _Codecvt_guard {
+    const _From* const& _First1;
+    const _From*& _Mid1;
+    _To* const& _First2;
+    _To*& _Mid2;
+
+    _Codecvt_guard(const _From* const& _First1_, const _From*& _Mid1_, _To* const& _First2_, _To*& _Mid2_)
+        : _First1{_First1_}, _Mid1{_Mid1_}, _First2{_First2_}, _Mid2{_Mid2_} {}
+
+    _Codecvt_guard(const _Codecvt_guard&)            = delete;
+    _Codecvt_guard& operator=(const _Codecvt_guard&) = delete;
+
+    ~_Codecvt_guard() {
+        _Mid1 = _First1;
+        _Mid2 = _First2;
+    }
+};
+
+extern "C++" template <>
+class _CXX20_DEPRECATE_CODECVT_CHAR8_T_FACETS codecvt<char16_t, char8_t, mbstate_t> : public codecvt_base {
+    // facet for converting between UTF-16 and UTF-8 sequences
+public:
+    using intern_type = char16_t;
+    using extern_type = char8_t;
+    using state_type  = mbstate_t;
+
+    result in(mbstate_t& _State, const char8_t* _First1, const char8_t* _Last1, const char8_t*& _Mid1,
+        char16_t* _First2, char16_t* _Last2, char16_t*& _Mid2) const {
+        // convert UTF-8 [_First1, _Last1) to UTF-16 [_First2, _Last2)
+        return do_in(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result out(mbstate_t& _State, const char16_t* _First1, const char16_t* _Last1, const char16_t*& _Mid1,
+        char8_t* _First2, char8_t* _Last2, char8_t*& _Mid2) const {
+        // convert UTF-16 [_First1, _Last1) to UTF-8 [_First2, _Last2)
+        return do_out(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result unshift(mbstate_t& _State, char8_t* _First2, char8_t* _Last2, char8_t*& _Mid2) const {
+        // generate bytes to return to default shift state
+        return do_unshift(_State, _First2, _Last2, _Mid2);
+    }
+
+    int length(mbstate_t& _State, const char8_t* _First1, const char8_t* _Last1, size_t _Count) const {
+        // return p - _First1, for the largest value p in [_First1, _Last1] such that [_First1, p) successfully
+        // converts to at most _Count UTF-16 code units
+        return do_length(_State, _First1, _Last1, _Count);
+    }
+
+    _CRT_SATELLITE_CODECVT_IDS static locale::id id;
+
+    explicit codecvt(size_t _Refs = 0) : codecvt_base(_Refs) {} // construct "from current locale"
+    explicit codecvt(const _Locinfo&, size_t _Refs = 0) : codecvt_base(_Refs) {} // construct "from specified locale"
+
+    static size_t _Getcat(const locale::facet** _Ppf = nullptr, const locale* = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new codecvt;
+        }
+
+        return _X_CTYPE;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt() noexcept override = default;
+
+    virtual result __CLR_OR_THIS_CALL do_in(mbstate_t&, const char8_t* _First1, const char8_t* _Last1,
+        const char8_t*& _Mid1, char16_t* _First2, char16_t* _Last2, char16_t*& _Mid2) const {
+        // convert UTF-8 [_First1, _Last1) to UTF-16 [_First2, _Last2)
+        _Adl_verify_range(_First1, _Last1);
+        _Adl_verify_range(_First2, _Last2);
+
+        _Codecvt_guard<char8_t, char16_t> _Guard{_First1, _Mid1, _First2, _Mid2};
+
+        for (; _First1 != _Last1; ++_First1, ++_First2) {
+            if (_First2 == _Last2) {
+                return partial;
+            }
+
+            char8_t _Lead_byte = *_First1;
+            if (_Lead_byte < 0b1000'0000u) { // single-byte sequence
+                *_First2 = static_cast<char16_t>(_Lead_byte);
+                continue;
+            }
+
+            int _Trailing_count = 1;
+            if (_Lead_byte < 0b1110'0000u) {
+                if (_Lead_byte < 0b1100'0000u) { // out-of-sequence trailing byte
+                    return error;
+                }
+
+                // lead byte of 2-byte sequence
+                _Lead_byte &= 0b0001'1111u;
+            } else if (_Lead_byte < 0b1111'0000u) { // lead byte of 3-byte sequence
+                _Lead_byte &= 0b0000'1111u;
+                _Trailing_count = 2;
+            } else if (_Lead_byte < 0b1111'1000u) { // lead byte of 4-byte sequence
+                if (_Last2 - _First2 < 2) { // not enough output for a surrogate pair
+                    return partial;
+                }
+
+                _Lead_byte &= 0b0000'0111u;
+                _Trailing_count = 3;
+            } else { // Invalid UTF-8 code unit
+                return error;
+            }
+
+            if (_Last1 - _First1 < _Trailing_count + 1) { // not enough input
+                return partial;
+            }
+
+            const char8_t* _Peek = _First1;
+            char32_t _Code_point = _Lead_byte;
+            do {
+                const char8_t _By = *++_Peek;
+                if ((_By & 0b1100'0000u) != 0b1000'0000u) { // out-of-sequence lead byte
+                    return error;
+                }
+
+                _Code_point = (_Code_point << 6) | (_By & 0b11'1111u);
+            } while (--_Trailing_count != 0);
+
+            if (_Code_point < 0x10000u) {
+                if (_Code_point >= 0xd800u && _Code_point < 0xe000u) { // invalid code point (surrogate)
+                    return error;
+                }
+                // Output single code unit
+                *_First2 = static_cast<char16_t>(_Code_point);
+            } else if (_Code_point >= 0x110000u) { // Invalid code point (out of range)
+                return error;
+            } else {
+                // Output surrogate pair
+                _Code_point -= 0x10000u;
+                // High surrogate: 0xd800 | <upper ten bits>
+                *_First2 = static_cast<char16_t>(0xd800u | (_Code_point >> 10));
+                // Low surrogate: 0xdc00 | <lower ten bits>
+                *++_First2 = static_cast<char16_t>(0xdc00u | (_Code_point & 0b11'1111'1111u));
+            }
+
+            _First1 = _Peek;
+        }
+
+        return ok;
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_out(mbstate_t&, const char16_t* _First1, const char16_t* _Last1,
+        const char16_t*& _Mid1, char8_t* _First2, char8_t* _Last2, char8_t*& _Mid2) const {
+        // convert UTF-16 [_First1, _Last1) to UTF-8 [_First2, _Last2)
+        _Adl_verify_range(_First1, _Last1);
+        _Adl_verify_range(_First2, _Last2);
+
+        _Codecvt_guard<char16_t, char8_t> _Guard{_First1, _Mid1, _First2, _Mid2};
+
+        for (; _First1 != _Last1; ++_First1, ++_First2) {
+            if (_First2 == _Last2) { // no more output
+                return partial;
+            }
+
+            char32_t _Code_point = *_First1;
+            if (_Code_point < 0x80u) { // encode 1-byte sequence
+                *_First2 = static_cast<char8_t>(_Code_point);
+                continue;
+            }
+
+            int _Trailing_count = 1;
+            if (_Code_point < 0x800u) { // encode 2-byte sequence
+                *_First2 = static_cast<char8_t>(0b1100'0000u | (_Code_point >> 6));
+            } else if (_Code_point < 0xd800u || _Code_point >= 0xe000u) { // encode 3-byte sequence
+                *_First2        = static_cast<char8_t>(0b1110'0000u | (_Code_point >> 12));
+                _Trailing_count = 2;
+            } else if (_Code_point < 0xdc00u) { // high surrogate; parse the low surrogate
+                if (_Last1 - _First1 < 2) { // not enough input
+                    return partial;
+                }
+
+                const char16_t _Low_surrogate = *++_First1;
+                if (_Low_surrogate < 0xdc00u || _Low_surrogate >= 0xe000u) { // invalid low surrogate
+                    --_First1;
+                    return error;
+                }
+                _Code_point = 0x10000u + (((_Code_point & 0b11'1111'1111u) << 10) | (_Low_surrogate & 0b11'1111'1111u));
+
+                // encode 4-byte sequence
+                *_First2        = static_cast<char8_t>(0b1111'0000u | (_Code_point >> 18));
+                _Trailing_count = 3;
+            } else { // out-of-sequence low surrogate
+                return error;
+            }
+
+            if (_Last2 - _First2 < _Trailing_count + 1) { // not enough output
+                if (_Trailing_count > 2) { // input was a surrogate pair; revert
+                    --_First1;
+                }
+                return partial;
+            }
+
+            do {
+                --_Trailing_count;
+                *++_First2 = static_cast<char8_t>(0b1000'0000u | ((_Code_point >> (6 * _Trailing_count)) & 0b11'1111u));
+            } while (_Trailing_count != 0);
+        }
+
+        return ok;
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_unshift(mbstate_t&, char8_t* _First2, char8_t*, char8_t*& _Mid2) const {
+        // terminate encoding sequence
+        _Mid2 = _First2;
+        return noconv; // no termination necessary
+    }
+
+    virtual int __CLR_OR_THIS_CALL do_length(
+        mbstate_t&, const char8_t* _First1, const char8_t* _Last1, size_t _Count) const {
+        // return p - _First1, for the largest value p in [_First1, _Last1] such that [_First1, p) successfully
+        // converts to at most _Count UTF-16 code units
+        _Adl_verify_range(_First1, _Last1);
+
+        const auto _Old_first1 = _First1;
+
+        for (; _First1 != _Last1 && _Count > 0u; ++_First1, --_Count) {
+            char32_t _Code_point = *_First1;
+            if (_Code_point < 0b1000'0000u) { // single-byte sequence
+                continue;
+            }
+
+            int _Trailing_count = 1;
+            if (_Code_point < 0b1110'0000u) {
+                if (_Code_point < 0b1100'0000u) { // out-of-sequence trailing byte
+                    break;
+                }
+
+                // lead byte of 2-byte sequence
+                _Code_point &= 0b0001'1111u;
+            } else if (_Code_point < 0b1111'0000u) { // lead byte of 3-byte sequence
+                _Code_point &= 0b0000'1111u;
+                _Trailing_count = 2;
+            } else if (_Code_point < 0b1111'1000u) { // lead byte of 4-byte sequence
+                if (_Count < 2u) { // not enough output
+                    break;
+                }
+
+                _Code_point &= 0b0000'0111u;
+                _Trailing_count = 3;
+            } else { // Invalid UTF-8 code unit
+                break;
+            }
+
+            if (_Last1 - _First1 < _Trailing_count + 1) { // not enough input
+                break;
+            }
+
+            const char8_t* _Peek = _First1;
+            bool _Done           = false;
+            do {
+                const char8_t _By = *++_Peek;
+                if ((_By & 0b1100'0000u) != 0b1000'0000u) { // out-of-sequence lead byte
+                    _Done = true;
+                    break;
+                }
+
+                _Code_point = (_Code_point << 6) | (_By & 0b11'1111u);
+            } while (--_Trailing_count != 0);
+
+            if (_Done) {
+                break;
+            }
+
+            if (_Code_point < 0x10000u) { // Output single code unit
+                if (_Code_point >= 0xd800u && _Code_point < 0xe0000u) { // invalid code point (surrogate)
+                    break;
+                }
+            } else if (_Code_point < 0x110000u) { // Output surrogate pair
+                --_Count;
+            } else { // Invalid code point (out of range)
+                break;
+            }
+
+            _First1 = _Peek;
+        }
+
+        return static_cast<int>((_STD min)(_First1 - _Old_first1, ptrdiff_t{INT_MAX}));
+    }
+
+    bool __CLR_OR_THIS_CALL do_always_noconv() const noexcept override {
+        // return true if conversions never change input
+        return false;
+    }
+
+    int __CLR_OR_THIS_CALL do_max_length() const noexcept override {
+        // return maximum length required for a conversion
+        return 4; // 4-byte max input sequence
+    }
+
+    int __CLR_OR_THIS_CALL do_encoding() const noexcept override {
+        // return length of code sequence (from codecvt)
+        return 0; // 0 => varying length
+    }
+};
+
+extern "C++" template <>
+class _CXX20_DEPRECATE_CODECVT_CHAR8_T_FACETS codecvt<char32_t, char8_t, mbstate_t> : public codecvt_base {
+    // facet for converting between UTF-32 and UTF-8 sequences
+public:
+    using intern_type = char32_t;
+    using extern_type = char8_t;
+    using state_type  = mbstate_t;
+
+    result in(mbstate_t& _State, const char8_t* _First1, const char8_t* _Last1, const char8_t*& _Mid1,
+        char32_t* _First2, char32_t* _Last2, char32_t*& _Mid2) const {
+        // convert UTF-8 [_First1, _Last1) to UTF-32 [_First2, _Last2)
+        return do_in(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result out(mbstate_t& _State, const char32_t* _First1, const char32_t* _Last1, const char32_t*& _Mid1,
+        char8_t* _First2, char8_t* _Last2, char8_t*& _Mid2) const {
+        // convert UTF-32 [_First1, _Last1) to UTF-8 [_First2, _Last2)
+        return do_out(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result unshift(mbstate_t& _State, char8_t* _First2, char8_t* _Last2, char8_t*& _Mid2) const {
+        // generate bytes to return to default shift state
+        return do_unshift(_State, _First2, _Last2, _Mid2);
+    }
+
+    int length(mbstate_t& _State, const char8_t* _First1, const char8_t* _Last1, size_t _Count) const {
+        // return p - _First1, for the largest value p in [_First1, _Last1] such that [_First1, p) successfully
+        // converts to at most _Count UTF-32 code units
+        return do_length(_State, _First1, _Last1, _Count);
+    }
+
+    _CRT_SATELLITE_CODECVT_IDS static locale::id id;
+
+    explicit codecvt(size_t _Refs = 0) : codecvt_base(_Refs) {} // construct "from current locale"
+    explicit codecvt(const _Locinfo&, size_t _Refs = 0) : codecvt_base(_Refs) {} // construct "from specified locale"
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new codecvt;
+        }
+
+        return _X_CTYPE;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt() noexcept override = default;
+
+    virtual result __CLR_OR_THIS_CALL do_in(mbstate_t&, const char8_t* _First1, const char8_t* _Last1,
+        const char8_t*& _Mid1, char32_t* _First2, char32_t* _Last2, char32_t*& _Mid2) const {
+        // convert UTF-8 [_First1, _Last1) to UTF-32 [_First2, _Last2)
+        _Adl_verify_range(_First1, _Last1);
+        _Adl_verify_range(_First2, _Last2);
+
+        _Codecvt_guard<char8_t, char32_t> _Guard{_First1, _Mid1, _First2, _Mid2};
+
+        for (; _First1 != _Last1; ++_First1, ++_First2) {
+            if (_First2 == _Last2) {
+                return partial;
+            }
+
+            char8_t _Lead_byte = *_First1;
+            if (_Lead_byte < 0b1000'0000u) { // single-byte sequence
+                *_First2 = _Lead_byte;
+                continue;
+            }
+
+            int _Trailing_count = 1;
+            if (_Lead_byte < 0b1110'0000u) {
+                if (_Lead_byte < 0b1100'0000u) { // out-of-sequence trailing byte
+                    return partial;
+                }
+
+                // lead byte of 2-byte sequence
+                _Lead_byte &= 0b0001'1111u;
+            } else if (_Lead_byte < 0b1111'0000u) { // lead byte of 3-byte sequence
+                _Lead_byte &= 0b0000'1111u;
+                _Trailing_count = 2;
+            } else if (_Lead_byte < 0b1111'1000u) { // lead byte of 4-byte sequence
+                _Lead_byte &= 0b0000'0111u;
+                _Trailing_count = 3;
+            } else { // invalid UTF-8 code unit
+                return error;
+            }
+
+            if (_Last1 - _First1 < _Trailing_count + 1) { // not enough input
+                return partial;
+            }
+
+            const char8_t* _Peek = _First1;
+            char32_t _Code_point = _Lead_byte;
+            do {
+                const char8_t _By = *++_Peek;
+                if ((_By & 0b1100'0000u) != 0b1000'0000u) { // out-of-sequence lead byte
+                    return error;
+                }
+
+                _Code_point = (_Code_point << 6) | (_By & 0b11'1111u);
+            } while (--_Trailing_count != 0);
+
+            if (_Code_point >= 0xd800u && (_Code_point < 0xe000u || _Code_point >= 0x110000u)) {
+                // invalid code point (surrogate or out of range)
+                return error;
+            }
+
+            _First1  = _Peek;
+            *_First2 = _Code_point;
+        }
+
+        return ok;
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_out(mbstate_t&, const char32_t* _First1, const char32_t* _Last1,
+        const char32_t*& _Mid1, char8_t* _First2, char8_t* _Last2, char8_t*& _Mid2) const {
+        // convert UTF-32 [_First1, _Last1) to UTF-8 [_First2, _Last2)
+        _Adl_verify_range(_First1, _Last1);
+        _Adl_verify_range(_First2, _Last2);
+
+        _Codecvt_guard<char32_t, char8_t> _Guard{_First1, _Mid1, _First2, _Mid2};
+
+        for (; _First1 != _Last1; ++_First1, ++_First2) {
+            if (_First2 == _Last2) { // no more output
+                return partial;
+            }
+
+            const char32_t _Code_point = *_First1;
+            if (_Code_point < 0x80u) { // encode 1-byte sequence
+                *_First2 = static_cast<char8_t>(_Code_point);
+                continue;
+            }
+
+            int _Trailing_count = 1;
+            if (_Code_point < 0x800u) { // encode 2-byte sequence
+                *_First2 = static_cast<char8_t>(0b1100'0000u | (_Code_point >> 6));
+            } else if (_Code_point < 0x10000u) { // encode 3-byte sequence
+                if (_Code_point >= 0xd800u && _Code_point < 0xe000u) { // invalid code point (surrogate)
+                    return error;
+                }
+
+                *_First2        = static_cast<char8_t>(0b1110'0000u | (_Code_point >> 12));
+                _Trailing_count = 2;
+            } else if (_Code_point < 0x110000u) { // encode 4-byte sequence
+                *_First2        = static_cast<char8_t>(0b1111'0000u | (_Code_point >> 18));
+                _Trailing_count = 3;
+            } else { // Invalid code point (out of range)
+                return error;
+            }
+
+            if (_Last2 - _First2 < _Trailing_count + 1) { // not enough output
+                return partial;
+            }
+
+            do {
+                --_Trailing_count;
+                *++_First2 = static_cast<char8_t>(0b1000'0000u | ((_Code_point >> (6 * _Trailing_count)) & 0b11'1111u));
+            } while (_Trailing_count != 0);
+        }
+
+        return ok;
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_unshift(mbstate_t&, char8_t* _First2, char8_t*, char8_t*& _Mid2) const {
+        // terminate encoding sequence
+        _Mid2 = _First2;
+        return noconv; // no termination necessary
+    }
+
+    virtual int __CLR_OR_THIS_CALL do_length(
+        mbstate_t&, const char8_t* _First1, const char8_t* _Last1, size_t _Count) const {
+        // return p - _First1, for the largest value p in [_First1, _Last1] such that [_First1, p) successfully
+        // converts to at most _Count UTF-32 code units
+        _Adl_verify_range(_First1, _Last1);
+
+        const auto _Old_first1 = _First1;
+
+        for (; _First1 != _Last1 && _Count > 0u; ++_First1, --_Count) {
+            char32_t _Code_point = *_First1;
+            if (_Code_point < 0b1000'0000u) { // single-byte sequence
+                continue;
+            }
+
+            int _Trailing_count = 1;
+            if (_Code_point < 0b1110'0000u) {
+                if (_Code_point < 0b1100'0000u) { // out-of-sequence trailing byte
+                    break;
+                }
+
+                // lead byte of 2-byte sequence
+                _Code_point &= 0b0001'1111u;
+            } else if (_Code_point < 0b1111'0000u) { // lead byte of 3-byte sequence
+                _Code_point &= 0b0000'1111u;
+                _Trailing_count = 2;
+            } else if (_Code_point < 0b1111'1000u) { // lead byte of 4-byte sequence
+                _Code_point &= 0b0000'0111u;
+                _Trailing_count = 3;
+            } else { // invalid UTF-8 code unit
+                break;
+            }
+
+            if (_Last1 - _First1 < _Trailing_count + 1) { // not enough input
+                break;
+            }
+
+            const char8_t* _Peek = _First1;
+            bool _Done           = false;
+            do {
+                const char8_t _By = *++_Peek;
+                if ((_By & 0b1100'0000u) != 0b1000'0000u) { // out-of-sequence lead byte
+                    _Done = true;
+                    break;
+                }
+
+                _Code_point = (_Code_point << 6) | (_By & 0b11'1111u);
+            } while (--_Trailing_count != 0);
+
+            if (_Done || (_Code_point >= 0xd800u && (_Code_point < 0xe000u || _Code_point >= 0x110000u))) {
+                // invalid code point (surrogate or out of range)
+                break;
+            }
+
+            _First1 = _Peek;
+        }
+
+        return static_cast<int>((_STD min)(_First1 - _Old_first1, ptrdiff_t{INT_MAX}));
+    }
+
+    bool __CLR_OR_THIS_CALL do_always_noconv() const noexcept override {
+        // return true if conversions never change input
+        return false;
+    }
+
+    int __CLR_OR_THIS_CALL do_max_length() const noexcept override {
+        // return maximum length required for a conversion
+        return 4;
+    }
+
+    int __CLR_OR_THIS_CALL do_encoding() const noexcept override {
+        // return length of code sequence (from codecvt)
+        return 0; // varying length
+    }
+};
+#endif // defined(__cpp_char8_t) && !defined(_M_CEE_PURE)
+
+extern "C++" template <>
+class _CRTIMP2_PURE_IMPORT codecvt<wchar_t, char, mbstate_t> : public codecvt_base {
+    // facet for converting between wchar_t and char (_Byte) sequences
+public:
+    using intern_type = wchar_t;
+    using extern_type = char;
+    using state_type  = mbstate_t;
+
+    result __CLR_OR_THIS_CALL in(mbstate_t& _State, const char* _First1, const char* _Last1, const char*& _Mid1,
+        wchar_t* _First2, wchar_t* _Last2, wchar_t*& _Mid2) const {
+        // convert bytes [_First1, _Last1) to [_First2, _Last2)
+        return do_in(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result __CLR_OR_THIS_CALL out(mbstate_t& _State, const wchar_t* _First1, const wchar_t* _Last1,
+        const wchar_t*& _Mid1, char* _First2, char* _Last2, char*& _Mid2) const {
+        // convert [_First1, _Last1) to bytes [_First2, _Last2)
+        return do_out(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result __CLR_OR_THIS_CALL unshift(mbstate_t& _State, char* _First2, char* _Last2, char*& _Mid2) const {
+        // generate bytes to return to default shift state
+        return do_unshift(_State, _First2, _Last2, _Mid2);
+    }
+
+    int __CLR_OR_THIS_CALL length(mbstate_t& _State, const char* _First1, const char* _Last1, size_t _Count) const {
+        // return p - _First1, for the largest value p in [_First1, _Last1] such that [_First1, p) successfully
+        // converts to at most _Count wide characters
+        return do_length(_State, _First1, _Last1, _Count);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id;
+
+    explicit __CLR_OR_THIS_CALL codecvt(size_t _Refs = 0) : codecvt_base(_Refs) {
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    explicit __CLR_OR_THIS_CALL codecvt(const _Locinfo& _Lobj, size_t _Refs = 0) : codecvt_base(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new codecvt(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_CTYPE;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt() noexcept override {}
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo& _Lobj) { // initialize from _Lobj
+        _Cvt = _Lobj._Getcvt();
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_in(mbstate_t&, const char* _First1, const char* _Last1, const char*& _Mid1,
+        wchar_t* _First2, wchar_t* _Last2, wchar_t*& _Mid2) const {
+        // convert bytes [_First1, _Last1) to [_First2, _Last2)
+        mbstate_t _Mystate{};
+        _Adl_verify_range(_First1, _Last1);
+        _Adl_verify_range(_First2, _Last2);
+        _Mid1 = _First1;
+        _Mid2 = _First2;
+        for (;;) {
+            if (_Mid1 == _Last1) {
+                return ok;
+            }
+
+            if (_Mid2 == _Last2) {
+                return partial;
+            }
+
+            int _Bytes = _Mbrtowc(_Mid2, _Mid1, static_cast<size_t>(_Last1 - _Mid1), &_Mystate, &_Cvt);
+            switch (_Bytes) {
+            case -2: // partial conversion
+                return partial;
+
+            case -1: // failed conversion
+                return error;
+
+            case 0: // converted NULL character, TRANSITION, VSO-654347
+                _Bytes = 1;
+                _FALLTHROUGH;
+
+            default: // converted some other character
+                _Mid1 += _Bytes;
+                ++_Mid2;
+                break;
+            }
+        }
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_out(mbstate_t& _State, const wchar_t* _First1, const wchar_t* _Last1,
+        const wchar_t*& _Mid1, char* _First2, char* _Last2, char*& _Mid2) const {
+        // convert [_First1, _Last1) to bytes [_First2, _Last2)
+        _Adl_verify_range(_First1, _Last1);
+        _Adl_verify_range(_First2, _Last2);
+        _Mid1 = _First1;
+        _Mid2 = _First2;
+        int _Bytes;
+
+        while (_Mid1 != _Last1 && _Mid2 != _Last2) {
+            if (MB_LEN_MAX <= _Last2 - _Mid2) {
+                if ((_Bytes = _Wcrtomb(_Mid2, *_Mid1, &_State, &_Cvt)) < 0) {
+                    return error; // locale-specific wcrtomb failed
+                } else {
+                    ++_Mid1;
+                    _Mid2 += _Bytes;
+                }
+            } else { // destination too small, convert into buffer
+                char _Buf[MB_LEN_MAX];
+                mbstate_t _Stsave = _State;
+
+                if ((_Bytes = _Wcrtomb(_Buf, *_Mid1, &_State, &_Cvt)) < 0) {
+                    return error; // locale-specific wcrtomb failed
+                } else if (_Last2 - _Mid2 < _Bytes) { // converted too many, roll back and return previous
+                    _State = _Stsave;
+                    break;
+                } else { // copy converted bytes from buffer
+                    _CSTD memcpy(_Mid2, _Buf, static_cast<size_t>(_Bytes));
+                    ++_Mid1;
+                    _Mid2 += _Bytes;
+                }
+            }
+        }
+
+        return _Mid1 == _Last1 ? ok : partial;
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_unshift(mbstate_t& _State, char* _First2, char* _Last2, char*& _Mid2) const {
+        // generate bytes to return to default shift state
+        _Adl_verify_range(_First2, _Last2);
+        _Mid2       = _First2;
+        result _Ans = ok;
+        int _Bytes;
+        char _Buf[MB_LEN_MAX];
+        mbstate_t _Stsave = _State;
+
+        if ((_Bytes = _Wcrtomb(_Buf, L'\0', &_State, &_Cvt)) <= 0) {
+            _Ans = error; // locale-specific wcrtomb failed
+        } else if (_Last2 - _Mid2 < --_Bytes) { // converted too many, roll back and return
+            _State = _Stsave;
+            _Ans   = partial;
+        } else if (0 < _Bytes) { // copy converted bytes from buffer
+            _CSTD memcpy(_Mid2, _Buf, static_cast<size_t>(_Bytes));
+            _Mid2 += _Bytes;
+        }
+        return _Ans;
+    }
+
+    virtual int __CLR_OR_THIS_CALL do_length(
+        mbstate_t& _State, const char* _First1, const char* _Last1, size_t _Count) const {
+        // return p - _First1, for the largest value p in [_First1, _Last1] such that [_First1, p) successfully
+        // converts to at most _Count wide characters
+        _Adl_verify_range(_First1, _Last1);
+        const auto _Old_first1 = _First1;
+
+        for (; _Count > 0u && _First1 != _Last1; --_Count) {
+            wchar_t _Ch;
+            int _Bytes = _Mbrtowc(&_Ch, _First1, static_cast<size_t>(_Last1 - _First1), &_State, &_Cvt);
+            if (_Bytes < 0) { // partial or failed conversion
+                break;
+            }
+
+            if (_Bytes == 0) { // converted NULL character, TRANSITION, VSO-654347
+                _Bytes = 1;
+            }
+
+            // converted _Bytes bytes to a wide character
+            _First1 += _Bytes;
+        }
+
+        return static_cast<int>((_STD min)(_First1 - _Old_first1, ptrdiff_t{INT_MAX}));
+    }
+
+    bool __CLR_OR_THIS_CALL do_always_noconv() const noexcept override {
+        // return true if conversions never change input
+        return false;
+    }
+
+    int __CLR_OR_THIS_CALL do_max_length() const noexcept override {
+        // return maximum length required for a conversion (from codecvt)
+        return static_cast<int>(_Cvt._Mbcurmax);
+    }
+
+    int __CLR_OR_THIS_CALL do_encoding() const noexcept override {
+        // return length of code sequence (from codecvt)
+        return _Cvt._Mbcurmax == 1; // 0 => varying length, 1 => fixed length
+    }
+
+private:
+    _Locinfo::_Cvtvec _Cvt; // locale info passed to _Mbrtowc, _Wcrtomb
+};
+
+#if defined(_NATIVE_WCHAR_T_DEFINED) && !_ENFORCE_FACET_SPECIALIZATIONS
+extern "C++" template <>
+class _CRTIMP2_PURE_IMPORT codecvt<unsigned short, char, mbstate_t> : public codecvt_base {
+    // facet for converting between unsigned short and char sequences
+public:
+    using intern_type = unsigned short;
+    using extern_type = char;
+    using state_type  = mbstate_t;
+
+    result __CLR_OR_THIS_CALL in(mbstate_t& _State, const char* _First1, const char* _Last1, const char*& _Mid1,
+        unsigned short* _First2, unsigned short* _Last2, unsigned short*& _Mid2) const {
+        // convert bytes [_First1, _Last1) to [_First2, _Last2)
+        return do_in(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result __CLR_OR_THIS_CALL out(mbstate_t& _State, const unsigned short* _First1, const unsigned short* _Last1,
+        const unsigned short*& _Mid1, char* _First2, char* _Last2, char*& _Mid2) const {
+        // convert [_First1, _Last1) to bytes [_First2, _Last2)
+        return do_out(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result __CLR_OR_THIS_CALL unshift(mbstate_t& _State, char* _First2, char* _Last2, char*& _Mid2) const {
+        // generate bytes to return to default shift state
+        return do_unshift(_State, _First2, _Last2, _Mid2);
+    }
+
+    int __CLR_OR_THIS_CALL length(mbstate_t& _State, const char* _First1, const char* _Last1, size_t _Count) const {
+        // return p - _First1, for the largest value p in [_First1, _Last1] such that [_First1, p) successfully
+        // converts to at most _Count _Elems
+        return do_length(_State, _First1, _Last1, _Count);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id;
+
+    explicit __CLR_OR_THIS_CALL codecvt(size_t _Refs = 0) : codecvt_base(_Refs) {
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    explicit __CLR_OR_THIS_CALL codecvt(const _Locinfo& _Lobj, size_t _Refs = 0) : codecvt_base(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new codecvt(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_CTYPE;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt() noexcept override {}
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo& _Lobj) { // initialize from _Lobj
+        _Cvt = _Lobj._Getcvt();
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_in(mbstate_t&, const char* _First1, const char* _Last1, const char*& _Mid1,
+        unsigned short* _First2, unsigned short* _Last2, unsigned short*& _Mid2) const {
+        // convert bytes [_First1, _Last1) to [_First2, _Last2)
+        mbstate_t _Mystate{};
+        _Adl_verify_range(_First1, _Last1);
+        _Adl_verify_range(_First2, _Last2);
+        _Mid1 = _First1;
+        _Mid2 = _First2;
+        for (;;) {
+            if (_Mid1 == _Last1) {
+                return ok;
+            }
+
+            if (_Mid2 == _Last2) {
+                return partial;
+            }
+
+            int _Bytes = _Mbrtowc(
+                reinterpret_cast<wchar_t*>(_Mid2), _Mid1, static_cast<size_t>(_Last1 - _Mid1), &_Mystate, &_Cvt);
+            switch (_Bytes) {
+            case -2: // partial conversion
+                return partial;
+
+            case -1: // failed conversion
+                return error;
+
+            case 0: // converted NULL character, TRANSITION, VSO-654347
+                _Bytes = 1;
+                _FALLTHROUGH;
+
+            default: // converted some other character
+                _Mid1 += _Bytes;
+                ++_Mid2;
+                break;
+            }
+        }
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_out(mbstate_t& _State, const unsigned short* _First1,
+        const unsigned short* _Last1, const unsigned short*& _Mid1, char* _First2, char* _Last2, char*& _Mid2) const {
+        // convert [_First1, _Last1) to bytes [_First2, _Last2)
+        _Adl_verify_range(_First1, _Last1);
+        _Adl_verify_range(_First2, _Last2);
+        _Mid1 = _First1;
+        _Mid2 = _First2;
+        int _Bytes;
+
+        while (_Mid1 != _Last1 && _Mid2 != _Last2) {
+            if (MB_LEN_MAX <= _Last2 - _Mid2) {
+                if ((_Bytes = _Wcrtomb(_Mid2, *_Mid1, &_State, &_Cvt)) < 0) {
+                    return error; // locale-specific wcrtomb failed
+                } else {
+                    ++_Mid1;
+                    _Mid2 += _Bytes;
+                }
+            } else { // destination too small, convert into buffer
+                char _Buf[MB_LEN_MAX];
+                mbstate_t _Stsave = _State;
+
+                if ((_Bytes = _Wcrtomb(_Buf, *_Mid1, &_State, &_Cvt)) < 0) {
+                    return error; // locale-specific wcrtomb failed
+                } else if (_Last2 - _Mid2 < _Bytes) { // converted too many, roll back and return previous
+                    _State = _Stsave;
+                    break;
+                } else { // copy converted bytes from buffer
+                    _CSTD memcpy(_Mid2, _Buf, static_cast<size_t>(_Bytes));
+                    ++_Mid1;
+                    _Mid2 += _Bytes;
+                }
+            }
+        }
+
+        return _Mid1 == _Last1 ? ok : partial;
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_unshift(mbstate_t& _State, char* _First2, char* _Last2, char*& _Mid2) const {
+        // generate bytes to return to default shift state
+        _Adl_verify_range(_First2, _Last2);
+        _Mid2       = _First2;
+        result _Ans = ok;
+        int _Bytes;
+        char _Buf[MB_LEN_MAX];
+        mbstate_t _Stsave = _State;
+
+        if ((_Bytes = _Wcrtomb(_Buf, L'\0', &_State, &_Cvt)) <= 0) {
+            _Ans = error; // locale-specific wcrtomb failed
+        } else if (_Last2 - _Mid2 < --_Bytes) { // converted too many, roll back and return
+            _State = _Stsave;
+            _Ans   = partial;
+        } else if (0 < _Bytes) { // copy converted bytes from buffer
+            _CSTD memcpy(_Mid2, _Buf, static_cast<size_t>(_Bytes));
+            _Mid2 += _Bytes;
+        }
+
+        return _Ans;
+    }
+
+    virtual int __CLR_OR_THIS_CALL do_length(
+        mbstate_t& _State, const char* _First1, const char* _Last1, size_t _Count) const {
+        // return p - _First1, for the largest value p in [_First1, _Last1] such that [_First1, p) successfully
+        // converts to at most _Count wide characters
+        _Adl_verify_range(_First1, _Last1);
+        const auto _Old_first1 = _First1;
+
+        for (; _Count > 0u && _First1 != _Last1; --_Count) {
+            wchar_t _Ch;
+            int _Bytes = _Mbrtowc(&_Ch, _First1, static_cast<size_t>(_Last1 - _First1), &_State, &_Cvt);
+            if (_Bytes < 0) { // partial or failed conversion
+                break;
+            }
+
+            if (_Bytes == 0) { // converted NULL character, TRANSITION, VSO-654347
+                _Bytes = 1;
+            }
+
+            // converted _Bytes bytes to a wide character
+            _First1 += _Bytes;
+        }
+
+        return static_cast<int>((_STD min)(_First1 - _Old_first1, ptrdiff_t{INT_MAX}));
+    }
+
+    bool __CLR_OR_THIS_CALL do_always_noconv() const noexcept override {
+        // return true if conversions never change input
+        return false;
+    }
+
+    int __CLR_OR_THIS_CALL do_max_length() const noexcept override {
+        // return maximum length required for a conversion (from codecvt)
+        return static_cast<int>(_Cvt._Mbcurmax);
+    }
+
+    int __CLR_OR_THIS_CALL do_encoding() const noexcept override {
+        // return length of code sequence (from codecvt)
+        return _Cvt._Mbcurmax == 1u; // 0 => varying length, 1 => fixed length
+    }
+
+private:
+    _Locinfo::_Cvtvec _Cvt; // locale info passed to _Mbrtowc, _Wcrtomb
+};
+#endif // defined(_NATIVE_WCHAR_T_DEFINED) && !_ENFORCE_FACET_SPECIALIZATIONS
+
+_EXPORT_STD template <class _Elem, class _Byte, class _Statype>
+class codecvt_byname : public codecvt<_Elem, _Byte, _Statype> {
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS
+                      || _Is_any_of_v<codecvt_byname, codecvt_byname<char, char, mbstate_t>,
+                          codecvt_byname<wchar_t, char, mbstate_t>>,
+        _FACET_SPECIALIZATION_MESSAGE);
+
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const char* _Locname, size_t _Refs = 0)
+        : codecvt<_Elem, _Byte, _Statype>(_Locinfo(_Locname), _Refs) {}
+
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const string& _Str, size_t _Refs = 0)
+        : codecvt<_Elem, _Byte, _Statype>(_Locinfo(_Str.c_str()), _Refs) {}
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt_byname() noexcept override {}
+};
+
+_STL_DISABLE_DEPRECATED_WARNING
+
+template <>
+class _CXX20_DEPRECATE_CODECVT_FACETS codecvt_byname<char16_t, char, mbstate_t>
+    : public codecvt<char16_t, char, mbstate_t> {
+public:
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const char* _Locname, size_t _Refs = 0)
+        : codecvt(_Locinfo(_Locname), _Refs) {}
+
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const string& _Str, size_t _Refs = 0)
+        : codecvt(_Locinfo(_Str.c_str()), _Refs) {}
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt_byname() noexcept override {}
+};
+
+template <>
+class _CXX20_DEPRECATE_CODECVT_FACETS codecvt_byname<char32_t, char, mbstate_t>
+    : public codecvt<char32_t, char, mbstate_t> {
+public:
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const char* _Locname, size_t _Refs = 0)
+        : codecvt(_Locinfo(_Locname), _Refs) {}
+
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const string& _Str, size_t _Refs = 0)
+        : codecvt(_Locinfo(_Str.c_str()), _Refs) {}
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt_byname() noexcept override {}
+};
+
+#ifdef __cpp_char8_t
+template <>
+class _CXX20_DEPRECATE_CODECVT_CHAR8_T_FACETS codecvt_byname<char16_t, char8_t, mbstate_t>
+    : public codecvt<char16_t, char8_t, mbstate_t> {
+public:
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const char* _Locname, size_t _Refs = 0)
+        : codecvt(_Locinfo(_Locname), _Refs) {}
+
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const string& _Str, size_t _Refs = 0)
+        : codecvt(_Locinfo(_Str.c_str()), _Refs) {}
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt_byname() noexcept override {}
+};
+
+template <>
+class _CXX20_DEPRECATE_CODECVT_CHAR8_T_FACETS codecvt_byname<char32_t, char8_t, mbstate_t>
+    : public codecvt<char32_t, char8_t, mbstate_t> {
+public:
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const char* _Locname, size_t _Refs = 0)
+        : codecvt(_Locinfo(_Locname), _Refs) {}
+
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const string& _Str, size_t _Refs = 0)
+        : codecvt(_Locinfo(_Str.c_str()), _Refs) {}
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt_byname() noexcept override {}
+};
+#endif // defined(__cpp_char8_t)
+
+_STL_RESTORE_DEPRECATED_WARNING
+
+#define _XA 0x100 // extra alphabetic
+#define _BB _CONTROL // BEL, BS, etc.
+#define _CN _SPACE // CR, FF, HT, NL, VT
+#define _DI _DIGIT // '0'-'9'
+#define _LO _LOWER // 'a'-'z'
+#define _PU _PUNCT // punctuation
+#define _SP _BLANK // space
+#define _UP _UPPER // 'A'-'Z'
+#define _XD _HEX // '0'-'9', 'A'-'F', 'a'-'f'
+
+_EXPORT_STD extern "C++" struct _CRTIMP2_PURE_IMPORT ctype_base // base for ctype
+    : locale::facet // TRANSITION, ABI, shouldn't be derived from locale::facet
+{
+    enum { // constants for character classifications
+        alnum  = _DI | _LO | _UP | _XA,
+        alpha  = _LO | _UP | _XA,
+        cntrl  = _BB,
+        digit  = _DI,
+        graph  = _DI | _LO | _PU | _UP | _XA,
+        lower  = _LO,
+        print  = _DI | _LO | _PU | _SP | _UP | _XA | _XD,
+        punct  = _PU,
+        space  = _CN | _SP,
+        upper  = _UP,
+        xdigit = _XD,
+        blank  = _CN | _SP
+    };
+    using mask = short; // to match <ctype.h>
+
+    __CLR_OR_THIS_CALL ctype_base(size_t _Refs = 0) noexcept // strengthened
+        : locale::facet(_Refs) {}
+
+    __CLR_OR_THIS_CALL ~ctype_base() noexcept override {}
+};
+
+#undef _XA
+#undef _BB
+#undef _CN
+#undef _DI
+#undef _LO
+#undef _PU
+#undef _SP
+#undef _UP
+#undef _XD
+
+_EXPORT_STD extern "C++" template <class _Elem>
+class ctype : public ctype_base { // facet for classifying elements, converting cases
+public:
+    // ctype<char>, ctype<wchar_t>, and ctype<unsigned short> are explicitly specialized below.
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Always_false<_Elem>, _FACET_SPECIALIZATION_MESSAGE);
+
+    using char_type = _Elem;
+
+    bool __CLR_OR_THIS_CALL is(mask _Maskval, _Elem _Ch) const { // test if element fits any mask classifications
+        return do_is(_Maskval, _Ch);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL is(const _Elem* _First, const _Elem* _Last,
+        mask* _Dest) const { // get mask sequence for elements in [_First, _Last)
+        return do_is(_First, _Last, _Dest);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL scan_is(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) that fits mask classification
+        return do_scan_is(_Maskval, _First, _Last);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL scan_not(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) not fitting mask classification
+        return do_scan_not(_Maskval, _First, _Last);
+    }
+
+    _Elem __CLR_OR_THIS_CALL tolower(_Elem _Ch) const { // convert element to lower case
+        return do_tolower(_Ch);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL tolower(
+        _Elem* _First, const _Elem* _Last) const { // convert [_First, _Last) in place to lower case
+        return do_tolower(_First, _Last);
+    }
+
+    _Elem __CLR_OR_THIS_CALL toupper(_Elem _Ch) const { // convert element to upper case
+        return do_toupper(_Ch);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL toupper(
+        _Elem* _First, const _Elem* _Last) const { // convert [_First, _Last) in place to upper case
+        return do_toupper(_First, _Last);
+    }
+
+    _Elem __CLR_OR_THIS_CALL widen(char _Byte) const { // widen char
+        return do_widen(_Byte);
+    }
+
+    const char* __CLR_OR_THIS_CALL widen(const char* _First, const char* _Last,
+        _Elem* _Dest) const { // widen chars in [_First, _Last)
+        return do_widen(_First, _Last, _Dest);
+    }
+
+    char __CLR_OR_THIS_CALL narrow(_Elem _Ch, char _Dflt = '\0') const { // narrow element to char
+        return do_narrow(_Ch, _Dflt);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL narrow(const _Elem* _First, const _Elem* _Last, char _Dflt,
+        char* _Dest) const { // narrow elements in [_First, _Last) to chars
+        return do_narrow(_First, _Last, _Dflt, _Dest);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id;
+
+    explicit __CLR_OR_THIS_CALL ctype(size_t _Refs = 0) : ctype_base(_Refs) {
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    __CLR_OR_THIS_CALL ctype(const _Locinfo& _Lobj, size_t _Refs = 0) : ctype_base(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new ctype<_Elem>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_CTYPE;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~ctype() noexcept override {
+        if (_Ctype._Delfl) {
+            _CSTD free(const_cast<short*>(_Ctype._Table));
+        }
+
+        _CSTD free(_Ctype._LocaleName);
+    }
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo& _Lobj) { // initialize from _Lobj
+        _Ctype = _Lobj._Getctype();
+        _Cvt   = _Lobj._Getcvt();
+    }
+
+    virtual bool __CLR_OR_THIS_CALL do_is(
+        mask _Maskval, _Elem _Ch) const { // test if element fits any mask classifications
+        return (_Ctype._Table[static_cast<unsigned char>(narrow(_Ch))] & _Maskval) != 0;
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_is(const _Elem* _First, const _Elem* _Last,
+        mask* _Dest) const { // get mask sequence for elements in [_First, _Last)
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First, ++_Dest) {
+            *_Dest = _Ctype._Table[static_cast<unsigned char>(narrow(*_First))];
+        }
+
+        return _First;
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_scan_is(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) that fits mask classification
+        _Adl_verify_range(_First, _Last);
+        while (_First != _Last && !is(_Maskval, *_First)) {
+            ++_First;
+        }
+
+        return _First;
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_scan_not(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) not fitting mask classification
+        _Adl_verify_range(_First, _Last);
+        while (_First != _Last && is(_Maskval, *_First)) {
+            ++_First;
+        }
+
+        return _First;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_tolower(_Elem _Ch) const { // convert element to lower case
+        unsigned char _Byte = static_cast<unsigned char>(narrow(_Ch, '\0'));
+        if (_Byte == '\0') {
+            return _Ch;
+        }
+
+        return widen(static_cast<char>(_Tolower(_Byte, &_Ctype)));
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_tolower(_Elem* _First,
+        const _Elem* _Last) const { // convert [_First, _Last) in place to lower case
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First) { // convert *_First to lower case
+            unsigned char _Byte = static_cast<unsigned char>(narrow(*_First, '\0'));
+            if (_Byte != '\0') {
+                *_First = (widen(static_cast<char>(_Tolower(_Byte, &_Ctype))));
+            }
+        }
+        return _First;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_toupper(_Elem _Ch) const { // convert element to upper case
+        unsigned char _Byte = static_cast<unsigned char>(narrow(_Ch, '\0'));
+        if (_Byte == '\0') {
+            return _Ch;
+        }
+
+        return widen(static_cast<char>(_Toupper(_Byte, &_Ctype)));
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_toupper(_Elem* _First,
+        const _Elem* _Last) const { // convert [_First, _Last) in place to upper case
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First) { // convert *_First to upper case
+            unsigned char _Byte = static_cast<unsigned char>(narrow(*_First, '\0'));
+            if (_Byte != '\0') {
+                *_First = (widen(static_cast<char>(_Toupper(_Byte, &_Ctype))));
+            }
+        }
+
+        return _First;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_widen(char _Byte) const { // widen char
+        return _Maklocchr(_Byte, static_cast<_Elem*>(nullptr), _Cvt);
+    }
+
+    virtual const char* __CLR_OR_THIS_CALL do_widen(
+        const char* _First, const char* _Last, _Elem* _Dest) const { // widen chars in [_First, _Last)
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First, ++_Dest) {
+            *_Dest = _Maklocchr(*_First, static_cast<_Elem*>(nullptr), _Cvt);
+        }
+
+        return _First;
+    }
+
+    char __CLR_OR_THIS_CALL _Donarrow(_Elem _Ch, char _Dflt) const { // narrow element to char
+        char _Byte;
+        if (_Ch == _Elem{}) {
+            return '\0';
+        }
+
+        if ((_Byte = _Maklocbyte(_Ch, _Cvt)) == '\0') {
+            return _Dflt;
+        }
+
+        return _Byte;
+    }
+
+    virtual char __CLR_OR_THIS_CALL do_narrow(_Elem _Ch, char _Dflt) const { // narrow element to char
+        return _Donarrow(_Ch, _Dflt);
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_narrow(const _Elem* _First, const _Elem* _Last, char _Dflt,
+        char* _Dest) const { // narrow elements in [_First, _Last) to chars
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First, ++_Dest) {
+            *_Dest = _Donarrow(*_First, _Dflt);
+        }
+
+        return _First;
+    }
+
+private:
+    _Locinfo::_Ctypevec _Ctype; // locale info passed to _Tolower, etc.
+    _Locinfo::_Cvtvec _Cvt; // conversion information
+};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _Elem>
+locale::id ctype<_Elem>::id;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+
+extern "C++" template <>
+class _CRTIMP2_PURE_IMPORT ctype<char> : public ctype_base { // facet for classifying char elements, converting cases
+public:
+    using _Elem     = char;
+    using char_type = _Elem;
+
+    bool __CLR_OR_THIS_CALL is(mask _Maskval, _Elem _Ch) const { // test if element fits any mask classifications
+        return (_Ctype._Table[static_cast<unsigned char>(_Ch)] & _Maskval) != 0;
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL is(const _Elem* _First, const _Elem* _Last,
+        mask* _Dest) const { // get mask sequence for elements in [_First, _Last)
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First, ++_Dest) {
+            *_Dest = _Ctype._Table[static_cast<unsigned char>(*_First)];
+        }
+
+        return _First;
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL scan_is(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) that fits mask classification
+        _Adl_verify_range(_First, _Last);
+        while (_First != _Last && !is(_Maskval, *_First)) {
+            ++_First;
+        }
+
+        return _First;
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL scan_not(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) not fitting mask classification
+        _Adl_verify_range(_First, _Last);
+        while (_First != _Last && is(_Maskval, *_First)) {
+            ++_First;
+        }
+
+        return _First;
+    }
+
+    _Elem __CLR_OR_THIS_CALL tolower(_Elem _Ch) const { // convert element to lower case
+        return do_tolower(_Ch);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL tolower(
+        _Elem* _First, const _Elem* _Last) const { // convert [_First, _Last) in place to lower case
+        return do_tolower(_First, _Last);
+    }
+
+    _Elem __CLR_OR_THIS_CALL toupper(_Elem _Ch) const { // convert element to upper case
+        return do_toupper(_Ch);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL toupper(
+        _Elem* _First, const _Elem* _Last) const { // convert [_First, _Last) in place to upper case
+        return do_toupper(_First, _Last);
+    }
+
+    _Elem __CLR_OR_THIS_CALL widen(char _Byte) const { // widen char
+        return do_widen(_Byte);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL widen(const char* _First, const char* _Last,
+        _Elem* _Dest) const { // widen chars in [_First, _Last)
+        return do_widen(_First, _Last, _Dest);
+    }
+
+    _Elem __CLR_OR_THIS_CALL narrow(_Elem _Ch, char _Dflt = '\0') const { // narrow element to char
+        return do_narrow(_Ch, _Dflt);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL narrow(const _Elem* _First, const _Elem* _Last, char _Dflt,
+        char* _Dest) const { // narrow elements in [_First, _Last) to chars
+        return do_narrow(_First, _Last, _Dflt, _Dest);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id;
+
+    explicit __CLR_OR_THIS_CALL ctype(const mask* _Table = nullptr, bool _Deletetable = false,
+        size_t _Refs = 0)
+        : ctype_base(_Refs) { // construct with specified table and delete flag for table
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+
+        _Tidy(); // free existing table, as needed
+        if (_Table) { // replace existing char to mask table
+            _Ctype._Table = _Table;
+            _Ctype._Delfl = _Deletetable ? -1 : 0;
+        } else { // use classic table
+            _Ctype._Table = classic_table();
+            _Ctype._Delfl = 0;
+        }
+    }
+
+    __CLR_OR_THIS_CALL ctype(const _Locinfo& _Lobj, size_t _Refs = 0) : ctype_base(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new ctype<_Elem>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_CTYPE;
+    }
+
+    const mask* __CLR_OR_THIS_CALL table() const noexcept {
+        return _Ctype._Table;
+    }
+
+    static const mask* __CLRCALL_OR_CDECL classic_table() noexcept {
+        return _STD use_facet<ctype>(locale::classic()).table();
+    }
+
+    _PGLOBAL static const size_t table_size = 1 << CHAR_BIT; // size of ctype mapping table, typically 256
+
+protected:
+    __CLR_OR_THIS_CALL ~ctype() noexcept override {
+        _Tidy();
+    }
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo& _Lobj) { // initialize from _Lobj
+        _Ctype = _Lobj._Getctype();
+    }
+
+    void __CLR_OR_THIS_CALL _Tidy() noexcept { // free any allocated storage
+        if (0 < _Ctype._Delfl) {
+            _CSTD free(const_cast<short*>(_Ctype._Table));
+        } else if (_Ctype._Delfl < 0) {
+            delete[] _Ctype._Table;
+        }
+
+        _CSTD free(_Ctype._LocaleName);
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_tolower(_Elem _Ch) const { // convert element to lower case
+        return static_cast<_Elem>(_Tolower(static_cast<unsigned char>(_Ch), &_Ctype));
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_tolower(_Elem* _First,
+        const _Elem* _Last) const { // convert [_First, _Last) in place to lower case
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First) {
+            *_First = static_cast<_Elem>(_Tolower(static_cast<unsigned char>(*_First), &_Ctype));
+        }
+
+        return _First;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_toupper(_Elem _Ch) const { // convert element to upper case
+        return static_cast<_Elem>(_Toupper(static_cast<unsigned char>(_Ch), &_Ctype));
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_toupper(_Elem* _First,
+        const _Elem* _Last) const { // convert [_First, _Last) in place to upper case
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First) {
+            *_First = static_cast<_Elem>(_Toupper(static_cast<unsigned char>(*_First), &_Ctype));
+        }
+
+        return _First;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_widen(char _Byte) const { // widen char
+        return _Byte;
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_widen(
+        const char* _First, const char* _Last, _Elem* _Dest) const { // widen chars in [_First, _Last)
+        _Adl_verify_range(_First, _Last);
+        _CSTD memcpy(_Dest, _First, static_cast<size_t>(_Last - _First));
+        return _Last;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_narrow(_Elem _Ch, char) const { // narrow char
+        return _Ch;
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_narrow(const _Elem* _First, const _Elem* _Last, char,
+        char* _Dest) const { // narrow elements in [_First, _Last) to chars
+        _Adl_verify_range(_First, _Last);
+        _CSTD memcpy(_Dest, _First, static_cast<size_t>(_Last - _First));
+        return _Last;
+    }
+
+private:
+    _Locinfo::_Ctypevec _Ctype; // information
+};
+
+extern "C++" template <>
+class _CRTIMP2_PURE_IMPORT ctype<wchar_t>
+    : public ctype_base { // facet for classifying wchar_t elements, converting cases
+public:
+    using _Elem     = wchar_t;
+    using char_type = _Elem;
+
+    bool __CLR_OR_THIS_CALL is(mask _Maskval, _Elem _Ch) const { // test if element fits any mask classifications
+        return do_is(_Maskval, _Ch);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL is(const _Elem* _First, const _Elem* _Last,
+        mask* _Dest) const { // get mask sequence for elements in [_First, _Last)
+        return do_is(_First, _Last, _Dest);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL scan_is(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) that fits mask classification
+        return do_scan_is(_Maskval, _First, _Last);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL scan_not(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) not fitting mask classification
+        return do_scan_not(_Maskval, _First, _Last);
+    }
+
+    _Elem __CLR_OR_THIS_CALL tolower(_Elem _Ch) const { // convert element to lower case
+        return do_tolower(_Ch);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL tolower(
+        _Elem* _First, const _Elem* _Last) const { // convert [_First, _Last) in place to lower case
+        return do_tolower(_First, _Last);
+    }
+
+    _Elem __CLR_OR_THIS_CALL toupper(_Elem _Ch) const { // convert element to upper case
+        return do_toupper(_Ch);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL toupper(
+        _Elem* _First, const _Elem* _Last) const { // convert [_First, _Last) in place to upper case
+        return do_toupper(_First, _Last);
+    }
+
+    _Elem __CLR_OR_THIS_CALL widen(char _Byte) const { // widen char
+        return do_widen(_Byte);
+    }
+
+    const char* __CLR_OR_THIS_CALL widen(const char* _First, const char* _Last,
+        _Elem* _Dest) const { // widen chars in [_First, _Last)
+        return do_widen(_First, _Last, _Dest);
+    }
+
+    char __CLR_OR_THIS_CALL narrow(_Elem _Ch, char _Dflt = '\0') const { // narrow element to char
+        return do_narrow(_Ch, _Dflt);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL narrow(const _Elem* _First, const _Elem* _Last, char _Dflt,
+        char* _Dest) const { // narrow elements in [_First, _Last) to chars
+        return do_narrow(_First, _Last, _Dflt, _Dest);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id;
+
+    explicit __CLR_OR_THIS_CALL ctype(size_t _Refs = 0) : ctype_base(_Refs) {
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    __CLR_OR_THIS_CALL ctype(const _Locinfo& _Lobj, size_t _Refs = 0) : ctype_base(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new ctype<_Elem>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_CTYPE;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~ctype() noexcept override {
+        if (_Ctype._Delfl) {
+            _CSTD free(const_cast<short*>(_Ctype._Table));
+        }
+
+        _CSTD free(_Ctype._LocaleName);
+    }
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo& _Lobj) { // initialize from _Lobj
+        _Ctype = _Lobj._Getctype();
+        _Cvt   = _Lobj._Getcvt();
+    }
+
+    virtual bool __CLR_OR_THIS_CALL do_is(
+        mask _Maskval, _Elem _Ch) const { // test if element fits any mask classifications
+        return (_CSTD _Getwctype(_Ch, &_Ctype) & _Maskval) != 0;
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_is(const _Elem* _First, const _Elem* _Last,
+        mask* _Dest) const { // get mask sequence for elements in [_First, _Last)
+        _Adl_verify_range(_First, _Last);
+        return _CSTD _Getwctypes(_First, _Last, _Dest, &_Ctype);
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_scan_is(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) that fits mask classification
+        _Adl_verify_range(_First, _Last);
+        while (_First != _Last && !is(_Maskval, *_First)) {
+            ++_First;
+        }
+
+        return _First;
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_scan_not(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) not fitting mask classification
+        _Adl_verify_range(_First, _Last);
+        while (_First != _Last && is(_Maskval, *_First)) {
+            ++_First;
+        }
+
+        return _First;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_tolower(_Elem _Ch) const { // convert element to lower case
+        return _Towlower(_Ch, &_Ctype);
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_tolower(_Elem* _First,
+        const _Elem* _Last) const { // convert [_First, _Last) in place to lower case
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First) {
+            *_First = _Towlower(*_First, &_Ctype);
+        }
+
+        return _First;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_toupper(_Elem _Ch) const { // convert element to upper case
+        return _Towupper(_Ch, &_Ctype);
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_toupper(_Elem* _First,
+        const _Elem* _Last) const { // convert [_First, _Last) in place to upper case
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First) {
+            *_First = _Towupper(*_First, &_Ctype);
+        }
+
+        return _First;
+    }
+
+    _Elem __CLR_OR_THIS_CALL _Dowiden(char _Byte) const { // widen char
+        mbstate_t _Mbst = {};
+        wchar_t _Wc;
+        return _Mbrtowc(&_Wc, &_Byte, 1, &_Mbst, &_Cvt) < 0 ? static_cast<wchar_t>(WEOF) : _Wc;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_widen(char _Byte) const { // widen char
+        return _Dowiden(_Byte);
+    }
+
+    virtual const char* __CLR_OR_THIS_CALL do_widen(
+        const char* _First, const char* _Last, _Elem* _Dest) const { // widen chars in [_First, _Last)
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First, ++_Dest) {
+            *_Dest = _Dowiden(*_First);
+        }
+
+        return _First;
+    }
+
+    char __CLR_OR_THIS_CALL _Donarrow(_Elem _Ch, char _Dflt) const { // narrow element to char
+        char _Buf[MB_LEN_MAX];
+        mbstate_t _Mbst = {};
+        return _Wcrtomb(_Buf, _Ch, &_Mbst, &_Cvt) != 1 ? _Dflt : _Buf[0];
+    }
+
+    virtual char __CLR_OR_THIS_CALL do_narrow(_Elem _Ch, char _Dflt) const { // narrow element to char
+        return _Donarrow(_Ch, _Dflt);
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_narrow(const _Elem* _First, const _Elem* _Last, char _Dflt,
+        char* _Dest) const { // narrow elements in [_First, _Last) to chars
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First, ++_Dest) {
+            *_Dest = _Donarrow(*_First, _Dflt);
+        }
+
+        return _First;
+    }
+
+private:
+    _Locinfo::_Ctypevec _Ctype; // locale info passed to _Tolower, etc.
+    _Locinfo::_Cvtvec _Cvt; // conversion information
+};
+
+#if defined(_NATIVE_WCHAR_T_DEFINED) && !_ENFORCE_FACET_SPECIALIZATIONS
+extern "C++" template <>
+class _CRTIMP2_PURE_IMPORT ctype<unsigned short>
+    : public ctype_base { // facet for classifying unsigned short elements, converting cases
+public:
+    using _Elem     = unsigned short;
+    using char_type = _Elem;
+
+    bool __CLR_OR_THIS_CALL is(mask _Maskval, _Elem _Ch) const { // test if element fits any mask classifications
+        return do_is(_Maskval, _Ch);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL is(const _Elem* _First, const _Elem* _Last,
+        mask* _Dest) const { // get mask sequence for elements in [_First, _Last)
+        return do_is(_First, _Last, _Dest);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL scan_is(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) that fits mask classification
+        return do_scan_is(_Maskval, _First, _Last);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL scan_not(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) not fitting mask classification
+        return do_scan_not(_Maskval, _First, _Last);
+    }
+
+    _Elem __CLR_OR_THIS_CALL tolower(_Elem _Ch) const { // convert element to lower case
+        return do_tolower(_Ch);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL tolower(
+        _Elem* _First, const _Elem* _Last) const { // convert [_First, _Last) in place to lower case
+        return do_tolower(_First, _Last);
+    }
+
+    _Elem __CLR_OR_THIS_CALL toupper(_Elem _Ch) const { // convert element to upper case
+        return do_toupper(_Ch);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL toupper(
+        _Elem* _First, const _Elem* _Last) const { // convert [_First, _Last) in place to upper case
+        return do_toupper(_First, _Last);
+    }
+
+    _Elem __CLR_OR_THIS_CALL widen(char _Byte) const { // widen char
+        return do_widen(_Byte);
+    }
+
+    const char* __CLR_OR_THIS_CALL widen(const char* _First, const char* _Last,
+        _Elem* _Dest) const { // widen chars in [_First, _Last)
+        return do_widen(_First, _Last, _Dest);
+    }
+
+    char __CLR_OR_THIS_CALL narrow(_Elem _Ch, char _Dflt = '\0') const { // narrow element to char
+        return do_narrow(_Ch, _Dflt);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL narrow(const _Elem* _First, const _Elem* _Last, char _Dflt,
+        char* _Dest) const { // narrow elements in [_First, _Last) to chars
+        return do_narrow(_First, _Last, _Dflt, _Dest);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id;
+
+    explicit __CLR_OR_THIS_CALL ctype(size_t _Refs = 0) : ctype_base(_Refs) {
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    __CLR_OR_THIS_CALL ctype(const _Locinfo& _Lobj, size_t _Refs = 0) : ctype_base(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new ctype<_Elem>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_CTYPE;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~ctype() noexcept override {
+        if (_Ctype._Delfl) {
+            _CSTD free(const_cast<short*>(_Ctype._Table));
+        }
+
+        _CSTD free(_Ctype._LocaleName);
+    }
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo& _Lobj) { // initialize from _Lobj
+        _Ctype = _Lobj._Getctype();
+        _Cvt   = _Lobj._Getcvt();
+    }
+
+    virtual bool __CLR_OR_THIS_CALL do_is(
+        mask _Maskval, _Elem _Ch) const { // test if element fits any mask classifications
+        return (_CSTD _Getwctype(_Ch, &_Ctype) & _Maskval) != 0;
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_is(const _Elem* _First, const _Elem* _Last,
+        mask* _Dest) const { // get mask sequence for elements in [_First, _Last)
+        _Adl_verify_range(_First, _Last);
+        return reinterpret_cast<const _Elem*>(_CSTD _Getwctypes(
+            reinterpret_cast<const wchar_t*>(_First), reinterpret_cast<const wchar_t*>(_Last), _Dest, &_Ctype));
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_scan_is(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) that fits mask classification
+        _Adl_verify_range(_First, _Last);
+        while (_First != _Last && !is(_Maskval, *_First)) {
+            ++_First;
+        }
+
+        return _First;
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_scan_not(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) not fitting mask classification
+        _Adl_verify_range(_First, _Last);
+        while (_First != _Last && is(_Maskval, *_First)) {
+            ++_First;
+        }
+
+        return _First;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_tolower(_Elem _Ch) const { // convert element to lower case
+        return _Towlower(_Ch, &_Ctype);
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_tolower(_Elem* _First,
+        const _Elem* _Last) const { // convert [_First, _Last) in place to lower case
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First) {
+            *_First = _Towlower(*_First, &_Ctype);
+        }
+
+        return _First;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_toupper(_Elem _Ch) const { // convert element to upper case
+        return _Towupper(_Ch, &_Ctype);
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_toupper(_Elem* _First,
+        const _Elem* _Last) const { // convert [_First, _Last) in place to upper case
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First) {
+            *_First = _Towupper(*_First, &_Ctype);
+        }
+
+        return _First;
+    }
+
+    _Elem __CLR_OR_THIS_CALL _Dowiden(char _Byte) const { // widen char
+        mbstate_t _Mbst = {};
+        unsigned short _Wc;
+
+        if (_Mbrtowc(reinterpret_cast<wchar_t*>(&_Wc), &_Byte, 1, &_Mbst, &_Cvt) < 0) {
+            return static_cast<unsigned short>(WEOF);
+        }
+
+        return _Wc;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_widen(char _Byte) const { // widen char
+        return _Dowiden(_Byte);
+    }
+
+    virtual const char* __CLR_OR_THIS_CALL do_widen(
+        const char* _First, const char* _Last, _Elem* _Dest) const { // widen chars in [_First, _Last)
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First, ++_Dest) {
+            *_Dest = _Dowiden(*_First);
+        }
+
+        return _First;
+    }
+
+    char __CLR_OR_THIS_CALL _Donarrow(_Elem _Ch, char _Dflt) const { // narrow element to char
+        char _Buf[MB_LEN_MAX];
+        mbstate_t _Mbst = {};
+        return _Wcrtomb(_Buf, _Ch, &_Mbst, &_Cvt) != 1 ? _Dflt : _Buf[0];
+    }
+
+    virtual char __CLR_OR_THIS_CALL do_narrow(_Elem _Ch, char _Dflt) const { // narrow element to char
+        return _Donarrow(_Ch, _Dflt);
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_narrow(const _Elem* _First, const _Elem* _Last, char _Dflt,
+        char* _Dest) const { // narrow elements in [_First, _Last) to chars
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First, ++_Dest) {
+            *_Dest = _Donarrow(*_First, _Dflt);
+        }
+
+        return _First;
+    }
+
+private:
+    _Locinfo::_Ctypevec _Ctype; // locale info passed to _Tolower, etc.
+    _Locinfo::_Cvtvec _Cvt; // conversion information
+};
+#endif // defined(_NATIVE_WCHAR_T_DEFINED) && !_ENFORCE_FACET_SPECIALIZATIONS
+
+_EXPORT_STD template <class _Elem>
+class ctype_byname : public ctype<_Elem> { // ctype for named locale
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    explicit __CLR_OR_THIS_CALL ctype_byname(const char* _Locname, size_t _Refs = 0)
+        : ctype<_Elem>(_Locinfo(_Locname), _Refs) {} // construct for named locale
+
+    explicit __CLR_OR_THIS_CALL ctype_byname(const string& _Str, size_t _Refs = 0)
+        : ctype<_Elem>(_Locinfo(_Str.c_str()), _Refs) {} // construct for named locale
+
+protected:
+    __CLR_OR_THIS_CALL ~ctype_byname() noexcept override {}
+};
+
+enum class _Case_sensitive : bool { _Nope, _Yes };
+
+template <class _InIt, class _Elem>
+int __CRTDECL _Getloctxt(
+    _InIt& _First, _InIt& _Last, size_t _Numfields, const _Elem* _Ptr, const _Case_sensitive _Matching) {
+    // find field at _Ptr that matches longest in [_First, _Last)
+    for (size_t _Off = 0; _Ptr[_Off] != _Elem{}; ++_Off) {
+        if (_Ptr[_Off] == _Ptr[0]) {
+            ++_Numfields; // add fields with leading mark to initial count
+        }
+    }
+
+    string _Str(_Numfields, '\0'); // one column counter for each field
+    const ctype<_Elem>& _CType = _STD use_facet<ctype<_Elem>>(locale{});
+
+    int _Ans = -2; // no candidates so far
+    for (size_t _Column = 1;; ++_Column, (void) ++_First, _Ans = -1) { // test each element against all viable fields
+        bool _Prefix  = false; // seen at least one valid prefix
+        size_t _Off   = 0; // offset into fields
+        size_t _Field = 0; // current field number
+
+        for (; _Field < _Numfields; ++_Field) { // test element at _Column in field _Field
+            while (_Ptr[_Off] != _Elem{} && _Ptr[_Off] != _Ptr[0]) { // find beginning of field
+                ++_Off;
+            }
+
+            if (_Str[_Field] != '\0') {
+                _Off += _Str[_Field]; // skip tested columns in field
+            } else if (_Ptr[_Off += _Column] == _Ptr[0]
+                       || _Ptr[_Off] == _Elem{}) { // matched all of field, save as possible answer
+                _Str[_Field] = static_cast<char>(_Column < 127 ? _Column : 127); // save skip count if small enough
+                _Ans         = static_cast<int>(_Field); // save answer
+            } else if (_First == _Last
+                       || (_Matching == _Case_sensitive::_Yes
+                               ? _Ptr[_Off] != *_First
+                               : _CType.tolower(_Ptr[_Off]) != _CType.tolower(static_cast<_Elem>(*_First)))) {
+                _Str[_Field] = static_cast<char>(_Column < 127 ? _Column : 127); // no match, just save skip count
+            } else {
+                _Prefix = true; // still a valid prefix
+            }
+        }
+
+        if (!_Prefix || _First == _Last) {
+            break; // no pending prefixes or no input, give up
+        }
+    }
+    return _Ans; // return field number or negative value on failure
+}
+
+#if defined(_DLL_CPPLIB)
+#if !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+template class _CRTIMP2_PURE_IMPORT codecvt<char, char, mbstate_t>;
+#endif // !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+#endif // defined(_DLL_CPPLIB)
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XLOCALE_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xlocbuf b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xlocbuf
new file mode 100644
index 0000000000000000000000000000000000000000..a5891697efa92c2f6ec15295781318f80d84c50b
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xlocbuf
@@ -0,0 +1,507 @@
+// xlocbuf internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XLOCBUF_
+#define _XLOCBUF_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#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
+
+_STD_BEGIN
+_STL_DISABLE_DEPRECATED_WARNING
+_EXPORT_STD template <class _Codecvt, class _Elem = wchar_t, class _Traits = char_traits<_Elem>>
+class _CXX17_DEPRECATE_CODECVT_HEADER wbuffer_convert
+    : public basic_streambuf<_Elem, _Traits> { // stream buffer associated with a codecvt facet
+private:
+    enum _Mode { _Unused, _Wrote, _Need, _Got, _Eof };
+    enum { _STRING_INC = 8 };
+
+public:
+    using _Mysb        = streambuf;
+    using _Byte_traits = char_traits<char>;
+
+    using int_type   = typename _Traits::int_type;
+    using pos_type   = typename _Traits::pos_type;
+    using off_type   = typename _Traits::off_type;
+    using state_type = typename _Codecvt::state_type;
+
+    wbuffer_convert() : _State(), _Pcvt(new _Codecvt), _Mystrbuf(nullptr), _Status(_Unused), _Nback(0) {
+        // construct without buffer pointer
+        _Loc = locale{_Loc, _Pcvt};
+    }
+
+    explicit wbuffer_convert(_Mysb* _Strbuf)
+        : _State(), _Pcvt(new _Codecvt), _Mystrbuf(_Strbuf), _Status(_Unused), _Nback(0) {
+        // construct with byte stream buffer pointer
+        _Loc = locale{_Loc, _Pcvt};
+    }
+
+    wbuffer_convert(_Mysb* _Strbuf, const _Codecvt* _Pcvt_arg)
+        : _State(), _Pcvt(_Pcvt_arg), _Mystrbuf(_Strbuf), _Status(_Unused), _Nback(0) {
+        // construct with byte stream buffer pointer and codecvt
+        _Loc = locale{_Loc, _Pcvt};
+    }
+
+    wbuffer_convert(_Mysb* _Strbuf, const _Codecvt* _Pcvt_arg, state_type _State_arg)
+        : _State(_State_arg), _Pcvt(_Pcvt_arg), _Mystrbuf(_Strbuf), _Status(_Unused), _Nback(0) {
+        // construct with byte stream buffer pointer, codecvt, and state
+        _Loc = locale{_Loc, _Pcvt};
+    }
+
+    ~wbuffer_convert() noexcept override {
+        while (_Status == _Wrote) { // put any trailing homing shift
+            if (_Str.size() < _STRING_INC) {
+                _Str.assign(_STRING_INC, '\0');
+            }
+
+            char* _Buf = &_Str[0];
+            char* _Dest;
+            switch (_Pcvt->unshift(_State, _Buf, _Buf + _Str.size(), _Dest)) { // test result of homing conversion
+            case _Codecvt::ok:
+                _Status = _Unused; // homed successfully
+                _FALLTHROUGH;
+
+            case _Codecvt::partial:
+                { // put any generated bytes
+                    ptrdiff_t _Count = _Dest - _Buf;
+                    if (0 < _Count
+                        && _Byte_traits::eq_int_type(
+                            _Byte_traits::eof(), static_cast<_Byte_traits::int_type>(_Mystrbuf->sputn(_Buf, _Count)))) {
+                        return; // write failed
+                    }
+
+                    if (_Status == _Wrote && _Count == 0) {
+                        _Str.append(_STRING_INC, '\0'); // try with more space
+                    }
+
+                    break;
+                }
+
+            case _Codecvt::noconv:
+                return; // nothing to do
+
+            default:
+                return; // conversion failed
+            }
+        }
+    }
+
+    _NODISCARD _Mysb* rdbuf() const {
+        return _Mystrbuf;
+    }
+
+    _Mysb* rdbuf(_Mysb* _Strbuf) { // set byte stream buffer pointer
+        _Mysb* _Oldstrbuf = _Mystrbuf;
+        _Mystrbuf         = _Strbuf;
+        return _Oldstrbuf;
+    }
+
+    _NODISCARD state_type state() const {
+        return _State;
+    }
+
+    wbuffer_convert(const wbuffer_convert&)            = delete;
+    wbuffer_convert& operator=(const wbuffer_convert&) = delete;
+
+protected:
+    int_type 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
+        } else if (!_Mystrbuf || 0 < _Nback || (_Status != _Unused && _Status != _Wrote)) {
+            return _Traits::eof(); // no buffer or reading, fail
+        } else { // put using codecvt facet
+            const _Elem _Ch = _Traits::to_char_type(_Meta);
+
+            if (_Str.size() < _STRING_INC) {
+                _Str.assign(_STRING_INC, '\0');
+            }
+
+            for (_Status = _Wrote;;) {
+                char* _Buf = &_Str[0];
+                const _Elem* _Src;
+                char* _Dest;
+
+                // test result of converting one element
+                switch (_Pcvt->out(_State, &_Ch, &_Ch + 1, _Src, _Buf, _Buf + _Str.size(), _Dest)) {
+                case _Codecvt::partial:
+                case _Codecvt::ok:
+                    { // converted something, try to put it out
+                        ptrdiff_t _Count = _Dest - _Buf;
+                        if (0 < _Count
+                            && _Byte_traits::eq_int_type(_Byte_traits::eof(),
+                                static_cast<_Byte_traits::int_type>(_Mystrbuf->sputn(_Buf, _Count)))) {
+                            return _Traits::eof(); // write failed
+                        }
+
+                        if (_Src != &_Ch) {
+                            return _Meta; // converted whole element
+                        }
+
+                        if (0 >= _Count) {
+                            if (_Str.size() >= 4 * _STRING_INC) {
+                                return _Traits::eof(); // conversion failed
+                            }
+
+                            _Str.append(_STRING_INC, '\0'); // try with more space
+                        }
+
+                        break;
+                    }
+
+                case _Codecvt::noconv:
+                    if (_Traits::eq_int_type(
+                            _Traits::eof(), static_cast<int_type>(_Mystrbuf->sputn(reinterpret_cast<const char*>(&_Ch),
+                                                static_cast<streamsize>(sizeof(_Elem)))))) {
+                        return _Traits::eof();
+                    }
+
+                    return _Meta; // put native byte order
+
+                default:
+                    return _Traits::eof(); // conversion failed
+                }
+            }
+        }
+    }
+
+    int_type pbackfail(int_type _Meta = _Traits::eof()) override { // put an element back to stream
+        if (_STD size(_Myback) <= _Nback || _Status == _Wrote) {
+            return _Traits::eof(); // nowhere to put back
+        } else { // enough room, put it back
+            if (!_Traits::eq_int_type(_Traits::eof(), _Meta)) {
+                _Myback[_Nback] = _Traits::to_char_type(_Meta);
+            }
+
+            ++_Nback;
+            if (_Status == _Unused) {
+                _Status = _Got;
+            }
+
+            return _Meta;
+        }
+    }
+
+    int_type underflow() override { // get an element from stream, but don't point past it
+        int_type _Meta;
+
+        if (0 >= _Nback) {
+            if (_Traits::eq_int_type(_Traits::eof(), _Meta = _Get_elem())) {
+                return _Meta; // _Get_elem failed, return EOF
+            }
+
+            _Myback[_Nback++] = _Traits::to_char_type(_Meta);
+        }
+
+        return _Traits::to_int_type(_Myback[_Nback - 1]);
+    }
+
+#pragma warning(push)
+#pragma warning(disable : 6385) // Reading invalid data from 'this->_Myback':
+                                // the readable size is 'X' bytes, but 'Y' bytes may be read.
+    int_type uflow() override { // get an element from stream, point past it
+        int_type _Meta;
+
+        if (0 >= _Nback) {
+            if (_Traits::eq_int_type(_Traits::eof(), _Meta = _Get_elem())) {
+                return _Meta; // _Get_elem failed, return EOF
+            }
+
+            _Myback[_Nback++] = _Traits::to_char_type(_Meta);
+        }
+
+        return _Traits::to_int_type(_Myback[--_Nback]);
+    }
+#pragma warning(pop)
+
+    pos_type seekoff(off_type, ios_base::seekdir,
+        ios_base::openmode = static_cast<ios_base::openmode>(ios_base::in | ios_base::out)) override {
+        return pos_type{off_type{-1}}; // always fail
+    }
+
+    pos_type seekpos(
+        pos_type, ios_base::openmode = static_cast<ios_base::openmode>(ios_base::in | ios_base::out)) override {
+        return pos_type{off_type{-1}}; // always fail
+    }
+
+private:
+    int_type _Get_elem() { // compose an element from byte stream buffer
+        if (_Mystrbuf && _Status != _Wrote) { // got buffer, haven't written, try to compose an element
+            if (_Status != _Eof) {
+                if (_Str.empty()) {
+                    _Status = _Need;
+                } else {
+                    _Status = _Got;
+                }
+            }
+
+            while (_Status != _Eof) { // get using codecvt facet
+                char* _Buf = &_Str[0];
+                _Elem _Ch;
+                _Elem* _Dest;
+                const char* _Src;
+                int _Meta;
+
+                if (_Status == _Need) {
+                    if (_Byte_traits::eq_int_type(_Byte_traits::eof(), _Meta = _Mystrbuf->sbumpc())) {
+                        _Status = _Eof;
+                    } else {
+                        _Str.push_back(_Byte_traits::to_char_type(_Meta));
+                    }
+                }
+
+                // test result of converting one element
+                switch (_Pcvt->in(_State, _Buf, _Buf + _Str.size(), _Src, &_Ch, &_Ch + 1, _Dest)) {
+                case _Codecvt::partial:
+                case _Codecvt::ok:
+                    _Str.erase(0, static_cast<size_t>(_Src - _Buf)); // discard any used input
+                    if (_Dest != &_Ch) {
+                        return _Traits::to_int_type(_Ch);
+                    }
+
+                    break;
+
+                case _Codecvt::noconv:
+                    if (_Str.size() < sizeof(_Elem)) {
+                        break; // no conversion, but need more chars
+                    }
+
+                    _CSTD memcpy(&_Ch, _Buf, sizeof(_Elem)); // copy raw bytes to element
+                    _Str.erase(0, sizeof(_Elem));
+                    return _Traits::to_int_type(_Ch); // return result
+
+                default:
+                    _Status = _Eof; // conversion failed
+                    break;
+                }
+            }
+        }
+
+        return _Traits::eof();
+    }
+
+    state_type _State; // code conversion state
+    const _Codecvt* _Pcvt; // the codecvt facet
+    _Mysb* _Mystrbuf; // pointer to stream buffer
+    _Mode _Status; // buffer read/write status
+    size_t _Nback; // number of elements in putback buffer
+    _Elem _Myback[8]; // putback buffer
+    string _Str; // unconsumed input bytes
+    locale _Loc; // manages reference to codecvt facet
+};
+
+_EXPORT_STD template <class _Codecvt, class _Elem = wchar_t, class _Walloc = allocator<_Elem>,
+    class _Balloc = allocator<char>>
+class _CXX17_DEPRECATE_CODECVT_HEADER wstring_convert { // converts between _Elem (wide) and char (byte) strings
+private:
+    enum { _BUF_INC = 8, _BUF_MAX = 16 };
+    void _Init(const _Codecvt* _Pcvt_arg = new _Codecvt) { // initialize the object
+        _State = state_type{};
+        _Pcvt  = _Pcvt_arg;
+        _Loc   = locale{_Loc, _Pcvt};
+        _Nconv = 0;
+    }
+
+public:
+    using byte_string = basic_string<char, char_traits<char>, _Balloc>;
+    using wide_string = basic_string<_Elem, char_traits<_Elem>, _Walloc>;
+    using state_type  = typename _Codecvt::state_type;
+    using int_type    = typename wide_string::traits_type::int_type;
+
+    wstring_convert() : _Has_state(false), _Has_berr(false), _Has_werr(false) { // construct with no error strings
+        _Init();
+    }
+
+    explicit wstring_convert(const _Codecvt* _Pcvt_arg)
+        : _Has_state(false), _Has_berr(false), _Has_werr(false) { // construct with no error strings and codecvt
+        _Init(_Pcvt_arg);
+    }
+
+    wstring_convert(const _Codecvt* _Pcvt_arg, state_type _State_arg)
+        : _Has_state(true), _Has_berr(false), _Has_werr(false) { // construct with no error strings, codecvt, and state
+        _Init(_Pcvt_arg);
+        _State = _State_arg;
+    }
+
+    explicit wstring_convert(const byte_string& _Berr_arg)
+        : _Berr(_Berr_arg), _Has_state(false), _Has_berr(true), _Has_werr(false) { // construct with byte error string
+        _Init();
+    }
+
+    wstring_convert(const byte_string& _Berr_arg, const wide_string& _Werr_arg)
+        : _Berr(_Berr_arg), _Werr(_Werr_arg), _Has_state(false), _Has_berr(true),
+          _Has_werr(true) { // construct with byte and wide error strings
+        _Init();
+    }
+
+    virtual ~wstring_convert() noexcept {}
+
+    _NODISCARD size_t converted() const noexcept { // get conversion count
+        return _Nconv;
+    }
+
+    _NODISCARD state_type state() const {
+        return _State;
+    }
+
+    _NODISCARD wide_string from_bytes(char _Byte) { // convert a byte to a wide string
+        return from_bytes(&_Byte, &_Byte + 1);
+    }
+
+    _NODISCARD wide_string from_bytes(const char* _Ptr) { // convert a NTBS to a wide string
+        return from_bytes(_Ptr, _Ptr + _CSTD strlen(_Ptr));
+    }
+
+    _NODISCARD wide_string from_bytes(const byte_string& _Bstr) { // convert a byte string to a wide string
+        const char* _Ptr = _Bstr.c_str();
+        return from_bytes(_Ptr, _Ptr + _Bstr.size());
+    }
+
+    _NODISCARD wide_string from_bytes(
+        const char* _First, const char* _Last) { // convert byte sequence [_First, _Last) to a wide string
+        wide_string _Wbuf;
+        wide_string _Wstr;
+        const char* _First_sav = _First;
+
+        if (!_Has_state) {
+            _State = state_type{}; // reset state if not remembered
+        }
+
+        _Wbuf.append(_BUF_INC, _Elem{});
+        for (_Nconv = 0; _First != _Last; _Nconv = static_cast<size_t>(_First - _First_sav)) {
+            // convert one or more bytes
+            _Elem* _Dest = &_Wbuf[0];
+            _Elem* _Dnext;
+
+            // test result of converting one or more bytes
+            switch (_Pcvt->in(_State, _First, _Last, _First, _Dest, _Dest + _Wbuf.size(), _Dnext)) {
+            case _Codecvt::partial:
+            case _Codecvt::ok:
+                if (_Dest < _Dnext) {
+                    _Wstr.append(_Dest, static_cast<size_t>(_Dnext - _Dest));
+                } else if (_Wbuf.size() < _BUF_MAX) {
+                    _Wbuf.append(_BUF_INC, _Elem{});
+                } else if (_Has_werr) {
+                    return _Werr;
+                } else {
+                    _Throw_range_error("bad conversion");
+                }
+
+                break;
+
+            case _Codecvt::noconv:
+                for (; _First != _Last; ++_First) {
+                    _Wstr.push_back(static_cast<_Elem>(static_cast<unsigned char>(*_First)));
+                }
+
+                break; // no conversion, just copy code values
+
+            default:
+                if (_Has_werr) {
+                    return _Werr;
+                } else {
+                    _Throw_range_error("bad conversion");
+                }
+            }
+        }
+        return _Wstr;
+    }
+
+    _NODISCARD byte_string to_bytes(_Elem _Char) { // convert a wide char to a byte string
+        return to_bytes(&_Char, &_Char + 1);
+    }
+
+    _NODISCARD byte_string to_bytes(const _Elem* _Wptr) { // convert a NTWCS to a byte string
+        const _Elem* _Next = _Wptr;
+        while (*_Next != 0) {
+            ++_Next;
+        }
+
+        return to_bytes(_Wptr, _Next);
+    }
+
+    _NODISCARD byte_string to_bytes(const wide_string& _Wstr) { // convert a wide string to a byte string
+        const _Elem* _Wptr = _Wstr.c_str();
+        return to_bytes(_Wptr, _Wptr + _Wstr.size());
+    }
+
+    _NODISCARD byte_string to_bytes(
+        const _Elem* _First, const _Elem* _Last) { // convert wide sequence [_First, _Last) to a byte string
+        byte_string _Bbuf;
+        byte_string _Bstr;
+        const _Elem* _First_sav = _First;
+
+        if (!_Has_state) {
+            _State = state_type{}; // reset state if not remembered
+        }
+
+        _Bbuf.append(_BUF_INC, '\0');
+        for (_Nconv = 0; _First != _Last; _Nconv = static_cast<size_t>(_First - _First_sav)) {
+            // convert one or more wide chars
+            char* _Dest = &_Bbuf[0];
+            char* _Dnext;
+
+            // test result of converting one or more wide chars
+            switch (_Pcvt->out(_State, _First, _Last, _First, _Dest, _Dest + _Bbuf.size(), _Dnext)) {
+            case _Codecvt::partial:
+            case _Codecvt::ok:
+                if (_Dest < _Dnext) {
+                    _Bstr.append(_Dest, static_cast<size_t>(_Dnext - _Dest));
+                } else if (_Bbuf.size() < _BUF_MAX) {
+                    _Bbuf.append(_BUF_INC, '\0');
+                } else if (_Has_berr) {
+                    return _Berr;
+                } else {
+                    _Throw_range_error("bad conversion");
+                }
+
+                break;
+
+            case _Codecvt::noconv:
+                for (; _First != _Last; ++_First) {
+                    _Bstr.push_back(static_cast<char>(static_cast<int_type>(*_First)));
+                }
+
+                break; // no conversion, just copy code values
+
+            default:
+                if (_Has_berr) {
+                    return _Berr;
+                } else {
+                    _Throw_range_error("bad conversion");
+                }
+            }
+        }
+        return _Bstr;
+    }
+
+    wstring_convert(const wstring_convert&)            = delete;
+    wstring_convert& operator=(const wstring_convert&) = delete;
+
+private:
+    const _Codecvt* _Pcvt; // the codecvt facet
+    locale _Loc; // manages reference to codecvt facet
+    byte_string _Berr;
+    wide_string _Werr;
+    state_type _State; // the remembered state
+    bool _Has_state;
+    bool _Has_berr;
+    bool _Has_werr;
+    size_t _Nconv;
+};
+_STL_RESTORE_DEPRECATED_WARNING
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XLOCBUF_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xlocinfo b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xlocinfo
new file mode 100644
index 0000000000000000000000000000000000000000..80487ea2f33c9d27280bf5b22b8796202afad2c3
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xlocinfo
@@ -0,0 +1,446 @@
+// xlocinfo internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XLOCINFO_
+#define _XLOCINFO_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <__msvc_xlocinfo_types.hpp>
+#include <cctype>
+#include <clocale>
+#include <cstdio> // TRANSITION, VSO-661721
+#include <cstdlib>
+#include <cwchar>
+#include <xstring>
+
+#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_UNLESS_PURE
+
+#define _X_ALL      LC_ALL
+#define _X_COLLATE  LC_COLLATE
+#define _X_CTYPE    LC_CTYPE
+#define _X_MONETARY LC_MONETARY
+#define _X_NUMERIC  LC_NUMERIC
+#define _X_TIME     LC_TIME
+#define _X_MAX      LC_MAX
+#define _X_MESSAGES 6
+#define _NCAT       (_X_MESSAGES + 1) // maximum + 1
+
+#define _CATMASK(n) ((1 << (n)) >> 1)
+#define _M_COLLATE  _CATMASK(_X_COLLATE)
+#define _M_CTYPE    _CATMASK(_X_CTYPE)
+#define _M_MONETARY _CATMASK(_X_MONETARY)
+#define _M_NUMERIC  _CATMASK(_X_NUMERIC)
+#define _M_TIME     _CATMASK(_X_TIME)
+#define _M_MESSAGES _CATMASK(_X_MESSAGES)
+#define _M_ALL      (_CATMASK(_NCAT) - 1)
+
+_CRTIMP2_PURE _Collvec __CLRCALL_PURE_OR_CDECL _Getcoll() noexcept;
+_CRTIMP2_PURE _Ctypevec __CLRCALL_PURE_OR_CDECL _Getctype() noexcept;
+_CRTIMP2_PURE _Cvtvec __CLRCALL_PURE_OR_CDECL _Getcvt() noexcept;
+_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Getdateorder() noexcept;
+
+#ifdef _M_CEE_PURE
+[System::Runtime::InteropServices::DllImport(_CRT_MSVCP_CURRENT, EntryPoint = "_Mbrtowc",
+    CallingConvention = System::Runtime::InteropServices::CallingConvention::Cdecl)] extern "C" int
+    _Mbrtowc(_Out_opt_ wchar_t*, const char*, size_t, mbstate_t*, const _Cvtvec*) noexcept;
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+_MRTIMP2 _Success_(return >= 0) int __cdecl _Mbrtowc(_When_(_Max_multibyte != 0, _Out_) wchar_t*, const char*,
+    size_t _Max_multibyte, mbstate_t*, const _Cvtvec*) noexcept;
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+
+_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Strcoll(
+    const char*, const char*, const char*, const char*, const _Collvec*) noexcept;
+_CRTIMP2_PURE size_t __CLRCALL_PURE_OR_CDECL _Strxfrm(_Out_writes_(_End1 - _String1)
+                                                          _Post_readable_size_(return) char* _String1,
+    _In_z_ char* _End1, const char*, const char*, const _Collvec*) noexcept;
+_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Tolower(int, const _Ctypevec*) noexcept;
+_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Toupper(int, const _Ctypevec*) noexcept;
+_CRTIMP2_PURE _Success_(return != -1) int __CLRCALL_PURE_OR_CDECL
+    _Wcrtomb(_Out_ char*, wchar_t, mbstate_t*, const _Cvtvec*) noexcept;
+_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Wcscoll(
+    const wchar_t*, const wchar_t*, const wchar_t*, const wchar_t*, const _Collvec*) noexcept;
+_CRTIMP2_PURE size_t __CLRCALL_PURE_OR_CDECL _Wcsxfrm(_Out_writes_(_End1 - _String1) _Post_readable_size_(return)
+                                                          wchar_t* _String1,
+    _In_z_ wchar_t* _End1, const wchar_t*, const wchar_t*, const _Collvec*) noexcept;
+
+_CRTIMP2_PURE short __CLRCALL_PURE_OR_CDECL _Getwctype(wchar_t, const _Ctypevec*) noexcept;
+_CRTIMP2_PURE const wchar_t* __CLRCALL_PURE_OR_CDECL _Getwctypes(
+    const wchar_t*, const wchar_t*, short*, const _Ctypevec*) noexcept;
+_CRTIMP2_PURE wchar_t __CLRCALL_PURE_OR_CDECL _Towlower(wchar_t, const _Ctypevec*) noexcept;
+_CRTIMP2_PURE wchar_t __CLRCALL_PURE_OR_CDECL _Towupper(wchar_t, const _Ctypevec*) noexcept;
+
+_END_EXTERN_C_UNLESS_PURE
+
+extern "C" {
+// These _should_ be explicitly `noexcept` but cannot be made so here because
+// the primary declarations in the C runtime headers are not.
+
+_Success_(return != 0) _Ret_z_ _ACRTIMP char* __cdecl _Getdays();
+
+_Success_(return != 0) _Ret_z_ _ACRTIMP char* __cdecl _Getmonths();
+
+_ACRTIMP void* __cdecl _Gettnames();
+
+_Success_(return > 0) _ACRTIMP size_t __cdecl _Strftime(
+    _Out_writes_z_(_Maxsize) char*, _In_ size_t _Maxsize, _In_z_ const char*, _In_ const tm*, _In_opt_ void*);
+
+_Success_(return != 0) _Ret_z_ _ACRTIMP wchar_t* __cdecl _W_Getdays();
+
+_Success_(return != 0) _Ret_z_ _ACRTIMP wchar_t* __cdecl _W_Getmonths();
+
+_ACRTIMP void* __cdecl _W_Gettnames();
+
+_Success_(return > 0) _ACRTIMP size_t __cdecl _Wcsftime(
+    _Out_writes_z_(_Maxsize) wchar_t*, _In_ size_t _Maxsize, _In_z_ const wchar_t*, _In_ const tm*, _In_opt_ void*);
+} // extern "C"
+
+_STD_BEGIN
+extern "C++" class _CRTIMP2_PURE_IMPORT _Timevec { // smart pointer to information used by _Strftime
+public:
+    explicit __CLR_OR_THIS_CALL _Timevec(void* _Ptr = nullptr) : _Timeptr(_Ptr) {}
+
+    __CLR_OR_THIS_CALL _Timevec(const _Timevec& _Right) : _Timeptr(nullptr) {
+        *this = _Right;
+    }
+
+    __CLR_OR_THIS_CALL ~_Timevec() noexcept {
+        _CSTD free(_Timeptr);
+    }
+
+    _Timevec& __CLR_OR_THIS_CALL operator=(const _Timevec& _Right) { // transfer ownership of _Timeptr from _Right
+        if (this != &_Right) {
+            _CSTD free(_Timeptr);
+            _Timeptr                               = _Right._Timeptr;
+            const_cast<_Timevec&>(_Right)._Timeptr = nullptr; // TRANSITION, should be movable-only
+        }
+
+        return *this;
+    }
+
+    void* __CLR_OR_THIS_CALL _Getptr() const {
+        return _Timeptr;
+    }
+
+private:
+    void* _Timeptr; // pointer to time information
+};
+
+extern "C++" template <class _Elem>
+class _CRTIMP2_PURE_IMPORT _Yarn { // wrap a NTCTS
+public:
+    __CLR_OR_THIS_CALL _Yarn() noexcept : _Myptr(nullptr), _Nul(0) {}
+
+    __CLR_OR_THIS_CALL _Yarn(const _Yarn& _Right) noexcept : _Myptr(nullptr), _Nul(0) {
+        *this = _Right;
+    }
+
+    __CLR_OR_THIS_CALL _Yarn(const _Elem* _Right) noexcept : _Myptr(nullptr), _Nul(0) {
+        *this = _Right;
+    }
+
+    _Yarn& __CLR_OR_THIS_CALL operator=(const _Yarn& _Right) noexcept {
+        return *this = _Right._Myptr;
+    }
+
+    _Yarn& __CLR_OR_THIS_CALL operator=(const _Elem* _Right) noexcept {
+        if (_Myptr != _Right) { // new value, discard old and copy new
+            _Tidy();
+
+            if (_Right) { // new is not empty, copy it
+                const _Elem* _Ptr = _Right;
+                while (*_Ptr != _Elem{}) {
+                    ++_Ptr;
+                }
+
+                const auto _Count = (++_Ptr - _Right) * sizeof(_Elem);
+
+#ifdef _DEBUG
+                _Myptr = static_cast<_Elem*>(_malloc_dbg(_Count, _CRT_BLOCK, __FILE__, __LINE__));
+#else
+                _Myptr = static_cast<_Elem*>(_CSTD malloc(_Count));
+#endif
+
+                if (_Myptr) {
+                    _CSTD memcpy(_Myptr, _Right, _Count);
+                }
+            }
+        }
+
+        return *this;
+    }
+
+    __CLR_OR_THIS_CALL ~_Yarn() noexcept {
+        _Tidy();
+    }
+
+    _NODISCARD bool __CLR_OR_THIS_CALL empty() const noexcept {
+        return _Myptr == nullptr;
+    }
+
+    _Ret_z_ const _Elem* __CLR_OR_THIS_CALL c_str() const noexcept {
+        return _Myptr ? _Myptr : &_Nul;
+    }
+
+    _NODISCARD bool __CLR_OR_THIS_CALL _Empty() const noexcept {
+        return _Myptr == nullptr;
+    }
+
+    _Ret_z_ const _Elem* __CLR_OR_THIS_CALL _C_str() const noexcept {
+        return _Myptr ? _Myptr : &_Nul;
+    }
+
+private:
+    void __CLR_OR_THIS_CALL _Tidy() noexcept {
+        if (_Myptr) {
+#ifdef _DEBUG
+            _free_dbg(_Myptr, _CRT_BLOCK);
+#else
+            _CSTD free(_Myptr);
+#endif
+        }
+
+        _Myptr = nullptr;
+    }
+
+    _Elem* _Myptr; // pointer to allocated string
+    _Elem _Nul; // nul terminator for unallocated string
+};
+
+extern "C++" class _CRTIMP2_PURE_IMPORT _Locinfo { // summary of all stuff specific to a locale used by standard facets
+public:
+    using _Collvec  = ::_Collvec;
+    using _Ctypevec = ::_Ctypevec;
+    using _Cvtvec   = ::_Cvtvec;
+    using _Timevec  = _STD _Timevec;
+
+    static void __CLRCALL_PURE_OR_CDECL _Locinfo_ctor(_Locinfo*, const char*);
+    static void __CLRCALL_PURE_OR_CDECL _Locinfo_ctor(_Locinfo*, int, const char*);
+    static void __CLRCALL_PURE_OR_CDECL _Locinfo_dtor(_Locinfo*);
+    static _Locinfo& __CLRCALL_PURE_OR_CDECL _Locinfo_Addcats(_Locinfo*, int, const char*);
+
+    __CLR_OR_THIS_CALL _Locinfo(const char* _Pch = "C")
+#ifndef _M_CEE_PURE
+        : _Lock(_LOCK_LOCALE)
+#endif // !defined(_M_CEE_PURE)
+    {
+        if (_Pch) {
+            _Locinfo_ctor(this, _Pch);
+            return;
+        }
+
+        _Xruntime_error("bad locale name");
+    }
+
+    __CLR_OR_THIS_CALL _Locinfo(int _Cat, const char* _Pch)
+#ifndef _M_CEE_PURE
+        : _Lock(_LOCK_LOCALE)
+#endif // !defined(_M_CEE_PURE)
+    {
+        if (_Pch) {
+            _Locinfo_ctor(this, _Cat, _Pch);
+            return;
+        }
+
+        _Xruntime_error("bad locale name");
+    }
+
+    __CLR_OR_THIS_CALL ~_Locinfo() noexcept {
+        _Locinfo_dtor(this);
+    }
+
+    _Locinfo& __CLR_OR_THIS_CALL _Addcats(int _Cat, const char* _Pch) { // add facets matching category mask and NTBS
+        if (_Pch) {
+            return _Locinfo_Addcats(this, _Cat, _Pch);
+        }
+
+        _Xruntime_error("bad locale name");
+    }
+
+    const char* __CLR_OR_THIS_CALL _Getname() const {
+        return _Newlocname._C_str();
+    }
+
+    _Collvec __CLR_OR_THIS_CALL _Getcoll() const {
+        return ::_Getcoll();
+    }
+
+    _Ctypevec __CLR_OR_THIS_CALL _Getctype() const {
+        return ::_Getctype();
+    }
+
+    _Cvtvec __CLR_OR_THIS_CALL _Getcvt() const {
+        return ::_Getcvt();
+    }
+
+    const lconv* __CLR_OR_THIS_CALL _Getlconv() const {
+        return localeconv();
+    }
+
+    _Timevec __CLR_OR_THIS_CALL _Gettnames() const {
+        return _Timevec(::_Gettnames());
+    }
+
+    const char* __CLR_OR_THIS_CALL _Getdays() const {
+        const char* _Ptr = ::_Getdays();
+        if (_Ptr) { // capture names and free allocated C string
+            const_cast<_Locinfo*>(this)->_Days = _Ptr;
+            _CSTD free(const_cast<char*>(_Ptr));
+        }
+
+        return !_Days._Empty() ? _Days._C_str()
+                               : ":Sun:Sunday:Mon:Monday:Tue:Tuesday:Wed:Wednesday"
+                                 ":Thu:Thursday:Fri:Friday:Sat:Saturday";
+    }
+
+    const char* __CLR_OR_THIS_CALL _Getmonths() const {
+        const char* _Ptr = ::_Getmonths();
+        if (_Ptr) { // capture names and free allocated C string
+            const_cast<_Locinfo*>(this)->_Months = _Ptr;
+            _CSTD free(const_cast<char*>(_Ptr));
+        }
+
+        return !_Months._Empty() ? _Months._C_str()
+                                 : ":Jan:January:Feb:February:Mar:March"
+                                   ":Apr:April:May:May:Jun:June"
+                                   ":Jul:July:Aug:August:Sep:September"
+                                   ":Oct:October:Nov:November:Dec:December";
+    }
+
+    const char* __CLR_OR_THIS_CALL _Getfalse() const {
+        return "false";
+    }
+
+    const char* __CLR_OR_THIS_CALL _Gettrue() const {
+        return "true";
+    }
+
+    int __CLR_OR_THIS_CALL _Getdateorder() const {
+        return ::_Getdateorder();
+    }
+
+    _Timevec __CLR_OR_THIS_CALL _W_Gettnames() const {
+        return _Timevec(::_W_Gettnames());
+    }
+
+    const unsigned short* __CLR_OR_THIS_CALL _W_Getdays() const {
+        const wchar_t* _Ptr = ::_W_Getdays();
+        if (_Ptr) { // capture names and free allocated C string
+            const_cast<_Locinfo*>(this)->_W_Days = _Ptr;
+            _CSTD free(const_cast<wchar_t*>(_Ptr));
+        }
+
+        const wchar_t* _Ret;
+
+        if (_W_Days._Empty()) {
+            _Ret = L":Sun:Sunday:Mon:Monday:Tue:Tuesday:Wed:Wednesday:Thu:Thursday:Fri:Friday:Sat:Saturday";
+        } else {
+            _Ret = _W_Days._C_str();
+        }
+
+        return reinterpret_cast<const unsigned short*>(_Ret);
+    }
+
+    const unsigned short* __CLR_OR_THIS_CALL _W_Getmonths() const {
+        const wchar_t* _Ptr = ::_W_Getmonths();
+        if (_Ptr) { // capture names and free allocated C string
+            const_cast<_Locinfo*>(this)->_W_Months = _Ptr;
+            _CSTD free(const_cast<wchar_t*>(_Ptr));
+        }
+
+        const wchar_t* _Ret;
+
+        if (_W_Months._Empty()) {
+            _Ret = L":Jan:January:Feb:February:Mar:March:Apr:April:May:May:Jun:June"
+                   L":Jul:July:Aug:August:Sep:September:Oct:October:Nov:November:Dec:December";
+        } else {
+            _Ret = _W_Months._C_str();
+        }
+
+        return reinterpret_cast<const unsigned short*>(_Ret);
+    }
+
+    _Locinfo(const _Locinfo&)            = delete;
+    _Locinfo& operator=(const _Locinfo&) = delete;
+
+private:
+#ifdef _M_CEE_PURE
+    _EmptyLockit _Empty_lock; // to maintain same size
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+    _Lockit _Lock; // thread lock, because global locale is altered
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+
+    _Yarn<char> _Days; // weekday names
+    _Yarn<char> _Months; // month names
+    _Yarn<wchar_t> _W_Days; // wide weekday names
+    _Yarn<wchar_t> _W_Months; // wide month names
+    _Yarn<char> _Oldlocname; // old locale name to revert to on destruction
+    _Yarn<char> _Newlocname; // new locale name for this object
+};
+
+template <class _Elem>
+int __CRTDECL _LStrcoll(const _Elem* _First1, const _Elem* _Last1, const _Elem* _First2, const _Elem* _Last2,
+    const _Locinfo::_Collvec*) { // perform locale-specific comparison of _Elem sequences
+    for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, ++_First2) {
+        if (*_First1 < *_First2) {
+            return -1; // [_First1, _Last1) < [_First2, _Last2)
+        } else if (*_First2 < *_First1) {
+            return +1; // [_First1, _Last1) > [_First2, _Last2)
+        }
+    }
+
+    return _First2 != _Last2 ? -1 : _First1 != _Last1 ? +1 : 0;
+}
+
+template <>
+inline int __CRTDECL _LStrcoll(const char* _First1, const char* _Last1, const char* _First2, const char* _Last2,
+    const _Locinfo::_Collvec* _Vector) { // perform locale-specific comparison of char sequences
+    return _Strcoll(_First1, _Last1, _First2, _Last2, _Vector);
+}
+
+template <>
+inline int __CRTDECL _LStrcoll(const wchar_t* _First1, const wchar_t* _Last1, const wchar_t* _First2,
+    const wchar_t* _Last2,
+    const _Locinfo::_Collvec* _Vector) { // perform locale-specific comparison of wchar_t sequences
+    return _Wcscoll(_First1, _Last1, _First2, _Last2, _Vector);
+}
+
+template <class _Elem>
+size_t __CRTDECL _LStrxfrm(_Elem* _First1, _Elem* _Last1, const _Elem* _First2, const _Elem* _Last2,
+    const _Locinfo::_Collvec*) { // perform locale-specific transform of _Elems [_First1, _Last1)
+    const ptrdiff_t _Count = _Last2 - _First2;
+    if (_Count <= _Last1 - _First1) {
+        _CSTD memcpy(_First1, _First2, _Count * sizeof(_Elem));
+    }
+
+    return _Count;
+}
+
+template <>
+inline size_t __CRTDECL _LStrxfrm(_Out_writes_(_Last1 - _First1) _Post_readable_size_(return) char* _First1,
+    _In_z_ char* _Last1, const char* _First2, const char* _Last2,
+    const _Locinfo::_Collvec* _Vector) { // perform locale-specific transform of chars [_First1, _Last1)
+    return _Strxfrm(_First1, _Last1, _First2, _Last2, _Vector);
+}
+
+template <>
+inline size_t __CRTDECL _LStrxfrm(_Out_writes_(_Last1 - _First1) _Post_readable_size_(return) wchar_t* _First1,
+    _In_z_ wchar_t* _Last1, const wchar_t* _First2, const wchar_t* _Last2,
+    const _Locinfo::_Collvec* _Vector) { // perform locale-specific transform of wchar_ts [_First1, _Last1)
+    return _Wcsxfrm(_First1, _Last1, _First2, _Last2, _Vector);
+}
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XLOCINFO_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xlocmes b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xlocmes
new file mode 100644
index 0000000000000000000000000000000000000000..4d161b5696e7b6b3bcb3b50a733277ce7994449b
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xlocmes
@@ -0,0 +1,139 @@
+// xlocmes internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XLOCMES_
+#define _XLOCMES_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <xiosbase>
+
+#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 messages_base // base class for messages
+    : locale::facet // TRANSITION, ABI, shouldn't be derived from locale::facet
+{
+    using catalog = int;
+
+    messages_base() noexcept // strengthened
+        : messages_base(0) {}
+    explicit messages_base(size_t _Refs) noexcept : locale::facet(_Refs) {}
+};
+
+_EXPORT_STD template <class _Elem>
+class messages : public messages_base { // facet for obtaining messages from a catalog
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    using char_type   = _Elem;
+    using string_type = basic_string<_Elem, char_traits<_Elem>, allocator<_Elem>>;
+
+    catalog open(const string& _Catname, const locale& _Loc) const { // open catalog
+        return do_open(_Catname, _Loc);
+    }
+
+    string_type get(catalog _Catval, int _Set, int _Message,
+        const string_type& _Dflt) const { // get message from set in catalog
+        return do_get(_Catval, _Set, _Message, _Dflt);
+    }
+
+    void close(catalog _Catval) const { // close catalog
+        do_close(_Catval);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL _CRTIMP2_PURE_IMPORT static locale::id id; // unique facet id
+
+    explicit messages(size_t _Refs = 0) : messages_base(_Refs) { // construct from current locale
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    messages(const _Locinfo& _Lobj, size_t _Refs = 0) : messages_base(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new messages<_Elem>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_MESSAGES;
+    }
+
+protected:
+    messages(const char* _Locname, size_t _Refs = 0) : messages_base(_Refs) {
+        _BEGIN_LOCINFO(_Lobj(_Locname))
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    __CLR_OR_THIS_CALL ~messages() noexcept override {}
+
+    void _Init(const _Locinfo&) {} // initialize from _Locinfo object (do nothing)
+
+    virtual catalog __CLR_OR_THIS_CALL do_open(const string&, const locale&) const { // open catalog (do nothing)
+        return -1;
+    }
+
+    virtual string_type __CLR_OR_THIS_CALL do_get(catalog, int, int,
+        const string_type& _Dflt) const { // get message from set in catalog (return default)
+        return _Dflt;
+    }
+
+    virtual void __CLR_OR_THIS_CALL do_close(catalog) const {} // close catalog (do nothing)
+};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _Elem>
+__PURE_APPDOMAIN_GLOBAL locale::id messages<_Elem>::id;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+
+_EXPORT_STD template <class _Elem>
+class messages_byname : public messages<_Elem> { // messages for named locale
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    explicit messages_byname(const char* _Locname, size_t _Refs = 0)
+        : messages<_Elem>(_Locname, _Refs) {} // construct for named locale
+
+    explicit messages_byname(const string& _Str, size_t _Refs = 0)
+        : messages<_Elem>(_Str.c_str(), _Refs) {} // construct for named locale
+
+protected:
+    __CLR_OR_THIS_CALL ~messages_byname() noexcept override {}
+};
+
+#if defined(_DLL_CPPLIB)
+
+#if !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+template __PURE_APPDOMAIN_GLOBAL locale::id messages<char>::id;
+template __PURE_APPDOMAIN_GLOBAL locale::id messages<wchar_t>::id;
+#endif // !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+
+#ifdef __FORCE_INSTANCE
+template __PURE_APPDOMAIN_GLOBAL locale::id messages<unsigned short>::id;
+#endif // defined(__FORCE_INSTANCE)
+#endif // defined(_DLL_CPPLIB)
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XLOCMES_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xlocmon b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xlocmon
new file mode 100644
index 0000000000000000000000000000000000000000..3c7d924644fa97c1ab4704cc7c903022f3793da6
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xlocmon
@@ -0,0 +1,942 @@
+// xlocmon internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XLOCMON_
+#define _XLOCMON_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <iterator>
+#include <xlocnum>
+
+#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 money_base // ultimate base class for moneypunct
+    : locale::facet // TRANSITION, ABI, shouldn't be derived from locale::facet
+{
+    enum { // constants for different format codes
+        symbol = '$',
+        sign   = '+',
+        space  = ' ',
+        value  = 'v',
+        none   = 'x'
+    };
+    using part = int;
+
+    struct pattern { // four-part formats for monetary text
+        char field[4];
+    };
+
+    money_base(size_t _Refs = 0) noexcept // strengthened
+        : locale::facet(_Refs) {}
+};
+
+template <class _Elem>
+class _Mpunct : public money_base { // common base class for moneypunct<_Elem, false/true>
+public:
+    friend _Tidy_guard<_Mpunct>;
+
+    using char_type   = _Elem;
+    using string_type = basic_string<_Elem, char_traits<_Elem>, allocator<_Elem>>;
+
+    _Elem decimal_point() const {
+        return do_decimal_point();
+    }
+
+    _Elem thousands_sep() const {
+        return do_thousands_sep();
+    }
+
+    string grouping() const {
+        return do_grouping();
+    }
+
+    string_type curr_symbol() const {
+        return do_curr_symbol();
+    }
+
+    string_type positive_sign() const {
+        return do_positive_sign();
+    }
+
+    string_type negative_sign() const {
+        return do_negative_sign();
+    }
+
+    int frac_digits() const {
+        return do_frac_digits();
+    }
+
+    pattern pos_format() const {
+        return do_pos_format();
+    }
+
+    pattern neg_format() const {
+        return do_neg_format();
+    }
+
+    explicit _Mpunct(size_t _Refs, bool _Intl)
+        : money_base(_Refs), _International(_Intl) { // construct from current locale
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    _Mpunct(const _Locinfo& _Lobj, size_t _Refs, bool _Intl, bool _Isdef = false)
+        : money_base(_Refs), _International(_Intl) {
+        _Init(_Lobj, _Isdef);
+    }
+
+protected:
+    _Mpunct(const char* _Locname, size_t _Refs, bool _Intl, bool _Isdef = false)
+        : money_base(_Refs), _International(_Intl) {
+        _BEGIN_LOCINFO(_Lobj(_Locname))
+        _Init(_Lobj, _Isdef);
+        _END_LOCINFO()
+    }
+
+    __CLR_OR_THIS_CALL ~_Mpunct() noexcept override {
+        _Tidy();
+    }
+
+    template <class _Elem2>
+    void _Getvals(_Elem2, const lconv* _Ptr) { // get values
+        _Currencysign = _Maklocstr(
+            _International ? _Ptr->int_curr_symbol : _Ptr->currency_symbol, static_cast<_Elem2*>(nullptr), _Cvt);
+        _Plussign = _Maklocstr(4 < static_cast<unsigned int>(_Ptr->p_sign_posn) ? "" : _Ptr->positive_sign,
+            static_cast<_Elem2*>(nullptr), _Cvt);
+        _Minussign = _Maklocstr(4 < static_cast<unsigned int>(_Ptr->n_sign_posn) ? "-" : _Ptr->negative_sign,
+            static_cast<_Elem2*>(nullptr), _Cvt);
+        _Decimalpoint = _Maklocchr(_Ptr->mon_decimal_point[0], static_cast<_Elem2*>(nullptr), _Cvt);
+        _Kseparator   = _Maklocchr(_Ptr->mon_thousands_sep[0], static_cast<_Elem2*>(nullptr), _Cvt);
+    }
+
+    void _Getvals(wchar_t, const lconv* _Ptr) { // get values
+        _Currencysign = reinterpret_cast<const _Elem*>(
+            _Maklocwcs(_International ? _Ptr->_W_int_curr_symbol : _Ptr->_W_currency_symbol));
+        _Plussign = reinterpret_cast<const _Elem*>(
+            _Maklocwcs(4 < static_cast<unsigned int>(_Ptr->p_sign_posn) ? L"" : _Ptr->_W_positive_sign));
+        _Minussign = reinterpret_cast<const _Elem*>(
+            _Maklocwcs(4 < static_cast<unsigned int>(_Ptr->n_sign_posn) ? L"-" : _Ptr->_W_negative_sign));
+        _Decimalpoint = static_cast<_Elem>(_Ptr->_W_mon_decimal_point[0]);
+        _Kseparator   = static_cast<_Elem>(_Ptr->_W_mon_thousands_sep[0]);
+    }
+
+    void _Init(const _Locinfo& _Lobj, bool _Isdef = false) { // initialize from _Lobj
+        _Cvt              = _Lobj._Getcvt();
+        const lconv* _Ptr = _Lobj._Getlconv();
+
+        _Grouping     = nullptr;
+        _Currencysign = nullptr;
+        _Plussign     = nullptr;
+        _Minussign    = nullptr;
+
+        _Tidy_guard<_Mpunct> _Guard{this};
+        _Grouping = _Maklocstr(_Ptr->mon_grouping, static_cast<char*>(nullptr), _Cvt);
+        _Getvals(_Elem{}, _Ptr);
+        _Guard._Target = nullptr;
+
+        _Fracdigits = _International ? _Ptr->int_frac_digits : _Ptr->frac_digits;
+        if (_Fracdigits < 0 || CHAR_MAX <= _Fracdigits) {
+            _Fracdigits = 0;
+        }
+
+        _Makpat(_Plusformat, static_cast<unsigned int>(_Ptr->p_sep_by_space),
+            static_cast<unsigned int>(_Ptr->p_cs_precedes), static_cast<unsigned int>(_Ptr->p_sign_posn));
+        _Makpat(_Minusformat, static_cast<unsigned int>(_Ptr->n_sep_by_space),
+            static_cast<unsigned int>(_Ptr->n_cs_precedes), static_cast<unsigned int>(_Ptr->n_sign_posn));
+
+        if (_Isdef) { // apply defaults for required facets
+            _CSTD memcpy(&_Plusformat, "$+xv", 4);
+            _CSTD memcpy(&_Minusformat, "$+xv", 4);
+        }
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_decimal_point() const {
+        return _Decimalpoint;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_thousands_sep() const {
+        return _Kseparator;
+    }
+
+    virtual string __CLR_OR_THIS_CALL do_grouping() const {
+        return string{_Grouping};
+    }
+
+    virtual string_type __CLR_OR_THIS_CALL do_curr_symbol() const {
+        return string_type{_Currencysign};
+    }
+
+    virtual string_type __CLR_OR_THIS_CALL do_positive_sign() const {
+        return string_type{_Plussign};
+    }
+
+    virtual string_type __CLR_OR_THIS_CALL do_negative_sign() const {
+        return string_type{_Minussign};
+    }
+
+    virtual int __CLR_OR_THIS_CALL do_frac_digits() const {
+        return _Fracdigits;
+    }
+
+    virtual pattern __CLR_OR_THIS_CALL do_pos_format() const {
+        return _Plusformat;
+    }
+
+    virtual pattern __CLR_OR_THIS_CALL do_neg_format() const {
+        return _Minusformat;
+    }
+
+private:
+    void _Makpat(pattern& _Pattern, unsigned int _Sepbyspace, unsigned int _Symbolprecedes,
+        unsigned int _Signposition) { // make format pattern from locale information
+
+        const char* _Ptr;
+
+        if (_International || 2 < _Sepbyspace || 1 < _Symbolprecedes || 4 < _Signposition) {
+            // international or bad parameters
+            _Ptr = "$+xv";
+        } else {
+            // clang-format off
+            _Ptr =
+                "+v$x" "+v$x" "v$+x" "v+$x" "v$+x"
+                "+$vx" "+$vx" "$v+x" "+$vx" "$+vx"
+                "+v $" "+v $" "v $+" "v +$" "v $+"
+                "+$ v" "+$ v" "$ v+" "+$ v" "$+ v"
+                "+xv$" "+ v$" "v$ +" "v+ $" "v$ +"
+                "+x$v" "+ $v" "$v +" "+ $v" "$ +v";
+            // clang-format on
+            _Ptr += _Signposition * 4 // pick even/odd column
+                  + _Symbolprecedes * 20 // pick even/odd row
+                  + _Sepbyspace * 40; // pick first/second/third group
+        }
+
+        _CSTD memcpy(_Pattern.field, _Ptr, sizeof(_Pattern.field));
+    }
+
+    void _Tidy() noexcept { // free all storage
+        _CSTD free(const_cast<char*>(_Grouping));
+        _CSTD free(const_cast<_Elem*>(_Currencysign));
+        _CSTD free(const_cast<_Elem*>(_Plussign));
+        _CSTD free(const_cast<_Elem*>(_Minussign));
+    }
+
+    const char* _Grouping; // grouping string, "" for "C" locale
+    _Elem _Decimalpoint; // decimal point, '\0' for "C" locale
+    _Elem _Kseparator; // thousands separator, '\0' for "C" locale
+    const _Elem* _Currencysign; // currency symbol, "" for "C" locale
+    const _Elem* _Plussign; // plus sign, "" for "C" locale
+    const _Elem* _Minussign; // minus sign, "-" for "C" locale
+    int _Fracdigits; // number of fraction digits, 0 for "C" locale
+    pattern _Plusformat; // positive format, "$+vx" for "C" locale
+    pattern _Minusformat; // negative format, "$+vx" for "C" locale
+    bool _International; // true if international format
+
+    _Locinfo::_Cvtvec _Cvt; // conversion information
+};
+
+_EXPORT_STD template <class _Elem, bool _Intl = false>
+class moneypunct : public _Mpunct<_Elem> { // facet for defining monetary punctuation text
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    _PGLOBAL _CRTIMP2_PURE_IMPORT static const bool intl; // true if international
+    __PURE_APPDOMAIN_GLOBAL _CRTIMP2_PURE_IMPORT static locale::id id; // unique facet id
+
+    explicit moneypunct(size_t _Refs = 0) : _Mpunct<_Elem>(_Refs, _Intl) {} // construct from current locale
+
+    moneypunct(const _Locinfo& _Lobj, size_t _Refs = 0, bool _Isdef = false)
+        : _Mpunct<_Elem>(_Lobj, _Refs, _Intl, _Isdef) {}
+
+    static size_t _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new moneypunct<_Elem, _Intl>(_Locinfo(_Ploc->_C_str()), 0, true);
+        }
+
+        return _X_MONETARY;
+    }
+
+protected:
+    moneypunct(const char* _Locname, size_t _Refs = 0) : _Mpunct<_Elem>(_Locname, _Refs, _Intl) {}
+
+    __CLR_OR_THIS_CALL ~moneypunct() noexcept override {}
+};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _Elem, bool _Intl>
+_PGLOBAL const bool moneypunct<_Elem, _Intl>::intl = _Intl;
+
+template <class _Elem, bool _Intl>
+__PURE_APPDOMAIN_GLOBAL locale::id moneypunct<_Elem, _Intl>::id;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+
+_EXPORT_STD template <class _Elem, bool _Intl = false>
+class moneypunct_byname : public moneypunct<_Elem, _Intl> { // moneypunct for named locale
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    explicit moneypunct_byname(const char* _Locname, size_t _Refs = 0)
+        : moneypunct<_Elem, _Intl>(_Locname, _Refs) {} // construct for named locale
+
+    explicit moneypunct_byname(const string& _Str, size_t _Refs = 0)
+        : moneypunct<_Elem, _Intl>(_Str.c_str(), _Refs) {} // construct for named locale
+
+protected:
+    __CLR_OR_THIS_CALL ~moneypunct_byname() noexcept override {}
+};
+
+_EXPORT_STD template <class _Elem, class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem>>>
+class money_get : public locale::facet { // facet for converting text to encoded monetary amounts
+private:
+    using _Mypunct0 = moneypunct<_Elem, false>;
+    using _Mypunct1 = moneypunct<_Elem, true>;
+
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    using char_type   = _Elem;
+    using iter_type   = _InIt;
+    using string_type = basic_string<_Elem, char_traits<_Elem>, allocator<_Elem>>;
+
+    _InIt get(_InIt _First, _InIt _Last, bool _Intl, ios_base& _Iosbase, ios_base::iostate& _State,
+        long double& _Val) const { // get long double from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Intl, _Iosbase, _State, _Val);
+    }
+
+    _InIt get(_InIt _First, _InIt _Last, bool _Intl, ios_base& _Iosbase, ios_base::iostate& _State,
+        string_type& _Val) const { // get string_type from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Intl, _Iosbase, _State, _Val);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL _CRTIMP2_PURE_IMPORT static locale::id id; // unique facet id
+
+    explicit money_get(size_t _Refs = 0) : locale::facet(_Refs) { // construct from current locale
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    money_get(const _Locinfo& _Lobj, size_t _Refs = 0) : locale::facet(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new money_get<_Elem, _InIt>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_MONETARY;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~money_get() noexcept override {}
+
+    void _Init(const _Locinfo&) {} // initialize from _Locinfo object
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, bool _Intl, ios_base& _Iosbase,
+        ios_base::iostate& _State,
+        long double& _Val) const { // get long double from [_First, _Last) into _Val
+        _Elem _Atoms[sizeof("0123456789-")];
+        string _Str = _Getmfld(_First, _Last, _Intl, _Iosbase, _Atoms);
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        if (_Str.empty()) {
+            _State |= ios_base::failbit; // _Getmfld failed
+        } else { // convert to long double
+            const char* _Eb = _Str.c_str();
+            char* _Ep;
+            int _Errno             = 0;
+            const long double _Ans = _Stodx_v3(_Eb, &_Ep, &_Errno); // convert and "widen" double to long double
+
+            if (_Ep == _Eb || _Errno != 0) {
+                _State |= ios_base::failbit;
+            } else {
+                _Val = _Ans; // deliver value
+            }
+        }
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, bool _Intl, ios_base& _Iosbase,
+        ios_base::iostate& _State,
+        string_type& _Val) const { // get string_type from [_First, _Last) into _Val
+        _Elem _Atoms[sizeof("0123456789-")];
+        string _Str = _Getmfld(_First, _Last, _Intl, _Iosbase, _Atoms);
+        size_t _Len = _Str.size();
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        if (_Len == 0) {
+            _State |= ios_base::failbit; // _Getmfld failed
+        } else { // deliver value
+            size_t _Idx = 0;
+            _Val.resize(_Len);
+            if (_Str[0] == '-') {
+                _Val[_Idx++] = _Atoms[10];
+            }
+
+            for (; _Idx < _Len; ++_Idx) {
+                _Val[_Idx] = _Atoms[_Str[_Idx] - '0']; // map digits
+            }
+        }
+        return _First;
+    }
+
+private:
+    string _Getmfld(_InIt& _First, _InIt& _Last, bool _Intl, ios_base& _Iosbase,
+        _Elem (&_Atoms)[12]) const { // get monetary field from [_First, _Last) into string_type
+        _Adl_verify_range(_First, _Last);
+        const _Mpunct<_Elem>* _Ppunct_fac;
+        if (_Intl) {
+            _Ppunct_fac = _STD addressof(_STD use_facet<_Mypunct1>(_Iosbase.getloc())); // international
+        } else {
+            _Ppunct_fac = _STD addressof(_STD use_facet<_Mypunct0>(_Iosbase.getloc())); // local
+        }
+
+        bool _Bad = false;
+        bool _Neg = false;
+        string_type _Sign;
+        const money_base::pattern _Pattern = _Ppunct_fac->neg_format();
+        string _Val;
+        size_t _Idx;
+        static constexpr char _Src[]   = "0123456789-";
+        const ctype<_Elem>& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Iosbase.getloc());
+        _Ctype_fac.widen(_STD begin(_Src), _STD end(_Src), _Atoms);
+
+        for (size_t _Off = 0; !_Bad && _Off < 4; ++_Off) {
+            switch (_Pattern.field[_Off]) { // parse a format component
+            case money_base::symbol:
+                { // parse currency symbol
+                    string_type _Symbol = _Ppunct_fac->curr_symbol();
+                    typename string_type::const_iterator _Source;
+
+                    if ((!(_Iosbase.flags() & ios_base::showbase) && _First != _Last && *_First != *_Symbol.c_str())
+                        || (_Off == 3 && _Sign.size() <= 1
+                            && (_First == _Last || *_First != *_Symbol.c_str()))) { // showbase ==> mandatory symbol
+                                                                                    // or
+                                                                                    // currency symbol optional at end
+                        _Symbol.erase();
+                    }
+
+                    _Source = _Symbol.begin();
+                    while (_First != _Last && _Source != _Symbol.end() && *_First == *_Source) {
+                        // still matching currency symbol
+                        ++_Source;
+                        ++_First;
+                    }
+
+                    if (_Source != _Symbol.end()) {
+                        _Bad = true; // currency symbol match failed
+                    }
+                    break;
+                }
+
+            case money_base::sign: // parse sign
+                if (_First != _Last) {
+                    if (0 < _Ppunct_fac->positive_sign().size()
+                        && _Ppunct_fac->positive_sign()[0] == *_First) { // match positive sign
+                        ++_First;
+                        _Sign = _Ppunct_fac->positive_sign();
+                    } else if (0 < _Ppunct_fac->negative_sign().size()
+                               && _Ppunct_fac->negative_sign()[0] == *_First) { // match negative sign
+                        ++_First;
+                        _Sign = _Ppunct_fac->negative_sign();
+                        _Neg  = true;
+                    } else if (0 != _Ppunct_fac->positive_sign().size() && 0 == _Ppunct_fac->negative_sign().size()) {
+                        _Neg = true;
+                    }
+                }
+
+                break; // sign match can't fail
+
+            case money_base::value:
+                { // parse value field
+                    int _Fracdigseen        = 0;
+                    int _Fracdigits         = _Ppunct_fac->frac_digits();
+                    const string _Grouping  = _Ppunct_fac->grouping();
+                    const _Elem _Kseparator = _Grouping.empty() ? _Elem{} : _Ppunct_fac->thousands_sep();
+
+                    if (_Kseparator == _Elem{} || CHAR_MAX <= static_cast<unsigned char>(*_Grouping.c_str())) {
+                        for (; _First != _Last && (_Idx = _Find_elem(_Atoms, *_First)) < 10; ++_First) {
+                            _Val += _Src[_Idx]; // no grouping, just gather digits
+                        }
+                    } else { // grouping specified, gather digits and group sizes
+                        string _Groups;
+                        _Groups.push_back('\0');
+                        size_t _Group = 0;
+
+                        for (; _First != _Last; ++_First) {
+                            if ((_Idx = _Find_elem(_Atoms, *_First)) < 10) { // got a digit, add to group size
+                                _Val += _Src[_Idx];
+                                if (_Groups[_Group] != CHAR_MAX) {
+                                    ++_Groups[_Group];
+                                }
+                            } else if (_Groups[_Group] == '\0' || *_First != _Kseparator) {
+                                break; // not a group separator, done
+                            } else { // add a new group to _Groups string
+                                _Groups.push_back('\0');
+                                ++_Group;
+                            }
+                        }
+
+                        if (_Group != 0) { // thousands separators seen
+                            if ('\0' < _Groups[_Group]) {
+                                ++_Group; // add trailing group to group count
+                            } else {
+                                _Bad = true; // trailing separator, fail
+                            }
+                        }
+
+                        for (const char* _Pg = _Grouping.c_str(); !_Bad && 0 < _Group;) {
+                            if (*_Pg == CHAR_MAX) {
+                                break; // end of grouping constraints to check
+                            }
+
+                            if ((0 < --_Group && *_Pg != _Groups[_Group]) || (0 == _Group && *_Pg < _Groups[_Group])) {
+                                _Bad = true; // bad group size, fail
+                            } else if ('\0' < _Pg[1]) {
+                                ++_Pg; // group size okay, advance to next test
+                            }
+                        }
+
+                        if (_Bad) {
+                            break; // bad grouping, give up
+                        }
+                    }
+
+                    const _Elem _Point = _Ppunct_fac->decimal_point();
+                    if (_First != _Last && _Point != _Elem{}
+                        && *_First == _Point) { // seen decimal point, gather fraction digits
+                        while (++_First != _Last && _Fracdigseen < _Fracdigits
+                               && (_Idx = _Find_elem(_Atoms, *_First)) < 10) {
+                            _Val += _Src[_Idx];
+                            ++_Fracdigseen;
+                        }
+
+                        if (_Fracdigseen < _Fracdigits) {
+                            _Bad = true; // short fraction
+                        }
+                    }
+
+                    if (_Val.empty()) {
+                        _Bad = true; // fail if no elements parsed
+                    } else {
+                        for (; _Fracdigseen < _Fracdigits; ++_Fracdigseen) {
+                            _Val += '0'; // pad out fraction with zeros
+                        }
+                    }
+
+                    break;
+                }
+
+            case money_base::space:
+            case money_base::none:
+                { // parse optional space
+                    if (_Off == 3) {
+                        break; // ignore space at end
+                    }
+
+                    bool _Seen = false;
+
+                    for (; _First != _Last && _Ctype_fac.is(ctype_base::space, *_First); ++_First) {
+                        _Seen = true; // skip any space
+                    }
+
+                    if (_Pattern.field[_Off] == money_base::space && !_Seen) {
+                        _Bad = true; // fail if no space seen
+                    }
+
+                    break;
+                }
+
+            default:
+                _STL_ASSERT(false, "Invalid money_base::pattern, see N4981 [locale.moneypunct.general]/1: "
+                                   "In the field member of a pattern object, each value symbol, sign, value, "
+                                   "and either space or none appears exactly once.");
+                break;
+            } // switch
+        }
+
+        if (!_Bad && 1 < _Sign.size()) { // match rest of sign string
+            auto _Source = _Sign.begin();
+
+            while (++_Source != _Sign.end() && _First != _Last && *_First == *_Source) {
+                ++_First;
+            }
+
+            if (_Source != _Sign.end()) {
+                _Bad = true; // rest of sign doesn't match, fail
+            }
+        }
+
+        if (_Bad) {
+            _Val.erase(); // bad input, return empty string
+        } else if (_Neg) {
+            _Val.insert(0, 1, '-'); // minus sign
+        }
+
+        return _Val;
+    }
+};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _Elem, class _InIt>
+__PURE_APPDOMAIN_GLOBAL locale::id money_get<_Elem, _InIt>::id;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+
+_EXPORT_STD template <class _Elem, class _OutIt = ostreambuf_iterator<_Elem, char_traits<_Elem>>>
+class money_put : public locale::facet { // facet for converting encoded monetary amounts to text
+private:
+    using _Mypunct0 = moneypunct<_Elem, false>;
+    using _Mypunct1 = moneypunct<_Elem, true>;
+
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    using char_type   = _Elem;
+    using iter_type   = _OutIt;
+    using string_type = basic_string<_Elem, char_traits<_Elem>, allocator<_Elem>>;
+
+    _OutIt put(_OutIt _Dest, bool _Intl, ios_base& _Iosbase, _Elem _Fill,
+        long double _Val) const { // put long double to _Dest
+        return do_put(_Dest, _Intl, _Iosbase, _Fill, _Val);
+    }
+
+    _OutIt put(_OutIt _Dest, bool _Intl, ios_base& _Iosbase, _Elem _Fill,
+        const string_type& _Val) const { // put string_type to _Dest
+        return do_put(_Dest, _Intl, _Iosbase, _Fill, _Val);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL _CRTIMP2_PURE_IMPORT static locale::id id; // unique facet id
+
+    explicit money_put(size_t _Refs = 0) : locale::facet(_Refs) { // construct from current locale
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    money_put(const _Locinfo& _Lobj, size_t _Refs = 0) : locale::facet(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new money_put<_Elem, _OutIt>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_MONETARY;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~money_put() noexcept override {}
+
+    void _Init(const _Locinfo&) {} // initialize from _Locinfo object
+
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest, bool _Intl, ios_base& _Iosbase, _Elem _Fill,
+        long double _Val) const { // put long double to _Dest
+        bool _Negative = false;
+        if (_Val < 0) {
+            _Negative = true;
+            _Val      = -_Val;
+        }
+
+        size_t _Exp;
+        for (_Exp = 0; 1e35 <= _Val && _Exp < 5000; _Exp += 10) {
+            _Val /= 1e10; // drop 10 zeros before decimal point
+        }
+
+        char _Buf[40];
+
+        // convert to chars:
+        const int _Count = _CSTD sprintf_s(_Buf, sizeof(_Buf), "%.0Lf", _Val);
+
+        if (_Count < 0) {
+            return _Dest; // bad conversion, give up
+        }
+
+        const ctype<_Elem>& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Iosbase.getloc());
+        const _Elem _Elem0             = _Ctype_fac.widen('0');
+
+        string_type _Val2(static_cast<size_t>(_Count), _Elem{});
+        _Ctype_fac.widen(_Buf, _Buf + _Count, &_Val2[0]);
+        _Val2.append(_Exp, _Elem0); // scale by trailing zeros
+        return _Putmfld(_Dest, _Intl, _Iosbase, _Fill, _Negative, _Val2, _Elem0);
+    }
+
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest, bool _Intl, ios_base& _Iosbase, _Elem _Fill,
+        const string_type& _Val) const { // put string_type to _Dest
+        static constexpr char _Src[] = "0123456789-";
+        _Elem _Atoms[sizeof(_Src)];
+        const ctype<_Elem>& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Iosbase.getloc());
+        _Ctype_fac.widen(_STD begin(_Src), _STD end(_Src), _Atoms);
+
+        bool _Negative = false;
+        size_t _Idx0   = 0;
+        if (!_Val.empty() && _Val[0] == _Atoms[10]) { // strip off '-'
+            _Negative = true;
+            ++_Idx0;
+        }
+
+        size_t _Size = _Val.size();
+        size_t _Idx  = _Idx0;
+        for (; _Idx < _Size && _Find_elem(_Atoms, _Val[_Idx]) < 10; ++_Idx) { // count digits
+        }
+
+        string_type _Val2(&_Val[_Idx0], _Idx - _Idx0);
+        if (_Val2.empty()) { // replace empty digit string with '0'
+            _Val2.push_back(_Atoms[0]);
+        }
+
+        return _Putmfld(_Dest, _Intl, _Iosbase, _Fill, _Negative, _Val2, _Atoms[0]);
+    }
+
+private:
+    _OutIt _Putmfld(
+        _OutIt _Dest, bool _Intl, ios_base& _Iosbase, _Elem _Fill, bool _Neg, string_type _Val, _Elem _Elem0) const {
+        // put string_type with just digits to _Dest
+        const _Mpunct<_Elem>* _Ppunct_fac;
+        if (_Intl) {
+            _Ppunct_fac = _STD addressof(_STD use_facet<_Mypunct1>(_Iosbase.getloc())); // international
+        } else {
+            _Ppunct_fac = _STD addressof(_STD use_facet<_Mypunct0>(_Iosbase.getloc())); // local
+        }
+
+        const string _Grouping = _Ppunct_fac->grouping();
+        int _Ifracdigits       = _Ppunct_fac->frac_digits();
+        const auto _Fracdigits = static_cast<unsigned int>(_Ifracdigits < 0 ? -_Ifracdigits : _Ifracdigits);
+
+        if (_Val.size() <= _Fracdigits) {
+            _Val.insert(0, _Fracdigits - _Val.size() + 1, _Elem0);
+        } else if (*_Grouping.c_str() != CHAR_MAX && '\0' < *_Grouping.c_str()) {
+            // grouping specified, add thousands separators
+            const _Elem _Kseparator = _Ppunct_fac->thousands_sep();
+            const char* _Pg         = _Grouping.c_str();
+            size_t _Off             = _Val.size() - _Fracdigits; // start of fraction
+
+            while (*_Pg != CHAR_MAX && '\0' < *_Pg && static_cast<size_t>(*_Pg) < _Off) {
+                // add a thousands separator, right to left
+                _Val.insert(_Off -= *_Pg, 1, _Kseparator);
+                if ('\0' < _Pg[1]) {
+                    ++_Pg; // not last group, advance
+                }
+            }
+        }
+
+        money_base::pattern _Pattern;
+        string_type _Sign;
+        if (_Neg) { // negative value, choose appropriate format and sign
+            _Pattern = _Ppunct_fac->neg_format();
+            _Sign    = _Ppunct_fac->negative_sign();
+        } else { // positive value, choose appropriate format and sign
+            _Pattern = _Ppunct_fac->pos_format();
+            _Sign    = _Ppunct_fac->positive_sign();
+        }
+
+        string_type _Symbol;
+        if (_Iosbase.flags() & ios_base::showbase) {
+            _Symbol = _Ppunct_fac->curr_symbol(); // showbase ==> show $
+        }
+
+        bool _Intern = false;
+        size_t _Fillcount;
+        size_t _Off;
+        for (_Fillcount = 0, _Off = 0; _Off < 4; ++_Off) {
+            switch (_Pattern.field[_Off]) { // accumulate total length in _Fillcount
+            case money_base::symbol: // count currency symbol size
+                _Fillcount += _Symbol.size();
+                break;
+
+            case money_base::sign: // count sign size
+                _Fillcount += _Sign.size();
+                break;
+
+            case money_base::value: // count value field size
+                _Fillcount += _Val.size() + (0 < _Fracdigits ? 1 : 0)
+                            + (_Val.size() <= _Fracdigits ? _Fracdigits - _Val.size() + 1 : 0);
+                break;
+
+            case money_base::space: // count space size
+                ++_Fillcount; // at least one space
+                _FALLTHROUGH;
+
+            case money_base::none: // count space size
+                if (_Off != 3) {
+                    _Intern = true; // optional internal fill
+                }
+
+                break;
+
+            default:
+                _STL_ASSERT(false, "Invalid money_base::pattern, see N4981 [locale.moneypunct.general]/1: "
+                                   "In the field member of a pattern object, each value symbol, sign, value, "
+                                   "and either space or none appears exactly once.");
+                break;
+            }
+        }
+
+        if (_Iosbase.width() <= 0 || static_cast<size_t>(_Iosbase.width()) <= _Fillcount) {
+            _Fillcount = 0;
+        } else {
+            _Fillcount = static_cast<size_t>(_Iosbase.width()) - _Fillcount;
+        }
+
+        ios_base::fmtflags _Afl = _Iosbase.flags() & ios_base::adjustfield;
+        if (_Afl != ios_base::left && (_Afl != ios_base::internal || !_Intern)) { // put leading fill
+            _Dest      = _Rep(_Dest, _Fill, _Fillcount);
+            _Fillcount = 0;
+        }
+
+        for (_Off = 0; _Off < 4; ++_Off) {
+            switch (_Pattern.field[_Off]) { // put components as specified by _Pattern
+            case money_base::symbol: // put currency symbol
+                _Dest = _Put(_Dest, _Symbol.begin(), _Symbol.size());
+                break;
+
+            case money_base::sign: // put sign
+                if (0 < _Sign.size()) {
+                    _Dest = _Put(_Dest, _Sign.begin(), 1);
+                }
+
+                break;
+
+            case money_base::value: // put value field
+                if (_Fracdigits == 0) {
+                    _Dest = _Put(_Dest, _Val.begin(), _Val.size()); // no fraction part
+                } else if (_Val.size() <= _Fracdigits) { // put leading zero, all fraction digits
+                    *_Dest++ = _Elem0;
+                    *_Dest++ = _Ppunct_fac->decimal_point();
+                    _Dest    = _Rep(_Dest, _Elem0, _Fracdigits - _Val.size()); // insert zeros
+                    _Dest    = _Put(_Dest, _Val.begin(), _Val.size());
+                } else { // put both integer and fraction parts
+                    _Dest    = _Put(_Dest, _Val.begin(), _Val.size() - _Fracdigits); // put integer part
+                    *_Dest++ = _Ppunct_fac->decimal_point();
+                    _Dest =
+                        _Put(_Dest, _Val.end() - static_cast<ptrdiff_t>(_Fracdigits), _Fracdigits); // put fraction part
+                }
+                break;
+
+            case money_base::space: // put any internal fill
+                _Dest = _Rep(_Dest, _Fill, 1);
+                _FALLTHROUGH;
+
+            case money_base::none: // put any internal fill
+                if (_Afl == ios_base::internal) { // put internal fill
+                    _Dest      = _Rep(_Dest, _Fill, _Fillcount);
+                    _Fillcount = 0;
+                }
+                break;
+
+            default:
+                _STL_ASSERT(false, "Invalid money_base::pattern, see N4981 [locale.moneypunct.general]/1: "
+                                   "In the field member of a pattern object, each value symbol, sign, value, "
+                                   "and either space or none appears exactly once.");
+                break;
+            }
+        }
+
+        if (1 < _Sign.size()) {
+            _Dest = _Put(_Dest, _Sign.begin() + 1, _Sign.size() - 1); // put remainder of sign
+        }
+
+        _Iosbase.width(0);
+        return _Rep(_Dest, _Fill, _Fillcount); // put trailing fill
+    }
+
+    static _OutIt _Put(_OutIt _Dest, typename string_type::const_iterator _Source, size_t _Count) {
+        // put [_Source, _Source + _Count) to _Dest
+        for (; 0 < _Count; --_Count, (void) ++_Dest, ++_Source) {
+            *_Dest = *_Source;
+        }
+
+        return _Dest;
+    }
+
+    static _OutIt _Rep(_OutIt _Dest, _Elem _Ch, size_t _Count) { // put _Count * _Ch to _Dest
+        for (; 0 < _Count; --_Count, (void) ++_Dest) {
+            *_Dest = _Ch;
+        }
+
+        return _Dest;
+    }
+};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _Elem, class _OutIt>
+__PURE_APPDOMAIN_GLOBAL locale::id money_put<_Elem, _OutIt>::id;
+
+#if defined(_DLL_CPPLIB)
+
+#if !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+template _PGLOBAL const bool moneypunct<char, true>::intl;
+template _PGLOBAL const bool moneypunct<char, false>::intl;
+template __PURE_APPDOMAIN_GLOBAL locale::id moneypunct<char, true>::id;
+template __PURE_APPDOMAIN_GLOBAL locale::id moneypunct<char, false>::id;
+template __PURE_APPDOMAIN_GLOBAL locale::id money_get<char, istreambuf_iterator<char, char_traits<char>>>::id;
+template __PURE_APPDOMAIN_GLOBAL locale::id money_put<char, ostreambuf_iterator<char, char_traits<char>>>::id;
+
+template _PGLOBAL const bool moneypunct<wchar_t, true>::intl;
+template _PGLOBAL const bool moneypunct<wchar_t, false>::intl;
+template __PURE_APPDOMAIN_GLOBAL locale::id moneypunct<wchar_t, true>::id;
+template __PURE_APPDOMAIN_GLOBAL locale::id moneypunct<wchar_t, false>::id;
+template __PURE_APPDOMAIN_GLOBAL locale::id money_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t>>>::id;
+template __PURE_APPDOMAIN_GLOBAL locale::id money_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t>>>::id;
+#endif // !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+
+#ifdef __FORCE_INSTANCE
+template _PGLOBAL const bool moneypunct<unsigned short, true>::intl;
+template _PGLOBAL const bool moneypunct<unsigned short, false>::intl;
+template __PURE_APPDOMAIN_GLOBAL locale::id moneypunct<unsigned short, true>::id;
+template __PURE_APPDOMAIN_GLOBAL locale::id moneypunct<unsigned short, false>::id;
+template __PURE_APPDOMAIN_GLOBAL locale::id
+    money_get<unsigned short, istreambuf_iterator<unsigned short, char_traits<unsigned short>>>::id;
+template __PURE_APPDOMAIN_GLOBAL locale::id
+    money_put<unsigned short, ostreambuf_iterator<unsigned short, char_traits<unsigned short>>>::id;
+#endif // defined(__FORCE_INSTANCE)
+#endif // defined(_DLL_CPPLIB)
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XLOCMON_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xlocnum b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xlocnum
new file mode 100644
index 0000000000000000000000000000000000000000..e06101f63e19dc1df03068d23aff3e69dcb3a1ff
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xlocnum
@@ -0,0 +1,1684 @@
+// xlocnum internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XLOCNUM_
+#define _XLOCNUM_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <cfloat>
+#include <climits>
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <iterator>
+#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
+
+_EXTERN_C_UNLESS_PURE
+
+_CRTIMP2_PURE long __CLRCALL_PURE_OR_CDECL _Stolx(
+    const char*, _Out_opt_ _Deref_post_opt_valid_ char**, int, int*) noexcept;
+_CRTIMP2_PURE unsigned long __CLRCALL_PURE_OR_CDECL _Stoulx(
+    const char*, _Out_opt_ _Deref_post_opt_valid_ char**, int, int*) noexcept;
+_CRTIMP2_PURE long long __CLRCALL_PURE_OR_CDECL _Stollx(
+    const char*, _Out_opt_ _Deref_post_opt_valid_ char**, int, int*) noexcept;
+_CRTIMP2_PURE unsigned long long __CLRCALL_PURE_OR_CDECL _Stoullx(
+    const char*, _Out_opt_ _Deref_post_opt_valid_ char**, int, int*) noexcept;
+
+_END_EXTERN_C_UNLESS_PURE
+
+_STD_BEGIN
+
+_INLINE_VAR constexpr size_t _Max_int_dig = 32; // integer properties
+
+inline double _Stodx_v3(const char* _Str, char** _Endptr, int* _Perr) noexcept { // convert string to double
+    int& _Errno_ref = errno; // Nonzero cost, pay it once
+    const int _Orig = _Errno_ref;
+
+    _Errno_ref  = 0;
+    double _Val = _CSTD strtod(_Str, _Endptr);
+    *_Perr      = _Errno_ref;
+    _Errno_ref  = _Orig;
+
+    return _Val;
+}
+
+inline float _Stofx_v3(const char* _Str, char** _Endptr, int* _Perr) noexcept { // convert string to float
+    int& _Errno_ref = errno; // Nonzero cost, pay it once
+    const int _Orig = _Errno_ref;
+
+    _Errno_ref = 0;
+    float _Val = _CSTD strtof(_Str, _Endptr);
+    *_Perr     = _Errno_ref;
+    _Errno_ref = _Orig;
+
+    return _Val;
+}
+
+template <class _Elem, size_t _Base_size>
+size_t _Find_elem(const _Elem (&_Base)[_Base_size], const _Elem _Ch) {
+    // lookup _Ch in array storing NUL-terminated string _Base
+    // pre: _Base contains no nulls except for _Base[_Base_size - 1]
+    return static_cast<size_t>(_STD _Find_unchecked(_Base, _Base + (_Base_size - 1), _Ch) - _Base);
+}
+
+inline wchar_t* _Maklocwcs(const wchar_t* _Ptr) { // copy NTWCS to allocated storage
+    const size_t _Count = _CSTD wcslen(_Ptr) + 1;
+
+    wchar_t* _Ptrdest = static_cast<wchar_t*>(_calloc_dbg(_Count, sizeof(wchar_t), _CRT_BLOCK, __FILE__, __LINE__));
+
+    if (!_Ptrdest) {
+        _Xbad_alloc();
+    }
+
+    _CSTD wmemcpy(_Ptrdest, _Ptr, _Count);
+    return _Ptrdest;
+}
+
+_EXPORT_STD template <class _Elem>
+class numpunct : public locale::facet { // facet for defining numeric punctuation text
+private:
+    friend _Tidy_guard<numpunct>;
+
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    using string_type = basic_string<_Elem, char_traits<_Elem>, allocator<_Elem>>;
+    using char_type   = _Elem;
+
+    __PURE_APPDOMAIN_GLOBAL _CRTIMP2_PURE_IMPORT static locale::id id; // unique facet id
+
+    _Elem decimal_point() const {
+        return do_decimal_point();
+    }
+
+    _Elem thousands_sep() const {
+        return do_thousands_sep();
+    }
+
+    string grouping() const {
+        return do_grouping();
+    }
+
+    string_type falsename() const {
+        return do_falsename();
+    }
+
+    string_type truename() const {
+        return do_truename();
+    }
+
+    explicit numpunct(size_t _Refs = 0) : locale::facet(_Refs) { // construct from current locale
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        if (_Kseparator == 0) {
+            _Kseparator = // NB: differs from "C" locale
+                _Maklocchr(',', static_cast<_Elem*>(nullptr), _Lobj._Getcvt());
+        }
+        _END_LOCINFO()
+    }
+
+    numpunct(const _Locinfo& _Lobj, size_t _Refs = 0, bool _Isdef = false) : locale::facet(_Refs) {
+        _Init(_Lobj, _Isdef);
+    }
+
+    static size_t _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new numpunct<_Elem>(_Locinfo(_Ploc->_C_str()), 0, true);
+        }
+        return _X_NUMERIC;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~numpunct() noexcept override {
+        _Tidy();
+    }
+
+    numpunct(const char* _Locname, size_t _Refs = 0, bool _Isdef = false) : locale::facet(_Refs) {
+        _BEGIN_LOCINFO(_Lobj(_Locname))
+        _Init(_Lobj, _Isdef);
+        _END_LOCINFO()
+    }
+
+    template <class _Elem2>
+    void _Getvals(_Elem2, const lconv* _Ptr, _Locinfo::_Cvtvec _Cvt) { // get values
+        _Dp         = _Maklocchr(_Ptr->decimal_point[0], static_cast<_Elem2*>(nullptr), _Cvt);
+        _Kseparator = _Maklocchr(_Ptr->thousands_sep[0], static_cast<_Elem2*>(nullptr), _Cvt);
+    }
+
+    void _Getvals(wchar_t, const lconv* _Ptr, _Locinfo::_Cvtvec) { // get values
+        _Dp         = static_cast<_Elem>(_Ptr->_W_decimal_point[0]);
+        _Kseparator = static_cast<_Elem>(_Ptr->_W_thousands_sep[0]);
+    }
+
+    void _Init(const _Locinfo& _Lobj, bool _Isdef = false) { // initialize from _Lobj
+        const lconv* _Ptr      = _Lobj._Getlconv();
+        _Locinfo::_Cvtvec _Cvt = _Lobj._Getcvt(); // conversion information
+
+        _Grouping  = nullptr;
+        _Falsename = nullptr;
+        _Truename  = nullptr;
+
+        _Tidy_guard<numpunct> _Guard{this};
+        _Grouping      = _Maklocstr(_Isdef ? "" : _Ptr->grouping, static_cast<char*>(nullptr), _Lobj._Getcvt());
+        _Falsename     = _Maklocstr(_Lobj._Getfalse(), static_cast<_Elem*>(nullptr), _Cvt);
+        _Truename      = _Maklocstr(_Lobj._Gettrue(), static_cast<_Elem*>(nullptr), _Cvt);
+        _Guard._Target = nullptr;
+
+        if (_Isdef) { // apply defaults for required facets
+            // _Grouping = _Maklocstr("", static_cast<char *>(nullptr), _Cvt);
+            _Dp         = _Maklocchr('.', static_cast<_Elem*>(nullptr), _Cvt);
+            _Kseparator = _Maklocchr(',', static_cast<_Elem*>(nullptr), _Cvt);
+        } else {
+            _Getvals(_Elem{}, _Ptr, _Cvt);
+        }
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_decimal_point() const {
+        return _Dp;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_thousands_sep() const {
+        return _Kseparator;
+    }
+
+    virtual string __CLR_OR_THIS_CALL do_grouping() const {
+        return string{_Grouping};
+    }
+
+    virtual string_type __CLR_OR_THIS_CALL do_falsename() const {
+        return string_type{_Falsename};
+    }
+
+    virtual string_type __CLR_OR_THIS_CALL do_truename() const {
+        return string_type{_Truename};
+    }
+
+private:
+    void _Tidy() noexcept { // free all storage
+        _CSTD free(const_cast<char*>(_Grouping));
+        _CSTD free(const_cast<_Elem*>(_Falsename));
+        _CSTD free(const_cast<_Elem*>(_Truename));
+    }
+
+    const char* _Grouping; // grouping string, "" for "C" locale
+    _Elem _Dp; // decimal point, '.' for "C" locale
+    _Elem _Kseparator; // thousands separator, '\0' for "C" locale
+    const _Elem* _Falsename; // name for false, "false" for "C" locale
+    const _Elem* _Truename; // name for true, "true" for "C" locale
+};
+
+_EXPORT_STD template <class _Elem>
+class numpunct_byname : public numpunct<_Elem> { // numpunct for named locale
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    explicit numpunct_byname(const char* _Locname, size_t _Refs = 0)
+        : numpunct<_Elem>(_Locname, _Refs) {} // construct for named locale
+
+    explicit numpunct_byname(const string& _Str, size_t _Refs = 0)
+        : numpunct<_Elem>(_Str.c_str(), _Refs) {} // construct for named locale
+
+protected:
+    __CLR_OR_THIS_CALL ~numpunct_byname() noexcept override {}
+};
+
+#if !defined(_CRTBLD) || defined(CRTDLL2) || !defined(_DLL) || defined(_M_CEE_PURE) // TRANSITION, VSO-578955
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _Elem>
+__PURE_APPDOMAIN_GLOBAL locale::id numpunct<_Elem>::id;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+#endif // !defined(_CRTBLD) || defined(CRTDLL2) || !defined(_DLL) || defined(_M_CEE_PURE)
+
+struct _Num_get_parse_result {
+    // For integers: negative values mean parsing failure, while the "actual" base (used by _Getifld) is ~_Base.
+    // Otherwise, 0, 8, 10, or 16.
+    // For floating-point numbers: 0 for parsing failure, otherwise 10 or 16.
+    int8_t _Base;
+    bool _Bad_grouping;
+};
+
+_EXPORT_STD extern "C++" template <class _Elem, class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem>>>
+class num_get : public locale::facet { // facet for converting text to encoded numbers
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new num_get<_Elem, _InIt>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_NUMERIC;
+    }
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id; // unique facet id
+
+protected:
+    __CLR_OR_THIS_CALL ~num_get() noexcept override {}
+
+    void _Init(const _Locinfo&) {} // initialize from _Locinfo object
+
+public:
+    explicit __CLR_OR_THIS_CALL num_get(size_t _Refs = 0) : locale::facet(_Refs) { // construct from current locale
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    __CLR_OR_THIS_CALL num_get(const _Locinfo& _Lobj, size_t _Refs = 0) : locale::facet(_Refs) {
+        _Init(_Lobj);
+    }
+
+    using char_type = _Elem;
+    using iter_type = _InIt;
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        bool& _Val) const { // get bool from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Iosbase, _State, _Val);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        unsigned short& _Val) const { // get unsigned short from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Iosbase, _State, _Val);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        unsigned int& _Val) const { // get unsigned int from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Iosbase, _State, _Val);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        long& _Val) const { // get long from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Iosbase, _State, _Val);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        unsigned long& _Val) const { // get unsigned long from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Iosbase, _State, _Val);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        long long& _Val) const { // get long long from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Iosbase, _State, _Val);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        unsigned long long& _Val) const { // get unsigned long long from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Iosbase, _State, _Val);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        float& _Val) const { // get float from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Iosbase, _State, _Val);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        double& _Val) const { // get double from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Iosbase, _State, _Val);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        long double& _Val) const { // get long double from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Iosbase, _State, _Val);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        void*& _Val) const { // get void pointer from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Iosbase, _State, _Val);
+    }
+
+protected:
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        bool& _Val) const { // get bool from [_First, _Last) into _Val
+        _Adl_verify_range(_First, _Last);
+        if (_Iosbase.flags() & ios_base::boolalpha) { // get false name or true name
+            const auto& _Punct_fac = _STD use_facet<numpunct<_Elem>>(_Iosbase.getloc());
+            basic_string<_Elem> _Str(static_cast<size_t>(1), _Elem{});
+            _Str += _Punct_fac.falsename();
+            _Str.push_back(_Elem{});
+            _Str += _Punct_fac.truename(); // construct "\0false\0true"
+            switch (_Getloctxt(_First, _Last, 2, _Str.c_str(), _Case_sensitive::_Yes)) {
+            case 0:
+                _Val = false;
+                break;
+            case 1:
+                _Val = true;
+                break;
+            default:
+                _Val   = false;
+                _State = ios_base::failbit;
+                break;
+            }
+        } else { // get long value
+            char _Ac[_Max_int_dig];
+            const auto _Parse_result =
+                _Parse_int_with_locale(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc()); // gather field
+            if (_Parse_result._Base < 0) {
+                // N4950 [facet.num.get.virtuals]/3.9:
+                //  "zero, if the conversion function does not convert the entire field."
+                _Val   = false;
+                _State = ios_base::failbit;
+            } else {
+                char* _Ep;
+                int _Errno;
+                const long _Ans = _CSTD _Stolx(_Ac, &_Ep, _Parse_result._Base, &_Errno); // convert
+                if (_Ep == _Ac || _Errno != 0 // N4950 [facet.num.get.virtuals]/3
+                    || _Parse_result._Bad_grouping) { // N4950 [facet.num.get.virtuals]/4
+                    _Val   = true;
+                    _State = ios_base::failbit;
+                } else {
+                    _Val = _Ans != 0;
+                    if (_Ans != 0 && _Ans != 1) {
+                        _State = ios_base::failbit;
+                    }
+                }
+            }
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        unsigned short& _Val) const { // get unsigned short from [_First, _Last) into _Val
+        _Adl_verify_range(_First, _Last);
+        char _Ac[_Max_int_dig];
+        const auto _Parse_result =
+            _Parse_int_with_locale(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc()); // gather field
+        if (_Parse_result._Base < 0) { // ditto "fails to convert the entire field"
+            _State = ios_base::failbit;
+            _Val   = 0;
+        } else {
+            const bool _Minus   = _Ac[0] == '-';
+            const char* _Digits = _Ac;
+            // C11 7.22.1.4/5: the sequence of characters starting with the first digit
+            // is interpreted as an integer constant according to the rules of 6.4.4.1
+            if (_Minus) { // skip over minus to start with the first digit
+                ++_Digits;
+            }
+
+            char* _Ep;
+            int _Errno;
+            const unsigned long _Tmp = _CSTD _Stoulx(_Digits, &_Ep, _Parse_result._Base, &_Errno); // convert
+            _Val                     = static_cast<unsigned short>(_Tmp);
+            if (_Ep == _Digits || _Errno != 0 || _Tmp > USHRT_MAX) { // N4950 [facet.num.get.virtuals]/3
+                _State = ios_base::failbit;
+                _Val   = USHRT_MAX;
+            } else if (_Minus) { // C11 7.22.1.4/5:  If the subject sequence begins with a minus sign,
+                                 // the value resulting from the conversion is negated (in the return type).
+                _Val = static_cast<unsigned short>(0 - _Val);
+            }
+
+            if (_Parse_result._Bad_grouping) { // N4950 [facet.num.get.virtuals]/4
+                _State = ios_base::failbit;
+            }
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        unsigned int& _Val) const { // get unsigned int from [_First, _Last) into _Val
+        static_assert(sizeof(unsigned int) == sizeof(unsigned long),
+            "Bad overflow assumptions due to sizeof(unsigned int) != sizeof(unsigned long)");
+        unsigned long _Tmp;
+        _First = num_get::do_get(_First, _Last, _Iosbase, _State, _Tmp); // avoid virtual call for perf
+        _Val   = _Tmp;
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        long& _Val) const { // get long from [_First, _Last) into _Val
+        _Adl_verify_range(_First, _Last);
+        char _Ac[_Max_int_dig];
+        const auto _Parse_result =
+            _Parse_int_with_locale(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc()); // gather field
+        if (_Parse_result._Base < 0) { // ditto "fails to convert the entire field"
+            _State = ios_base::failbit;
+            _Val   = 0;
+        } else {
+            char* _Ep;
+            int _Errno;
+            _Val = _CSTD _Stolx(_Ac, &_Ep, _Parse_result._Base, &_Errno); // convert
+            if (_Ep == _Ac || _Errno != 0 // N4950 [facet.num.get.virtuals]/3
+                || _Parse_result._Bad_grouping) { // N4950 [facet.num.get.virtuals]/4
+                _State = ios_base::failbit;
+            }
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        unsigned long& _Val) const { // get unsigned long from [_First, _Last) into _Val
+        _Adl_verify_range(_First, _Last);
+        char _Ac[_Max_int_dig];
+        const auto _Parse_result =
+            _Parse_int_with_locale(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc()); // gather field
+        if (_Parse_result._Base < 0) { // ditto "fails to convert the entire field"
+            _State = ios_base::failbit;
+            _Val   = 0;
+        } else {
+            char* _Ep;
+            int _Errno;
+            _Val = _CSTD _Stoulx(_Ac, &_Ep, _Parse_result._Base, &_Errno); // convert
+            if (_Ep == _Ac || _Errno != 0 // N4950 [facet.num.get.virtuals]/3
+                || _Parse_result._Bad_grouping) { // N4950 [facet.num.get.virtuals]/4
+                _State = ios_base::failbit;
+            }
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        long long& _Val) const { // get long long from [_First, _Last) into _Val
+        _Adl_verify_range(_First, _Last);
+        char _Ac[_Max_int_dig];
+        const auto _Parse_result =
+            _Parse_int_with_locale(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc()); // gather field
+        if (_Parse_result._Base < 0) { // ditto "fails to convert the entire field"
+            _State = ios_base::failbit;
+            _Val   = 0;
+        } else {
+            char* _Ep;
+            int _Errno;
+            _Val = _CSTD _Stollx(_Ac, &_Ep, _Parse_result._Base, &_Errno); // convert
+            if (_Ep == _Ac || _Errno != 0 // N4950 [facet.num.get.virtuals]/3
+                || _Parse_result._Bad_grouping) { // N4950 [facet.num.get.virtuals]/4
+                _State = ios_base::failbit;
+            }
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        unsigned long long& _Val) const { // get unsigned long long from [_First, _Last) into _Val
+        _Adl_verify_range(_First, _Last);
+        char _Ac[_Max_int_dig];
+        const auto _Parse_result =
+            _Parse_int_with_locale(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc()); // gather field
+        if (_Parse_result._Base < 0) { // ditto "fails to convert the entire field"
+            _State = ios_base::failbit;
+            _Val   = 0;
+        } else {
+            int _Errno;
+            char* _Ep;
+            _Val = _CSTD _Stoullx(_Ac, &_Ep, _Parse_result._Base, &_Errno); // convert
+            if (_Ep == _Ac || _Errno != 0 // N4950 [facet.num.get.virtuals]/3
+                || _Parse_result._Bad_grouping) { // N4950 [facet.num.get.virtuals]/4
+                _State = ios_base::failbit;
+            }
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        return _First;
+    }
+
+#define _MAX_SIG_DIG_V2 768
+#define _MAX_EXP_DIG    8 // for parsing floating-point numbers
+// Size of char buffer used by num_get::do_get() for float/double/long double
+#define _FLOATING_BUFFER_SIZE (_MAX_EXP_DIG + _MAX_SIG_DIG_V2 + 16)
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        float& _Val) const { // get float from [_First, _Last) into _Val
+        _Adl_verify_range(_First, _Last);
+        char _Ac[_FLOATING_BUFFER_SIZE];
+        const auto _Parse_result =
+            _Parse_fp_with_locale(_Ac, _MAX_SIG_DIG_V2, _First, _Last, _Iosbase.getloc()); // gather field
+        if (_Parse_result._Base == 0) { // ditto "fails to convert the entire field"
+            _State = ios_base::failbit;
+            _Val   = 0.0f;
+        } else {
+            int _Errno;
+            char* _Ep;
+            _Val = _STD _Stofx_v3(_Ac, &_Ep, &_Errno); // convert
+            if (_Ep == _Ac || _Errno != 0 // N4950 [facet.num.get.virtuals]/3
+                || _Parse_result._Bad_grouping) { // N4950 [facet.num.get.virtuals]/4
+                _State = ios_base::failbit;
+            }
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        double& _Val) const { // get double from [_First, _Last) into _Val
+        _Adl_verify_range(_First, _Last);
+        char _Ac[_FLOATING_BUFFER_SIZE];
+        const auto _Parse_result =
+            _Parse_fp_with_locale(_Ac, _MAX_SIG_DIG_V2, _First, _Last, _Iosbase.getloc()); // gather field
+        if (_Parse_result._Base == 0) { // ditto "fails to convert the entire field"
+            _State = ios_base::failbit;
+            _Val   = 0.0;
+        } else {
+            int _Errno;
+            char* _Ep;
+            _Val = _STD _Stodx_v3(_Ac, &_Ep, &_Errno); // convert
+            if (_Ep == _Ac || _Errno != 0 // N4950 [facet.num.get.virtuals]/3
+                || _Parse_result._Bad_grouping) { // N4950 [facet.num.get.virtuals]/4
+                _State = ios_base::failbit;
+            }
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        return _First;
+    }
+#undef _FLOATING_BUFFER_SIZE
+#undef _MAX_EXP_DIG
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        long double& _Val) const { // get long double from [_First, _Last) into _Val
+        // Assumes sizeof(double) == sizeof(long double).
+        // For 80-bit long double (which is not supported by MSVC in general), this will compile
+        // but will not attempt to handle the increased precision at runtime.
+        double _Result;
+        _First = num_get::do_get(_First, _Last, _Iosbase, _State, _Result); // avoid virtual call for perf
+        _Val   = _Result;
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        void*& _Val) const { // get void pointer from [_First, _Last) into _Val
+        _Adl_verify_range(_First, _Last);
+        char _Ac[_Max_int_dig];
+        const auto _Parse_result =
+            _Parse_int_with_locale(_Ac, _First, _Last, ios_base::hex, _Iosbase.getloc()); // gather field
+        if (_Parse_result._Base < 0) { // ditto "fails to convert the entire field"
+            _State = ios_base::failbit;
+            _Val   = nullptr;
+        } else {
+            int _Errno;
+            char* _Ep;
+#ifdef _WIN64
+            _Val = reinterpret_cast<void*>(_CSTD _Stoullx(_Ac, &_Ep, _Parse_result._Base, &_Errno));
+#else // ^^^ defined(_WIN64) / !defined(_WIN64) vvv
+            _Val = reinterpret_cast<void*>(_CSTD _Stoulx(_Ac, &_Ep, _Parse_result._Base, &_Errno));
+#endif // ^^^ !defined(_WIN64) ^^^
+            if (_Ep == _Ac || _Errno != 0) { // N4950 [facet.num.get.virtuals]/3
+                _State = ios_base::failbit;
+                _Val   = nullptr;
+            }
+
+            if (_Parse_result._Bad_grouping) { // N4950 [facet.num.get.virtuals]/4
+                _State = ios_base::failbit;
+            }
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        return _First;
+    }
+
+private:
+    template <int = 0> // TRANSITION, ABI
+    static _Num_get_parse_result _Parse_int_with_locale(
+        char* const _Ac, _InIt& _First, _InIt& _Last, ios_base::fmtflags _Basefield, const locale& _Loc) {
+        // get integer field from [_First, _Last) into _Ac
+        const auto& _Punct_fac  = _STD use_facet<numpunct<_Elem>>(_Loc);
+        const string _Grouping  = _Punct_fac.grouping();
+        const _Elem _Kseparator = _Grouping.empty() ? _Elem{} : _Punct_fac.thousands_sep();
+
+        constexpr int _Numget_signoff = 22;
+        constexpr int _Numget_xoff    = 24;
+        static constexpr char _Src[]  = "0123456789ABCDEFabcdef-+Xx";
+        _Elem _Atoms[sizeof(_Src)];
+        const ctype<_Elem>& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Loc);
+        _Ctype_fac.widen(_STD begin(_Src), _STD end(_Src), _Atoms);
+
+        bool _Bad_grouping = false;
+
+        // skip leading separators before the sign
+        if (_Kseparator != _Elem{}) {
+            while (_First != _Last && *_First == _Kseparator) {
+                ++_First;
+                _Bad_grouping = true;
+            }
+        }
+
+        char* _Ptr = _Ac;
+
+        if (_First != _Last) {
+            if (*_First == _Atoms[_Numget_signoff + 1]) { // gather plus sign
+                *_Ptr++ = '+';
+                ++_First;
+            } else if (*_First == _Atoms[_Numget_signoff]) { // gather minus sign
+                *_Ptr++ = '-';
+                ++_First;
+            }
+        }
+
+        // skip leading separators before digits
+        if (_Kseparator != _Elem{}) {
+            while (_First != _Last && *_First == _Kseparator) {
+                ++_First;
+                _Bad_grouping = true;
+            }
+        }
+
+        _Basefield &= ios_base::basefield;
+
+        int8_t _Base;
+        if (_Basefield == ios_base::oct) {
+            _Base = 8;
+        } else if (_Basefield == ios_base::hex) {
+            _Base = 16;
+        } else if (_Basefield == ios_base::_Fmtzero) {
+            _Base = 0;
+        } else {
+            _Base = 10;
+        }
+
+        bool _Seendigit = false; // seen a digit in input
+        bool _Nonzero   = false; // seen a nonzero digit in input
+
+        if (_First != _Last && *_First == _Atoms[0]) { // leading zero, look for 0x, 0X
+            _Seendigit = true;
+            ++_First;
+            if (_First != _Last && (*_First == _Atoms[_Numget_xoff + 1] || *_First == _Atoms[_Numget_xoff])
+                && (_Base == 0 || _Base == 16)) {
+                _Base      = 16;
+                _Seendigit = false;
+                ++_First;
+            } else if (_Base == 0) {
+                _Base = 8;
+            }
+        }
+
+        const auto _Dlen = static_cast<size_t>(_Base == 0 || _Base == 10 ? 10 : _Base == 8 ? 8 : 16 + 6);
+        string _Groups(1, static_cast<char>(_Seendigit)); // Groups are detected in the reversed order of _Groups.
+        size_t _Groups_arr_idx = 0;
+
+        for (char* const _Pe = &_Ac[_Max_int_dig - 1]; _First != _Last; ++_First) { // look for digits and separators
+            size_t _Idx = _STD _Find_elem(_Atoms, *_First);
+            if (_Idx < _Dlen) { // got a digit, characterize it and add to group size
+                *_Ptr = _Src[_Idx];
+                if ((_Nonzero || *_Ptr != '0') && _Ptr < _Pe) {
+                    ++_Ptr;
+                    _Nonzero = true;
+                }
+
+                _Seendigit = true;
+                if (_Groups[_Groups_arr_idx] != CHAR_MAX) {
+                    ++_Groups[_Groups_arr_idx];
+                }
+            } else if (_Kseparator == _Elem{} || *_First != _Kseparator) {
+                break; // not a group separator, done
+            } else if (_Groups[_Groups_arr_idx] == '\0') {
+                _Bad_grouping = true; // adjacent separators, fail
+            } else { // add a new group to _Groups string
+                _Groups.push_back('\0');
+                ++_Groups_arr_idx;
+            }
+        }
+
+        if (_Groups_arr_idx != 0) {
+            if (_Groups[_Groups_arr_idx] > '\0') {
+                ++_Groups_arr_idx; // add trailing group to group count
+            } else {
+                _Bad_grouping = true; // trailing separator, fail
+            }
+        }
+
+        // skip trailing separators
+        if (_Kseparator != _Elem{}) {
+            while (_First != _Last && *_First == _Kseparator) {
+                ++_First;
+                _Bad_grouping = true;
+            }
+        }
+
+        const char* _Grouping_iter      = _Grouping.data();
+        const char* const _Grouping_end = _Grouping_iter + _Grouping.size();
+        for (char _Current_grouping_count = '\0'; _Seendigit && !_Bad_grouping && _Groups_arr_idx > 0;) {
+            if (_Grouping_iter != _Grouping_end) { // keep the last value when _Grouping is exhausted
+                _Current_grouping_count = *_Grouping_iter; // if _Grouping is empty, '\0' is used
+                ++_Grouping_iter;
+            }
+
+            --_Groups_arr_idx;
+            if ((_Current_grouping_count > '\0' && _Current_grouping_count != CHAR_MAX)
+                && ((_Groups_arr_idx > 0 && _Groups[_Groups_arr_idx] != _Current_grouping_count)
+                    || (_Groups_arr_idx == 0 && _Groups[_Groups_arr_idx] > _Current_grouping_count))) {
+                _Bad_grouping = true; // bad group size, fail
+            }
+            // group size okay, advance to next test
+        }
+
+        if (!_Seendigit) {
+            return {static_cast<int8_t>(~_Base), false};
+        }
+
+        if (!_Nonzero) {
+            *_Ptr++ = '0'; // zero field, replace stripped zero(s)
+        }
+
+        *_Ptr = '\0';
+        return {_Base, _Bad_grouping};
+    }
+
+    template <int = 0> // TRANSITION, ABI
+    static _Num_get_parse_result _Parse_fp_with_locale(
+        char* const _Ac, const int _Max_sig_dig, _InIt& _First, _InIt& _Last, const locale& _Loc) {
+        // get floating-point field from [_First, _Last) into _Ac
+        char* _Ptr = _Ac;
+
+        constexpr size_t _Offset_dec_digit_end = 10;
+        constexpr size_t _Offset_hex_digit_end = 22;
+        constexpr size_t _Offset_neg_sign      = 22;
+        constexpr size_t _Offset_pos_sign      = 23;
+        constexpr size_t _Offset_upper_x       = 24;
+        constexpr size_t _Offset_lower_x       = 25;
+        constexpr size_t _Offset_upper_p       = 26;
+        constexpr size_t _Offset_lower_p       = 27;
+        constexpr size_t _Offset_upper_e       = 14;
+        constexpr size_t _Offset_lower_e       = 20;
+        static constexpr char _Src[]           = "0123456789ABCDEFabcdef-+XxPp";
+        _Elem _Atoms[sizeof(_Src)];
+        const auto& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Loc);
+        _Ctype_fac.widen(_STD begin(_Src), _STD end(_Src), _Atoms);
+
+        const _Elem _Positive_sign = _Atoms[_Offset_pos_sign];
+        const _Elem _Negative_sign = _Atoms[_Offset_neg_sign];
+        const _Elem _Zero_wc       = _Atoms[0];
+
+        const auto& _Punct_fac  = _STD use_facet<numpunct<_Elem>>(_Loc);
+        const string _Grouping  = _Punct_fac.grouping();
+        const _Elem _Kseparator = _Grouping.empty() ? _Elem{} : _Punct_fac.thousands_sep();
+
+        bool _Bad_grouping = false;
+
+        // skip leading separators before the sign
+        if (!_Grouping.empty()) {
+            while (_First != _Last && *_First == _Kseparator) {
+                ++_First;
+                _Bad_grouping = true;
+            }
+        }
+
+        if (_First != _Last) {
+            if (*_First == _Positive_sign) { // gather plus sign
+                *_Ptr++ = '+';
+                ++_First;
+            } else if (*_First == _Negative_sign) { // gather minus sign
+                *_Ptr++ = '-';
+                ++_First;
+            }
+        }
+
+        *_Ptr++ = '0'; // backstop carries from sticky bit
+
+        bool _Parse_hex                = false;
+        bool _Seendigit                = false; // seen a digit in input
+        char _Initial_dec_leading_zero = '\0';
+        if (_First != _Last && *_First == _Zero_wc) {
+            ++_First;
+            if (_First == _Last) { // "0" only
+                *_Ptr = '\0';
+                return {10, _Bad_grouping};
+            }
+
+            if (*_First == _Atoms[_Offset_lower_x] || *_First == _Atoms[_Offset_upper_x]) { // 0x or 0X
+                _Parse_hex = true;
+                ++_First; // discard 0x or 0X for further parsing
+                *_Ptr++ = 'x';
+            } else {
+                _Seendigit = true;
+                ++_Initial_dec_leading_zero;
+            }
+        }
+
+        bool _Has_unaccumulated_digits = false;
+        int _Significant               = 0; // number of significant digits
+        ptrdiff_t _Power_of_rep_base   = 0; // power of 10 or 16
+
+        const size_t _Offset_digit_end = _Parse_hex ? _Offset_hex_digit_end : _Offset_dec_digit_end;
+        if (_Grouping.empty()) {
+            for (size_t _Idx; _First != _Last && (_Idx = _STD _Find_elem(_Atoms, *_First)) < _Offset_digit_end;
+                 _Seendigit = true, (void) ++_First) {
+                if (_Significant >= _Max_sig_dig) {
+                    ++_Power_of_rep_base; // just scale by 10 or 16
+                    if (_Idx > 0) {
+                        _Has_unaccumulated_digits = true;
+                    }
+                } else if (_Idx != 0 || _Significant != 0) { // save a significant digit
+                    *_Ptr++ = _Src[_Idx];
+                    ++_Significant;
+                }
+            }
+        } else {
+            // skip leading separators before digits
+            while (_First != _Last && *_First == _Kseparator) {
+                ++_First;
+                _Bad_grouping = true;
+            }
+
+            string _Groups(1, _Initial_dec_leading_zero); // Groups are detected in the reversed order of _Groups.
+            size_t _Groups_arr_idx = 0;
+
+            for (; _First != _Last; ++_First) {
+                const size_t _Idx = _STD _Find_elem(_Atoms, *_First);
+                if (_Idx < _Offset_digit_end) { // got a digit, add to group size
+                    _Seendigit = true;
+                    if (_Significant >= _Max_sig_dig) {
+                        ++_Power_of_rep_base; // just scale by 10 or 16
+                        if (_Idx > 0) {
+                            _Has_unaccumulated_digits = true;
+                        }
+                    } else if (_Idx != 0 || _Significant != 0) { // save a significant digit
+                        *_Ptr++ = _Src[_Idx];
+                        ++_Significant;
+                    }
+
+                    if (_Groups[_Groups_arr_idx] != CHAR_MAX) {
+                        ++_Groups[_Groups_arr_idx];
+                    }
+                } else if (*_First != _Kseparator) {
+                    break; // not a group separator, done
+                } else if (_Groups[_Groups_arr_idx] == '\0') {
+                    _Bad_grouping = true; // adjacent separators, fail
+                } else { // add a new group to _Groups string
+                    _Groups.push_back('\0');
+                    ++_Groups_arr_idx;
+                }
+            }
+
+            if (_Groups_arr_idx != 0) {
+                if (_Groups[_Groups_arr_idx] > '\0') {
+                    ++_Groups_arr_idx; // add trailing group to group count
+                } else {
+                    _Bad_grouping = true; // trailing separator, fail
+                }
+            }
+
+            // skip trailing separators
+            while (_First != _Last && *_First == _Kseparator) {
+                ++_First;
+                _Bad_grouping = true;
+            }
+
+            const char* _Grouping_iter      = _Grouping.data();
+            const char* const _Grouping_end = _Grouping_iter + _Grouping.size();
+            char _Current_grouping_count    = '\0';
+            while (!_Bad_grouping && _Groups_arr_idx > 0) {
+                if (_Grouping_iter != _Grouping_end) { // keep the last value when _Grouping is exhausted
+                    _Current_grouping_count = *_Grouping_iter; // assign the variable at least once
+                    ++_Grouping_iter;
+                }
+
+                --_Groups_arr_idx;
+                if ((_Current_grouping_count > '\0' && _Current_grouping_count != CHAR_MAX)
+                    && ((_Groups_arr_idx > 0 && _Groups[_Groups_arr_idx] != _Current_grouping_count)
+                        || (_Groups_arr_idx == 0 && _Groups[_Groups_arr_idx] > _Current_grouping_count))) {
+                    _Bad_grouping = true; // bad group size, fail
+                }
+                // group size okay, advance to next test
+            }
+        }
+
+        if (_Parse_hex && _Seendigit && _Significant == 0) {
+            // the condition is true when all of the digits after the 'x' and before the decimal point are zero
+            *_Ptr++ = '0'; // save at least one leading digit for hex
+        }
+
+        const char _Decimal_point = _CSTD localeconv()->decimal_point[0];
+        if (_First != _Last && *_First == _Punct_fac.decimal_point()) { // add .
+            *_Ptr++ = _Decimal_point;
+            ++_First;
+        }
+
+        if (_Significant == 0) { // 0000. so far
+            for (; _First != _Last && *_First == _Zero_wc; _Seendigit = true, (void) ++_First) {
+                --_Power_of_rep_base; // count leading fraction zeros without storing digits into buffer
+            }
+        }
+
+        for (size_t _Idx; _First != _Last && (_Idx = _STD _Find_elem(_Atoms, *_First)) < _Offset_digit_end;
+             _Seendigit = true, (void) ++_First) {
+            if (_Significant < _Max_sig_dig) { // save a significant fraction digit
+                *_Ptr++ = _Src[_Idx];
+                ++_Significant;
+            } else if (_Idx > 0) {
+                _Has_unaccumulated_digits = true; // just update _Has_unaccumulated_digits
+            }
+        }
+
+        if (_Has_unaccumulated_digits) { // increment last digit in memory of those lost
+            char& _Last_got_digit = _Ptr[-1] == _Decimal_point ? _Ptr[-2] : _Ptr[-1];
+            if (_Last_got_digit == '0' || _Last_got_digit == (_Parse_hex ? '8' : '5')) {
+                ++_Last_got_digit;
+            }
+        }
+
+        const _Elem _Lower_exp_wc = _Atoms[_Parse_hex ? _Offset_lower_p : _Offset_lower_e]; // 'e' for dec, 'p' for hex
+        const _Elem _Upper_exp_wc = _Atoms[_Parse_hex ? _Offset_upper_p : _Offset_upper_e]; // 'E' for dec, 'P' for hex
+
+        bool _Exponent_part_negative = false;
+        ptrdiff_t _Exponent_part     = 0;
+        if (_Seendigit && _First != _Last
+            && (*_First == _Lower_exp_wc || *_First == _Upper_exp_wc)) { // collect exponent
+            ++_First;
+            _Seendigit   = false;
+            _Significant = 0;
+
+            if (_First != _Last) {
+                if (*_First == _Positive_sign) { // gather plus sign
+                    ++_First;
+                } else if (*_First == _Negative_sign) { // gather minus sign
+                    _Exponent_part_negative = true;
+                    ++_First;
+                }
+            }
+
+            for (; _First != _Last && *_First == _Zero_wc; ++_First) { // strip leading zeros
+                _Seendigit = true;
+            }
+
+            for (size_t _Idx; _First != _Last && (_Idx = _STD _Find_elem(_Atoms, *_First)) < _Offset_dec_digit_end;
+                 _Seendigit = true, (void) ++_First) {
+                if (_Exponent_part < PTRDIFF_MAX / 10
+                    || (_Exponent_part == PTRDIFF_MAX / 10
+                        && static_cast<ptrdiff_t>(_Idx) <= PTRDIFF_MAX % 10)) { // save a significant exponent digit
+                    _Exponent_part = _Exponent_part * 10 + static_cast<ptrdiff_t>(_Idx);
+                } else {
+                    _Exponent_part = PTRDIFF_MAX; // saturated
+                }
+            }
+
+            if (_Exponent_part_negative) {
+                _Exponent_part = -_Exponent_part;
+            }
+        }
+
+        if (!_Seendigit) {
+            return {0, false};
+        }
+
+        constexpr int _Dec_exp_abs_bound = 1100; // slightly greater than 324 + 768
+        constexpr int _Hex_exp_abs_bound = 4200; // slightly greater than 1074 + 768 * 4
+
+        const ptrdiff_t _Exp_abs_bound     = _Parse_hex ? _Hex_exp_abs_bound : _Dec_exp_abs_bound;
+        const ptrdiff_t _Exp_rep_abs_bound = _Parse_hex ? _Hex_exp_abs_bound / 4 : _Dec_exp_abs_bound;
+
+        // basically _Exponent_part = _STD clamp(-_Exp_abs_bound,
+        //     _Exponent_part + _Parse_hex ? _Power_of_rep_base * 4 : _Power_of_rep_base, _Exp_abs_bound)
+        // but need to defend overflowing
+        for (ptrdiff_t _Power_of_rep_adjusted = _Power_of_rep_base;;) {
+            if (_Exponent_part >= 0 && _Power_of_rep_adjusted >= 0
+                && (_Exponent_part >= _Exp_abs_bound || _Power_of_rep_adjusted >= _Exp_rep_abs_bound)) {
+                _Exponent_part = _Exp_abs_bound;
+                break;
+            } else if (_Exponent_part <= 0 && _Power_of_rep_adjusted <= 0
+                       && (_Exponent_part <= -_Exp_abs_bound || _Power_of_rep_adjusted <= -_Exp_rep_abs_bound)) {
+                _Exponent_part = -_Exp_abs_bound;
+                break;
+            } else if (_STD abs(_Exponent_part) <= _Exp_abs_bound
+                       && _STD abs(_Power_of_rep_adjusted) <= _Exp_rep_abs_bound) {
+                // _Exponent_part and _Power_of_rep_base are of different signedness, both of which are small enough
+                _Exponent_part += _Parse_hex ? _Power_of_rep_adjusted * 4 : _Power_of_rep_adjusted;
+                if (_Exponent_part > _Exp_abs_bound) {
+                    _Exponent_part = _Exp_abs_bound;
+                } else if (_Exponent_part < -_Exp_abs_bound) {
+                    _Exponent_part = -_Exp_abs_bound;
+                }
+                break;
+            } else {
+                // only enters once:
+                // _Exponent_part and _Power_of_rep_base are of different signedness, but at least one is large
+                const ptrdiff_t _Exponent_part_preadjustment_round_up =
+                    _Parse_hex ? (_STD abs(_Exponent_part) - 1) / 4 + 1 : _STD abs(_Exponent_part);
+                const ptrdiff_t _Exp_rep_adjustment =
+                    (_STD min)(_Exponent_part_preadjustment_round_up, _STD abs(_Power_of_rep_base));
+
+                if (_Exponent_part >= 0) {
+                    _Exponent_part -= _Parse_hex ? _Exp_rep_adjustment * 4 : _Exp_rep_adjustment;
+                    _Power_of_rep_adjusted += _Exp_rep_adjustment;
+                } else {
+                    _Exponent_part += _Parse_hex ? _Exp_rep_adjustment * 4 : _Exp_rep_adjustment;
+                    _Power_of_rep_adjusted -= _Exp_rep_adjustment;
+                }
+            }
+        }
+
+        if (_Exponent_part != 0) {
+            *_Ptr++ = _Parse_hex ? 'p' : 'e';
+            if (_Exponent_part < 0) {
+                *_Ptr++ = '-';
+            }
+
+            char* const _Rev_begin = _Ptr;
+            for (ptrdiff_t _Exponent_part_abs = _STD abs(_Exponent_part); _Exponent_part_abs != 0;
+                 _Exponent_part_abs /= 10) {
+                *_Ptr++ = static_cast<char>('0' + _Exponent_part_abs % 10);
+            }
+            _STD reverse(_Rev_begin, _Ptr);
+        }
+
+        *_Ptr = '\0';
+        return {static_cast<int8_t>(_Parse_hex ? 16 : 10), _Bad_grouping};
+    }
+
+    // TRANSITION, ABI, unused now, tracked by VSO-591516.
+    int __CLRCALL_OR_CDECL _Getifld(
+        char* _Ac, _InIt& _First, _InIt& _Last, ios_base::fmtflags _Basefield, const locale& _Loc) const {
+        // get integer field from [_First, _Last) into _Ac
+        static constexpr char _Src[] = "0123456789ABCDEFabcdef-+Xx"; // TRANSITION, ABI, was implicitly dllexported
+        const char* volatile _Ptr    = _Src;
+        (void) _Ptr;
+
+        const auto _Parse_result = _Parse_int_with_locale(_Ac, _First, _Last, _Basefield, _Loc);
+        if (_Parse_result._Base < 0 || _Parse_result._Bad_grouping) { // TRANSITION, ABI, old behavior
+            *_Ac = '\0';
+        }
+        return _Parse_result._Base < 0 ? ~_Parse_result._Base : _Parse_result._Base;
+    }
+
+#define _MAX_SIG_DIG_V1 36 // TRANSITION, ABI
+// TRANSITION, ABI: Sentinel value used by num_get::do_get()
+// to enable correct "V2" behavior in _Getffld() and _Getffldx()
+#define _ENABLE_V2_BEHAVIOR 1000000000
+
+    // TRANSITION, ABI, unused now
+    int __CLRCALL_OR_CDECL _Getffld(char* _Ac, _InIt& _First, _InIt& _Last, ios_base& _Iosbase, int* _Phexexp) const {
+        // get floating-point field from [_First, _Last) into _Ac
+        static constexpr char _Src[] = "0123456789-+Ee"; // TRANSITION, ABI, was implicitly dllexported
+        const char* volatile _Ptr    = &_Src[0];
+        (void) _Ptr;
+        const int _Max_sig_dig   = (*_Phexexp == _ENABLE_V2_BEHAVIOR ? _MAX_SIG_DIG_V2 : _MAX_SIG_DIG_V1);
+        const auto _Parse_result = _Parse_fp_with_locale(_Ac, _Max_sig_dig, _First, _Last, _Iosbase.getloc());
+        if (_Parse_result._Base == 0 || _Parse_result._Bad_grouping) { // TRANSITION, ABI, old behavior
+            *_Ac = '\0';
+        }
+
+        if (_Parse_result._Base == 16) {
+            *_Phexexp = 0; // power of 16 multiplier, unnecessary now
+        }
+        return 0; // power of 10 multiplier, unnecessary now
+    }
+
+    // TRANSITION, ABI, unused now
+    int __CLRCALL_OR_CDECL _Getffldx(char* _Ac, _InIt& _First, _InIt& _Last, ios_base& _Iosbase, int* _Phexexp) const {
+        // get floating-point field from [_First, _Last) into _Ac
+        static constexpr char _Src[] = "0123456789ABCDEFabcdef-+XxPp"; // TRANSITION, ABI, was implicitly dllexported
+        const char* volatile _Ptr    = &_Src[0];
+        (void) _Ptr;
+        const int _Max_sig_dig   = (*_Phexexp == _ENABLE_V2_BEHAVIOR ? _MAX_SIG_DIG_V2 : _MAX_SIG_DIG_V1);
+        const auto _Parse_result = _Parse_fp_with_locale(_Ac, _Max_sig_dig, _First, _Last, _Iosbase.getloc());
+        if (_Parse_result._Base == 0 || _Parse_result._Bad_grouping) { // TRANSITION, ABI, old behavior
+            *_Ac = '\0';
+        }
+
+        if (_Parse_result._Base == 16) {
+            *_Phexexp = 0; // power of 16 multiplier, unnecessary now
+        }
+        return 0; // power of 10 multiplier, unnecessary now
+    }
+
+#undef _ENABLE_V2_BEHAVIOR
+#undef _MAX_SIG_DIG_V1
+#undef _MAX_SIG_DIG_V2
+};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _Elem, class _InIt>
+__PURE_APPDOMAIN_GLOBAL locale::id num_get<_Elem, _InIt>::id;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+
+template <class _Ty>
+int _Float_put_desired_precision(const streamsize _Precision, const ios_base::fmtflags _Float_flags) {
+    // return the effective precision determined by N4950 [facet.num.put.virtuals]/2.1 and printf's rules
+    const bool _Is_hex = _Float_flags == (ios_base::fixed | ios_base::scientific);
+    if (_Is_hex) {
+        // return the number of hexits needed (after the radix point) to represent the floating-point value exactly
+        if constexpr (is_same_v<_Ty, double>) {
+            return ((DBL_MANT_DIG - 1) + 3) / 4;
+        } else if constexpr (is_same_v<_Ty, long double>) {
+            return ((LDBL_MANT_DIG - 1) + 3) / 4;
+        } else {
+            _STL_INTERNAL_STATIC_ASSERT(false); // unexpected type; shouldn't be float
+        }
+    }
+
+    if (_Precision > 0) {
+        return static_cast<int>(_Precision);
+    } else if (_Precision == 0) {
+        const bool _Is_default_float = _Float_flags == 0;
+        if (_Is_default_float) {
+            return 1;
+        } else {
+            return 0;
+        }
+    } else {
+        constexpr int _Default_precision = 6;
+        return _Default_precision;
+    }
+}
+
+_EXPORT_STD extern "C++" template <class _Elem, class _OutIt = ostreambuf_iterator<_Elem, char_traits<_Elem>>>
+class num_put : public locale::facet { // facet for converting encoded numbers to text
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new num_put<_Elem, _OutIt>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_NUMERIC;
+    }
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id; // unique facet id
+
+protected:
+    __CLR_OR_THIS_CALL ~num_put() noexcept override {}
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo&) {} // initialize from _Locinfo object
+
+public:
+    explicit __CLR_OR_THIS_CALL num_put(size_t _Refs = 0) : locale::facet(_Refs) { // construct from current locale
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    __CLR_OR_THIS_CALL num_put(const _Locinfo& _Lobj, size_t _Refs = 0) : locale::facet(_Refs) {
+        _Init(_Lobj);
+    }
+
+    using char_type = _Elem;
+    using iter_type = _OutIt;
+
+    _OutIt __CLR_OR_THIS_CALL put(
+        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, bool _Val) const { // put formatted bool to _Dest
+        return do_put(_Dest, _Iosbase, _Fill, _Val);
+    }
+
+    _OutIt __CLR_OR_THIS_CALL put(
+        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, long _Val) const { // put formatted long to _Dest
+        return do_put(_Dest, _Iosbase, _Fill, _Val);
+    }
+
+    _OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill,
+        unsigned long _Val) const { // put formatted unsigned long to _Dest
+        return do_put(_Dest, _Iosbase, _Fill, _Val);
+    }
+
+    _OutIt __CLR_OR_THIS_CALL put(
+        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, long long _Val) const { // put formatted long long to _Dest
+        return do_put(_Dest, _Iosbase, _Fill, _Val);
+    }
+
+    _OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill,
+        unsigned long long _Val) const { // put formatted unsigned long long to _Dest
+        return do_put(_Dest, _Iosbase, _Fill, _Val);
+    }
+
+    _OutIt __CLR_OR_THIS_CALL put(
+        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, double _Val) const { // put formatted double to _Dest
+        return do_put(_Dest, _Iosbase, _Fill, _Val);
+    }
+
+    _OutIt __CLR_OR_THIS_CALL put(
+        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, long double _Val) const { // put formatted long double to _Dest
+        return do_put(_Dest, _Iosbase, _Fill, _Val);
+    }
+
+    _OutIt __CLR_OR_THIS_CALL put(
+        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const void* _Val) const { // put formatted void pointer to _Dest
+        return do_put(_Dest, _Iosbase, _Fill, _Val);
+    }
+
+protected:
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(
+        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, bool _Val) const { // put formatted bool to _Dest
+        if (!(_Iosbase.flags() & ios_base::boolalpha)) {
+            return do_put(_Dest, _Iosbase, _Fill, static_cast<long>(_Val));
+        } else { // put "false" or "true"
+            const auto& _Punct_fac = _STD use_facet<numpunct<_Elem>>(_Iosbase.getloc());
+            basic_string<_Elem> _Str;
+            if (_Val) {
+                _Str.assign(_Punct_fac.truename());
+            } else {
+                _Str.assign(_Punct_fac.falsename());
+            }
+
+            size_t _Fillcount;
+            if (_Iosbase.width() <= 0 || static_cast<size_t>(_Iosbase.width()) <= _Str.size()) {
+                _Fillcount = 0;
+            } else {
+                _Fillcount = static_cast<size_t>(_Iosbase.width()) - _Str.size();
+            }
+
+            if ((_Iosbase.flags() & ios_base::adjustfield) != ios_base::left) { // put leading fill
+                _Dest      = _Rep(_Dest, _Fill, _Fillcount);
+                _Fillcount = 0;
+            }
+            _Dest = _Put(_Dest, _Str.c_str(), _Str.size()); // put field
+            _Iosbase.width(0);
+            return _Rep(_Dest, _Fill, _Fillcount); // put trailing fill
+        }
+    }
+
+#pragma warning(push)
+#pragma warning(disable : 4774) // format string expected in argument N is not a string literal (/Wall)
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(
+        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, long _Val) const { // put formatted long to _Dest
+        char _Buf[2 * _Max_int_dig];
+        char _Fmt[6];
+
+        return _Iput(_Dest, _Iosbase, _Fill, _Buf,
+            static_cast<size_t>(_CSTD sprintf_s(_Buf, sizeof(_Buf), _Ifmt(_Fmt, "ld", _Iosbase.flags()), _Val)));
+    }
+
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill,
+        unsigned long _Val) const { // put formatted unsigned long to _Dest
+        char _Buf[2 * _Max_int_dig];
+        char _Fmt[6];
+
+        return _Iput(_Dest, _Iosbase, _Fill, _Buf,
+            static_cast<size_t>(_CSTD sprintf_s(_Buf, sizeof(_Buf), _Ifmt(_Fmt, "lu", _Iosbase.flags()), _Val)));
+    }
+
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(
+        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, long long _Val) const { // put formatted long long to _Dest
+        char _Buf[2 * _Max_int_dig];
+        char _Fmt[8];
+
+        return _Iput(_Dest, _Iosbase, _Fill, _Buf,
+            static_cast<size_t>(_CSTD sprintf_s(_Buf, sizeof(_Buf), _Ifmt(_Fmt, "Ld", _Iosbase.flags()), _Val)));
+    }
+
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill,
+        unsigned long long _Val) const { // put formatted unsigned long long to _Dest
+        char _Buf[2 * _Max_int_dig];
+        char _Fmt[8];
+
+        return _Iput(_Dest, _Iosbase, _Fill, _Buf,
+            static_cast<size_t>(_CSTD sprintf_s(_Buf, sizeof(_Buf), _Ifmt(_Fmt, "Lu", _Iosbase.flags()), _Val)));
+    }
+
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(
+        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, double _Val) const { // put formatted double to _Dest
+        string _Buf;
+        char _Fmt[8];
+        const auto _Float_flags     = _Iosbase.flags() & ios_base::floatfield;
+        const bool _Is_fixed        = _Float_flags == ios_base::fixed;
+        const bool _Is_hex          = _Float_flags == (ios_base::fixed | ios_base::scientific);
+        const streamsize _Precision = _Is_hex ? -1 : _Iosbase.precision(); // precision setting
+        const int _Desired_precision =
+            _Float_put_desired_precision<double>(_Precision, _Float_flags); // desired precision
+        size_t _Bufsize = static_cast<size_t>(_Desired_precision);
+        if (_Is_fixed && 1e10 < _CSTD fabs(_Val)) { // f or F format
+            int _Ptwo;
+            (void) _CSTD frexp(_Val, &_Ptwo);
+            _Bufsize += _CSTD abs(_Ptwo) * 30103L / 100000L;
+        }
+
+        _Buf.resize(_Bufsize + 50); // add fudge factor
+        const bool _Is_finite      = (_STD isfinite)(_Val);
+        const auto _Adjusted_flags = // TRANSITION, DevCom-10519861
+            _Is_finite ? _Iosbase.flags() : _Iosbase.flags() & ~ios_base::showpoint;
+        const auto _Ngen = static_cast<size_t>(_CSTD sprintf_s(
+            &_Buf[0], _Buf.size(), _Ffmt(_Fmt, 0, _Adjusted_flags), static_cast<int>(_Precision), _Val));
+
+        return _Fput_v3(_Dest, _Iosbase, _Fill, _Buf.c_str(), _Ngen, _Is_finite);
+    }
+
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(
+        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, long double _Val) const { // put formatted long double to _Dest
+        string _Buf;
+        char _Fmt[8];
+        const auto _Float_flags     = _Iosbase.flags() & ios_base::floatfield;
+        const bool _Is_fixed        = _Float_flags == ios_base::fixed;
+        const bool _Is_hex          = _Float_flags == (ios_base::fixed | ios_base::scientific);
+        const streamsize _Precision = _Is_hex ? -1 : _Iosbase.precision(); // precision setting
+        const int _Desired_precision =
+            _Float_put_desired_precision<long double>(_Precision, _Float_flags); // desired precision
+        size_t _Bufsize = static_cast<size_t>(_Desired_precision);
+        if (_Is_fixed && 1e10 < _CSTD fabsl(_Val)) { // f or F format
+            int _Ptwo;
+            (void) _CSTD frexpl(_Val, &_Ptwo);
+            _Bufsize += _CSTD abs(_Ptwo) * 30103L / 100000L;
+        }
+
+        _Buf.resize(_Bufsize + 50); // add fudge factor
+        const bool _Is_finite      = (_STD isfinite)(_Val);
+        const auto _Adjusted_flags = // TRANSITION, DevCom-10519861
+            _Is_finite ? _Iosbase.flags() : _Iosbase.flags() & ~ios_base::showpoint;
+        const auto _Ngen = static_cast<size_t>(_CSTD sprintf_s(
+            &_Buf[0], _Buf.size(), _Ffmt(_Fmt, 'L', _Adjusted_flags), static_cast<int>(_Precision), _Val));
+
+        return _Fput_v3(_Dest, _Iosbase, _Fill, _Buf.c_str(), _Ngen, _Is_finite);
+    }
+#pragma warning(pop)
+
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(
+        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const void* _Val) const { // put formatted void pointer to _Dest
+        char _Buf[2 * _Max_int_dig];
+
+        return _Iput(
+            _Dest, _Iosbase, _Fill, _Buf, static_cast<size_t>(_CSTD sprintf_s(_Buf, sizeof(_Buf), "%p", _Val)));
+    }
+
+private:
+    char* __CLRCALL_OR_CDECL _Ffmt(
+        char* _Fmt, char _Spec, ios_base::fmtflags _Flags) const { // generate sprintf format for floating-point
+        char* _Ptr = _Fmt;
+        *_Ptr++    = '%';
+
+        if (_Flags & ios_base::showpos) {
+            *_Ptr++ = '+';
+        }
+
+        if (_Flags & ios_base::showpoint) {
+            *_Ptr++ = '#';
+        }
+
+        *_Ptr++ = '.';
+        *_Ptr++ = '*'; // for precision argument
+        if (_Spec != '\0') {
+            *_Ptr++ = _Spec; // 'L' qualifier for long double only
+        }
+
+        char _Ch; // specifier
+        ios_base::fmtflags _Ffl = _Flags & ios_base::floatfield;
+        if (_Flags & ios_base::uppercase) {
+            if (_Ffl == ios_base::fixed) {
+                _Ch = 'f';
+            } else if (_Ffl == (ios_base::scientific | ios_base::fixed)) {
+                _Ch = 'A';
+            } else if (_Ffl == ios_base::scientific) {
+                _Ch = 'E';
+            } else {
+                _Ch = 'G';
+            }
+        } else {
+            if (_Ffl == ios_base::fixed) {
+                _Ch = 'f';
+            } else if (_Ffl == (ios_base::scientific | ios_base::fixed)) {
+                _Ch = 'a';
+            } else if (_Ffl == ios_base::scientific) {
+                _Ch = 'e';
+            } else {
+                _Ch = 'g';
+            }
+        }
+        *_Ptr++ = _Ch;
+
+        *_Ptr = '\0';
+        return _Fmt;
+    }
+
+    _OutIt __CLRCALL_OR_CDECL _Fput(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const char* _Buf,
+        size_t _Count) const { // TRANSITION, ABI: preserved for binary compatibility
+        return _Fput_v3(_Dest, _Iosbase, _Fill, _Buf, _Count, true);
+    }
+
+    template <int = 0> // TRANSITION, ABI
+    _OutIt _Fput_v3(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const char* _Buf, size_t _Count,
+        bool _Is_finite_val) const { // put formatted floating-point to _Dest
+        auto _Prefix = static_cast<size_t>(0 < _Count && (*_Buf == '+' || *_Buf == '-'));
+        const char* _Exps;
+        if ((_Iosbase.flags() & ios_base::floatfield) != (ios_base::scientific | ios_base::fixed)) {
+            _Exps = "eE";
+        } else { // correct for hexadecimal floating-point
+            _Exps = "pP";
+            if (_Prefix + 2 <= _Count && _Buf[_Prefix] == '0'
+                && (_Buf[_Prefix + 1] == 'x' || _Buf[_Prefix + 1] == 'X')) {
+                _Prefix += 2;
+            }
+        }
+        const size_t _Eoff = _CSTD strcspn(&_Buf[0], _Exps); // find exponent
+        char _Dp[2]        = {"."};
+        _Dp[0]             = _CSTD localeconv()->decimal_point[0];
+        const size_t _Poff = _CSTD strcspn(&_Buf[0], &_Dp[0]); // find decimal point
+
+        const ctype<_Elem>& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Iosbase.getloc());
+        basic_string<_Elem> _Groupstring(_Count, _Elem(0)); // reserve space
+        _Ctype_fac.widen(_Buf, _Buf + _Count, &_Groupstring[0]);
+
+        const auto& _Punct_fac  = _STD use_facet<numpunct<_Elem>>(_Iosbase.getloc());
+        const string _Grouping  = _Punct_fac.grouping();
+        const _Elem _Kseparator = _Punct_fac.thousands_sep();
+
+        if (_Poff != _Count) {
+            _Groupstring[_Poff] = _Punct_fac.decimal_point();
+        }
+
+        if (_Is_finite_val) {
+            size_t _Off     = _Poff == _Count ? _Eoff : _Poff;
+            const char* _Pg = &_Grouping[0];
+            while (*_Pg != CHAR_MAX && '\0' < *_Pg && static_cast<size_t>(*_Pg) < _Off - _Prefix) {
+                // add thousands separator
+                _Groupstring.insert(_Off -= *_Pg, 1, _Kseparator);
+                if ('\0' < _Pg[1]) {
+                    ++_Pg; // not last group, advance
+                }
+            }
+        }
+
+        _Count = _Groupstring.size();
+
+        size_t _Fillcount;
+        if (_Iosbase.width() <= 0 || static_cast<size_t>(_Iosbase.width()) <= _Count) {
+            _Fillcount = 0;
+        } else {
+            _Fillcount = static_cast<size_t>(_Iosbase.width()) - _Count;
+        }
+
+        ios_base::fmtflags _Adjustfield = _Iosbase.flags() & ios_base::adjustfield;
+        if (_Adjustfield != ios_base::left && _Adjustfield != ios_base::internal) { // put leading fill
+            _Dest      = _Rep(_Dest, _Fill, _Fillcount);
+            _Fillcount = 0;
+            _Dest      = _Put(_Dest, &_Groupstring[0], _Prefix);
+        } else if (_Adjustfield == ios_base::internal) { // put internal fill
+            _Dest      = _Put(_Dest, &_Groupstring[0], _Prefix);
+            _Dest      = _Rep(_Dest, _Fill, _Fillcount);
+            _Fillcount = 0;
+        } else {
+            _Dest = _Put(_Dest, &_Groupstring[0], _Prefix);
+        }
+
+        _Dest = _Put(_Dest, &_Groupstring[_Prefix], _Count - _Prefix);
+        _Iosbase.width(0);
+        return _Rep(_Dest, _Fill, _Fillcount); // put trailing fill
+    }
+
+    char* __CLRCALL_OR_CDECL _Ifmt(
+        char* _Fmt, const char* _Spec, ios_base::fmtflags _Flags) const { // generate sprintf format for integer
+        char* _Ptr = _Fmt;
+        *_Ptr++    = '%';
+
+        if (_Flags & ios_base::showpos) {
+            *_Ptr++ = '+';
+        }
+
+        if (_Flags & ios_base::showbase) {
+            *_Ptr++ = '#';
+        }
+
+        if (_Spec[0] != 'L') {
+            *_Ptr++ = _Spec[0]; // qualifier
+        } else { // change L to I64
+            *_Ptr++ = 'I';
+            *_Ptr++ = '6';
+            *_Ptr++ = '4';
+        }
+
+        ios_base::fmtflags _Basefield = _Flags & ios_base::basefield;
+        *_Ptr++                       = _Basefield == ios_base::oct  ? 'o'
+                                      : _Basefield != ios_base::hex  ? _Spec[1] // 'd' or 'u'
+                                      : _Flags & ios_base::uppercase ? 'X'
+                                                                     : 'x';
+        *_Ptr                         = '\0';
+        return _Fmt;
+    }
+
+    _OutIt __CLRCALL_OR_CDECL _Iput(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, char* _Buf,
+        size_t _Count) const { // put formatted integer to _Dest
+        auto _Prefix = static_cast<size_t>(0 < _Count && (*_Buf == '+' || *_Buf == '-'));
+        if ((_Iosbase.flags() & ios_base::basefield) == ios_base::hex && _Prefix + 2 <= _Count && _Buf[_Prefix] == '0'
+            && (_Buf[_Prefix + 1] == 'x' || _Buf[_Prefix + 1] == 'X')) {
+            _Prefix += 2;
+        }
+
+        const ctype<_Elem>& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Iosbase.getloc());
+        basic_string<_Elem> _Groupstring(_Count, _Elem(0)); // reserve space
+        _Ctype_fac.widen(_Buf, _Buf + _Count, &_Groupstring[0]);
+
+        const auto& _Punct_fac = _STD use_facet<numpunct<_Elem>>(_Iosbase.getloc());
+        const string _Grouping = _Punct_fac.grouping();
+        const char* _Pg        = &_Grouping[0];
+        if (*_Pg != CHAR_MAX && '\0' < *_Pg) { // grouping specified, add thousands separators
+            const _Elem _Kseparator = _Punct_fac.thousands_sep();
+            while (*_Pg != CHAR_MAX && '\0' < *_Pg && static_cast<size_t>(*_Pg) < _Count - _Prefix) {
+                // insert thousands separator
+                _Count -= *_Pg;
+                _Groupstring.insert(_Count, 1, _Kseparator);
+                if ('\0' < _Pg[1]) {
+                    ++_Pg; // not last group, advance
+                }
+            }
+        }
+
+        _Count = _Groupstring.size();
+
+        size_t _Fillcount;
+        if (_Iosbase.width() <= 0 || static_cast<size_t>(_Iosbase.width()) <= _Count) {
+            _Fillcount = 0;
+        } else {
+            _Fillcount = static_cast<size_t>(_Iosbase.width()) - _Count;
+        }
+
+        ios_base::fmtflags _Adjustfield = _Iosbase.flags() & ios_base::adjustfield;
+        if (_Adjustfield != ios_base::left && _Adjustfield != ios_base::internal) { // put leading fill
+            _Dest      = _Rep(_Dest, _Fill, _Fillcount);
+            _Fillcount = 0;
+            _Dest      = _Put(_Dest, &_Groupstring[0], _Prefix);
+        } else if (_Adjustfield == ios_base::internal) { // put internal fill
+            _Dest      = _Put(_Dest, &_Groupstring[0], _Prefix);
+            _Dest      = _Rep(_Dest, _Fill, _Fillcount);
+            _Fillcount = 0;
+        } else {
+            _Dest = _Put(_Dest, &_Groupstring[0], _Prefix);
+        }
+
+        _Dest = _Put(_Dest, &_Groupstring[_Prefix], _Count - _Prefix);
+        _Iosbase.width(0);
+        return _Rep(_Dest, _Fill, _Fillcount); // put trailing fill
+    }
+
+    _OutIt __CLRCALL_OR_CDECL _Put(
+        _OutIt _Dest, const _Elem* _Ptr, size_t _Count) const { // put [_Ptr, _Ptr + _Count) to _Dest
+        for (; 0 < _Count; --_Count, (void) ++_Dest, ++_Ptr) {
+            *_Dest = *_Ptr;
+        }
+
+        return _Dest;
+    }
+
+    _OutIt __CLRCALL_OR_CDECL _Rep(_OutIt _Dest, _Elem _Ch, size_t _Count) const { // put _Count * _Ch to _Dest
+        for (; 0 < _Count; --_Count, (void) ++_Dest) {
+            *_Dest = _Ch;
+        }
+
+        return _Dest;
+    }
+};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _Elem, class _OutIt>
+__PURE_APPDOMAIN_GLOBAL locale::id num_put<_Elem, _OutIt>::id;
+
+#if defined(_DLL_CPPLIB)
+
+#if !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+template __PURE_APPDOMAIN_GLOBAL locale::id numpunct<char>::id;
+template class _CRTIMP2_PURE_IMPORT num_get<char, istreambuf_iterator<char, char_traits<char>>>;
+template class _CRTIMP2_PURE_IMPORT num_put<char, ostreambuf_iterator<char, char_traits<char>>>;
+
+template __PURE_APPDOMAIN_GLOBAL locale::id numpunct<wchar_t>::id;
+template class _CRTIMP2_PURE_IMPORT num_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t>>>;
+template class _CRTIMP2_PURE_IMPORT num_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t>>>;
+#endif // !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+
+#ifdef __FORCE_INSTANCE
+template __PURE_APPDOMAIN_GLOBAL locale::id numpunct<unsigned short>::id;
+template class _CRTIMP2_PURE_IMPORT
+    num_get<unsigned short, istreambuf_iterator<unsigned short, char_traits<unsigned short>>>;
+template class _CRTIMP2_PURE_IMPORT
+    num_put<unsigned short, ostreambuf_iterator<unsigned short, char_traits<unsigned short>>>;
+#endif // defined(__FORCE_INSTANCE)
+#endif // defined(_DLL_CPPLIB)
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XLOCNUM_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xloctime b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xloctime
new file mode 100644
index 0000000000000000000000000000000000000000..1952685dddc257ec4b956a112a7fb755cf8fa03c
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xloctime
@@ -0,0 +1,1260 @@
+// xloctime internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XLOCTIME_
+#define _XLOCTIME_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <ctime>
+#include <iterator>
+#include <xlocnum>
+
+#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 _InIt, class _Elem>
+ios_base::iostate _Getint_v2(_InIt& _First, _InIt& _Last, int _Lo, int _Hi, int& _Val, int& _Digits_read,
+    const ctype<_Elem>& _Ctype_fac) { // get integer in range [_Lo, _Hi] from [_First, _Last)
+    _STL_INTERNAL_CHECK(0 <= _Hi && _Hi <= 9999);
+    const int _Hi_digits = (_Hi <= 9 ? 1 : _Hi <= 99 ? 2 : _Hi <= 999 ? 3 : 4);
+    char _Ac[_Max_int_dig];
+    char* _Ep;
+    char* _Ptr = _Ac;
+    char _Ch;
+
+    _Digits_read = 0;
+
+    while (_First != _Last && _Digits_read < _Hi_digits && _Ctype_fac.is(ctype_base::space, *_First)) {
+        ++_First;
+        ++_Digits_read;
+    }
+
+    if (_First != _Last && _Digits_read < _Hi_digits) {
+        if ((_Ch = _Ctype_fac.narrow(*_First)) == '+') { // copy plus sign
+            *_Ptr++ = '+';
+            ++_First;
+        } else if (_Ch == '-') { // copy minus sign
+            *_Ptr++ = '-';
+            ++_First;
+        }
+    }
+
+    for (; _First != _Last && _Digits_read < _Hi_digits && _Ctype_fac.narrow(*_First) == '0'; ++_First) {
+        ++_Digits_read; // strip leading zeros
+    }
+
+    if (_Digits_read > 0) {
+        *_Ptr++ = '0'; // replace one or more with single zero
+    }
+
+    for (char* const _Pe = &_Ac[_Max_int_dig - 1];
+         _First != _Last && '0' <= (_Ch = _Ctype_fac.narrow(*_First)) && _Ch <= '9' && _Digits_read < _Hi_digits;
+         ++_Digits_read, (void) ++_First) { // copy digits
+        *_Ptr = _Ch;
+        if (_Ptr < _Pe) {
+            ++_Ptr; // drop trailing digits if already too large
+        }
+    }
+
+    if (_Digits_read == 0) {
+        _Ptr = _Ac;
+    }
+
+    *_Ptr                    = '\0';
+    int _Errno               = 0;
+    const long _Ans          = _CSTD _Stolx(_Ac, &_Ep, 10, &_Errno);
+    ios_base::iostate _State = ios_base::goodbit;
+
+    if (_First == _Last) {
+        _State |= ios_base::eofbit;
+    }
+
+    if (_Ep == _Ac || _Errno != 0 || _Ans < _Lo || _Hi < _Ans) {
+        _State |= ios_base::failbit; // bad conversion
+    } else {
+        _Val = _Ans; // store valid result
+    }
+
+    return _State;
+}
+
+_EXPORT_STD extern "C++" struct _CRTIMP2_PURE_IMPORT time_base // base class for time_get
+    : locale::facet // TRANSITION, ABI, shouldn't be derived from locale::facet
+{
+    enum dateorder { // constants for different orders of date components
+        no_order,
+        dmy,
+        mdy,
+        ymd,
+        ydm
+    };
+
+    __CLR_OR_THIS_CALL time_base(size_t _Refs = 0) noexcept // strengthened
+        : locale::facet(_Refs) {}
+
+    __CLR_OR_THIS_CALL ~time_base() noexcept override {}
+};
+
+_EXPORT_STD extern "C++" template <class _Elem, class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem>>>
+class time_get : public time_base { // facet for converting text to encoded times
+private:
+    friend _Tidy_guard<time_get>;
+
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    using char_type = _Elem;
+    using iter_type = _InIt;
+    using _Ctype    = ctype<_Elem>;
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id; // unique facet id
+
+    dateorder __CLR_OR_THIS_CALL date_order() const {
+        return do_date_order();
+    }
+
+    _InIt __CLR_OR_THIS_CALL get_time(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        tm* _Pt) const { // get time of day from [_First, _Last) into _Pt
+        return do_get_time(_First, _Last, _Iosbase, _State, _Pt);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get_date(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        tm* _Pt) const { // get date from [_First, _Last) into _Pt
+        return do_get_date(_First, _Last, _Iosbase, _State, _Pt);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get_weekday(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        tm* _Pt) const { // get weekday from [_First, _Last) into _Pt
+        return do_get_weekday(_First, _Last, _Iosbase, _State, _Pt);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get_monthname(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        tm* _Pt) const { // get month from [_First, _Last) into _Pt
+        return do_get_monthname(_First, _Last, _Iosbase, _State, _Pt);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get_year(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        tm* _Pt) const { // get year from [_First, _Last) into _Pt
+        return do_get_year(_First, _Last, _Iosbase, _State, _Pt);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State, tm* _Pt,
+        char _Specifier, char _Modifier = '\0') const { // get formatted time for _Specifier/_Modifier
+        return do_get(_First, _Last, _Iosbase, _State, _Pt, _Specifier, _Modifier);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State, tm* _Pt,
+        const _Elem* _Fmtfirst, const _Elem* _Fmtlast) const { // get formatted time for format string
+        _Adl_verify_range(_Fmtfirst, _Fmtlast);
+        const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Iosbase.getloc());
+
+        _State = ios_base::goodbit;
+
+        for (; _Fmtfirst != _Fmtlast; ++_Fmtfirst) {
+            if (_State != ios_base::goodbit) {
+                // N4950 [locale.time.get.members]/8.2
+                // _State is fail, eof, or bad. Do not proceed to the next fields. Return with current _State.
+                break;
+            } else if (_First == _Last) {
+                // N4950 [locale.time.get.members]/8.3
+                _State = ios_base::eofbit | ios_base::failbit;
+                break;
+            } else if (_Ctype_fac.narrow(*_Fmtfirst) != '%') { // match literal element
+                if (_Ctype_fac.is(_Ctype::space, *_Fmtfirst)) {
+                    while (_First != _Last && _Ctype_fac.is(_Ctype::space, *_First)) {
+                        ++_First;
+                    }
+                } else if (_Ctype_fac.tolower(*_First) != _Ctype_fac.tolower(*_Fmtfirst)) { // bad literal match
+                    _State |= ios_base::failbit;
+                    break;
+                } else {
+                    ++_First;
+                }
+            } else if (++_Fmtfirst == _Fmtlast) {
+                // N4950 [locale.time.get.members]/8.4: "If the number of elements in the range [fmt, fmtend) is not
+                // sufficient to unambiguously determine whether the conversion specification is complete and valid,
+                // the function evaluates err = ios_base::failbit."
+                _State = ios_base::failbit;
+                break;
+            } else { // get specifier after %
+                char _Specifier = _Ctype_fac.narrow(*_Fmtfirst);
+                char _Modifier  = '\0';
+
+                if (_Specifier == 'E' || _Specifier == 'O' || _Specifier == 'Q' || _Specifier == '#') {
+                    if (++_Fmtfirst == _Fmtlast) { // no specifier
+                        _State = ios_base::failbit;
+                        break;
+                    } else { // save both qualifier and specifier
+                        _Modifier  = _Specifier;
+                        _Specifier = _Ctype_fac.narrow(*_Fmtfirst);
+                    }
+                }
+
+                _First = do_get(_First, _Last, _Iosbase, _State, _Pt, _Specifier, _Modifier); // convert a single field
+            }
+        }
+
+        return _First;
+    }
+
+    explicit __CLR_OR_THIS_CALL time_get(size_t _Refs = 0) : time_base(_Refs) { // construct from current locale
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    __CLR_OR_THIS_CALL time_get(const _Locinfo& _Lobj, size_t _Refs = 0) : time_base(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new time_get<_Elem, _InIt>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_TIME;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~time_get() noexcept override {
+        _Tidy();
+    }
+
+    __CLR_OR_THIS_CALL time_get(const char* _Locname, size_t _Refs = 0) : time_base(_Refs) {
+        _BEGIN_LOCINFO(_Lobj(_Locname))
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    template <class _Elem2>
+    void __CLR_OR_THIS_CALL _Getvals(_Elem2, const _Locinfo& _Lobj) { // get values
+        _Cvt = _Lobj._Getcvt();
+
+        if (is_same_v<_Elem2, wchar_t>) {
+            _Days = reinterpret_cast<const _Elem*>(_Maklocwcs(reinterpret_cast<const wchar_t*>(_Lobj._W_Getdays())));
+            _Months =
+                reinterpret_cast<const _Elem*>(_Maklocwcs(reinterpret_cast<const wchar_t*>(_Lobj._W_Getmonths())));
+            _Ampm = reinterpret_cast<const _Elem*>(_Maklocwcs(L":AM:am:PM:pm"));
+        } else {
+            _Days   = _Maklocstr(_Lobj._Getdays(), static_cast<_Elem*>(nullptr), _Cvt);
+            _Months = _Maklocstr(_Lobj._Getmonths(), static_cast<_Elem*>(nullptr), _Cvt);
+            _Ampm   = _Maklocstr(":AM:am:PM:pm", static_cast<_Elem*>(nullptr), _Cvt);
+        }
+    }
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo& _Lobj) { // initialize from _Lobj
+        _Days   = nullptr;
+        _Months = nullptr;
+        _Ampm   = nullptr;
+
+        _Tidy_guard<time_get> _Guard{this};
+        _Getvals(_Elem{}, _Lobj);
+        _Dateorder     = static_cast<dateorder>(_Lobj._Getdateorder());
+        _Guard._Target = nullptr;
+    }
+
+    virtual dateorder __CLR_OR_THIS_CALL do_date_order() const {
+        return _Dateorder;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get_time(_InIt _First, _InIt _Last, ios_base& _Iosbase,
+        ios_base::iostate& _State, tm* _Pt) const { // get time of day from [_First, _Last) into _Pt
+        const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Iosbase.getloc());
+
+        _State |= _Getint(_First, _Last, 0, 23, _Pt->tm_hour, _Ctype_fac);
+
+        if (_State != ios_base::goodbit || _Ctype_fac.narrow(*_First) != ':') {
+            _State |= ios_base::failbit; // hour field is bad
+        } else {
+            _State |= _Getint(++_First, _Last, 0, 59, _Pt->tm_min, _Ctype_fac);
+        }
+
+        if (_State != ios_base::goodbit || _Ctype_fac.narrow(*_First) != ':') {
+            _State |= ios_base::failbit; // min field is bad
+        } else {
+            _State |= _Getint(++_First, _Last, 0, 60, _Pt->tm_sec, _Ctype_fac);
+        }
+
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get_date(_InIt _First, _InIt _Last, ios_base& _Iosbase,
+        ios_base::iostate& _State, tm* _Pt) const { // get date from [_First, _Last) into _Pt
+        const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Iosbase.getloc());
+
+        dateorder _Dorder = date_order();
+        if (_Dorder == no_order) {
+            _Dorder = mdy;
+        }
+
+        if (_First != _Last) {
+            if (!_Ctype_fac.is(_Ctype::digit, *_First)) { // begins with month name, assume mdy
+                _First  = get_monthname(_First, _Last, _Iosbase, _State, _Pt);
+                _Dorder = mdy;
+            } else if (_Dorder == mdy) { // get month number
+                _State |= _Getint(_First, _Last, 1, 12, _Pt->tm_mon, _Ctype_fac);
+                --_Pt->tm_mon;
+            } else if (_Dorder == dmy) {
+                _State |= _Getint(_First, _Last, 1, 31, _Pt->tm_mday, _Ctype_fac);
+            } else { // ymd or ydm
+                _First = get_year(_First, _Last, _Iosbase, _State, _Pt);
+            }
+        }
+
+        while (_First != _Last && _Ctype_fac.is(_Ctype::space, *_First)) {
+            ++_First; // skip spaces
+        }
+
+        if (_First != _Last) { // skip [:,/]
+            char _Ch = _Ctype_fac.narrow(*_First);
+            if (_Ch == ':' || _Ch == ',' || _Ch == '/') {
+                ++_First;
+            }
+        }
+
+        while (_First != _Last && _Ctype_fac.is(_Ctype::space, *_First)) {
+            ++_First; // skip spaces
+        }
+
+        if (_First != _Last) {
+            if (!_Ctype_fac.is(_Ctype::digit, *_First)) {
+                if (_Dorder == mdy) {
+                    _State |= ios_base::failbit; // error, month already seen
+                } else { // month name is second, like it or not
+                    _First = get_monthname(_First, _Last, _Iosbase, _State, _Pt);
+                    if (_Dorder == ydm) {
+                        _Dorder = ymd;
+                    }
+                }
+            } else if (_Dorder == dmy || _Dorder == ymd) { // get month number
+                _State |= _Getint(_First, _Last, 1, 12, _Pt->tm_mon, _Ctype_fac);
+                --_Pt->tm_mon;
+            } else {
+                _State |= _Getint(_First, _Last, 1, 31, _Pt->tm_mday, _Ctype_fac);
+            }
+        }
+
+        while (_First != _Last && _Ctype_fac.is(_Ctype::space, *_First)) {
+            ++_First; // skip spaces
+        }
+
+        if (_First != _Last) { // skip [:,/]
+            char _Ch = _Ctype_fac.narrow(*_First);
+            if (_Ch == ':' || _Ch == ',' || _Ch == '/') {
+                ++_First;
+            }
+        }
+
+        while (_First != _Last && _Ctype_fac.is(_Ctype::space, *_First)) {
+            ++_First; // skip spaces
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::failbit; // error, missing component(s)
+        } else if (!_Ctype_fac.is(_Ctype::digit, *_First)) {
+            if (_Dorder != ydm) {
+                _State |= ios_base::failbit; // error, month out of place
+            } else {
+                _First = get_monthname(_First, _Last, _Iosbase, _State, _Pt);
+            }
+        } else if (_Dorder == ydm) { // get month number
+            _State |= _Getint(_First, _Last, 1, 12, _Pt->tm_mon, _Ctype_fac);
+            --_Pt->tm_mon;
+        } else if (_Dorder == ymd) {
+            _State |= _Getint(_First, _Last, 1, 31, _Pt->tm_mday, _Ctype_fac);
+        } else { // mdy or dmy
+            _First = get_year(_First, _Last, _Iosbase, _State, _Pt);
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get_weekday(_InIt _First, _InIt _Last, ios_base&, ios_base::iostate& _State,
+        tm* _Pt) const { // get weekday from [_First, _Last) into _Pt
+        int _Num = _Getloctxt(_First, _Last, 0, _Days, _Case_sensitive::_Nope);
+        if (_Num < 0) {
+            _State |= ios_base::failbit;
+        } else {
+            _Pt->tm_wday = _Num >> 1; // set wday
+        }
+
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get_monthname(_InIt _First, _InIt _Last, ios_base&, ios_base::iostate& _State,
+        tm* _Pt) const { // get month from [_First, _Last) into _Pt
+        int _Num = _Getloctxt(_First, _Last, 0, _Months, _Case_sensitive::_Nope);
+
+        if (_Num < 0) {
+            _State |= ios_base::failbit;
+        } else {
+            _Pt->tm_mon = _Num >> 1; // set mon
+        }
+
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get_year(_InIt _First, _InIt _Last, ios_base& _Iosbase,
+        ios_base::iostate& _State, tm* _Pt) const { // get year from [_First, _Last) into _Pt
+        const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Iosbase.getloc());
+
+        int _Ans = 0;
+        int _Digits_read;
+        ios_base::iostate _Res = _Getint_v2(_First, _Last, 0, 9999, _Ans, _Digits_read, _Ctype_fac);
+
+        _State |= _Res; // pass on eofbit and failbit
+        if (!(_Res & ios_base::failbit)) {
+            if (_Digits_read <= 2) {
+                if (_Ans < 69) {
+                    _Pt->tm_year = _Ans + 100; // [00, 68] parsed as [2000, 2068]
+                } else if (_Ans < 100) {
+                    _Pt->tm_year = _Ans; // [69, 99] parsed as [1969, 1999]
+                }
+            } else {
+                _Pt->tm_year = _Ans - 1900; // parsed literally
+            }
+        }
+
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        tm* _Pt, char _Specifier, char = 0) const { // get formatted time for _Specifier (_Modifier ignored)
+        const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Iosbase.getloc());
+        int _Ans                 = 0;
+
+        _State = ios_base::goodbit;
+
+        switch (_Specifier) { // process format specifier
+        case 'a':
+        case 'A':
+            _First = get_weekday(_First, _Last, _Iosbase, _State, _Pt);
+            break;
+
+        case 'b':
+        case 'B':
+        case 'h':
+            _First = get_monthname(_First, _Last, _Iosbase, _State, _Pt);
+            break;
+
+        case 'c':
+            _First = _Getfmt(_First, _Last, _Iosbase, _State, _Pt, "%b %d %H : %M : %S %Y");
+            break;
+
+        case 'C':
+            _State |= _Getint(_First, _Last, 0, 99, _Ans, _Ctype_fac);
+            if (!(_State & ios_base::failbit)) {
+                _Pt->tm_year = _Ans * 100 - 1900; // convert to century
+            }
+
+            break;
+
+        case 'd':
+        case 'e':
+            _State |= _Getint(_First, _Last, 1, 31, _Pt->tm_mday, _Ctype_fac);
+            break;
+
+        case 'D':
+            _First = _Getfmt(_First, _Last, _Iosbase, _State, _Pt, "%m / %d / %y");
+            break;
+
+        case 'H':
+            _State |= _Getint(_First, _Last, 0, 23, _Pt->tm_hour, _Ctype_fac);
+            break;
+
+        case 'I':
+            _State |= _Getint(_First, _Last, 1, 12, _Ans, _Ctype_fac);
+            if (!(_State & ios_base::failbit)) {
+                _Pt->tm_hour = _Ans == 12 ? 0 : _Ans;
+            }
+
+            break;
+
+        case 'j':
+            _State |= _Getint(_First, _Last, 1, 366, _Pt->tm_yday, _Ctype_fac);
+            break;
+
+        case 'm':
+            _State |= _Getint(_First, _Last, 1, 12, _Ans, _Ctype_fac);
+            if (!(_State & ios_base::failbit)) {
+                _Pt->tm_mon = _Ans - 1;
+            }
+
+            break;
+
+        case 'M':
+            _State |= _Getint(_First, _Last, 0, 59, _Pt->tm_min, _Ctype_fac);
+            break;
+
+        case 'n':
+        case 't':
+            _First = _Getfmt(_First, _Last, _Iosbase, _State, _Pt, " ");
+            break;
+
+        case 'p':
+            _Ans = _Getloctxt(_First, _Last, 0, ":AM:am:PM:pm", _Case_sensitive::_Nope);
+            if (_Ans < 0) {
+                _State |= ios_base::failbit;
+            } else if (1 < _Ans) {
+                _Pt->tm_hour += 12;
+            }
+
+            break;
+
+        case 'r':
+            _First = _Getfmt(_First, _Last, _Iosbase, _State, _Pt, "%I : %M : %S %p");
+            break;
+
+        case 'R':
+            _First = _Getfmt(_First, _Last, _Iosbase, _State, _Pt, "%H : %M");
+            break;
+
+        case 'S':
+            _State |= _Getint(_First, _Last, 0, 60, _Pt->tm_sec, _Ctype_fac);
+            break;
+
+        case 'T':
+        case 'X':
+            _First = _Getfmt(_First, _Last, _Iosbase, _State, _Pt, "%H : %M : %S");
+            break;
+
+        case 'U':
+            _State |= _Getint(_First, _Last, 0, 53, _Pt->tm_yday, _Ctype_fac);
+            break;
+
+        case 'w':
+            _State |= _Getint(_First, _Last, 0, 6, _Pt->tm_wday, _Ctype_fac);
+            break;
+
+        case 'W':
+            _State |= _Getint(_First, _Last, 0, 53, _Pt->tm_yday, _Ctype_fac);
+            break;
+
+        case 'x':
+            _First = _Getfmt(_First, _Last, _Iosbase, _State, _Pt, "%d / %m / %y");
+            break;
+
+        case 'y':
+            _State |= _Getint(_First, _Last, 0, 99, _Ans, _Ctype_fac);
+            if (!(_State & ios_base::failbit)) {
+                _Pt->tm_year = _Ans < 69 ? _Ans + 100 : _Ans;
+            }
+
+            break;
+
+        case 'Y':
+            _State |= _Getint(_First, _Last, 0, 9999, _Ans, _Ctype_fac);
+            if (!(_State & ios_base::failbit)) {
+                _Pt->tm_year = _Ans - 1900;
+            }
+            break;
+
+        default:
+            _State |= ios_base::failbit; // unknown specifier
+            break;
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        return _First;
+    }
+
+    _InIt __CLR_OR_THIS_CALL _Getfmt(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State, tm* _Pt,
+        const char* _Fmtfirst) const { // get formatted time for format NTBS
+        const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Iosbase.getloc());
+
+        for (; *_Fmtfirst != '\0'; ++_Fmtfirst) {
+            if (_First == _Last) {
+                _State |= ios_base::failbit;
+                break;
+            } else if (*_Fmtfirst == '%') {
+                _First = do_get(_First, _Last, _Iosbase, _State, _Pt,
+                    *++_Fmtfirst); // convert a single field
+            } else if (*_Fmtfirst == ' ') {
+                while (_First != _Last && _Ctype_fac.is(_Ctype::space, *_First)) {
+                    ++_First;
+                }
+            } else if (_Ctype_fac.narrow(*_First) != *_Fmtfirst) { // bad literal match
+                _State |= ios_base::failbit;
+                break;
+            } else {
+                ++_First;
+            }
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        return _First;
+    }
+
+private:
+    ios_base::iostate __CLRCALL_OR_CDECL _Getint(_InIt& _First, _InIt& _Last, int _Lo, int _Hi, int& _Val,
+        const _Ctype& _Ctype_fac) const { // get integer in range [_Lo, _Hi] from [_First, _Last)
+        // TRANSITION, ABI
+        int _Digits_read;
+        return _Getint_v2(_First, _Last, _Lo, _Hi, _Val, _Digits_read, _Ctype_fac);
+    }
+
+    void __CLR_OR_THIS_CALL _Tidy() noexcept { // free all storage
+        _CSTD free(const_cast<_Elem*>(_Days));
+        _CSTD free(const_cast<_Elem*>(_Months));
+        _CSTD free(const_cast<_Elem*>(_Ampm));
+    }
+
+    const _Elem* _Days; // ":Sun:Sunday:Mon:Monday..." for example
+    const _Elem* _Months; // "Jan:January:Feb:February..." for example
+    const _Elem* _Ampm; // ":AM:am:PM:pm"
+    dateorder _Dateorder;
+    _Locinfo::_Cvtvec _Cvt; // conversion information
+};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _Elem, class _InIt>
+__PURE_APPDOMAIN_GLOBAL locale::id time_get<_Elem, _InIt>::id;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+
+_EXPORT_STD template <class _Elem, class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem>>>
+class time_get_byname : public time_get<_Elem, _InIt> { // time_get for named locale
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    explicit time_get_byname(const char* _Locname, size_t _Refs = 0)
+        : time_get<_Elem, _InIt>(_Locname, _Refs) {} // construct for named locale
+
+    explicit time_get_byname(const string& _Str, size_t _Refs = 0)
+        : time_get<_Elem, _InIt>(_Locinfo(_Str.c_str()), _Refs) {} // construct for named locale
+
+protected:
+    __CLR_OR_THIS_CALL ~time_get_byname() noexcept override {}
+};
+
+// C23 7.29.3.5 "The strftime function"/3
+_INLINE_VAR constexpr char _Valid_strftime_specifiers[] = {'a', 'A', 'b', 'B', 'c', 'C', 'd', 'D', 'e', 'F', 'g', 'G',
+    'h', 'H', 'I', 'j', 'm', 'M', 'n', 'p', 'r', 'R', 'S', 't', 'T', 'u', 'U', 'V', 'w', 'W', 'x', 'X', 'y', 'Y', 'z',
+    'Z'};
+
+_NODISCARD constexpr bool _Is_valid_strftime_specifier(const char _Specifier) {
+    for (const auto& _Valid_specifier : _Valid_strftime_specifiers) {
+        if (_Specifier == _Valid_specifier) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+_NODISCARD constexpr bool _Is_valid_strftime_tm_sec(const tm* const _Pt) noexcept {
+    // seconds after the minute - [0, 60] including leap second
+    return _Pt->tm_sec >= 0 && _Pt->tm_sec <= 60;
+}
+
+_NODISCARD constexpr bool _Is_valid_strftime_tm_min(const tm* const _Pt) noexcept {
+    // minutes after the hour - [0, 59]
+    return _Pt->tm_min >= 0 && _Pt->tm_min <= 59;
+}
+
+_NODISCARD constexpr bool _Is_valid_strftime_tm_hour(const tm* const _Pt) noexcept {
+    // hours since midnight - [0, 23]
+    return _Pt->tm_hour >= 0 && _Pt->tm_hour <= 23;
+}
+
+_NODISCARD constexpr bool _Is_valid_strftime_tm_mday(const tm* const _Pt) noexcept {
+    // day of the month - [1, 31]
+    return _Pt->tm_mday >= 1 && _Pt->tm_mday <= 31;
+}
+
+_NODISCARD constexpr bool _Is_valid_strftime_tm_mon(const tm* const _Pt) noexcept {
+    // months since January - [0, 11]
+    return _Pt->tm_mon >= 0 && _Pt->tm_mon <= 11;
+}
+
+_NODISCARD constexpr bool _Is_valid_strftime_tm_year(const tm* const _Pt) noexcept {
+    // years since 1900 - UCRT max range is up until 8099
+    return _Pt->tm_year >= -1900 && _Pt->tm_year <= 8099;
+}
+
+_NODISCARD constexpr bool _Is_valid_strftime_tm_wday(const tm* const _Pt) noexcept {
+    // days since Sunday - [0, 6]
+    return _Pt->tm_wday >= 0 && _Pt->tm_wday <= 6;
+}
+
+_NODISCARD constexpr bool _Is_valid_strftime_tm_yday(const tm* const _Pt) noexcept {
+    // days since January 1 - [0, 365]
+    return _Pt->tm_yday >= 0 && _Pt->tm_yday <= 365;
+}
+
+_NODISCARD constexpr bool _Is_valid_strftime_tm_data(const char _Specifier, const tm* const _Pt) noexcept {
+    if (!_Pt) {
+        return false;
+    }
+
+    switch (_Specifier) {
+    case 'S':
+        return _Is_valid_strftime_tm_sec(_Pt);
+    case 'M':
+        return _Is_valid_strftime_tm_min(_Pt);
+    case 'H':
+    case 'I':
+    case 'p':
+        return _Is_valid_strftime_tm_hour(_Pt);
+    case 'd':
+    case 'e':
+        return _Is_valid_strftime_tm_mday(_Pt);
+    case 'b':
+    case 'B':
+    case 'm':
+    case 'h':
+        return _Is_valid_strftime_tm_mon(_Pt);
+    case 'C':
+    case 'y':
+    case 'Y':
+        return _Is_valid_strftime_tm_year(_Pt);
+    case 'j':
+        return _Is_valid_strftime_tm_yday(_Pt);
+    case 'a':
+    case 'A':
+    case 'u':
+    case 'w':
+        return _Is_valid_strftime_tm_wday(_Pt);
+    case 'U': // C23 7.29.3.5 "The strftime function"/3 says that %U and %W depend on tm_year,
+    case 'W': // but the UCRT neither uses nor validates it.
+        return _Is_valid_strftime_tm_wday(_Pt) && _Is_valid_strftime_tm_yday(_Pt);
+    case 'R':
+        return _Is_valid_strftime_tm_hour(_Pt) && _Is_valid_strftime_tm_min(_Pt);
+    case 'D':
+    case 'x':
+    case 'F':
+        return _Is_valid_strftime_tm_year(_Pt) && _Is_valid_strftime_tm_mon(_Pt) && _Is_valid_strftime_tm_mday(_Pt);
+    case 'g':
+    case 'G':
+        return _Is_valid_strftime_tm_year(_Pt) && _Is_valid_strftime_tm_wday(_Pt) && _Is_valid_strftime_tm_yday(_Pt);
+    case 'r':
+    case 'X':
+    case 'T':
+        return _Is_valid_strftime_tm_hour(_Pt) && _Is_valid_strftime_tm_min(_Pt) && _Is_valid_strftime_tm_sec(_Pt);
+    case 'c':
+        return _Is_valid_strftime_tm_wday(_Pt) && _Is_valid_strftime_tm_mon(_Pt) && _Is_valid_strftime_tm_mday(_Pt)
+            && _Is_valid_strftime_tm_hour(_Pt) && _Is_valid_strftime_tm_min(_Pt) && _Is_valid_strftime_tm_sec(_Pt)
+            && _Is_valid_strftime_tm_year(_Pt);
+    case 'V': // C23 7.29.3.5 "The strftime function"/3 says that %V depends on tm_year, tm_wday, and tm_yday.
+              // The UCRT uses them without validating them.
+        return true;
+    case 'z': // C23 7.29.3.5 "The strftime function"/3 says that %z and %Z depend on tm_isdst.
+    case 'Z': // The UCRT treats it as a boolean value, so there's no need for validation.
+        return true;
+    case 'n': // newline
+    case 't': // tab
+        return true;
+    default:
+        // We should have handled %% and called _Is_valid_strftime_specifier() before calling this function.
+        _STL_INTERNAL_CHECK(false);
+        return false;
+    }
+}
+
+_EXPORT_STD extern "C++" template <class _Elem, class _OutIt = ostreambuf_iterator<_Elem, char_traits<_Elem>>>
+class time_put : public locale::facet { // facet for converting encoded times to text
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    using char_type = _Elem;
+    using iter_type = _OutIt;
+    using _Ctype    = ctype<_Elem>;
+
+    _OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const tm* _Pt, const _Elem* _Fmtfirst,
+        const _Elem* _Fmtlast) const { // put formatted time from _Pt to _Dest for [_Fmtfirst, _Fmtlast)
+        const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Iosbase.getloc());
+
+        for (; _Fmtfirst != _Fmtlast; ++_Fmtfirst) {
+            if (_Ctype_fac.narrow(*_Fmtfirst) != '%') {
+                *_Dest++ = *_Fmtfirst; // copy literal element
+            } else if (++_Fmtfirst == _Fmtlast) { // treat trailing % as %%
+                *_Dest++ = _Fmtfirst[-1];
+                break;
+            } else { // get specifier after %
+                char _Specifier = _Ctype_fac.narrow(*_Fmtfirst);
+                char _Modifier  = '\0';
+                _Elem _Percent  = _Fmtfirst[-1];
+
+                if (_Specifier == 'E' || _Specifier == 'O' || _Specifier == 'Q' || _Specifier == '#') {
+                    if (++_Fmtfirst == _Fmtlast) { // no specifier, copy %[E0Q#] as literal elements
+                        *_Dest++ = _Percent;
+                        *_Dest++ = _Specifier;
+                        break;
+                    }
+
+                    // save both qualifier and specifier
+                    _Modifier  = _Specifier;
+                    _Specifier = _Ctype_fac.narrow(*_Fmtfirst);
+                }
+
+                if (_Specifier == '%' && _Modifier == '\0') {
+                    // if the specifier is percent and no modifier is set, just append it
+                    *_Dest++ = _Percent;
+                } else if (!_Is_valid_strftime_specifier(_Specifier)) {
+                    // no valid specifier, directly copy as literal elements
+                    *_Dest++ = _Percent;
+                    if (_Modifier != '\0') {
+                        *_Dest++ = _Modifier;
+                    }
+                    *_Dest++ = _Specifier;
+                } else {
+                    if (_Is_valid_strftime_tm_data(_Specifier, _Pt)) {
+                        _Dest = do_put(_Dest, _Iosbase, _Fill, _Pt, _Specifier, _Modifier); // convert a single field
+                    } else {
+                        *_Dest++ = _Elem('?');
+                    }
+                }
+            }
+        }
+
+        return _Dest;
+    }
+
+    _OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const tm* _Pt, char _Specifier,
+        char _Modifier = '\0') const { // put formatted time from _Pt to _Dest for _Specifier/_Modifier
+        return do_put(_Dest, _Iosbase, _Fill, _Pt, _Specifier, _Modifier);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id; // unique facet id
+
+    explicit __CLR_OR_THIS_CALL time_put(size_t _Refs = 0) : locale::facet(_Refs) { // construct from current locale
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    __CLR_OR_THIS_CALL time_put(const _Locinfo& _Lobj, size_t _Refs = 0) : locale::facet(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new time_put<_Elem, _OutIt>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_TIME;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~time_put() noexcept override {}
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo& _Lobj) { // initialize from _Lobj
+        _Tnames = _Lobj._Gettnames();
+    }
+
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest, ios_base& _Iosbase, _Elem, const tm* _Pt, char _Specifier,
+        char _Modifier = '\0') const { // put formatted time from _Pt to _Dest for [_Fmtfirst, _Fmtlast)
+        char _Fmt[5] = "!%x\0"; // '!' for nonzero count, null for modifier
+        size_t _Count;
+        size_t _Num;
+        string _Str;
+
+        if (_Modifier == '\0') {
+            _Fmt[2] = _Specifier;
+        } else { // add both modifier and specifier
+            _Fmt[2] = _Modifier;
+            _Fmt[3] = _Specifier;
+        }
+
+        int& _Errno_ref      = errno; // Nonzero cost, pay it once
+        const int _Old_errno = _Errno_ref;
+
+        for (_Num = 16;; _Num *= 2) { // convert into ever larger string buffer until success
+            _Str.append(_Num, '\0');
+            _Count = _Strftime(&_Str[0], _Str.size(), _Fmt, _Pt, _Tnames._Getptr());
+            if (0 < _Count) {
+                break;
+            } else if (_Errno_ref == EINVAL) {
+                _Iosbase.setstate(ios_base::badbit);
+                return _Dest;
+            }
+        }
+
+        _Errno_ref = _Old_errno;
+        return _STD copy(&_Str[1], &_Str[_Count], _Dest);
+    }
+
+private:
+    _Locinfo::_Timevec _Tnames; // locale-specific stuff for _Strftime
+};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _Elem, class _OutIt>
+__PURE_APPDOMAIN_GLOBAL locale::id time_put<_Elem, _OutIt>::id;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+
+extern "C++" template <class _OutIt>
+class time_put<wchar_t, _OutIt> : public locale::facet { // facet for converting encoded times to wchar_t text
+public:
+    using _Elem     = wchar_t;
+    using char_type = _Elem;
+    using iter_type = _OutIt;
+    using _Ctype    = ctype<_Elem>;
+
+    _OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const tm* _Pt, const _Elem* _Fmtfirst,
+        const _Elem* _Fmtlast) const { // put formatted time from _Pt to _Dest for [_Fmtfirst, _Fmtlast)
+        const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Iosbase.getloc());
+
+        for (; _Fmtfirst != _Fmtlast; ++_Fmtfirst) {
+            if (_Ctype_fac.narrow(*_Fmtfirst) != '%') {
+                *_Dest++ = *_Fmtfirst; // copy literal element
+            } else if (++_Fmtfirst == _Fmtlast) { // treat trailing % as %%
+                *_Dest++ = _Fmtfirst[-1];
+                break;
+            } else { // get specifier after %
+                _Elem _Raw      = *_Fmtfirst;
+                char _Specifier = _Ctype_fac.narrow(_Raw);
+                char _Modifier  = '\0';
+                _Elem _Percent  = _Fmtfirst[-1];
+
+                if (_Specifier == 'E' || _Specifier == 'O' || _Specifier == 'Q' || _Specifier == '#') {
+                    if (++_Fmtfirst == _Fmtlast) { // no specifier, copy %[E0Q#] as literal elements
+                        *_Dest++ = _Percent;
+                        *_Dest++ = _Raw;
+                        break;
+                    }
+
+                    // save both qualifier and specifier
+                    _Modifier  = _Specifier;
+                    _Specifier = _Ctype_fac.narrow(*_Fmtfirst);
+                }
+
+                if (_Specifier == '%' && _Modifier == '\0') {
+                    // if the specifier is percent and no modifier is set, just append it
+                    *_Dest++ = _Percent;
+                } else if (!_Is_valid_strftime_specifier(_Specifier)) {
+                    // no valid specifier, directly copy as literal elements
+                    *_Dest++ = _Percent;
+                    if (_Modifier != '\0') {
+                        *_Dest++ = _Raw;
+                    }
+                    *_Dest++ = *_Fmtfirst;
+                } else {
+                    if (_Is_valid_strftime_tm_data(_Specifier, _Pt)) {
+                        _Dest = do_put(_Dest, _Iosbase, _Fill, _Pt, _Specifier, _Modifier); // convert a single field
+                    } else {
+                        *_Dest++ = _Elem('?');
+                    }
+                }
+            }
+        }
+
+        return _Dest;
+    }
+
+    _OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const tm* _Pt, char _Specifier,
+        char _Modifier = '\0') const { // put formatted time from _Pt to _Dest for _Specifier/_Modifier
+        return do_put(_Dest, _Iosbase, _Fill, _Pt, _Specifier, _Modifier);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id; // unique facet id
+
+    explicit __CLR_OR_THIS_CALL time_put(size_t _Refs = 0) : locale::facet(_Refs) { // construct from current locale
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    __CLR_OR_THIS_CALL time_put(const _Locinfo& _Lobj, size_t _Refs = 0) : locale::facet(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new time_put<_Elem, _OutIt>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_TIME;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~time_put() noexcept override {}
+
+    __CLR_OR_THIS_CALL time_put(const char* _Locname, size_t _Refs = 0) : locale::facet(_Refs) {
+        _BEGIN_LOCINFO(_Lobj(_Locname))
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo& _Lobj) { // initialize from _Lobj
+        _Tnames = _Lobj._W_Gettnames();
+    }
+
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest, ios_base& _Iosbase, _Elem, const tm* _Pt, char _Specifier,
+        char _Modifier = '\0') const { // put formatted time from _Pt to _Dest for [_Fmtfirst, _Fmtlast)
+        wchar_t _Fmt[5] = L"!%x\0"; // ! for nonzero count, null for modifier
+        size_t _Count;
+        size_t _Num;
+        wstring _Str;
+
+        if (_Modifier == '\0') {
+            _Fmt[2] = static_cast<_Elem>(_Specifier); // conversion rule unspecified
+        } else { // add both modifier and specifier
+            _Fmt[2] = static_cast<_Elem>(_Modifier);
+            _Fmt[3] = static_cast<_Elem>(_Specifier);
+        }
+
+        int& _Errno_ref      = errno; // Nonzero cost, pay it once
+        const int _Old_errno = _Errno_ref;
+
+        for (_Num = 16;; _Num *= 2) { // convert into ever larger string buffer until success
+            _Str.append(_Num, '\0');
+            _Count = _Wcsftime(&_Str[0], _Str.size(), _Fmt, _Pt, _Tnames._Getptr());
+            if (0 < _Count) {
+                break;
+            } else if (_Errno_ref == EINVAL) {
+                _Iosbase.setstate(ios_base::badbit);
+                return _Dest;
+            }
+        }
+
+        _Errno_ref = _Old_errno;
+        return _STD copy(&_Str[1], &_Str[_Count], _Dest);
+    }
+
+private:
+    _Locinfo::_Timevec _Tnames; // locale-specific stuff for _Wcsftime
+};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _OutIt>
+__PURE_APPDOMAIN_GLOBAL locale::id time_put<wchar_t, _OutIt>::id;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+
+#if defined(_CRTBLD)
+
+extern "C++" template <class _OutIt>
+class time_put<unsigned short, _OutIt>
+    : public locale::facet { // facet for converting encoded times to unsigned short text
+public:
+    using _Elem     = unsigned short;
+    using char_type = _Elem;
+    using iter_type = _OutIt;
+    using _Ctype    = ctype<_Elem>;
+
+    _OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const tm* _Pt, const _Elem* _Fmtfirst,
+        const _Elem* _Fmtlast) const { // put formatted time from _Pt to _Dest for [_Fmtfirst, _Fmtlast)
+        const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Iosbase.getloc());
+
+        for (; _Fmtfirst != _Fmtlast; ++_Fmtfirst) {
+            if (_Ctype_fac.narrow(*_Fmtfirst) != '%') {
+                *_Dest++ = *_Fmtfirst; // copy literal element
+            } else if (++_Fmtfirst == _Fmtlast) { // treat trailing % as %%
+                *_Dest++ = _Fmtfirst[-1];
+                break;
+            } else { // get specifier after %
+                _Elem _Raw      = *_Fmtfirst;
+                char _Specifier = _Ctype_fac.narrow(_Raw);
+                char _Modifier  = '\0';
+                _Elem _Percent  = _Fmtfirst[-1];
+
+                if (_Specifier == 'E' || _Specifier == 'O' || _Specifier == 'Q' || _Specifier == '#') {
+                    if (++_Fmtfirst == _Fmtlast) { // no specifier, copy %[E0Q#] as literal elements
+                        *_Dest++ = _Percent;
+                        *_Dest++ = _Raw;
+                        break;
+                    }
+
+                    // save both qualifier and specifier
+                    _Modifier  = _Specifier;
+                    _Specifier = _Ctype_fac.narrow(*_Fmtfirst);
+                }
+
+                if (_Specifier == '%' && _Modifier == '\0') {
+                    // if the specifier is percent and no modifier is set, just append it
+                    *_Dest++ = _Percent;
+                } else if (!_Is_valid_strftime_specifier(_Specifier)) {
+                    // no valid specifier, directly copy as literal elements
+                    *_Dest++ = _Percent;
+                    if (_Modifier != '\0') {
+                        *_Dest++ = _Raw;
+                    }
+                    *_Dest++ = *_Fmtfirst;
+                } else {
+                    if (_Is_valid_strftime_tm_data(_Specifier, _Pt)) {
+                        _Dest = do_put(_Dest, _Iosbase, _Fill, _Pt, _Specifier, _Modifier); // convert a single field
+                    } else {
+                        *_Dest++ = _Elem('?');
+                    }
+                }
+            }
+        }
+
+        return _Dest;
+    }
+
+    _OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const tm* _Pt, char _Specifier,
+        char _Modifier = '\0') const { // put formatted time from _Pt to _Dest for _Specifier/_Modifier
+        return do_put(_Dest, _Iosbase, _Fill, _Pt, _Specifier, _Modifier);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id; // unique facet id
+
+    explicit __CLR_OR_THIS_CALL time_put(size_t _Refs = 0) : locale::facet(_Refs) { // construct from current locale
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    __CLR_OR_THIS_CALL time_put(const _Locinfo& _Lobj, size_t _Refs = 0) : locale::facet(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new time_put<_Elem, _OutIt>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_TIME;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~time_put() noexcept override {}
+
+    __CLR_OR_THIS_CALL time_put(const char* _Locname, size_t _Refs = 0) : locale::facet(_Refs) {
+        _BEGIN_LOCINFO(_Lobj(_Locname))
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo& _Lobj) { // initialize from _Lobj
+        _Tnames = _Lobj._W_Gettnames();
+    }
+
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest, ios_base& _Iosbase, _Elem, const tm* _Pt, char _Specifier,
+        char _Modifier = '\0') const { // put formatted time from _Pt to _Dest for [_Fmtfirst, _Fmtlast)
+        wchar_t _Fmt[5] = L"!%x\0"; // ! for nonzero count, null for modifier
+        size_t _Count;
+        size_t _Num;
+        wstring _Str;
+
+        if (_Modifier == '\0') {
+            _Fmt[2] = static_cast<_Elem>(_Specifier); // conversion rule unspecified
+        } else { // add both modifier and specifier
+            _Fmt[2] = static_cast<_Elem>(_Modifier);
+            _Fmt[3] = static_cast<_Elem>(_Specifier);
+        }
+
+        int& _Errno_ref      = errno; // Nonzero cost, pay it once
+        const int _Old_errno = _Errno_ref;
+
+        for (_Num = 16;; _Num *= 2) { // convert into ever larger string buffer until success
+            _Str.append(_Num, '\0');
+            _Count = _Wcsftime(&_Str[0], _Str.size(), _Fmt, _Pt, _Tnames._Getptr());
+            if (0 < _Count) {
+                break;
+            } else if (_Errno_ref == EINVAL) {
+                _Iosbase.setstate(ios_base::badbit);
+                return _Dest;
+            }
+        }
+
+        _Errno_ref = _Old_errno;
+        return _STD copy(&_Str[1], &_Str[_Count], _Dest);
+    }
+
+private:
+    _Locinfo::_Timevec _Tnames; // locale-specific stuff for _Wcsftime
+};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _OutIt>
+__PURE_APPDOMAIN_GLOBAL locale::id time_put<unsigned short, _OutIt>::id;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+#endif // defined(_CRTBLD)
+
+_EXPORT_STD template <class _Elem, class _OutIt = ostreambuf_iterator<_Elem, char_traits<_Elem>>>
+class time_put_byname : public time_put<_Elem, _OutIt> { // time_put for named locale
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    explicit time_put_byname(const char* _Locname, size_t _Refs = 0)
+        : time_put<_Elem, _OutIt>(_Locname, _Refs) {} // construct for named locale
+
+    explicit time_put_byname(const string& _Str, size_t _Refs = 0)
+        : time_put<_Elem, _OutIt>(_Str.c_str(), _Refs) {} // construct for named locale
+
+protected:
+    __CLR_OR_THIS_CALL ~time_put_byname() noexcept override {}
+};
+
+#if defined(_DLL_CPPLIB)
+
+#if !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+template class _CRTIMP2_PURE_IMPORT time_get<char, istreambuf_iterator<char, char_traits<char>>>;
+template class _CRTIMP2_PURE_IMPORT time_put<char, ostreambuf_iterator<char, char_traits<char>>>;
+template _CRTIMP2_PURE void __CLR_OR_THIS_CALL time_get<char, istreambuf_iterator<char, char_traits<char>>>::_Getvals(
+    wchar_t, const _Locinfo&);
+
+template class _CRTIMP2_PURE_IMPORT time_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t>>>;
+template class _CRTIMP2_PURE_IMPORT time_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t>>>;
+template _CRTIMP2_PURE void __CLR_OR_THIS_CALL
+    time_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t>>>::_Getvals(wchar_t, const _Locinfo&);
+#endif // !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+
+#ifdef __FORCE_INSTANCE
+template class _CRTIMP2_PURE_IMPORT
+    time_get<unsigned short, istreambuf_iterator<unsigned short, char_traits<unsigned short>>>;
+template class _CRTIMP2_PURE_IMPORT
+    time_put<unsigned short, ostreambuf_iterator<unsigned short, char_traits<unsigned short>>>;
+template _CRTIMP2_PURE void __CLR_OR_THIS_CALL
+    time_get<unsigned short, istreambuf_iterator<unsigned short, char_traits<unsigned short>>>::_Getvals(
+        wchar_t, const _Locinfo&);
+#endif // defined(__FORCE_INSTANCE)
+#endif // defined(_DLL_CPPLIB)
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XLOCTIME_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xmemory b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xmemory
new file mode 100644
index 0000000000000000000000000000000000000000..45913c396c3896bf07ba83dc615d356ccc65d21f
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xmemory
@@ -0,0 +1,2627 @@
+// xmemory internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XMEMORY_
+#define _XMEMORY_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <cstdint>
+#include <cstdlib>
+#include <limits> // TRANSITION, see GH-4634: Lots of user code assumes that <xmemory> drags in <limits>
+#include <new>
+#include <xatomic.h>
+#include <xutility>
+
+#if _HAS_CXX20
+#include <tuple>
+#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
+template <class _Ptrty>
+_NODISCARD constexpr auto _Unfancy(_Ptrty _Ptr) noexcept { // converts from a fancy pointer to a plain pointer
+    return _STD addressof(*_Ptr);
+}
+
+template <class _Ty>
+_NODISCARD constexpr _Ty* _Unfancy(_Ty* _Ptr) noexcept { // do nothing for plain pointers
+    return _Ptr;
+}
+
+template <class _Ptrty>
+constexpr auto _Unfancy_maybe_null(_Ptrty _Ptr) noexcept {
+    // converts from a (potentially null) fancy pointer to a plain pointer
+    return _Ptr ? _STD addressof(*_Ptr) : nullptr;
+}
+
+template <class _Ty>
+constexpr _Ty* _Unfancy_maybe_null(_Ty* _Ptr) noexcept { // do nothing for plain pointers
+    return _Ptr;
+}
+
+template <class _Ty>
+struct _NODISCARD _Tidy_guard { // class with destructor that calls _Tidy
+    _Ty* _Target;
+    _CONSTEXPR20 ~_Tidy_guard() {
+        if (_Target) {
+            _Target->_Tidy();
+        }
+    }
+};
+
+template <class _Ty>
+struct _NODISCARD _Tidy_deallocate_guard { // class with destructor that calls _Tidy_deallocate
+    _Ty* _Target;
+    _CONSTEXPR20 ~_Tidy_deallocate_guard() {
+        if (_Target) {
+            _Target->_Tidy_deallocate();
+        }
+    }
+};
+
+template <class _Keycmp, class _Lhs, class _Rhs>
+constexpr bool _Nothrow_compare = noexcept(
+    static_cast<bool>(_STD declval<const _Keycmp&>()(_STD declval<const _Lhs&>(), _STD declval<const _Rhs&>())));
+
+[[noreturn]] inline void _Throw_bad_array_new_length() {
+    _THROW(bad_array_new_length{});
+}
+
+template <size_t _Ty_size>
+_NODISCARD constexpr size_t _Get_size_of_n(const size_t _Count) {
+    constexpr bool _Overflow_is_possible = _Ty_size > 1;
+
+    if constexpr (_Overflow_is_possible) {
+        constexpr size_t _Max_possible = static_cast<size_t>(-1) / _Ty_size;
+        if (_Count > _Max_possible) {
+            _Throw_bad_array_new_length(); // multiply overflow
+        }
+    }
+
+    return _Count * _Ty_size;
+}
+
+template <class _Ty>
+constexpr size_t _New_alignof = (_STD max)(alignof(_Ty), __STDCPP_DEFAULT_NEW_ALIGNMENT__);
+
+struct _Default_allocate_traits {
+    __declspec(allocator) static
+#ifdef __clang__ // Clang and MSVC implement P0784R7 differently; see GH-1532
+        _CONSTEXPR20
+#endif // defined(__clang__)
+        void* _Allocate(const size_t _Bytes) {
+        return ::operator new(_Bytes);
+    }
+
+#ifdef __cpp_aligned_new
+    __declspec(allocator) static
+#ifdef __clang__ // Clang and MSVC implement P0784R7 differently; see GH-1532
+        _CONSTEXPR20
+#endif // defined(__clang__)
+        void* _Allocate_aligned(const size_t _Bytes, const size_t _Align) {
+#ifdef __clang__ // Clang and MSVC implement P0784R7 differently; see GH-1532
+#if _HAS_CXX20
+        if (_STD is_constant_evaluated()) {
+            return ::operator new(_Bytes);
+        } else
+#endif // _HAS_CXX20
+#endif // defined(__clang__)
+        {
+            return ::operator new(_Bytes, align_val_t{_Align});
+        }
+    }
+#endif // defined(__cpp_aligned_new)
+};
+
+constexpr bool _Is_pow_2(const size_t _Value) noexcept {
+    return _Value != 0 && (_Value & (_Value - 1)) == 0;
+}
+
+#if defined(_M_IX86) || defined(_M_X64)
+_INLINE_VAR constexpr size_t _Big_allocation_threshold = 4096;
+_INLINE_VAR constexpr size_t _Big_allocation_alignment = 32;
+
+// Big allocation alignment should at least match vector register alignment
+_STL_INTERNAL_STATIC_ASSERT(2 * sizeof(void*) <= _Big_allocation_alignment);
+
+// Big allocation alignment must be a power of two
+_STL_INTERNAL_STATIC_ASSERT(_Is_pow_2(_Big_allocation_alignment));
+
+#ifdef _DEBUG
+_INLINE_VAR constexpr size_t _Non_user_size = 2 * sizeof(void*) + _Big_allocation_alignment - 1;
+#else // ^^^ defined(_DEBUG) / !defined(_DEBUG) vvv
+_INLINE_VAR constexpr size_t _Non_user_size = sizeof(void*) + _Big_allocation_alignment - 1;
+#endif // ^^^ !defined(_DEBUG) ^^^
+
+#ifdef _WIN64
+_INLINE_VAR constexpr size_t _Big_allocation_sentinel = 0xFAFAFAFAFAFAFAFAULL;
+#else // ^^^ defined(_WIN64) / !defined(_WIN64) vvv
+_INLINE_VAR constexpr size_t _Big_allocation_sentinel = 0xFAFAFAFAUL;
+#endif // ^^^ !defined(_WIN64) ^^^
+
+template <class _Traits>
+__declspec(allocator) void* _Allocate_manually_vector_aligned(const size_t _Bytes) {
+    // allocate _Bytes manually aligned to at least _Big_allocation_alignment
+    const size_t _Block_size = _Non_user_size + _Bytes;
+    if (_Block_size <= _Bytes) {
+        _Throw_bad_array_new_length(); // add overflow
+    }
+
+    const uintptr_t _Ptr_container = reinterpret_cast<uintptr_t>(_Traits::_Allocate(_Block_size));
+    _STL_VERIFY(_Ptr_container != 0, "invalid argument"); // validate even in release since we're doing p[-1]
+    void* const _Ptr = reinterpret_cast<void*>((_Ptr_container + _Non_user_size) & ~(_Big_allocation_alignment - 1));
+    static_cast<uintptr_t*>(_Ptr)[-1] = _Ptr_container;
+
+#ifdef _DEBUG
+    static_cast<uintptr_t*>(_Ptr)[-2] = _Big_allocation_sentinel;
+#endif // defined(_DEBUG)
+    return _Ptr;
+}
+
+inline void _Adjust_manually_vector_aligned(void*& _Ptr, size_t& _Bytes) {
+    // adjust parameters from _Allocate_manually_vector_aligned to pass to operator delete
+    _Bytes += _Non_user_size;
+
+    const uintptr_t* const _Ptr_user = static_cast<uintptr_t*>(_Ptr);
+    const uintptr_t _Ptr_container   = _Ptr_user[-1];
+
+    // If the following asserts, it likely means that we are performing
+    // an aligned delete on memory coming from an unaligned allocation.
+    _STL_ASSERT(_Ptr_user[-2] == _Big_allocation_sentinel, "invalid argument");
+
+    // Extra paranoia on aligned allocation/deallocation; ensure _Ptr_container is
+    // in range [_Min_back_shift, _Non_user_size]
+#ifdef _DEBUG
+    constexpr uintptr_t _Min_back_shift = 2 * sizeof(void*);
+#else // ^^^ defined(_DEBUG) / !defined(_DEBUG) vvv
+    constexpr uintptr_t _Min_back_shift = sizeof(void*);
+#endif // ^^^ !defined(_DEBUG) ^^^
+    const uintptr_t _Back_shift = reinterpret_cast<uintptr_t>(_Ptr) - _Ptr_container;
+    _STL_VERIFY(_Back_shift >= _Min_back_shift && _Back_shift <= _Non_user_size, "invalid argument");
+    _Ptr = reinterpret_cast<void*>(_Ptr_container);
+}
+#endif // defined(_M_IX86) || defined(_M_X64)
+
+template <size_t _Align, class _Traits = _Default_allocate_traits>
+__declspec(allocator) _CONSTEXPR20 void* _Allocate(const size_t _Bytes) {
+    // allocate _Bytes
+    if (_Bytes == 0) {
+        return nullptr;
+    }
+
+#if _HAS_CXX20 // TRANSITION, GH-1532
+    if (_STD is_constant_evaluated()) {
+        return _Traits::_Allocate(_Bytes);
+    }
+#endif // _HAS_CXX20
+
+#ifdef __cpp_aligned_new
+    if constexpr (_Align > __STDCPP_DEFAULT_NEW_ALIGNMENT__) {
+        size_t _Passed_align = _Align;
+#if defined(_M_IX86) || defined(_M_X64)
+        if (_Bytes >= _Big_allocation_threshold) {
+            // boost the alignment of big allocations to help autovectorization
+            _Passed_align = (_STD max)(_Align, _Big_allocation_alignment);
+        }
+#endif // defined(_M_IX86) || defined(_M_X64)
+        return _Traits::_Allocate_aligned(_Bytes, _Passed_align);
+    } else
+#endif // defined(__cpp_aligned_new)
+    {
+#if defined(_M_IX86) || defined(_M_X64)
+        if (_Bytes >= _Big_allocation_threshold) {
+            // boost the alignment of big allocations to help autovectorization
+            return _Allocate_manually_vector_aligned<_Traits>(_Bytes);
+        }
+#endif // defined(_M_IX86) || defined(_M_X64)
+        return _Traits::_Allocate(_Bytes);
+    }
+}
+
+template <size_t _Align>
+_CONSTEXPR20 void _Deallocate(void* _Ptr, size_t _Bytes) noexcept {
+    // deallocate storage allocated by _Allocate
+#if _HAS_CXX20 // TRANSITION, GH-1532
+    if (_STD is_constant_evaluated()) {
+        ::operator delete(_Ptr);
+        return;
+    }
+#endif // _HAS_CXX20
+
+#ifdef __cpp_aligned_new
+    if constexpr (_Align > __STDCPP_DEFAULT_NEW_ALIGNMENT__) {
+        size_t _Passed_align = _Align;
+#if defined(_M_IX86) || defined(_M_X64)
+        if (_Bytes >= _Big_allocation_threshold) {
+            // boost the alignment of big allocations to help autovectorization
+            _Passed_align = (_STD max)(_Align, _Big_allocation_alignment);
+        }
+#endif // defined(_M_IX86) || defined(_M_X64)
+        ::operator delete(_Ptr, _Bytes, align_val_t{_Passed_align});
+    } else
+#endif // defined(__cpp_aligned_new)
+    {
+#if defined(_M_IX86) || defined(_M_X64)
+        if (_Bytes >= _Big_allocation_threshold) {
+            // boost the alignment of big allocations to help autovectorization
+            _Adjust_manually_vector_aligned(_Ptr, _Bytes);
+        }
+#endif // defined(_M_IX86) || defined(_M_X64)
+        ::operator delete(_Ptr, _Bytes);
+    }
+}
+
+template <class _Ptr, class _Ty>
+using _Rebind_pointer_t = typename pointer_traits<_Ptr>::template rebind<_Ty>;
+
+template <class _Pointer, enable_if_t<!is_pointer_v<_Pointer>, int> = 0>
+_CONSTEXPR20 _Pointer _Refancy(typename pointer_traits<_Pointer>::element_type* _Ptr) noexcept {
+    return pointer_traits<_Pointer>::pointer_to(*_Ptr);
+}
+
+template <class _Pointer, enable_if_t<is_pointer_v<_Pointer>, int> = 0>
+_CONSTEXPR20 _Pointer _Refancy(_Pointer _Ptr) noexcept {
+    return _Ptr;
+}
+
+template <class _Pointer, enable_if_t<!is_pointer_v<_Pointer>, int> = 0>
+_CONSTEXPR20 _Pointer _Refancy_maybe_null(typename pointer_traits<_Pointer>::element_type* _Ptr) noexcept {
+    return _Ptr == nullptr ? _Pointer() : pointer_traits<_Pointer>::pointer_to(*_Ptr);
+}
+
+template <class _Pointer, enable_if_t<is_pointer_v<_Pointer>, int> = 0>
+_CONSTEXPR20 _Pointer _Refancy_maybe_null(_Pointer _Ptr) noexcept {
+    return _Ptr;
+}
+
+template <class _NoThrowFwdIt, class _NoThrowSentinel>
+_CONSTEXPR20 void _Destroy_range(_NoThrowFwdIt _First, _NoThrowSentinel _Last) noexcept;
+
+template <class _Ty>
+_CONSTEXPR20 void _Destroy_in_place(_Ty& _Obj) noexcept {
+    if constexpr (is_array_v<_Ty>) {
+        _STD _Destroy_range(_Obj, _Obj + extent_v<_Ty>);
+    } else {
+        _Obj.~_Ty();
+    }
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _Ty>
+_CONSTEXPR20 void destroy_at(_Ty* const _Location) noexcept /* strengthened */ {
+#if _HAS_CXX20
+    if constexpr (is_array_v<_Ty>) {
+        _STD _Destroy_range(_STD begin(*_Location), _STD end(*_Location));
+    } else
+#endif // _HAS_CXX20
+    {
+        _Location->~_Ty();
+    }
+}
+#endif // _HAS_CXX17
+
+template <class _Ptrty>
+auto _Const_cast(_Ptrty _Ptr) noexcept { // remove constness from a fancy pointer
+    using _Elem       = typename pointer_traits<_Ptrty>::element_type;
+    using _Modifiable = remove_const_t<_Elem>;
+    using _Dest       = typename pointer_traits<_Ptrty>::template rebind<_Modifiable>;
+
+    return pointer_traits<_Dest>::pointer_to(const_cast<_Modifiable&>(*_Ptr));
+}
+
+template <class _Ty>
+auto _Const_cast(_Ty* _Ptr) noexcept {
+    return const_cast<remove_const_t<_Ty>*>(_Ptr);
+}
+
+template <class _Ty, class = void>
+struct _Get_pointer_type {
+    using type = typename _Ty::value_type*;
+};
+
+_STL_DISABLE_DEPRECATED_WARNING
+template <class _Ty>
+struct _Get_pointer_type<_Ty, void_t<typename _Ty::pointer>> {
+    using type = typename _Ty::pointer;
+};
+_STL_RESTORE_DEPRECATED_WARNING
+
+template <class _Ty, class = void>
+struct _Get_const_pointer_type {
+    using _Ptrty = typename _Get_pointer_type<_Ty>::type;
+    using _Valty = typename _Ty::value_type;
+    using type   = typename pointer_traits<_Ptrty>::template rebind<const _Valty>;
+};
+
+_STL_DISABLE_DEPRECATED_WARNING
+template <class _Ty>
+struct _Get_const_pointer_type<_Ty, void_t<typename _Ty::const_pointer>> {
+    using type = typename _Ty::const_pointer;
+};
+_STL_RESTORE_DEPRECATED_WARNING
+
+template <class _Ty, class = void>
+struct _Get_void_pointer_type {
+    using _Ptrty = typename _Get_pointer_type<_Ty>::type;
+    using type   = typename pointer_traits<_Ptrty>::template rebind<void>;
+};
+
+template <class _Ty>
+struct _Get_void_pointer_type<_Ty, void_t<typename _Ty::void_pointer>> {
+    using type = typename _Ty::void_pointer;
+};
+
+template <class _Ty, class = void>
+struct _Get_const_void_pointer_type {
+    using _Ptrty = typename _Get_pointer_type<_Ty>::type;
+    using type   = typename pointer_traits<_Ptrty>::template rebind<const void>;
+};
+
+template <class _Ty>
+struct _Get_const_void_pointer_type<_Ty, void_t<typename _Ty::const_void_pointer>> {
+    using type = typename _Ty::const_void_pointer;
+};
+
+template <class _Ty, class = void>
+struct _Get_difference_type {
+    using _Ptrty = typename _Get_pointer_type<_Ty>::type;
+    using type   = typename pointer_traits<_Ptrty>::difference_type;
+};
+
+template <class _Ty>
+struct _Get_difference_type<_Ty, void_t<typename _Ty::difference_type>> {
+    using type = typename _Ty::difference_type;
+};
+
+template <class _Ty, class = void>
+struct _Get_size_type {
+    using type = make_unsigned_t<typename _Get_difference_type<_Ty>::type>;
+};
+
+template <class _Ty>
+struct _Get_size_type<_Ty, void_t<typename _Ty::size_type>> {
+    using type = typename _Ty::size_type;
+};
+
+template <class _Ty, class = void>
+struct _Get_propagate_on_container_copy {
+    using type = false_type;
+};
+
+template <class _Ty>
+struct _Get_propagate_on_container_copy<_Ty, void_t<typename _Ty::propagate_on_container_copy_assignment>> {
+    using type = typename _Ty::propagate_on_container_copy_assignment;
+};
+
+template <class _Ty, class = void>
+struct _Get_propagate_on_container_move {
+    using type = false_type;
+};
+
+template <class _Ty>
+struct _Get_propagate_on_container_move<_Ty, void_t<typename _Ty::propagate_on_container_move_assignment>> {
+    using type = typename _Ty::propagate_on_container_move_assignment;
+};
+
+template <class _Ty, class = void>
+struct _Get_propagate_on_container_swap {
+    using type = false_type;
+};
+
+template <class _Ty>
+struct _Get_propagate_on_container_swap<_Ty, void_t<typename _Ty::propagate_on_container_swap>> {
+    using type = typename _Ty::propagate_on_container_swap;
+};
+
+template <class _Ty, class = void>
+struct _Get_is_always_equal {
+    using type = bool_constant<is_empty_v<_Ty>>;
+};
+
+_STL_DISABLE_DEPRECATED_WARNING
+template <class _Ty>
+struct _Get_is_always_equal<_Ty, void_t<typename _Ty::is_always_equal>> {
+    using type = typename _Ty::is_always_equal;
+};
+_STL_RESTORE_DEPRECATED_WARNING
+
+template <class _Ty, class _Other, class = void>
+struct _Get_rebind_type {
+    using type = typename _Replace_first_parameter<_Other, _Ty>::type;
+};
+
+_STL_DISABLE_DEPRECATED_WARNING
+template <class _Ty, class _Other>
+struct _Get_rebind_type<_Ty, _Other, void_t<typename _Ty::template rebind<_Other>::other>> {
+    using type = typename _Ty::template rebind<_Other>::other;
+};
+_STL_RESTORE_DEPRECATED_WARNING
+
+_EXPORT_STD template <class _Ty>
+class allocator;
+
+template <class _Alloc, class = void>
+struct _Is_default_allocator : false_type {};
+
+template <class _Ty>
+struct _Is_default_allocator<allocator<_Ty>, void_t<typename allocator<_Ty>::_From_primary>>
+    : is_same<typename allocator<_Ty>::_From_primary, allocator<_Ty>>::type {};
+
+#if _HAS_CXX23
+template <class _Alloc, class _SizeTy>
+concept _Has_member_allocate_at_least = requires(_Alloc& _Al, const _SizeTy& _Count) { _Al.allocate_at_least(_Count); };
+#endif // _HAS_CXX23
+
+template <class _Void, class... _Types>
+struct _Has_no_allocator_construct : true_type {};
+
+_STL_DISABLE_DEPRECATED_WARNING
+template <class _Alloc, class _Ptr, class... _Args>
+struct _Has_no_allocator_construct<
+    void_t<decltype(_STD declval<_Alloc&>().construct(_STD declval<_Ptr>(), _STD declval<_Args>()...))>, _Alloc, _Ptr,
+    _Args...> : false_type {};
+_STL_RESTORE_DEPRECATED_WARNING
+
+template <class _Alloc, class _Ptr, class... _Args>
+using _Uses_default_construct =
+    disjunction<_Is_default_allocator<_Alloc>, _Has_no_allocator_construct<void, _Alloc, _Ptr, _Args...>>;
+
+template <class _Alloc, class _Ptr, class = void>
+struct _Has_no_alloc_destroy : true_type {};
+
+_STL_DISABLE_DEPRECATED_WARNING
+template <class _Alloc, class _Ptr>
+struct _Has_no_alloc_destroy<_Alloc, _Ptr, void_t<decltype(_STD declval<_Alloc&>().destroy(_STD declval<_Ptr>()))>>
+    : false_type {};
+_STL_RESTORE_DEPRECATED_WARNING
+
+template <class _Alloc, class _Ptr>
+using _Uses_default_destroy = disjunction<_Is_default_allocator<_Alloc>, _Has_no_alloc_destroy<_Alloc, _Ptr>>;
+
+template <class _Alloc, class _Size_type, class _Const_void_pointer, class = void>
+struct _Has_allocate_hint : false_type {};
+
+_STL_DISABLE_DEPRECATED_WARNING
+template <class _Alloc, class _Size_type, class _Const_void_pointer>
+struct _Has_allocate_hint<_Alloc, _Size_type, _Const_void_pointer,
+    void_t<decltype(_STD declval<_Alloc&>().allocate(
+        _STD declval<const _Size_type&>(), _STD declval<const _Const_void_pointer&>()))>> : true_type {};
+_STL_RESTORE_DEPRECATED_WARNING
+
+template <class _Alloc, class = void>
+struct _Has_max_size : false_type {};
+
+_STL_DISABLE_DEPRECATED_WARNING
+template <class _Alloc>
+struct _Has_max_size<_Alloc, void_t<decltype(_STD declval<const _Alloc&>().max_size())>> : true_type {};
+_STL_RESTORE_DEPRECATED_WARNING
+
+template <class _Alloc, class = void>
+struct _Has_select_on_container_copy_construction : false_type {};
+
+template <class _Alloc>
+struct _Has_select_on_container_copy_construction<_Alloc,
+    void_t<decltype(_STD declval<const _Alloc&>().select_on_container_copy_construction())>> : true_type {};
+
+#if _HAS_CXX23
+_EXPORT_STD template <class _Ptr, class _SizeTy = size_t>
+struct allocation_result {
+    _Ptr ptr;
+    _SizeTy count;
+};
+#endif // _HAS_CXX23
+
+_EXPORT_STD template <class _Alloc>
+struct allocator_traits;
+
+_STL_DISABLE_DEPRECATED_WARNING
+template <class _Alloc>
+struct _Normal_allocator_traits { // defines traits for allocators
+    using allocator_type = _Alloc;
+    using value_type     = typename _Alloc::value_type;
+
+    using pointer            = typename _Get_pointer_type<_Alloc>::type;
+    using const_pointer      = typename _Get_const_pointer_type<_Alloc>::type;
+    using void_pointer       = typename _Get_void_pointer_type<_Alloc>::type;
+    using const_void_pointer = typename _Get_const_void_pointer_type<_Alloc>::type;
+
+    using size_type       = typename _Get_size_type<_Alloc>::type;
+    using difference_type = typename _Get_difference_type<_Alloc>::type;
+
+    using propagate_on_container_copy_assignment = typename _Get_propagate_on_container_copy<_Alloc>::type;
+    using propagate_on_container_move_assignment = typename _Get_propagate_on_container_move<_Alloc>::type;
+    using propagate_on_container_swap            = typename _Get_propagate_on_container_swap<_Alloc>::type;
+    using is_always_equal                        = typename _Get_is_always_equal<_Alloc>::type;
+
+    template <class _Other>
+    using rebind_alloc = typename _Get_rebind_type<_Alloc, _Other>::type;
+
+    template <class _Other>
+    using rebind_traits = allocator_traits<rebind_alloc<_Other>>;
+
+    _NODISCARD_RAW_PTR_ALLOC static _CONSTEXPR20 __declspec(allocator) pointer
+        allocate(_Alloc& _Al, _CRT_GUARDOVERFLOW const size_type _Count) {
+        return _Al.allocate(_Count);
+    }
+
+    _NODISCARD_RAW_PTR_ALLOC static _CONSTEXPR20 __declspec(allocator) pointer
+        allocate(_Alloc& _Al, _CRT_GUARDOVERFLOW const size_type _Count, const const_void_pointer _Hint) {
+        if constexpr (_Has_allocate_hint<_Alloc, size_type, const_void_pointer>::value) {
+            return _Al.allocate(_Count, _Hint);
+        } else {
+            return _Al.allocate(_Count);
+        }
+    }
+
+#if _HAS_CXX23
+    _NODISCARD_RAW_PTR_ALLOC static constexpr allocation_result<pointer, size_type> allocate_at_least(
+        _Alloc& _Al, _CRT_GUARDOVERFLOW const size_type _Count) {
+        if constexpr (_Has_member_allocate_at_least<_Alloc, size_type>) {
+            return _Al.allocate_at_least(_Count);
+        } else {
+            return {_Al.allocate(_Count), _Count};
+        }
+    }
+#endif // _HAS_CXX23
+
+    static _CONSTEXPR20 void deallocate(_Alloc& _Al, pointer _Ptr, size_type _Count) {
+        _Al.deallocate(_Ptr, _Count);
+    }
+
+    template <class _Ty, class... _Types>
+    static _CONSTEXPR20 void construct(_Alloc& _Al, _Ty* _Ptr, _Types&&... _Args) {
+        if constexpr (_Uses_default_construct<_Alloc, _Ty*, _Types...>::value) {
+#if _HAS_CXX20
+            _STD construct_at(_Ptr, _STD forward<_Types>(_Args)...);
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+            ::new (static_cast<void*>(_Ptr)) _Ty(_STD forward<_Types>(_Args)...);
+#endif // ^^^ !_HAS_CXX20 ^^^
+        } else {
+            _Al.construct(_Ptr, _STD forward<_Types>(_Args)...);
+        }
+    }
+
+    template <class _Ty>
+    static _CONSTEXPR20 void destroy(_Alloc& _Al, _Ty* _Ptr) {
+        if constexpr (_Uses_default_destroy<_Alloc, _Ty*>::value) {
+#if _HAS_CXX20
+            _STD destroy_at(_Ptr);
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+            _Ptr->~_Ty();
+#endif // ^^^ !_HAS_CXX20 ^^^
+        } else {
+            _Al.destroy(_Ptr);
+        }
+    }
+
+    _NODISCARD static _CONSTEXPR20 size_type max_size(const _Alloc& _Al) noexcept {
+        if constexpr (_Has_max_size<_Alloc>::value) {
+            return _Al.max_size();
+        } else {
+            return _STD _Max_limit<size_type>() / sizeof(value_type);
+        }
+    }
+
+    _NODISCARD static _CONSTEXPR20 _Alloc select_on_container_copy_construction(const _Alloc& _Al) {
+        if constexpr (_Has_select_on_container_copy_construction<_Alloc>::value) {
+            return _Al.select_on_container_copy_construction();
+        } else {
+            return _Al;
+        }
+    }
+};
+_STL_RESTORE_DEPRECATED_WARNING
+
+template <class _Alloc>
+struct _Default_allocator_traits { // traits for std::allocator
+    using allocator_type = _Alloc;
+    using value_type     = typename _Alloc::value_type;
+
+    using pointer            = value_type*;
+    using const_pointer      = const value_type*;
+    using void_pointer       = void*;
+    using const_void_pointer = const void*;
+
+    using size_type       = size_t;
+    using difference_type = ptrdiff_t;
+
+    using propagate_on_container_copy_assignment = false_type;
+    using propagate_on_container_move_assignment = true_type;
+    using propagate_on_container_swap            = false_type;
+    using is_always_equal                        = true_type;
+
+    template <class _Other>
+    using rebind_alloc = allocator<_Other>;
+
+    template <class _Other>
+    using rebind_traits = allocator_traits<allocator<_Other>>;
+
+    _NODISCARD_RAW_PTR_ALLOC static _CONSTEXPR20 __declspec(allocator) pointer
+        allocate(_Alloc& _Al, _CRT_GUARDOVERFLOW const size_type _Count) {
+#if _HAS_CXX20 // TRANSITION, GH-1532
+        if (_STD is_constant_evaluated()) {
+            return _Al.allocate(_Count);
+        } else
+#endif // _HAS_CXX20
+        {
+            (void) _Al;
+            return static_cast<pointer>(
+                _Allocate<_New_alignof<value_type>>(_Get_size_of_n<sizeof(value_type)>(_Count)));
+        }
+    }
+
+    _NODISCARD_RAW_PTR_ALLOC static _CONSTEXPR20 __declspec(allocator) pointer
+        allocate(_Alloc& _Al, _CRT_GUARDOVERFLOW const size_type _Count, const_void_pointer) {
+#if _HAS_CXX20 // TRANSITION, GH-1532
+        if (_STD is_constant_evaluated()) {
+            return _Al.allocate(_Count);
+        } else
+#endif // _HAS_CXX20
+        {
+            (void) _Al;
+            return static_cast<pointer>(
+                _Allocate<_New_alignof<value_type>>(_Get_size_of_n<sizeof(value_type)>(_Count)));
+        }
+    }
+
+#if _HAS_CXX23
+    _NODISCARD_RAW_PTR_ALLOC static constexpr allocation_result<pointer, size_type> allocate_at_least(
+        _Alloc& _Al, _CRT_GUARDOVERFLOW const size_type _Count) {
+        return {_Al.allocate(_Count), _Count};
+    }
+#endif // _HAS_CXX23
+
+    static _CONSTEXPR20 void deallocate(_Alloc& _Al, const pointer _Ptr, const size_type _Count) {
+        // no overflow check on the following multiply; we assume _Allocate did that check
+#if _HAS_CXX20 // TRANSITION, GH-1532
+        if (_STD is_constant_evaluated()) {
+            _Al.deallocate(_Ptr, _Count);
+        } else
+#endif // _HAS_CXX20
+        {
+            (void) _Al;
+            _STD _Deallocate<_New_alignof<value_type>>(_Ptr, sizeof(value_type) * _Count);
+        }
+    }
+
+    template <class _Objty, class... _Types>
+    static _CONSTEXPR20 void construct(_Alloc&, _Objty* const _Ptr, _Types&&... _Args) {
+#if _HAS_CXX20
+        _STD construct_at(_Ptr, _STD forward<_Types>(_Args)...);
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+        ::new (const_cast<void*>(static_cast<const volatile void*>(_Ptr))) _Objty(_STD forward<_Types>(_Args)...);
+#endif // ^^^ !_HAS_CXX20 ^^^
+    }
+
+    template <class _Uty>
+    static _CONSTEXPR20 void destroy(_Alloc&, _Uty* const _Ptr) {
+#if _HAS_CXX20
+        _STD destroy_at(_Ptr);
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+        _Ptr->~_Uty();
+#endif // ^^^ !_HAS_CXX20 ^^^
+    }
+
+    _NODISCARD static _CONSTEXPR20 size_type max_size(const _Alloc&) noexcept {
+        return static_cast<size_t>(-1) / sizeof(value_type);
+    }
+
+    _NODISCARD static _CONSTEXPR20 _Alloc select_on_container_copy_construction(const _Alloc& _Al) {
+        return _Al;
+    }
+};
+
+_EXPORT_STD template <class _Alloc>
+struct allocator_traits : conditional_t<_Is_default_allocator<_Alloc>::value, _Default_allocator_traits<_Alloc>,
+                              _Normal_allocator_traits<_Alloc>> {};
+
+// _Choose_pocca_v returns whether an attempt to propagate allocators is necessary in copy assignment operations.
+// Note that even when false_type, callers should call _Pocca as we want to assign allocators even when equal.
+template <class _Alloc>
+constexpr bool _Choose_pocca_v = allocator_traits<_Alloc>::propagate_on_container_copy_assignment::value
+                              && !allocator_traits<_Alloc>::is_always_equal::value;
+
+enum class _Pocma_values {
+    _Equal_allocators, // usually allows contents to be stolen (e.g. with swap)
+    _Propagate_allocators, // usually allows the allocator to be propagated, and then contents stolen
+    _No_propagate_allocators, // usually turns moves into copies
+};
+
+template <class _Alloc>
+constexpr _Pocma_values _Choose_pocma_v = allocator_traits<_Alloc>::is_always_equal::value
+                                            ? _Pocma_values::_Equal_allocators
+                                            : (allocator_traits<_Alloc>::propagate_on_container_move_assignment::value
+                                                    ? _Pocma_values::_Propagate_allocators
+                                                    : _Pocma_values::_No_propagate_allocators);
+
+template <class _Alloc, class _Value_type>
+using _Rebind_alloc_t = typename allocator_traits<_Alloc>::template rebind_alloc<_Value_type>;
+
+// If _Alloc is already rebound appropriately, binds an lvalue reference to it, avoiding a copy. Otherwise, creates a
+// rebound copy.
+template <class _Alloc, class _Value_type>
+using _Maybe_rebind_alloc_t =
+    typename _Select<is_same_v<typename _Alloc::value_type, _Value_type>>::template _Apply<_Alloc&,
+        _Rebind_alloc_t<_Alloc, _Value_type>>;
+
+template <class _Alloc> // tests if allocator has simple addressing
+constexpr bool _Is_simple_alloc_v =
+    is_same_v<typename allocator_traits<_Alloc>::size_type, size_t>
+    && is_same_v<typename allocator_traits<_Alloc>::difference_type, ptrdiff_t>
+    && is_same_v<typename allocator_traits<_Alloc>::pointer, typename _Alloc::value_type*>
+    && is_same_v<typename allocator_traits<_Alloc>::const_pointer, const typename _Alloc::value_type*>;
+
+template <class _Value_type>
+struct _Simple_types { // wraps types from allocators with simple addressing for use in iterators
+                       // and other SCARY machinery
+    using value_type      = _Value_type;
+    using size_type       = size_t;
+    using difference_type = ptrdiff_t;
+    using pointer         = value_type*;
+    using const_pointer   = const value_type*;
+};
+
+// The number of user bytes a single byte of ASAN shadow memory can track.
+_INLINE_VAR constexpr size_t _Asan_granularity      = 8;
+_INLINE_VAR constexpr size_t _Asan_granularity_mask = _Asan_granularity - 1;
+
+struct _Asan_aligned_pointers {
+    const void* _First;
+    const void* _End;
+
+    _NODISCARD constexpr const void* _Clamp_to_end(const void* _Mid) const noexcept {
+        _STL_INTERNAL_CHECK(_Mid >= _First);
+        if (_Mid > _End) {
+            return _End;
+        } else {
+            return _Mid;
+        }
+    }
+};
+
+// The way that ASan shadow memory works, each eight byte block of memory ("shadow memory section")
+// has a single byte to mark it as either poison or valid.
+// Each section has 0 to 8 "valid" bytes followed by poison bytes, so:
+// ```
+//   [ v v v p p p p p ]
+// ```
+// or
+// ```
+//   [ v v v v v v v v ]
+// ```
+// are okay, but
+// ```
+//   [ p p p p v v v v ]
+// ```
+// is not.
+//
+// This function exists to fix up `first` and `end` pointers so that one can call
+// `__sanitizer_annotate_contiguous_container`:
+//
+//   - `__sanitizer_annotate_contiguous_container` checks that `first` is aligned to an 8-byte boundary
+//   - if `end` is not aligned to an 8-byte boundary, `__sanitizer_annotate_contiguous_container` still poisons the
+//     remaining bytes in the shadow memory section.
+//
+// Because of the second property, we can only mark poison up to the final aligned address before the true `last`.
+// Otherwise, we'd poison the memory _after_ `last` as well.
+// For the first property, we can assume that everything before `first` in the shadow memory section is valid
+// (since otherwise we couldn't mark `first` valid), and so we just return back the first address in
+// `first`'s shadow memory section.
+//
+// ### Example
+//
+// ```cpp
+// struct alignas(8) cat {
+//     int meow; // bytes [0, 4)
+//     char buffer[16]; // bytes [4, 20)
+//     int purr; // bytes [20, 24)
+// };
+// ```
+//
+// First, `meow` and `purr` are just regular data members, not container buffers, so they _must_ be valid.
+// Then, assume we want to poison all of `buffer`.
+// This would mean that, in a perfect world, we want something like:
+//
+// ```
+//    |  meow |               buffer                | purr  |
+//   [ v v v v p p p p ][ p p p p p p p p ][ p p p p v v v v ]
+//           sm1                sm2                sm3
+// ```
+//
+// However, note that by the rules above, `sm3` is not a valid shadow memory section; we always need
+// the valid bytes to come before the poison bytes. Thus, the closest we can actually get to it is:
+//
+// ```
+//    |  meow |               buffer                | purr  |
+//   [ v v v v p p p p ][ p p p p p p p p ][ v v v v v v v v ]
+//           sm1                sm2                sm3
+// ```
+//
+// We call `aligned = _Get_asan_aligned_first_end(cat.buffer, cat.buffer + 16);`, and we get back
+//
+// ```cpp
+// aligned = {
+//     ._First = &cat.meow,
+//     ._End = cat.buffer + 12,
+// };
+// ```
+//
+// Then, we poison as much of buffer as we can via
+//
+// ```cpp
+// __sanitizer_annotate_contiguous_container(
+//     aligned._First,
+//     aligned._End,
+//     cat.buffer,
+//     aligned._Clamp_to_end(cat.buffer + 16));
+// ```
+//
+// We are allowed to assume that `&cat.meow` is valid, since otherwise `cat.buffer + [0, 4)` could not be valid.
+// We cannot poison up to `cat.buffer + 16`, since then `&purr` could not be valid.
+// Thus, this results in the shadow memory state from the second example.
+_NODISCARD inline _Asan_aligned_pointers _Get_asan_aligned_first_end(
+    const void* const _First, const void* const _End) noexcept {
+    return {
+        reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(_First) & ~_Asan_granularity_mask),
+        reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(_End) & ~_Asan_granularity_mask),
+    };
+}
+
+// When we can assume that the allocator we are using will always align allocations to the 8-byte,
+// we can simply push the `_End` pointer to the end of the shadow memory section.
+// This is _not_ safe in general (see _Get_asan_aligned_first_end's comment for why).
+_NODISCARD inline const void* _Get_asan_aligned_after(const void* const _End) noexcept {
+    return reinterpret_cast<const void*>(
+        (reinterpret_cast<uintptr_t>(_End) + _Asan_granularity_mask) & ~_Asan_granularity_mask);
+}
+
+template <class _Container, class = void>
+constexpr size_t _Container_allocation_minimum_asan_alignment = alignof(typename _Container::value_type);
+
+template <class _Container>
+constexpr size_t _Container_allocation_minimum_asan_alignment<_Container,
+    void_t<decltype(_Container::allocator_type::_Minimum_asan_allocation_alignment)>> =
+    (_STD max)(
+        alignof(typename _Container::value_type), _Container::allocator_type::_Minimum_asan_allocation_alignment);
+
+_EXPORT_STD template <class _Ty>
+class allocator {
+public:
+    static_assert(!is_const_v<_Ty>, "The C++ Standard forbids containers of const elements "
+                                    "because allocator<const T> is ill-formed.");
+    static_assert(!is_function_v<_Ty>, "The C++ Standard forbids allocators for function elements "
+                                       "because of [allocator.requirements].");
+    static_assert(!is_reference_v<_Ty>, "The C++ Standard forbids allocators for reference elements "
+                                        "because of [allocator.requirements].");
+
+    using _From_primary = allocator;
+
+    using value_type = _Ty;
+
+#if _HAS_DEPRECATED_ALLOCATOR_MEMBERS
+    using pointer _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS       = _Ty*;
+    using const_pointer _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS = const _Ty*;
+
+    using reference _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS       = _Ty&;
+    using const_reference _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS = const _Ty&;
+#endif // _HAS_DEPRECATED_ALLOCATOR_MEMBERS
+
+    using size_type       = size_t;
+    using difference_type = ptrdiff_t;
+
+    using propagate_on_container_move_assignment           = true_type;
+    using is_always_equal _CXX20_DEPRECATE_IS_ALWAYS_EQUAL = true_type;
+
+#if _HAS_DEPRECATED_ALLOCATOR_MEMBERS
+    template <class _Other>
+    struct _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS rebind {
+        using other = allocator<_Other>;
+    };
+
+    _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS _NODISCARD _Ty* address(_Ty& _Val) const noexcept {
+        return _STD addressof(_Val);
+    }
+
+    _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS _NODISCARD const _Ty* address(const _Ty& _Val) const noexcept {
+        return _STD addressof(_Val);
+    }
+#endif // _HAS_DEPRECATED_ALLOCATOR_MEMBERS
+
+    constexpr allocator() noexcept {}
+
+    constexpr allocator(const allocator&) noexcept = default;
+    template <class _Other>
+    constexpr allocator(const allocator<_Other>&) noexcept {}
+    _CONSTEXPR20 ~allocator()                           = default;
+    _CONSTEXPR20 allocator& operator=(const allocator&) = default;
+
+    _CONSTEXPR20 void deallocate(_Ty* const _Ptr, const size_t _Count) {
+        _STL_ASSERT(_Ptr != nullptr || _Count == 0, "null pointer cannot point to a block of non-zero size");
+        // no overflow check on the following multiply; we assume _Allocate did that check
+        _STD _Deallocate<_New_alignof<_Ty>>(_Ptr, sizeof(_Ty) * _Count);
+    }
+
+    _NODISCARD_RAW_PTR_ALLOC _CONSTEXPR20 __declspec(allocator) _Ty* allocate(_CRT_GUARDOVERFLOW const size_t _Count) {
+        static_assert(sizeof(value_type) > 0, "value_type must be complete before calling allocate.");
+        return static_cast<_Ty*>(_STD _Allocate<_New_alignof<_Ty>>(_Get_size_of_n<sizeof(_Ty)>(_Count)));
+    }
+
+#if _HAS_CXX23
+    _NODISCARD_RAW_PTR_ALLOC constexpr allocation_result<_Ty*> allocate_at_least(
+        _CRT_GUARDOVERFLOW const size_t _Count) {
+        return {allocate(_Count), _Count};
+    }
+#endif // _HAS_CXX23
+
+#if _HAS_DEPRECATED_ALLOCATOR_MEMBERS
+    _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS _NODISCARD_RAW_PTR_ALLOC __declspec(allocator) _Ty* allocate(
+        _CRT_GUARDOVERFLOW const size_t _Count, const void*) {
+        return allocate(_Count);
+    }
+
+    template <class _Objty, class... _Types>
+    _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS void construct(_Objty* const _Ptr, _Types&&... _Args) {
+        ::new (const_cast<void*>(static_cast<const volatile void*>(_Ptr))) _Objty(_STD forward<_Types>(_Args)...);
+    }
+
+    template <class _Uty>
+    _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS void destroy(_Uty* const _Ptr) {
+        _Ptr->~_Uty();
+    }
+
+    _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS _NODISCARD size_t max_size() const noexcept {
+        return static_cast<size_t>(-1) / sizeof(_Ty);
+    }
+#endif // _HAS_DEPRECATED_ALLOCATOR_MEMBERS
+
+    static constexpr size_t _Minimum_asan_allocation_alignment = _Asan_granularity;
+};
+
+#if _HAS_DEPRECATED_ALLOCATOR_VOID || _HAS_DEPRECATED_ALLOCATOR_MEMBERS
+template <>
+class allocator<void> {
+public:
+    using value_type = void;
+#if _HAS_DEPRECATED_ALLOCATOR_MEMBERS
+    using pointer _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS       = void*;
+    using const_pointer _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS = const void*;
+
+    template <class _Other>
+    struct _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS rebind {
+        using other = allocator<_Other>;
+    };
+#endif // _HAS_DEPRECATED_ALLOCATOR_MEMBERS
+
+#if _HAS_CXX20
+    using size_type       = size_t;
+    using difference_type = ptrdiff_t;
+
+    using propagate_on_container_move_assignment           = true_type;
+    using is_always_equal _CXX20_DEPRECATE_IS_ALWAYS_EQUAL = true_type;
+#endif // _HAS_CXX20
+};
+#endif // _HAS_DEPRECATED_ALLOCATOR_VOID || _HAS_DEPRECATED_ALLOCATOR_MEMBERS
+
+_EXPORT_STD template <class _Ty, class _Other>
+_NODISCARD _CONSTEXPR20 bool operator==(const allocator<_Ty>&, const allocator<_Other>&) noexcept {
+    return true;
+}
+
+#if !_HAS_CXX20
+template <class _Ty, class _Other>
+_NODISCARD bool operator!=(const allocator<_Ty>&, const allocator<_Other>&) noexcept {
+    return false;
+}
+#endif // !_HAS_CXX20
+
+#if _HAS_CXX17
+// See N4950 [unord.map.overview]/4
+template <class _Alloc>
+using _Guide_size_type_t =
+    typename allocator_traits<conditional_t<_Is_allocator<_Alloc>::value, _Alloc, allocator<int>>>::size_type;
+#endif // _HAS_CXX17
+
+template <class _Alloc>
+using _Alloc_ptr_t = typename allocator_traits<_Alloc>::pointer;
+
+template <class _Alloc>
+using _Alloc_size_t = typename allocator_traits<_Alloc>::size_type;
+
+template <class _Alloc>
+_CONSTEXPR20 void _Pocca(_Alloc& _Left, const _Alloc& _Right) noexcept {
+    if constexpr (allocator_traits<_Alloc>::propagate_on_container_copy_assignment::value) {
+        _Left = _Right;
+    }
+}
+
+template <class _Alloc>
+_CONSTEXPR20 void _Pocma(_Alloc& _Left, _Alloc& _Right) noexcept { // (maybe) propagate on container move assignment
+    if constexpr (allocator_traits<_Alloc>::propagate_on_container_move_assignment::value) {
+        _Left = _STD move(_Right);
+    }
+}
+
+template <class _Alloc>
+_CONSTEXPR20 void _Pocs(_Alloc& _Left, _Alloc& _Right) noexcept {
+    if constexpr (allocator_traits<_Alloc>::propagate_on_container_swap::value) {
+        swap(_Left, _Right); // intentional ADL
+    } else {
+        _STL_ASSERT(_Left == _Right, "containers incompatible for swap");
+    }
+}
+
+template <class _Alloc>
+_CONSTEXPR20 void _Destroy_range(_Alloc_ptr_t<_Alloc> _First, const _Alloc_ptr_t<_Alloc> _Last, _Alloc& _Al) noexcept {
+    // note that this is an optimization for debug mode codegen; in release mode the BE removes all of this
+    using _Ty = typename _Alloc::value_type;
+    if constexpr (!conjunction_v<is_trivially_destructible<_Ty>, _Uses_default_destroy<_Alloc, _Ty*>>) {
+        for (; _First != _Last; ++_First) {
+            allocator_traits<_Alloc>::destroy(_Al, _STD _Unfancy(_First));
+        }
+    }
+}
+
+template <class _NoThrowFwdIt, class _NoThrowSentinel>
+_CONSTEXPR20 void _Destroy_range(_NoThrowFwdIt _First, const _NoThrowSentinel _Last) noexcept {
+    // note that this is an optimization for debug mode codegen; in release mode the BE removes all of this
+    if constexpr (!is_trivially_destructible_v<_Iter_value_t<_NoThrowFwdIt>>) {
+        for (; _First != _Last; ++_First) {
+            _STD _Destroy_in_place(*_First);
+        }
+    }
+}
+
+template <class _Size_type, class _Unsigned_type>
+_NODISCARD constexpr _Size_type _Convert_size(const _Unsigned_type _Len) noexcept(
+    sizeof(_Unsigned_type) <= sizeof(_Size_type)) {
+    // convert _Unsigned_type to _Size_type, avoiding truncation
+    _STL_INTERNAL_STATIC_ASSERT(_Unsigned_type(-1) > 0);
+    _STL_INTERNAL_STATIC_ASSERT(_Size_type(-1) > 0);
+
+    if constexpr (sizeof(_Unsigned_type) > sizeof(_Size_type)) {
+        if (_Len > _STD _Max_limit<_Size_type>()) {
+            _Xlength_error("size is too long for _Size_type");
+        }
+    }
+
+    return static_cast<_Size_type>(_Len);
+}
+
+template <class _Alloc>
+_CONSTEXPR20 void _Deallocate_plain(_Alloc& _Al, typename _Alloc::value_type* const _Ptr) noexcept {
+    // deallocate a plain pointer using an allocator
+    using _Alloc_traits = allocator_traits<_Alloc>;
+    if constexpr (is_same_v<_Alloc_ptr_t<_Alloc>, typename _Alloc::value_type*>) {
+        _Alloc_traits::deallocate(_Al, _Ptr, 1);
+    } else {
+        using _Ptr_traits = pointer_traits<_Alloc_ptr_t<_Alloc>>;
+        _Alloc_traits::deallocate(_Al, _Ptr_traits::pointer_to(*_Ptr), 1);
+    }
+}
+
+template <class _Alloc>
+_CONSTEXPR20 void _Delete_plain_internal(_Alloc& _Al, typename _Alloc::value_type* const _Ptr) noexcept {
+    // destroy *_Ptr in place, then deallocate _Ptr using _Al; used for internal container types the user didn't name
+    using _Ty = typename _Alloc::value_type;
+    _Ptr->~_Ty();
+    _STD _Deallocate_plain(_Al, _Ptr);
+}
+
+template <class _Alloc>
+struct _Alloc_construct_ptr { // pointer used to help construct 1 _Alloc::value_type without EH
+    using pointer = _Alloc_ptr_t<_Alloc>;
+    _Alloc& _Al;
+    pointer _Ptr;
+
+    _CONSTEXPR20 explicit _Alloc_construct_ptr(_Alloc& _Al_) : _Al(_Al_), _Ptr(nullptr) {}
+
+    _NODISCARD _CONSTEXPR20 pointer _Release() noexcept { // disengage *this and return contained pointer
+        return _STD exchange(_Ptr, nullptr);
+    }
+
+    _CONSTEXPR20 void _Allocate() { // disengage *this, then allocate a new memory block
+        _Ptr = nullptr; // if allocate throws, prevents double-free
+        _Ptr = _Al.allocate(1);
+    }
+
+    _CONSTEXPR20 ~_Alloc_construct_ptr() { // if this instance is engaged, deallocate storage
+        if (_Ptr) {
+            _Al.deallocate(_Ptr, 1);
+        }
+    }
+
+    _Alloc_construct_ptr(const _Alloc_construct_ptr&)            = delete;
+    _Alloc_construct_ptr& operator=(const _Alloc_construct_ptr&) = delete;
+};
+
+struct _Fake_allocator {};
+
+struct _Container_base0 {
+    _CONSTEXPR20 void _Orphan_all() noexcept {}
+    _CONSTEXPR20 void _Swap_proxy_and_iterators(_Container_base0&) noexcept {}
+    _CONSTEXPR20 void _Alloc_proxy(const _Fake_allocator&) noexcept {}
+    _CONSTEXPR20 void _Reload_proxy(const _Fake_allocator&, const _Fake_allocator&) noexcept {}
+};
+
+struct _Iterator_base0 {
+    _CONSTEXPR20 void _Adopt(const void*) noexcept {}
+    _CONSTEXPR20 const _Container_base0* _Getcont() const noexcept {
+        return nullptr;
+    }
+
+    static constexpr bool _Unwrap_when_unverified = true;
+};
+
+struct _Container_base12;
+struct _Container_proxy { // store head of iterator chain and back pointer
+    _CONSTEXPR20 _Container_proxy() noexcept = default;
+    _CONSTEXPR20 _Container_proxy(_Container_base12* _Mycont_) noexcept : _Mycont(_Mycont_) {}
+
+    const _Container_base12* _Mycont       = nullptr;
+    mutable _Iterator_base12* _Myfirstiter = nullptr;
+};
+
+struct _Container_base12 {
+public:
+    _CONSTEXPR20 _Container_base12() noexcept = default;
+
+    _Container_base12(const _Container_base12&)            = delete;
+    _Container_base12& operator=(const _Container_base12&) = delete;
+
+    _CONSTEXPR20 void _Orphan_all() noexcept;
+    _CONSTEXPR20 void _Swap_proxy_and_iterators(_Container_base12&) noexcept;
+
+    template <class _Alloc>
+    _CONSTEXPR20 void _Alloc_proxy(_Alloc&& _Al) {
+        _Container_proxy* const _New_proxy = _Unfancy(_Al.allocate(1));
+        _Construct_in_place(*_New_proxy, this);
+        _Myproxy            = _New_proxy;
+        _New_proxy->_Mycont = this;
+    }
+
+    template <class _Alloc>
+    _CONSTEXPR20 void _Reload_proxy(_Alloc&& _Old_alloc, _Alloc&& _New_alloc) {
+        // pre: no iterators refer to the existing proxy
+        _Container_proxy* const _New_proxy = _Unfancy(_New_alloc.allocate(1));
+        _Construct_in_place(*_New_proxy, this);
+        _New_proxy->_Mycont = this;
+        _Delete_plain_internal(_Old_alloc, _STD exchange(_Myproxy, _New_proxy));
+    }
+
+    _Container_proxy* _Myproxy = nullptr;
+
+private:
+    _CONSTEXPR20 void _Orphan_all_unlocked_v3() noexcept;
+    _CONSTEXPR20 void _Swap_proxy_and_iterators_unlocked(_Container_base12&) noexcept;
+
+    void _Orphan_all_locked_v3() noexcept {
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Orphan_all_unlocked_v3();
+    }
+
+    void _Swap_proxy_and_iterators_locked(_Container_base12& _Right) noexcept {
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Swap_proxy_and_iterators_unlocked(_Right);
+    }
+};
+
+struct _Iterator_base12 { // store links to container proxy, next iterator
+public:
+    _CONSTEXPR20 _Iterator_base12() noexcept = default; // construct orphaned iterator
+
+    _CONSTEXPR20 _Iterator_base12(const _Iterator_base12& _Right) noexcept {
+        *this = _Right;
+    }
+
+    _CONSTEXPR20 _Iterator_base12& operator=(const _Iterator_base12& _Right) noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 2
+#if _HAS_CXX20
+        if (_STD is_constant_evaluated()) {
+            _Assign_unlocked(_Right);
+        } else
+#endif // _HAS_CXX20
+        {
+            _Assign_locked(_Right);
+        }
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 2 / _ITERATOR_DEBUG_LEVEL != 2 vvv
+        _Myproxy = _Right._Myproxy;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 2 ^^^
+        return *this;
+    }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+    _CONSTEXPR20 ~_Iterator_base12() noexcept {
+#if _HAS_CXX20
+        if (_STD is_constant_evaluated()) {
+            _Orphan_me_unlocked_v3();
+        } else
+#endif // _HAS_CXX20
+        {
+            _Orphan_me_locked_v3();
+        }
+    }
+
+    _CONSTEXPR20 void _Adopt(const _Container_base12* _Parent) noexcept {
+#if _HAS_CXX20
+        if (_STD is_constant_evaluated()) {
+            _Adopt_unlocked(_Parent);
+        } else
+#endif // _HAS_CXX20
+        {
+            _Adopt_locked(_Parent);
+        }
+    }
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 2 / _ITERATOR_DEBUG_LEVEL != 2 vvv
+    _CONSTEXPR20 void _Adopt(const _Container_base12* _Parent) noexcept {
+        if (_Parent) { // have a parent, do adoption
+            _Myproxy = _Parent->_Myproxy;
+        } else { // no future parent, just disown current parent
+            _Myproxy = nullptr;
+        }
+    }
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 2 ^^^
+
+    _CONSTEXPR20 const _Container_base12* _Getcont() const noexcept {
+        return _Myproxy ? _Myproxy->_Mycont : nullptr;
+    }
+
+    static constexpr bool _Unwrap_when_unverified = _ITERATOR_DEBUG_LEVEL == 0;
+
+    mutable _Container_proxy* _Myproxy    = nullptr;
+    mutable _Iterator_base12* _Mynextiter = nullptr;
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+private:
+    _CONSTEXPR20 void _Assign_unlocked(const _Iterator_base12& _Right) noexcept {
+        if (_Myproxy == _Right._Myproxy) {
+            return;
+        }
+
+        if (_Right._Myproxy) {
+            _Adopt_unlocked(_Right._Myproxy->_Mycont);
+        } else { // becoming invalid, disown current parent
+            _Orphan_me_unlocked_v3();
+        }
+    }
+
+    void _Assign_locked(const _Iterator_base12& _Right) noexcept {
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Assign_unlocked(_Right);
+    }
+
+    _CONSTEXPR20 void _Adopt_unlocked(const _Container_base12* _Parent) noexcept {
+        if (!_Parent) {
+            _Orphan_me_unlocked_v3();
+            return;
+        }
+
+        _Container_proxy* _Parent_proxy = _Parent->_Myproxy;
+        if (_Myproxy != _Parent_proxy) { // change parentage
+            if (_Myproxy) { // adopted, remove self from list
+                _Orphan_me_unlocked_v3();
+            }
+            _Mynextiter                 = _Parent_proxy->_Myfirstiter;
+            _Parent_proxy->_Myfirstiter = this;
+            _Myproxy                    = _Parent_proxy;
+        }
+    }
+
+    void _Adopt_locked(const _Container_base12* _Parent) noexcept {
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Adopt_unlocked(_Parent);
+    }
+
+    _CONSTEXPR20 void _Orphan_me_unlocked_v3() noexcept {
+        if (!_Myproxy) { // already orphaned
+            return;
+        }
+
+        // adopted, remove self from list
+        _Iterator_base12** _Pnext = &_Myproxy->_Myfirstiter;
+        while (*_Pnext && *_Pnext != this) {
+            _Pnext = &(*_Pnext)->_Mynextiter;
+        }
+
+        _STL_VERIFY(*_Pnext, "ITERATOR LIST CORRUPTED!");
+        *_Pnext  = _Mynextiter;
+        _Myproxy = nullptr;
+    }
+
+    void _Orphan_me_locked_v3() noexcept {
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Orphan_me_unlocked_v3();
+    }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+};
+
+_CONSTEXPR20 void _Container_base12::_Orphan_all_unlocked_v3() noexcept {
+    if (!_Myproxy) { // no proxy, already done
+        return;
+    }
+
+    // proxy allocated, drain it
+    for (auto _Pnext = _STD exchange(_Myproxy->_Myfirstiter, nullptr); _Pnext; _Pnext = _Pnext->_Mynextiter) {
+        _Pnext->_Myproxy = nullptr;
+    }
+}
+
+_CONSTEXPR20 void _Container_base12::_Orphan_all() noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 2
+#if _HAS_CXX20
+    if (_STD is_constant_evaluated()) {
+        _Orphan_all_unlocked_v3();
+    } else
+#endif // _HAS_CXX20
+    {
+        _Orphan_all_locked_v3();
+    }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+}
+
+_CONSTEXPR20 void _Container_base12::_Swap_proxy_and_iterators_unlocked(_Container_base12& _Right) noexcept {
+    _Container_proxy* _Temp = _Myproxy;
+    _Myproxy                = _Right._Myproxy;
+    _Right._Myproxy         = _Temp;
+
+    if (_Myproxy) {
+        _Myproxy->_Mycont = this;
+    }
+
+    if (_Right._Myproxy) {
+        _Right._Myproxy->_Mycont = &_Right;
+    }
+}
+
+_CONSTEXPR20 void _Container_base12::_Swap_proxy_and_iterators(_Container_base12& _Right) noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 2
+#if _HAS_CXX20
+    if (_STD is_constant_evaluated()) {
+        _Swap_proxy_and_iterators_unlocked(_Right);
+    } else
+#endif // _HAS_CXX20
+    {
+        _Swap_proxy_and_iterators_locked(_Right);
+    }
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 2 / _ITERATOR_DEBUG_LEVEL != 2 vvv
+    _Swap_proxy_and_iterators_unlocked(_Right);
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 2 ^^^
+}
+
+#if _ITERATOR_DEBUG_LEVEL == 0
+using _Container_base = _Container_base0;
+using _Iterator_base  = _Iterator_base0;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 0 / _ITERATOR_DEBUG_LEVEL > 0 vvv
+using _Container_base = _Container_base12;
+using _Iterator_base  = _Iterator_base12;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL > 0 ^^^
+
+struct _Leave_proxy_unbound {
+    explicit _Leave_proxy_unbound() = default;
+}; // tag to indicate that a proxy is being allocated before it is safe to bind to a _Container_base12
+
+struct _Fake_proxy_ptr_impl { // fake replacement for a container proxy smart pointer when no container proxy is in use
+    _Fake_proxy_ptr_impl(const _Fake_proxy_ptr_impl&)            = delete;
+    _Fake_proxy_ptr_impl& operator=(const _Fake_proxy_ptr_impl&) = delete;
+    _CONSTEXPR20 _Fake_proxy_ptr_impl(const _Fake_allocator&, _Leave_proxy_unbound) noexcept {}
+    _CONSTEXPR20 _Fake_proxy_ptr_impl(const _Fake_allocator&, const _Container_base0&) noexcept {}
+
+    _CONSTEXPR20 void _Bind(const _Fake_allocator&, _Container_base0*) noexcept {}
+    _CONSTEXPR20 void _Release() noexcept {}
+};
+
+struct _Basic_container_proxy_ptr12 {
+    // smart pointer components for a _Container_proxy * that don't depend on the allocator
+    _Container_proxy* _Ptr = nullptr;
+
+    constexpr void _Release() noexcept { // disengage this _Basic_container_proxy_ptr12
+        _Ptr = nullptr;
+    }
+
+protected:
+    _CONSTEXPR20 _Basic_container_proxy_ptr12()                       = default;
+    _Basic_container_proxy_ptr12(const _Basic_container_proxy_ptr12&) = delete;
+    _Basic_container_proxy_ptr12(_Basic_container_proxy_ptr12&&)      = delete;
+};
+
+template <class _Alloc>
+struct _Container_proxy_ptr12 : _Basic_container_proxy_ptr12 {
+    // smart pointer components for a _Container_proxy * for an allocator family
+    _Alloc& _Al;
+
+    _CONSTEXPR20 _Container_proxy_ptr12(_Alloc& _Al_, _Leave_proxy_unbound) : _Al(_Al_) {
+        // create a new unbound _Container_proxy
+        _Ptr = _Unfancy(_Al_.allocate(1));
+        _Construct_in_place(*_Ptr);
+    }
+
+    _CONSTEXPR20 _Container_proxy_ptr12(_Alloc& _Al_, _Container_base12& _Mycont) : _Al(_Al_) {
+        // create a new _Container_proxy pointing at _Mycont
+        _Ptr = _Unfancy(_Al_.allocate(1));
+        _Construct_in_place(*_Ptr, _STD addressof(_Mycont));
+        _Mycont._Myproxy = _Ptr;
+    }
+
+    _CONSTEXPR20 void _Bind(_Alloc& _Old_alloc, _Container_base12* _Mycont) noexcept {
+        // Attach the proxy stored in *this to _Mycont, and destroy _Mycont's existing proxy
+        // with _Old_alloc. Requires that no iterators are alive referring to _Mycont.
+        _Ptr->_Mycont = _Mycont;
+        _Delete_plain_internal(_Old_alloc, _STD exchange(_Mycont->_Myproxy, _STD exchange(_Ptr, nullptr)));
+    }
+
+    _CONSTEXPR20 ~_Container_proxy_ptr12() {
+        if (_Ptr) {
+            _Delete_plain_internal(_Al, _Ptr);
+        }
+    }
+};
+
+#if _ITERATOR_DEBUG_LEVEL == 0
+_INLINE_VAR constexpr _Fake_allocator _Fake_alloc{};
+#define _GET_PROXY_ALLOCATOR(_Alty, _Al) _Fake_alloc // TRANSITION, VSO-1284799, should be _Fake_allocator{}
+template <class _Alloc>
+using _Container_proxy_ptr = _Fake_proxy_ptr_impl;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 0 / _ITERATOR_DEBUG_LEVEL > 0 vvv
+#define _GET_PROXY_ALLOCATOR(_Alty, _Al) static_cast<_Rebind_alloc_t<_Alty, _Container_proxy>>(_Al)
+template <class _Alloc>
+using _Container_proxy_ptr = _Container_proxy_ptr12<_Rebind_alloc_t<_Alloc, _Container_proxy>>;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL > 0 ^^^
+
+struct _Zero_then_variadic_args_t {
+    explicit _Zero_then_variadic_args_t() = default;
+}; // tag type for value-initializing first, constructing second from remaining args
+
+struct _One_then_variadic_args_t {
+    explicit _One_then_variadic_args_t() = default;
+}; // tag type for constructing first from one arg, constructing second from remaining args
+
+template <class _Ty1, class _Ty2, bool = is_empty_v<_Ty1> && !is_final_v<_Ty1>>
+class _Compressed_pair final : private _Ty1 { // store a pair of values, deriving from empty first
+public:
+    _Ty2 _Myval2;
+
+    using _Mybase = _Ty1; // for visualization
+
+    template <class... _Other2>
+    constexpr explicit _Compressed_pair(_Zero_then_variadic_args_t, _Other2&&... _Val2) noexcept(
+        conjunction_v<is_nothrow_default_constructible<_Ty1>, is_nothrow_constructible<_Ty2, _Other2...>>)
+        : _Ty1(), _Myval2(_STD forward<_Other2>(_Val2)...) {}
+
+    template <class _Other1, class... _Other2>
+    constexpr _Compressed_pair(_One_then_variadic_args_t, _Other1&& _Val1, _Other2&&... _Val2) noexcept(
+        conjunction_v<is_nothrow_constructible<_Ty1, _Other1>, is_nothrow_constructible<_Ty2, _Other2...>>)
+        : _Ty1(_STD forward<_Other1>(_Val1)), _Myval2(_STD forward<_Other2>(_Val2)...) {}
+
+    constexpr _Ty1& _Get_first() noexcept {
+        return *this;
+    }
+
+    constexpr const _Ty1& _Get_first() const noexcept {
+        return *this;
+    }
+};
+
+template <class _Ty1, class _Ty2>
+class _Compressed_pair<_Ty1, _Ty2, false> final { // store a pair of values, not deriving from first
+public:
+    _Ty1 _Myval1;
+    _Ty2 _Myval2;
+
+    template <class... _Other2>
+    constexpr explicit _Compressed_pair(_Zero_then_variadic_args_t, _Other2&&... _Val2) noexcept(
+        conjunction_v<is_nothrow_default_constructible<_Ty1>, is_nothrow_constructible<_Ty2, _Other2...>>)
+        : _Myval1(), _Myval2(_STD forward<_Other2>(_Val2)...) {}
+
+    template <class _Other1, class... _Other2>
+    constexpr _Compressed_pair(_One_then_variadic_args_t, _Other1&& _Val1, _Other2&&... _Val2) noexcept(
+        conjunction_v<is_nothrow_constructible<_Ty1, _Other1>, is_nothrow_constructible<_Ty2, _Other2...>>)
+        : _Myval1(_STD forward<_Other1>(_Val1)), _Myval2(_STD forward<_Other2>(_Val2)...) {}
+
+    constexpr _Ty1& _Get_first() noexcept {
+        return _Myval1;
+    }
+
+    constexpr const _Ty1& _Get_first() const noexcept {
+        return _Myval1;
+    }
+};
+
+struct _Move_allocator_tag {
+    explicit _Move_allocator_tag() = default;
+};
+
+template <class _Ty>
+pair<_Ty*, ptrdiff_t> _Get_temporary_buffer(ptrdiff_t _Count) noexcept {
+    if (static_cast<size_t>(_Count) <= static_cast<size_t>(-1) / sizeof(_Ty)) {
+        for (; 0 < _Count; _Count /= 2) {
+            const auto _Size = static_cast<size_t>(_Count) * sizeof(_Ty);
+            void* _Pbuf;
+#ifdef __cpp_aligned_new
+            if constexpr (alignof(_Ty) > __STDCPP_DEFAULT_NEW_ALIGNMENT__) {
+                _Pbuf = ::operator new(_Size, align_val_t{alignof(_Ty)}, nothrow);
+            } else
+#endif // defined(__cpp_aligned_new)
+            {
+                _Pbuf = ::operator new(_Size, nothrow);
+            }
+
+            if (_Pbuf) {
+                return {static_cast<_Ty*>(_Pbuf), _Count};
+            }
+        }
+    }
+
+    return {nullptr, 0};
+}
+
+template <class _Ty>
+void _Return_temporary_buffer(_Ty* const _Pbuf) noexcept {
+#ifdef __cpp_aligned_new
+    if constexpr (alignof(_Ty) > __STDCPP_DEFAULT_NEW_ALIGNMENT__) {
+        ::operator delete(_Pbuf, align_val_t{alignof(_Ty)});
+    } else
+#endif // defined(__cpp_aligned_new)
+    {
+        ::operator delete(_Pbuf);
+    }
+}
+
+template <class _NoThrowFwdIt>
+struct _NODISCARD _Uninitialized_backout {
+    // struct to undo partially constructed ranges in _Uninitialized_xxx algorithms
+    _NoThrowFwdIt _First;
+    _NoThrowFwdIt _Last;
+
+    constexpr explicit _Uninitialized_backout(_NoThrowFwdIt _Dest) : _First(_Dest), _Last(_Dest) {}
+
+    constexpr _Uninitialized_backout(_NoThrowFwdIt _First_, _NoThrowFwdIt _Last_) : _First(_First_), _Last(_Last_) {}
+
+    _Uninitialized_backout(const _Uninitialized_backout&)            = delete;
+    _Uninitialized_backout& operator=(const _Uninitialized_backout&) = delete;
+
+    _CONSTEXPR20 ~_Uninitialized_backout() {
+        _STD _Destroy_range(_First, _Last);
+    }
+
+    template <class... _Types>
+    _CONSTEXPR20 void _Emplace_back(_Types&&... _Vals) {
+        // construct a new element at *_Last and increment
+        _STD _Construct_in_place(*_Last, _STD forward<_Types>(_Vals)...);
+        ++_Last;
+    }
+
+    constexpr _NoThrowFwdIt _Release() { // suppress any exception handling backout and return _Last
+        _First = _Last;
+        return _Last;
+    }
+};
+
+template <class _InIt, class _NoThrowFwdIt>
+_CONSTEXPR20 _NoThrowFwdIt _Uninitialized_move_unchecked(_InIt _First, const _InIt _Last, _NoThrowFwdIt _Dest) {
+    // move [_First, _Last) to raw [_Dest, ...)
+    if constexpr (_Iter_move_cat<_InIt, _NoThrowFwdIt>::_Bitcopy_constructible) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            return _STD _Copy_memmove(_First, _Last, _Dest);
+        }
+    }
+    _Uninitialized_backout<_NoThrowFwdIt> _Backout{_Dest};
+    for (; _First != _Last; ++_First) {
+        _Backout._Emplace_back(_STD move(*_First));
+    }
+
+    return _Backout._Release();
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    template <class _It>
+    concept _No_throw_input_iterator =
+        input_iterator<_It> && is_lvalue_reference_v<iter_reference_t<_It>>
+        && same_as<remove_cvref_t<iter_reference_t<_It>>, remove_reference_t<iter_reference_t<_It>>> // per LWG-3888
+        && same_as<remove_cvref_t<iter_reference_t<_It>>, iter_value_t<_It>>;
+
+    template <class _Se, class _It>
+    concept _No_throw_sentinel_for = sentinel_for<_Se, _It>;
+
+    template <class _It>
+    concept _No_throw_forward_iterator =
+        _No_throw_input_iterator<_It> && forward_iterator<_It> && _No_throw_sentinel_for<_It, _It>;
+
+    template <class _Rng>
+    concept _No_throw_input_range = range<_Rng> && _No_throw_input_iterator<iterator_t<_Rng>>
+                                 && _No_throw_sentinel_for<sentinel_t<_Rng>, iterator_t<_Rng>>;
+
+    template <class _Rng>
+    concept _No_throw_forward_range = _No_throw_input_range<_Rng> && _No_throw_forward_iterator<iterator_t<_Rng>>;
+
+    template <class _InIt, class _OutIt>
+    in_out_result<_InIt, _OutIt> _Copy_memcpy_count(_InIt _IFirst, _OutIt _OFirst, const size_t _Count) noexcept {
+        const auto _IFirstPtr     = _STD _To_address(_IFirst);
+        const auto _OFirstPtr     = _STD _To_address(_OFirst);
+        const auto _IFirst_ch     = const_cast<char*>(reinterpret_cast<const volatile char*>(_IFirstPtr));
+        const auto _OFirst_ch     = const_cast<char*>(reinterpret_cast<const volatile char*>(_OFirstPtr));
+        const size_t _Count_bytes = _Count * sizeof(iter_value_t<_InIt>);
+        _CSTD memcpy(_OFirst_ch, _IFirst_ch, _Count_bytes);
+        if constexpr (is_pointer_v<_InIt>) {
+            _IFirst = reinterpret_cast<_InIt>(_IFirst_ch + _Count_bytes);
+        } else {
+            _IFirst += static_cast<iter_difference_t<_InIt>>(_Count);
+        }
+
+        if constexpr (is_pointer_v<_OutIt>) {
+            _OFirst = reinterpret_cast<_OutIt>(_OFirst_ch + _Count_bytes);
+        } else {
+            _OFirst += static_cast<iter_difference_t<_OutIt>>(_Count);
+        }
+        return {_STD move(_IFirst), _STD move(_OFirst)};
+    }
+
+    template <class _InIt, class _OutIt, class _DistIt>
+    in_out_result<_InIt, _OutIt> _Copy_memcpy_distance(
+        _InIt _IFirst, _OutIt _OFirst, const _DistIt _DFirst, const _DistIt _DLast) noexcept {
+        // equivalent to _Copy_memcpy_count(_IFirst, _OFirst, _DLast - _DFirst) but computes distance more efficiently
+        const auto _IFirstPtr   = _STD _To_address(_IFirst);
+        const auto _OFirstPtr   = _STD _To_address(_OFirst);
+        const auto _DFirstPtr   = _STD _To_address(_DFirst);
+        const auto _DLastPtr    = _STD _To_address(_DLast);
+        const auto _IFirst_ch   = const_cast<char*>(reinterpret_cast<const volatile char*>(_IFirstPtr));
+        const auto _OFirst_ch   = const_cast<char*>(reinterpret_cast<const volatile char*>(_OFirstPtr));
+        const auto _DFirst_ch   = const_cast<char*>(reinterpret_cast<const volatile char*>(_DFirstPtr));
+        const auto _DLast_ch    = const_cast<char*>(reinterpret_cast<const volatile char*>(_DLastPtr));
+        const auto _Count_bytes = static_cast<size_t>(_DLast_ch - _DFirst_ch);
+        _CSTD memcpy(_OFirst_ch, _IFirst_ch, _Count_bytes);
+        if constexpr (is_pointer_v<_InIt>) {
+            _IFirst = reinterpret_cast<_InIt>(_IFirst_ch + _Count_bytes);
+        } else {
+            _IFirst += _Count_bytes / sizeof(iter_value_t<_InIt>);
+        }
+
+        if constexpr (is_pointer_v<_OutIt>) {
+            _OFirst = reinterpret_cast<_OutIt>(_OFirst_ch + _Count_bytes);
+        } else {
+            _OFirst += _Count_bytes / sizeof(iter_value_t<_OutIt>);
+        }
+        return {_STD move(_IFirst), _STD move(_OFirst)};
+    }
+
+    template <class _InIt, class _OutIt>
+    in_out_result<_InIt, _OutIt> _Copy_memcpy_common(
+        _InIt _IFirst, _InIt _ILast, _OutIt _OFirst, _OutIt _OLast) noexcept {
+        const auto _IFirstPtr   = _STD _To_address(_IFirst);
+        const auto _ILastPtr    = _STD _To_address(_ILast);
+        const auto _OFirstPtr   = _STD _To_address(_OFirst);
+        const auto _OLastPtr    = _STD _To_address(_OLast);
+        const auto _IFirst_ch   = const_cast<char*>(reinterpret_cast<const volatile char*>(_IFirstPtr));
+        const auto _ILast_ch    = const_cast<const char*>(reinterpret_cast<const volatile char*>(_ILastPtr));
+        const auto _OFirst_ch   = const_cast<char*>(reinterpret_cast<const volatile char*>(_OFirstPtr));
+        const auto _OLast_ch    = const_cast<const char*>(reinterpret_cast<const volatile char*>(_OLastPtr));
+        const auto _Count_bytes = static_cast<size_t>((_STD min)(_ILast_ch - _IFirst_ch, _OLast_ch - _OFirst_ch));
+        _CSTD memcpy(_OFirst_ch, _IFirst_ch, _Count_bytes);
+        if constexpr (is_pointer_v<_InIt>) {
+            _IFirst = reinterpret_cast<_InIt>(_IFirst_ch + _Count_bytes);
+        } else {
+            _IFirst += static_cast<iter_difference_t<_InIt>>(_Count_bytes / sizeof(iter_value_t<_InIt>));
+        }
+
+        if constexpr (is_pointer_v<_OutIt>) {
+            _OFirst = reinterpret_cast<_OutIt>(_OFirst_ch + _Count_bytes);
+        } else {
+            _OFirst += static_cast<iter_difference_t<_OutIt>>(_Count_bytes / sizeof(iter_value_t<_OutIt>));
+        }
+        return {_STD move(_IFirst), _STD move(_OFirst)};
+    }
+
+    _EXPORT_STD template <class _In, class _Out>
+    using uninitialized_move_result = in_out_result<_In, _Out>;
+
+    template <input_iterator _It, sentinel_for<_It> _Se, _No_throw_forward_iterator _Out,
+        _No_throw_sentinel_for<_Out> _OSe>
+        requires (constructible_from<iter_value_t<_Out>, iter_rvalue_reference_t<_It>>)
+    uninitialized_move_result<_It, _Out> _Uninitialized_move_unchecked(
+        _It _IFirst, _Se _ILast, _Out _OFirst, _OSe _OLast) {
+        constexpr bool _Is_sized1 = sized_sentinel_for<_Se, _It>;
+        constexpr bool _Is_sized2 = sized_sentinel_for<_OSe, _Out>;
+        if constexpr (_Iter_move_cat<_It, _Out>::_Bitcopy_constructible && _Sized_or_unreachable_sentinel_for<_Se, _It>
+                      && _Sized_or_unreachable_sentinel_for<_OSe, _Out>) {
+            if constexpr (_Is_sized1 && _Is_sized2) {
+                return _RANGES _Copy_memcpy_common(_IFirst, _RANGES next(_IFirst, _STD move(_ILast)), _OFirst,
+                    _RANGES next(_OFirst, _STD move(_OLast)));
+            } else if constexpr (_Is_sized1) {
+                return _RANGES _Copy_memcpy_distance(
+                    _IFirst, _OFirst, _IFirst, _RANGES next(_IFirst, _STD move(_ILast)));
+            } else if constexpr (_Is_sized2) {
+                return _RANGES _Copy_memcpy_distance(
+                    _IFirst, _OFirst, _OFirst, _RANGES next(_OFirst, _STD move(_OLast)));
+            } else {
+                _STL_ASSERT(false, "Tried to uninitialized_move two ranges with unreachable sentinels");
+            }
+        } else {
+            _Uninitialized_backout _Backout{_STD move(_OFirst)};
+
+            for (; _IFirst != _ILast && _Backout._Last != _OLast; ++_IFirst) {
+                _Backout._Emplace_back(_RANGES iter_move(_IFirst));
+            }
+
+            return {_STD move(_IFirst), _Backout._Release()};
+        }
+    }
+} // namespace ranges
+#endif // _HAS_CXX20
+
+template <class _Alloc>
+class _NODISCARD _Uninitialized_backout_al {
+    // struct to undo partially constructed ranges in _Uninitialized_xxx_al algorithms
+private:
+    using pointer = _Alloc_ptr_t<_Alloc>;
+
+public:
+    _CONSTEXPR20 _Uninitialized_backout_al(pointer _Dest, _Alloc& _Al_) : _First(_Dest), _Last(_Dest), _Al(_Al_) {}
+
+    _Uninitialized_backout_al(const _Uninitialized_backout_al&)            = delete;
+    _Uninitialized_backout_al& operator=(const _Uninitialized_backout_al&) = delete;
+
+    _CONSTEXPR20 ~_Uninitialized_backout_al() {
+        _STD _Destroy_range(_First, _Last, _Al);
+    }
+
+    template <class... _Types>
+    _CONSTEXPR20 void _Emplace_back(_Types&&... _Vals) { // construct a new element at *_Last and increment
+        allocator_traits<_Alloc>::construct(_Al, _STD _Unfancy(_Last), _STD forward<_Types>(_Vals)...);
+        ++_Last;
+    }
+
+    constexpr pointer _Release() { // suppress any exception handling backout and return _Last
+        _First = _Last;
+        return _Last;
+    }
+
+private:
+    pointer _First;
+    pointer _Last;
+    _Alloc& _Al;
+};
+
+template <class _InIt, class _Se, class _Alloc>
+_CONSTEXPR20 _Alloc_ptr_t<_Alloc> _Uninitialized_copy(
+    _InIt _First, _Se _Last, _Alloc_ptr_t<_Alloc> _Dest, _Alloc& _Al) {
+    // copy [_First, _Last) to raw _Dest, using _Al
+    // note: only called internally from elsewhere in the STL
+    using _Ptrval = typename _Alloc::value_type*;
+
+#if _HAS_CXX20
+    auto _UFirst = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+    auto _ULast  = _RANGES _Unwrap_sent<_InIt>(_STD move(_Last));
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    // In pre-concepts world, _Uninitialized_copy should only ever be called with an iterator
+    // and sentinel of the same type, so `_Get_unwrapped` is fine to call.
+    auto _UFirst = _STD _Get_unwrapped(_STD move(_First));
+    auto _ULast  = _STD _Get_unwrapped(_STD move(_Last));
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    constexpr bool _Can_memmove = _Sent_copy_cat<decltype(_UFirst), decltype(_ULast), _Ptrval>::_Bitcopy_constructible
+                               && _Uses_default_construct<_Alloc, _Ptrval, decltype(*_UFirst)>::value;
+
+    if constexpr (_Can_memmove) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            if constexpr (is_same_v<decltype(_UFirst), decltype(_ULast)>) {
+                _STD _Copy_memmove(_STD _To_address(_UFirst), _STD _To_address(_ULast), _STD _Unfancy(_Dest));
+                _Dest += _ULast - _UFirst;
+            } else {
+                const auto _Count = static_cast<size_t>(_ULast - _UFirst);
+                _STD _Copy_memmove_n(_STD _To_address(_UFirst), _Count, _STD _Unfancy(_Dest));
+                _Dest += _Count;
+            }
+            return _Dest;
+        }
+    }
+
+    _Uninitialized_backout_al<_Alloc> _Backout{_Dest, _Al};
+    for (; _UFirst != _ULast; ++_UFirst) {
+        _Backout._Emplace_back(*_UFirst);
+    }
+
+    return _Backout._Release();
+}
+
+template <class _InIt, class _Alloc>
+_CONSTEXPR20 _Alloc_ptr_t<_Alloc> _Uninitialized_copy_n(
+    _InIt _First, size_t _Count, _Alloc_ptr_t<_Alloc> _Dest, _Alloc& _Al) {
+    // copy _First + [0, _Count) to raw _Dest, using _Al
+    // note: only called internally from elsewhere in the STL
+    using _Ptrval = typename _Alloc::value_type*;
+
+    auto _UFirst = _STD _Get_unwrapped(_STD move(_First));
+
+    constexpr bool _Can_memmove =
+        conjunction_v<bool_constant<_Iter_copy_cat<decltype(_UFirst), _Ptrval>::_Bitcopy_constructible>,
+            _Uses_default_construct<_Alloc, _Ptrval, decltype(*_UFirst)>>;
+
+    if constexpr (_Can_memmove) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            _STD _Copy_memmove_n(_UFirst, _Count, _STD _Unfancy(_Dest));
+            _Dest += _Count;
+            return _Dest;
+        }
+    }
+
+    _Uninitialized_backout_al<_Alloc> _Backout{_Dest, _Al};
+    for (; _Count != 0; ++_UFirst, (void) --_Count) {
+        _Backout._Emplace_back(*_UFirst);
+    }
+
+    return _Backout._Release();
+}
+
+template <class _InIt, class _NoThrowFwdIt>
+_CONSTEXPR20 _NoThrowFwdIt _Uninitialized_copy_unchecked(_InIt _First, const _InIt _Last, _NoThrowFwdIt _Dest) {
+    // copy [_First, _Last) to raw [_Dest, ...)
+    if constexpr (_Iter_copy_cat<_InIt, _NoThrowFwdIt>::_Bitcopy_constructible) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            return _STD _Copy_memmove(_First, _Last, _Dest);
+        }
+    }
+
+    _Uninitialized_backout<_NoThrowFwdIt> _Backout{_Dest};
+    for (; _First != _Last; ++_First) {
+        _Backout._Emplace_back(*_First);
+    }
+
+    return _Backout._Release();
+}
+
+_EXPORT_STD template <class _InIt, class _NoThrowFwdIt>
+_NoThrowFwdIt uninitialized_copy(const _InIt _First, const _InIt _Last, _NoThrowFwdIt _Dest) {
+    // copy [_First, _Last) to raw [_Dest, ...)
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    auto _UDest       = _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_InIt>(_UFirst, _ULast));
+    _STD _Seek_wrapped(_Dest, _STD _Uninitialized_copy_unchecked(_UFirst, _ULast, _UDest));
+    return _Dest;
+}
+
+template <class _InIt, class _Alloc>
+_CONSTEXPR20 _Alloc_ptr_t<_Alloc> _Uninitialized_move(
+    const _InIt _First, const _InIt _Last, _Alloc_ptr_t<_Alloc> _Dest, _Alloc& _Al) {
+    // move [_First, _Last) to raw _Dest, using _Al
+    // note: only called internally from elsewhere in the STL
+    using _Ptrval     = typename _Alloc::value_type*;
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    if constexpr (conjunction_v<bool_constant<_Iter_move_cat<decltype(_UFirst), _Ptrval>::_Bitcopy_constructible>,
+                      _Uses_default_construct<_Alloc, _Ptrval, decltype(_STD move(*_UFirst))>>) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            _STD _Copy_memmove(_UFirst, _ULast, _STD _Unfancy(_Dest));
+            return _Dest + (_ULast - _UFirst);
+        }
+    }
+
+    _Uninitialized_backout_al<_Alloc> _Backout{_Dest, _Al};
+    for (; _UFirst != _ULast; ++_UFirst) {
+        _Backout._Emplace_back(_STD move(*_UFirst));
+    }
+
+    return _Backout._Release();
+}
+
+template <class _Alloc>
+_CONSTEXPR20 _Alloc_ptr_t<_Alloc> _Uninitialized_fill_n(
+    _Alloc_ptr_t<_Alloc> _First, _Alloc_size_t<_Alloc> _Count, const typename _Alloc::value_type& _Val, _Alloc& _Al) {
+    // copy _Count copies of _Val to raw _First, using _Al
+    using _Ty = typename _Alloc::value_type;
+    if constexpr (_Fill_memset_is_safe<_Ty*, _Ty> && _Uses_default_construct<_Alloc, _Ty*, _Ty>::value) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            _Fill_memset(_Unfancy(_First), _Val, static_cast<size_t>(_Count));
+            return _First + _Count;
+        }
+    } else if constexpr (_Fill_zero_memset_is_safe<_Ty*, _Ty> && _Uses_default_construct<_Alloc, _Ty*, _Ty>::value) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            if (_Is_all_bits_zero(_Val)) {
+                _Fill_zero_memset(_Unfancy(_First), static_cast<size_t>(_Count));
+                return _First + _Count;
+            }
+        }
+    }
+
+    _Uninitialized_backout_al<_Alloc> _Backout{_First, _Al};
+    for (; 0 < _Count; --_Count) {
+        _Backout._Emplace_back(_Val);
+    }
+
+    return _Backout._Release();
+}
+
+_EXPORT_STD template <class _NoThrowFwdIt, class _Tval>
+void uninitialized_fill(const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last, const _Tval& _Val) {
+    // copy _Val throughout raw [_First, _Last)
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    if constexpr (_Fill_memset_is_safe<_Unwrapped_t<const _NoThrowFwdIt&>, _Tval>) {
+        _STD _Fill_memset(_UFirst, _Val, static_cast<size_t>(_ULast - _UFirst));
+    } else {
+        if constexpr (_Fill_zero_memset_is_safe<_Unwrapped_t<const _NoThrowFwdIt&>, _Tval>) {
+            if (_STD _Is_all_bits_zero(_Val)) {
+                _STD _Fill_zero_memset(_UFirst, static_cast<size_t>(_ULast - _UFirst));
+                return;
+            }
+        }
+
+        _Uninitialized_backout<_Unwrapped_t<const _NoThrowFwdIt&>> _Backout{_UFirst};
+        while (_Backout._Last != _ULast) {
+            _Backout._Emplace_back(_Val);
+        }
+
+        _Backout._Release();
+    }
+}
+
+template <class _NoThrowFwdIt>
+constexpr bool _Use_memset_value_construct_v = conjunction_v<bool_constant<_Iterator_is_contiguous<_NoThrowFwdIt>>,
+    is_scalar<_Iter_value_t<_NoThrowFwdIt>>, negation<is_volatile<remove_reference_t<_Iter_ref_t<_NoThrowFwdIt>>>>,
+    negation<is_member_pointer<_Iter_value_t<_NoThrowFwdIt>>>>;
+
+template <class _Ptr>
+_Ptr _Zero_range(const _Ptr _First, const _Ptr _Last) { // fill [_First, _Last) with zeroes
+    char* const _First_ch = reinterpret_cast<char*>(_STD _To_address(_First));
+    char* const _Last_ch  = reinterpret_cast<char*>(_STD _To_address(_Last));
+    _CSTD memset(_First_ch, 0, static_cast<size_t>(_Last_ch - _First_ch));
+    return _Last;
+}
+
+template <class _Alloc>
+_CONSTEXPR20 _Alloc_ptr_t<_Alloc> _Uninitialized_value_construct_n(
+    _Alloc_ptr_t<_Alloc> _First, _Alloc_size_t<_Alloc> _Count, _Alloc& _Al) {
+    // value-initialize _Count objects to raw _First, using _Al
+    using _Ptrty = typename _Alloc::value_type*;
+    if constexpr (_Use_memset_value_construct_v<_Ptrty> && _Uses_default_construct<_Alloc, _Ptrty>::value) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            auto _PFirst = _Unfancy(_First);
+            _Zero_range(_PFirst, _PFirst + _Count);
+            return _First + _Count;
+        }
+    }
+
+    _Uninitialized_backout_al<_Alloc> _Backout{_First, _Al};
+    for (; 0 < _Count; --_Count) {
+        _Backout._Emplace_back();
+    }
+
+    return _Backout._Release();
+}
+
+template <class _NoThrowFwdIt, class _Diff>
+_NoThrowFwdIt _Uninitialized_value_construct_n_unchecked1(_NoThrowFwdIt _UFirst, _Diff _Count) {
+    // value-initialize all elements in [_UFirst, _UFirst + _Count)
+    _STL_INTERNAL_CHECK(_Count >= 0);
+    if constexpr (_Use_memset_value_construct_v<_NoThrowFwdIt>) {
+        return _STD _Zero_range(_UFirst, _UFirst + _Count);
+    } else {
+        _Uninitialized_backout<_NoThrowFwdIt> _Backout{_UFirst};
+        for (; 0 < _Count; --_Count) {
+            _Backout._Emplace_back();
+        }
+
+        return _Backout._Release();
+    }
+}
+
+#if _HAS_DEPRECATED_TEMPORARY_BUFFER
+_EXPORT_STD template <class _Ty>
+_CXX17_DEPRECATE_TEMPORARY_BUFFER _NODISCARD pair<_Ty*, ptrdiff_t> get_temporary_buffer(ptrdiff_t _Count) noexcept {
+    return _Get_temporary_buffer<_Ty>(_Count);
+}
+
+_EXPORT_STD template <class _Ty>
+_CXX17_DEPRECATE_TEMPORARY_BUFFER void return_temporary_buffer(_Ty* _Pbuf) {
+    _Return_temporary_buffer(_Pbuf);
+}
+#endif // _HAS_DEPRECATED_TEMPORARY_BUFFER
+
+// assumes _Args have already been _Remove_cvref_t'd
+template <class _Key, class... _Args>
+struct _In_place_key_extract_set {
+    // by default we can't extract the key in the emplace family and must construct a node we might not use
+    static constexpr bool _Extractable = false;
+};
+
+template <class _Key>
+struct _In_place_key_extract_set<_Key, _Key> {
+    // we can extract the key in emplace if the emplaced type is identical to the key type
+    static constexpr bool _Extractable = true;
+    static const _Key& _Extract(const _Key& _Val) noexcept {
+        return _Val;
+    }
+};
+
+// assumes _Args have already been _Remove_cvref_t'd
+template <class _Key, class... _Args>
+struct _In_place_key_extract_map {
+    // by default we can't extract the key in the emplace family and must construct a node we might not use
+    static constexpr bool _Extractable = false;
+};
+
+template <class _Key, class _Second>
+struct _In_place_key_extract_map<_Key, _Key, _Second> {
+    // if we would call the pair(key, value) constructor family, we can use the first parameter as the key
+    static constexpr bool _Extractable = true;
+    static const _Key& _Extract(const _Key& _Val, const _Second&) noexcept {
+        return _Val;
+    }
+};
+
+template <class _Key, class _First, class _Second>
+struct _In_place_key_extract_map<_Key, pair<_First, _Second>> {
+    // if we would call the pair(pair<other, other>) constructor family, we can use the pair.first member as the key
+    static constexpr bool _Extractable = is_same_v<_Key, _Remove_cvref_t<_First>>;
+    static const _Key& _Extract(const pair<_First, _Second>& _Val) {
+        return _Val.first;
+    }
+};
+
+#pragma warning(push)
+#pragma warning(disable : 4624) // '%s': destructor was implicitly defined as deleted
+template <class _Ty>
+struct _Wrap {
+    _Ty _Value; // workaround for VSO-586813 "T^ is not allowed in a union"
+};
+#pragma warning(pop)
+
+template <class _Alloc>
+struct _Alloc_temporary2 {
+    using value_type = typename _Alloc::value_type;
+    using _Traits    = allocator_traits<_Alloc>;
+
+    _Alloc& _Al;
+
+#ifdef __cplusplus_winrt
+    union {
+        _Wrap<value_type> _Storage;
+    };
+
+    _NODISCARD _CONSTEXPR20 value_type& _Get_value() noexcept {
+        return _Storage._Value;
+    }
+
+    _NODISCARD _CONSTEXPR20 const value_type& _Get_value() const noexcept {
+        return _Storage._Value;
+    }
+#else // ^^^ workaround for VSO-586813 "T^ is not allowed in a union" / no workaround vvv
+    union {
+        value_type _Value;
+    };
+
+    _NODISCARD _CONSTEXPR20 value_type& _Get_value() noexcept {
+        return _Value;
+    }
+
+    _NODISCARD _CONSTEXPR20 const value_type& _Get_value() const noexcept {
+        return _Value;
+    }
+#endif // ^^^ no workaround ^^^
+
+    template <class... _Args>
+    _CONSTEXPR20 explicit _Alloc_temporary2(_Alloc& _Al_, _Args&&... _Vals) noexcept(
+        noexcept(_Traits::construct(_Al_, _STD addressof(_Get_value()), _STD forward<_Args>(_Vals)...)))
+        : _Al(_Al_) {
+        _Traits::construct(_Al, _STD addressof(_Get_value()), _STD forward<_Args>(_Vals)...);
+    }
+
+    _Alloc_temporary2(const _Alloc_temporary2&)            = delete;
+    _Alloc_temporary2& operator=(const _Alloc_temporary2&) = delete;
+
+    _CONSTEXPR20 ~_Alloc_temporary2() {
+        _Traits::destroy(_Al, _STD addressof(_Get_value()));
+    }
+};
+
+template <class _Alloc>
+_NODISCARD constexpr bool _Allocators_equal(const _Alloc& _Lhs, const _Alloc& _Rhs) noexcept {
+    if constexpr (allocator_traits<_Alloc>::is_always_equal::value) {
+        return true;
+    } else {
+        return _Lhs == _Rhs;
+    }
+}
+
+#if _HAS_CXX23
+template <class _Ty>
+constexpr bool _Has_member_from_primary = requires { typename _Ty::_From_primary; };
+
+// Avoid using allocate_at_least when the allocator publicly derives from std::allocator:
+// "old" allocators might hide allocate and deallocate but fail to hide allocate_at_least.
+// Also avoid using allocate_at_least from std::allocator itself because it currently doesn't do anything useful.
+template <class _Alloc>
+constexpr bool _Should_allocate_at_least =
+    !_Has_member_from_primary<_Alloc>
+    && _Has_member_allocate_at_least<_Alloc, typename allocator_traits<_Alloc>::size_type>;
+#endif // _HAS_CXX23
+
+template <class _Alloc>
+_NODISCARD_RAW_PTR_ALLOC _CONSTEXPR20 typename allocator_traits<_Alloc>::pointer _Allocate_at_least_helper(
+    _Alloc& _Al, _CRT_GUARDOVERFLOW typename allocator_traits<_Alloc>::size_type& _Count) {
+#if _HAS_CXX23
+    if constexpr (_Should_allocate_at_least<_Alloc>) {
+        auto [_Ptr, _Allocated] = _Al.allocate_at_least(_Count);
+        _Count                  = _Allocated;
+        return _Ptr;
+    } else
+#endif // _HAS_CXX23
+    {
+        return _Al.allocate(_Count);
+    }
+}
+
+_EXPORT_STD template <class _FwdIt, class _Ty>
+_NODISCARD_REMOVE_ALG _CONSTEXPR20 _FwdIt remove(_FwdIt _First, const _FwdIt _Last, const _Ty& _Val) {
+    // remove each matching _Val
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    _UFirst           = _STD _Find_unchecked(_UFirst, _ULast, _Val);
+    auto _UNext       = _UFirst;
+    if (_UFirst != _ULast) {
+        while (++_UFirst != _ULast) {
+            if (!(*_UFirst == _Val)) {
+                *_UNext = _STD move(*_UFirst);
+                ++_UNext;
+            }
+        }
+    }
+
+    _STD _Seek_wrapped(_First, _UNext);
+    return _First;
+}
+
+_EXPORT_STD template <class _FwdIt, class _Pr>
+_NODISCARD_REMOVE_ALG _CONSTEXPR20 _FwdIt remove_if(_FwdIt _First, const _FwdIt _Last, _Pr _Pred) {
+    // remove each satisfying _Pred
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    _UFirst           = _STD find_if(_UFirst, _ULast, _STD _Pass_fn(_Pred));
+    auto _UNext       = _UFirst;
+    if (_UFirst != _ULast) {
+        while (++_UFirst != _ULast) {
+            if (!_Pred(*_UFirst)) {
+                *_UNext = _STD move(*_UFirst);
+                ++_UNext;
+            }
+        }
+    }
+
+    _STD _Seek_wrapped(_First, _UNext);
+    return _First;
+}
+
+template <class _Container, class _Uty>
+_CONSTEXPR20 typename _Container::size_type _Erase_remove(_Container& _Cont, const _Uty& _Val) {
+    // erase each element matching _Val
+    auto _First          = _Cont.begin();
+    const auto _Last     = _Cont.end();
+    const auto _Old_size = _Cont.size();
+    _STD _Seek_wrapped(_First, _STD remove(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last), _Val));
+    _Cont.erase(_First, _Last);
+    return _Old_size - _Cont.size();
+}
+
+template <class _Container, class _Pr>
+_CONSTEXPR20 typename _Container::size_type _Erase_remove_if(_Container& _Cont, _Pr _Pred) {
+    // erase each element satisfying _Pred
+    auto _First          = _Cont.begin();
+    const auto _Last     = _Cont.end();
+    const auto _Old_size = _Cont.size();
+    _STD _Seek_wrapped(_First, _STD remove_if(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last), _Pred));
+    _Cont.erase(_First, _Last);
+    return _Old_size - _Cont.size();
+}
+
+template <class _Container, class _Pr>
+typename _Container::size_type _Erase_nodes_if(_Container& _Cont, _Pr _Pred) {
+    // erase each element satisfying _Pred
+    auto _First          = _Cont.begin();
+    const auto _Last     = _Cont.end();
+    const auto _Old_size = _Cont.size();
+    while (_First != _Last) {
+        if (_Pred(*_First)) {
+            _First = _Cont.erase(_First);
+        } else {
+            ++_First;
+        }
+    }
+    return _Old_size - _Cont.size();
+}
+
+template <class _Ty1, class _Ty2>
+void _Deduce_as_pair(const pair<_Ty1, _Ty2>&); // not defined
+
+template <class _Ty, class = void>
+constexpr bool _Is_deducible_as_pair = false;
+
+template <class _Ty>
+constexpr bool _Is_deducible_as_pair<_Ty, decltype(_STD _Deduce_as_pair(_STD declval<_Ty>()))> = true;
+
+template <class _Ty>
+constexpr bool _Is_cv_pair = _Is_specialization_v<remove_cv_t<_Ty>, pair>;
+
+template <class _Ty>
+const _Ty& _Normally_bind(_Identity_t<const _Ty&>); // not defined
+
+template <class _Ty>
+_Ty&& _Normally_bind(_Identity_t<_Ty&&>); // not defined
+
+template <class _Ty, class _Uty>
+using _Normally_bound_ref = decltype(_STD _Normally_bind<_Ty>(_STD declval<_Uty>()));
+
+template <class _Ty, class _Uty, class = void>
+constexpr bool _Is_normally_bindable = false;
+
+template <class _Ty, class _Uty>
+constexpr bool _Is_normally_bindable<_Ty, _Uty, void_t<_Normally_bound_ref<_Ty, _Uty>>> = true;
+
+#if _HAS_CXX20
+template <class _Ty>
+concept _Cv_std_pair = _Is_cv_pair<_Ty>;
+
+template <class _Ty>
+concept _Usable_for_pair_like_overload =
+#if _HAS_CXX23
+    _Pair_like<_Ty> ||
+#endif // _HAS_CXX23
+    !_Is_deducible_as_pair<_Ty&>;
+
+_EXPORT_STD template <class _Ty, class _Alloc, class... _Types>
+    requires (!_Is_cv_pair<_Ty>)
+_NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, _Types&&... _Args) noexcept {
+    if constexpr (!uses_allocator_v<remove_cv_t<_Ty>, _Alloc>) {
+        static_assert(is_constructible_v<_Ty, _Types...>,
+            "If uses_allocator_v<remove_cv_t<T>, Alloc> is false, "
+            "T must be constructible from (Types...). (N4981 [allocator.uses.construction]/5)");
+        (void) _Al;
+        return _STD forward_as_tuple(_STD forward<_Types>(_Args)...);
+    } else if constexpr (is_constructible_v<_Ty, allocator_arg_t, const _Alloc&, _Types...>) {
+        using _ReturnType = tuple<allocator_arg_t, const _Alloc&, _Types&&...>;
+        return _ReturnType{allocator_arg, _Al, _STD forward<_Types>(_Args)...};
+    } else if constexpr (is_constructible_v<_Ty, _Types..., const _Alloc&>) {
+        return _STD forward_as_tuple(_STD forward<_Types>(_Args)..., _Al);
+    } else {
+        static_assert(false, "If uses_allocator_v<remove_cv_t<T>, Alloc> is true, "
+                             "T must be constructible from either (allocator_arg_t, const Alloc&, Types...) "
+                             "or (Types..., const Alloc&). (N4981 [allocator.uses.construction]/5)");
+    }
+}
+
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc>
+_NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al) noexcept;
+
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, class _Uty1, class _Uty2>
+_NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, _Uty1&& _Val1, _Uty2&& _Val2) noexcept;
+
+#if _HAS_CXX23
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, class _Uty1, class _Uty2>
+_NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, pair<_Uty1, _Uty2>& _Pair) noexcept;
+#endif // _HAS_CXX23
+
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, class _Uty1, class _Uty2>
+_NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, const pair<_Uty1, _Uty2>& _Pair) noexcept;
+
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, class _Uty1, class _Uty2>
+_NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, pair<_Uty1, _Uty2>&& _Pair) noexcept;
+
+#if _HAS_CXX23
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, class _Uty1, class _Uty2>
+_NODISCARD constexpr auto uses_allocator_construction_args(
+    const _Alloc& _Al, const pair<_Uty1, _Uty2>&& _Pair) noexcept;
+#endif // _HAS_CXX23
+
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, _Usable_for_pair_like_overload _Uty>
+_NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, _Uty&& _Ux) noexcept;
+
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, class _Tuple1, class _Tuple2>
+_NODISCARD constexpr auto uses_allocator_construction_args(
+    const _Alloc& _Al, piecewise_construct_t, _Tuple1&& _Tup1, _Tuple2&& _Tup2) noexcept {
+    return _STD make_tuple(piecewise_construct,
+        _STD apply(
+            [&_Al](auto&&... _Tuple_args) {
+                return _STD uses_allocator_construction_args<typename _Ty::first_type>(
+                    _Al, _STD forward<decltype(_Tuple_args)>(_Tuple_args)...);
+            },
+            _STD forward<_Tuple1>(_Tup1)),
+        _STD apply(
+            [&_Al](auto&&... _Tuple_args) {
+                return _STD uses_allocator_construction_args<typename _Ty::second_type>(
+                    _Al, _STD forward<decltype(_Tuple_args)>(_Tuple_args)...);
+            },
+            _STD forward<_Tuple2>(_Tup2)));
+}
+
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc>
+_NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al) noexcept {
+    // equivalent to
+    // return _STD uses_allocator_construction_args<_Ty>(_Al, piecewise_construct, tuple<>{}, tuple<>{});
+    return _STD make_tuple(piecewise_construct, _STD uses_allocator_construction_args<typename _Ty::first_type>(_Al),
+        _STD uses_allocator_construction_args<typename _Ty::second_type>(_Al));
+}
+
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, class _Uty1, class _Uty2>
+_NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, _Uty1&& _Val1, _Uty2&& _Val2) noexcept {
+    // equivalent to
+    // return _STD uses_allocator_construction_args<_Ty>(_Al, piecewise_construct,
+    //     _STD forward_as_tuple(_STD forward<_Uty1>(_Val1)), _STD forward_as_tuple(_STD forward<_Uty2>(_Val2)));
+    return _STD make_tuple(piecewise_construct,
+        _STD uses_allocator_construction_args<typename _Ty::first_type>(_Al, _STD forward<_Uty1>(_Val1)),
+        _STD uses_allocator_construction_args<typename _Ty::second_type>(_Al, _STD forward<_Uty2>(_Val2)));
+}
+
+#if _HAS_CXX23
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, class _Uty1, class _Uty2>
+_NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, pair<_Uty1, _Uty2>& _Pair) noexcept {
+    // equivalent to
+    // return _STD uses_allocator_construction_args<_Ty>(_Al, piecewise_construct,
+    //     _STD forward_as_tuple(_Pair.first), _STD forward_as_tuple(_Pair.second));
+    return _STD make_tuple(piecewise_construct,
+        _STD uses_allocator_construction_args<typename _Ty::first_type>(_Al, _Pair.first),
+        _STD uses_allocator_construction_args<typename _Ty::second_type>(_Al, _Pair.second));
+}
+#endif // _HAS_CXX23
+
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, class _Uty1, class _Uty2>
+_NODISCARD constexpr auto uses_allocator_construction_args(
+    const _Alloc& _Al, const pair<_Uty1, _Uty2>& _Pair) noexcept {
+    // equivalent to
+    // return _STD uses_allocator_construction_args<_Ty>(_Al, piecewise_construct,
+    //     _STD forward_as_tuple(_Pair.first), _STD forward_as_tuple(_Pair.second));
+    return _STD make_tuple(piecewise_construct,
+        _STD uses_allocator_construction_args<typename _Ty::first_type>(_Al, _Pair.first),
+        _STD uses_allocator_construction_args<typename _Ty::second_type>(_Al, _Pair.second));
+}
+
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, class _Uty1, class _Uty2>
+_NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, pair<_Uty1, _Uty2>&& _Pair) noexcept {
+    // equivalent to
+    // return _STD uses_allocator_construction_args<_Ty>(_Al, piecewise_construct,
+    //     _STD forward_as_tuple(_STD get<0>(_STD move(_Pair)), _STD forward_as_tuple(_STD get<1>(_STD move(_Pair)));
+    return _STD make_tuple(piecewise_construct,
+        _STD uses_allocator_construction_args<typename _Ty::first_type>(_Al, _STD get<0>(_STD move(_Pair))),
+        _STD uses_allocator_construction_args<typename _Ty::second_type>(_Al, _STD get<1>(_STD move(_Pair))));
+}
+
+#if _HAS_CXX23
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, class _Uty1, class _Uty2>
+_NODISCARD constexpr auto uses_allocator_construction_args(
+    const _Alloc& _Al, const pair<_Uty1, _Uty2>&& _Pair) noexcept {
+    // equivalent to
+    // return _STD uses_allocator_construction_args<_Ty>(_Al, piecewise_construct,
+    //     _STD forward_as_tuple(_STD get<0>(_STD move(_Pair)), _STD forward_as_tuple(_STD get<1>(_STD move(_Pair)));
+    return _STD make_tuple(piecewise_construct,
+        _STD uses_allocator_construction_args<typename _Ty::first_type>(_Al, _STD get<0>(_STD move(_Pair))),
+        _STD uses_allocator_construction_args<typename _Ty::second_type>(_Al, _STD get<1>(_STD move(_Pair))));
+}
+#endif // _HAS_CXX23
+
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, _Usable_for_pair_like_overload _Uty>
+_NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, _Uty&& _Ux) noexcept {
+#if _HAS_CXX23
+    if constexpr (_Pair_like<_Uty> && !_Is_subrange_v<remove_cvref_t<_Uty>>) {
+        // equivalent to
+        // return _STD uses_allocator_construction_args<_Ty>(_Al, piecewise_construct,
+        //     _STD forward_as_tuple(_STD get<0>(_STD forward<_Uty>(_Ux)),
+        //     _STD forward_as_tuple(_STD get<1>(_STD forward<_Uty>(_Ux)));
+        return _STD make_tuple(piecewise_construct,
+            _STD uses_allocator_construction_args<typename _Ty::first_type>(_Al, _STD get<0>(_STD forward<_Uty>(_Ux))),
+            _STD uses_allocator_construction_args<typename _Ty::second_type>(
+                _Al, _STD get<1>(_STD forward<_Uty>(_Ux))));
+    } else
+#endif // _HAS_CXX23
+    {
+        struct _Pair_remaker {
+            const _Alloc& _Al;
+            _Uty& _Ux;
+
+            constexpr operator remove_cv_t<_Ty>() const {
+                using _Pair_t = remove_cv_t<_Ty>;
+                static_assert(_Is_normally_bindable<_Pair_t, _Uty>,
+                    "The argument must be bindable to a reference to the std::pair type.");
+
+                using _Pair_first_t   = _Pair_t::first_type;
+                using _Pair_second_t  = _Pair_t::second_type;
+                using _Pair_ref_t     = _Normally_bound_ref<_Pair_t, _Uty>;
+                _Pair_ref_t _Pair_ref = _STD forward<_Uty>(_Ux);
+                if constexpr (is_same_v<_Pair_ref_t, const _Pair_t&>) {
+                    // equivalent to
+                    // return _STD make_obj_using_allocator<_Pair_t>(_Al, _Pair_ref);
+                    return _Pair_t{piecewise_construct,
+                        _STD uses_allocator_construction_args<_Pair_first_t>(_Al, _Pair_ref.first),
+                        _STD uses_allocator_construction_args<_Pair_second_t>(_Al, _Pair_ref.second)};
+                } else {
+                    // equivalent to
+                    // return _STD make_obj_using_allocator<_Pair_t>(_Al, _STD move(_Pair_ref));
+                    return _Pair_t{piecewise_construct,
+                        _STD uses_allocator_construction_args<_Pair_first_t>(_Al, _STD get<0>(_STD move(_Pair_ref))),
+                        _STD uses_allocator_construction_args<_Pair_second_t>(_Al, _STD get<1>(_STD move(_Pair_ref)))};
+                }
+            }
+        };
+
+        // equivalent to
+        // return _STD make_tuple(_Pair_remaker{_Al, _Ux});
+        return tuple<_Pair_remaker>({_Al, _Ux});
+    }
+}
+
+_EXPORT_STD template <class _Ty, class _Alloc, class... _Types>
+_NODISCARD constexpr _Ty make_obj_using_allocator(const _Alloc& _Al, _Types&&... _Args) {
+    return _STD make_from_tuple<_Ty>(_STD uses_allocator_construction_args<_Ty>(_Al, _STD forward<_Types>(_Args)...));
+}
+
+_EXPORT_STD template <class _Ty, class _Alloc, class... _Types>
+constexpr _Ty* uninitialized_construct_using_allocator(_Ty* _Ptr, const _Alloc& _Al, _Types&&... _Args) {
+    return _STD apply(
+        [&](auto&&... _Construct_args) {
+            return _STD construct_at(_Ptr, _STD forward<decltype(_Construct_args)>(_Construct_args)...);
+        },
+        _STD uses_allocator_construction_args<_Ty>(_Al, _STD forward<_Types>(_Args)...));
+}
+#endif // _HAS_CXX20
+
+#if _HAS_CXX23
+_EXPORT_STD struct from_range_t {
+    explicit from_range_t() = default;
+};
+_EXPORT_STD inline constexpr from_range_t from_range;
+
+template <class _Rng, class _Elem>
+concept _Container_compatible_range =
+    (_RANGES input_range<_Rng>) &&convertible_to<_RANGES range_reference_t<_Rng>, _Elem>;
+
+template <_RANGES input_range _Rng>
+using _Range_key_type = remove_const_t<typename _RANGES range_value_t<_Rng>::first_type>;
+
+template <_RANGES input_range _Rng>
+using _Range_mapped_type = _RANGES range_value_t<_Rng>::second_type;
+
+template <_RANGES input_range _Rng>
+using _Range_to_alloc_type =
+    pair<const typename _RANGES range_value_t<_Rng>::first_type, typename _RANGES range_value_t<_Rng>::second_type>;
+#endif // _HAS_CXX23
+
+template <class _Ty,
+    bool = is_empty_v<_Ty> && !is_final_v<_Ty>>
+class _Ebco_base : private _Ty { // Empty Base Class Optimization, active
+private:
+    using _Mybase = _Ty; // for visualization
+
+protected:
+    template <class _Other, enable_if_t<!is_same_v<_Remove_cvref_t<_Other>, _Ebco_base>, int> = 0>
+    constexpr explicit _Ebco_base(_Other&& _Val) noexcept(is_nothrow_constructible_v<_Ty, _Other>)
+        : _Ty(_STD forward<_Other>(_Val)) {}
+
+    constexpr _Ty& _Get_val() noexcept {
+        return *this;
+    }
+
+    constexpr const _Ty& _Get_val() const noexcept {
+        return *this;
+    }
+};
+
+template <class _Ty>
+class _Ebco_base<_Ty, false> { // Empty Base Class Optimization, inactive
+private:
+    _Ty _Myval;
+
+protected:
+    template <class _Other, enable_if_t<!is_same_v<_Remove_cvref_t<_Other>, _Ebco_base>, int> = 0>
+    constexpr explicit _Ebco_base(_Other&& _Val) noexcept(is_nothrow_constructible_v<_Ty, _Other>)
+        : _Myval(_STD forward<_Other>(_Val)) {}
+
+    constexpr _Ty& _Get_val() noexcept {
+        return _Myval;
+    }
+
+    constexpr const _Ty& _Get_val() const noexcept {
+        return _Myval;
+    }
+};
+
+_EXPORT_STD inline void* align(size_t _Bound, size_t _Size, void*& _Ptr, size_t& _Space) noexcept /* strengthened */ {
+    // try to carve out _Size bytes on boundary _Bound
+    size_t _Off = static_cast<size_t>(reinterpret_cast<uintptr_t>(_Ptr) & (_Bound - 1));
+    if (_Off != 0) {
+        _Off = _Bound - _Off; // number of bytes to skip
+    }
+
+    if (_Space < _Off || _Space - _Off < _Size) {
+        return nullptr;
+    }
+
+    // enough room, update
+    _Ptr = static_cast<char*>(_Ptr) + _Off;
+    _Space -= _Off;
+    return _Ptr;
+}
+
+template <class _Ty, class = void>
+constexpr bool _Is_transparent_v = false;
+
+template <class _Ty>
+constexpr bool _Is_transparent_v<_Ty, void_t<typename _Ty::is_transparent>> = true;
+
+template <class _Ty>
+struct _Is_transparent : bool_constant<_Is_transparent_v<_Ty>> {};
+
+#if _HAS_CXX20
+template <class _Ty>
+concept _Transparent = _Is_transparent_v<_Ty>;
+#endif // _HAS_CXX20
+
+template <class _Elem, class _UTy>
+_NODISCARD _Elem* _UIntegral_to_buff(_Elem* _RNext, _UTy _UVal) { // used by both to_string and thread::id output
+    // format _UVal into buffer *ending at* _RNext
+    static_assert(is_unsigned_v<_UTy>, "_UTy must be unsigned");
+
+#ifdef _WIN64
+    auto _UVal_trunc = _UVal;
+#else // ^^^ defined(_WIN64) / !defined(_WIN64) vvv
+
+    constexpr bool _Big_uty = sizeof(_UTy) > 4;
+    if constexpr (_Big_uty) { // For 64-bit numbers, work in chunks to avoid 64-bit divisions.
+        while (_UVal > 0xFFFFFFFFU) {
+            auto _UVal_chunk = static_cast<unsigned long>(_UVal % 1000000000);
+            _UVal /= 1000000000;
+
+            for (int _Idx = 0; _Idx != 9; ++_Idx) {
+                *--_RNext = static_cast<_Elem>('0' + _UVal_chunk % 10);
+                _UVal_chunk /= 10;
+            }
+        }
+    }
+
+    auto _UVal_trunc = static_cast<unsigned long>(_UVal);
+#endif // ^^^ !defined(_WIN64) ^^^
+
+    do {
+        *--_RNext = static_cast<_Elem>('0' + _UVal_trunc % 10);
+        _UVal_trunc /= 10;
+    } while (_UVal_trunc != 0);
+    return _RNext;
+}
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XMEMORY_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xmmintrin.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xmmintrin.h
new file mode 100644
index 0000000000000000000000000000000000000000..ce18378afabbd6f2a0d75502fc4d463b7093735c
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xmmintrin.h
@@ -0,0 +1,533 @@
+/*
+ *  Copyright (C) 1985-2015 Intel Corporation.
+ *
+ *  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+/*
+ * xmmintrin.h
+ *
+ * Principal header file for Streaming SIMD Extensions intrinsics
+ *
+ * The intrinsics package can be used in 2 ways, based whether or not
+ * _MM_FUNCTIONALITY is defined; if it is, the C/x87 implementation
+ * will be used (the "faux intrinsics").
+ *
+ *
+ * Note that the m128 datatype provided using _MM2_FUNCTIONALITY mode is
+ *   implemented as struct, will not be 128b aligned, will be passed
+ *   via the stack, etc.  MM_FUNCTIONALITY mode is not intended for
+ *   performance, just semantics.
+ *
+ */
+
+#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_MM2
+#define _INCLUDED_MM2
+#ifndef __midl
+
+#if defined (_M_CEE_PURE)
+        #error ERROR: XMM intrinsics not supported in the pure mode!
+#else  /* defined (_M_CEE_PURE) */
+
+/*
+ * the m64 type is required for the integer Streaming SIMD Extensions intrinsics
+ */
+#ifndef _MMINTRIN_H_INCLUDED
+#include <mmintrin.h>
+#endif  /* _MMINTRIN_H_INCLUDED */
+
+#ifdef _MM2_FUNCTIONALITY
+/* support old notation */
+#ifndef _MM_FUNCTIONALITY
+#define _MM_FUNCTIONALITY
+#endif  /* _MM_FUNCTIONALITY */
+#endif  /* _MM2_FUNCTIONALITY */
+
+#ifdef __ICL
+#ifdef _MM_FUNCTIONALITY
+#include "xmm_func.h"
+#else  /* _MM_FUNCTIONALITY */
+/* using real intrinsics */
+typedef long long __m128;
+#endif  /* _MM_FUNCTIONALITY */
+#else  /* __ICL */
+
+typedef union __declspec(intrin_type) __declspec(align(16)) __m128 {
+     float               m128_f32[4];
+     unsigned __int64    m128_u64[2];
+     __int8              m128_i8[16];
+     __int16             m128_i16[8];
+     __int32             m128_i32[4];
+     __int64             m128_i64[2];
+     unsigned __int8     m128_u8[16];
+     unsigned __int16    m128_u16[8];
+     unsigned __int32    m128_u32[4];
+ } __m128;
+
+#if !defined _VCRT_BUILD && !defined _INC_MALLOC
+/* pick up _mm_malloc() and _mm_free() */
+#include <malloc.h>
+#endif  /* !defined _VCRT_BUILD && !defined _INC_MALLOC */
+#endif  /* __ICL */
+
+ /*******************************************************/
+ /* MACRO for shuffle parameter for _mm_shuffle_ps().   */
+ /* Argument fp3 is a digit[0123] that represents the fp*/
+ /* from argument "b" of mm_shuffle_ps that will be     */
+ /* placed in fp3 of result. fp2 is the same for fp2 in */
+ /* result. fp1 is a digit[0123] that represents the fp */
+ /* from argument "a" of mm_shuffle_ps that will be     */
+ /* places in fp1 of result. fp0 is the same for fp0 of */
+ /* result                                              */
+ /*******************************************************/
+#define _MM_SHUFFLE(fp3,fp2,fp1,fp0) (((fp3) << 6) | ((fp2) << 4) | \
+                                     ((fp1) << 2) | ((fp0)))
+
+
+ /*******************************************************/
+ /* MACRO for performing the transpose of a 4x4 matrix  */
+ /* of single precision floating point values.          */
+ /* Arguments row0, row1, row2, and row3 are __m128     */
+ /* values whose elements form the corresponding rows   */
+ /* of a 4x4 matrix.  The matrix transpose is returned  */
+ /* in arguments row0, row1, row2, and row3 where row0  */
+ /* now holds column 0 of the original matrix, row1 now */
+ /* holds column 1 of the original matrix, etc.         */
+ /*******************************************************/
+#define _MM_TRANSPOSE4_PS(row0, row1, row2, row3) {                 \
+            __m128 _Tmp3, _Tmp2, _Tmp1, _Tmp0;                          \
+                                                                    \
+            _Tmp0   = _mm_shuffle_ps((row0), (row1), 0x44);          \
+            _Tmp2   = _mm_shuffle_ps((row0), (row1), 0xEE);          \
+            _Tmp1   = _mm_shuffle_ps((row2), (row3), 0x44);          \
+            _Tmp3   = _mm_shuffle_ps((row2), (row3), 0xEE);          \
+                                                                    \
+            (row0) = _mm_shuffle_ps(_Tmp0, _Tmp1, 0x88);              \
+            (row1) = _mm_shuffle_ps(_Tmp0, _Tmp1, 0xDD);              \
+            (row2) = _mm_shuffle_ps(_Tmp2, _Tmp3, 0x88);              \
+            (row3) = _mm_shuffle_ps(_Tmp2, _Tmp3, 0xDD);              \
+        }
+
+
+/* constants for use with _mm_prefetch */
+#define _MM_HINT_NTA    0
+#define _MM_HINT_T0     1
+#define _MM_HINT_T1     2
+#define _MM_HINT_T2     3
+#define _MM_HINT_ENTA   4
+/* code prefix constants */
+#if defined (_M_X64)
+#define _MM_HINT_IT0    7
+#define _MM_HINT_IT1    6
+#endif  /* defined (_M_X64) */
+// The values below were previously defined but not supported.
+//#define _MM_HINT_ET0    5
+//#define _MM_HINT_ET1    6
+//#define _MM_HINT_ET2    7
+
+/* (this declspec not supported with 0.A or 0.B) */
+#define _MM_ALIGN16 _VCRT_ALIGN(16)
+
+/* MACRO functions for setting and reading the MXCSR */
+#define _MM_EXCEPT_MASK       0x003f
+#define _MM_EXCEPT_INVALID    0x0001
+#define _MM_EXCEPT_DENORM     0x0002
+#define _MM_EXCEPT_DIV_ZERO   0x0004
+#define _MM_EXCEPT_OVERFLOW   0x0008
+#define _MM_EXCEPT_UNDERFLOW  0x0010
+#define _MM_EXCEPT_INEXACT    0x0020
+
+#define _MM_MASK_MASK         0x1f80
+#define _MM_MASK_INVALID      0x0080
+#define _MM_MASK_DENORM       0x0100
+#define _MM_MASK_DIV_ZERO     0x0200
+#define _MM_MASK_OVERFLOW     0x0400
+#define _MM_MASK_UNDERFLOW    0x0800
+#define _MM_MASK_INEXACT      0x1000
+
+#define _MM_ROUND_MASK        0x6000
+#define _MM_ROUND_NEAREST     0x0000
+#define _MM_ROUND_DOWN        0x2000
+#define _MM_ROUND_UP          0x4000
+#define _MM_ROUND_TOWARD_ZERO 0x6000
+
+#define _MM_FLUSH_ZERO_MASK   0x8000
+#define _MM_FLUSH_ZERO_ON     0x8000
+#define _MM_FLUSH_ZERO_OFF    0x0000
+
+#define _MM_SET_EXCEPTION_STATE(mask)                               \
+            _mm_setcsr((_mm_getcsr() & ~_MM_EXCEPT_MASK) | (mask))
+#define _MM_GET_EXCEPTION_STATE()                                   \
+            (_mm_getcsr() & _MM_EXCEPT_MASK)
+
+#define _MM_SET_EXCEPTION_MASK(mask)                                \
+            _mm_setcsr((_mm_getcsr() & ~_MM_MASK_MASK) | (mask))
+#define _MM_GET_EXCEPTION_MASK()                                    \
+            (_mm_getcsr() & _MM_MASK_MASK)
+
+#define _MM_SET_ROUNDING_MODE(mode)                                 \
+            _mm_setcsr((_mm_getcsr() & ~_MM_ROUND_MASK) | (mode))
+#define _MM_GET_ROUNDING_MODE()                                     \
+            (_mm_getcsr() & _MM_ROUND_MASK)
+
+#define _MM_SET_FLUSH_ZERO_MODE(mode)                               \
+            _mm_setcsr((_mm_getcsr() & ~_MM_FLUSH_ZERO_MASK) | (mode))
+#define _MM_GET_FLUSH_ZERO_MODE()                                   \
+            (_mm_getcsr() & _MM_FLUSH_ZERO_MASK)
+
+ /*****************************************************/
+ /*     INTRINSICS FUNCTION PROTOTYPES START HERE     */
+ /*****************************************************/
+
+#if defined __cplusplus
+extern "C" { /* Begin "C" */
+  /* Intrinsics use C name-mangling. */
+#endif  /* defined __cplusplus */
+
+// Suppress C28251: Inconsistent annotation for prior declaration.
+// Depending on the include order the definition may not exist so
+// _Use_decl_annotations_ can not be used. 
+#pragma warning(push)
+#pragma warning(disable: 28251)
+
+/*
+ * FP, arithmetic
+ */
+
+extern __m128 _mm_add_ss(__m128 _A, __m128 _B);
+extern __m128 _mm_add_ps(__m128 _A, __m128 _B);
+extern __m128 _mm_sub_ss(__m128 _A, __m128 _B);
+extern __m128 _mm_sub_ps(__m128 _A, __m128 _B);
+extern __m128 _mm_mul_ss(__m128 _A, __m128 _B);
+extern __m128 _mm_mul_ps(__m128 _A, __m128 _B);
+extern __m128 _mm_div_ss(__m128 _A, __m128 _B);
+extern __m128 _mm_div_ps(__m128 _A, __m128 _B);
+extern __m128 _mm_sqrt_ss(__m128 _A);
+extern __m128 _mm_sqrt_ps(__m128 _A);
+extern __m128 _mm_rcp_ss(__m128 _A);
+extern __m128 _mm_rcp_ps(__m128 _A);
+extern __m128 _mm_rsqrt_ss(__m128 _A);
+extern __m128 _mm_rsqrt_ps(__m128 _A);
+extern __m128 _mm_min_ss(__m128 _A, __m128 _B);
+extern __m128 _mm_min_ps(__m128 _A, __m128 _B);
+extern __m128 _mm_max_ss(__m128 _A, __m128 _B);
+extern __m128 _mm_max_ps(__m128 _A, __m128 _B);
+
+/*
+ * FP, logical
+ */
+
+extern __m128 _mm_and_ps(__m128 _A, __m128 _B);
+extern __m128 _mm_andnot_ps(__m128 _A, __m128 _B);
+extern __m128 _mm_or_ps(__m128 _A, __m128 _B);
+extern __m128 _mm_xor_ps(__m128 _A, __m128 _B);
+
+/*
+ * FP, comparison
+ */
+
+extern __m128 _mm_cmpeq_ss(__m128 _A, __m128 _B);
+extern __m128 _mm_cmpeq_ps(__m128 _A, __m128 _B);
+extern __m128 _mm_cmplt_ss(__m128 _A, __m128 _B);
+extern __m128 _mm_cmplt_ps(__m128 _A, __m128 _B);
+extern __m128 _mm_cmple_ss(__m128 _A, __m128 _B);
+extern __m128 _mm_cmple_ps(__m128 _A, __m128 _B);
+extern __m128 _mm_cmpgt_ss(__m128 _A, __m128 _B);
+extern __m128 _mm_cmpgt_ps(__m128 _A, __m128 _B);
+extern __m128 _mm_cmpge_ss(__m128 _A, __m128 _B);
+extern __m128 _mm_cmpge_ps(__m128 _A, __m128 _B);
+extern __m128 _mm_cmpneq_ss(__m128 _A, __m128 _B);
+extern __m128 _mm_cmpneq_ps(__m128 _A, __m128 _B);
+extern __m128 _mm_cmpnlt_ss(__m128 _A, __m128 _B);
+extern __m128 _mm_cmpnlt_ps(__m128 _A, __m128 _B);
+extern __m128 _mm_cmpnle_ss(__m128 _A, __m128 _B);
+extern __m128 _mm_cmpnle_ps(__m128 _A, __m128 _B);
+extern __m128 _mm_cmpngt_ss(__m128 _A, __m128 _B);
+extern __m128 _mm_cmpngt_ps(__m128 _A, __m128 _B);
+extern __m128 _mm_cmpnge_ss(__m128 _A, __m128 _B);
+extern __m128 _mm_cmpnge_ps(__m128 _A, __m128 _B);
+extern __m128 _mm_cmpord_ss(__m128 _A, __m128 _B);
+extern __m128 _mm_cmpord_ps(__m128 _A, __m128 _B);
+extern __m128 _mm_cmpunord_ss(__m128 _A, __m128 _B);
+extern __m128 _mm_cmpunord_ps(__m128 _A, __m128 _B);
+extern int _mm_comieq_ss(__m128 _A, __m128 _B);
+extern int _mm_comilt_ss(__m128 _A, __m128 _B);
+extern int _mm_comile_ss(__m128 _A, __m128 _B);
+extern int _mm_comigt_ss(__m128 _A, __m128 _B);
+extern int _mm_comige_ss(__m128 _A, __m128 _B);
+extern int _mm_comineq_ss(__m128 _A, __m128 _B);
+extern int _mm_ucomieq_ss(__m128 _A, __m128 _B);
+extern int _mm_ucomilt_ss(__m128 _A, __m128 _B);
+extern int _mm_ucomile_ss(__m128 _A, __m128 _B);
+extern int _mm_ucomigt_ss(__m128 _A, __m128 _B);
+extern int _mm_ucomige_ss(__m128 _A, __m128 _B);
+extern int _mm_ucomineq_ss(__m128 _A, __m128 _B);
+
+/*
+ * FP, conversions
+ */
+
+extern int _mm_cvt_ss2si(__m128 _A);
+extern int _mm_cvtt_ss2si(__m128 _A);
+extern __m128 _mm_cvt_si2ss(__m128, int);
+extern float _mm_cvtss_f32(__m128 _A);
+
+#if defined(_M_IX86)
+/*
+ * Support for MMX extension intrinsics
+ */
+extern __m64 _mm_cvt_ps2pi(__m128 _A);
+extern __m64 _mm_cvtt_ps2pi(__m128 _A);
+extern __m128 _mm_cvt_pi2ps(__m128, __m64);
+#endif
+
+#if defined (_M_X64)
+/*
+ * Support for 64-bit intrinsics
+ */
+extern __int64 _mm_cvtss_si64(__m128 _A);
+extern __int64 _mm_cvttss_si64(__m128 _A);
+extern __m128  _mm_cvtsi64_ss(__m128 _A, __int64 _B);
+#endif  /* defined (_M_X64) */
+
+/*
+ * FP, misc
+ */
+
+extern __m128 _mm_shuffle_ps(__m128 _A, __m128 _B, unsigned int _Imm8);
+extern __m128 _mm_unpackhi_ps(__m128 _A, __m128 _B);
+extern __m128 _mm_unpacklo_ps(__m128 _A, __m128 _B);
+extern __m128 _mm_loadh_pi(__m128, __m64 const*);
+extern __m128 _mm_movehl_ps(__m128, __m128);
+extern __m128 _mm_movelh_ps(__m128, __m128);
+extern void _mm_storeh_pi(__m64 *, __m128);
+extern __m128 _mm_loadl_pi(__m128, __m64 const*);
+extern void _mm_storel_pi(__m64 *, __m128);
+extern int _mm_movemask_ps(__m128 _A);
+
+
+#if defined(_M_IX86)
+/*
+ * Integer (MMX) extensions
+ */
+extern int _m_pextrw(__m64, int);
+extern __m64 _m_pinsrw(__m64, int, int);
+extern __m64 _m_pmaxsw(__m64, __m64);
+extern __m64 _m_pmaxub(__m64, __m64);
+extern __m64 _m_pminsw(__m64, __m64);
+extern __m64 _m_pminub(__m64, __m64);
+extern int _m_pmovmskb(__m64);
+extern __m64 _m_pmulhuw(__m64, __m64);
+extern __m64 _m_pshufw(__m64, int);
+extern void _m_maskmovq(__m64, __m64, char *);
+extern __m64 _m_pavgb(__m64, __m64);
+extern __m64 _m_pavgw(__m64, __m64);
+extern __m64 _m_psadbw(__m64, __m64);
+#endif
+
+/*
+ * memory & initialization
+ */
+
+extern __m128 _mm_set_ss(float _A);
+extern __m128 _mm_set_ps1(float _A);
+extern __m128 _mm_set_ps(float _A, float _B, float _C, float _D);
+extern __m128 _mm_setr_ps(float _A, float _B, float _C, float _D);
+extern __m128 _mm_setzero_ps(void);
+extern __m128 _mm_load_ss(float const*_A);
+extern __m128 _mm_load_ps1(float const*_A);
+extern __m128 _mm_load_ps(float const*_A);
+extern __m128 _mm_loadr_ps(float const*_A);
+extern __m128 _mm_loadu_ps(float const*_A);
+extern void _mm_store_ss(float *_V, __m128 _A);
+extern void _mm_store_ps1(float *_V, __m128 _A);
+extern void _mm_store_ps(float *_V, __m128 _A);
+extern void _mm_storer_ps(float *_V, __m128 _A);
+extern void _mm_storeu_ps(float *_V, __m128 _A);
+extern void _mm_prefetch(char const*_A, int _Sel);
+#if defined (_M_X64)
+extern void _m_prefetchit0(const void *);
+extern void _m_prefetchit1(const void *);
+#endif  /* defined (_M_X64) */
+#if defined(_M_IX86)
+extern void _mm_stream_pi(__m64 *, __m64);
+#endif
+extern void _mm_stream_ps(float *, __m128);
+extern __m128 _mm_move_ss(__m128 _A, __m128 _B);
+
+extern void _mm_sfence(void);
+extern unsigned int _mm_getcsr(void);
+extern void _mm_setcsr(unsigned int);
+
+#ifdef __ICL
+extern void* __cdecl _mm_malloc(size_t _Siz, size_t _Al);
+extern void __cdecl _mm_free(void *_P);
+#endif  /* __ICL */
+
+/* Alternate intrinsic names definition */
+#if defined(_M_IX86)
+#define _mm_cvtps_pi32    _mm_cvt_ps2pi
+#define _mm_cvttps_pi32   _mm_cvtt_ps2pi
+#define _mm_cvtpi32_ps    _mm_cvt_pi2ps
+#define _mm_extract_pi16  _m_pextrw
+#define _mm_insert_pi16   _m_pinsrw
+#define _mm_max_pi16      _m_pmaxsw
+#define _mm_max_pu8       _m_pmaxub
+#define _mm_min_pi16      _m_pminsw
+#define _mm_min_pu8       _m_pminub
+#define _mm_movemask_pi8  _m_pmovmskb
+#define _mm_mulhi_pu16    _m_pmulhuw
+#define _mm_shuffle_pi16  _m_pshufw
+#define _mm_maskmove_si64 _m_maskmovq
+#define _mm_avg_pu8       _m_pavgb
+#define _mm_avg_pu16      _m_pavgw
+#define _mm_sad_pu8       _m_psadbw
+#endif
+#define _mm_cvtss_si32    _mm_cvt_ss2si
+#define _mm_cvttss_si32   _mm_cvtt_ss2si
+#define _mm_cvtsi32_ss    _mm_cvt_si2ss
+#define _mm_set1_ps       _mm_set_ps1
+#define _mm_load1_ps      _mm_load_ps1
+#define _mm_store1_ps     _mm_store_ps1
+
+ /******************************************************/
+ /* UTILITY INTRINSICS FUNCTION DEFINITIONS START HERE */
+ /******************************************************/
+
+#if defined(_M_IX86)
+#pragma warning(push)
+#pragma warning(disable: 4514) // unreferenced inline function
+ /*********************************************************/
+ /*  NAME : _mm_cvtpi16_ps                                */
+ /*  DESCRIPTION : Convert 4 16-bit signed integer values */
+ /*                to 4 single-precision float values     */
+ /*  IN : __m64 _A                                         */
+ /*  OUT : none                                           */
+ /*  RETURN : __m128 : (float)_A                           */
+ /*********************************************************/
+__inline __m128 _mm_cvtpi16_ps(__m64 _A)
+{
+  __m128 _Tmp;
+  __m64  _Ext_val = _mm_cmpgt_pi16(_mm_setzero_si64(), _A);
+
+  _Tmp = _mm_cvtpi32_ps(_mm_setzero_ps(), _mm_unpackhi_pi16(_A, _Ext_val));
+  return(_mm_cvtpi32_ps(_mm_movelh_ps(_Tmp, _Tmp),
+                        _mm_unpacklo_pi16(_A, _Ext_val)));
+}
+
+
+ /***********************************************************/
+ /*  NAME : _mm_cvtpu16_ps                                  */
+ /*  DESCRIPTION : Convert 4 16-bit unsigned integer values */
+ /*                to 4 single-precision float values       */
+ /*  IN : __m64 _A                                           */
+ /*  OUT : none                                             */
+ /*  RETURN : __m128 : (float)_A                             */
+ /***********************************************************/
+__inline __m128 _mm_cvtpu16_ps(__m64 _A)
+{
+  __m128 _Tmp;
+  __m64  _Ext_val = _mm_setzero_si64();
+
+  _Tmp = _mm_cvtpi32_ps(_mm_setzero_ps(), _mm_unpackhi_pi16(_A, _Ext_val));
+  return(_mm_cvtpi32_ps(_mm_movelh_ps(_Tmp, _Tmp),
+                        _mm_unpacklo_pi16(_A, _Ext_val)));
+}
+
+
+ /******************************************************/
+ /*  NAME : _mm_cvtps_pi16                             */
+ /*  DESCRIPTION : Convert 4 single-precision float    */
+ /*                values to 4 16-bit integer values   */
+ /*  IN : __m128 a                                     */
+ /*  OUT : none                                        */
+ /*  RETURN : __m64 : (short)a                         */
+ /******************************************************/
+__inline __m64 _mm_cvtps_pi16(__m128 _A)
+{
+  return _mm_packs_pi32(_mm_cvtps_pi32(_A),
+                        _mm_cvtps_pi32(_mm_movehl_ps(_A, _A)));
+}
+
+
+ /******************************************************/
+ /*  NAME : _mm_cvtpi8_ps                              */
+ /*  DESCRIPTION : Convert 4 8-bit integer values to 4 */
+ /*                single-precision float values       */
+ /*  IN : __m64 _A                                     */
+ /*  OUT : none                                        */
+ /*  RETURN : __m128 : (float)_A                        */
+ /******************************************************/
+__inline __m128 _mm_cvtpi8_ps(__m64 _A)
+{
+  __m64  _Ext_val = _mm_cmpgt_pi8(_mm_setzero_si64(), _A);
+
+  return _mm_cvtpi16_ps(_mm_unpacklo_pi8(_A, _Ext_val));
+}
+
+
+ /******************************************************/
+ /*  NAME : _mm_cvtpu8_ps                              */
+ /*  DESCRIPTION : Convert 4 8-bit unsigned integer    */
+ /*                values to 4 single-precision float  */
+ /*                values                              */
+ /*  IN : __m64 _A                                      */
+ /*  OUT : none                                        */
+ /*  RETURN : __m128 : (float)_A                        */
+ /******************************************************/
+__inline __m128 _mm_cvtpu8_ps(__m64 _A)
+{
+  return _mm_cvtpu16_ps(_mm_unpacklo_pi8(_A, _mm_setzero_si64()));
+}
+
+
+ /******************************************************/
+ /*  NAME : _mm_cvtps_pi8                              */
+ /*  DESCRIPTION : Convert 4 single-precision float    */
+ /*                values to 4 8-bit integer values    */
+ /*  IN : __m128 _A                                     */
+ /*  OUT : none                                        */
+ /*  RETURN : __m64 : (char)_A                          */
+ /******************************************************/
+__inline __m64 _mm_cvtps_pi8(__m128 _A)
+{
+  return _mm_packs_pi16(_mm_cvtps_pi16(_A), _mm_setzero_si64());
+}
+
+
+ /******************************************************/
+ /*  NAME : _mm_cvtpi32x2_ps                           */
+ /*  DESCRIPTION : Convert 4 32-bit integer values     */
+ /*                to 4 single-precision float values  */
+ /*  IN : __m64 _A : operand 1                          */
+ /*       __m64 _B : operand 2                          */
+ /*  OUT : none                                        */
+ /*  RETURN : __m128 : (float)_A,(float)_B               */
+ /******************************************************/
+__inline __m128 _mm_cvtpi32x2_ps(__m64 _A, __m64 _B)
+{
+  return _mm_movelh_ps(_mm_cvt_pi2ps(_mm_setzero_ps(), _A),
+                       _mm_cvt_pi2ps(_mm_setzero_ps(), _B));
+}
+#pragma warning(pop)
+#endif // _M_IX86
+
+#pragma warning(pop) // disable: 28251
+
+#if defined __cplusplus
+}; /* End "C" */
+#endif  /* defined __cplusplus */
+
+#endif  /* defined (_M_CEE_PURE) */
+#endif  /* __midl */
+#endif  /* _INCLUDED_MM2 */
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xnode_handle.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xnode_handle.h
new file mode 100644
index 0000000000000000000000000000000000000000..2462a506e53a95556316c94394dffbb288658c45
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xnode_handle.h
@@ -0,0 +1,216 @@
+// xnode_handle.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XNODE_HANDLE_H
+#define _XNODE_HANDLE_H
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX17
+#error Node handles are only available with C++17. (Also, you should not include this internal header.)
+#endif // _HAS_CXX17
+
+#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
+
+template <class _Iterator, class _NodeType>
+struct _Insert_return_type {
+    _Iterator position;
+    bool inserted;
+    _NodeType node;
+};
+
+template <class _Derived_type, class _KeyTy, class _ValueTy>
+struct _Node_handle_map_base { // map-specific node handle behavior
+    using key_type    = _KeyTy;
+    using mapped_type = _ValueTy;
+
+    key_type& key() const noexcept /* strengthened */ {
+        return _Datum().first;
+    }
+    mapped_type& mapped() const noexcept /* strengthened */ {
+        return _Datum().second;
+    }
+
+private:
+    using _Pair_type = pair<key_type, mapped_type>;
+    _Pair_type& _Datum() const {
+        const auto& _Self = static_cast<const _Derived_type&>(*this);
+        auto& _Data       = _Self._Getptr()->_Myval;
+        // NB: Node handle requires formally-undefined behavior *somewhere*, this
+        // implementation chooses to type-pun pair<const K, T> as pair<K, T>.
+        return reinterpret_cast<_Pair_type&>(_Data);
+    }
+};
+
+template <class _Derived_type, class _ValueTy>
+struct _Node_handle_set_base { // set-specific node handle behavior
+    using value_type = _ValueTy;
+
+    value_type& value() const noexcept /* strengthened */ {
+        const auto& _Self = static_cast<const _Derived_type&>(*this);
+        return _Self._Getptr()->_Myval;
+    }
+};
+
+template <class _Node, class _Alloc, template <class...> class _Base, class... _Types>
+class _Node_handle : public _Base<_Node_handle<_Node, _Alloc, _Base, _Types...>, _Types...> {
+    // storage for a node from one of the node-based standard containers
+public:
+    using allocator_type = _Alloc;
+
+private:
+    using _Alty_traits   = allocator_traits<_Alloc>;
+    using _Alnode        = _Rebind_alloc_t<_Alloc, _Node>;
+    using _Alnode_traits = allocator_traits<_Alnode>;
+    using _Nodeptr       = typename _Alnode_traits::pointer;
+
+    _Nodeptr _Ptr{};
+    _Aligned_storage_t<sizeof(_Alloc), alignof(_Alloc)>
+        _Alloc_storage; // Invariant: contains a live _Alloc iff _Ptr != nullptr
+
+    void _Clear() noexcept { // destroy any contained node and return to the empty state
+        if (_Ptr != nullptr) {
+            _Alloc& _Al = _Getal();
+            _Alty_traits::destroy(_Al, _STD addressof(_Ptr->_Myval));
+            _Alnode _Node_alloc{_Al};
+            _Node::_Freenode0(_Node_alloc, _Ptr);
+            _Destroy_in_place(_Al);
+            _Ptr = nullptr;
+        }
+    }
+
+    _Node_handle(const _Nodeptr _Ptr_, const _Alloc& _Al) noexcept
+        : _Ptr{_Ptr_} { // Initialize a _Node_handle that holds the specified node
+                        // pre: _Alloc can release _Ptr
+        _STL_INTERNAL_CHECK(_Ptr_ != nullptr);
+        _Construct_in_place(_Getal(), _Al);
+    }
+
+public:
+    constexpr _Node_handle() noexcept : _Alloc_storage{} {}
+
+    ~_Node_handle() noexcept {
+        _Clear();
+    }
+
+    _Node_handle(_Node_handle&& _That) noexcept : _Ptr{_That._Ptr} { // steal node and allocator (if any) from _That
+        if (_Ptr != nullptr) {
+            _That._Ptr       = nullptr;
+            _Alloc& _That_al = _That._Getal();
+            _Construct_in_place(_Getal(), _STD move(_That_al));
+            _Destroy_in_place(_That_al);
+        }
+    }
+
+    _Node_handle& operator=(_Node_handle&& _That) noexcept /* strengthened */ {
+        // steal state from _That
+        if (_Ptr == nullptr) {
+            if (_That._Ptr != nullptr) {
+                _Alloc& _That_al = _That._Getal();
+                _Construct_in_place(_Getal(), _STD move(_That_al));
+                _Destroy_in_place(_That_al);
+                _Ptr = _STD exchange(_That._Ptr, nullptr);
+            }
+
+            return *this;
+        }
+
+        if (_That._Ptr == nullptr || this == _STD addressof(_That)) {
+            _Clear();
+            return *this;
+        }
+
+        _Alloc& _Al = _Getal();
+        _Alty_traits::destroy(_Al, _STD addressof(_Ptr->_Myval));
+        _Alnode _Node_alloc{_Al};
+        _Alnode_traits::deallocate(_Node_alloc, _Ptr, 1);
+
+        _Alloc& _That_al = _That._Getal();
+        _Pocma(_Al, _That_al);
+        _Destroy_in_place(_That_al);
+
+        _Ptr = _STD exchange(_That._Ptr, nullptr);
+        return *this;
+    }
+
+    _Nodeptr _Getptr() const noexcept {
+        return _Ptr;
+    }
+
+    _Alloc& _Getal() noexcept {
+        return reinterpret_cast<_Alloc&>(_Alloc_storage);
+    }
+    const _Alloc& _Getal() const noexcept {
+        _STL_INTERNAL_CHECK(!empty());
+        return reinterpret_cast<const _Alloc&>(_Alloc_storage);
+    }
+
+    _NODISCARD allocator_type get_allocator() const noexcept /* strengthened */ {
+        _STL_INTERNAL_CHECK(!empty());
+        return _Getal();
+    }
+
+    explicit operator bool() const noexcept {
+        return _Ptr != nullptr;
+    }
+
+    _NODISCARD bool empty() const noexcept {
+        return _Ptr == nullptr;
+    }
+
+    _Nodeptr _Release() noexcept { // extract the node from *this
+        _STL_INTERNAL_CHECK(!empty());
+        _Destroy_in_place(_Getal());
+        return _STD exchange(_Ptr, nullptr);
+    }
+
+    void swap(_Node_handle& _That) noexcept /* strengthened */ {
+        using _STD swap;
+        if (_Ptr != nullptr) {
+            if (_That._Ptr != nullptr) {
+                _Pocs(_Getal(), _That._Getal());
+            } else {
+                _Alloc& _Al = _Getal();
+                _Construct_in_place(_That._Getal(), _STD move(_Al));
+                _Destroy_in_place(_Al);
+            }
+        } else {
+            if (_That._Ptr == nullptr) {
+                return;
+            }
+
+            _Alloc& _That_al = _That._Getal();
+            _Construct_in_place(_Getal(), _STD move(_That_al));
+            _Destroy_in_place(_That_al);
+        }
+        swap(_Ptr, _That._Ptr); // intentional ADL
+    }
+    friend void swap(_Node_handle& _Left, _Node_handle& _Right) noexcept /* strengthened */ {
+        _Left.swap(_Right);
+    }
+
+    static _Node_handle _Make(const _Nodeptr _Ptr, const allocator_type& _Al) {
+        // initialize a _Node_handle that holds _Ptr and _Al
+        // pre: _Al can release _Ptr
+        _STL_INTERNAL_CHECK(_Ptr != nullptr);
+        return _Node_handle{_Ptr, _Al};
+    }
+};
+
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XNODE_HANDLE_H
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xpolymorphic_allocator.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xpolymorphic_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..ea0825c7c9ff0e2eba99198de25dcfbb2e593e6b
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xpolymorphic_allocator.h
@@ -0,0 +1,361 @@
+// xpolymorphic_allocator.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XPOLYMORPHIC_ALLOCATOR_H
+#define _XPOLYMORPHIC_ALLOCATOR_H
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#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
+
+#if !_HAS_CXX20
+template <class _Ty, class _Outer_alloc, class _Inner_alloc, class... _Types>
+void _Uses_alloc_construct_non_pair(_Ty* const _Ptr, _Outer_alloc& _Outer, _Inner_alloc& _Inner, _Types&&... _Args) {
+    // uses-allocator construction of *_Ptr by alloc _Outer propagating alloc _Inner, non-pair case
+    if constexpr (uses_allocator_v<remove_cv_t<_Ty>, _Inner_alloc>) {
+        if constexpr (is_constructible_v<_Ty, allocator_arg_t, _Inner_alloc&, _Types...>) {
+            allocator_traits<_Outer_alloc>::construct(
+                _Outer, _Ptr, allocator_arg, _Inner, _STD forward<_Types>(_Args)...);
+        } else {
+            static_assert(is_constructible_v<_Ty, _Types..., _Inner_alloc&>,
+                "N4950 [allocator.uses.trait]/1 requires "
+                "is_constructible_v<T, Args..., Alloc&> when uses_allocator_v<remove_cv_t<T>, Alloc> is true and "
+                "is_constructible_v<T, allocator_arg_t, Alloc&, Args...> is false");
+            allocator_traits<_Outer_alloc>::construct(_Outer, _Ptr, _STD forward<_Types>(_Args)..., _Inner);
+        }
+    } else {
+        static_assert(is_constructible_v<_Ty, _Types...>,
+            "N4950 [allocator.uses.trait]/1 requires "
+            "is_constructible_v<T, Args...> when uses_allocator_v<remove_cv_t<T>, Alloc> is false");
+        allocator_traits<_Outer_alloc>::construct(_Outer, _Ptr, _STD forward<_Types>(_Args)...);
+    }
+}
+
+template <class _Ty, class _Alloc, class... _Types>
+decltype(auto) _Uses_alloc_piecewise(_Alloc& _Al, tuple<_Types...>&& _Tuple) {
+    if constexpr (uses_allocator_v<remove_cv_t<_Ty>, _Alloc>) {
+        if constexpr (is_constructible_v<_Ty, allocator_arg_t, _Alloc&, _Types...>) {
+            return _STD tuple_cat(tuple<allocator_arg_t, _Alloc&>(allocator_arg, _Al), _STD move(_Tuple));
+        } else {
+            return _STD tuple_cat(_STD move(_Tuple), tuple<_Alloc&>(_Al));
+        }
+    } else {
+        return _STD move(_Tuple);
+    }
+}
+
+template <class _CvPair, class _Outer_alloc, class _Inner_alloc, class... _Types1, class... _Types2>
+void _Uses_alloc_construct_pair_piecewise(_CvPair* const _Ptr, _Outer_alloc& _Outer, _Inner_alloc& _Inner,
+    tuple<_Types1...>&& _Val1, tuple<_Types2...>&& _Val2) {
+    // uses-allocator construction of pair from _Val1 and _Val2 by alloc _Outer propagating alloc _Inner
+    allocator_traits<_Outer_alloc>::construct(_Outer, _Ptr, piecewise_construct,
+        _STD _Uses_alloc_piecewise<typename _CvPair::first_type>(_Inner, _STD move(_Val1)),
+        _STD _Uses_alloc_piecewise<typename _CvPair::second_type>(_Inner, _STD move(_Val2)));
+}
+
+template <class _CvPair, class _Outer_alloc, class _Inner_alloc, class... _Types1, class... _Types2>
+void _Uses_alloc_construct_pair(_CvPair* const _Ptr, _Outer_alloc& _Outer, _Inner_alloc& _Inner, piecewise_construct_t,
+    tuple<_Types1...> _Val1, tuple<_Types2...> _Val2) {
+    // uses-allocator construction of pair by alloc _Outer propagating alloc _Inner, piecewise case
+    _STD _Uses_alloc_construct_pair_piecewise(_Ptr, _Outer, _Inner, _STD move(_Val1), _STD move(_Val2));
+}
+
+template <class _CvPair, class _Outer_alloc, class _Inner_alloc>
+void _Uses_alloc_construct_pair(_CvPair* const _Ptr, _Outer_alloc& _Outer, _Inner_alloc& _Inner) {
+    // uses-allocator construction of pair by alloc _Outer propagating alloc _Inner, zero-argument case
+    _STD _Uses_alloc_construct_pair_piecewise(_Ptr, _Outer, _Inner, tuple<>{}, tuple<>{});
+}
+
+template <class _CvPair, class _Outer_alloc, class _Inner_alloc, class _Uty, class _Vty>
+void _Uses_alloc_construct_pair(
+    _CvPair* const _Ptr, _Outer_alloc& _Outer, _Inner_alloc& _Inner, _Uty&& _Arg1, _Vty&& _Arg2) {
+    // uses-allocator construction of pair by alloc _Outer propagating alloc _Inner, two-argument case
+    _STD _Uses_alloc_construct_pair_piecewise(_Ptr, _Outer, _Inner, _STD forward_as_tuple(_STD forward<_Uty>(_Arg1)),
+        _STD forward_as_tuple(_STD forward<_Vty>(_Arg2)));
+}
+
+template <class _CvPair, class _Outer_alloc, class _Inner_alloc, class _Uty, class _Vty>
+void _Uses_alloc_construct_pair(
+    _CvPair* const _Ptr, _Outer_alloc& _Outer, _Inner_alloc& _Inner, const pair<_Uty, _Vty>& _Pair) {
+    // uses-allocator construction of pair by alloc _Outer propagating alloc _Inner, lvalue pair argument
+    _STD _Uses_alloc_construct_pair_piecewise(
+        _Ptr, _Outer, _Inner, _STD forward_as_tuple(_Pair.first), _STD forward_as_tuple(_Pair.second));
+}
+
+template <class _CvPair, class _Outer_alloc, class _Inner_alloc, class _Uty, class _Vty>
+void _Uses_alloc_construct_pair(
+    _CvPair* const _Ptr, _Outer_alloc& _Outer, _Inner_alloc& _Inner, pair<_Uty, _Vty>&& _Pair) {
+    // uses-allocator construction of pair by alloc _Outer propagating alloc _Inner, rvalue pair argument
+    _STD _Uses_alloc_construct_pair_piecewise(_Ptr, _Outer, _Inner,
+        _STD forward_as_tuple(_STD forward<_Uty>(_Pair.first)),
+        _STD forward_as_tuple(_STD forward<_Vty>(_Pair.second)));
+}
+
+template <class _CvPair, class _Outer_alloc, class _Inner_alloc, class _Uty,
+    enable_if_t<!_Is_deducible_as_pair<_Uty>, int> = 0>
+void _Uses_alloc_construct_pair(_CvPair* const _Ptr, _Outer_alloc& _Outer, _Inner_alloc& _Inner, _Uty&& _Ux) {
+    // uses-allocator construction of pair by alloc _Outer propagating alloc _Inner, non-pair argument
+    static_assert(_Is_normally_bindable<remove_cv_t<_CvPair>, _Uty>,
+        "The argument must be bindable to a reference to the std::pair type.");
+
+    using _Pair_ref_t     = _Normally_bound_ref<remove_cv_t<_CvPair>, _Uty>;
+    _Pair_ref_t _Pair_ref = _STD forward<_Uty>(_Ux);
+    if constexpr (is_lvalue_reference_v<_Pair_ref_t>) {
+        _STD _Uses_alloc_construct_pair_piecewise(
+            _Ptr, _Outer, _Inner, _STD forward_as_tuple(_Pair_ref.first), _STD forward_as_tuple(_Pair_ref.second));
+    } else {
+        _STD _Uses_alloc_construct_pair_piecewise(_Ptr, _Outer, _Inner,
+            _STD forward_as_tuple(_STD forward<typename _CvPair::first_type>(_Pair_ref.first)),
+            _STD forward_as_tuple(_STD forward<typename _CvPair::second_type>(_Pair_ref.second)));
+    }
+}
+#endif // !_HAS_CXX20
+
+#if _HAS_CXX17
+namespace pmr {
+    _EXPORT_STD class __declspec(novtable) memory_resource {
+    public:
+        virtual ~memory_resource() noexcept = default;
+
+        _NODISCARD_RAW_PTR_ALLOC __declspec(allocator) void* allocate(_CRT_GUARDOVERFLOW const size_t _Bytes,
+            const size_t _Align = alignof(max_align_t)) { // allocate _Bytes bytes of memory with alignment _Align
+            _STL_ASSERT(_STD _Is_pow_2(_Align), "memory_resource::allocate(): Alignment must be a power of two.");
+            void* _Ptr = do_allocate(_Bytes, _Align);
+            return ::operator new(_Bytes, _Ptr);
+        }
+
+        void deallocate(void* const _Ptr, const size_t _Bytes, const size_t _Align = alignof(max_align_t)) {
+            // deallocate _Ptr, which was returned from allocate(_Bytes, _Align)
+            _STL_ASSERT(_STD _Is_pow_2(_Align), "memory_resource::deallocate(): Alignment must be a power of two.");
+            return do_deallocate(_Ptr, _Bytes, _Align);
+        }
+
+        _NODISCARD bool is_equal(const memory_resource& _That) const noexcept {
+            // determine if *this and _That can both deallocate memory allocated by either
+            return do_is_equal(_That);
+        }
+
+    private:
+        virtual void* do_allocate(size_t _Bytes, size_t _Align)               = 0;
+        virtual void do_deallocate(void* _Ptr, size_t _Bytes, size_t _Align)  = 0;
+        virtual bool do_is_equal(const memory_resource& _That) const noexcept = 0;
+    };
+
+    _EXPORT_STD _NODISCARD inline bool operator==(
+        const memory_resource& _Left, const memory_resource& _Right) noexcept {
+        return &_Left == &_Right || _Left.is_equal(_Right);
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD inline bool operator!=(const memory_resource& _Left, const memory_resource& _Right) noexcept {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    extern "C" _CRT_SATELLITE_1 memory_resource* __cdecl _Aligned_get_default_resource() noexcept;
+    extern "C" _CRT_SATELLITE_1 memory_resource* __cdecl _Unaligned_get_default_resource() noexcept;
+
+    _EXPORT_STD _NODISCARD inline memory_resource* get_default_resource() noexcept {
+#ifdef __cpp_aligned_new
+        return _STD pmr::_Aligned_get_default_resource();
+#else // ^^^ defined(__cpp_aligned_new) / !defined(__cpp_aligned_new) vvv
+        return _STD pmr::_Unaligned_get_default_resource();
+#endif // ^^^ !defined(__cpp_aligned_new) ^^^
+    }
+
+#if _HAS_CXX20
+    template <class _Uty>
+    struct _NODISCARD _Deallocate_bytes_guard {
+        ~_Deallocate_bytes_guard() noexcept {
+            if (_Mem_res) {
+                _Mem_res->deallocate(_Pobj, sizeof(_Uty), alignof(_Uty));
+            }
+        }
+
+        _Deallocate_bytes_guard& operator=(const _Deallocate_bytes_guard&) = delete;
+        _Deallocate_bytes_guard& operator=(_Deallocate_bytes_guard&&)      = delete;
+
+        memory_resource* _Mem_res;
+        void* _Pobj;
+    };
+#endif // _HAS_CXX20
+
+#if _HAS_CXX20 && defined(__cpp_lib_byte)
+    _EXPORT_STD template <class _Ty = byte>
+#else // ^^^ _HAS_CXX20 && defined(__cpp_lib_byte) / !_HAS_CXX20 || !defined(__cpp_lib_byte) vvv
+    _EXPORT_STD template <class _Ty>
+#endif // ^^^ !_HAS_CXX20 || !defined(__cpp_lib_byte) ^^^
+    class polymorphic_allocator {
+    public:
+        template <class>
+        friend class polymorphic_allocator;
+
+        using value_type = _Ty;
+
+        polymorphic_allocator() noexcept = default;
+
+        /* implicit */ polymorphic_allocator(memory_resource* const _Resource_) noexcept // strengthened
+            : _Resource{_Resource_} { // initialize with _Resource_
+            _STL_ASSERT(_Resource,
+                "Cannot initialize polymorphic_allocator with null resource (N4950 [mem.poly.allocator.ctor]/2)");
+        }
+
+        polymorphic_allocator(const polymorphic_allocator&) = default;
+
+        template <class _Uty>
+        polymorphic_allocator(const polymorphic_allocator<_Uty>& _That) noexcept
+            : _Resource{_That._Resource} {} // initialize with _That's resource
+
+        polymorphic_allocator& operator=(const polymorphic_allocator&) = delete;
+
+        _NODISCARD_RAW_PTR_ALLOC __declspec(allocator) _Ty* allocate(_CRT_GUARDOVERFLOW const size_t _Count) {
+            // get space for _Count objects of type _Ty from _Resource
+            void* const _Vp = _Resource->allocate(_Get_size_of_n<sizeof(_Ty)>(_Count), alignof(_Ty));
+            return static_cast<_Ty*>(_Vp);
+        }
+
+        void deallocate(_Ty* const _Ptr, const size_t _Count) noexcept /* strengthened */ {
+            // return space for _Count objects of type _Ty to _Resource
+            // No need to verify that size_t can represent the size of _Ty[_Count].
+            _Resource->deallocate(_Ptr, _Count * sizeof(_Ty), alignof(_Ty));
+        }
+
+#if _HAS_CXX20
+        _NODISCARD_RAW_PTR_ALLOC __declspec(allocator) void* allocate_bytes(
+            const size_t _Bytes, const size_t _Align = alignof(max_align_t)) {
+            return _Resource->allocate(_Bytes, _Align);
+        }
+
+        void deallocate_bytes(void* const _Ptr, const size_t _Bytes,
+            const size_t _Align = alignof(max_align_t)) noexcept /* strengthened */ {
+            _Resource->deallocate(_Ptr, _Bytes, _Align);
+        }
+
+        template <class _Uty>
+        _NODISCARD_RAW_PTR_ALLOC __declspec(allocator) _Uty* allocate_object(
+            _CRT_GUARDOVERFLOW const size_t _Count = 1) {
+            void* const _Vp = allocate_bytes(_Get_size_of_n<sizeof(_Uty)>(_Count), alignof(_Uty));
+            return static_cast<_Uty*>(_Vp);
+        }
+
+        template <class _Uty>
+        void deallocate_object(_Uty* const _Ptr, const size_t _Count = 1) noexcept /* strengthened */ {
+            deallocate_bytes(_Ptr, _Count * sizeof(_Uty), alignof(_Uty));
+        }
+
+        template <class _Uty, class... _Types>
+        _NODISCARD_RAW_PTR_ALLOC __declspec(allocator) _Uty* new_object(_Types&&... _Args) {
+            _Uty* const _Ptr = allocate_object<_Uty>();
+
+            _Deallocate_bytes_guard<_Uty> _Guard{_Resource, _Ptr};
+            construct(_Ptr, _STD forward<_Types>(_Args)...);
+            _Guard._Mem_res = nullptr;
+
+            return _Ptr;
+        }
+
+        template <class _Uty>
+        void delete_object(_Uty* const _Ptr) noexcept /* strengthened */ {
+            _Ptr->~_Uty();
+            deallocate_object(_Ptr);
+        }
+#endif // _HAS_CXX20
+
+        template <class _Uty, class... _Types>
+        void construct(_Uty* const _Ptr, _Types&&... _Args) {
+            // propagate allocator *this if uses_allocator_v<remove_cv_t<_Uty>, polymorphic_allocator>
+#if _HAS_CXX20
+            // equivalent to calling uninitialized_construct_using_allocator except for handling of cv-qualification
+            _STD apply(
+                [_Ptr](auto&&... _Construct_args) {
+                    return ::new (const_cast<void*>(static_cast<const volatile void*>(_Ptr)))
+                        _Uty(_STD forward<decltype(_Construct_args)>(_Construct_args)...);
+                },
+                _STD uses_allocator_construction_args<_Uty>(*this, _STD forward<_Types>(_Args)...));
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+            allocator<char> _Al{};
+            if constexpr (_Is_cv_pair<_Uty>) {
+                _STD _Uses_alloc_construct_pair(_Ptr, _Al, *this, _STD forward<_Types>(_Args)...);
+            } else {
+                _STD _Uses_alloc_construct_non_pair(_Ptr, _Al, *this, _STD forward<_Types>(_Args)...);
+            }
+#endif // ^^^ !_HAS_CXX20 ^^^
+        }
+
+        template <class _Uty>
+        void destroy(_Uty* const _Ptr) noexcept /* strengthened */ {
+            _Ptr->~_Uty();
+        }
+
+        _NODISCARD polymorphic_allocator select_on_container_copy_construction() const noexcept /* strengthened */ {
+            // don't propagate on copy
+            return {};
+        }
+
+        _NODISCARD memory_resource* resource() const noexcept /* strengthened */ {
+            // retrieve this allocator's memory_resource
+            return _Resource;
+        }
+
+        _NODISCARD friend bool operator==(
+            const polymorphic_allocator& _Lhs, const polymorphic_allocator& _Rhs) noexcept {
+            return *_Lhs._Resource == *_Rhs._Resource;
+        }
+
+#if !_HAS_CXX20
+        _NODISCARD friend bool operator!=(
+            const polymorphic_allocator& _Lhs, const polymorphic_allocator& _Rhs) noexcept {
+            return *_Lhs._Resource != *_Rhs._Resource;
+        }
+#endif // !_HAS_CXX20
+
+    private:
+        memory_resource* _Resource = _STD pmr::get_default_resource();
+    };
+
+    _EXPORT_STD template <class _Ty1, class _Ty2>
+    _NODISCARD bool operator==(
+        const polymorphic_allocator<_Ty1>& _Left, const polymorphic_allocator<_Ty2>& _Right) noexcept {
+        // polymorphic_allocators with the same resource are compatible
+        return *_Left.resource() == *_Right.resource();
+    }
+
+#if !_HAS_CXX20
+    template <class _Ty1, class _Ty2>
+    _NODISCARD bool operator!=(
+        const polymorphic_allocator<_Ty1>& _Left, const polymorphic_allocator<_Ty2>& _Right) noexcept {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+} // namespace pmr
+
+template <class _Ty, class _Ptr>
+struct _Has_no_alloc_destroy<pmr::polymorphic_allocator<_Ty>, _Ptr, void> : true_type {
+    // polymorphic_allocator technically _does_ have a destroy member, but it's equivalent to the
+    // default implementation in allocator_traits so we can optimize it away.
+};
+
+#endif // _HAS_CXX17
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XPOLYMORPHIC_ALLOCATOR_H
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xsmf_control.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xsmf_control.h
new file mode 100644
index 0000000000000000000000000000000000000000..381f0499f7fa5869f15b9bf387386d3dc52e5844
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xsmf_control.h
@@ -0,0 +1,169 @@
+// xsmf_control.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XSMF_CONTROL_H
+#define _XSMF_CONTROL_H
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#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 <class _Base>
+struct _Non_trivial_copy : _Base { // non-trivial copy construction facade
+    using _Base::_Base;
+
+    _Non_trivial_copy() = default;
+    _CONSTEXPR20 _Non_trivial_copy(const _Non_trivial_copy& _That) noexcept(
+        noexcept(_Base::_Construct_from(static_cast<const _Base&>(_That)))) {
+        _Base::_Construct_from(static_cast<const _Base&>(_That));
+    }
+    _Non_trivial_copy(_Non_trivial_copy&&)                 = default;
+    _Non_trivial_copy& operator=(const _Non_trivial_copy&) = default;
+    _Non_trivial_copy& operator=(_Non_trivial_copy&&)      = default;
+};
+
+template <class _Base>
+struct _Deleted_copy : _Base { // deleted copy construction facade
+    using _Base::_Base;
+
+    _Deleted_copy()                                = default;
+    _Deleted_copy(const _Deleted_copy&)            = delete;
+    _Deleted_copy(_Deleted_copy&&)                 = default;
+    _Deleted_copy& operator=(const _Deleted_copy&) = default;
+    _Deleted_copy& operator=(_Deleted_copy&&)      = default;
+};
+
+template <class _Base, class... _Types>
+using _SMF_control_copy = conditional_t<conjunction_v<is_trivially_copy_constructible<_Types>...>, _Base,
+    conditional_t<conjunction_v<is_copy_constructible<_Types>...>, _Non_trivial_copy<_Base>, _Deleted_copy<_Base>>>;
+
+template <class _Base, class... _Types>
+struct _Non_trivial_move : _SMF_control_copy<_Base, _Types...> { // non-trivial move construction facade
+    using _Mybase = _SMF_control_copy<_Base, _Types...>;
+    using _Mybase::_Mybase;
+
+    _Non_trivial_move()                         = default;
+    _Non_trivial_move(const _Non_trivial_move&) = default;
+    _CONSTEXPR20 _Non_trivial_move(_Non_trivial_move&& _That) noexcept(
+        noexcept(_Mybase::_Construct_from(static_cast<_Base&&>(_That)))) {
+        _Mybase::_Construct_from(static_cast<_Base&&>(_That));
+    }
+    _Non_trivial_move& operator=(const _Non_trivial_move&) = default;
+    _Non_trivial_move& operator=(_Non_trivial_move&&)      = default;
+};
+
+template <class _Base, class... _Types>
+struct _Deleted_move : _SMF_control_copy<_Base, _Types...> { // deleted move construction facade
+    using _Mybase = _SMF_control_copy<_Base, _Types...>;
+    using _Mybase::_Mybase;
+
+    _Deleted_move()                                = default;
+    _Deleted_move(const _Deleted_move&)            = default;
+    _Deleted_move(_Deleted_move&&)                 = delete;
+    _Deleted_move& operator=(const _Deleted_move&) = default;
+    _Deleted_move& operator=(_Deleted_move&&)      = default;
+};
+
+template <class _Base, class... _Types>
+using _SMF_control_move =
+    conditional_t<conjunction_v<is_trivially_move_constructible<_Types>...>, _SMF_control_copy<_Base, _Types...>,
+        conditional_t<conjunction_v<is_move_constructible<_Types>...>, _Non_trivial_move<_Base, _Types...>,
+            _Deleted_move<_Base, _Types...>>>;
+
+template <class _Base, class... _Types>
+struct _Non_trivial_copy_assign : _SMF_control_move<_Base, _Types...> { // non-trivial copy assignment facade
+    using _Mybase = _SMF_control_move<_Base, _Types...>;
+    using _Mybase::_Mybase;
+
+    _Non_trivial_copy_assign()                                = default;
+    _Non_trivial_copy_assign(const _Non_trivial_copy_assign&) = default;
+    _Non_trivial_copy_assign(_Non_trivial_copy_assign&&)      = default;
+
+    _CONSTEXPR20 _Non_trivial_copy_assign& operator=(const _Non_trivial_copy_assign& _That) noexcept(
+        noexcept(_Mybase::_Assign_from(static_cast<const _Base&>(_That)))) {
+        _Mybase::_Assign_from(static_cast<const _Base&>(_That));
+        return *this;
+    }
+    _Non_trivial_copy_assign& operator=(_Non_trivial_copy_assign&&) = default;
+};
+
+template <class _Base, class... _Types>
+struct _Deleted_copy_assign : _SMF_control_move<_Base, _Types...> { // deleted copy assignment facade
+    using _Mybase = _SMF_control_move<_Base, _Types...>;
+    using _Mybase::_Mybase;
+
+    _Deleted_copy_assign()                                       = default;
+    _Deleted_copy_assign(const _Deleted_copy_assign&)            = default;
+    _Deleted_copy_assign(_Deleted_copy_assign&&)                 = default;
+    _Deleted_copy_assign& operator=(const _Deleted_copy_assign&) = delete;
+    _Deleted_copy_assign& operator=(_Deleted_copy_assign&&)      = default;
+};
+
+template <class _Base, class... _Types>
+using _SMF_control_copy_assign =
+    conditional_t<conjunction_v<is_trivially_destructible<_Types>..., is_trivially_copy_constructible<_Types>...,
+                      is_trivially_copy_assignable<_Types>...>,
+        _SMF_control_move<_Base, _Types...>,
+        conditional_t<conjunction_v<is_copy_constructible<_Types>..., is_copy_assignable<_Types>...>,
+            _Non_trivial_copy_assign<_Base, _Types...>, _Deleted_copy_assign<_Base, _Types...>>>;
+
+template <class _Base, class... _Types>
+struct _Non_trivial_move_assign : _SMF_control_copy_assign<_Base, _Types...> { // non-trivial move assignment facade
+    using _Mybase = _SMF_control_copy_assign<_Base, _Types...>;
+    using _Mybase::_Mybase;
+
+    _Non_trivial_move_assign()                                           = default;
+    _Non_trivial_move_assign(const _Non_trivial_move_assign&)            = default;
+    _Non_trivial_move_assign(_Non_trivial_move_assign&&)                 = default;
+    _Non_trivial_move_assign& operator=(const _Non_trivial_move_assign&) = default;
+
+    _CONSTEXPR20 _Non_trivial_move_assign& operator=(_Non_trivial_move_assign&& _That) noexcept(
+        noexcept(_Mybase::_Assign_from(static_cast<_Base&&>(_That)))) {
+        _Mybase::_Assign_from(static_cast<_Base&&>(_That));
+        return *this;
+    }
+};
+
+template <class _Base, class... _Types>
+struct _Deleted_move_assign : _SMF_control_copy_assign<_Base, _Types...> { // deleted move assignment facade
+    using _Mybase = _SMF_control_copy_assign<_Base, _Types...>;
+    using _Mybase::_Mybase;
+
+    _Deleted_move_assign()                                       = default;
+    _Deleted_move_assign(const _Deleted_move_assign&)            = default;
+    _Deleted_move_assign(_Deleted_move_assign&&)                 = default;
+    _Deleted_move_assign& operator=(const _Deleted_move_assign&) = default;
+    _Deleted_move_assign& operator=(_Deleted_move_assign&&)      = delete;
+};
+
+template <class _Base, class... _Types>
+using _SMF_control_move_assign =
+    conditional_t<conjunction_v<is_trivially_destructible<_Types>..., is_trivially_move_constructible<_Types>...,
+                      is_trivially_move_assignable<_Types>...>,
+        _SMF_control_copy_assign<_Base, _Types...>,
+        conditional_t<conjunction_v<is_move_constructible<_Types>..., is_move_assignable<_Types>...>,
+            _Non_trivial_move_assign<_Base, _Types...>, _Deleted_move_assign<_Base, _Types...>>>;
+
+template <class _Base, class... _Types>
+using _SMF_control = _SMF_control_move_assign<_Base, _Types...>;
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XSMF_CONTROL_H
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xstring b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xstring
new file mode 100644
index 0000000000000000000000000000000000000000..7b458d16c5b30b48e8cd046787fee63147c7eec7
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xstring
@@ -0,0 +1,3490 @@
+// xstring internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XSTRING_
+#define _XSTRING_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <__msvc_sanitizer_annotate_container.hpp>
+#include <__msvc_string_view.hpp>
+#include <iosfwd>
+#include <xmemory>
+
+#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 _Mystr>
+class _String_const_iterator : public _Iterator_base {
+public:
+#if _HAS_CXX20
+    using iterator_concept = contiguous_iterator_tag;
+#endif // _HAS_CXX20
+    using iterator_category = random_access_iterator_tag;
+    using value_type        = typename _Mystr::value_type;
+    using difference_type   = typename _Mystr::difference_type;
+    using pointer           = typename _Mystr::const_pointer;
+    using reference         = const value_type&;
+
+    _CONSTEXPR20 _String_const_iterator() noexcept : _Ptr() {}
+
+    _CONSTEXPR20 _String_const_iterator(pointer _Parg, const _Container_base* _Pstring) noexcept : _Ptr(_Parg) {
+        this->_Adopt(_Pstring);
+    }
+
+    _NODISCARD _CONSTEXPR20 reference operator*() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _STL_VERIFY(_Ptr, "cannot dereference value-initialized string iterator");
+        const auto _Mycont = static_cast<const _Mystr*>(this->_Getcont());
+        _STL_VERIFY(_Mycont, "cannot dereference string iterator because the iterator was "
+                             "invalidated (e.g. reallocation occurred, or the string was destroyed)");
+        const auto _Contptr = _Mycont->_Myptr();
+        const auto _Rawptr  = _Unfancy(_Ptr);
+        _STL_VERIFY(_Contptr <= _Rawptr && _Rawptr < _Contptr + _Mycont->_Mysize,
+            "cannot dereference string iterator because it is out of range (e.g. an end iterator)");
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+
+        _Analysis_assume_(_Ptr);
+        return *_Ptr;
+    }
+
+    _NODISCARD _CONSTEXPR20 pointer operator->() const noexcept {
+        return pointer_traits<pointer>::pointer_to(**this);
+    }
+
+    _CONSTEXPR20 _String_const_iterator& operator++() noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _STL_VERIFY(_Ptr, "cannot increment value-initialized string iterator");
+        const auto _Mycont = static_cast<const _Mystr*>(this->_Getcont());
+        _STL_VERIFY(_Mycont, "cannot increment string iterator because the iterator was "
+                             "invalidated (e.g. reallocation occurred, or the string was destroyed)");
+        _STL_VERIFY(_Unfancy(_Ptr) < _Mycont->_Myptr() + _Mycont->_Mysize, "cannot increment string iterator past end");
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+
+        ++_Ptr;
+        return *this;
+    }
+
+    _CONSTEXPR20 _String_const_iterator operator++(int) noexcept {
+        _String_const_iterator _Tmp = *this;
+        ++*this;
+        return _Tmp;
+    }
+
+    _CONSTEXPR20 _String_const_iterator& operator--() noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _STL_VERIFY(_Ptr, "cannot decrement value-initialized string iterator");
+        const auto _Mycont = static_cast<const _Mystr*>(this->_Getcont());
+        _STL_VERIFY(_Mycont, "cannot decrement string iterator because the iterator was "
+                             "invalidated (e.g. reallocation occurred, or the string was destroyed)");
+        _STL_VERIFY(_Mycont->_Myptr() < _Unfancy(_Ptr), "cannot decrement string iterator before begin");
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+
+        --_Ptr;
+        return *this;
+    }
+
+    _CONSTEXPR20 _String_const_iterator operator--(int) noexcept {
+        _String_const_iterator _Tmp = *this;
+        --*this;
+        return _Tmp;
+    }
+
+    _CONSTEXPR20 void _Verify_offset(const difference_type _Off) const noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        if (_Off == 0) {
+            return;
+        }
+
+        _STL_ASSERT(_Ptr, "cannot seek value-initialized string iterator");
+        const auto _Mycont = static_cast<const _Mystr*>(this->_Getcont());
+        _STL_ASSERT(_Mycont, "cannot seek string iterator because the iterator was "
+                             "invalidated (e.g. reallocation occurred, or the string was destroyed)");
+        const auto _Contptr = _Mycont->_Myptr();
+        const auto _Rawptr  = _Unfancy(_Ptr);
+
+        if (_Off < 0) {
+            _STL_VERIFY(_Contptr - _Rawptr <= _Off, "cannot seek string iterator before begin");
+        }
+
+        if (_Off > 0) {
+            using _Size_type = typename _Mystr::size_type;
+            const auto _Left = _Mycont->_Mysize - static_cast<_Size_type>(_Rawptr - _Contptr);
+            _STL_VERIFY(static_cast<_Size_type>(_Off) <= _Left, "cannot seek string iterator after end");
+        }
+#else // ^^^ _ITERATOR_DEBUG_LEVEL >= 1 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+        (void) _Off;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+    }
+
+    _CONSTEXPR20 _String_const_iterator& operator+=(const difference_type _Off) noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _Verify_offset(_Off);
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+        _Ptr += _Off;
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR20 _String_const_iterator operator+(const difference_type _Off) const noexcept {
+        _String_const_iterator _Tmp = *this;
+        _Tmp += _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD friend _CONSTEXPR20 _String_const_iterator operator+(
+        const difference_type _Off, _String_const_iterator _Next) noexcept {
+        _Next += _Off;
+        return _Next;
+    }
+
+    _CONSTEXPR20 _String_const_iterator& operator-=(const difference_type _Off) noexcept {
+        return *this += -_Off;
+    }
+
+    _NODISCARD _CONSTEXPR20 _String_const_iterator operator-(const difference_type _Off) const noexcept {
+        _String_const_iterator _Tmp = *this;
+        _Tmp -= _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD _CONSTEXPR20 difference_type operator-(const _String_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return static_cast<difference_type>(_Ptr - _Right._Ptr);
+    }
+
+    _NODISCARD _CONSTEXPR20 reference operator[](const difference_type _Off) const noexcept {
+        return *(*this + _Off);
+    }
+
+    _NODISCARD _CONSTEXPR20 bool operator==(const _String_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return _Ptr == _Right._Ptr;
+    }
+
+#if _HAS_CXX20
+    _NODISCARD constexpr strong_ordering operator<=>(const _String_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return _STD _Unfancy_maybe_null(_Ptr) <=> _STD _Unfancy_maybe_null(_Right._Ptr);
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD bool operator!=(const _String_const_iterator& _Right) const noexcept {
+        return !(*this == _Right);
+    }
+
+    _NODISCARD bool operator<(const _String_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return _Ptr < _Right._Ptr;
+    }
+
+    _NODISCARD bool operator>(const _String_const_iterator& _Right) const noexcept {
+        return _Right < *this;
+    }
+
+    _NODISCARD bool operator<=(const _String_const_iterator& _Right) const noexcept {
+        return !(_Right < *this);
+    }
+
+    _NODISCARD bool operator>=(const _String_const_iterator& _Right) const noexcept {
+        return !(*this < _Right);
+    }
+#endif // !_HAS_CXX20
+
+    _CONSTEXPR20 void _Compat(const _String_const_iterator& _Right) const noexcept {
+        // test for compatible iterator pair
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _STL_VERIFY(this->_Getcont() == _Right._Getcont(),
+            "string iterators incompatible (e.g. point to different string instances)");
+#else // ^^^ _ITERATOR_DEBUG_LEVEL >= 1 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+        (void) _Right;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+    }
+
+#if _ITERATOR_DEBUG_LEVEL >= 1
+    friend _CONSTEXPR20 void _Verify_range(
+        const _String_const_iterator& _First, const _String_const_iterator& _Last) noexcept {
+        _STL_VERIFY(_First._Getcont() == _Last._Getcont(), "string iterators in range are from different containers");
+        _STL_VERIFY(_First._Ptr <= _Last._Ptr, "string iterator range transposed");
+    }
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+
+    using _Prevent_inheriting_unwrap = _String_const_iterator;
+
+    _NODISCARD _CONSTEXPR20 const value_type* _Unwrapped() const noexcept {
+        return _STD _Unfancy_maybe_null(_Ptr);
+    }
+
+    _CONSTEXPR20 void _Seek_to(const value_type* _It) noexcept {
+        _Ptr = _STD _Refancy_maybe_null<pointer>(const_cast<value_type*>(_It));
+    }
+
+    pointer _Ptr; // pointer to element in string
+};
+
+#if _HAS_CXX20
+template <class _Mystr>
+struct pointer_traits<_String_const_iterator<_Mystr>> {
+    using pointer         = _String_const_iterator<_Mystr>;
+    using element_type    = const pointer::value_type;
+    using difference_type = pointer::difference_type;
+
+    _NODISCARD static constexpr element_type* to_address(const pointer _Iter) noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        const auto _Mycont = static_cast<const _Mystr*>(_Iter._Getcont());
+        if (!_Mycont) {
+            _STL_VERIFY(!_Iter._Ptr, "cannot convert string iterator to pointer because the iterator was invalidated "
+                                     "(e.g. reallocation occurred, or the string was destroyed)");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+
+        const auto _Rawptr = _STD to_address(_Iter._Ptr);
+
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        if (_Mycont) {
+            const auto _Contptr = _Mycont->_Myptr();
+            _STL_VERIFY(_Contptr <= _Rawptr && _Rawptr <= _Contptr + _Mycont->_Mysize,
+                "cannot convert string iterator to pointer because it is out of range");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+
+        return _Rawptr;
+    }
+};
+#endif // _HAS_CXX20
+
+template <class _Mystr>
+class _String_iterator : public _String_const_iterator<_Mystr> {
+public:
+    using _Mybase = _String_const_iterator<_Mystr>;
+
+#if _HAS_CXX20
+    using iterator_concept = contiguous_iterator_tag;
+#endif // _HAS_CXX20
+    using iterator_category = random_access_iterator_tag;
+    using value_type        = typename _Mystr::value_type;
+    using difference_type   = typename _Mystr::difference_type;
+    using pointer           = typename _Mystr::pointer;
+    using reference         = value_type&;
+
+    using _Mybase::_Mybase;
+
+    _NODISCARD _CONSTEXPR20 reference operator*() const noexcept {
+        return const_cast<reference>(_Mybase::operator*());
+    }
+
+    _NODISCARD _CONSTEXPR20 pointer operator->() const noexcept {
+        return pointer_traits<pointer>::pointer_to(**this);
+    }
+
+    _CONSTEXPR20 _String_iterator& operator++() noexcept {
+        _Mybase::operator++();
+        return *this;
+    }
+
+    _CONSTEXPR20 _String_iterator operator++(int) noexcept {
+        _String_iterator _Tmp = *this;
+        _Mybase::operator++();
+        return _Tmp;
+    }
+
+    _CONSTEXPR20 _String_iterator& operator--() noexcept {
+        _Mybase::operator--();
+        return *this;
+    }
+
+    _CONSTEXPR20 _String_iterator operator--(int) noexcept {
+        _String_iterator _Tmp = *this;
+        _Mybase::operator--();
+        return _Tmp;
+    }
+
+    _CONSTEXPR20 _String_iterator& operator+=(const difference_type _Off) noexcept {
+        _Mybase::operator+=(_Off);
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR20 _String_iterator operator+(const difference_type _Off) const noexcept {
+        _String_iterator _Tmp = *this;
+        _Tmp += _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD friend _CONSTEXPR20 _String_iterator operator+(
+        const difference_type _Off, _String_iterator _Next) noexcept {
+        _Next += _Off;
+        return _Next;
+    }
+
+    _CONSTEXPR20 _String_iterator& operator-=(const difference_type _Off) noexcept {
+        _Mybase::operator-=(_Off);
+        return *this;
+    }
+
+    using _Mybase::operator-;
+
+    _NODISCARD _CONSTEXPR20 _String_iterator operator-(const difference_type _Off) const noexcept {
+        _String_iterator _Tmp = *this;
+        _Tmp -= _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD _CONSTEXPR20 reference operator[](const difference_type _Off) const noexcept {
+        return const_cast<reference>(_Mybase::operator[](_Off));
+    }
+
+    using _Prevent_inheriting_unwrap = _String_iterator;
+
+    _NODISCARD _CONSTEXPR20 value_type* _Unwrapped() const noexcept {
+        return const_cast<value_type*>(_STD _Unfancy_maybe_null(this->_Ptr));
+    }
+};
+
+#if _HAS_CXX20
+template <class _Mystr>
+struct pointer_traits<_String_iterator<_Mystr>> {
+    using pointer         = _String_iterator<_Mystr>;
+    using element_type    = pointer::value_type;
+    using difference_type = pointer::difference_type;
+
+    _NODISCARD static constexpr element_type* to_address(const pointer _Iter) noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        const auto _Mycont = static_cast<const _Mystr*>(_Iter._Getcont());
+        if (!_Mycont) {
+            _STL_VERIFY(!_Iter._Ptr, "cannot convert string iterator to pointer because the iterator was invalidated "
+                                     "(e.g. reallocation occurred, or the string was destroyed)");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+
+        const auto _Rawptr = _STD to_address(_Iter._Ptr);
+
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        if (_Mycont) {
+            const auto _Contptr = _Mycont->_Myptr();
+            _STL_VERIFY(_Contptr <= _Rawptr && _Rawptr <= _Contptr + _Mycont->_Mysize,
+                "cannot convert string iterator to pointer because it is out of range");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+
+        return const_cast<element_type*>(_Rawptr);
+    }
+};
+#endif // _HAS_CXX20
+
+template <class _Value_type, class _Size_type, class _Difference_type, class _Pointer, class _Const_pointer>
+struct _String_iter_types {
+    using value_type      = _Value_type;
+    using size_type       = _Size_type;
+    using difference_type = _Difference_type;
+    using pointer         = _Pointer;
+    using const_pointer   = _Const_pointer;
+};
+
+template <class _Val_types>
+class _String_val : public _Container_base {
+public:
+    using value_type      = typename _Val_types::value_type;
+    using size_type       = typename _Val_types::size_type;
+    using difference_type = typename _Val_types::difference_type;
+    using pointer         = typename _Val_types::pointer;
+    using const_pointer   = typename _Val_types::const_pointer;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+
+    _CONSTEXPR20 _String_val() noexcept : _Bx() {}
+
+    // length of internal buffer, [1, 16] (NB: used by the debugger visualizer)
+    static constexpr size_type _BUF_SIZE = 16 / sizeof(value_type) < 1 ? 1 : 16 / sizeof(value_type);
+    // roundup mask for allocated buffers, [0, 15]
+    static constexpr size_type _Alloc_mask = sizeof(value_type) <= 1 ? 15
+                                           : sizeof(value_type) <= 2 ? 7
+                                           : sizeof(value_type) <= 4 ? 3
+                                           : sizeof(value_type) <= 8 ? 1
+                                                                     : 0;
+    // capacity in small mode
+    static constexpr size_type _Small_string_capacity = _BUF_SIZE - 1;
+
+    _NODISCARD _CONSTEXPR20 value_type* _Myptr() noexcept {
+        value_type* _Result = _Bx._Buf;
+        if (_Large_mode_engaged()) {
+            _Result = _Unfancy(_Bx._Ptr);
+        }
+
+        return _Result;
+    }
+
+    _NODISCARD _CONSTEXPR20 const value_type* _Myptr() const noexcept {
+        const value_type* _Result = _Bx._Buf;
+        if (_Large_mode_engaged()) {
+            _Result = _Unfancy(_Bx._Ptr);
+        }
+
+        return _Result;
+    }
+
+    _NODISCARD _CONSTEXPR20 bool _Large_mode_engaged() const noexcept {
+        return _Myres > _Small_string_capacity;
+    }
+
+    _CONSTEXPR20 void _Activate_SSO_buffer() noexcept {
+        // start the lifetime of the array elements
+#if _HAS_CXX20
+        if (_STD is_constant_evaluated()) {
+            for (size_type _Idx = 0; _Idx < _BUF_SIZE; ++_Idx) {
+                _Bx._Buf[_Idx] = value_type();
+            }
+        }
+#endif // _HAS_CXX20
+    }
+
+    _CONSTEXPR20 void _Check_offset(const size_type _Off) const {
+        // checks whether _Off is in the bounds of [0, size()]
+        if (_Mysize < _Off) {
+            _Xran();
+        }
+    }
+
+    _CONSTEXPR20 void _Check_offset_exclusive(const size_type _Off) const {
+        // checks whether _Off is in the bounds of [0, size())
+        if (_Mysize <= _Off) {
+            _Xran();
+        }
+    }
+
+    [[noreturn]] static void _Xran() {
+        _Xout_of_range("invalid string position");
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type _Clamp_suffix_size(const size_type _Off, const size_type _Size) const noexcept {
+        // trims _Size to the longest it can be assuming a string at/after _Off
+        return (_STD min)(_Size, _Mysize - _Off);
+    }
+
+    union _Bxty { // storage for small buffer or pointer to larger one
+        // This constructor previously initialized _Ptr. Don't rely on the new behavior without
+        // renaming `_String_val` (and fixing the visualizer).
+        _CONSTEXPR20 _Bxty() noexcept : _Buf() {} // user-provided, for fancy pointers
+        _CONSTEXPR20 ~_Bxty() noexcept {} // user-provided, for fancy pointers
+
+        value_type _Buf[_BUF_SIZE];
+        pointer _Ptr;
+        char _Alias[_BUF_SIZE]; // TRANSITION, ABI: _Alias is preserved for binary compatibility (especially /clr)
+
+        _CONSTEXPR20 void _Switch_to_buf() noexcept {
+            _STD _Destroy_in_place(_Ptr);
+
+#if _HAS_CXX20
+            // start the lifetime of the array elements
+            if (_STD is_constant_evaluated()) {
+                for (size_type _Idx = 0; _Idx < _BUF_SIZE; ++_Idx) {
+                    _Buf[_Idx] = value_type();
+                }
+            }
+#endif // _HAS_CXX20
+        }
+    };
+    _Bxty _Bx;
+
+    // invariant: _Myres >= _Mysize, and _Myres >= _Small_string_capacity (after string's construction)
+    // neither _Mysize nor _Myres takes account of the extra null terminator
+    size_type _Mysize = 0; // current length of string (size)
+    size_type _Myres  = 0; // current storage reserved for string (capacity)
+};
+
+// get _Ty's size after being EBCO'd
+template <class _Ty>
+constexpr size_t _Size_after_ebco_v = is_empty_v<_Ty> ? 0 : sizeof(_Ty);
+
+struct _String_constructor_concat_tag {
+    // tag to select constructors used by basic_string's concatenation operators (operator+)
+    explicit _String_constructor_concat_tag() = default;
+};
+
+struct _String_constructor_rvalue_allocator_tag {
+    // tag to select constructors used by basic_stringbuf's rvalue str()
+    explicit _String_constructor_rvalue_allocator_tag() = default;
+};
+
+[[noreturn]] inline void _Xlen_string() {
+    _Xlength_error("string too long");
+}
+
+#if _HAS_CXX23
+template <class _Rng, class _Ty>
+concept _Contiguous_range_of =
+    (_RANGES contiguous_range<_Rng>) &&same_as<remove_cvref_t<_RANGES range_reference_t<_Rng>>, _Ty>;
+#endif // _HAS_CXX23
+
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
+class basic_string { // null-terminated transparent array of elements
+private:
+    friend _Tidy_deallocate_guard<basic_string>;
+    friend basic_stringbuf<_Elem, _Traits, _Alloc>;
+
+    using _Alty        = _Rebind_alloc_t<_Alloc, _Elem>;
+    using _Alty_traits = allocator_traits<_Alty>;
+
+    using _Scary_val = _String_val<conditional_t<_Is_simple_alloc_v<_Alty>, _Simple_types<_Elem>,
+        _String_iter_types<_Elem, typename _Alty_traits::size_type, typename _Alty_traits::difference_type,
+            typename _Alty_traits::pointer, typename _Alty_traits::const_pointer>>>;
+
+    static_assert(!_ENFORCE_MATCHING_ALLOCATORS || is_same_v<_Elem, typename _Alloc::value_type>,
+        _MISMATCHED_ALLOCATOR_MESSAGE("basic_string<T, Traits, Allocator>", "T"));
+
+    static_assert(is_same_v<_Elem, typename _Traits::char_type>,
+        "N4950 [string.require]/3 requires that the supplied "
+        "char_traits character type match the string's character type.");
+
+    static_assert(!is_array_v<_Elem> && is_trivial_v<_Elem> && is_standard_layout_v<_Elem>,
+        "The character type of basic_string must be a non-array trivial standard-layout type. See N4950 "
+        "[strings.general]/1.");
+
+public:
+    using traits_type    = _Traits;
+    using allocator_type = _Alloc;
+
+    using value_type      = _Elem;
+    using size_type       = typename _Alty_traits::size_type;
+    using difference_type = typename _Alty_traits::difference_type;
+    using pointer         = typename _Alty_traits::pointer;
+    using const_pointer   = typename _Alty_traits::const_pointer;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+
+    using iterator       = _String_iterator<_Scary_val>;
+    using const_iterator = _String_const_iterator<_Scary_val>;
+
+    using reverse_iterator       = _STD reverse_iterator<iterator>;
+    using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
+
+private:
+    static constexpr size_type _BUF_SIZE              = _Scary_val::_BUF_SIZE;
+    static constexpr size_type _Alloc_mask            = _Scary_val::_Alloc_mask;
+    static constexpr size_type _Small_string_capacity = _Scary_val::_Small_string_capacity;
+
+    // least real allocation size, including space reserved for terminating null
+    static constexpr size_type _Least_allocation_size = _Small_string_capacity + 1 + 1;
+
+    // When doing _String_val operations by memcpy, we are touching:
+    //   _String_val::_Bx::_Buf (type is array of _Elem)
+    //   _String_val::_Bx::_Ptr (type is pointer)
+    //   _String_val::_Mysize   (type is size_type)
+    //   _String_val::_Myres    (type is size_type)
+    // N4950 [strings.general]/1 says _Elem must be trivial standard-layout, so memcpy is safe.
+    // We need to ask if pointer is safe to memcpy.
+    // size_type must be an unsigned integral type so memcpy is safe.
+    // We also need to disable memcpy if the user has supplied _Traits, since
+    //   they can observe traits::assign and similar.
+    static constexpr bool _Can_memcpy_val = _Is_specialization_v<_Traits, char_traits> && is_trivial_v<pointer>;
+    // This offset skips over the _Container_base members, if any
+    static constexpr size_t _Memcpy_val_offset = _Size_after_ebco_v<_Container_base>;
+    static constexpr size_t _Memcpy_val_size   = sizeof(_Scary_val) - _Memcpy_val_offset;
+
+    template <class _Iter>
+    // TRANSITION, /clr:pure is incompatible with templated static constexpr data members
+    // static constexpr bool _Is_elem_cptr =_Is_any_of_v<_Iter, const _Elem* const, _Elem* const, const _Elem*, _Elem*>;
+    using _Is_elem_cptr = bool_constant<_Is_any_of_v<_Iter, const _Elem* const, _Elem* const, const _Elem*, _Elem*>>;
+
+#if _HAS_CXX17
+    template <class _StringViewIsh>
+    using _Is_string_view_ish =
+        enable_if_t<conjunction_v<is_convertible<const _StringViewIsh&, basic_string_view<_Elem, _Traits>>,
+                        negation<is_convertible<const _StringViewIsh&, const _Elem*>>>,
+            int>;
+#endif // _HAS_CXX17
+
+#ifdef _INSERT_STRING_ANNOTATION
+    _CONSTEXPR20 void _Create_annotation() const noexcept {
+        // Annotates the valid range with shadow memory
+        auto& _My_data = _Mypair._Myval2;
+        _Apply_annotation(_My_data._Myptr(), _My_data._Myres, _My_data._Myres, _My_data._Mysize);
+    }
+
+    _CONSTEXPR20 void _Remove_annotation() const noexcept {
+        // Removes annotation of the range with shadow memory
+        auto& _My_data = _Mypair._Myval2;
+        _Apply_annotation(_My_data._Myptr(), _My_data._Myres, _My_data._Mysize, _My_data._Myres);
+    }
+
+    _CONSTEXPR20 void _Modify_annotation(const size_type _Old_size, const size_type _New_size) const noexcept {
+        if (_Old_size == _New_size) {
+            return;
+        }
+
+        auto& _My_data = _Mypair._Myval2;
+        _Apply_annotation(_My_data._Myptr(), _My_data._Myres, _Old_size, _New_size);
+    }
+
+    static _CONSTEXPR20 void _Apply_annotation(const value_type* const _First, const size_type _Capacity,
+        const size_type _Old_size, const size_type _New_size) noexcept {
+#if _HAS_CXX20
+        if (_STD is_constant_evaluated()) {
+            return;
+        }
+#endif // _HAS_CXX20
+       // Don't annotate small strings; only annotate on the heap.
+        if (_Capacity <= _Small_string_capacity || !_Asan_string_should_annotate) {
+            return;
+        }
+
+        // Note that `_Capacity`, `_Old_size`, and `_New_size` do not include the null terminator
+        const void* const _End      = _First + _Capacity + 1;
+        const void* const _Old_last = _First + _Old_size + 1;
+        const void* const _New_last = _First + _New_size + 1;
+
+        constexpr bool _Large_string_always_asan_aligned =
+            (_Container_allocation_minimum_asan_alignment<basic_string>) >= _Asan_granularity;
+
+        // for the non-aligned buffer options, the buffer must always have size >= 9 bytes,
+        // so it will always end at least one shadow memory section.
+
+        _Asan_aligned_pointers _Aligned;
+        if constexpr (_Large_string_always_asan_aligned) {
+            _Aligned = {_First, _STD _Get_asan_aligned_after(_End)};
+        } else {
+            _Aligned = _STD _Get_asan_aligned_first_end(_First, _End);
+        }
+        const void* const _Old_fixed = _Aligned._Clamp_to_end(_Old_last);
+        const void* const _New_fixed = _Aligned._Clamp_to_end(_New_last);
+
+        // --- always aligned case ---
+        // old state:
+        //   [_First, _Old_last) valid
+        //   [_Old_last, asan_aligned_after(_End)) poison
+        // new state:
+        //   [_First, _New_last) valid
+        //   [_New_last, asan_aligned_after(_End)) poison
+
+        // --- sometimes non-aligned case ---
+        // old state:
+        //   [_Aligned._First, _Old_fixed) valid
+        //   [_Old_fixed, _Aligned._End) poison
+        //   [_Aligned._End, _End) valid
+        // new state:
+        //   [_Aligned._First, _New_fixed) valid
+        //   [_New_fixed, _Aligned._End) poison
+        //   [_Aligned._End, _End) valid
+        _CSTD __sanitizer_annotate_contiguous_container(_Aligned._First, _Aligned._End, _Old_fixed, _New_fixed);
+    }
+
+#define _ASAN_STRING_REMOVE(_Str)                       (_Str)._Remove_annotation()
+#define _ASAN_STRING_CREATE(_Str)                       (_Str)._Create_annotation()
+#define _ASAN_STRING_MODIFY(_Str, _Old_size, _New_size) (_Str)._Modify_annotation(_Old_size, _New_size)
+#else // ^^^ _INSERT_STRING_ANNOTATION / !_INSERT_STRING_ANNOTATION vvv
+#define _ASAN_STRING_REMOVE(_Str)
+#define _ASAN_STRING_CREATE(_Str)
+#define _ASAN_STRING_MODIFY(_Str, _Old_size, _New_size)
+#endif // ^^^ !_INSERT_STRING_ANNOTATION ^^^
+
+public:
+    _CONSTEXPR20
+    basic_string() noexcept(is_nothrow_default_constructible_v<_Alty>) : _Mypair(_Zero_then_variadic_args_t{}) {
+        _Construct_empty();
+    }
+
+    _CONSTEXPR20 explicit basic_string(const _Alloc& _Al) noexcept : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Construct_empty();
+    }
+
+    _CONSTEXPR20 basic_string(const basic_string& _Right)
+        : _Mypair(_One_then_variadic_args_t{}, _Alty_traits::select_on_container_copy_construction(_Right._Getal())) {
+        _Construct<_Construct_strategy::_From_string>(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+    }
+
+    _CONSTEXPR20 basic_string(const basic_string& _Right, const _Alloc& _Al)
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Construct<_Construct_strategy::_From_string>(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+    }
+
+    _CONSTEXPR20 basic_string(const basic_string& _Right, const size_type _Roff, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) { // construct from _Right [_Roff, <end>)
+        _Right._Mypair._Myval2._Check_offset(_Roff);
+        _Construct<_Construct_strategy::_From_ptr>(
+            _Right._Mypair._Myval2._Myptr() + _Roff, _Right._Mypair._Myval2._Clamp_suffix_size(_Roff, npos));
+    }
+
+    _CONSTEXPR20 basic_string(
+        const basic_string& _Right, const size_type _Roff, const size_type _Count, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) { // construct from _Right [_Roff, _Roff + _Count)
+        _Right._Mypair._Myval2._Check_offset(_Roff);
+        _Construct<_Construct_strategy::_From_ptr>(
+            _Right._Mypair._Myval2._Myptr() + _Roff, _Right._Mypair._Myval2._Clamp_suffix_size(_Roff, _Count));
+    }
+
+#if _HAS_CXX23
+    constexpr basic_string(basic_string&& _Right, const size_type _Roff, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) { // construct from _Right [_Roff, <end>), potentially move
+        _Move_construct_from_substr(_Right, _Roff, npos);
+    }
+
+    constexpr basic_string(
+        basic_string&& _Right, const size_type _Roff, const size_type _Count, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) { // construct from _Right [_Roff, _Roff + _Count), potentially move
+        _Move_construct_from_substr(_Right, _Roff, _Count);
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 basic_string(_In_reads_(_Count) const _Elem* const _Ptr, _CRT_GUARDOVERFLOW const size_type _Count)
+        : _Mypair(_Zero_then_variadic_args_t{}) {
+        _Construct<_Construct_strategy::_From_ptr>(_Ptr, _Count);
+    }
+
+#if _HAS_CXX17
+    template <class _Alloc2 = _Alloc, enable_if_t<_Is_allocator<_Alloc2>::value, int> = 0>
+#endif // _HAS_CXX17
+    _CONSTEXPR20 basic_string(
+        _In_reads_(_Count) const _Elem* const _Ptr, _CRT_GUARDOVERFLOW const size_type _Count, const _Alloc& _Al)
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Construct<_Construct_strategy::_From_ptr>(_Ptr, _Count);
+    }
+
+    _CONSTEXPR20 basic_string(_In_z_ const _Elem* const _Ptr) : _Mypair(_Zero_then_variadic_args_t{}) {
+        _Construct<_Construct_strategy::_From_ptr>(_Ptr, _Convert_size<size_type>(_Traits::length(_Ptr)));
+    }
+
+#if _HAS_CXX17
+    template <class _Alloc2 = _Alloc, enable_if_t<_Is_allocator<_Alloc2>::value, int> = 0>
+#endif // _HAS_CXX17
+    _CONSTEXPR20 basic_string(_In_z_ const _Elem* const _Ptr, const _Alloc& _Al)
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Construct<_Construct_strategy::_From_ptr>(_Ptr, _Convert_size<size_type>(_Traits::length(_Ptr)));
+    }
+
+#if _HAS_CXX23
+    basic_string(nullptr_t) = delete;
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 basic_string(_CRT_GUARDOVERFLOW const size_type _Count, const _Elem _Ch)
+        : _Mypair(_Zero_then_variadic_args_t{}) { // construct from _Count * _Ch
+        _Construct<_Construct_strategy::_From_char>(_Ch, _Count);
+    }
+
+#if _HAS_CXX17
+    template <class _Alloc2 = _Alloc, enable_if_t<_Is_allocator<_Alloc2>::value, int> = 0>
+#endif // _HAS_CXX17
+    _CONSTEXPR20 basic_string(_CRT_GUARDOVERFLOW const size_type _Count, const _Elem _Ch, const _Alloc& _Al)
+        : _Mypair(_One_then_variadic_args_t{}, _Al) { // construct from _Count * _Ch with allocator
+        _Construct<_Construct_strategy::_From_char>(_Ch, _Count);
+    }
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    _CONSTEXPR20 basic_string(_Iter _First, _Iter _Last, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _STD _Adl_verify_range(_First, _Last);
+        auto _UFirst = _STD _Get_unwrapped(_First);
+        auto _ULast  = _STD _Get_unwrapped(_Last);
+        if (_UFirst == _ULast) {
+            _Construct_empty();
+        } else {
+            if constexpr (_Is_elem_cptr<decltype(_UFirst)>::value) {
+                _Construct<_Construct_strategy::_From_ptr>(
+                    _UFirst, _STD _Convert_size<size_type>(static_cast<size_t>(_ULast - _UFirst)));
+            } else if constexpr (_Is_cpp17_fwd_iter_v<decltype(_UFirst)>) {
+                const auto _Length = static_cast<size_t>(_STD distance(_UFirst, _ULast));
+                const auto _Count  = _STD _Convert_size<size_type>(_Length);
+                _Construct_from_iter(_STD move(_UFirst), _STD move(_ULast), _Count);
+            } else {
+                _Construct_from_iter(_STD move(_UFirst), _STD move(_ULast));
+            }
+        }
+    }
+
+private:
+    enum class _Allocation_policy { _At_least, _Exactly };
+
+    template <_Allocation_policy _Policy = _Allocation_policy::_At_least>
+    _NODISCARD static _CONSTEXPR20 pointer _Allocate_for_capacity(_Alty& _Al, size_type& _Capacity) {
+        _STL_INTERNAL_CHECK(_Capacity > _Small_string_capacity);
+        ++_Capacity; // Take null terminator into consideration
+
+        pointer _Fancy_ptr = nullptr;
+        if constexpr (_Policy == _Allocation_policy::_At_least) {
+            _Fancy_ptr = _Allocate_at_least_helper(_Al, _Capacity);
+        } else {
+            _STL_INTERNAL_STATIC_ASSERT(_Policy == _Allocation_policy::_Exactly);
+            _Fancy_ptr = _Al.allocate(_Capacity);
+        }
+
+#if _HAS_CXX20
+        // Start element lifetimes to avoid UB. This is a more general mechanism than _String_val::_Activate_SSO_buffer,
+        // but likely more impactful to throughput.
+        if (_STD is_constant_evaluated()) {
+            _Elem* const _Ptr = _Unfancy(_Fancy_ptr);
+            for (size_type _Idx = 0; _Idx < _Capacity; ++_Idx) {
+                _STD construct_at(_Ptr + _Idx);
+            }
+        }
+#endif // _HAS_CXX20
+        --_Capacity;
+        return _Fancy_ptr;
+    }
+
+    static _CONSTEXPR20 void _Deallocate_for_capacity(
+        _Alty& _Al, const pointer _Old_ptr, const size_type _Capacity) noexcept {
+        _STL_INTERNAL_CHECK(_Capacity > _Small_string_capacity);
+        _Al.deallocate(_Old_ptr, _Capacity + 1); // +1 for null terminator
+    }
+
+    _CONSTEXPR20 void _Construct_empty() {
+        auto& _My_data = _Mypair._Myval2;
+        _My_data._Alloc_proxy(_GET_PROXY_ALLOCATOR(_Alty, _Getal()));
+
+        // initialize basic_string data members
+        _My_data._Mysize = 0;
+        _My_data._Myres  = _Small_string_capacity;
+        _My_data._Activate_SSO_buffer();
+
+        // the _Traits::assign is last so the codegen doesn't think the char write can alias this
+        _Traits::assign(_My_data._Bx._Buf[0], _Elem());
+    }
+
+    enum class _Construct_strategy : uint8_t { _From_char, _From_ptr, _From_string };
+
+    template <_Construct_strategy _Strat, class _Char_or_ptr>
+    _CONSTEXPR20 void _Construct(const _Char_or_ptr _Arg, _CRT_GUARDOVERFLOW const size_type _Count) {
+        auto& _My_data = _Mypair._Myval2;
+        _STL_INTERNAL_CHECK(!_My_data._Large_mode_engaged());
+
+        if constexpr (_Strat == _Construct_strategy::_From_char) {
+            _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Char_or_ptr, _Elem>);
+        } else {
+            _STL_INTERNAL_STATIC_ASSERT(_Is_elem_cptr<_Char_or_ptr>::value);
+        }
+
+        if (_Count > max_size()) {
+            _Xlen_string(); // result too long
+        }
+
+        auto& _Al       = _Getal();
+        auto&& _Alproxy = _GET_PROXY_ALLOCATOR(_Alty, _Al);
+        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _My_data);
+
+        if (_Count <= _Small_string_capacity) {
+            _My_data._Mysize = _Count;
+            _My_data._Myres  = _Small_string_capacity;
+
+            if constexpr (_Strat == _Construct_strategy::_From_char) {
+                _Traits::assign(_My_data._Bx._Buf, _Count, _Arg);
+                _Traits::assign(_My_data._Bx._Buf[_Count], _Elem());
+            } else if constexpr (_Strat == _Construct_strategy::_From_ptr) {
+                _Traits::copy(_My_data._Bx._Buf, _Arg, _Count);
+                _Traits::assign(_My_data._Bx._Buf[_Count], _Elem());
+            } else { // _Strat == _Construct_strategy::_From_string
+#ifdef _INSERT_STRING_ANNOTATION
+                _Traits::copy(_My_data._Bx._Buf, _Arg, _Count + 1);
+#else // ^^^ _INSERT_STRING_ANNOTATION / !_INSERT_STRING_ANNOTATION vvv
+                _Traits::copy(_My_data._Bx._Buf, _Arg, _BUF_SIZE);
+#endif // ^^^ !_INSERT_STRING_ANNOTATION ^^^
+            }
+
+            _Proxy._Release();
+            return;
+        }
+
+        size_type _New_capacity = _Calculate_growth(_Count, _Small_string_capacity, max_size());
+        const pointer _New_ptr  = _Allocate_for_capacity(_Al, _New_capacity); // throws
+        _Construct_in_place(_My_data._Bx._Ptr, _New_ptr);
+
+        _My_data._Mysize = _Count;
+        _My_data._Myres  = _New_capacity;
+        if constexpr (_Strat == _Construct_strategy::_From_char) {
+            _Traits::assign(_Unfancy(_New_ptr), _Count, _Arg);
+            _Traits::assign(_Unfancy(_New_ptr)[_Count], _Elem());
+        } else if constexpr (_Strat == _Construct_strategy::_From_ptr) {
+            _Traits::copy(_Unfancy(_New_ptr), _Arg, _Count);
+            _Traits::assign(_Unfancy(_New_ptr)[_Count], _Elem());
+        } else { // _Strat == _Construct_strategy::_From_string
+            _Traits::copy(_Unfancy(_New_ptr), _Arg, _Count + 1);
+        }
+
+        _ASAN_STRING_CREATE(*this);
+        _Proxy._Release();
+    }
+
+    template <class _Iter, class _Sent, class _Size = nullptr_t>
+    _CONSTEXPR20 void _Construct_from_iter(_Iter _First, const _Sent _Last, _Size _Count = {}) {
+        // Pre: _Iter models input_iterator or meets the Cpp17InputIterator requirements.
+        // Pre: [_First, _Last) is a valid range.
+        // Pre: if _Iter models forward_iterator or meets the Cpp17ForwardIterator requirements,
+        //      then is_same_v<_Size, size_type> holds.
+        // Pre: if is_same_v<_Size, size_type>, _Count is the length of [_First, _Last).
+        // Pre: *this is in small mode; the lifetime of the SSO elements has already begun.
+
+        auto& _My_data  = _Mypair._Myval2;
+        auto& _Al       = _Getal();
+        auto&& _Alproxy = _GET_PROXY_ALLOCATOR(_Alty, _Al);
+        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _My_data);
+
+        _My_data._Mysize = 0;
+        _My_data._Myres  = _Small_string_capacity;
+
+        if constexpr (is_same_v<_Size, size_type>) {
+            if (_Count > max_size()) {
+                _Xlen_string(); // result too long
+            }
+
+            if (_Count > _Small_string_capacity) {
+                size_type _New_capacity = _Calculate_growth(_Count);
+                const pointer _New_ptr  = _Allocate_for_capacity(_Al, _New_capacity); // throws
+                _Construct_in_place(_My_data._Bx._Ptr, _New_ptr);
+                _My_data._Myres = _New_capacity;
+            }
+        }
+
+        _Tidy_deallocate_guard<basic_string> _Guard{this};
+
+        constexpr bool _Can_construct_by_copy =
+            _Is_specialization_v<_Traits, char_traits> && _Is_EcharT<_Elem> && is_same_v<_Size, size_type>;
+
+        if constexpr (_Can_construct_by_copy) {
+            const auto _Data = _My_data._Myptr();
+            _STD _Copy_n_unchecked4(_STD move(_First), _Count, _Data);
+            _My_data._Mysize = _Count;
+            _Data[_Count]    = _Elem();
+        } else {
+            for (; _First != _Last; ++_First) {
+                if constexpr (!is_same_v<_Size, size_type>) {
+                    if (_My_data._Mysize == _My_data._Myres) { // Need to grow
+                        if (_My_data._Mysize == max_size()) {
+                            _Xlen_string(); // result too long
+                        }
+
+                        _Elem* const _Old_ptr   = _My_data._Myptr();
+                        size_type _New_capacity = _Calculate_growth(_My_data._Mysize + 1);
+                        const pointer _New_ptr  = _Allocate_for_capacity(_Al, _New_capacity); // throws
+
+                        _Traits::copy(_Unfancy(_New_ptr), _Old_ptr, _My_data._Mysize);
+                        if (_My_data._Large_mode_engaged()) { // Need to deallocate old storage
+                            _Deallocate_for_capacity(_Al, _My_data._Bx._Ptr, _My_data._Myres);
+                            _My_data._Bx._Ptr = _New_ptr;
+                        } else {
+                            _Construct_in_place(_My_data._Bx._Ptr, _New_ptr);
+                        }
+                        _My_data._Myres = _New_capacity;
+                    }
+                }
+
+                _Elem* const _Ptr = _My_data._Myptr();
+                _Traits::assign(_Ptr[_My_data._Mysize], *_First);
+                ++_My_data._Mysize;
+            }
+
+            _Elem* const _Ptr = _My_data._Myptr();
+            _Traits::assign(_Ptr[_My_data._Mysize], _Elem());
+        }
+
+        _ASAN_STRING_CREATE(*this);
+        _Guard._Target = nullptr;
+        _Proxy._Release();
+    }
+
+public:
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Elem> _Rng>
+    constexpr basic_string(from_range_t, _Rng&& _Range, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        if constexpr (_RANGES sized_range<_Rng> || _RANGES forward_range<_Rng>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_Range));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            if constexpr (_Contiguous_range_of<_Rng, _Elem>) {
+                _Construct<_Construct_strategy::_From_ptr>(_RANGES data(_Range), _Count);
+            } else {
+                _Construct_from_iter(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range), _Count);
+            }
+        } else {
+            _Construct_from_iter(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        }
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 basic_string(basic_string&& _Right) noexcept
+        : _Mypair(_One_then_variadic_args_t{}, _STD move(_Right._Getal())) {
+        _Mypair._Myval2._Alloc_proxy(_GET_PROXY_ALLOCATOR(_Alty, _Getal()));
+        _Take_contents(_Right);
+    }
+
+    _CONSTEXPR20 basic_string(basic_string&& _Right, const _Alloc& _Al) noexcept(
+        _Alty_traits::is_always_equal::value) // strengthened
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        if constexpr (!_Alty_traits::is_always_equal::value) {
+            if (_Getal() != _Right._Getal()) {
+                _Construct<_Construct_strategy::_From_string>(
+                    _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+                return;
+            }
+        }
+
+        _Mypair._Myval2._Alloc_proxy(_GET_PROXY_ALLOCATOR(_Alty, _Getal()));
+        _Take_contents(_Right);
+    }
+
+    _CONSTEXPR20 basic_string(_String_constructor_concat_tag, const basic_string& _Source_of_al,
+        const _Elem* const _Left_ptr, const size_type _Left_size, const _Elem* const _Right_ptr,
+        const size_type _Right_size)
+        : _Mypair(
+            _One_then_variadic_args_t{}, _Alty_traits::select_on_container_copy_construction(_Source_of_al._Getal())) {
+        _STL_INTERNAL_CHECK(_Left_size <= max_size());
+        _STL_INTERNAL_CHECK(_Right_size <= max_size());
+        _STL_INTERNAL_CHECK(_Right_size <= max_size() - _Left_size);
+        const auto _New_size    = static_cast<size_type>(_Left_size + _Right_size);
+        size_type _New_capacity = _Small_string_capacity;
+        auto& _My_data          = _Mypair._Myval2;
+        _Elem* _Ptr             = _My_data._Bx._Buf;
+        auto&& _Alproxy         = _GET_PROXY_ALLOCATOR(_Alty, _Getal());
+        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _My_data); // throws
+
+        if (_New_capacity < _New_size) {
+            _New_capacity           = _Calculate_growth(_New_size, _Small_string_capacity, max_size());
+            const pointer _Fancyptr = _Allocate_for_capacity(_Getal(), _New_capacity); // throws
+            _Ptr                    = _Unfancy(_Fancyptr);
+            _Construct_in_place(_My_data._Bx._Ptr, _Fancyptr);
+        }
+
+        _My_data._Mysize = _New_size;
+        _My_data._Myres  = _New_capacity;
+        _Traits::copy(_Ptr, _Left_ptr, _Left_size);
+        _Traits::copy(_Ptr + static_cast<ptrdiff_t>(_Left_size), _Right_ptr, _Right_size);
+        _Traits::assign(_Ptr[_New_size], _Elem());
+        _ASAN_STRING_CREATE(*this);
+        _Proxy._Release();
+    }
+
+    _CONSTEXPR20 basic_string(_String_constructor_concat_tag, basic_string& _Left, basic_string& _Right)
+        : _Mypair(_One_then_variadic_args_t{}, _Left._Getal()) {
+        auto& _My_data    = _Mypair._Myval2;
+        auto& _Left_data  = _Left._Mypair._Myval2;
+        auto& _Right_data = _Right._Mypair._Myval2;
+        _Left_data._Orphan_all();
+        _Right_data._Orphan_all();
+        const auto _Left_size  = _Left_data._Mysize;
+        const auto _Right_size = _Right_data._Mysize;
+
+        const auto _Left_capacity  = _Left_data._Myres;
+        const auto _Right_capacity = _Right_data._Myres;
+        // overflow is OK due to max_size() checks:
+        const auto _New_size     = static_cast<size_type>(_Left_size + _Right_size);
+        const bool _Fits_in_left = _Right_size <= _Left_capacity - _Left_size;
+        if (_Fits_in_left && _Right_capacity <= _Left_capacity) {
+            // take _Left's buffer, max_size() is OK because _Fits_in_left
+            _My_data._Alloc_proxy(_GET_PROXY_ALLOCATOR(_Alty, _Getal())); // throws, hereafter nothrow in this block
+            _Take_contents(_Left);
+            const auto _Ptr = _My_data._Myptr();
+            _ASAN_STRING_MODIFY(*this, _Left_size, _New_size);
+            _Traits::copy(_Ptr + _Left_size, _Right_data._Myptr(), _Right_size + 1);
+            _My_data._Mysize = _New_size;
+            return;
+        }
+
+        const bool _Fits_in_right = _Left_size <= _Right_capacity - _Right_size;
+        if (_Allocators_equal(_Getal(), _Right._Getal()) && _Fits_in_right) {
+            // take _Right's buffer, max_size() is OK because _Fits_in_right
+            // At this point, we have tested:
+            // !(_Fits_in_left && _Right_capacity <= _Left_capacity) && _Fits_in_right
+            // therefore: (by De Morgan's Laws)
+            // (!_Fits_in_left || _Right_capacity > _Left_capacity) && _Fits_in_right
+            // therefore: (by the distributive property)
+            // (!_Fits_in_left && _Fits_in_right)  // implying _Right has more capacity
+            //     || (_Right_capacity > _Left_capacity && _Fits_in_right)  // tests that _Right has more capacity
+            // therefore: _Right must have more than the minimum capacity, so it must be _Large_mode_engaged()
+            _STL_INTERNAL_CHECK(_Right_data._Large_mode_engaged());
+            _My_data._Alloc_proxy(_GET_PROXY_ALLOCATOR(_Alty, _Getal())); // throws, hereafter nothrow in this block
+            _Take_contents(_Right);
+            const auto _Ptr = _Unfancy(_My_data._Bx._Ptr);
+            _ASAN_STRING_MODIFY(*this, _Right_size, _New_size);
+            _Traits::move(_Ptr + _Left_size, _Ptr, _Right_size + 1);
+            _Traits::copy(_Ptr, _Left_data._Myptr(), _Left_size);
+            _My_data._Mysize = _New_size;
+            return;
+        }
+
+        // can't use either buffer, reallocate
+        const auto _Max = max_size();
+        if (_Max - _Left_size < _Right_size) { // check if max_size() is OK
+            _Xlen_string();
+        }
+
+        size_type _New_capacity = _Calculate_growth(_New_size, _Small_string_capacity, _Max);
+        auto&& _Alproxy         = _GET_PROXY_ALLOCATOR(_Alty, _Getal());
+        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _My_data); // throws
+        const pointer _Fancyptr = _Allocate_for_capacity(_Getal(), _New_capacity); // throws
+        // nothrow hereafter
+        _Construct_in_place(_My_data._Bx._Ptr, _Fancyptr);
+        _My_data._Mysize = _New_size;
+        _My_data._Myres  = _New_capacity;
+        const auto _Ptr  = _Unfancy(_Fancyptr);
+        _Traits::copy(_Ptr, _Left_data._Myptr(), _Left_size);
+        _Traits::copy(_Ptr + _Left_size, _Right_data._Myptr(), _Right_size + 1);
+        _ASAN_STRING_CREATE(*this);
+        _Proxy._Release();
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _CONSTEXPR20 explicit basic_string(const _StringViewIsh& _Right, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        const basic_string_view<_Elem, _Traits> _As_view = _Right;
+        _Construct<_Construct_strategy::_From_ptr>(_As_view.data(), _Convert_size<size_type>(_As_view.size()));
+    }
+
+    template <class _Ty, enable_if_t<is_convertible_v<const _Ty&, basic_string_view<_Elem, _Traits>>, int> = 0>
+    _CONSTEXPR20 basic_string(
+        const _Ty& _Right, const size_type _Roff, const size_type _Count, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) { // construct from _Right [_Roff, _Roff + _Count) using _Al
+        const basic_string_view<_Elem, _Traits> _As_view = _Right;
+        const auto _As_sub_view                          = _As_view.substr(_Roff, _Count);
+        _Construct<_Construct_strategy::_From_ptr>(_As_sub_view.data(), _Convert_size<size_type>(_As_sub_view.size()));
+    }
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+    basic_string(_String_constructor_rvalue_allocator_tag, _Alloc&& _Al)
+        : _Mypair(_One_then_variadic_args_t{}, _STD move(_Al)) {
+        // Used exclusively by basic_stringbuf
+        _Construct_empty();
+    }
+
+    _NODISCARD bool _Move_assign_from_buffer(
+        _Elem* const _Right, const size_type _Size, const size_type _Actual_allocation_size) {
+        // Move assign from a buffer, used exclusively by basic_stringbuf; returns _Large_mode_engaged()
+        auto& _My_data = _Mypair._Myval2;
+        _STL_INTERNAL_CHECK(!_My_data._Large_mode_engaged() && _My_data._Mysize == 0);
+        _STL_INTERNAL_CHECK(_Size < _Actual_allocation_size); // So there is room for null terminator
+        _Traits::assign(_Right[_Size], _Elem());
+
+        const bool _Is_large = _Actual_allocation_size >= _Least_allocation_size;
+        if (_Is_large) {
+            _ASAN_STRING_REMOVE(*this);
+            _Construct_in_place(_My_data._Bx._Ptr, _Refancy<pointer>(_Right));
+            _My_data._Mysize = _Size;
+            _My_data._Myres  = _Actual_allocation_size - 1;
+            _ASAN_STRING_CREATE(*this);
+        } else {
+            _Traits::copy(_My_data._Bx._Buf, _Right, _Actual_allocation_size);
+            _My_data._Mysize = _Size;
+            _My_data._Myres  = _Small_string_capacity;
+        }
+
+        return _Is_large;
+    }
+
+    // No instance of this type can exist where an exception may be thrown.
+    struct _Released_buffer {
+        pointer _Ptr;
+        size_type _Size;
+        size_type _Actual_allocation_size;
+    };
+
+    _NODISCARD _Released_buffer _Release_to_buffer(_Alloc& _Al) {
+        // Release to a buffer, or allocate a new one if in small string mode; used exclusively by basic_stringbuf
+        _Released_buffer _Result;
+        auto& _My_data = _Mypair._Myval2;
+        _Result._Size  = _My_data._Mysize;
+        _My_data._Orphan_all();
+        _ASAN_STRING_REMOVE(*this);
+        if (_My_data._Large_mode_engaged()) {
+            _Result._Ptr                    = _My_data._Bx._Ptr;
+            _Result._Actual_allocation_size = _My_data._Myres + 1;
+
+            _My_data._Bx._Switch_to_buf();
+        } else {
+            // use _Least_allocation_size to avoid small mode, if the buffer is assigned back
+            size_type _Allocated = _Least_allocation_size;
+            _Result._Ptr         = _Allocate_at_least_helper(_Al, _Allocated);
+            _Traits::copy(_Unfancy(_Result._Ptr), _My_data._Bx._Buf, _BUF_SIZE);
+            _Result._Actual_allocation_size = _Allocated;
+        }
+        _My_data._Mysize = 0;
+        _My_data._Myres  = _Small_string_capacity;
+        _Traits::assign(_My_data._Bx._Buf[0], _Elem());
+        return _Result;
+    }
+#endif // _HAS_CXX20
+
+    _CONSTEXPR20 basic_string& operator=(basic_string&& _Right) noexcept(
+        _Choose_pocma_v<_Alty> != _Pocma_values::_No_propagate_allocators) {
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+        auto& _Al                 = _Getal();
+        auto& _Right_al           = _Right._Getal();
+        constexpr auto _Pocma_val = _Choose_pocma_v<_Alty>;
+        if constexpr (_Pocma_val == _Pocma_values::_Propagate_allocators) {
+            if (_Al != _Right_al) {
+                // intentionally slams into noexcept on OOM, TRANSITION, VSO-466800
+                _Mypair._Myval2._Orphan_all();
+                _Mypair._Myval2._Reload_proxy(_GET_PROXY_ALLOCATOR(_Alty, _Al), _GET_PROXY_ALLOCATOR(_Alty, _Right_al));
+            }
+        } else if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
+            if (_Al != _Right_al) {
+                assign(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+                return *this;
+            }
+        }
+
+        _Tidy_deallocate();
+        _Pocma(_Al, _Right_al);
+        _Take_contents(_Right);
+        return *this;
+    }
+
+    _CONSTEXPR20 basic_string& assign(basic_string&& _Right) noexcept(noexcept(*this = _STD move(_Right))) {
+        *this = _STD move(_Right);
+        return *this;
+    }
+
+private:
+    _CONSTEXPR20 void _Take_contents(basic_string& _Right) noexcept {
+        // assign by stealing _Right's buffer
+        // pre: this != &_Right
+        // pre: allocator propagation (POCMA) from _Right, if necessary, is complete
+        // pre: *this owns no memory, iterators orphaned
+        // (note: _Buf/_Ptr/_Mysize/_Myres may be garbage init)
+        auto& _My_data    = _Mypair._Myval2;
+        auto& _Right_data = _Right._Mypair._Myval2;
+
+#if !defined(_INSERT_STRING_ANNOTATION)
+        if constexpr (_Can_memcpy_val) {
+#if _HAS_CXX20
+            if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                if (_Right_data._Large_mode_engaged()) {
+                    // take ownership of _Right's iterators along with its buffer
+                    _Swap_proxy_and_iterators(_Right);
+                } else {
+                    _Right_data._Orphan_all();
+                }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+                const auto _My_data_mem =
+                    reinterpret_cast<unsigned char*>(_STD addressof(_Mypair._Myval2)) + _Memcpy_val_offset;
+                const auto _Right_data_mem =
+                    reinterpret_cast<const unsigned char*>(_STD addressof(_Right._Mypair._Myval2)) + _Memcpy_val_offset;
+                _CSTD memcpy(_My_data_mem, _Right_data_mem, _Memcpy_val_size);
+
+                _Right_data._Mysize = 0;
+                _Right_data._Myres  = _Small_string_capacity;
+                _Right_data._Activate_SSO_buffer();
+                _Traits::assign(_Right_data._Bx._Buf[0], _Elem());
+                return;
+            }
+        }
+#endif // !defined(_INSERT_STRING_ANNOTATION)
+
+        if (_Right_data._Large_mode_engaged()) { // steal buffer
+            _Swap_proxy_and_iterators(_Right);
+
+            _Construct_in_place(_My_data._Bx._Ptr, _Right_data._Bx._Ptr);
+            _Right_data._Bx._Switch_to_buf();
+        } else { // copy small string buffer
+            _Right_data._Orphan_all();
+
+            _My_data._Activate_SSO_buffer();
+            _Traits::copy(_My_data._Bx._Buf, _Right_data._Bx._Buf, _Right_data._Mysize + 1);
+        }
+
+        _My_data._Myres  = _Right_data._Myres;
+        _My_data._Mysize = _Right_data._Mysize;
+
+        _Right_data._Mysize = 0;
+        _Right_data._Myres  = _Small_string_capacity;
+        _Traits::assign(_Right_data._Bx._Buf[0], _Elem());
+    }
+
+#if _HAS_CXX23
+    constexpr void _Move_construct_from_substr(basic_string& _Right, const size_type _Roff, const size_type _Size_max) {
+        auto& _Right_data = _Right._Mypair._Myval2;
+        _Right_data._Check_offset(_Roff);
+
+        const auto _Result_size = _Right_data._Clamp_suffix_size(_Roff, _Size_max);
+        const auto _Right_ptr   = _Right_data._Myptr();
+        auto& _Al               = _Getal();
+        if (_Allocators_equal(_Al, _Right._Getal()) && _Result_size > _Small_string_capacity) {
+            _Mypair._Myval2._Alloc_proxy(_GET_PROXY_ALLOCATOR(_Alty, _Al));
+
+            if (_Roff != 0) {
+                _Traits::move(_Right_ptr, _Right_ptr + _Roff, _Result_size);
+            }
+            _Right._Eos(_Result_size);
+            _Take_contents(_Right);
+        } else {
+            _Construct<_Construct_strategy::_From_ptr>(_Right_ptr + _Roff, _Result_size);
+        }
+    }
+#endif // _HAS_CXX23
+
+public:
+    _CONSTEXPR20 basic_string(initializer_list<_Elem> _Ilist, const _Alloc& _Al = allocator_type())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Construct<_Construct_strategy::_From_ptr>(_Ilist.begin(), _Convert_size<size_type>(_Ilist.size()));
+    }
+
+    _CONSTEXPR20 basic_string& operator=(initializer_list<_Elem> _Ilist) {
+        return assign(_Ilist.begin(), _Convert_size<size_type>(_Ilist.size()));
+    }
+
+    _CONSTEXPR20 basic_string& operator+=(initializer_list<_Elem> _Ilist) {
+        return append(_Ilist.begin(), _Convert_size<size_type>(_Ilist.size()));
+    }
+
+    _CONSTEXPR20 basic_string& assign(initializer_list<_Elem> _Ilist) {
+        return assign(_Ilist.begin(), _Convert_size<size_type>(_Ilist.size()));
+    }
+
+    _CONSTEXPR20 basic_string& append(initializer_list<_Elem> _Ilist) {
+        return append(_Ilist.begin(), _Convert_size<size_type>(_Ilist.size()));
+    }
+
+    _CONSTEXPR20 iterator insert(const const_iterator _Where, const initializer_list<_Elem> _Ilist) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2), "string iterator incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Off = static_cast<size_type>(_Unfancy(_Where._Ptr) - _Mypair._Myval2._Myptr());
+        insert(_Off, _Ilist.begin(), _Convert_size<size_type>(_Ilist.size()));
+        return begin() + static_cast<difference_type>(_Off);
+    }
+
+    _CONSTEXPR20 basic_string& replace(
+        const const_iterator _First, const const_iterator _Last, const initializer_list<_Elem> _Ilist) {
+        // replace with initializer_list
+        _STD _Adl_verify_range(_First, _Last);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_First._Getcont() == _STD addressof(_Mypair._Myval2), "string iterators incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Offset = static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr());
+        const auto _Length = static_cast<size_type>(_Last._Ptr - _First._Ptr);
+        return replace(_Offset, _Length, _Ilist.begin(), _Convert_size<size_type>(_Ilist.size()));
+    }
+
+    _CONSTEXPR20 ~basic_string() noexcept {
+        _Tidy_deallocate();
+#if _ITERATOR_DEBUG_LEVEL != 0
+        auto&& _Alproxy          = _GET_PROXY_ALLOCATOR(_Alty, _Getal());
+        const auto _To_delete    = _Mypair._Myval2._Myproxy;
+        _Mypair._Myval2._Myproxy = nullptr;
+        _Delete_plain_internal(_Alproxy, _To_delete);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+    static constexpr auto npos{static_cast<size_type>(-1)};
+
+    _CONSTEXPR20 basic_string& operator=(const basic_string& _Right) {
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+        auto& _Al             = _Getal();
+        const auto& _Right_al = _Right._Getal();
+        if constexpr (_Choose_pocca_v<_Alty>) {
+            if (_Al != _Right_al) {
+                auto&& _Alproxy       = _GET_PROXY_ALLOCATOR(_Alty, _Al);
+                auto&& _Right_alproxy = _GET_PROXY_ALLOCATOR(_Alty, _Right_al);
+                _Container_proxy_ptr<_Alty> _New_proxy(_Right_alproxy, _Leave_proxy_unbound{}); // throws
+
+                const size_type _Right_size   = _Right._Mypair._Myval2._Mysize;
+                const _Elem* const _Right_ptr = _Right._Mypair._Myval2._Myptr();
+                if (_Right_size > _Small_string_capacity) {
+                    size_type _New_capacity = _Calculate_growth(_Right_size, _Small_string_capacity, _Right.max_size());
+                    auto _Right_al_non_const = _Right_al;
+                    const pointer _New_ptr   = _Allocate_for_capacity(_Right_al_non_const, _New_capacity); // throws
+                    _Traits::copy(_Unfancy(_New_ptr), _Right_ptr, _Right_size + 1);
+
+                    _Tidy_deallocate();
+                    _Construct_in_place(_Mypair._Myval2._Bx._Ptr, _New_ptr);
+                    _Mypair._Myval2._Mysize = _Right_size;
+                    _Mypair._Myval2._Myres  = _New_capacity;
+                    _ASAN_STRING_CREATE(*this);
+                } else {
+                    _Tidy_deallocate();
+                    _Traits::copy(_Mypair._Myval2._Bx._Buf, _Right_ptr, _Right_size + 1);
+                    _Mypair._Myval2._Mysize = _Right_size;
+                    _Mypair._Myval2._Myres  = _Small_string_capacity;
+                }
+
+                _Pocca(_Al, _Right_al);
+                _New_proxy._Bind(_Alproxy, _STD addressof(_Mypair._Myval2));
+                return *this;
+            }
+        }
+
+        _Pocca(_Al, _Right_al);
+        assign(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+        return *this;
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _CONSTEXPR20 basic_string& operator=(const _StringViewIsh& _Right) {
+        return assign(_Right);
+    }
+#endif // _HAS_CXX17
+
+    _CONSTEXPR20 basic_string& operator=(_In_z_ const _Elem* const _Ptr) {
+        return assign(_Ptr);
+    }
+
+#if _HAS_CXX23
+    basic_string& operator=(nullptr_t) = delete;
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 basic_string& operator=(const _Elem _Ch) { // assign {_Ch, _Elem()}
+        _ASAN_STRING_MODIFY(*this, _Mypair._Myval2._Mysize, 1);
+        _Mypair._Myval2._Mysize = 1;
+        _Elem* const _Ptr       = _Mypair._Myval2._Myptr();
+        _Traits::assign(_Ptr[0], _Ch);
+        _Traits::assign(_Ptr[1], _Elem());
+        return *this;
+    }
+
+    _CONSTEXPR20 basic_string& operator+=(const basic_string& _Right) {
+        return append(_Right);
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _CONSTEXPR20 basic_string& operator+=(const _StringViewIsh& _Right) {
+        return append(_Right);
+    }
+#endif // _HAS_CXX17
+
+    _CONSTEXPR20 basic_string& operator+=(_In_z_ const _Elem* const _Ptr) { // append [_Ptr, <null>)
+        return append(_Ptr);
+    }
+
+    _CONSTEXPR20 basic_string& operator+=(_Elem _Ch) {
+        push_back(_Ch);
+        return *this;
+    }
+
+    _CONSTEXPR20 basic_string& append(const basic_string& _Right) {
+        return append(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+    }
+
+    _CONSTEXPR20 basic_string& append(const basic_string& _Right, const size_type _Roff, size_type _Count = npos) {
+        // append _Right [_Roff, _Roff + _Count)
+        _Right._Mypair._Myval2._Check_offset(_Roff);
+        _Count = _Right._Mypair._Myval2._Clamp_suffix_size(_Roff, _Count);
+        return append(_Right._Mypair._Myval2._Myptr() + _Roff, _Count);
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _CONSTEXPR20 basic_string& append(const _StringViewIsh& _Right) {
+        const basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return append(_As_view.data(), _Convert_size<size_type>(_As_view.size()));
+    }
+
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _CONSTEXPR20 basic_string& append(
+        const _StringViewIsh& _Right, const size_type _Roff, const size_type _Count = npos) {
+        // append _Right [_Roff, _Roff + _Count)
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return append(_As_view.substr(_Roff, _Count));
+    }
+#endif // _HAS_CXX17
+
+    _CONSTEXPR20 basic_string& append(
+        _In_reads_(_Count) const _Elem* const _Ptr, _CRT_GUARDOVERFLOW const size_type _Count) {
+        // append [_Ptr, _Ptr + _Count)
+        const size_type _Old_size = _Mypair._Myval2._Mysize;
+        if (_Count <= _Mypair._Myval2._Myres - _Old_size) {
+            _ASAN_STRING_MODIFY(*this, _Old_size, _Old_size + _Count);
+            _Mypair._Myval2._Mysize = _Old_size + _Count;
+            _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
+            _Traits::move(_Old_ptr + _Old_size, _Ptr, _Count);
+            _Traits::assign(_Old_ptr[_Old_size + _Count], _Elem());
+            return *this;
+        }
+
+        return _Reallocate_grow_by(
+            _Count,
+            [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size, const _Elem* const _Ptr,
+                const size_type _Count) _STATIC_CALL_OPERATOR {
+                _Traits::copy(_New_ptr, _Old_ptr, _Old_size);
+                _Traits::copy(_New_ptr + _Old_size, _Ptr, _Count);
+                _Traits::assign(_New_ptr[_Old_size + _Count], _Elem());
+            },
+            _Ptr, _Count);
+    }
+
+    _CONSTEXPR20 basic_string& append(_In_z_ const _Elem* const _Ptr) { // append [_Ptr, <null>)
+        return append(_Ptr, _Convert_size<size_type>(_Traits::length(_Ptr)));
+    }
+
+    _CONSTEXPR20 basic_string& append(_CRT_GUARDOVERFLOW const size_type _Count, const _Elem _Ch) {
+        // append _Count * _Ch
+        const size_type _Old_size = _Mypair._Myval2._Mysize;
+        if (_Count <= _Mypair._Myval2._Myres - _Old_size) {
+            _ASAN_STRING_MODIFY(*this, _Old_size, _Old_size + _Count);
+            _Mypair._Myval2._Mysize = _Old_size + _Count;
+            _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
+            _Traits::assign(_Old_ptr + _Old_size, _Count, _Ch);
+            _Traits::assign(_Old_ptr[_Old_size + _Count], _Elem());
+            return *this;
+        }
+
+        return _Reallocate_grow_by(
+            _Count,
+            [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size, const size_type _Count,
+                const _Elem _Ch) _STATIC_CALL_OPERATOR {
+                _Traits::copy(_New_ptr, _Old_ptr, _Old_size);
+                _Traits::assign(_New_ptr + _Old_size, _Count, _Ch);
+                _Traits::assign(_New_ptr[_Old_size + _Count], _Elem());
+            },
+            _Count, _Ch);
+    }
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    _CONSTEXPR20 basic_string& append(const _Iter _First, const _Iter _Last) {
+        // append [_First, _Last), input iterators
+        _STD _Adl_verify_range(_First, _Last);
+        const auto _UFirst = _STD _Get_unwrapped(_First);
+        const auto _ULast  = _STD _Get_unwrapped(_Last);
+        if constexpr (_Is_elem_cptr<decltype(_UFirst)>::value) {
+            return append(_UFirst, _STD _Convert_size<size_type>(static_cast<size_t>(_ULast - _UFirst)));
+        } else {
+            const basic_string _Right(_UFirst, _ULast, get_allocator());
+            return append(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+        }
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Elem> _Rng>
+    constexpr basic_string& append_range(_Rng&& _Range) {
+        if constexpr (_RANGES sized_range<_Rng> && _Contiguous_range_of<_Rng, _Elem>) {
+            const auto _Count = _Convert_size<size_type>(_To_unsigned_like(_RANGES size(_Range)));
+            return append(_RANGES data(_Range), _Count);
+        } else {
+            const basic_string _Right(from_range, _Range, get_allocator());
+            return append(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+        }
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 basic_string& assign(const basic_string& _Right) {
+        *this = _Right;
+        return *this;
+    }
+
+    _CONSTEXPR20 basic_string& assign(const basic_string& _Right, const size_type _Roff, size_type _Count = npos) {
+        // assign _Right [_Roff, _Roff + _Count)
+        _Right._Mypair._Myval2._Check_offset(_Roff);
+        _Count = _Right._Mypair._Myval2._Clamp_suffix_size(_Roff, _Count);
+        return assign(_Right._Mypair._Myval2._Myptr() + _Roff, _Count);
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _CONSTEXPR20 basic_string& assign(const _StringViewIsh& _Right) {
+        const basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return assign(_As_view.data(), _Convert_size<size_type>(_As_view.size()));
+    }
+
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _CONSTEXPR20 basic_string& assign(
+        const _StringViewIsh& _Right, const size_type _Roff, const size_type _Count = npos) {
+        // assign _Right [_Roff, _Roff + _Count)
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return assign(_As_view.substr(_Roff, _Count));
+    }
+#endif // _HAS_CXX17
+
+    _CONSTEXPR20 basic_string& assign(
+        _In_reads_(_Count) const _Elem* const _Ptr, _CRT_GUARDOVERFLOW const size_type _Count) {
+        // assign [_Ptr, _Ptr + _Count)
+        if (_Count <= _Mypair._Myval2._Myres) {
+            _ASAN_STRING_REMOVE(*this);
+            _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
+            _Mypair._Myval2._Mysize = _Count;
+            _Traits::move(_Old_ptr, _Ptr, _Count);
+            _Traits::assign(_Old_ptr[_Count], _Elem());
+            _ASAN_STRING_CREATE(*this);
+            return *this;
+        }
+
+        return _Reallocate_for(
+            _Count,
+            [](_Elem* const _New_ptr, const size_type _Count, const _Elem* const _Ptr) _STATIC_CALL_OPERATOR {
+                _Traits::copy(_New_ptr, _Ptr, _Count);
+                _Traits::assign(_New_ptr[_Count], _Elem());
+            },
+            _Ptr);
+    }
+
+    _CONSTEXPR20 basic_string& assign(_In_z_ const _Elem* const _Ptr) {
+        return assign(_Ptr, _Convert_size<size_type>(_Traits::length(_Ptr)));
+    }
+
+    _CONSTEXPR20 basic_string& assign(_CRT_GUARDOVERFLOW const size_type _Count, const _Elem _Ch) {
+        // assign _Count * _Ch
+        if (_Count <= _Mypair._Myval2._Myres) {
+            _ASAN_STRING_MODIFY(*this, _Mypair._Myval2._Mysize, _Count);
+            _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
+            _Mypair._Myval2._Mysize = _Count;
+            _Traits::assign(_Old_ptr, _Count, _Ch);
+            _Traits::assign(_Old_ptr[_Count], _Elem());
+            return *this;
+        }
+
+        return _Reallocate_for(
+            _Count,
+            [](_Elem* const _New_ptr, const size_type _Count, const _Elem _Ch) _STATIC_CALL_OPERATOR {
+                _Traits::assign(_New_ptr, _Count, _Ch);
+                _Traits::assign(_New_ptr[_Count], _Elem());
+            },
+            _Ch);
+    }
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    _CONSTEXPR20 basic_string& assign(const _Iter _First, const _Iter _Last) {
+        _STD _Adl_verify_range(_First, _Last);
+        const auto _UFirst = _STD _Get_unwrapped(_First);
+        const auto _ULast  = _STD _Get_unwrapped(_Last);
+        if constexpr (_Is_elem_cptr<decltype(_UFirst)>::value) {
+            return assign(_UFirst, _STD _Convert_size<size_type>(static_cast<size_t>(_ULast - _UFirst)));
+        } else {
+            basic_string _Right(_UFirst, _ULast, get_allocator());
+            if (_Mypair._Myval2._Myres < _Right._Mypair._Myval2._Myres) {
+                _Mypair._Myval2._Orphan_all();
+                _Swap_data(_Right);
+                return *this;
+            } else {
+                return assign(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+            }
+        }
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Elem> _Rng>
+    constexpr basic_string& assign_range(_Rng&& _Range) {
+        if constexpr (_RANGES sized_range<_Rng> && _Contiguous_range_of<_Rng, _Elem>) {
+            const auto _Count = _Convert_size<size_type>(_To_unsigned_like(_RANGES size(_Range)));
+            return assign(_RANGES data(_Range), _Count);
+        } else {
+            basic_string _Right(from_range, _Range, get_allocator());
+            if (_Mypair._Myval2._Myres < _Right._Mypair._Myval2._Myres) {
+                _Mypair._Myval2._Orphan_all();
+                _Swap_data(_Right);
+                return *this;
+            } else {
+                return assign(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+            }
+        }
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 basic_string& insert(const size_type _Off, const basic_string& _Right) {
+        // insert _Right at _Off
+        return insert(_Off, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+    }
+
+    _CONSTEXPR20 basic_string& insert(
+        const size_type _Off, const basic_string& _Right, const size_type _Roff, size_type _Count = npos) {
+        // insert _Right [_Roff, _Roff + _Count) at _Off
+        _Right._Mypair._Myval2._Check_offset(_Roff);
+        _Count = _Right._Mypair._Myval2._Clamp_suffix_size(_Roff, _Count);
+        return insert(_Off, _Right._Mypair._Myval2._Myptr() + _Roff, _Count);
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _CONSTEXPR20 basic_string& insert(const size_type _Off, const _StringViewIsh& _Right) {
+        // insert _Right at _Off
+        const basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return insert(_Off, _As_view.data(), _Convert_size<size_type>(_As_view.size()));
+    }
+
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _CONSTEXPR20 basic_string& insert(
+        const size_type _Off, const _StringViewIsh& _Right, const size_type _Roff, const size_type _Count = npos) {
+        // insert _Right [_Roff, _Roff + _Count) at _Off
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return insert(_Off, _As_view.substr(_Roff, _Count));
+    }
+#endif // _HAS_CXX17
+
+    _CONSTEXPR20 basic_string& insert(
+        const size_type _Off, _In_reads_(_Count) const _Elem* const _Ptr, _CRT_GUARDOVERFLOW const size_type _Count) {
+        // insert [_Ptr, _Ptr + _Count) at _Off
+        _Mypair._Myval2._Check_offset(_Off);
+        const size_type _Old_size = _Mypair._Myval2._Mysize;
+
+        // We can't check for overlapping ranges when constant evaluated since comparison of pointers into string
+        // literals is unspecified, so always reallocate and copy to the new buffer if constant evaluated.
+#if _HAS_CXX20
+        const bool _Check_overlap = _Count <= _Mypair._Myval2._Myres - _Old_size && !_STD is_constant_evaluated();
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+        const bool _Check_overlap = _Count <= _Mypair._Myval2._Myres - _Old_size;
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+        if (_Check_overlap) {
+            _ASAN_STRING_MODIFY(*this, _Old_size, _Old_size + _Count);
+            _Mypair._Myval2._Mysize = _Old_size + _Count;
+            _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
+            _Elem* const _Insert_at = _Old_ptr + _Off;
+            // the range [_Ptr, _Ptr + _Ptr_shifted_after) is left alone by moving the suffix out,
+            // while the range [_Ptr + _Ptr_shifted_after, _Ptr + _Count) shifts down by _Count
+            size_type _Ptr_shifted_after;
+            if (_Ptr + _Count <= _Insert_at || _Ptr > _Old_ptr + _Old_size) {
+                // inserted content is before the shifted region, or does not alias
+                _Ptr_shifted_after = _Count; // none of _Ptr's data shifts
+            } else if (_Insert_at <= _Ptr) { // all of [_Ptr, _Ptr + _Count) shifts
+                _Ptr_shifted_after = 0;
+            } else { // [_Ptr, _Ptr + _Count) contains _Insert_at, so only the part after _Insert_at shifts
+                _Ptr_shifted_after = static_cast<size_type>(_Insert_at - _Ptr);
+            }
+
+            _Traits::move(_Insert_at + _Count, _Insert_at, _Old_size - _Off + 1); // move suffix + null down
+            _Traits::copy(_Insert_at, _Ptr, _Ptr_shifted_after);
+            _Traits::copy(
+                _Insert_at + _Ptr_shifted_after, _Ptr + _Count + _Ptr_shifted_after, _Count - _Ptr_shifted_after);
+            return *this;
+        }
+
+        return _Reallocate_grow_by(
+            _Count,
+            [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size, const size_type _Off,
+                const _Elem* const _Ptr, const size_type _Count) _STATIC_CALL_OPERATOR {
+                _Traits::copy(_New_ptr, _Old_ptr, _Off);
+                _Traits::copy(_New_ptr + _Off, _Ptr, _Count);
+                _Traits::copy(_New_ptr + _Off + _Count, _Old_ptr + _Off, _Old_size - _Off + 1);
+            },
+            _Off, _Ptr, _Count);
+    }
+
+    _CONSTEXPR20 basic_string& insert(const size_type _Off, _In_z_ const _Elem* const _Ptr) {
+        // insert [_Ptr, <null>) at _Off
+        return insert(_Off, _Ptr, _Convert_size<size_type>(_Traits::length(_Ptr)));
+    }
+
+    _CONSTEXPR20 basic_string& insert(
+        const size_type _Off, _CRT_GUARDOVERFLOW const size_type _Count, const _Elem _Ch) {
+        // insert _Count * _Ch at _Off
+        _Mypair._Myval2._Check_offset(_Off);
+        const size_type _Old_size = _Mypair._Myval2._Mysize;
+        if (_Count <= _Mypair._Myval2._Myres - _Old_size) {
+            _ASAN_STRING_MODIFY(*this, _Old_size, _Old_size + _Count);
+            _Mypair._Myval2._Mysize = _Old_size + _Count;
+            _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
+            _Elem* const _Insert_at = _Old_ptr + _Off;
+            _Traits::move(_Insert_at + _Count, _Insert_at, _Old_size - _Off + 1); // move suffix + null down
+            _Traits::assign(_Insert_at, _Count, _Ch); // fill hole
+            return *this;
+        }
+
+        return _Reallocate_grow_by(
+            _Count,
+            [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size, const size_type _Off,
+                const size_type _Count, const _Elem _Ch) _STATIC_CALL_OPERATOR {
+                _Traits::copy(_New_ptr, _Old_ptr, _Off);
+                _Traits::assign(_New_ptr + _Off, _Count, _Ch);
+                _Traits::copy(_New_ptr + _Off + _Count, _Old_ptr + _Off, _Old_size - _Off + 1);
+            },
+            _Off, _Count, _Ch);
+    }
+
+    _CONSTEXPR20 iterator insert(const const_iterator _Where, const _Elem _Ch) { // insert _Ch at _Where
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2), "string iterator incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Off = static_cast<size_type>(_Unfancy(_Where._Ptr) - _Mypair._Myval2._Myptr());
+        insert(_Off, 1, _Ch);
+        return begin() + static_cast<difference_type>(_Off);
+    }
+
+    _CONSTEXPR20 iterator insert(
+        const const_iterator _Where, _CRT_GUARDOVERFLOW const size_type _Count, const _Elem _Ch) {
+        // insert _Count * _Elem at _Where
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2), "string iterator incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Off = static_cast<size_type>(_Unfancy(_Where._Ptr) - _Mypair._Myval2._Myptr());
+        insert(_Off, _Count, _Ch);
+        return begin() + static_cast<difference_type>(_Off);
+    }
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    _CONSTEXPR20 iterator insert(const const_iterator _Where, const _Iter _First, const _Iter _Last) {
+        // insert [_First, _Last) at _Where, input iterators
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2), "string iterator incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Off = static_cast<size_type>(_Unfancy(_Where._Ptr) - _Mypair._Myval2._Myptr());
+        _STD _Adl_verify_range(_First, _Last);
+        const auto _UFirst = _STD _Get_unwrapped(_First);
+        const auto _ULast  = _STD _Get_unwrapped(_Last);
+        if constexpr (_Is_elem_cptr<decltype(_UFirst)>::value) {
+            insert(_Off, _UFirst, _STD _Convert_size<size_type>(static_cast<size_t>(_ULast - _UFirst)));
+        } else {
+            const basic_string _Right(_UFirst, _ULast, get_allocator());
+            insert(_Off, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+        }
+
+        return begin() + static_cast<difference_type>(_Off);
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Elem> _Rng>
+    constexpr iterator insert_range(const const_iterator _Where, _Rng&& _Range) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2), "string iterator incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Off = static_cast<size_type>(_Unfancy(_Where._Ptr) - _Mypair._Myval2._Myptr());
+
+        if constexpr (_RANGES sized_range<_Rng> && _Contiguous_range_of<_Rng, _Elem>) {
+            const auto _Count = _Convert_size<size_type>(_To_unsigned_like(_RANGES size(_Range)));
+            insert(_Off, _RANGES data(_Range), _Count);
+        } else {
+            const basic_string _Right(from_range, _Range, get_allocator());
+            insert(_Off, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+        }
+
+        return begin() + static_cast<difference_type>(_Off);
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 basic_string& erase(const size_type _Off = 0) { // erase elements [_Off, ...)
+        _Mypair._Myval2._Check_offset(_Off);
+        _Eos(_Off);
+        return *this;
+    }
+
+private:
+    _CONSTEXPR20 basic_string& _Erase_noexcept(const size_type _Off, size_type _Count) noexcept {
+        _Count                    = _Mypair._Myval2._Clamp_suffix_size(_Off, _Count);
+        const size_type _Old_size = _Mypair._Myval2._Mysize;
+        _Elem* const _My_ptr      = _Mypair._Myval2._Myptr();
+        _Elem* const _Erase_at    = _My_ptr + _Off;
+        const size_type _New_size = _Old_size - _Count;
+        _Traits::move(_Erase_at, _Erase_at + _Count, _New_size - _Off + 1); // move suffix + null up
+        _ASAN_STRING_MODIFY(*this, _Old_size, _New_size);
+        _Mypair._Myval2._Mysize = _New_size;
+        return *this;
+    }
+
+public:
+    _CONSTEXPR20 basic_string& erase(const size_type _Off, const size_type _Count) {
+        // erase elements [_Off, _Off + _Count)
+        _Mypair._Myval2._Check_offset(_Off);
+        return _Erase_noexcept(_Off, _Count);
+    }
+
+    _CONSTEXPR20 iterator erase(const const_iterator _Where) noexcept /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2), "string iterator incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Off = static_cast<size_type>(_Unfancy(_Where._Ptr) - _Mypair._Myval2._Myptr());
+        _Erase_noexcept(_Off, 1);
+        return begin() + static_cast<difference_type>(_Off);
+    }
+
+    _CONSTEXPR20 iterator erase(const const_iterator _First, const const_iterator _Last) noexcept
+    /* strengthened */ {
+        _STD _Adl_verify_range(_First, _Last);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_First._Getcont() == _STD addressof(_Mypair._Myval2), "string iterators incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Off = static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr());
+        _Erase_noexcept(_Off, static_cast<size_type>(_Last._Ptr - _First._Ptr));
+        return begin() + static_cast<difference_type>(_Off);
+    }
+
+    _CONSTEXPR20 void clear() noexcept { // erase all
+        _Eos(0);
+    }
+
+    _CONSTEXPR20 basic_string& replace(const size_type _Off, const size_type _Nx, const basic_string& _Right) {
+        // replace [_Off, _Off + _Nx) with _Right
+        return replace(_Off, _Nx, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+    }
+
+    _CONSTEXPR20 basic_string& replace(const size_type _Off, size_type _Nx, const basic_string& _Right,
+        const size_type _Roff, size_type _Count = npos) {
+        // replace [_Off, _Off + _Nx) with _Right [_Roff, _Roff + _Count)
+        _Right._Mypair._Myval2._Check_offset(_Roff);
+        _Count = _Right._Mypair._Myval2._Clamp_suffix_size(_Roff, _Count);
+        return replace(_Off, _Nx, _Right._Mypair._Myval2._Myptr() + _Roff, _Count);
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _CONSTEXPR20 basic_string& replace(const size_type _Off, const size_type _Nx, const _StringViewIsh& _Right) {
+        // replace [_Off, _Off + _Nx) with _Right
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return replace(_Off, _Nx, _As_view.data(), _Convert_size<size_type>(_As_view.size()));
+    }
+
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _CONSTEXPR20 basic_string& replace(const size_type _Off, const size_type _Nx, const _StringViewIsh& _Right,
+        const size_type _Roff, const size_type _Count = npos) {
+        // replace [_Off, _Off + _Nx) with _Right [_Roff, _Roff + _Count)
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return replace(_Off, _Nx, _As_view.substr(_Roff, _Count));
+    }
+#endif // _HAS_CXX17
+
+    _CONSTEXPR20 basic_string& replace(
+        const size_type _Off, size_type _Nx, _In_reads_(_Count) const _Elem* const _Ptr, const size_type _Count) {
+        // replace [_Off, _Off + _Nx) with [_Ptr, _Ptr + _Count)
+        _Mypair._Myval2._Check_offset(_Off);
+        _Nx = _Mypair._Myval2._Clamp_suffix_size(_Off, _Nx);
+        if (_Nx == _Count) { // size doesn't change, so a single move does the trick
+            _Traits::move(_Mypair._Myval2._Myptr() + _Off, _Ptr, _Count);
+            return *this;
+        }
+
+        const size_type _Old_size    = _Mypair._Myval2._Mysize;
+        const size_type _Suffix_size = _Old_size - _Nx - _Off + 1;
+        if (_Count < _Nx) { // suffix shifts backwards; we don't have to move anything out of the way
+            _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
+            _Elem* const _Insert_at = _Old_ptr + _Off;
+            _Traits::move(_Insert_at, _Ptr, _Count);
+            _Traits::move(_Insert_at + _Count, _Insert_at + _Nx, _Suffix_size);
+
+            const auto _New_size = _Old_size - (_Nx - _Count);
+            _ASAN_STRING_MODIFY(*this, _Old_size, _New_size);
+            _Mypair._Myval2._Mysize = _New_size;
+            return *this;
+        }
+
+        const size_type _Growth = static_cast<size_type>(_Count - _Nx);
+
+        // checking for overlapping ranges is technically UB (considering string literals), so just always reallocate
+        // and copy to the new buffer if constant evaluated
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            if (_Growth <= _Mypair._Myval2._Myres - _Old_size) { // growth fits
+                _ASAN_STRING_MODIFY(*this, _Old_size, _Old_size + _Growth);
+                _Mypair._Myval2._Mysize = _Old_size + _Growth;
+                _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
+                _Elem* const _Insert_at = _Old_ptr + _Off;
+                _Elem* const _Suffix_at = _Insert_at + _Nx;
+
+                size_type _Ptr_shifted_after; // see rationale in insert
+                if (_Ptr + _Count <= _Insert_at || _Ptr > _Old_ptr + _Old_size) {
+                    _Ptr_shifted_after = _Count;
+                } else if (_Suffix_at <= _Ptr) {
+                    _Ptr_shifted_after = 0;
+                } else {
+                    _Ptr_shifted_after = static_cast<size_type>(_Suffix_at - _Ptr);
+                }
+
+                _Traits::move(_Suffix_at + _Growth, _Suffix_at, _Suffix_size);
+                // next case must be move, in case _Ptr begins before _Insert_at and contains part of the hole;
+                // this case doesn't occur in insert because the new content must come from outside the removed
+                // content there (because in insert there is no removed content)
+                _Traits::move(_Insert_at, _Ptr, _Ptr_shifted_after);
+                // the next case can be copy, because it comes from the chunk moved out of the way in the
+                // first move, and the hole we're filling can't alias the chunk we moved out of the way
+                _Traits::copy(
+                    _Insert_at + _Ptr_shifted_after, _Ptr + _Growth + _Ptr_shifted_after, _Count - _Ptr_shifted_after);
+                return *this;
+            }
+        }
+
+        return _Reallocate_grow_by(
+            _Growth,
+            [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size, const size_type _Off,
+                const size_type _Nx, const _Elem* const _Ptr, const size_type _Count) _STATIC_CALL_OPERATOR {
+                _Traits::copy(_New_ptr, _Old_ptr, _Off);
+                _Traits::copy(_New_ptr + _Off, _Ptr, _Count);
+                _Traits::copy(_New_ptr + _Off + _Count, _Old_ptr + _Off + _Nx, _Old_size - _Nx - _Off + 1);
+            },
+            _Off, _Nx, _Ptr, _Count);
+    }
+
+    _CONSTEXPR20 basic_string& replace(const size_type _Off, const size_type _Nx, _In_z_ const _Elem* const _Ptr) {
+        // replace [_Off, _Off + _Nx) with [_Ptr, <null>)
+        return replace(_Off, _Nx, _Ptr, _Convert_size<size_type>(_Traits::length(_Ptr)));
+    }
+
+    _CONSTEXPR20 basic_string& replace(const size_type _Off, size_type _Nx, const size_type _Count, const _Elem _Ch) {
+        // replace [_Off, _Off + _Nx) with _Count * _Ch
+        _Mypair._Myval2._Check_offset(_Off);
+        _Nx = _Mypair._Myval2._Clamp_suffix_size(_Off, _Nx);
+        if (_Count == _Nx) {
+            _Traits::assign(_Mypair._Myval2._Myptr() + _Off, _Count, _Ch);
+            return *this;
+        }
+
+        const size_type _Old_size = _Mypair._Myval2._Mysize;
+        if (_Count < _Nx || _Count - _Nx <= _Mypair._Myval2._Myres - _Old_size) {
+            // either we are shrinking, or the growth fits
+            // may temporarily overflow; OK because size_type must be unsigned
+            const auto _New_size = _Old_size + _Count - _Nx;
+            _ASAN_STRING_REMOVE(*this);
+            _Mypair._Myval2._Mysize = _New_size;
+            _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
+            _Elem* const _Insert_at = _Old_ptr + _Off;
+            _Traits::move(_Insert_at + _Count, _Insert_at + _Nx, _Old_size - _Nx - _Off + 1);
+            _Traits::assign(_Insert_at, _Count, _Ch);
+            _ASAN_STRING_CREATE(*this);
+            return *this;
+        }
+
+        return _Reallocate_grow_by(
+            _Count - _Nx,
+            [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size, const size_type _Off,
+                const size_type _Nx, const size_type _Count, const _Elem _Ch) _STATIC_CALL_OPERATOR {
+                _Traits::copy(_New_ptr, _Old_ptr, _Off);
+                _Traits::assign(_New_ptr + _Off, _Count, _Ch);
+                _Traits::copy(_New_ptr + _Off + _Count, _Old_ptr + _Off + _Nx, _Old_size - _Nx - _Off + 1);
+            },
+            _Off, _Nx, _Count, _Ch);
+    }
+
+    _CONSTEXPR20 basic_string& replace(
+        const const_iterator _First, const const_iterator _Last, const basic_string& _Right) {
+        // replace [_First, _Last) with _Right
+        _STD _Adl_verify_range(_First, _Last);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_First._Getcont() == _STD addressof(_Mypair._Myval2), "string iterators incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        return replace(static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr()),
+            static_cast<size_type>(_Last._Ptr - _First._Ptr), _Right);
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _CONSTEXPR20 basic_string& replace(
+        const const_iterator _First, const const_iterator _Last, const _StringViewIsh& _Right) {
+        // replace [_First, _Last) with _Right
+        _STD _Adl_verify_range(_First, _Last);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_First._Getcont() == _STD addressof(_Mypair._Myval2), "string iterators incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        return replace(static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr()),
+            static_cast<size_type>(_Last._Ptr - _First._Ptr), _Right);
+    }
+#endif // _HAS_CXX17
+
+    _CONSTEXPR20 basic_string& replace(const const_iterator _First, const const_iterator _Last,
+        _In_reads_(_Count) const _Elem* const _Ptr, const size_type _Count) {
+        // replace [_First, _Last) with [_Ptr, _Ptr + _Count)
+        _STD _Adl_verify_range(_First, _Last);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_First._Getcont() == _STD addressof(_Mypair._Myval2), "string iterators incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        return replace(static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr()),
+            static_cast<size_type>(_Last._Ptr - _First._Ptr), _Ptr, _Count);
+    }
+
+    _CONSTEXPR20 basic_string& replace(
+        const const_iterator _First, const const_iterator _Last, _In_z_ const _Elem* const _Ptr) {
+        // replace [_First, _Last) with [_Ptr, <null>)
+        _STD _Adl_verify_range(_First, _Last);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_First._Getcont() == _STD addressof(_Mypair._Myval2), "string iterators incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        return replace(static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr()),
+            static_cast<size_type>(_Last._Ptr - _First._Ptr), _Ptr);
+    }
+
+    _CONSTEXPR20 basic_string& replace(
+        const const_iterator _First, const const_iterator _Last, const size_type _Count, const _Elem _Ch) {
+        // replace [_First, _Last) with _Count * _Ch
+        _STD _Adl_verify_range(_First, _Last);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_First._Getcont() == _STD addressof(_Mypair._Myval2), "string iterators incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        return replace(static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr()),
+            static_cast<size_type>(_Last._Ptr - _First._Ptr), _Count, _Ch);
+    }
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    _CONSTEXPR20 basic_string& replace(
+        const const_iterator _First, const const_iterator _Last, const _Iter _First2, const _Iter _Last2) {
+        // replace [_First, _Last) with [_First2, _Last2), input iterators
+        _STD _Adl_verify_range(_First, _Last);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_First._Getcont() == _STD addressof(_Mypair._Myval2), "string iterators incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Off    = static_cast<size_type>(_STD _Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr());
+        const auto _Length = static_cast<size_type>(_Last._Ptr - _First._Ptr);
+        _STD _Adl_verify_range(_First2, _Last2);
+        const auto _UFirst2 = _STD _Get_unwrapped(_First2);
+        const auto _ULast2  = _STD _Get_unwrapped(_Last2);
+        if constexpr (_Is_elem_cptr<decltype(_UFirst2)>::value) {
+            return replace(
+                _Off, _Length, _UFirst2, _STD _Convert_size<size_type>(static_cast<size_t>(_ULast2 - _UFirst2)));
+        } else {
+            const basic_string _Right(_UFirst2, _ULast2, get_allocator());
+            return replace(_Off, _Length, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+        }
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Elem> _Rng>
+    constexpr basic_string& replace_with_range(const const_iterator _First, const const_iterator _Last, _Rng&& _Range) {
+        _STD _Adl_verify_range(_First, _Last);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_First._Getcont() == _STD addressof(_Mypair._Myval2), "string iterators incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Off    = static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr());
+        const auto _Length = static_cast<size_type>(_Last._Ptr - _First._Ptr);
+
+        if constexpr (_RANGES sized_range<_Rng> && _Contiguous_range_of<_Rng, _Elem>) {
+            const auto _Count = _Convert_size<size_type>(_To_unsigned_like(_RANGES size(_Range)));
+            return replace(_Off, _Length, _RANGES data(_Range), _Count);
+        } else {
+            const basic_string _Right(from_range, _Range, get_allocator());
+            return replace(_Off, _Length, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+        }
+    }
+#endif // _HAS_CXX23
+
+    _NODISCARD _CONSTEXPR20 iterator begin() noexcept {
+        return iterator(_Refancy<pointer>(_Mypair._Myval2._Myptr()), _STD addressof(_Mypair._Myval2));
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator begin() const noexcept {
+        return const_iterator(_Refancy<const_pointer>(_Mypair._Myval2._Myptr()), _STD addressof(_Mypair._Myval2));
+    }
+
+    _NODISCARD _CONSTEXPR20 iterator end() noexcept {
+        return iterator(
+            _Refancy<pointer>(_Mypair._Myval2._Myptr()) + static_cast<difference_type>(_Mypair._Myval2._Mysize),
+            _STD addressof(_Mypair._Myval2));
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator end() const noexcept {
+        return const_iterator(
+            _Refancy<const_pointer>(_Mypair._Myval2._Myptr()) + static_cast<difference_type>(_Mypair._Myval2._Mysize),
+            _STD addressof(_Mypair._Myval2));
+    }
+
+    _NODISCARD _CONSTEXPR20 _Elem* _Unchecked_begin() noexcept {
+        return _Mypair._Myval2._Myptr();
+    }
+
+    _NODISCARD _CONSTEXPR20 const _Elem* _Unchecked_begin() const noexcept {
+        return _Mypair._Myval2._Myptr();
+    }
+
+    _NODISCARD _CONSTEXPR20 _Elem* _Unchecked_end() noexcept {
+        return _Mypair._Myval2._Myptr() + _Mypair._Myval2._Mysize;
+    }
+
+    _NODISCARD _CONSTEXPR20 const _Elem* _Unchecked_end() const noexcept {
+        return _Mypair._Myval2._Myptr() + _Mypair._Myval2._Mysize;
+    }
+
+    _NODISCARD _CONSTEXPR20 reverse_iterator rbegin() noexcept {
+        return reverse_iterator(end());
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reverse_iterator rbegin() const noexcept {
+        return const_reverse_iterator(end());
+    }
+
+    _NODISCARD _CONSTEXPR20 reverse_iterator rend() noexcept {
+        return reverse_iterator(begin());
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reverse_iterator rend() const noexcept {
+        return const_reverse_iterator(begin());
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator cbegin() const noexcept {
+        return begin();
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator cend() const noexcept {
+        return end();
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reverse_iterator crbegin() const noexcept {
+        return rbegin();
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reverse_iterator crend() const noexcept {
+        return rend();
+    }
+
+    _CONSTEXPR20 void shrink_to_fit() { // reduce capacity
+        auto& _My_data = _Mypair._Myval2;
+
+        if (!_My_data._Large_mode_engaged()) { // can't shrink from small mode
+            return;
+        }
+
+        if (_My_data._Mysize <= _Small_string_capacity) {
+            _Become_small();
+            return;
+        }
+
+        size_type _Target_capacity = (_STD min)(_My_data._Mysize | _Alloc_mask, max_size());
+        if (_Target_capacity < _My_data._Myres) { // worth shrinking, do it
+            auto& _Al = _Getal();
+            const pointer _New_ptr =
+                _Allocate_for_capacity<_Allocation_policy::_Exactly>(_Al, _Target_capacity); // throws
+            _ASAN_STRING_REMOVE(*this);
+
+            _My_data._Orphan_all();
+            _Traits::copy(_Unfancy(_New_ptr), _Unfancy(_My_data._Bx._Ptr), _My_data._Mysize + 1);
+            _Deallocate_for_capacity(_Al, _My_data._Bx._Ptr, _My_data._Myres);
+            _My_data._Bx._Ptr = _New_ptr;
+            _My_data._Myres   = _Target_capacity;
+            _ASAN_STRING_CREATE(*this);
+        }
+    }
+
+    _NODISCARD _CONSTEXPR20 reference at(const size_type _Off) {
+        _Mypair._Myval2._Check_offset_exclusive(_Off);
+        return _Mypair._Myval2._Myptr()[_Off];
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reference at(const size_type _Off) const {
+        _Mypair._Myval2._Check_offset_exclusive(_Off);
+        return _Mypair._Myval2._Myptr()[_Off];
+    }
+
+    _NODISCARD _CONSTEXPR20 reference operator[](const size_type _Off) noexcept /* strengthened */ {
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_Off <= _Mypair._Myval2._Mysize, "string subscript out of range");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+        return _Mypair._Myval2._Myptr()[_Off];
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reference operator[](const size_type _Off) const noexcept
+    /* strengthened */ {
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_Off <= _Mypair._Myval2._Mysize, "string subscript out of range");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+        return _Mypair._Myval2._Myptr()[_Off];
+    }
+
+#if _HAS_CXX17
+    /* implicit */ _CONSTEXPR20 operator basic_string_view<_Elem, _Traits>() const noexcept {
+        // return a string_view around *this's character-type sequence
+        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize};
+    }
+#endif // _HAS_CXX17
+
+    _CONSTEXPR20 void push_back(const _Elem _Ch) { // insert element at end
+        const size_type _Old_size = _Mypair._Myval2._Mysize;
+        if (_Old_size < _Mypair._Myval2._Myres) {
+            _ASAN_STRING_MODIFY(*this, _Old_size, _Old_size + 1);
+            _Mypair._Myval2._Mysize = _Old_size + 1;
+            _Elem* const _Ptr       = _Mypair._Myval2._Myptr();
+            _Traits::assign(_Ptr[_Old_size], _Ch);
+            _Traits::assign(_Ptr[_Old_size + 1], _Elem());
+            return;
+        }
+
+        _Reallocate_grow_by(
+            1,
+            [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size, const _Elem _Ch)
+                _STATIC_CALL_OPERATOR {
+                    _Traits::copy(_New_ptr, _Old_ptr, _Old_size);
+                    _Traits::assign(_New_ptr[_Old_size], _Ch);
+                    _Traits::assign(_New_ptr[_Old_size + 1], _Elem());
+                },
+            _Ch);
+    }
+
+    _CONSTEXPR20 void pop_back() noexcept /* strengthened */ {
+        const size_type _Old_size = _Mypair._Myval2._Mysize;
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _STL_VERIFY(_Old_size != 0, "invalid to pop_back empty string");
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+        _Eos(_Old_size - 1);
+    }
+
+    _NODISCARD _CONSTEXPR20 reference front() noexcept /* strengthened */ {
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_Mypair._Myval2._Mysize != 0, "front() called on empty string");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+
+        return _Mypair._Myval2._Myptr()[0];
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reference front() const noexcept /* strengthened */ {
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_Mypair._Myval2._Mysize != 0, "front() called on empty string");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+
+        return _Mypair._Myval2._Myptr()[0];
+    }
+
+    _NODISCARD _CONSTEXPR20 reference back() noexcept /* strengthened */ {
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_Mypair._Myval2._Mysize != 0, "back() called on empty string");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+
+        return _Mypair._Myval2._Myptr()[_Mypair._Myval2._Mysize - 1];
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reference back() const noexcept /* strengthened */ {
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_Mypair._Myval2._Mysize != 0, "back() called on empty string");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+
+        return _Mypair._Myval2._Myptr()[_Mypair._Myval2._Mysize - 1];
+    }
+
+    _NODISCARD _CONSTEXPR20 _Ret_z_ const _Elem* c_str() const noexcept {
+        return _Mypair._Myval2._Myptr();
+    }
+
+    _NODISCARD _CONSTEXPR20 _Ret_z_ const _Elem* data() const noexcept {
+        return _Mypair._Myval2._Myptr();
+    }
+
+#if _HAS_CXX17
+    _NODISCARD _CONSTEXPR20 _Ret_z_ _Elem* data() noexcept {
+        return _Mypair._Myval2._Myptr();
+    }
+#endif // _HAS_CXX17
+
+    _NODISCARD _CONSTEXPR20 size_type length() const noexcept {
+        return _Mypair._Myval2._Mysize;
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type size() const noexcept {
+        return _Mypair._Myval2._Mysize;
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type max_size() const noexcept {
+        const size_type _Alloc_max   = _Alty_traits::max_size(_Getal());
+        const size_type _Storage_max = // can always store small string
+            (_STD max)(_Alloc_max, static_cast<size_type>(_BUF_SIZE));
+        return (_STD min)(static_cast<size_type>(_STD _Max_limit<difference_type>()),
+            _Storage_max - 1 // -1 is for null terminator and/or npos
+        );
+    }
+
+    _CONSTEXPR20 void resize(_CRT_GUARDOVERFLOW const size_type _New_size, const _Elem _Ch = _Elem()) {
+        // determine new length, padding with _Ch elements as needed
+        const size_type _Old_size = size();
+        if (_New_size <= _Old_size) {
+            _Eos(_New_size);
+        } else {
+            append(_New_size - _Old_size, _Ch);
+        }
+    }
+
+    template <class _Operation>
+    constexpr void
+#if _HAS_CXX23
+        resize_and_overwrite
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+        _Resize_and_overwrite
+#endif // ^^^ !_HAS_CXX23 ^^^
+        (_CRT_GUARDOVERFLOW const size_type _New_size, _Operation _Op) {
+        if (_Mypair._Myval2._Myres < _New_size) {
+            _Reallocate_grow_by(_New_size - _Mypair._Myval2._Mysize,
+                [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size)
+                    _STATIC_CALL_OPERATOR { _Traits::copy(_New_ptr, _Old_ptr, _Old_size + 1); });
+        } else {
+            _ASAN_STRING_MODIFY(*this, _Mypair._Myval2._Mysize, _New_size);
+            _Mypair._Myval2._Mysize = _New_size;
+        }
+
+        auto _Arg_ptr                   = _Mypair._Myval2._Myptr();
+        auto _Arg_size                  = _New_size;
+        const auto _Result_size         = _STD move(_Op)(_Arg_ptr, _Arg_size);
+        const auto _Result_as_size_type = static_cast<size_type>(_Result_size);
+#if _CONTAINER_DEBUG_LEVEL > 0
+        _STL_VERIFY(_Result_size >= 0, "the returned size can't be smaller than 0");
+        _STL_VERIFY(_Result_as_size_type <= _New_size, "the returned size can't be greater than the passed size");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+        _Eos(_Result_as_size_type);
+    }
+
+#if _HAS_CXX23
+    template <class _Operation>
+    constexpr void _Resize_and_overwrite(_CRT_GUARDOVERFLOW const size_type _New_size, _Operation _Op) {
+        resize_and_overwrite(_New_size, _Op);
+    }
+#endif // _HAS_CXX23
+
+    _NODISCARD _CONSTEXPR20 size_type capacity() const noexcept {
+        return _Mypair._Myval2._Myres;
+    }
+
+#if _HAS_CXX20
+    constexpr void reserve(_CRT_GUARDOVERFLOW const size_type _Newcap) {
+        // determine new minimum length of allocated storage
+        if (_Mypair._Myval2._Myres >= _Newcap) { // requested capacity is not larger than current capacity, ignore
+            return; // nothing to do
+        }
+
+        const size_type _Old_size = _Mypair._Myval2._Mysize;
+        _Reallocate_grow_by(_Newcap - _Old_size,
+            [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size)
+                _STATIC_CALL_OPERATOR { _Traits::copy(_New_ptr, _Old_ptr, _Old_size + 1); });
+
+        _Mypair._Myval2._Mysize = _Old_size;
+    }
+
+    _CXX20_DEPRECATE_STRING_RESERVE_WITHOUT_ARGUMENT void reserve() {
+        if (_Mypair._Myval2._Mysize == 0 && _Mypair._Myval2._Large_mode_engaged()) {
+            _Become_small();
+        }
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    void reserve(_CRT_GUARDOVERFLOW const size_type _Newcap = 0) { // determine new minimum length of allocated storage
+        if (_Mypair._Myval2._Mysize > _Newcap) { // requested capacity is not large enough for current size, ignore
+            return; // nothing to do
+        }
+
+        if (_Mypair._Myval2._Myres == _Newcap) { // we're already at the requested capacity
+            return; // nothing to do
+        }
+
+        if (_Mypair._Myval2._Myres < _Newcap) { // reallocate to grow
+            const size_type _Old_size = _Mypair._Myval2._Mysize;
+            _Reallocate_grow_by(_Newcap - _Old_size,
+                [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size)
+                    _STATIC_CALL_OPERATOR { _Traits::copy(_New_ptr, _Old_ptr, _Old_size + 1); });
+
+            _Mypair._Myval2._Mysize = _Old_size;
+            return;
+        }
+
+        if (_Newcap <= _Small_string_capacity && _Mypair._Myval2._Large_mode_engaged()) {
+            // deallocate everything; switch back to "small" mode
+            _Become_small();
+            return;
+        }
+
+        // ignore requests to reserve to [_Small_string_capacity + 1, _Myres)
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    _NODISCARD_EMPTY_MEMBER _CONSTEXPR20 bool empty() const noexcept {
+        return _Mypair._Myval2._Mysize == 0;
+    }
+
+    _CONSTEXPR20 size_type copy(
+        _Out_writes_(_Count) _Elem* const _Ptr, size_type _Count, const size_type _Off = 0) const {
+        // copy [_Off, _Off + _Count) to [_Ptr, _Ptr + _Count)
+        _Mypair._Myval2._Check_offset(_Off);
+        _Count = _Mypair._Myval2._Clamp_suffix_size(_Off, _Count);
+        _Traits::copy(_Ptr, _Mypair._Myval2._Myptr() + _Off, _Count);
+        return _Count;
+    }
+
+    _CONSTEXPR20 _Pre_satisfies_(_Dest_size >= _Count) size_type
+        _Copy_s(_Out_writes_all_(_Dest_size) _Elem* const _Dest, const size_type _Dest_size, size_type _Count,
+            const size_type _Off = 0) const {
+        // copy [_Off, _Off + _Count) to [_Dest, _Dest + _Dest_size)
+        _Mypair._Myval2._Check_offset(_Off);
+        _Count = _Mypair._Myval2._Clamp_suffix_size(_Off, _Count);
+        _Traits::_Copy_s(_Dest, _Dest_size, _Mypair._Myval2._Myptr() + _Off, _Count);
+        return _Count;
+    }
+
+    static _CONSTEXPR20 void _Swap_bx_large_with_small(_Scary_val& _Starts_large, _Scary_val& _Starts_small) noexcept {
+        // exchange a string in large mode with one in small mode
+        const pointer _Ptr = _Starts_large._Bx._Ptr;
+        _Starts_large._Bx._Switch_to_buf();
+        _Traits::copy(_Starts_large._Bx._Buf, _Starts_small._Bx._Buf, _BUF_SIZE);
+
+        _Construct_in_place(_Starts_small._Bx._Ptr, _Ptr);
+    }
+
+    _CONSTEXPR20 void _Swap_data(basic_string& _Right) noexcept {
+        using _STD swap;
+
+        auto& _My_data    = _Mypair._Myval2;
+        auto& _Right_data = _Right._Mypair._Myval2;
+
+#if !defined(_INSERT_STRING_ANNOTATION)
+        if constexpr (_Can_memcpy_val) {
+#if _HAS_CXX20
+            if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+            {
+                const auto _My_data_mem =
+                    reinterpret_cast<unsigned char*>(_STD addressof(_My_data)) + _Memcpy_val_offset;
+                const auto _Right_data_mem =
+                    reinterpret_cast<unsigned char*>(_STD addressof(_Right_data)) + _Memcpy_val_offset;
+                unsigned char _Temp_mem[_Memcpy_val_size];
+                _CSTD memcpy(_Temp_mem, _My_data_mem, _Memcpy_val_size);
+                _CSTD memcpy(_My_data_mem, _Right_data_mem, _Memcpy_val_size);
+                _CSTD memcpy(_Right_data_mem, _Temp_mem, _Memcpy_val_size);
+
+                return;
+            }
+        }
+#endif // !defined(_INSERT_STRING_ANNOTATION)
+
+        const bool _My_large    = _My_data._Large_mode_engaged();
+        const bool _Right_large = _Right_data._Large_mode_engaged();
+
+        if (_My_large && _Right_large) { // swap buffers, iterators preserved
+            swap(_My_data._Bx._Ptr, _Right_data._Bx._Ptr); // intentional ADL
+        } else if (_My_large) { // swap large with small
+            _Swap_bx_large_with_small(_My_data, _Right_data);
+        } else if (_Right_large) { // swap small with large
+            _Swap_bx_large_with_small(_Right_data, _My_data);
+        } else {
+            _Elem _Temp_buf[_BUF_SIZE];
+            _Traits::copy(_Temp_buf, _My_data._Bx._Buf, _My_data._Mysize + 1);
+            _Traits::copy(_My_data._Bx._Buf, _Right_data._Bx._Buf, _Right_data._Mysize + 1);
+            _Traits::copy(_Right_data._Bx._Buf, _Temp_buf, _My_data._Mysize + 1);
+        }
+
+        _STD swap(_My_data._Mysize, _Right_data._Mysize);
+        _STD swap(_My_data._Myres, _Right_data._Myres);
+    }
+
+    _CONSTEXPR20 void swap(basic_string& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _Pocs(_Getal(), _Right._Getal());
+
+#if _ITERATOR_DEBUG_LEVEL != 0
+            auto& _My_data    = _Mypair._Myval2;
+            auto& _Right_data = _Right._Mypair._Myval2;
+
+            if (!_My_data._Large_mode_engaged()) {
+                _My_data._Orphan_all();
+            }
+
+            if (!_Right_data._Large_mode_engaged()) {
+                _Right_data._Orphan_all();
+            }
+
+            _My_data._Swap_proxy_and_iterators(_Right_data);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+            _Swap_data(_Right);
+        }
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _NODISCARD _CONSTEXPR20 size_type find(const _StringViewIsh& _Right, const size_type _Off = 0) const
+        noexcept(_Is_nothrow_convertible_v<const _StringViewIsh&, basic_string_view<_Elem, _Traits>>) {
+        // look for _Right beginning at or after _Off
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return static_cast<size_type>(_Traits_find<_Traits>(
+            _Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _As_view.data(), _As_view.size()));
+    }
+#endif // _HAS_CXX17
+
+    _NODISCARD _CONSTEXPR20 size_type find(const basic_string& _Right, const size_type _Off = 0) const noexcept {
+        // look for _Right beginning at or after _Off
+        return static_cast<size_type>(_Traits_find<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off,
+            _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find(_In_reads_(_Count) const _Elem* const _Ptr, const size_type _Off,
+        const size_type _Count) const noexcept /* strengthened */ {
+        // look for [_Ptr, _Ptr + _Count) beginning at or after _Off
+        return static_cast<size_type>(
+            _Traits_find<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ptr, _Count));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find(_In_z_ const _Elem* const _Ptr, const size_type _Off = 0) const noexcept
+    /* strengthened */ {
+        // look for [_Ptr, <null>) beginning at or after _Off
+        return static_cast<size_type>(_Traits_find<_Traits>(
+            _Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ptr, _Traits::length(_Ptr)));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find(const _Elem _Ch, const size_type _Off = 0) const noexcept {
+        // look for _Ch at or after _Off
+        return static_cast<size_type>(
+            _Traits_find_ch<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ch));
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _NODISCARD _CONSTEXPR20 size_type rfind(const _StringViewIsh& _Right, const size_type _Off = npos) const
+        noexcept(_Is_nothrow_convertible_v<const _StringViewIsh&, basic_string_view<_Elem, _Traits>>) {
+        // look for _Right beginning before _Off
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return static_cast<size_type>(_Traits_rfind<_Traits>(
+            _Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _As_view.data(), _As_view.size()));
+    }
+#endif // _HAS_CXX17
+
+    _NODISCARD _CONSTEXPR20 size_type rfind(const basic_string& _Right, const size_type _Off = npos) const noexcept {
+        // look for _Right beginning before _Off
+        return static_cast<size_type>(_Traits_rfind<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off,
+            _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type rfind(_In_reads_(_Count) const _Elem* const _Ptr, const size_type _Off,
+        const size_type _Count) const noexcept /* strengthened */ {
+        // look for [_Ptr, _Ptr + _Count) beginning before _Off
+        return static_cast<size_type>(
+            _Traits_rfind<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ptr, _Count));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type rfind(_In_z_ const _Elem* const _Ptr, const size_type _Off = npos) const noexcept
+    /* strengthened */ {
+        // look for [_Ptr, <null>) beginning before _Off
+        return static_cast<size_type>(_Traits_rfind<_Traits>(
+            _Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ptr, _Traits::length(_Ptr)));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type rfind(const _Elem _Ch, const size_type _Off = npos) const noexcept {
+        // look for _Ch before _Off
+        return static_cast<size_type>(
+            _Traits_rfind_ch<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ch));
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _NODISCARD _CONSTEXPR20 size_type find_first_of(const _StringViewIsh& _Right, const size_type _Off = 0) const
+        noexcept(_Is_nothrow_convertible_v<const _StringViewIsh&, basic_string_view<_Elem, _Traits>>) {
+        // look for one of _Right at or after _Off
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return static_cast<size_type>(_Traits_find_first_of<_Traits>(
+            _Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _As_view.data(), _As_view.size()));
+    }
+#endif // _HAS_CXX17
+
+    _NODISCARD _CONSTEXPR20 size_type find_first_of(
+        const basic_string& _Right, const size_type _Off = 0) const noexcept {
+        // look for one of _Right at or after _Off
+        return static_cast<size_type>(_Traits_find_first_of<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize,
+            _Off, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find_first_of(_In_reads_(_Count) const _Elem* const _Ptr, const size_type _Off,
+        const size_type _Count) const noexcept /* strengthened */ {
+        // look for one of [_Ptr, _Ptr + _Count) at or after _Off
+        return static_cast<size_type>(
+            _Traits_find_first_of<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ptr, _Count));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find_first_of(
+        _In_z_ const _Elem* const _Ptr, const size_type _Off = 0) const noexcept
+    /* strengthened */ {
+        // look for one of [_Ptr, <null>) at or after _Off
+        return static_cast<size_type>(_Traits_find_first_of<_Traits>(
+            _Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ptr, _Traits::length(_Ptr)));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find_first_of(const _Elem _Ch, const size_type _Off = 0) const noexcept {
+        // look for _Ch at or after _Off
+        return static_cast<size_type>(
+            _Traits_find_ch<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ch));
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _NODISCARD _CONSTEXPR20 size_type find_last_of(const _StringViewIsh& _Right, const size_type _Off = npos) const
+        noexcept(_Is_nothrow_convertible_v<const _StringViewIsh&, basic_string_view<_Elem, _Traits>>) {
+        // look for one of _Right before _Off
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return static_cast<size_type>(_Traits_find_last_of<_Traits>(
+            _Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _As_view.data(), _As_view.size()));
+    }
+#endif // _HAS_CXX17
+
+    _NODISCARD _CONSTEXPR20 size_type find_last_of(const basic_string& _Right, size_type _Off = npos) const noexcept {
+        // look for one of _Right before _Off
+        return static_cast<size_type>(_Traits_find_last_of<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize,
+            _Off, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find_last_of(_In_reads_(_Count) const _Elem* const _Ptr, const size_type _Off,
+        const size_type _Count) const noexcept /* strengthened */ {
+        // look for one of [_Ptr, _Ptr + _Count) before _Off
+        return static_cast<size_type>(
+            _Traits_find_last_of<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ptr, _Count));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find_last_of(
+        _In_z_ const _Elem* const _Ptr, const size_type _Off = npos) const noexcept /* strengthened */ {
+        // look for one of [_Ptr, <null>) before _Off
+        return static_cast<size_type>(_Traits_find_last_of<_Traits>(
+            _Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ptr, _Traits::length(_Ptr)));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find_last_of(const _Elem _Ch, const size_type _Off = npos) const noexcept {
+        // look for _Ch before _Off
+        return static_cast<size_type>(
+            _Traits_rfind_ch<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ch));
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _NODISCARD _CONSTEXPR20 size_type find_first_not_of(const _StringViewIsh& _Right, const size_type _Off = 0) const
+        noexcept(_Is_nothrow_convertible_v<const _StringViewIsh&, basic_string_view<_Elem, _Traits>>) {
+        // look for none of _Right at or after _Off
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return static_cast<size_type>(_Traits_find_first_not_of<_Traits>(
+            _Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _As_view.data(), _As_view.size()));
+    }
+#endif // _HAS_CXX17
+
+    _NODISCARD _CONSTEXPR20 size_type find_first_not_of(
+        const basic_string& _Right, const size_type _Off = 0) const noexcept {
+        // look for none of _Right at or after _Off
+        return static_cast<size_type>(_Traits_find_first_not_of<_Traits>(_Mypair._Myval2._Myptr(),
+            _Mypair._Myval2._Mysize, _Off, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find_first_not_of(_In_reads_(_Count) const _Elem* const _Ptr,
+        const size_type _Off, const size_type _Count) const noexcept /* strengthened */ {
+        // look for none of [_Ptr, _Ptr + _Count) at or after _Off
+        return static_cast<size_type>(
+            _Traits_find_first_not_of<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ptr, _Count));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find_first_not_of(
+        _In_z_ const _Elem* const _Ptr, size_type _Off = 0) const noexcept
+    /* strengthened */ {
+        // look for one of [_Ptr, <null>) at or after _Off
+        return static_cast<size_type>(_Traits_find_first_not_of<_Traits>(
+            _Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ptr, _Traits::length(_Ptr)));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find_first_not_of(const _Elem _Ch, const size_type _Off = 0) const noexcept {
+        // look for non-_Ch at or after _Off
+        return static_cast<size_type>(
+            _Traits_find_not_ch<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ch));
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _NODISCARD _CONSTEXPR20 size_type find_last_not_of(const _StringViewIsh& _Right, const size_type _Off = npos) const
+        noexcept(_Is_nothrow_convertible_v<const _StringViewIsh&, basic_string_view<_Elem, _Traits>>) {
+        // look for none of _Right before _Off
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return static_cast<size_type>(_Traits_find_last_not_of<_Traits>(
+            _Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _As_view.data(), _As_view.size()));
+    }
+#endif // _HAS_CXX17
+
+    _NODISCARD _CONSTEXPR20 size_type find_last_not_of(
+        const basic_string& _Right, const size_type _Off = npos) const noexcept {
+        // look for none of _Right before _Off
+        return static_cast<size_type>(_Traits_find_last_not_of<_Traits>(_Mypair._Myval2._Myptr(),
+            _Mypair._Myval2._Mysize, _Off, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find_last_not_of(_In_reads_(_Count) const _Elem* const _Ptr, const size_type _Off,
+        const size_type _Count) const noexcept /* strengthened */ {
+        // look for none of [_Ptr, _Ptr + _Count) before _Off
+        return static_cast<size_type>(
+            _Traits_find_last_not_of<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ptr, _Count));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find_last_not_of(
+        _In_z_ const _Elem* const _Ptr, const size_type _Off = npos) const noexcept /* strengthened */ {
+        // look for none of [_Ptr, <null>) before _Off
+        return static_cast<size_type>(_Traits_find_last_not_of<_Traits>(
+            _Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ptr, _Traits::length(_Ptr)));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find_last_not_of(const _Elem _Ch, const size_type _Off = npos) const noexcept {
+        // look for non-_Ch before _Off
+        return static_cast<size_type>(
+            _Traits_rfind_not_ch<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ch));
+    }
+
+#if _HAS_CXX17
+    _NODISCARD bool _Starts_with(const basic_string_view<_Elem, _Traits> _Right) const noexcept {
+        // Used exclusively by filesystem
+        return basic_string_view<_Elem, _Traits>(*this)._Starts_with(_Right);
+    }
+#endif // _HAS_CXX17
+
+    _NODISCARD _CONSTEXPR20 basic_string substr(const size_type _Off = 0, const size_type _Count = npos)
+#if _HAS_CXX23
+        const&
+#else
+        const
+#endif
+    {
+        // return [_Off, _Off + _Count) as new string, default-constructing its allocator
+        return basic_string{*this, _Off, _Count};
+    }
+
+#if _HAS_CXX23
+    _NODISCARD constexpr basic_string substr(const size_type _Off = 0, const size_type _Count = npos) && {
+        // return [_Off, _Off + _Count) as new string, potentially moving, default-constructing its allocator
+        return basic_string{_STD move(*this), _Off, _Count};
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 bool _Equal(const basic_string& _Right) const noexcept {
+        // compare [0, size()) with _Right for equality
+        return _Traits_equal<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize,
+            _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+    }
+
+    _CONSTEXPR20 bool _Equal(_In_z_ const _Elem* const _Ptr) const noexcept {
+        // compare [0, size()) with _Ptr for equality
+        return _Traits_equal<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Ptr, _Traits::length(_Ptr));
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _NODISCARD _CONSTEXPR20 int compare(const _StringViewIsh& _Right) const
+        noexcept(_Is_nothrow_convertible_v<const _StringViewIsh&, basic_string_view<_Elem, _Traits>>) {
+        // compare [0, size()) with _Right
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return _Traits_compare<_Traits>(
+            _Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _As_view.data(), _As_view.size());
+    }
+
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _NODISCARD _CONSTEXPR20 int compare(const size_type _Off, const size_type _Nx, const _StringViewIsh& _Right) const {
+        // compare [_Off, _Off + _Nx) with _Right
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        _Mypair._Myval2._Check_offset(_Off);
+        return _Traits_compare<_Traits>(_Mypair._Myval2._Myptr() + _Off, _Mypair._Myval2._Clamp_suffix_size(_Off, _Nx),
+            _As_view.data(), _As_view.size());
+    }
+
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _NODISCARD _CONSTEXPR20 int compare(const size_type _Off, const size_type _Nx, const _StringViewIsh& _Right,
+        const size_type _Roff, const size_type _Count = npos) const {
+        // compare [_Off, _Off + _Nx) with _Right [_Roff, _Roff + _Count)
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        _Mypair._Myval2._Check_offset(_Off);
+        const auto _With_substr = _As_view.substr(_Roff, _Count);
+        return _Traits_compare<_Traits>(_Mypair._Myval2._Myptr() + _Off, _Mypair._Myval2._Clamp_suffix_size(_Off, _Nx),
+            _With_substr.data(), _With_substr.size());
+    }
+#endif // _HAS_CXX17
+
+    _NODISCARD _CONSTEXPR20 int compare(const basic_string& _Right) const noexcept {
+        // compare [0, size()) with _Right
+        return _Traits_compare<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize,
+            _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+    }
+
+    _NODISCARD _CONSTEXPR20 int compare(size_type _Off, size_type _Nx, const basic_string& _Right) const {
+        // compare [_Off, _Off + _Nx) with _Right
+        _Mypair._Myval2._Check_offset(_Off);
+        return _Traits_compare<_Traits>(_Mypair._Myval2._Myptr() + _Off, _Mypair._Myval2._Clamp_suffix_size(_Off, _Nx),
+            _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+    }
+
+    _NODISCARD _CONSTEXPR20 int compare(const size_type _Off, const size_type _Nx, const basic_string& _Right,
+        const size_type _Roff, const size_type _Count = npos) const {
+        // compare [_Off, _Off + _Nx) with _Right [_Roff, _Roff + _Count)
+        _Mypair._Myval2._Check_offset(_Off);
+        _Right._Mypair._Myval2._Check_offset(_Roff);
+        return _Traits_compare<_Traits>(_Mypair._Myval2._Myptr() + _Off, _Mypair._Myval2._Clamp_suffix_size(_Off, _Nx),
+            _Right._Mypair._Myval2._Myptr() + _Roff, _Right._Mypair._Myval2._Clamp_suffix_size(_Roff, _Count));
+    }
+
+    _NODISCARD _CONSTEXPR20 int compare(_In_z_ const _Elem* const _Ptr) const noexcept /* strengthened */ {
+        // compare [0, size()) with [_Ptr, <null>)
+        return _Traits_compare<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Ptr, _Traits::length(_Ptr));
+    }
+
+    _NODISCARD _CONSTEXPR20 int compare(
+        const size_type _Off, const size_type _Nx, _In_z_ const _Elem* const _Ptr) const {
+        // compare [_Off, _Off + _Nx) with [_Ptr, <null>)
+        _Mypair._Myval2._Check_offset(_Off);
+        return _Traits_compare<_Traits>(_Mypair._Myval2._Myptr() + _Off, _Mypair._Myval2._Clamp_suffix_size(_Off, _Nx),
+            _Ptr, _Traits::length(_Ptr));
+    }
+
+    _NODISCARD _CONSTEXPR20 int compare(const size_type _Off, const size_type _Nx,
+        _In_reads_(_Count) const _Elem* const _Ptr, const size_type _Count) const {
+        // compare [_Off, _Off + _Nx) with [_Ptr, _Ptr + _Count)
+        _Mypair._Myval2._Check_offset(_Off);
+        return _Traits_compare<_Traits>(
+            _Mypair._Myval2._Myptr() + _Off, _Mypair._Myval2._Clamp_suffix_size(_Off, _Nx), _Ptr, _Count);
+    }
+
+#if _HAS_CXX20
+    _NODISCARD constexpr bool starts_with(const basic_string_view<_Elem, _Traits> _Right) const noexcept {
+        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize}.starts_with(_Right);
+    }
+
+    _NODISCARD constexpr bool starts_with(const _Elem _Right) const noexcept {
+        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize}.starts_with(_Right);
+    }
+
+    _NODISCARD constexpr bool starts_with(const _Elem* const _Right) const noexcept /* strengthened */ {
+        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize}.starts_with(_Right);
+    }
+
+    _NODISCARD constexpr bool ends_with(const basic_string_view<_Elem, _Traits> _Right) const noexcept {
+        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize}.ends_with(_Right);
+    }
+
+    _NODISCARD constexpr bool ends_with(const _Elem _Right) const noexcept {
+        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize}.ends_with(_Right);
+    }
+
+    _NODISCARD constexpr bool ends_with(const _Elem* const _Right) const noexcept /* strengthened */ {
+        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize}.ends_with(_Right);
+    }
+#endif // _HAS_CXX20
+
+#if _HAS_CXX23
+    _NODISCARD constexpr bool contains(const basic_string_view<_Elem, _Traits> _Right) const noexcept {
+        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize}.contains(_Right);
+    }
+
+    _NODISCARD constexpr bool contains(const _Elem _Right) const noexcept {
+        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize}.contains(_Right);
+    }
+
+    _NODISCARD constexpr bool contains(const _Elem* const _Right) const noexcept /* strengthened */ {
+        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize}.contains(_Right);
+    }
+#endif // _HAS_CXX23
+
+    _NODISCARD _CONSTEXPR20 allocator_type get_allocator() const noexcept {
+        return static_cast<allocator_type>(_Getal());
+    }
+
+private:
+    _NODISCARD static _CONSTEXPR20 size_type _Calculate_growth(
+        const size_type _Requested, const size_type _Old, const size_type _Max) noexcept {
+        const size_type _Masked = _Requested | _Alloc_mask;
+        if (_Masked > _Max) { // the mask overflows, settle for max_size()
+            return _Max;
+        }
+
+        if (_Old > _Max - _Old / 2) { // similarly, geometric overflows
+            return _Max;
+        }
+
+        return (_STD max)(_Masked, _Old + _Old / 2);
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type _Calculate_growth(const size_type _Requested) const noexcept {
+        return _Calculate_growth(_Requested, _Mypair._Myval2._Myres, max_size());
+    }
+
+    template <class _Fty, class... _ArgTys>
+    _CONSTEXPR20 basic_string& _Reallocate_for(const size_type _New_size, _Fty _Fn, _ArgTys... _Args) {
+        // reallocate to store exactly _New_size elements, new buffer prepared by
+        // _Fn(_New_ptr, _New_size, _Args...)
+        if (_New_size > max_size()) {
+            _Xlen_string(); // result too long
+        }
+
+        const size_type _Old_capacity = _Mypair._Myval2._Myres;
+        size_type _New_capacity       = _Calculate_growth(_New_size);
+        auto& _Al                     = _Getal();
+        const pointer _New_ptr        = _Allocate_for_capacity(_Al, _New_capacity); // throws
+
+        _Mypair._Myval2._Orphan_all();
+        _ASAN_STRING_REMOVE(*this);
+        _Mypair._Myval2._Mysize = _New_size;
+        _Mypair._Myval2._Myres  = _New_capacity;
+        _Fn(_Unfancy(_New_ptr), _New_size, _Args...);
+        if (_Old_capacity > _Small_string_capacity) {
+            _Deallocate_for_capacity(_Al, _Mypair._Myval2._Bx._Ptr, _Old_capacity);
+            _Mypair._Myval2._Bx._Ptr = _New_ptr;
+        } else {
+            _Construct_in_place(_Mypair._Myval2._Bx._Ptr, _New_ptr);
+        }
+
+        _ASAN_STRING_CREATE(*this);
+        return *this;
+    }
+
+    template <class _Fty, class... _ArgTys>
+    _CONSTEXPR20 basic_string& _Reallocate_grow_by(const size_type _Size_increase, _Fty _Fn, _ArgTys... _Args) {
+        // reallocate to increase size by _Size_increase elements, new buffer prepared by
+        // _Fn(_New_ptr, _Old_ptr, _Old_size, _Args...)
+        auto& _My_data            = _Mypair._Myval2;
+        const size_type _Old_size = _My_data._Mysize;
+        if (max_size() - _Old_size < _Size_increase) {
+            _Xlen_string(); // result too long
+        }
+
+        const size_type _New_size     = _Old_size + _Size_increase;
+        const size_type _Old_capacity = _My_data._Myres;
+        size_type _New_capacity       = _Calculate_growth(_New_size);
+        auto& _Al                     = _Getal();
+        const pointer _New_ptr        = _Allocate_for_capacity(_Al, _New_capacity); // throws
+
+        _My_data._Orphan_all();
+        _ASAN_STRING_REMOVE(*this);
+        _My_data._Mysize      = _New_size;
+        _My_data._Myres       = _New_capacity;
+        _Elem* const _Raw_new = _Unfancy(_New_ptr);
+        if (_Old_capacity > _Small_string_capacity) {
+            const pointer _Old_ptr = _My_data._Bx._Ptr;
+            _Fn(_Raw_new, _Unfancy(_Old_ptr), _Old_size, _Args...);
+            _Deallocate_for_capacity(_Al, _Old_ptr, _Old_capacity);
+            _My_data._Bx._Ptr = _New_ptr;
+        } else {
+            _Fn(_Raw_new, _My_data._Bx._Buf, _Old_size, _Args...);
+            _Construct_in_place(_My_data._Bx._Ptr, _New_ptr);
+        }
+
+        _ASAN_STRING_CREATE(*this);
+        return *this;
+    }
+
+    _CONSTEXPR20 void _Become_small() noexcept {
+        // release any held storage and return to small string mode
+        auto& _My_data = _Mypair._Myval2;
+        _STL_INTERNAL_CHECK(_My_data._Large_mode_engaged());
+        _STL_INTERNAL_CHECK(_My_data._Mysize <= _Small_string_capacity);
+
+        _My_data._Orphan_all();
+        _ASAN_STRING_REMOVE(*this);
+        const pointer _Ptr = _My_data._Bx._Ptr;
+        _My_data._Bx._Switch_to_buf();
+        _Traits::copy(_My_data._Bx._Buf, _Unfancy(_Ptr), _My_data._Mysize + 1);
+        auto& _Al = _Getal();
+        _Deallocate_for_capacity(_Al, _Ptr, _My_data._Myres);
+        _My_data._Myres = _Small_string_capacity;
+    }
+
+    _CONSTEXPR20 void _Eos(const size_type _New_size) noexcept { // set new length and null terminator
+        _ASAN_STRING_MODIFY(*this, _Mypair._Myval2._Mysize, _New_size);
+        _Mypair._Myval2._Mysize = _New_size;
+        _Traits::assign(_Mypair._Myval2._Myptr()[_New_size], _Elem());
+    }
+
+    _CONSTEXPR20 void _Tidy_deallocate() noexcept { // initialize buffer, deallocating any storage
+        auto& _My_data = _Mypair._Myval2;
+        _My_data._Orphan_all();
+        if (_My_data._Large_mode_engaged()) {
+            _ASAN_STRING_REMOVE(*this);
+            auto& _Al = _Getal();
+            _Deallocate_for_capacity(_Al, _My_data._Bx._Ptr, _My_data._Myres);
+            _My_data._Bx._Switch_to_buf();
+        }
+
+        _My_data._Mysize = 0;
+        _My_data._Myres  = _Small_string_capacity;
+        // the _Traits::assign is last so the codegen doesn't think the char write can alias this
+        _Traits::assign(_My_data._Bx._Buf[0], _Elem());
+    }
+
+public:
+    _CONSTEXPR20 void _Orphan_all() noexcept { // used by filesystem::path
+        _Mypair._Myval2._Orphan_all();
+    }
+
+private:
+    _CONSTEXPR20 void _Swap_proxy_and_iterators(basic_string& _Right) noexcept {
+        _Mypair._Myval2._Swap_proxy_and_iterators(_Right._Mypair._Myval2);
+    }
+
+    _CONSTEXPR20 _Alty& _Getal() noexcept {
+        return _Mypair._Get_first();
+    }
+
+    _CONSTEXPR20 const _Alty& _Getal() const noexcept {
+        return _Mypair._Get_first();
+    }
+
+    _Compressed_pair<_Alty, _Scary_val> _Mypair;
+};
+
+#if _HAS_CXX17
+template <class _Iter, class _Alloc = allocator<_Iter_value_t<_Iter>>,
+    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
+basic_string(_Iter, _Iter, _Alloc = _Alloc())
+    -> basic_string<_Iter_value_t<_Iter>, char_traits<_Iter_value_t<_Iter>>, _Alloc>;
+
+template <class _Elem, class _Traits, class _Alloc = allocator<_Elem>,
+    enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+explicit basic_string(basic_string_view<_Elem, _Traits>, const _Alloc& = _Alloc())
+    -> basic_string<_Elem, _Traits, _Alloc>;
+
+template <class _Elem, class _Traits, class _Alloc = allocator<_Elem>,
+    enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+basic_string(basic_string_view<_Elem, _Traits>, _Guide_size_type_t<_Alloc>, _Guide_size_type_t<_Alloc>,
+    const _Alloc& = _Alloc()) -> basic_string<_Elem, _Traits, _Alloc>;
+
+#if _HAS_CXX23
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc = allocator<_RANGES range_value_t<_Rng>>>
+basic_string(from_range_t, _Rng&&, _Alloc = _Alloc())
+    -> basic_string<_RANGES range_value_t<_Rng>, char_traits<_RANGES range_value_t<_Rng>>, _Alloc>;
+#endif // _HAS_CXX23
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_CONSTEXPR20 void swap(basic_string<_Elem, _Traits, _Alloc>& _Left,
+    basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept /* strengthened */ {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) {
+    const auto _Left_size  = _Left.size();
+    const auto _Right_size = _Right.size();
+    if (_Left.max_size() - _Left_size < _Right_size) {
+        _Xlen_string();
+    }
+
+    return {_String_constructor_concat_tag{}, _Left, _Left.c_str(), _Left_size, _Right.c_str(), _Right_size};
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
+    _In_z_ const _Elem* const _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) {
+    using _Size_type       = typename basic_string<_Elem, _Traits, _Alloc>::size_type;
+    const auto _Left_size  = _Convert_size<_Size_type>(_Traits::length(_Left));
+    const auto _Right_size = _Right.size();
+    if (_Right.max_size() - _Right_size < _Left_size) {
+        _Xlen_string();
+    }
+
+    return {_String_constructor_concat_tag{}, _Right, _Left, _Left_size, _Right.c_str(), _Right_size};
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
+    const _Elem _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) {
+    const auto _Right_size = _Right.size();
+    if (_Right_size == _Right.max_size()) {
+        _Xlen_string();
+    }
+
+    return {_String_constructor_concat_tag{}, _Right, _STD addressof(_Left), 1, _Right.c_str(), _Right_size};
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, _In_z_ const _Elem* const _Right) {
+    using _Size_type       = typename basic_string<_Elem, _Traits, _Alloc>::size_type;
+    const auto _Left_size  = _Left.size();
+    const auto _Right_size = _Convert_size<_Size_type>(_Traits::length(_Right));
+    if (_Left.max_size() - _Left_size < _Right_size) {
+        _Xlen_string();
+    }
+
+    return {_String_constructor_concat_tag{}, _Left, _Left.c_str(), _Left_size, _Right, _Right_size};
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, const _Elem _Right) {
+    const auto _Left_size = _Left.size();
+    if (_Left_size == _Left.max_size()) {
+        _Xlen_string();
+    }
+
+    return {_String_constructor_concat_tag{}, _Left, _Left.c_str(), _Left_size, _STD addressof(_Right), 1};
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, basic_string<_Elem, _Traits, _Alloc>&& _Right) {
+    return _STD move(_Right.insert(0, _Left));
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
+    basic_string<_Elem, _Traits, _Alloc>&& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) {
+    return _STD move(_Left.append(_Right));
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
+    basic_string<_Elem, _Traits, _Alloc>&& _Left, basic_string<_Elem, _Traits, _Alloc>&& _Right) {
+#if _ITERATOR_DEBUG_LEVEL == 2
+    _STL_VERIFY(_STD addressof(_Left) != _STD addressof(_Right),
+        "You cannot concatenate the same moved string to itself. See N4950 [res.on.arguments]/1.3: "
+        "If a function argument is bound to an rvalue reference parameter, the implementation may assume that "
+        "this parameter is a unique reference to this argument, except that the argument passed to "
+        "a move-assignment operator may be a reference to *this ([lib.types.movedfrom]).");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+    return {_String_constructor_concat_tag{}, _Left, _Right};
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
+    _In_z_ const _Elem* const _Left, basic_string<_Elem, _Traits, _Alloc>&& _Right) {
+    return _STD move(_Right.insert(0, _Left));
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
+    const _Elem _Left, basic_string<_Elem, _Traits, _Alloc>&& _Right) {
+    return _STD move(_Right.insert(0, 1, _Left));
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
+    basic_string<_Elem, _Traits, _Alloc>&& _Left, _In_z_ const _Elem* const _Right) {
+    return _STD move(_Left.append(_Right));
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
+    basic_string<_Elem, _Traits, _Alloc>&& _Left, const _Elem _Right) {
+    _Left.push_back(_Right);
+    return _STD move(_Left);
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 bool operator==(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept {
+    return _Left._Equal(_Right);
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 bool operator==(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, _In_z_ const _Elem* const _Right) noexcept /* strengthened */ {
+    return _Left._Equal(_Right);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD constexpr _Get_comparison_category_t<_Traits> operator<=>(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept {
+    return static_cast<_Get_comparison_category_t<_Traits>>(_Left.compare(_Right) <=> 0);
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD constexpr _Get_comparison_category_t<_Traits> operator<=>(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, _In_z_ const _Elem* const _Right) noexcept /* strengthened */ {
+    return static_cast<_Get_comparison_category_t<_Traits>>(_Left.compare(_Right) <=> 0);
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator==(_In_z_ const _Elem* const _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept
+/* strengthened */ {
+    return _Right._Equal(_Left);
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator!=(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept {
+    return !(_Left == _Right);
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator!=(_In_z_ const _Elem* const _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept
+/* strengthened */ {
+    return !(_Left == _Right);
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator!=(const basic_string<_Elem, _Traits, _Alloc>& _Left, _In_z_ const _Elem* const _Right) noexcept
+/* strengthened */ {
+    return !(_Left == _Right);
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator<(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept {
+    return _Left.compare(_Right) < 0;
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator<(_In_z_ const _Elem* const _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept
+/* strengthened */ {
+    return _Right.compare(_Left) > 0;
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator<(const basic_string<_Elem, _Traits, _Alloc>& _Left, _In_z_ const _Elem* const _Right) noexcept
+/* strengthened */ {
+    return _Left.compare(_Right) < 0;
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator>(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept {
+    return _Right < _Left;
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator>(_In_z_ const _Elem* const _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept
+/* strengthened */ {
+    return _Right < _Left;
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator>(const basic_string<_Elem, _Traits, _Alloc>& _Left, _In_z_ const _Elem* const _Right) noexcept
+/* strengthened */ {
+    return _Right < _Left;
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator<=(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept {
+    return !(_Right < _Left);
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator<=(_In_z_ const _Elem* const _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept
+/* strengthened */ {
+    return !(_Right < _Left);
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator<=(const basic_string<_Elem, _Traits, _Alloc>& _Left, _In_z_ const _Elem* const _Right) noexcept
+/* strengthened */ {
+    return !(_Right < _Left);
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator>=(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept {
+    return !(_Left < _Right);
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator>=(_In_z_ const _Elem* const _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept
+/* strengthened */ {
+    return !(_Left < _Right);
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator>=(const basic_string<_Elem, _Traits, _Alloc>& _Left, _In_z_ const _Elem* const _Right) noexcept
+/* strengthened */ {
+    return !(_Left < _Right);
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+_EXPORT_STD using string  = basic_string<char, char_traits<char>, allocator<char>>;
+_EXPORT_STD using wstring = basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t>>;
+#ifdef __cpp_lib_char8_t
+_EXPORT_STD using u8string = basic_string<char8_t, char_traits<char8_t>, allocator<char8_t>>;
+#endif // defined(__cpp_lib_char8_t)
+_EXPORT_STD using u16string = basic_string<char16_t, char_traits<char16_t>, allocator<char16_t>>;
+_EXPORT_STD using u32string = basic_string<char32_t, char_traits<char32_t>, allocator<char32_t>>;
+
+template <class _Elem, class _Alloc>
+struct hash<basic_string<_Elem, char_traits<_Elem>, _Alloc>>
+    : _Conditionally_enabled_hash<basic_string<_Elem, char_traits<_Elem>, _Alloc>, _Is_EcharT<_Elem>> {
+    _NODISCARD static size_t _Do_hash(const basic_string<_Elem, char_traits<_Elem>, _Alloc>& _Keyval) noexcept {
+        return _Hash_array_representation(_Keyval.c_str(), _Keyval.size());
+    }
+};
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+basic_istream<_Elem, _Traits>& operator>>(
+    basic_istream<_Elem, _Traits>& _Istr, basic_string<_Elem, _Traits, _Alloc>& _Str) {
+    using _Myis   = basic_istream<_Elem, _Traits>;
+    using _Ctype  = typename _Myis::_Ctype;
+    using _Mystr  = basic_string<_Elem, _Traits, _Alloc>;
+    using _Mysizt = typename _Mystr::size_type;
+
+    typename _Myis::iostate _State = _Myis::goodbit;
+    bool _Changed                  = false;
+    const typename _Myis::sentry _Ok(_Istr);
+
+    if (_Ok) { // state okay, extract characters
+        const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Istr.getloc());
+        _Str.erase();
+
+        _TRY_IO_BEGIN
+        _Mysizt _Size;
+        if (0 < _Istr.width() && static_cast<_Mysizt>(_Istr.width()) < _Str.max_size()) {
+            _Size = static_cast<_Mysizt>(_Istr.width());
+        } else {
+            _Size = _Str.max_size();
+        }
+
+        typename _Traits::int_type _Meta = _Istr.rdbuf()->sgetc();
+
+        for (; 0 < _Size; --_Size, _Meta = _Istr.rdbuf()->snextc()) {
+            if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { // end of file, quit
+                _State |= _Myis::eofbit;
+                break;
+            } else if (_Ctype_fac.is(_Ctype::space, _Traits::to_char_type(_Meta))) {
+                break; // whitespace, quit
+            } else { // add character to string
+                _Str.push_back(_Traits::to_char_type(_Meta));
+                _Changed = true;
+            }
+        }
+        _CATCH_IO_(_Myis, _Istr)
+    }
+
+    _Istr.width(0);
+    if (!_Changed) {
+        _State |= _Myis::failbit;
+    }
+
+    _Istr.setstate(_State);
+    return _Istr;
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+basic_ostream<_Elem, _Traits>& operator<<(
+    basic_ostream<_Elem, _Traits>& _Ostr, const basic_string<_Elem, _Traits, _Alloc>& _Str) {
+    return _Insert_string(_Ostr, _Str.data(), _Str.size());
+}
+
+inline namespace literals {
+    inline namespace string_literals {
+        _EXPORT_STD _NODISCARD _CONSTEXPR20 string operator""s(const char* _Str, size_t _Len) {
+            return string{_Str, _Len};
+        }
+
+        _EXPORT_STD _NODISCARD _CONSTEXPR20 wstring operator""s(const wchar_t* _Str, size_t _Len) {
+            return wstring{_Str, _Len};
+        }
+
+#ifdef __cpp_char8_t
+        _EXPORT_STD _NODISCARD _CONSTEXPR20 basic_string<char8_t> operator""s(const char8_t* _Str, size_t _Len) {
+            return basic_string<char8_t>{_Str, _Len};
+        }
+#endif // defined(__cpp_char8_t)
+
+        _EXPORT_STD _NODISCARD _CONSTEXPR20 u16string operator""s(const char16_t* _Str, size_t _Len) {
+            return u16string{_Str, _Len};
+        }
+
+        _EXPORT_STD _NODISCARD _CONSTEXPR20 u32string operator""s(const char32_t* _Str, size_t _Len) {
+            return u32string{_Str, _Len};
+        }
+    } // namespace string_literals
+} // namespace literals
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc, class _Uty>
+constexpr basic_string<_Elem, _Traits, _Alloc>::size_type erase(
+    basic_string<_Elem, _Traits, _Alloc>& _Cont, const _Uty& _Val) {
+    return _STD _Erase_remove(_Cont, _Val);
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc, class _Pr>
+constexpr basic_string<_Elem, _Traits, _Alloc>::size_type erase_if(
+    basic_string<_Elem, _Traits, _Alloc>& _Cont, _Pr _Pred) {
+    return _STD _Erase_remove_if(_Cont, _STD _Pass_fn(_Pred));
+}
+#endif // _HAS_CXX20
+
+#if _HAS_CXX17
+namespace pmr {
+    _EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>>
+    using basic_string = _STD basic_string<_Elem, _Traits, polymorphic_allocator<_Elem>>;
+
+    _EXPORT_STD using string = basic_string<char>;
+#ifdef __cpp_lib_char8_t
+    _EXPORT_STD using u8string = basic_string<char8_t>;
+#endif // defined(__cpp_lib_char8_t)
+    _EXPORT_STD using u16string = basic_string<char16_t>;
+    _EXPORT_STD using u32string = basic_string<char32_t>;
+    _EXPORT_STD using wstring   = basic_string<wchar_t>;
+} // namespace pmr
+#endif // _HAS_CXX17
+_STD_END
+
+#undef _ASAN_STRING_REMOVE
+#undef _ASAN_STRING_CREATE
+#undef _ASAN_STRING_MODIFY
+#undef _INSERT_STRING_ANNOTATION
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XSTRING_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xthreads.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xthreads.h
new file mode 100644
index 0000000000000000000000000000000000000000..de50b11a5e57b55b55ce48b87cab07c756b25536
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xthreads.h
@@ -0,0 +1,103 @@
+// xthreads.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _THR_XTHREADS_H
+#define _THR_XTHREADS_H
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <__msvc_threads_core.hpp>
+#include <climits>
+#include <xtimec.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" {
+// threads
+_CRTIMP2_PURE _Thrd_result __cdecl _Thrd_detach(_Thrd_t) noexcept;
+_CRTIMP2_PURE _Thrd_result __cdecl _Thrd_join(_Thrd_t, int*) noexcept;
+_CRTIMP2_PURE void __cdecl _Thrd_yield() noexcept;
+_CRTIMP2_PURE unsigned int __cdecl _Thrd_hardware_concurrency() noexcept;
+_CRTIMP2_PURE _Thrd_id_t __cdecl _Thrd_id() noexcept;
+void __stdcall _Thrd_sleep_for(unsigned long /*ms*/) noexcept;
+
+// mutexes
+enum { // mutex types
+    _Mtx_plain     = 0x01,
+    _Mtx_try       = 0x02,
+    _Mtx_timed     = 0x04,
+    _Mtx_recursive = 0x100
+};
+
+#if defined(_CRTBLD) || defined(_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR)
+_CRTIMP2_PURE void __cdecl _Mtx_init_in_situ(_Mtx_t, int) noexcept;
+#endif // ^^^ defined(_CRTBLD) || defined(_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR) ^^^
+_CRTIMP2_PURE int __cdecl _Mtx_current_owns(_Mtx_t) noexcept;
+_CRTIMP2_PURE _Thrd_result __cdecl _Mtx_lock(_Mtx_t) noexcept;
+_CRTIMP2_PURE _Thrd_result __cdecl _Mtx_trylock(_Mtx_t) noexcept;
+_CRTIMP2_PURE _Thrd_result __cdecl _Mtx_unlock(_Mtx_t) noexcept; // TRANSITION, ABI: Always succeeds
+
+// shared mutex
+// these declarations must be in sync with those in sharedmutex.cpp
+void __cdecl _Smtx_lock_exclusive(_Smtx_t*) noexcept;
+void __cdecl _Smtx_lock_shared(_Smtx_t*) noexcept;
+int __cdecl _Smtx_try_lock_exclusive(_Smtx_t*) noexcept;
+int __cdecl _Smtx_try_lock_shared(_Smtx_t*) noexcept;
+void __cdecl _Smtx_unlock_exclusive(_Smtx_t*) noexcept;
+void __cdecl _Smtx_unlock_shared(_Smtx_t*) noexcept;
+
+// condition variables
+#ifdef _DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR
+_CRTIMP2_PURE void __cdecl _Cnd_init_in_situ(_Cnd_t) noexcept;
+#endif // ^^^ defined(_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR) ^^^
+_CRTIMP2_PURE _Thrd_result __cdecl _Cnd_wait(_Cnd_t, _Mtx_t) noexcept; // TRANSITION, ABI: Always succeeds
+_CRTIMP2_PURE _Thrd_result __cdecl _Cnd_broadcast(_Cnd_t) noexcept; // TRANSITION, ABI: Always succeeds
+_CRTIMP2_PURE _Thrd_result __cdecl _Cnd_signal(_Cnd_t) noexcept; // TRANSITION, ABI: Always succeeds
+_CRTIMP2_PURE void __cdecl _Cnd_register_at_thread_exit(_Cnd_t, _Mtx_t, int*) noexcept;
+_CRTIMP2_PURE void __cdecl _Cnd_unregister_at_thread_exit(_Mtx_t) noexcept;
+_CRTIMP2_PURE void __cdecl _Cnd_do_broadcast_at_thread_exit() noexcept;
+// '_unchecked' means it is not checked against the 'steady_clock', so may report timeout prematurely
+_Thrd_result __stdcall _Cnd_timedwait_for_unchecked(_Cnd_t, _Mtx_t, unsigned int) noexcept;
+} // extern "C"
+
+_STD_BEGIN
+enum { // constants for error codes
+    _DEVICE_OR_RESOURCE_BUSY,
+    _INVALID_ARGUMENT,
+    _NO_SUCH_PROCESS,
+    _NOT_ENOUGH_MEMORY,
+    _OPERATION_NOT_PERMITTED,
+    _RESOURCE_DEADLOCK_WOULD_OCCUR,
+    _RESOURCE_UNAVAILABLE_TRY_AGAIN
+};
+
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __cdecl _Throw_Cpp_error(int _Code);
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _THR_XTHREADS_H
+
+/*
+ * This file is derived from software bearing the following
+ * restrictions:
+ *
+ * (c) Copyright William E. Kempf 2001
+ *
+ * Permission to use, copy, modify, distribute and sell this
+ * software and its documentation for any purpose is hereby
+ * granted without fee, provided that the above copyright
+ * notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting
+ * documentation. William E. Kempf makes no representations
+ * about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ */
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xtimec.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xtimec.h
new file mode 100644
index 0000000000000000000000000000000000000000..7e615faa8d6599eaebf99b0a80d180558c27559c
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xtimec.h
@@ -0,0 +1,59 @@
+// xtimec.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _THR_XTIMEC_H
+#define _THR_XTIMEC_H
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <ctime>
+
+#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" {
+
+#ifdef _CRTBLD
+_CRTIMP2_PURE long __cdecl _Xtime_diff_to_millis2(const _timespec64*, const _timespec64*) noexcept;
+#endif // _CRTBLD
+
+_CRTIMP2_PURE long long __cdecl _Xtime_get_ticks() noexcept;
+
+#ifdef _CRTBLD
+// Used by several src files, but not dllexported.
+void _Timespec64_get_sys(_timespec64*) noexcept;
+#endif // defined(_CRTBLD)
+
+_CRTIMP2_PURE long long __cdecl _Query_perf_counter() noexcept;
+_CRTIMP2_PURE long long __cdecl _Query_perf_frequency() noexcept;
+
+} // extern "C"
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _THR_XTIMEC_H
+
+/*
+ * This file is derived from software bearing the following
+ * restrictions:
+ *
+ * (c) Copyright William E. Kempf 2001
+ *
+ * Permission to use, copy, modify, distribute and sell this
+ * software and its documentation for any purpose is hereby
+ * granted without fee, provided that the above copyright
+ * notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting
+ * documentation. William E. Kempf makes no representations
+ * about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ */
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xtr1common b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xtr1common
new file mode 100644
index 0000000000000000000000000000000000000000..b1829b8b323e58d3eb583bf489b92e8d2234867a
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xtr1common
@@ -0,0 +1,258 @@
+// xtr1common internal header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XTR1COMMON_
+#define _XTR1COMMON_
+#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
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("known_semantics")
+#undef msvc
+#undef known_semantics
+
+_STD_BEGIN
+_EXPORT_STD template <class _Ty, _Ty _Val>
+struct integral_constant {
+    static constexpr _Ty value = _Val;
+
+    using value_type = _Ty;
+    using type       = integral_constant;
+
+    constexpr operator value_type() const noexcept {
+        return value;
+    }
+
+    _NODISCARD constexpr value_type operator()() const noexcept {
+        return value;
+    }
+};
+
+_EXPORT_STD template <bool _Val>
+using bool_constant = integral_constant<bool, _Val>;
+
+_EXPORT_STD using true_type  = bool_constant<true>;
+_EXPORT_STD using false_type = bool_constant<false>;
+
+_EXPORT_STD template <bool _Test, class _Ty = void>
+struct enable_if {}; // no member "type" when !_Test
+
+template <class _Ty>
+struct enable_if<true, _Ty> { // type is _Ty for _Test
+    using type = _Ty;
+};
+
+_EXPORT_STD template <bool _Test, class _Ty = void>
+using enable_if_t = typename enable_if<_Test, _Ty>::type;
+
+_EXPORT_STD template <bool _Test, class _Ty1, class _Ty2>
+struct conditional { // Choose _Ty1 if _Test is true, and _Ty2 otherwise
+    using type = _Ty1;
+};
+
+template <class _Ty1, class _Ty2>
+struct conditional<false, _Ty1, _Ty2> {
+    using type = _Ty2;
+};
+
+_EXPORT_STD template <bool _Test, class _Ty1, class _Ty2>
+using conditional_t = typename conditional<_Test, _Ty1, _Ty2>::type;
+
+#ifdef __clang__
+_EXPORT_STD template <class _Ty1, class _Ty2>
+constexpr bool is_same_v = __is_same(_Ty1, _Ty2);
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+struct is_same : bool_constant<__is_same(_Ty1, _Ty2)> {};
+#else // ^^^ Clang / not Clang vvv
+_EXPORT_STD template <class, class>
+constexpr bool is_same_v = false; // determine whether arguments are the same type
+template <class _Ty>
+constexpr bool is_same_v<_Ty, _Ty> = true;
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+struct is_same : bool_constant<is_same_v<_Ty1, _Ty2>> {};
+#endif // ^^^ not Clang ^^^
+
+_EXPORT_STD template <class _Ty>
+struct remove_const { // remove top-level const qualifier
+    using type = _Ty;
+};
+
+template <class _Ty>
+struct remove_const<const _Ty> {
+    using type = _Ty;
+};
+
+_EXPORT_STD template <class _Ty>
+using remove_const_t = typename remove_const<_Ty>::type;
+
+_EXPORT_STD template <class _Ty>
+struct remove_volatile { // remove top-level volatile qualifier
+    using type = _Ty;
+};
+
+template <class _Ty>
+struct remove_volatile<volatile _Ty> {
+    using type = _Ty;
+};
+
+_EXPORT_STD template <class _Ty>
+using remove_volatile_t = typename remove_volatile<_Ty>::type;
+
+_EXPORT_STD template <class _Ty>
+struct remove_cv { // remove top-level const and volatile qualifiers
+    using type = _Ty;
+
+    template <template <class> class _Fn>
+    using _Apply = _Fn<_Ty>; // apply cv-qualifiers from the class template argument to _Fn<_Ty>
+};
+
+template <class _Ty>
+struct remove_cv<const _Ty> {
+    using type = _Ty;
+
+    template <template <class> class _Fn>
+    using _Apply = const _Fn<_Ty>;
+};
+
+template <class _Ty>
+struct remove_cv<volatile _Ty> {
+    using type = _Ty;
+
+    template <template <class> class _Fn>
+    using _Apply = volatile _Fn<_Ty>;
+};
+
+template <class _Ty>
+struct remove_cv<const volatile _Ty> {
+    using type = _Ty;
+
+    template <template <class> class _Fn>
+    using _Apply = const volatile _Fn<_Ty>;
+};
+
+_EXPORT_STD template <class _Ty>
+using remove_cv_t = typename remove_cv<_Ty>::type;
+
+template <bool _First_value, class _First, class... _Rest>
+struct _Disjunction { // handle true trait or last trait
+    using type = _First;
+};
+
+template <class _False, class _Next, class... _Rest>
+struct _Disjunction<false, _False, _Next, _Rest...> { // first trait is false, try the next trait
+    using type = typename _Disjunction<static_cast<bool>(_Next::value), _Next, _Rest...>::type;
+};
+
+_EXPORT_STD template <class... _Traits>
+struct disjunction : false_type {}; // If _Traits is empty, false_type
+
+template <class _First, class... _Rest>
+struct disjunction<_First, _Rest...> : _Disjunction<static_cast<bool>(_First::value), _First, _Rest...>::type {
+    // the first true trait in _Traits, or the last trait if none are true
+};
+
+_EXPORT_STD template <class... _Traits>
+constexpr bool disjunction_v = disjunction<_Traits...>::value;
+
+template <class _Ty, class... _Types>
+constexpr bool _Is_any_of_v = // true if and only if _Ty is in _Types
+#if _HAS_CXX17
+    (is_same_v<_Ty, _Types> || ...);
+#else // ^^^ _HAS_CXX17 / !_HAS_CXX17 vvv
+    disjunction_v<is_same<_Ty, _Types>...>;
+#endif // ^^^ !_HAS_CXX17 ^^^
+
+_NODISCARD constexpr bool _Is_constant_evaluated() noexcept { // Internal function for any standard mode
+    return __builtin_is_constant_evaluated();
+}
+
+#if _HAS_CXX20
+_EXPORT_STD _NODISCARD constexpr bool is_constant_evaluated() noexcept {
+    return __builtin_is_constant_evaluated();
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_integral_v = _Is_any_of_v<remove_cv_t<_Ty>, bool, char, signed char, unsigned char, wchar_t,
+#ifdef __cpp_char8_t
+    char8_t,
+#endif // defined(__cpp_char8_t)
+    char16_t, char32_t, short, unsigned short, int, unsigned int, long, unsigned long, long long, unsigned long long>;
+
+_EXPORT_STD template <class _Ty>
+struct is_integral : bool_constant<is_integral_v<_Ty>> {};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_floating_point_v = _Is_any_of_v<remove_cv_t<_Ty>, float, double, long double>;
+
+_EXPORT_STD template <class _Ty>
+struct is_floating_point : bool_constant<is_floating_point_v<_Ty>> {};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_arithmetic_v = // determine whether _Ty is an arithmetic type
+    is_integral_v<_Ty> || is_floating_point_v<_Ty>;
+
+_EXPORT_STD template <class _Ty>
+struct is_arithmetic : bool_constant<is_arithmetic_v<_Ty>> {};
+
+_EXPORT_STD template <class _Ty>
+struct remove_reference {
+    using type                 = _Ty;
+    using _Const_thru_ref_type = const _Ty;
+};
+
+template <class _Ty>
+struct remove_reference<_Ty&> {
+    using type                 = _Ty;
+    using _Const_thru_ref_type = const _Ty&;
+};
+
+template <class _Ty>
+struct remove_reference<_Ty&&> {
+    using type                 = _Ty;
+    using _Const_thru_ref_type = const _Ty&&;
+};
+
+_EXPORT_STD template <class _Ty>
+using remove_reference_t = typename remove_reference<_Ty>::type;
+
+template <class _Ty>
+using _Const_thru_ref = typename remove_reference<_Ty>::_Const_thru_ref_type;
+
+template <class _Ty>
+using _Remove_cvref_t _MSVC_KNOWN_SEMANTICS = remove_cv_t<remove_reference_t<_Ty>>;
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty>
+using remove_cvref_t = _Remove_cvref_t<_Ty>;
+
+_EXPORT_STD template <class _Ty>
+struct remove_cvref {
+    using type = remove_cvref_t<_Ty>;
+};
+#endif // _HAS_CXX20
+
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("known_semantics")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XTR1COMMON_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xtree b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xtree
new file mode 100644
index 0000000000000000000000000000000000000000..42c10a953416fc3ed8dca9863cd797738392c874
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xtree
@@ -0,0 +1,1990 @@
+// xtree internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XTREE_
+#define _XTREE_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <xmemory>
+
+#if _HAS_CXX17
+#include <xnode_handle.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 _Mytree, class _Base = _Iterator_base0>
+class _Tree_unchecked_const_iterator : public _Base {
+public:
+    using iterator_category = bidirectional_iterator_tag;
+
+    using _Nodeptr        = typename _Mytree::_Nodeptr;
+    using value_type      = typename _Mytree::value_type;
+    using difference_type = typename _Mytree::difference_type;
+    using pointer         = typename _Mytree::const_pointer;
+    using reference       = const value_type&;
+
+    _Tree_unchecked_const_iterator() noexcept : _Ptr() {}
+
+    _Tree_unchecked_const_iterator(_Nodeptr _Pnode, const _Mytree* _Plist) noexcept : _Ptr(_Pnode) {
+        this->_Adopt(_Plist);
+    }
+
+    _NODISCARD reference operator*() const noexcept {
+        return _Ptr->_Myval;
+    }
+
+    _NODISCARD pointer operator->() const noexcept {
+        return pointer_traits<pointer>::pointer_to(**this);
+    }
+
+    _Tree_unchecked_const_iterator& operator++() noexcept {
+        if (_Ptr->_Right->_Isnil) { // climb looking for right subtree
+            _Nodeptr _Pnode;
+            while (!(_Pnode = _Ptr->_Parent)->_Isnil && _Ptr == _Pnode->_Right) {
+                _Ptr = _Pnode; // ==> parent while right subtree
+            }
+
+            _Ptr = _Pnode; // ==> parent (head if end())
+        } else {
+            _Ptr = _Mytree::_Min(_Ptr->_Right); // ==> smallest of right subtree
+        }
+
+        return *this;
+    }
+
+    _Tree_unchecked_const_iterator operator++(int) noexcept {
+        _Tree_unchecked_const_iterator _Tmp = *this;
+        ++*this;
+        return _Tmp;
+    }
+
+    _Tree_unchecked_const_iterator& operator--() noexcept {
+        if (_Ptr->_Isnil) {
+            _Ptr = _Ptr->_Right; // end() ==> rightmost
+        } else if (_Ptr->_Left->_Isnil) { // climb looking for left subtree
+            _Nodeptr _Pnode;
+            while (!(_Pnode = _Ptr->_Parent)->_Isnil && _Ptr == _Pnode->_Left) {
+                _Ptr = _Pnode; // ==> parent while left subtree
+            }
+
+            if (!_Ptr->_Isnil) { // decrement non-begin()
+                _Ptr = _Pnode; // ==> parent if not head
+            }
+        } else {
+            _Ptr = _Mytree::_Max(_Ptr->_Left); // ==> largest of left subtree
+        }
+
+        return *this;
+    }
+
+    _Tree_unchecked_const_iterator operator--(int) noexcept {
+        _Tree_unchecked_const_iterator _Tmp = *this;
+        --*this;
+        return _Tmp;
+    }
+
+    _NODISCARD bool operator==(const _Tree_unchecked_const_iterator& _Right) const noexcept {
+        return _Ptr == _Right._Ptr;
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD bool operator!=(const _Tree_unchecked_const_iterator& _Right) const noexcept {
+        return !(*this == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    _NODISCARD bool operator==(_Default_sentinel) const noexcept {
+        return !!_Ptr->_Isnil; // TRANSITION, avoid warning C4800:
+                               // "Implicit conversion from 'char' to bool. Possible information loss" (/Wall)
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD bool operator!=(_Default_sentinel) const noexcept {
+        return !_Ptr->_Isnil;
+    }
+#endif // !_HAS_CXX20
+
+    _Nodeptr _Ptr; // pointer to node
+};
+
+template <class _Mytree>
+class _Tree_unchecked_iterator : public _Tree_unchecked_const_iterator<_Mytree> {
+public:
+    using _Mybase           = _Tree_unchecked_const_iterator<_Mytree>;
+    using iterator_category = bidirectional_iterator_tag;
+
+    using _Nodeptr        = typename _Mytree::_Nodeptr;
+    using value_type      = typename _Mytree::value_type;
+    using difference_type = typename _Mytree::difference_type;
+    using pointer         = typename _Mytree::pointer;
+    using reference       = value_type&;
+
+    using _Mybase::_Mybase;
+
+    _NODISCARD reference operator*() const noexcept {
+        return const_cast<reference>(_Mybase::operator*());
+    }
+
+    _NODISCARD pointer operator->() const noexcept {
+        return pointer_traits<pointer>::pointer_to(**this);
+    }
+
+    _Tree_unchecked_iterator& operator++() noexcept {
+        _Mybase::operator++();
+        return *this;
+    }
+
+    _Tree_unchecked_iterator operator++(int) noexcept {
+        _Tree_unchecked_iterator _Tmp = *this;
+        _Mybase::operator++();
+        return _Tmp;
+    }
+
+    _Tree_unchecked_iterator& operator--() noexcept {
+        _Mybase::operator--();
+        return *this;
+    }
+
+    _Tree_unchecked_iterator operator--(int) noexcept {
+        _Tree_unchecked_iterator _Tmp = *this;
+        _Mybase::operator--();
+        return _Tmp;
+    }
+};
+
+template <class _Mytree>
+class _Tree_const_iterator : public _Tree_unchecked_const_iterator<_Mytree, _Iterator_base> {
+public:
+    using _Mybase           = _Tree_unchecked_const_iterator<_Mytree, _Iterator_base>;
+    using iterator_category = bidirectional_iterator_tag;
+
+    using _Nodeptr        = typename _Mytree::_Nodeptr;
+    using value_type      = typename _Mytree::value_type;
+    using difference_type = typename _Mytree::difference_type;
+    using pointer         = typename _Mytree::const_pointer;
+    using reference       = const value_type&;
+
+    using _Mybase::_Mybase;
+
+    _NODISCARD reference operator*() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        const auto _Mycont = static_cast<const _Mytree*>(this->_Getcont());
+        _STL_ASSERT(_Mycont, "cannot dereference value-initialized map/set iterator");
+        _STL_VERIFY(this->_Ptr != _Mycont->_Myhead, "cannot dereference end map/set iterator");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        return this->_Ptr->_Myval;
+    }
+
+    _NODISCARD pointer operator->() const noexcept {
+        return pointer_traits<pointer>::pointer_to(**this);
+    }
+
+    _Tree_const_iterator& operator++() noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(this->_Getcont(), "cannot increment value-initialized map/set iterator");
+        _STL_VERIFY(!this->_Ptr->_Isnil, "cannot increment end map/set iterator");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        _Mybase::operator++();
+        return *this;
+    }
+
+    _Tree_const_iterator operator++(int) noexcept {
+        _Tree_const_iterator _Tmp = *this;
+        ++*this;
+        return _Tmp;
+    }
+
+    _Tree_const_iterator& operator--() noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_ASSERT(this->_Getcont(), "cannot decrement value-initialized map/set iterator");
+        _Nodeptr _Ptrsav = this->_Ptr;
+        _Mybase::operator--();
+        _STL_VERIFY(_Ptrsav != this->_Ptr, "cannot decrement begin map/set iterator");
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 2 / _ITERATOR_DEBUG_LEVEL != 2 vvv
+        _Mybase::operator--();
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 2 ^^^
+
+        return *this;
+    }
+
+    _Tree_const_iterator operator--(int) noexcept {
+        _Tree_const_iterator _Tmp = *this;
+        --*this;
+        return _Tmp;
+    }
+
+    _NODISCARD bool operator==(const _Tree_const_iterator& _Right) const noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(this->_Getcont() == _Right._Getcont(), "map/set iterators incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        return this->_Ptr == _Right._Ptr;
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD bool operator!=(const _Tree_const_iterator& _Right) const noexcept {
+        return !(*this == _Right);
+    }
+#endif // !_HAS_CXX20
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+    friend void _Verify_range(const _Tree_const_iterator& _First, const _Tree_const_iterator& _Last) noexcept {
+        _STL_VERIFY(_First._Getcont() == _Last._Getcont(), "map/set iterators in range are from different containers");
+    }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+    using _Prevent_inheriting_unwrap = _Tree_const_iterator;
+
+    _NODISCARD _Tree_unchecked_const_iterator<_Mytree> _Unwrapped() const noexcept {
+        return _Tree_unchecked_const_iterator<_Mytree>(this->_Ptr, static_cast<const _Mytree*>(this->_Getcont()));
+    }
+
+    void _Seek_to(const _Tree_unchecked_const_iterator<_Mytree> _It) noexcept {
+        this->_Ptr = _It._Ptr;
+    }
+};
+
+template <class _Mytree>
+class _Tree_iterator : public _Tree_const_iterator<_Mytree> {
+public:
+    using _Mybase           = _Tree_const_iterator<_Mytree>;
+    using iterator_category = bidirectional_iterator_tag;
+
+    using _Nodeptr        = typename _Mytree::_Nodeptr;
+    using value_type      = typename _Mytree::value_type;
+    using difference_type = typename _Mytree::difference_type;
+
+    using pointer   = typename _Mytree::pointer;
+    using reference = value_type&;
+
+    using _Mybase::_Mybase;
+
+    _NODISCARD reference operator*() const noexcept {
+        return const_cast<reference>(_Mybase::operator*());
+    }
+
+    _NODISCARD pointer operator->() const noexcept {
+        return pointer_traits<pointer>::pointer_to(**this);
+    }
+
+    _Tree_iterator& operator++() noexcept {
+        _Mybase::operator++();
+        return *this;
+    }
+
+    _Tree_iterator operator++(int) noexcept {
+        _Tree_iterator _Tmp = *this;
+        _Mybase::operator++();
+        return _Tmp;
+    }
+
+    _Tree_iterator& operator--() noexcept {
+        _Mybase::operator--();
+        return *this;
+    }
+
+    _Tree_iterator operator--(int) noexcept {
+        _Tree_iterator _Tmp = *this;
+        _Mybase::operator--();
+        return _Tmp;
+    }
+
+    using _Prevent_inheriting_unwrap = _Tree_iterator;
+
+    _NODISCARD _Tree_unchecked_iterator<_Mytree> _Unwrapped() const noexcept {
+        return _Tree_unchecked_iterator<_Mytree>(this->_Ptr, static_cast<const _Mytree*>(this->_Getcont()));
+    }
+};
+
+template <class _Value_type, class _Size_type, class _Difference_type, class _Pointer, class _Const_pointer,
+    class _Nodeptr_type>
+struct _Tree_iter_types {
+    using value_type      = _Value_type;
+    using size_type       = _Size_type;
+    using difference_type = _Difference_type;
+    using pointer         = _Pointer;
+    using const_pointer   = _Const_pointer;
+    using _Nodeptr        = _Nodeptr_type;
+};
+
+template <class _Value_type, class _Voidptr>
+struct _Tree_node {
+    using _Nodeptr   = _Rebind_pointer_t<_Voidptr, _Tree_node>;
+    using value_type = _Value_type;
+    _Nodeptr _Left; // left subtree, or smallest element if head
+    _Nodeptr _Parent; // parent, or root of tree if head
+    _Nodeptr _Right; // right subtree, or largest element if head
+    char _Color; // _Red or _Black, _Black if head
+    char _Isnil; // true only if head (also nil) node; TRANSITION, should be bool
+    value_type _Myval = // the stored value, unused if head
+        _Returns_exactly<value_type>(); // fake a viable constructor to workaround GH-2749
+
+    enum _Redbl { // colors for link to parent
+        _Red,
+        _Black
+    };
+
+    _Tree_node()                             = default;
+    _Tree_node(const _Tree_node&)            = delete;
+    _Tree_node& operator=(const _Tree_node&) = delete;
+
+    template <class _Alloc>
+    static _Nodeptr _Buyheadnode(_Alloc& _Al) {
+        static_assert(is_same_v<typename _Alloc::value_type, _Tree_node>, "Bad _Buyheadnode call");
+        const auto _Pnode = _Al.allocate(1);
+        _Construct_in_place(_Pnode->_Left, _Pnode);
+        _Construct_in_place(_Pnode->_Parent, _Pnode);
+        _Construct_in_place(_Pnode->_Right, _Pnode);
+        _Pnode->_Color = _Black;
+        _Pnode->_Isnil = true;
+        return _Pnode;
+    }
+
+    template <class _Alloc, class... _Valty>
+    static _Nodeptr _Buynode(_Alloc& _Al, _Nodeptr _Myhead, _Valty&&... _Val) {
+        // allocate a node with defaults and set links and value
+        static_assert(is_same_v<typename _Alloc::value_type, _Tree_node>, "Bad _Buynode call");
+        _Alloc_construct_ptr<_Alloc> _Newnode(_Al);
+        _Newnode._Allocate();
+        allocator_traits<_Alloc>::construct(_Al, _STD addressof(_Newnode._Ptr->_Myval), _STD forward<_Valty>(_Val)...);
+        _Construct_in_place(_Newnode._Ptr->_Left, _Myhead);
+        _Construct_in_place(_Newnode._Ptr->_Parent, _Myhead);
+        _Construct_in_place(_Newnode._Ptr->_Right, _Myhead);
+        _Newnode._Ptr->_Color = _Red;
+        _Newnode._Ptr->_Isnil = false;
+        return _Newnode._Release();
+    }
+
+    template <class _Alloc>
+    static void _Freenode0(_Alloc& _Al, _Nodeptr _Ptr) noexcept {
+        static_assert(is_same_v<typename _Alloc::value_type, _Tree_node>, "Bad _Freenode0 call");
+        _Destroy_in_place(_Ptr->_Left);
+        _Destroy_in_place(_Ptr->_Parent);
+        _Destroy_in_place(_Ptr->_Right);
+        allocator_traits<_Alloc>::deallocate(_Al, _Ptr, 1);
+    }
+
+    template <class _Alloc>
+    static void _Freenode(_Alloc& _Al, _Nodeptr _Ptr) noexcept {
+        static_assert(is_same_v<typename _Alloc::value_type, _Tree_node>, "Bad _Freenode call");
+        allocator_traits<_Alloc>::destroy(_Al, _STD addressof(_Ptr->_Myval));
+        _Freenode0(_Al, _Ptr);
+    }
+};
+
+template <class _Ty>
+struct _Tree_simple_types : _Simple_types<_Ty> {
+    using _Node    = _Tree_node<_Ty, void*>;
+    using _Nodeptr = _Node*;
+};
+
+enum class _Tree_child {
+    _Right, // perf note: compare with _Right rather than _Left where possible for comparison with zero
+    _Left,
+    _Unused // indicates that tree child should never be used for insertion
+};
+
+template <class _Nodeptr>
+struct _Tree_id {
+    _Nodeptr _Parent; // the leaf node under which a new node should be inserted
+    _Tree_child _Child;
+};
+
+template <class _Nodeptr>
+struct _Tree_find_result {
+    _Tree_id<_Nodeptr> _Location;
+    _Nodeptr _Bound;
+};
+
+template <class _Nodeptr>
+struct _Tree_find_hint_result {
+    _Tree_id<_Nodeptr> _Location;
+    bool _Duplicate;
+};
+
+[[noreturn]] inline void _Throw_tree_length_error() {
+    _Xlength_error("map/set too long");
+}
+
+template <class _Val_types>
+class _Tree_val : public _Container_base {
+public:
+    using _Nodeptr = typename _Val_types::_Nodeptr;
+
+    using value_type      = typename _Val_types::value_type;
+    using size_type       = typename _Val_types::size_type;
+    using difference_type = typename _Val_types::difference_type;
+    using pointer         = typename _Val_types::pointer;
+    using const_pointer   = typename _Val_types::const_pointer;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+
+    using _Unchecked_const_iterator = _Tree_unchecked_const_iterator<_Tree_val>;
+    using const_iterator            = _Tree_const_iterator<_Tree_val>;
+
+    template <class _AllocNode>
+    struct _NODISCARD _Erase_tree_and_orphan_guard {
+        _Tree_val* _Val_ptr;
+        _AllocNode& _Al;
+        _Nodeptr _New_root;
+
+        _Erase_tree_and_orphan_guard& operator=(const _Erase_tree_and_orphan_guard&) = delete;
+        ~_Erase_tree_and_orphan_guard() noexcept {
+            if (_Val_ptr != nullptr) {
+                _Val_ptr->_Erase_tree_and_orphan(_Al, _New_root); // subtree copy failed, bail out
+            }
+        }
+    };
+
+    _Tree_val() noexcept : _Myhead(), _Mysize(0) {}
+
+    enum _Redbl { // colors for link to parent
+        _Red,
+        _Black
+    };
+
+    static _Nodeptr _Max(_Nodeptr _Pnode) noexcept { // return rightmost node in subtree at _Pnode
+        while (!_Pnode->_Right->_Isnil) {
+            _Pnode = _Pnode->_Right;
+        }
+
+        return _Pnode;
+    }
+
+    static _Nodeptr _Min(_Nodeptr _Pnode) noexcept { // return leftmost node in subtree at _Pnode
+        while (!_Pnode->_Left->_Isnil) {
+            _Pnode = _Pnode->_Left;
+        }
+
+        return _Pnode;
+    }
+
+    void _Lrotate(_Nodeptr _Wherenode) noexcept { // promote right node to root of subtree
+        _Nodeptr _Pnode    = _Wherenode->_Right;
+        _Wherenode->_Right = _Pnode->_Left;
+
+        if (!_Pnode->_Left->_Isnil) {
+            _Pnode->_Left->_Parent = _Wherenode;
+        }
+
+        _Pnode->_Parent = _Wherenode->_Parent;
+
+        if (_Wherenode == _Myhead->_Parent) {
+            _Myhead->_Parent = _Pnode;
+        } else if (_Wherenode == _Wherenode->_Parent->_Left) {
+            _Wherenode->_Parent->_Left = _Pnode;
+        } else {
+            _Wherenode->_Parent->_Right = _Pnode;
+        }
+
+        _Pnode->_Left       = _Wherenode;
+        _Wherenode->_Parent = _Pnode;
+    }
+
+    void _Rrotate(_Nodeptr _Wherenode) noexcept { // promote left node to root of subtree
+        _Nodeptr _Pnode   = _Wherenode->_Left;
+        _Wherenode->_Left = _Pnode->_Right;
+
+        if (!_Pnode->_Right->_Isnil) {
+            _Pnode->_Right->_Parent = _Wherenode;
+        }
+
+        _Pnode->_Parent = _Wherenode->_Parent;
+
+        if (_Wherenode == _Myhead->_Parent) {
+            _Myhead->_Parent = _Pnode;
+        } else if (_Wherenode == _Wherenode->_Parent->_Right) {
+            _Wherenode->_Parent->_Right = _Pnode;
+        } else {
+            _Wherenode->_Parent->_Left = _Pnode;
+        }
+
+        _Pnode->_Right      = _Wherenode;
+        _Wherenode->_Parent = _Pnode;
+    }
+
+    _Nodeptr _Extract(_Unchecked_const_iterator _Where) noexcept {
+        _Nodeptr _Erasednode = _Where._Ptr; // node to erase
+        ++_Where; // save successor iterator for return
+
+        _Nodeptr _Fixnode; // the node to recolor as needed
+        _Nodeptr _Fixnodeparent; // parent of _Fixnode (which may be nil)
+        _Nodeptr _Pnode = _Erasednode;
+
+        if (_Pnode->_Left->_Isnil) {
+            _Fixnode = _Pnode->_Right; // stitch up right subtree
+        } else if (_Pnode->_Right->_Isnil) {
+            _Fixnode = _Pnode->_Left; // stitch up left subtree
+        } else { // two subtrees, must lift successor node to replace erased
+            _Pnode   = _Where._Ptr; // _Pnode is successor node
+            _Fixnode = _Pnode->_Right; // _Fixnode is only subtree
+        }
+
+        if (_Pnode == _Erasednode) { // at most one subtree, relink it
+            _Fixnodeparent = _Erasednode->_Parent;
+            if (!_Fixnode->_Isnil) {
+                _Fixnode->_Parent = _Fixnodeparent; // link up
+            }
+
+            if (_Myhead->_Parent == _Erasednode) {
+                _Myhead->_Parent = _Fixnode; // link down from root
+            } else if (_Fixnodeparent->_Left == _Erasednode) {
+                _Fixnodeparent->_Left = _Fixnode; // link down to left
+            } else {
+                _Fixnodeparent->_Right = _Fixnode; // link down to right
+            }
+
+            if (_Myhead->_Left == _Erasednode) {
+                _Myhead->_Left = _Fixnode->_Isnil ? _Fixnodeparent // smallest is parent of erased node
+                                                  : _Min(_Fixnode); // smallest in relinked subtree
+            }
+
+            if (_Myhead->_Right == _Erasednode) {
+                _Myhead->_Right = _Fixnode->_Isnil ? _Fixnodeparent // largest is parent of erased node
+                                                   : _Max(_Fixnode); // largest in relinked subtree
+            }
+        } else { // erased has two subtrees, _Pnode is successor to erased
+            _Erasednode->_Left->_Parent = _Pnode; // link left up
+            _Pnode->_Left               = _Erasednode->_Left; // link successor down
+
+            if (_Pnode == _Erasednode->_Right) {
+                _Fixnodeparent = _Pnode; // successor is next to erased
+            } else { // successor further down, link in place of erased
+                _Fixnodeparent = _Pnode->_Parent; // parent is successor's
+                if (!_Fixnode->_Isnil) {
+                    _Fixnode->_Parent = _Fixnodeparent; // link fix up
+                }
+
+                _Fixnodeparent->_Left        = _Fixnode; // link fix down
+                _Pnode->_Right               = _Erasednode->_Right; // link next down
+                _Erasednode->_Right->_Parent = _Pnode; // right up
+            }
+
+            if (_Myhead->_Parent == _Erasednode) {
+                _Myhead->_Parent = _Pnode; // link down from root
+            } else if (_Erasednode->_Parent->_Left == _Erasednode) {
+                _Erasednode->_Parent->_Left = _Pnode; // link down to left
+            } else {
+                _Erasednode->_Parent->_Right = _Pnode; // link down to right
+            }
+
+            _Pnode->_Parent = _Erasednode->_Parent; // link successor up
+            _STD swap(_Pnode->_Color, _Erasednode->_Color); // recolor it
+        }
+
+        if (_Erasednode->_Color == _Black) { // erasing black link, must recolor/rebalance tree
+            for (; _Fixnode != _Myhead->_Parent && _Fixnode->_Color == _Black; _Fixnodeparent = _Fixnode->_Parent) {
+                if (_Fixnode == _Fixnodeparent->_Left) { // fixup left subtree
+                    _Pnode = _Fixnodeparent->_Right;
+                    if (_Pnode->_Color == _Red) { // rotate red up from right subtree
+                        _Pnode->_Color         = _Black;
+                        _Fixnodeparent->_Color = _Red;
+                        _Lrotate(_Fixnodeparent);
+                        _Pnode = _Fixnodeparent->_Right;
+                    }
+
+                    if (_Pnode->_Isnil) {
+                        _Fixnode = _Fixnodeparent; // shouldn't happen
+                    } else if (_Pnode->_Left->_Color == _Black
+                               && _Pnode->_Right->_Color == _Black) { // redden right subtree with black children
+                        _Pnode->_Color = _Red;
+                        _Fixnode       = _Fixnodeparent;
+                    } else { // must rearrange right subtree
+                        if (_Pnode->_Right->_Color == _Black) { // rotate red up from left sub-subtree
+                            _Pnode->_Left->_Color = _Black;
+                            _Pnode->_Color        = _Red;
+                            _Rrotate(_Pnode);
+                            _Pnode = _Fixnodeparent->_Right;
+                        }
+
+                        _Pnode->_Color         = _Fixnodeparent->_Color;
+                        _Fixnodeparent->_Color = _Black;
+                        _Pnode->_Right->_Color = _Black;
+                        _Lrotate(_Fixnodeparent);
+                        break; // tree now recolored/rebalanced
+                    }
+                } else { // fixup right subtree
+                    _Pnode = _Fixnodeparent->_Left;
+                    if (_Pnode->_Color == _Red) { // rotate red up from left subtree
+                        _Pnode->_Color         = _Black;
+                        _Fixnodeparent->_Color = _Red;
+                        _Rrotate(_Fixnodeparent);
+                        _Pnode = _Fixnodeparent->_Left;
+                    }
+
+                    if (_Pnode->_Isnil) {
+                        _Fixnode = _Fixnodeparent; // shouldn't happen
+                    } else if (_Pnode->_Right->_Color == _Black
+                               && _Pnode->_Left->_Color == _Black) { // redden left subtree with black children
+                        _Pnode->_Color = _Red;
+                        _Fixnode       = _Fixnodeparent;
+                    } else { // must rearrange left subtree
+                        if (_Pnode->_Left->_Color == _Black) { // rotate red up from right sub-subtree
+                            _Pnode->_Right->_Color = _Black;
+                            _Pnode->_Color         = _Red;
+                            _Lrotate(_Pnode);
+                            _Pnode = _Fixnodeparent->_Left;
+                        }
+
+                        _Pnode->_Color         = _Fixnodeparent->_Color;
+                        _Fixnodeparent->_Color = _Black;
+                        _Pnode->_Left->_Color  = _Black;
+                        _Rrotate(_Fixnodeparent);
+                        break; // tree now recolored/rebalanced
+                    }
+                }
+            }
+
+            _Fixnode->_Color = _Black; // stopping node is black
+        }
+
+        if (0 < _Mysize) {
+            --_Mysize;
+        }
+
+        return _Erasednode;
+    }
+
+    _Nodeptr _Insert_node(const _Tree_id<_Nodeptr> _Loc, const _Nodeptr _Newnode) noexcept {
+        ++_Mysize;
+        const auto _Head  = _Myhead;
+        _Newnode->_Parent = _Loc._Parent;
+        if (_Loc._Parent == _Head) { // first node in tree, just set head values
+            _Head->_Left     = _Newnode;
+            _Head->_Parent   = _Newnode;
+            _Head->_Right    = _Newnode;
+            _Newnode->_Color = _Black; // the root is black
+            return _Newnode;
+        }
+
+        _STL_INTERNAL_CHECK(_Loc._Child != _Tree_child::_Unused);
+        if (_Loc._Child == _Tree_child::_Right) { // add to right of _Loc._Parent
+            _STL_INTERNAL_CHECK(_Loc._Parent->_Right->_Isnil);
+            _Loc._Parent->_Right = _Newnode;
+            if (_Loc._Parent == _Head->_Right) { // remember rightmost node
+                _Head->_Right = _Newnode;
+            }
+        } else { // add to left of _Loc._Parent
+            _STL_INTERNAL_CHECK(_Loc._Parent->_Left->_Isnil);
+            _Loc._Parent->_Left = _Newnode;
+            if (_Loc._Parent == _Head->_Left) { // remember leftmost node
+                _Head->_Left = _Newnode;
+            }
+        }
+
+        for (_Nodeptr _Pnode = _Newnode; _Pnode->_Parent->_Color == _Red;) {
+            if (_Pnode->_Parent == _Pnode->_Parent->_Parent->_Left) { // fixup red-red in left subtree
+                const auto _Parent_sibling = _Pnode->_Parent->_Parent->_Right;
+                if (_Parent_sibling->_Color == _Red) { // parent's sibling has two red children, blacken both
+                    _Pnode->_Parent->_Color          = _Black;
+                    _Parent_sibling->_Color          = _Black;
+                    _Pnode->_Parent->_Parent->_Color = _Red;
+                    _Pnode                           = _Pnode->_Parent->_Parent;
+                } else { // parent's sibling has red and black children
+                    if (_Pnode == _Pnode->_Parent->_Right) { // rotate right child to left
+                        _Pnode = _Pnode->_Parent;
+                        _Lrotate(_Pnode);
+                    }
+
+                    _Pnode->_Parent->_Color          = _Black; // propagate red up
+                    _Pnode->_Parent->_Parent->_Color = _Red;
+                    _Rrotate(_Pnode->_Parent->_Parent);
+                }
+            } else { // fixup red-red in right subtree
+                const auto _Parent_sibling = _Pnode->_Parent->_Parent->_Left;
+                if (_Parent_sibling->_Color == _Red) { // parent's sibling has two red children, blacken both
+                    _Pnode->_Parent->_Color          = _Black;
+                    _Parent_sibling->_Color          = _Black;
+                    _Pnode->_Parent->_Parent->_Color = _Red;
+                    _Pnode                           = _Pnode->_Parent->_Parent;
+                } else { // parent's sibling has red and black children
+                    if (_Pnode == _Pnode->_Parent->_Left) { // rotate left child to right
+                        _Pnode = _Pnode->_Parent;
+                        _Rrotate(_Pnode);
+                    }
+
+                    _Pnode->_Parent->_Color          = _Black; // propagate red up
+                    _Pnode->_Parent->_Parent->_Color = _Red;
+                    _Lrotate(_Pnode->_Parent->_Parent);
+                }
+            }
+        }
+
+        _Head->_Parent->_Color = _Black; // root is always black
+        return _Newnode;
+    }
+
+    void _Orphan_ptr(const _Nodeptr _Ptr) noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Iterator_base12** _Pnext = &this->_Myproxy->_Myfirstiter;
+        while (*_Pnext) {
+            const auto _Pnextptr = static_cast<const_iterator&>(**_Pnext)._Ptr;
+            if (_Pnextptr == _Myhead || (_Ptr != nullptr && _Pnextptr != _Ptr)) {
+                _Pnext = &(*_Pnext)->_Mynextiter;
+            } else { // orphan the iterator
+                (*_Pnext)->_Myproxy = nullptr;
+                *_Pnext             = (*_Pnext)->_Mynextiter;
+            }
+        }
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 2 / _ITERATOR_DEBUG_LEVEL != 2 vvv
+        (void) _Ptr;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 2 ^^^
+    }
+
+    template <class _Alnode>
+    void _Erase_tree_and_orphan(_Alnode& _Al, _Nodeptr _Rootnode) noexcept {
+        while (!_Rootnode->_Isnil) { // free subtrees, then node
+            _Erase_tree_and_orphan(_Al, _Rootnode->_Right);
+            auto _To_delete = _STD exchange(_Rootnode, _Rootnode->_Left);
+            _Orphan_ptr(_To_delete);
+            _Alnode::value_type::_Freenode(_Al, _To_delete);
+        }
+    }
+
+    template <class _Alnode>
+    void _Erase_tree(_Alnode& _Al, _Nodeptr _Rootnode) noexcept {
+        while (!_Rootnode->_Isnil) { // free subtrees, then node
+            _Erase_tree(_Al, _Rootnode->_Right);
+            _Alnode::value_type::_Freenode(_Al, _STD exchange(_Rootnode, _Rootnode->_Left));
+        }
+    }
+
+    template <class _Alnode>
+    void _Erase_head(_Alnode& _Al) noexcept {
+        this->_Orphan_all();
+        _Erase_tree(_Al, _Myhead->_Parent);
+        _Alnode::value_type::_Freenode0(_Al, _Myhead);
+    }
+
+    _Nodeptr _Myhead; // pointer to head node
+    size_type _Mysize; // number of elements
+};
+
+template <class _Alnode, class _Scary_val>
+struct _Tree_head_scoped_ptr { // temporary storage for allocated node pointers to ensure exception safety
+    _Alnode& _Al;
+    _Scary_val* _Mycont;
+
+    _Tree_head_scoped_ptr(_Alnode& _Al_, _Scary_val& _Mycont_) : _Al(_Al_), _Mycont(_STD addressof(_Mycont_)) {
+        _Mycont->_Myhead = _Alnode::value_type::_Buyheadnode(_Al);
+    }
+
+    void _Release() noexcept {
+        _Mycont = nullptr;
+    }
+
+    ~_Tree_head_scoped_ptr() {
+        if (_Mycont) {
+            _Mycont->_Erase_head(_Al);
+        }
+    }
+};
+
+template <class _Alnode>
+struct _Tree_temp_node_alloc : _Alloc_construct_ptr<_Alnode> {
+    // EH helper for _Tree_temp_node
+    explicit _Tree_temp_node_alloc(_Alnode& _Al_) : _Alloc_construct_ptr<_Alnode>(_Al_) {
+        _Alloc_construct_ptr<_Alnode>::_Allocate();
+    }
+
+    _Tree_temp_node_alloc(const _Tree_temp_node_alloc&)            = delete;
+    _Tree_temp_node_alloc& operator=(const _Tree_temp_node_alloc&) = delete;
+};
+
+template <class _Alnode>
+struct _Tree_temp_node : _Tree_temp_node_alloc<_Alnode> {
+    // temporarily stores a constructed tree node
+    using _Alnode_traits = allocator_traits<_Alnode>;
+    using _Nodeptr       = typename _Alnode_traits::pointer;
+
+    enum _Redbl { // colors for link to parent
+        _Red,
+        _Black
+    };
+
+    template <class... _Valtys>
+    explicit _Tree_temp_node(_Alnode& _Al_, _Nodeptr _Myhead, _Valtys&&... _Vals)
+        : _Tree_temp_node_alloc<_Alnode>(_Al_) {
+        _Alnode_traits::construct(this->_Al, _STD addressof(this->_Ptr->_Myval), _STD forward<_Valtys>(_Vals)...);
+        _Construct_in_place(this->_Ptr->_Left, _Myhead);
+        _Construct_in_place(this->_Ptr->_Parent, _Myhead);
+        _Construct_in_place(this->_Ptr->_Right, _Myhead);
+        this->_Ptr->_Color = _Red;
+        this->_Ptr->_Isnil = false;
+    }
+
+    _Tree_temp_node(const _Tree_temp_node&)            = delete;
+    _Tree_temp_node& operator=(const _Tree_temp_node&) = delete;
+
+    ~_Tree_temp_node() {
+        if (this->_Ptr) {
+            _Destroy_in_place(this->_Ptr->_Left);
+            _Destroy_in_place(this->_Ptr->_Parent);
+            _Destroy_in_place(this->_Ptr->_Right);
+            _Alnode_traits::destroy(this->_Al, _STD addressof(this->_Ptr->_Myval));
+        }
+    }
+};
+
+template <class _Traits>
+class _Tree { // ordered red-black tree for map/multimap/set/multiset
+public:
+    using key_type       = typename _Traits::key_type;
+    using value_type     = typename _Traits::value_type;
+    using allocator_type = typename _Traits::allocator_type;
+
+protected:
+    using _Alty          = _Rebind_alloc_t<allocator_type, value_type>;
+    using _Alty_traits   = allocator_traits<_Alty>;
+    using _Node          = _Tree_node<value_type, typename _Alty_traits::void_pointer>;
+    using _Alnode        = _Rebind_alloc_t<allocator_type, _Node>;
+    using _Alnode_traits = allocator_traits<_Alnode>;
+    using _Nodeptr       = typename _Alnode_traits::pointer;
+
+    using _Scary_val = _Tree_val<conditional_t<_Is_simple_alloc_v<_Alnode>, _Tree_simple_types<value_type>,
+        _Tree_iter_types<value_type, typename _Alty_traits::size_type, typename _Alty_traits::difference_type,
+            typename _Alty_traits::pointer, typename _Alty_traits::const_pointer, _Nodeptr>>>;
+
+    static constexpr bool _Multi  = _Traits::_Multi;
+    static constexpr bool _Is_set = is_same_v<key_type, value_type>;
+
+    enum _Redbl { // colors for link to parent
+        _Red,
+        _Black
+    };
+
+public:
+    using value_compare = typename _Traits::value_compare;
+
+    using key_compare = typename _Traits::key_compare;
+
+    using size_type       = typename _Alty_traits::size_type;
+    using difference_type = typename _Alty_traits::difference_type;
+    using pointer         = typename _Alty_traits::pointer;
+    using const_pointer   = typename _Alty_traits::const_pointer;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+
+    using iterator       = conditional_t<_Is_set, _Tree_const_iterator<_Scary_val>, _Tree_iterator<_Scary_val>>;
+    using const_iterator = _Tree_const_iterator<_Scary_val>;
+    using _Unchecked_iterator =
+        conditional_t<_Is_set, _Tree_unchecked_const_iterator<_Scary_val>, _Tree_unchecked_iterator<_Scary_val>>;
+    using _Unchecked_const_iterator = _Tree_unchecked_const_iterator<_Scary_val>;
+
+    using reverse_iterator       = _STD reverse_iterator<iterator>;
+    using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
+
+    enum class _Strategy : bool {
+        _Copy,
+        _Move,
+    };
+
+    _Tree(const key_compare& _Parg) : _Mypair(_One_then_variadic_args_t{}, _Parg, _Zero_then_variadic_args_t{}) {
+        _Alloc_sentinel_and_proxy();
+    }
+
+    _Tree(const key_compare& _Parg, const allocator_type& _Al)
+        : _Mypair(_One_then_variadic_args_t{}, _Parg, _One_then_variadic_args_t{}, _Al) {
+        _Alloc_sentinel_and_proxy();
+    }
+
+    template <class _Any_alloc>
+    _Tree(const _Tree& _Right, _Any_alloc&& _Al)
+        : _Mypair(_One_then_variadic_args_t{}, _Right.key_comp(), _One_then_variadic_args_t{},
+            _STD forward<_Any_alloc>(_Al)) {
+        auto&& _Alproxy   = _GET_PROXY_ALLOCATOR(_Alnode, _Getal());
+        const auto _Scary = _Get_scary();
+        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, *_Scary);
+        _Tree_head_scoped_ptr<_Alnode, _Scary_val> _Sentinel(_Getal(), *_Scary);
+        _Copy<_Strategy::_Copy>(_Right);
+        _Sentinel._Release();
+        _Proxy._Release();
+    }
+
+    _Tree(_Tree&& _Right)
+        : _Mypair(_One_then_variadic_args_t{}, _Right.key_comp(), // intentionally copy comparator, see LWG-2227
+            _One_then_variadic_args_t{}, _STD move(_Right._Getal())) {
+        _Alloc_sentinel_and_proxy();
+        _Swap_val_excluding_comp(_Right);
+    }
+
+    _Tree(_Tree&& _Right, const allocator_type& _Al)
+        : _Mypair(_One_then_variadic_args_t{}, _Right.key_comp(), // intentionally copy comparator, see LWG-2227
+            _One_then_variadic_args_t{}, _Al) {
+        if constexpr (!_Alnode_traits::is_always_equal::value) {
+            if (_Getal() != _Right._Getal()) {
+                auto&& _Alproxy   = _GET_PROXY_ALLOCATOR(_Alnode, _Getal());
+                const auto _Scary = _Get_scary();
+                _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, *_Scary);
+                _Tree_head_scoped_ptr<_Alnode, _Scary_val> _Sentinel(_Getal(), *_Scary);
+                _Copy<_Strategy::_Move>(_Right);
+                _Sentinel._Release();
+                _Proxy._Release();
+                return;
+            }
+        }
+
+        _Alloc_sentinel_and_proxy();
+        _Swap_val_excluding_comp(_Right);
+    }
+
+    _Tree& operator=(_Tree&& _Right) noexcept(
+        _Choose_pocma_v<_Alnode> == _Pocma_values::_Equal_allocators && is_nothrow_move_assignable_v<key_compare>) {
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+        auto& _Al                 = _Getal();
+        auto& _Right_al           = _Right._Getal();
+        constexpr auto _Pocma_val = _Choose_pocma_v<_Alnode>;
+        if constexpr (_Pocma_val == _Pocma_values::_Propagate_allocators) {
+            if (_Al != _Right_al) {
+                clear();
+                _Getcomp()            = _Right._Getcomp(); // intentionally copy comparator, see LWG-2227
+                auto&& _Alproxy       = _GET_PROXY_ALLOCATOR(_Alnode, _Al);
+                auto&& _Right_alproxy = _GET_PROXY_ALLOCATOR(_Alnode, _Right_al);
+                _Container_proxy_ptr<_Alty> _Proxy(_Right_alproxy, _Leave_proxy_unbound{});
+                const auto _Scary       = _Get_scary();
+                const auto _Right_scary = _Right._Get_scary();
+                const auto _Newhead     = _STD exchange(_Right_scary->_Myhead, _Node::_Buyheadnode(_Right_al));
+                const auto _Newsize     = _STD exchange(_Right_scary->_Mysize, size_type{0});
+                _Scary->_Erase_head(_Al);
+                _Pocma(_Al, _Right_al);
+                _Scary->_Myhead = _Newhead;
+                _Scary->_Mysize = _Newsize;
+                _Proxy._Bind(_Alproxy, _Scary);
+                _Scary->_Swap_proxy_and_iterators(*_Right_scary);
+                return *this;
+            }
+        } else if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
+            if (_Al != _Right_al) {
+                clear();
+                _Getcomp() = _Right._Getcomp(); // intentionally copy comparator, see LWG-2227
+                _Copy<_Strategy::_Move>(_Right);
+                return *this;
+            }
+        }
+
+        clear();
+        _Getcomp() = _Right._Getcomp(); // intentionally copy comparator, see LWG-2227
+        _Pocma(_Al, _Right_al);
+        _Swap_val_excluding_comp(_Right);
+
+        return *this;
+    }
+
+private:
+    void _Swap_val_excluding_comp(_Tree& _Right) { // swap contents (except comparator) with _Right, equal allocators
+        using _STD swap;
+        const auto _Scary       = _Get_scary();
+        const auto _Right_scary = _Right._Get_scary();
+        _Scary->_Swap_proxy_and_iterators(*_Right_scary);
+        swap(_Scary->_Myhead, _Right_scary->_Myhead); // intentional ADL
+        _STD swap(_Scary->_Mysize, _Right_scary->_Mysize);
+    }
+
+protected:
+    template <class... _Valtys>
+    pair<_Nodeptr, bool> _Emplace(_Valtys&&... _Vals) {
+        using _In_place_key_extractor = typename _Traits::template _In_place_key_extractor<_Remove_cvref_t<_Valtys>...>;
+        const auto _Scary             = _Get_scary();
+        _Tree_find_result<_Nodeptr> _Loc;
+        _Nodeptr _Inserted;
+        if constexpr (!_Multi && _In_place_key_extractor::_Extractable) {
+            const auto& _Keyval = _In_place_key_extractor::_Extract(_Vals...);
+            _Loc                = _Find_lower_bound(_Keyval);
+            if (_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
+                return {_Loc._Bound, false};
+            }
+
+            _Check_grow_by_1();
+            _Inserted = _Tree_temp_node<_Alnode>(_Getal(), _Scary->_Myhead, _STD forward<_Valtys>(_Vals)...)._Release();
+            // nothrow hereafter
+        } else {
+            _Tree_temp_node<_Alnode> _Newnode(_Getal(), _Scary->_Myhead, _STD forward<_Valtys>(_Vals)...);
+            const auto& _Keyval = _Traits::_Kfn(_Newnode._Ptr->_Myval);
+            if constexpr (_Multi) { // duplicate check if unique
+                _Loc = _Find_upper_bound(_Keyval);
+            } else {
+                _Loc = _Find_lower_bound(_Keyval);
+                if (_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
+                    return {_Loc._Bound, false};
+                }
+            }
+
+            _Check_grow_by_1();
+            // nothrow hereafter
+            _Inserted = _Newnode._Release();
+        }
+
+        return {_Scary->_Insert_node(_Loc._Location, _Inserted), true};
+    }
+
+public:
+    template <class... _Valtys>
+    pair<iterator, bool> emplace(_Valtys&&... _Vals) {
+        const auto _Result = _Emplace(_STD forward<_Valtys>(_Vals)...);
+        return {iterator(_Result.first, _Get_scary()), _Result.second};
+    }
+
+protected:
+    template <class... _Valtys>
+    _Nodeptr _Emplace_hint(const _Nodeptr _Hint, _Valtys&&... _Vals) {
+        using _In_place_key_extractor = typename _Traits::template _In_place_key_extractor<_Remove_cvref_t<_Valtys>...>;
+        const auto _Scary             = _Get_scary();
+        _Tree_find_hint_result<_Nodeptr> _Loc;
+        _Nodeptr _Inserted;
+        if constexpr (!_Multi && _In_place_key_extractor::_Extractable) {
+            _Loc = _Find_hint(_Hint, _In_place_key_extractor::_Extract(_Vals...));
+            if (_Loc._Duplicate) {
+                return _Loc._Location._Parent;
+            }
+
+            _Check_grow_by_1();
+            _Inserted = _Tree_temp_node<_Alnode>(_Getal(), _Scary->_Myhead, _STD forward<_Valtys>(_Vals)...)._Release();
+            // nothrow hereafter
+        } else {
+            _Tree_temp_node<_Alnode> _Newnode(_Getal(), _Scary->_Myhead, _STD forward<_Valtys>(_Vals)...);
+            _Loc = _Find_hint(_Hint, _Traits::_Kfn(_Newnode._Ptr->_Myval));
+            if constexpr (!_Multi) {
+                if (_Loc._Duplicate) {
+                    return _Loc._Location._Parent;
+                }
+            }
+
+            _Check_grow_by_1();
+            // nothrow hereafter
+            _Inserted = _Newnode._Release();
+        }
+
+        return _Scary->_Insert_node(_Loc._Location, _Inserted);
+    }
+
+public:
+    template <class... _Valtys>
+    iterator emplace_hint(const_iterator _Where, _Valtys&&... _Vals) { // insert value_type(_Val...) at _Where
+        const auto _Scary = _Get_scary();
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Where._Getcont() == _Scary, "map/set insert iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        return iterator(_Emplace_hint(_Where._Ptr, _STD forward<_Valtys>(_Vals)...), _Scary);
+    }
+
+    ~_Tree() noexcept {
+        const auto _Scary = _Get_scary();
+        _Scary->_Erase_head(_Getal());
+#if _ITERATOR_DEBUG_LEVEL != 0 // TRANSITION, ABI
+        auto&& _Alproxy = _GET_PROXY_ALLOCATOR(_Alnode, _Getal());
+        _Delete_plain_internal(_Alproxy, _Scary->_Myproxy);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+public:
+    _Tree& operator=(const _Tree& _Right) {
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+        auto& _Al       = _Getal();
+        auto& _Right_al = _Right._Getal();
+        if constexpr (_Choose_pocca_v<_Alnode>) {
+            if (_Al != _Right_al) {
+                clear();
+                const auto _Scary = _Get_scary();
+                _Scary->_Orphan_all();
+                auto&& _Alproxy       = _GET_PROXY_ALLOCATOR(_Alnode, _Al);
+                auto&& _Right_alproxy = _GET_PROXY_ALLOCATOR(_Alnode, _Right_al);
+                _Container_proxy_ptr<_Alty> _Proxy(_Right_alproxy, _Leave_proxy_unbound{});
+                auto _Right_al_non_const = _Right_al;
+                auto _Newhead            = _Node::_Buyheadnode(_Right_al_non_const);
+                _Node::_Freenode0(_Al, _Scary->_Myhead);
+                _Pocca(_Al, _Right_al);
+                _Scary->_Myhead = _Newhead;
+                _Proxy._Bind(_Alproxy, _Scary);
+                _Getcomp() = _Right._Getcomp();
+                _Copy<_Strategy::_Copy>(_Right);
+                return *this;
+            }
+        }
+
+        clear();
+        _Getcomp() = _Right._Getcomp();
+        _Pocca(_Al, _Right_al);
+        _Copy<_Strategy::_Copy>(_Right);
+
+        return *this;
+    }
+
+    _NODISCARD iterator begin() noexcept {
+        const auto _Scary = _Get_scary();
+        return iterator(_Scary->_Myhead->_Left, _Scary);
+    }
+
+    _NODISCARD const_iterator begin() const noexcept {
+        const auto _Scary = _Get_scary();
+        return const_iterator(_Scary->_Myhead->_Left, _Scary);
+    }
+
+    _NODISCARD iterator end() noexcept {
+        const auto _Scary = _Get_scary();
+        return iterator(_Scary->_Myhead, _Scary);
+    }
+
+    _NODISCARD const_iterator end() const noexcept {
+        const auto _Scary = _Get_scary();
+        return const_iterator(_Scary->_Myhead, _Scary);
+    }
+
+    _Unchecked_iterator _Unchecked_begin() noexcept {
+        return _Unchecked_iterator(_Get_scary()->_Myhead->_Left, nullptr);
+    }
+
+    _Unchecked_const_iterator _Unchecked_begin() const noexcept {
+        return _Unchecked_const_iterator(_Get_scary()->_Myhead->_Left, nullptr);
+    }
+
+    _Default_sentinel _Unchecked_end() const noexcept {
+        return {};
+    }
+
+    _Unchecked_const_iterator _Unchecked_end_iter() const noexcept {
+        return _Unchecked_const_iterator(_Get_scary()->_Myhead, nullptr);
+    }
+
+    _NODISCARD reverse_iterator rbegin() noexcept {
+        return reverse_iterator(end());
+    }
+
+    _NODISCARD const_reverse_iterator rbegin() const noexcept {
+        return const_reverse_iterator(end());
+    }
+
+    _NODISCARD reverse_iterator rend() noexcept {
+        return reverse_iterator(begin());
+    }
+
+    _NODISCARD const_reverse_iterator rend() const noexcept {
+        return const_reverse_iterator(begin());
+    }
+
+    _NODISCARD const_iterator cbegin() const noexcept {
+        return begin();
+    }
+
+    _NODISCARD const_iterator cend() const noexcept {
+        return end();
+    }
+
+    _NODISCARD const_reverse_iterator crbegin() const noexcept {
+        return rbegin();
+    }
+
+    _NODISCARD const_reverse_iterator crend() const noexcept {
+        return rend();
+    }
+
+    _NODISCARD size_type size() const noexcept {
+        return _Get_scary()->_Mysize;
+    }
+
+    _NODISCARD size_type max_size() const noexcept {
+        return (_STD min)(
+            static_cast<size_type>(_STD _Max_limit<difference_type>()), _Alnode_traits::max_size(_Getal()));
+    }
+
+    _NODISCARD_EMPTY_MEMBER bool empty() const noexcept {
+        return _Get_scary()->_Mysize == 0;
+    }
+
+    _NODISCARD allocator_type get_allocator() const noexcept {
+        return static_cast<allocator_type>(_Getal());
+    }
+
+    _NODISCARD key_compare key_comp() const {
+        return _Getcomp();
+    }
+
+    _NODISCARD value_compare value_comp() const {
+        return value_compare(key_comp());
+    }
+
+    template <bool _Multi2 = _Multi, enable_if_t<!_Multi2, int> = 0>
+    pair<iterator, bool> insert(const value_type& _Val) {
+        const auto _Result = _Emplace(_Val);
+        return {iterator(_Result.first, _Get_scary()), _Result.second};
+    }
+
+    template <bool _Multi2 = _Multi, enable_if_t<_Multi2, int> = 0>
+    iterator insert(const value_type& _Val) {
+        return iterator(_Emplace(_Val).first, _Get_scary());
+    }
+
+    template <bool _Multi2 = _Multi, enable_if_t<!_Multi2, int> = 0>
+    pair<iterator, bool> insert(value_type&& _Val) {
+        const auto _Result = _Emplace(_STD move(_Val));
+        return {iterator(_Result.first, _Get_scary()), _Result.second};
+    }
+
+    template <bool _Multi2 = _Multi, enable_if_t<_Multi2, int> = 0>
+    iterator insert(value_type&& _Val) {
+        return iterator(_Emplace(_STD move(_Val)).first, _Get_scary());
+    }
+
+    iterator insert(const_iterator _Where, const value_type& _Val) {
+        const auto _Scary = _Get_scary();
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Where._Getcont() == _Scary, "map/set insert iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        return iterator(_Emplace_hint(_Where._Ptr, _Val), _Scary);
+    }
+
+    iterator insert(const_iterator _Where, value_type&& _Val) {
+        const auto _Scary = _Get_scary();
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Where._Getcont() == _Scary, "map/set insert iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        return iterator(_Emplace_hint(_Where._Ptr, _STD move(_Val)), _Scary);
+    }
+
+protected:
+    template <class _Iter, class _Sent>
+    void _Insert_range_unchecked(_Iter _First, const _Sent _Last) {
+        const auto _Myhead = _Get_scary()->_Myhead;
+        for (; _First != _Last; ++_First) {
+            _Emplace_hint(_Myhead, *_First);
+        }
+    }
+
+public:
+    template <class _Iter>
+    void insert(_Iter _First, _Iter _Last) {
+        _STD _Adl_verify_range(_First, _Last);
+        _Insert_range_unchecked(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last));
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<value_type> _Rng>
+    void insert_range(_Rng&& _Range) {
+        _Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // _HAS_CXX23
+
+    void insert(initializer_list<value_type> _Ilist) {
+        _Insert_range_unchecked(_Ilist.begin(), _Ilist.end());
+    }
+
+private:
+    _Nodeptr _Erase_unchecked(_Unchecked_const_iterator _Where) noexcept {
+        const auto _Scary                    = _Get_scary();
+        _Unchecked_const_iterator _Successor = _Where;
+        ++_Successor; // save successor iterator for return
+        _Nodeptr _Erasednode = _Scary->_Extract(_Where); // node to erase
+        _Scary->_Orphan_ptr(_Erasednode);
+        _Node::_Freenode(_Getal(), _Erasednode); // delete erased node
+        return _Successor._Ptr; // return successor nodeptr
+    }
+
+    _Nodeptr _Erase_unchecked(_Unchecked_const_iterator _First, _Unchecked_const_iterator _Last) noexcept {
+        const auto _Begin = _Unchecked_begin();
+        if (_First == _Begin && _Last._Ptr->_Isnil) {
+            // erase all
+            clear();
+            return _Last._Ptr;
+        }
+
+        // partial erase, one at a time
+        while (_First != _Last) {
+            _Erase_unchecked(_First++);
+        }
+
+        return _Last._Ptr;
+    }
+
+    size_type _Erase(const pair<_Nodeptr, _Nodeptr> _Where) noexcept {
+        const _Unchecked_const_iterator _First(_Where.first, nullptr);
+        const _Unchecked_const_iterator _Last(_Where.second, nullptr);
+        const auto _Num = static_cast<size_type>(_STD distance(_First, _Last));
+        _Erase_unchecked(_First, _Last);
+        return _Num;
+    }
+
+public:
+    template <class _Iter = iterator, enable_if_t<!is_same_v<_Iter, const_iterator>, int> = 0>
+    iterator erase(iterator _Where) noexcept /* strengthened */ {
+        const auto _Scary = _Get_scary();
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Where._Getcont() == _Scary, "map/set erase iterator from incorrect container");
+        _STL_VERIFY(!_Where._Ptr->_Isnil, "cannot erase map/set end() iterator");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        return iterator(_Erase_unchecked(_Where._Unwrapped()), _Scary);
+    }
+
+    iterator erase(const_iterator _Where) noexcept /* strengthened */ {
+        const auto _Scary = _Get_scary();
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Where._Getcont() == _Scary, "map/set erase iterator from incorrect container");
+        _STL_VERIFY(!_Where._Ptr->_Isnil, "cannot erase map/set end() iterator");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        return iterator(_Erase_unchecked(_Where._Unwrapped()), _Scary);
+    }
+
+    iterator erase(const_iterator _First, const_iterator _Last) noexcept /* strengthened */ {
+        return iterator(_Erase_unchecked(_First._Unwrapped(), _Last._Unwrapped()), _Get_scary());
+    }
+
+    size_type erase(const key_type& _Keyval) noexcept(noexcept(_Eqrange(_Keyval))) /* strengthened */ {
+        return _Erase(_Eqrange(_Keyval));
+    }
+
+#if _HAS_CXX23
+    template <class _Kx>
+        requires _Is_transparent_v<key_compare>
+              && (!is_convertible_v<_Kx, const_iterator>) && (!is_convertible_v<_Kx, iterator>)
+    size_type erase(_Kx&& _Keyval) noexcept(noexcept(_Eqrange(_Keyval))) /* strengthened */ {
+        return _Erase(_Eqrange(_Keyval));
+    }
+#endif // _HAS_CXX23
+
+    void clear() noexcept {
+        const auto _Scary = _Get_scary();
+        _Scary->_Orphan_ptr(nullptr);
+        auto _Head = _Scary->_Myhead;
+        _Scary->_Erase_tree(_Getal(), _Head->_Parent);
+        _Head->_Parent  = _Head;
+        _Head->_Left    = _Head;
+        _Head->_Right   = _Head;
+        _Scary->_Mysize = 0;
+    }
+
+private:
+    template <class _Other>
+    _NODISCARD _Nodeptr _Find(const _Other& _Keyval) const {
+        const _Tree_find_result<_Nodeptr> _Loc = _Find_lower_bound(_Keyval);
+        if (_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
+            return _Loc._Bound;
+        }
+
+        return _Get_scary()->_Myhead;
+    }
+
+public:
+    _NODISCARD iterator find(const key_type& _Keyval) {
+        return iterator(_Find(_Keyval), _Get_scary());
+    }
+
+    _NODISCARD const_iterator find(const key_type& _Keyval) const {
+        return const_iterator(_Find(_Keyval), _Get_scary());
+    }
+
+    template <class _Other, class _Mycomp = key_compare, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
+    _NODISCARD iterator find(const _Other& _Keyval) {
+        return iterator(_Find(_Keyval), _Get_scary());
+    }
+
+    template <class _Other, class _Mycomp = key_compare, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
+    _NODISCARD const_iterator find(const _Other& _Keyval) const {
+        return const_iterator(_Find(_Keyval), _Get_scary());
+    }
+
+#if _HAS_CXX20
+    _NODISCARD bool contains(const key_type& _Keyval) const {
+        return _Lower_bound_duplicate(_Find_lower_bound(_Keyval)._Bound, _Keyval);
+    }
+
+    template <class _Other>
+        requires _Is_transparent_v<key_compare>
+    _NODISCARD bool contains(const _Other& _Keyval) const {
+        return _Lower_bound_duplicate(_Find_lower_bound(_Keyval)._Bound, _Keyval);
+    }
+#endif // _HAS_CXX20
+
+    _NODISCARD size_type count(const key_type& _Keyval) const {
+        if constexpr (_Multi) {
+            const auto _Ans = _Eqrange(_Keyval);
+            return static_cast<size_type>(_STD distance(
+                _Unchecked_const_iterator(_Ans.first, nullptr), _Unchecked_const_iterator(_Ans.second, nullptr)));
+        } else {
+            return _Lower_bound_duplicate(_Find_lower_bound(_Keyval)._Bound, _Keyval);
+        }
+    }
+
+    template <class _Other, class _Mycomp = key_compare, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
+    _NODISCARD size_type count(const _Other& _Keyval) const {
+        const auto _Ans = _Eqrange(_Keyval);
+        return static_cast<size_type>(_STD distance(
+            _Unchecked_const_iterator(_Ans.first, nullptr), _Unchecked_const_iterator(_Ans.second, nullptr)));
+    }
+
+    _NODISCARD iterator lower_bound(const key_type& _Keyval) {
+        return iterator(_Find_lower_bound(_Keyval)._Bound, _Get_scary());
+    }
+
+    _NODISCARD const_iterator lower_bound(const key_type& _Keyval) const {
+        return const_iterator(_Find_lower_bound(_Keyval)._Bound, _Get_scary());
+    }
+
+    template <class _Other, class _Mycomp = key_compare, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
+    _NODISCARD iterator lower_bound(const _Other& _Keyval) {
+        return iterator(_Find_lower_bound(_Keyval)._Bound, _Get_scary());
+    }
+
+    template <class _Other, class _Mycomp = key_compare, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
+    _NODISCARD const_iterator lower_bound(const _Other& _Keyval) const {
+        return const_iterator(_Find_lower_bound(_Keyval)._Bound, _Get_scary());
+    }
+
+    _NODISCARD iterator upper_bound(const key_type& _Keyval) {
+        return iterator(_Find_upper_bound(_Keyval)._Bound, _Get_scary());
+    }
+
+    _NODISCARD const_iterator upper_bound(const key_type& _Keyval) const {
+        return const_iterator(_Find_upper_bound(_Keyval)._Bound, _Get_scary());
+    }
+
+    template <class _Other, class _Mycomp = key_compare, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
+    _NODISCARD iterator upper_bound(const _Other& _Keyval) {
+        return iterator(_Find_upper_bound(_Keyval)._Bound, _Get_scary());
+    }
+
+    template <class _Other, class _Mycomp = key_compare, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
+    _NODISCARD const_iterator upper_bound(const _Other& _Keyval) const {
+        return const_iterator(_Find_upper_bound(_Keyval)._Bound, _Get_scary());
+    }
+
+    _NODISCARD pair<iterator, iterator> equal_range(const key_type& _Keyval) {
+        const auto _Result = _Eqrange(_Keyval);
+        const auto _Scary  = _Get_scary();
+        return {iterator(_Result.first, _Scary), iterator(_Result.second, _Scary)};
+    }
+
+    _NODISCARD pair<const_iterator, const_iterator> equal_range(const key_type& _Keyval) const {
+        const auto _Result = _Eqrange(_Keyval);
+        const auto _Scary  = _Get_scary();
+        return {const_iterator(_Result.first, _Scary), const_iterator(_Result.second, _Scary)};
+    }
+
+    template <class _Other, class _Mycomp = key_compare, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
+    _NODISCARD pair<iterator, iterator> equal_range(const _Other& _Keyval) {
+        const auto _Result = _Eqrange(_Keyval);
+        const auto _Scary  = _Get_scary();
+        return {iterator(_Result.first, _Scary), iterator(_Result.second, _Scary)};
+    }
+
+    template <class _Other, class _Mycomp = key_compare, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
+    _NODISCARD pair<const_iterator, const_iterator> equal_range(const _Other& _Keyval) const {
+        const auto _Result = _Eqrange(_Keyval);
+        const auto _Scary  = _Get_scary();
+        return {const_iterator(_Result.first, _Scary), const_iterator(_Result.second, _Scary)};
+    }
+
+    void swap(_Tree& _Right) noexcept(_Is_nothrow_swappable<key_compare>::value) /* strengthened */ {
+        using _STD swap;
+        if (this != _STD addressof(_Right)) {
+            _Pocs(_Getal(), _Right._Getal());
+            _Swap_val_excluding_comp(_Right);
+            swap(_Getcomp(), _Right._Getcomp()); // intentional ADL
+        }
+    }
+
+protected:
+    template <class _Keyty>
+    _Tree_find_hint_result<_Nodeptr> _Find_hint(const _Nodeptr _Hint, const _Keyty& _Keyval) const {
+        const auto& _Comp = _Getcomp();
+        const auto _Head  = _Get_scary()->_Myhead;
+        if constexpr (_Multi) { // insert even if duplicate
+            if (_Hint->_Isnil) {
+                // insert at end if greater than or equal to last element
+                if (_Head->_Parent->_Isnil || !_DEBUG_LT_PRED(_Comp, _Keyval, _Traits::_Kfn(_Head->_Right->_Myval))) {
+                    return {{_Head->_Right, _Tree_child::_Right}, false};
+                }
+
+                // _Hint is end(); it must be closer to the end of equivalents
+                return {_Find_upper_bound(_Keyval)._Location, false};
+            }
+
+            if (_Hint == _Head->_Left) {
+                // insert at beginning if less than or equal to first element
+                if (!_DEBUG_LT_PRED(_Comp, _Traits::_Kfn(_Hint->_Myval), _Keyval)) {
+                    return {{_Hint, _Tree_child::_Left}, false};
+                }
+
+                // _Hint is begin(); it must be closer to the beginning of equivalents
+                return {_Find_lower_bound(_Keyval)._Location, false};
+            }
+
+            if (!_DEBUG_LT_PRED(_Comp, _Traits::_Kfn(_Hint->_Myval), _Keyval)) {
+                // _Val <= *_Hint
+                const auto _Prev = (--(_Unchecked_const_iterator(_Hint, nullptr)))._Ptr;
+                if (!_DEBUG_LT_PRED(_Comp, _Keyval, _Traits::_Kfn(_Prev->_Myval))) {
+                    // _Val <= *_Hint and _Val >= *prev(_Hint); insert here
+                    if (_Prev->_Right->_Isnil) {
+                        return {{_Prev, _Tree_child::_Right}, false};
+                    } else {
+                        return {{_Hint, _Tree_child::_Left}, false};
+                    }
+                }
+
+                // _Val goes before *_Hint; _Hint must be closer to the end of equivalents
+                return {_Find_upper_bound(_Keyval)._Location, false};
+            }
+
+            // _Val goes after *_Hint; _Hint must be closer to the beginning of equivalents
+            return {_Find_lower_bound(_Keyval)._Location, false};
+        } else { // insert only if unique
+            if (_Hint->_Isnil) { // insert at end if after last element
+                // insert at end if greater than last element
+                if (_Head->_Parent->_Isnil || _DEBUG_LT_PRED(_Comp, _Traits::_Kfn(_Head->_Right->_Myval), _Keyval)) {
+                    return {{_Head->_Right, _Tree_child::_Right}, false};
+                }
+            } else if (_Hint == _Head->_Left) {
+                // insert at beginning if less than first element
+                if (_DEBUG_LT_PRED(_Comp, _Keyval, _Traits::_Kfn(_Hint->_Myval))) {
+                    return {{_Hint, _Tree_child::_Left}, false};
+                }
+            } else if (_DEBUG_LT_PRED(_Comp, _Keyval, _Traits::_Kfn(_Hint->_Myval))) {
+                // _Val < *_Hint
+                const auto _Prev = (--(_Unchecked_const_iterator(_Hint, nullptr)))._Ptr;
+                if (_DEBUG_LT_PRED(_Comp, _Traits::_Kfn(_Prev->_Myval), _Keyval)) {
+                    // _Val < *_Hint and _Val > *prev(_Hint); insert here
+                    if (_Prev->_Right->_Isnil) {
+                        return {{_Prev, _Tree_child::_Right}, false};
+                    } else {
+                        return {{_Hint, _Tree_child::_Left}, false};
+                    }
+                }
+            } else if (_DEBUG_LT_PRED(_Comp, _Traits::_Kfn(_Hint->_Myval), _Keyval)) {
+                // _Val > *_Hint
+                const auto _Next = (++(_Unchecked_const_iterator(_Hint, nullptr)))._Ptr;
+                if (_Next->_Isnil || _DEBUG_LT_PRED(_Comp, _Keyval, _Traits::_Kfn(_Next->_Myval))) {
+                    // _Val > *_Hint and _Val < *next(_Hint); insert here
+                    if (_Hint->_Right->_Isnil) {
+                        return {{_Hint, _Tree_child::_Right}, false};
+                    }
+
+                    return {{_Next, _Tree_child::_Left}, false};
+                }
+            } else {
+                // _Val is equivalent to *_Hint; don't insert
+                return {{_Hint, _Tree_child::_Right}, true};
+            }
+
+            const auto _Loc = _Find_lower_bound(_Keyval);
+            if (_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
+                return {{_Loc._Bound, _Tree_child::_Unused}, true};
+            }
+
+            return {_Loc._Location, false};
+        }
+    }
+
+    template <class _Keyty>
+    _Tree_find_result<_Nodeptr> _Find_upper_bound(const _Keyty& _Keyval) const {
+        const auto _Scary = _Get_scary();
+        _Tree_find_result<_Nodeptr> _Result{{_Scary->_Myhead->_Parent, _Tree_child::_Right}, _Scary->_Myhead};
+        _Nodeptr _Trynode = _Result._Location._Parent;
+        while (!_Trynode->_Isnil) {
+            _Result._Location._Parent = _Trynode;
+            if (_DEBUG_LT_PRED(_Getcomp(), _Keyval, _Traits::_Kfn(_Trynode->_Myval))) {
+                _Result._Location._Child = _Tree_child::_Left;
+                _Result._Bound           = _Trynode;
+                _Trynode                 = _Trynode->_Left;
+            } else {
+                _Result._Location._Child = _Tree_child::_Right;
+                _Trynode                 = _Trynode->_Right;
+            }
+        }
+
+        return _Result;
+    }
+
+    template <class _Keyty>
+    bool _Lower_bound_duplicate(const _Nodeptr _Bound, const _Keyty& _Keyval) const {
+        return !_Bound->_Isnil && !_DEBUG_LT_PRED(_Getcomp(), _Keyval, _Traits::_Kfn(_Bound->_Myval));
+    }
+
+    template <class _Keyty>
+    _Tree_find_result<_Nodeptr> _Find_lower_bound(const _Keyty& _Keyval) const {
+        const auto _Scary = _Get_scary();
+        _Tree_find_result<_Nodeptr> _Result{{_Scary->_Myhead->_Parent, _Tree_child::_Right}, _Scary->_Myhead};
+        _Nodeptr _Trynode = _Result._Location._Parent;
+        while (!_Trynode->_Isnil) {
+            _Result._Location._Parent = _Trynode;
+            if (_DEBUG_LT_PRED(_Getcomp(), _Traits::_Kfn(_Trynode->_Myval), _Keyval)) {
+                _Result._Location._Child = _Tree_child::_Right;
+                _Trynode                 = _Trynode->_Right;
+            } else {
+                _Result._Location._Child = _Tree_child::_Left;
+                _Result._Bound           = _Trynode;
+                _Trynode                 = _Trynode->_Left;
+            }
+        }
+
+        return _Result;
+    }
+
+    void _Check_grow_by_1() {
+        if (max_size() == _Get_scary()->_Mysize) {
+            _Throw_tree_length_error();
+        }
+    }
+
+    template <_Strategy _Strat>
+    void _Copy(const _Tree& _Right) { // copy or move entire tree from _Right
+        const auto _Scary        = _Get_scary();
+        const auto _Right_scary  = _Right._Get_scary();
+        _Scary->_Myhead->_Parent = _Copy_nodes<_Strat>(_Right_scary->_Myhead->_Parent, _Scary->_Myhead);
+        _Scary->_Mysize          = _Right_scary->_Mysize;
+        if (!_Scary->_Myhead->_Parent->_Isnil) { // nonempty tree, look for new smallest and largest
+            _Scary->_Myhead->_Left  = _Scary_val::_Min(_Scary->_Myhead->_Parent);
+            _Scary->_Myhead->_Right = _Scary_val::_Max(_Scary->_Myhead->_Parent);
+        } else { // empty tree, just tidy head pointers
+            _Scary->_Myhead->_Left  = _Scary->_Myhead;
+            _Scary->_Myhead->_Right = _Scary->_Myhead;
+        }
+    }
+
+    template <_Strategy _Strat, class _Ty>
+    _Nodeptr _Copy_or_move(_Ty& _Val) {
+        if constexpr (_Strat == _Strategy::_Copy) {
+            return _Buynode(_Val);
+        } else {
+            if constexpr (_Is_set) {
+                return _Buynode(_STD move(_Val));
+            } else {
+                return _Buynode(_STD move(const_cast<key_type&>(_Val.first)), _STD move(_Val.second));
+            }
+        }
+    }
+
+    template <_Strategy _Strat>
+    _Nodeptr _Copy_nodes(_Nodeptr _Rootnode, _Nodeptr _Wherenode) {
+        // copy entire subtree, recursively
+        const auto _Scary = _Get_scary();
+        _Nodeptr _Newroot = _Scary->_Myhead; // point at nil node
+
+        if (!_Rootnode->_Isnil) { // copy or move a node, then any subtrees
+            _Newroot          = _Copy_or_move<_Strat>(_Rootnode->_Myval); // memorize new root
+            _Newroot->_Parent = _Wherenode;
+            _Newroot->_Color  = _Rootnode->_Color;
+
+            typename _Scary_val::template _Erase_tree_and_orphan_guard<_Alnode> _Guard{_Scary, _Getal(), _Newroot};
+
+            _Newroot->_Left  = _Copy_nodes<_Strat>(_Rootnode->_Left, _Newroot);
+            _Newroot->_Right = _Copy_nodes<_Strat>(_Rootnode->_Right, _Newroot);
+
+            _Guard._Val_ptr = nullptr;
+        }
+
+        return _Newroot; // return newly constructed tree
+    }
+
+    template <class _Other>
+    pair<_Nodeptr, _Nodeptr> _Eqrange(const _Other& _Keyval) const
+        noexcept(_Nothrow_compare<key_compare, key_type, _Other> && _Nothrow_compare<key_compare, _Other, key_type>) {
+        // find range of nodes equivalent to _Keyval
+        const auto _Scary = _Get_scary();
+        const auto& _Comp = _Getcomp();
+        _Nodeptr _Pnode   = _Scary->_Myhead->_Parent;
+        _Nodeptr _Lonode  = _Scary->_Myhead; // end() if search fails
+        _Nodeptr _Hinode  = _Scary->_Myhead; // end() if search fails
+
+        while (!_Pnode->_Isnil) {
+            const auto& _Nodekey = _Traits::_Kfn(_Pnode->_Myval);
+            if (_DEBUG_LT_PRED(_Comp, _Nodekey, _Keyval)) {
+                _Pnode = _Pnode->_Right; // descend right subtree
+            } else { // _Pnode not less than _Keyval, remember it
+                if (_Hinode->_Isnil && _DEBUG_LT_PRED(_Comp, _Keyval, _Nodekey)) {
+                    _Hinode = _Pnode; // _Pnode greater, remember it
+                }
+
+                _Lonode = _Pnode;
+                _Pnode  = _Pnode->_Left; // descend left subtree
+            }
+        }
+
+        _Pnode = _Hinode->_Isnil ? _Scary->_Myhead->_Parent : _Hinode->_Left; // continue scan for upper bound
+        while (!_Pnode->_Isnil) {
+            if (_DEBUG_LT_PRED(_Getcomp(), _Keyval, _Traits::_Kfn(_Pnode->_Myval))) {
+                // _Pnode greater than _Keyval, remember it
+                _Hinode = _Pnode;
+                _Pnode  = _Pnode->_Left; // descend left subtree
+            } else {
+                _Pnode = _Pnode->_Right; // descend right subtree
+            }
+        }
+
+        return {_Lonode, _Hinode};
+    }
+
+#if _HAS_CXX17
+public:
+    using node_type = typename _Traits::node_type;
+
+    node_type extract(const const_iterator _Where) {
+        const auto _Scary = _Get_scary();
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Where._Getcont() == _Scary && !_Where._Ptr->_Isnil, "map/set erase iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        const auto _Ptr = _Scary->_Extract(_Where._Unwrapped());
+        _Scary->_Orphan_ptr(_Ptr);
+        return node_type::_Make(_Ptr, _Getal());
+    }
+
+    node_type extract(const key_type& _Keyval) {
+        const const_iterator _Where = find(_Keyval);
+        if (_Where == end()) {
+            return node_type{};
+        }
+
+        return extract(_Where);
+    }
+
+#if _HAS_CXX23
+    template <class _Kx>
+        requires _Is_transparent_v<key_compare>
+              && (!is_convertible_v<_Kx, const_iterator>) && (!is_convertible_v<_Kx, iterator>)
+    node_type extract(_Kx&& _Keyval) {
+        const const_iterator _Where = find(_Keyval);
+        if (_Where == end()) {
+            return node_type{};
+        }
+
+        return extract(_Where);
+    }
+#endif // _HAS_CXX23
+
+    auto insert(node_type&& _Handle) {
+        if (_Handle.empty()) {
+            if constexpr (_Multi) {
+                return end();
+            } else {
+                return _Insert_return_type<iterator, node_type>{end(), false, {}};
+            }
+        }
+
+        _Check_node_allocator(_Handle);
+        const auto _Scary        = _Get_scary();
+        const auto _Attempt_node = _Handle._Getptr();
+        const auto& _Keyval      = _Traits::_Kfn(_Attempt_node->_Myval);
+        _Tree_find_result<_Nodeptr> _Loc;
+        if constexpr (_Multi) {
+            _Loc = _Find_upper_bound(_Keyval);
+        } else {
+            _Loc = _Find_lower_bound(_Keyval);
+            if (_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
+                return _Insert_return_type<iterator, node_type>{
+                    iterator(_Loc._Bound, _Scary), false, _STD move(_Handle)};
+            }
+        }
+
+        _Check_grow_by_1();
+
+        // nothrow hereafter
+
+        _Attempt_node->_Left = _Scary->_Myhead;
+        // _Attempt_node->_Parent handled in _Insert_node
+        _Attempt_node->_Right = _Scary->_Myhead;
+        _Attempt_node->_Color = _Red;
+
+        const auto _Inserted = _Scary->_Insert_node(_Loc._Location, _Handle._Release());
+        if constexpr (_Multi) {
+            return iterator(_Inserted, _Scary);
+        } else {
+            return _Insert_return_type<iterator, node_type>{iterator(_Inserted, _Scary), true, _STD move(_Handle)};
+        }
+    }
+
+    iterator insert(const const_iterator _Hint, node_type&& _Handle) {
+        const auto _Scary = _Get_scary();
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Hint._Getcont() == _Scary, "map/set insert iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        if (_Handle.empty()) {
+            return end();
+        }
+
+        _Check_node_allocator(_Handle);
+        const auto _Attempt_node = _Handle._Getptr();
+        const auto& _Keyval      = _Traits::_Kfn(_Attempt_node->_Myval);
+        const auto _Loc          = _Find_hint(_Hint._Ptr, _Keyval);
+        if (_Loc._Duplicate) {
+            return iterator(_Loc._Location._Parent, _Scary);
+        }
+
+        _Check_grow_by_1();
+
+        _Attempt_node->_Left = _Scary->_Myhead;
+        // _Attempt_node->_Parent handled in _Insert_node
+        _Attempt_node->_Right = _Scary->_Myhead;
+        _Attempt_node->_Color = _Red;
+
+        return iterator(_Scary->_Insert_node(_Loc._Location, _Handle._Release()), _Scary);
+    }
+
+    template <class>
+    friend class _Tree;
+
+    template <class _Other_traits>
+    void merge(_Tree<_Other_traits>& _That) {
+        static_assert(is_same_v<_Nodeptr, typename _Tree<_Other_traits>::_Nodeptr>,
+            "merge() requires an argument with a compatible node type.");
+
+        static_assert(is_same_v<allocator_type, typename _Tree<_Other_traits>::allocator_type>,
+            "merge() requires an argument with the same allocator type.");
+
+        if constexpr (is_same_v<_Tree, _Tree<_Other_traits>>) {
+            if (this == _STD addressof(_That)) {
+                return;
+            }
+        }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        if constexpr (!_Alnode_traits::is_always_equal::value) {
+            _STL_VERIFY(_Getal() == _That._Getal(), "allocator incompatible for merge");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        const auto _Scary      = _Get_scary();
+        const auto _Head       = _Scary->_Myhead;
+        const auto _That_scary = _That._Get_scary();
+        auto _First            = _That._Unchecked_begin();
+        while (!_First._Ptr->_Isnil) {
+            const auto _Attempt_node = _First._Ptr;
+            ++_First;
+            _Tree_find_result<_Nodeptr> _Loc;
+            const auto& _Keyval = _Traits::_Kfn(_Attempt_node->_Myval);
+            if constexpr (_Multi) {
+                _Loc = _Find_upper_bound(_Keyval);
+            } else {
+                _Loc = _Find_lower_bound(_Keyval);
+                if (_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
+                    continue;
+                }
+            }
+
+            _Check_grow_by_1();
+
+            // nothrow hereafter for this iteration
+            const auto _Extracted = _That_scary->_Extract(_Unchecked_const_iterator(_Attempt_node, nullptr));
+            _Extracted->_Left     = _Head;
+            // _Extracted->_Parent handled in _Insert_node
+            _Extracted->_Right = _Head;
+            _Extracted->_Color = _Red;
+
+            const auto _Inserted = _Scary->_Insert_node(_Loc._Location, _Extracted);
+            _Reparent_ptr(_Inserted, _That);
+        }
+    }
+
+    template <class _Other_traits>
+    void merge(_Tree<_Other_traits>&& _That) {
+        static_assert(is_same_v<_Nodeptr, typename _Tree<_Other_traits>::_Nodeptr>,
+            "merge() requires an argument with a compatible node type.");
+
+        static_assert(is_same_v<allocator_type, typename _Tree<_Other_traits>::allocator_type>,
+            "merge() requires an argument with the same allocator type.");
+
+        merge(_That);
+    }
+
+protected:
+    template <class _Other_traits>
+    void _Reparent_ptr(const _Nodeptr _Ptr, _Tree<_Other_traits>& _Old_parent) {
+        (void) _Ptr;
+        (void) _Old_parent;
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _Lockit _Lock(_LOCK_DEBUG);
+        const auto _Old_parent_scary = _Old_parent._Get_scary();
+        _Iterator_base12** _Pnext    = &_Old_parent_scary->_Myproxy->_Myfirstiter;
+        _STL_VERIFY(_Pnext, "source container corrupted");
+        if (_Ptr == nullptr || _Ptr == _Old_parent_scary->_Myhead) {
+            return;
+        }
+
+        const auto _My_saved_proxy               = _Get_scary()->_Myproxy;
+        _Iterator_base12** const _My_saved_first = &_My_saved_proxy->_Myfirstiter;
+
+        while (*_Pnext) {
+            _Iterator_base12** const _Next = &(*_Pnext)->_Mynextiter;
+            const auto _Iter               = static_cast<const_iterator*>(*_Pnext);
+            if (_Iter->_Ptr == _Ptr) { // reparent the iterator
+                *_Pnext            = *_Next;
+                _Iter->_Myproxy    = _My_saved_proxy;
+                _Iter->_Mynextiter = *_My_saved_first;
+                *_My_saved_first   = _Iter;
+            } else { // skip the iterator
+                _Pnext = _Next;
+            }
+        }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+    }
+
+    void _Check_node_allocator(node_type& _Handle) const {
+        (void) _Handle;
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(get_allocator() == _Handle._Getal(), "node handle allocator incompatible for insert");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+    }
+#endif // _HAS_CXX17
+
+    void _Alloc_sentinel_and_proxy() {
+        const auto _Scary = _Get_scary();
+        auto&& _Alproxy   = _GET_PROXY_ALLOCATOR(_Alnode, _Getal());
+        _Container_proxy_ptr<_Alnode> _Proxy(_Alproxy, *_Scary);
+        _Scary->_Myhead = _Node::_Buyheadnode(_Getal());
+        _Proxy._Release();
+    }
+
+    template <class... _Valty>
+    _Nodeptr _Buynode(_Valty&&... _Val) {
+        return _Node::_Buynode(_Getal(), _Get_scary()->_Myhead, _STD forward<_Valty>(_Val)...);
+    }
+
+    key_compare& _Getcomp() noexcept {
+        return _Mypair._Get_first();
+    }
+
+    const key_compare& _Getcomp() const noexcept {
+        return _Mypair._Get_first();
+    }
+
+    _Alnode& _Getal() noexcept {
+        return _Mypair._Myval2._Get_first();
+    }
+
+    const _Alnode& _Getal() const noexcept {
+        return _Mypair._Myval2._Get_first();
+    }
+
+    _Scary_val* _Get_scary() noexcept {
+        return _STD addressof(_Mypair._Myval2._Myval2);
+    }
+
+    const _Scary_val* _Get_scary() const noexcept {
+        return _STD addressof(_Mypair._Myval2._Myval2);
+    }
+
+private:
+    _Compressed_pair<key_compare, _Compressed_pair<_Alnode, _Scary_val>> _Mypair;
+};
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XTREE_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xutility b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xutility
new file mode 100644
index 0000000000000000000000000000000000000000..5201e1202f5960b8fca01d9566921620b2f79546
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xutility
@@ -0,0 +1,7478 @@
+// xutility internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XUTILITY_
+#define _XUTILITY_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <__msvc_iter_core.hpp>
+#include <climits>
+#include <cstdlib>
+#include <cstring>
+#include <cwchar>
+
+#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("lifetimebound")
+#undef msvc
+#undef intrinsic
+#undef lifetimebound
+
+#if defined(_CRTBLD) && defined(CRTDLL2)
+// TRANSITION, ABI: The vector algorithms are compiled into the import lib, so we disable their usage when building
+// the DLL. (We could additionally link them into the DLL - not as exports, just for internal usage - but we
+// haven't chosen to do that yet.) When we can break ABI and export the vector algorithms from the DLL,
+// this preprocessor case should be removed.
+#ifndef _USE_STD_VECTOR_ALGORITHMS
+#define _USE_STD_VECTOR_ALGORITHMS 0
+#elif _USE_STD_VECTOR_ALGORITHMS
+#error Vector algorithms are not supported when building msvcp140.dll, but _USE_STD_VECTOR_ALGORITHMS is set.
+#endif // ^^^ _USE_STD_VECTOR_ALGORITHMS != 0 ^^^
+#elif (defined(_M_IX86) || defined(_M_X64)) && !defined(_M_CEE_PURE) && !defined(_M_HYBRID) && !defined(_M_ARM64EC)
+#ifndef _USE_STD_VECTOR_ALGORITHMS
+#define _USE_STD_VECTOR_ALGORITHMS 1
+#endif // !defined(_USE_STD_VECTOR_ALGORITHMS)
+#else // ^^^ arch supports vector algorithms / no support for vector algorithms vvv
+#ifndef _USE_STD_VECTOR_ALGORITHMS
+#define _USE_STD_VECTOR_ALGORITHMS 0
+#elif _USE_STD_VECTOR_ALGORITHMS
+#error Vector algorithms are not supported on this architecture, but _USE_STD_VECTOR_ALGORITHMS is set.
+#endif // ^^^ _USE_STD_VECTOR_ALGORITHMS != 0 ^^^
+#endif // ^^^ no support for vector algorithms ^^^
+
+#ifndef _USE_STD_VECTOR_FLOATING_ALGORITHMS
+#if _USE_STD_VECTOR_ALGORITHMS && !defined(_M_FP_EXCEPT)
+#define _USE_STD_VECTOR_FLOATING_ALGORITHMS 1
+#else // ^^^ use vector algorithms and fast math / not use vector algorithms or not use fast math vvv
+#define _USE_STD_VECTOR_FLOATING_ALGORITHMS 0
+#endif // ^^^ not use vector algorithms or not use fast math ^^^
+#else // ^^^ !defined(_USE_STD_VECTOR_FLOATING_ALGORITHMS) / defined(_USE_STD_VECTOR_FLOATING_ALGORITHMS) vvv
+#if _USE_STD_VECTOR_FLOATING_ALGORITHMS && !_USE_STD_VECTOR_ALGORITHMS
+#error _USE_STD_VECTOR_FLOATING_ALGORITHMS must imply _USE_STD_VECTOR_ALGORITHMS.
+#endif // _USE_STD_VECTOR_FLOATING_ALGORITHMS && !_USE_STD_VECTOR_ALGORITHMS
+#endif // ^^^ defined(_USE_STD_VECTOR_FLOATING_ALGORITHMS) ^^^
+
+#if _USE_STD_VECTOR_ALGORITHMS
+extern "C" {
+// The "noalias" attribute tells the compiler optimizer that pointers going into these hand-vectorized algorithms
+// won't be stored beyond the lifetime of the function, and that the function will only reference arrays denoted by
+// those pointers. The optimizer also assumes in that case that a pointer parameter is not returned to the caller via
+// the return value, so functions using "noalias" must usually return void. This attribute is valuable because these
+// functions are in native code objects that the compiler cannot analyze. In the absence of the noalias attribute, the
+// compiler has to assume that the denoted arrays are "globally address taken", and that any later calls to
+// unanalyzable routines may modify those arrays.
+__declspec(noalias) void __cdecl __std_reverse_trivially_swappable_1(void* _First, void* _Last) noexcept;
+__declspec(noalias) void __cdecl __std_reverse_trivially_swappable_2(void* _First, void* _Last) noexcept;
+__declspec(noalias) void __cdecl __std_reverse_trivially_swappable_4(void* _First, void* _Last) noexcept;
+__declspec(noalias) void __cdecl __std_reverse_trivially_swappable_8(void* _First, void* _Last) noexcept;
+__declspec(noalias) void __cdecl __std_swap_ranges_trivially_swappable_noalias(
+    void* _First1, void* _Last1, void* _First2) noexcept;
+
+__declspec(noalias) size_t
+    __stdcall __std_count_trivial_1(const void* _First, const void* _Last, uint8_t _Val) noexcept;
+__declspec(noalias) size_t
+    __stdcall __std_count_trivial_2(const void* _First, const void* _Last, uint16_t _Val) noexcept;
+__declspec(noalias) size_t
+    __stdcall __std_count_trivial_4(const void* _First, const void* _Last, uint32_t _Val) noexcept;
+__declspec(noalias) size_t
+    __stdcall __std_count_trivial_8(const void* _First, const void* _Last, uint64_t _Val) noexcept;
+
+const void* __stdcall __std_find_trivial_1(const void* _First, const void* _Last, uint8_t _Val) noexcept;
+const void* __stdcall __std_find_trivial_2(const void* _First, const void* _Last, uint16_t _Val) noexcept;
+const void* __stdcall __std_find_trivial_4(const void* _First, const void* _Last, uint32_t _Val) noexcept;
+const void* __stdcall __std_find_trivial_8(const void* _First, const void* _Last, uint64_t _Val) noexcept;
+
+const void* __stdcall __std_min_element_1(const void* _First, const void* _Last, bool _Signed) noexcept;
+const void* __stdcall __std_min_element_2(const void* _First, const void* _Last, bool _Signed) noexcept;
+const void* __stdcall __std_min_element_4(const void* _First, const void* _Last, bool _Signed) noexcept;
+const void* __stdcall __std_min_element_8(const void* _First, const void* _Last, bool _Signed) noexcept;
+const void* __stdcall __std_min_element_f(const void* _First, const void* _Last, bool _Unused) noexcept;
+const void* __stdcall __std_min_element_d(const void* _First, const void* _Last, bool _Unused) noexcept;
+
+const void* __stdcall __std_max_element_1(const void* _First, const void* _Last, bool _Signed) noexcept;
+const void* __stdcall __std_max_element_2(const void* _First, const void* _Last, bool _Signed) noexcept;
+const void* __stdcall __std_max_element_4(const void* _First, const void* _Last, bool _Signed) noexcept;
+const void* __stdcall __std_max_element_8(const void* _First, const void* _Last, bool _Signed) noexcept;
+const void* __stdcall __std_max_element_f(const void* _First, const void* _Last, bool _Unused) noexcept;
+const void* __stdcall __std_max_element_d(const void* _First, const void* _Last, bool _Unused) noexcept;
+
+__declspec(noalias) int8_t __stdcall __std_min_1i(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) uint8_t __stdcall __std_min_1u(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) int16_t __stdcall __std_min_2i(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) uint16_t __stdcall __std_min_2u(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) int32_t __stdcall __std_min_4i(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) uint32_t __stdcall __std_min_4u(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) int64_t __stdcall __std_min_8i(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) uint64_t __stdcall __std_min_8u(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) float __stdcall __std_min_f(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) double __stdcall __std_min_d(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) int8_t __stdcall __std_max_1i(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) uint8_t __stdcall __std_max_1u(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) int16_t __stdcall __std_max_2i(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) uint16_t __stdcall __std_max_2u(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) int32_t __stdcall __std_max_4i(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) uint32_t __stdcall __std_max_4u(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) int64_t __stdcall __std_max_8i(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) uint64_t __stdcall __std_max_8u(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) float __stdcall __std_max_f(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) double __stdcall __std_max_d(const void* _First, const void* _Last) noexcept;
+
+__declspec(noalias) size_t __stdcall __std_mismatch_1(const void* _First1, const void* _First2, size_t _Count) noexcept;
+__declspec(noalias) size_t __stdcall __std_mismatch_2(const void* _First1, const void* _First2, size_t _Count) noexcept;
+__declspec(noalias) size_t __stdcall __std_mismatch_4(const void* _First1, const void* _First2, size_t _Count) noexcept;
+__declspec(noalias) size_t __stdcall __std_mismatch_8(const void* _First1, const void* _First2, size_t _Count) noexcept;
+} // extern "C"
+
+_STD_BEGIN
+template <size_t _Nx>
+__declspec(noalias) void _Reverse_vectorized(void* _First, void* _Last) noexcept {
+    if constexpr (_Nx == 1) {
+        ::__std_reverse_trivially_swappable_1(_First, _Last);
+    } else if constexpr (_Nx == 2) {
+        ::__std_reverse_trivially_swappable_2(_First, _Last);
+    } else if constexpr (_Nx == 4) {
+        ::__std_reverse_trivially_swappable_4(_First, _Last);
+    } else if constexpr (_Nx == 8) {
+        ::__std_reverse_trivially_swappable_8(_First, _Last);
+    } else {
+        _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size
+    }
+}
+
+template <class _Ty, class _TVal>
+__declspec(noalias) size_t _Count_vectorized(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept {
+    if constexpr (is_pointer_v<_TVal> || is_null_pointer_v<_TVal>) {
+#ifdef _WIN64
+        return ::__std_count_trivial_8(_First, _Last, reinterpret_cast<uint64_t>(_Val));
+#else
+        return ::__std_count_trivial_4(_First, _Last, reinterpret_cast<uint32_t>(_Val));
+#endif
+    } else if constexpr (sizeof(_Ty) == 1) {
+        return ::__std_count_trivial_1(_First, _Last, static_cast<uint8_t>(_Val));
+    } else if constexpr (sizeof(_Ty) == 2) {
+        return ::__std_count_trivial_2(_First, _Last, static_cast<uint16_t>(_Val));
+    } else if constexpr (sizeof(_Ty) == 4) {
+        return ::__std_count_trivial_4(_First, _Last, static_cast<uint32_t>(_Val));
+    } else if constexpr (sizeof(_Ty) == 8) {
+        return ::__std_count_trivial_8(_First, _Last, static_cast<uint64_t>(_Val));
+    } else {
+        _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size
+    }
+}
+
+template <class _Ty, class _TVal>
+_Ty* _Find_vectorized(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept {
+    if constexpr (is_pointer_v<_TVal> || is_null_pointer_v<_TVal>) {
+#ifdef _WIN64
+        return const_cast<_Ty*>(
+            static_cast<const _Ty*>(::__std_find_trivial_8(_First, _Last, reinterpret_cast<uint64_t>(_Val))));
+#else
+        return const_cast<_Ty*>(
+            static_cast<const _Ty*>(::__std_find_trivial_4(_First, _Last, reinterpret_cast<uint32_t>(_Val))));
+#endif
+    } else if constexpr (sizeof(_Ty) == 1) {
+        return const_cast<_Ty*>(
+            static_cast<const _Ty*>(::__std_find_trivial_1(_First, _Last, static_cast<uint8_t>(_Val))));
+    } else if constexpr (sizeof(_Ty) == 2) {
+        return const_cast<_Ty*>(
+            static_cast<const _Ty*>(::__std_find_trivial_2(_First, _Last, static_cast<uint16_t>(_Val))));
+    } else if constexpr (sizeof(_Ty) == 4) {
+        return const_cast<_Ty*>(
+            static_cast<const _Ty*>(::__std_find_trivial_4(_First, _Last, static_cast<uint32_t>(_Val))));
+    } else if constexpr (sizeof(_Ty) == 8) {
+        return const_cast<_Ty*>(
+            static_cast<const _Ty*>(::__std_find_trivial_8(_First, _Last, static_cast<uint64_t>(_Val))));
+    } else {
+        _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size
+    }
+}
+
+template <class _Ty>
+_Ty* _Min_element_vectorized(_Ty* const _First, _Ty* const _Last) noexcept {
+    constexpr bool _Signed = is_signed_v<_Ty>;
+
+    if constexpr (is_same_v<remove_const_t<_Ty>, float>) {
+        return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_min_element_f(_First, _Last, false)));
+    } else if constexpr (_Is_any_of_v<remove_const_t<_Ty>, double, long double>) {
+        return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_min_element_d(_First, _Last, false)));
+    } else if constexpr (sizeof(_Ty) == 1) {
+        return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_min_element_1(_First, _Last, _Signed)));
+    } else if constexpr (sizeof(_Ty) == 2) {
+        return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_min_element_2(_First, _Last, _Signed)));
+    } else if constexpr (sizeof(_Ty) == 4) {
+        return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_min_element_4(_First, _Last, _Signed)));
+    } else if constexpr (sizeof(_Ty) == 8) {
+        return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_min_element_8(_First, _Last, _Signed)));
+    } else {
+        _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size
+    }
+}
+
+template <class _Ty>
+_Ty* _Max_element_vectorized(_Ty* const _First, _Ty* const _Last) noexcept {
+    constexpr bool _Signed = is_signed_v<_Ty>;
+
+    if constexpr (is_same_v<remove_const_t<_Ty>, float>) {
+        return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_max_element_f(_First, _Last, false)));
+    } else if constexpr (_Is_any_of_v<remove_const_t<_Ty>, double, long double>) {
+        return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_max_element_d(_First, _Last, false)));
+    } else if constexpr (sizeof(_Ty) == 1) {
+        return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_max_element_1(_First, _Last, _Signed)));
+    } else if constexpr (sizeof(_Ty) == 2) {
+        return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_max_element_2(_First, _Last, _Signed)));
+    } else if constexpr (sizeof(_Ty) == 4) {
+        return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_max_element_4(_First, _Last, _Signed)));
+    } else if constexpr (sizeof(_Ty) == 8) {
+        return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_max_element_8(_First, _Last, _Signed)));
+    } else {
+        _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size
+    }
+}
+
+template <class _Ty>
+auto _Min_vectorized(_Ty* const _First, _Ty* const _Last) noexcept {
+    constexpr bool _Signed = is_signed_v<_Ty>;
+
+    if constexpr (is_pointer_v<_Ty>) {
+#ifdef _WIN64
+        return reinterpret_cast<void*>(::__std_min_8u(_First, _Last));
+#else
+        return reinterpret_cast<void*>(::__std_min_4u(_First, _Last));
+#endif
+    } else if constexpr (is_same_v<remove_const_t<_Ty>, float>) {
+        return ::__std_min_f(_First, _Last);
+    } else if constexpr (_Is_any_of_v<remove_const_t<_Ty>, double, long double>) {
+        return ::__std_min_d(_First, _Last);
+    } else if constexpr (sizeof(_Ty) == 1) {
+        if constexpr (_Signed) {
+            return ::__std_min_1i(_First, _Last);
+        } else {
+            return ::__std_min_1u(_First, _Last);
+        }
+    } else if constexpr (sizeof(_Ty) == 2) {
+        if constexpr (_Signed) {
+            return ::__std_min_2i(_First, _Last);
+        } else {
+            return ::__std_min_2u(_First, _Last);
+        }
+    } else if constexpr (sizeof(_Ty) == 4) {
+        if constexpr (_Signed) {
+            return ::__std_min_4i(_First, _Last);
+        } else {
+            return ::__std_min_4u(_First, _Last);
+        }
+    } else if constexpr (sizeof(_Ty) == 8) {
+        if constexpr (_Signed) {
+            return ::__std_min_8i(_First, _Last);
+        } else {
+            return ::__std_min_8u(_First, _Last);
+        }
+    } else {
+        _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size
+    }
+}
+
+template <class _Ty>
+auto _Max_vectorized(_Ty* const _First, _Ty* const _Last) noexcept {
+    constexpr bool _Signed = is_signed_v<_Ty>;
+
+    if constexpr (is_pointer_v<_Ty>) {
+#ifdef _WIN64
+        return reinterpret_cast<void*>(::__std_max_8u(_First, _Last));
+#else
+        return reinterpret_cast<void*>(::__std_max_4u(_First, _Last));
+#endif
+    } else if constexpr (is_same_v<remove_const_t<_Ty>, float>) {
+        return ::__std_max_f(_First, _Last);
+    } else if constexpr (_Is_any_of_v<remove_const_t<_Ty>, double, long double>) {
+        return ::__std_max_d(_First, _Last);
+    } else if constexpr (sizeof(_Ty) == 1) {
+        if constexpr (_Signed) {
+            return ::__std_max_1i(_First, _Last);
+        } else {
+            return ::__std_max_1u(_First, _Last);
+        }
+    } else if constexpr (sizeof(_Ty) == 2) {
+        if constexpr (_Signed) {
+            return ::__std_max_2i(_First, _Last);
+        } else {
+            return ::__std_max_2u(_First, _Last);
+        }
+    } else if constexpr (sizeof(_Ty) == 4) {
+        if constexpr (_Signed) {
+            return ::__std_max_4i(_First, _Last);
+        } else {
+            return ::__std_max_4u(_First, _Last);
+        }
+    } else if constexpr (sizeof(_Ty) == 8) {
+        if constexpr (_Signed) {
+            return ::__std_max_8i(_First, _Last);
+        } else {
+            return ::__std_max_8u(_First, _Last);
+        }
+    } else {
+        _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size
+    }
+}
+
+template <size_t _Element_size>
+inline size_t // TRANSITION, GH-4496
+    _Mismatch_vectorized(const void* const _First1, const void* const _First2, const size_t _Count) noexcept {
+    if constexpr (_Element_size == 1) {
+        return __std_mismatch_1(_First1, _First2, _Count);
+    } else if constexpr (_Element_size == 2) {
+        return __std_mismatch_2(_First1, _First2, _Count);
+    } else if constexpr (_Element_size == 4) {
+        return __std_mismatch_4(_First1, _First2, _Count);
+    } else if constexpr (_Element_size == 8) {
+        return __std_mismatch_8(_First1, _First2, _Count);
+    } else {
+        _STL_INTERNAL_STATIC_ASSERT(false); // unexpected size
+    }
+}
+_STD_END
+
+#endif // _USE_STD_VECTOR_ALGORITHMS
+
+_STD_BEGIN
+
+template <class _Ty>
+struct _Get_first_parameter;
+
+template <template <class, class...> class _Ty, class _First, class... _Rest>
+struct _Get_first_parameter<_Ty<_First, _Rest...>> { // given _Ty<_First, _Rest...>, extract _First
+    using type = _First;
+};
+
+template <class _Newfirst, class _Ty>
+struct _Replace_first_parameter;
+
+template <class _Newfirst, template <class, class...> class _Ty, class _First, class... _Rest>
+struct _Replace_first_parameter<_Newfirst, _Ty<_First, _Rest...>> { // given _Ty<_First, _Rest...>, replace _First
+    using type = _Ty<_Newfirst, _Rest...>;
+};
+
+template <class _Ty, class = void>
+struct _Get_ptr_difference_type {
+    using type = ptrdiff_t;
+};
+
+template <class _Ty>
+struct _Get_ptr_difference_type<_Ty, void_t<typename _Ty::difference_type>> {
+    using type = typename _Ty::difference_type;
+};
+
+template <class _Ty, class _Other, class = void>
+struct _Get_rebind_alias {
+    using type = typename _Replace_first_parameter<_Other, _Ty>::type;
+};
+
+template <class _Ty, class _Other>
+struct _Get_rebind_alias<_Ty, _Other, void_t<typename _Ty::template rebind<_Other>>> {
+    using type = typename _Ty::template rebind<_Other>;
+};
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty, class... _Types>
+    requires requires(_Ty* _Location, _Types&&... _Args) {
+        ::new (static_cast<void*>(_Location)) _Ty(_STD forward<_Types>(_Args)...); // per LWG-3888
+    }
+constexpr _Ty* construct_at(_Ty* const _Location, _Types&&... _Args) noexcept(
+    noexcept(::new(static_cast<void*>(_Location)) _Ty(_STD forward<_Types>(_Args)...))) /* strengthened */ {
+    _MSVC_CONSTEXPR return ::new (static_cast<void*>(_Location)) _Ty(_STD forward<_Types>(_Args)...);
+}
+#endif // _HAS_CXX20
+
+template <class _Ty, class... _Types>
+_CONSTEXPR20 void _Construct_in_place(_Ty& _Obj, _Types&&... _Args) noexcept(
+    is_nothrow_constructible_v<_Ty, _Types...>) {
+#if _HAS_CXX20
+    if (_STD is_constant_evaluated()) {
+        _STD construct_at(_STD addressof(_Obj), _STD forward<_Types>(_Args)...);
+    } else
+#endif // _HAS_CXX20
+    {
+        ::new (static_cast<void*>(_STD addressof(_Obj))) _Ty(_STD forward<_Types>(_Args)...);
+    }
+}
+
+template <class _Ty>
+void _Default_construct_in_place(_Ty& _Obj) noexcept(is_nothrow_default_constructible_v<_Ty>) {
+    ::new (static_cast<void*>(_STD addressof(_Obj))) _Ty;
+}
+
+template <class _Ty, class _Elem>
+struct _Ptr_traits_base {
+    using pointer         = _Ty;
+    using element_type    = _Elem;
+    using difference_type = typename _Get_ptr_difference_type<_Ty>::type;
+
+    template <class _Other>
+    using rebind = typename _Get_rebind_alias<_Ty, _Other>::type;
+
+    using _Reftype = conditional_t<is_void_v<_Elem>, char, _Elem>&;
+
+    _NODISCARD static _CONSTEXPR20 pointer pointer_to(_Reftype _Val) noexcept(
+        noexcept(_Ty::pointer_to(_Val))) /* strengthened */ { // Per LWG-3454
+        return _Ty::pointer_to(_Val);
+    }
+};
+
+template <class, class = void, class = void>
+struct _Ptr_traits_sfinae_layer {};
+
+template <class _Ty, class _Uty>
+struct _Ptr_traits_sfinae_layer<_Ty, _Uty, void_t<typename _Get_first_parameter<_Ty>::type>>
+    : _Ptr_traits_base<_Ty, typename _Get_first_parameter<_Ty>::type> {};
+
+template <class _Ty>
+struct _Ptr_traits_sfinae_layer<_Ty, void_t<typename _Ty::element_type>, void>
+    : _Ptr_traits_base<_Ty, typename _Ty::element_type> {};
+
+_EXPORT_STD template <class _Ty>
+struct pointer_traits : _Ptr_traits_sfinae_layer<_Ty> {};
+
+template <class _Ty>
+struct pointer_traits<_Ty*> {
+    using pointer         = _Ty*;
+    using element_type    = _Ty;
+    using difference_type = ptrdiff_t;
+
+    template <class _Other>
+    using rebind = _Other*;
+
+    using _Reftype = conditional_t<is_void_v<_Ty>, char, _Ty>&;
+
+    _NODISCARD static _CONSTEXPR20 pointer pointer_to(_Reftype _Val) noexcept {
+        return _STD addressof(_Val);
+    }
+};
+
+#if _HAS_CXX20
+template <class _Ty>
+concept _Has_to_address = requires(const _Ty& _Val) {
+    typename pointer_traits<_Ty>;
+    pointer_traits<_Ty>::to_address(_Val);
+};
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD constexpr _Ty* to_address(_Ty* const _Val) noexcept {
+    static_assert(!is_function_v<_Ty>, "N4950 [pointer.conversion]/1: Mandates: T is not a function type.");
+    return _Val;
+}
+
+_EXPORT_STD template <class _Ptr>
+_NODISCARD constexpr auto to_address(const _Ptr& _Val) noexcept {
+    if constexpr (_Has_to_address<_Ptr>) {
+        return pointer_traits<_Ptr>::to_address(_Val);
+    } else {
+        return _STD to_address(_Val.operator->()); // plain pointer overload must come first
+    }
+}
+
+_EXPORT_STD struct identity {
+    template <class _Ty>
+    _NODISCARD constexpr _Ty&& operator()(_Ty&& _Left) const noexcept {
+        return _STD forward<_Ty>(_Left);
+    }
+
+    using is_transparent = int;
+};
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Ty = void>
+struct plus {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = _Ty;
+
+    _NODISCARD constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
+        return _Left + _Right;
+    }
+};
+
+_EXPORT_STD template <class _Ty = void>
+struct minus {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = _Ty;
+
+    _NODISCARD constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
+        return _Left - _Right;
+    }
+};
+
+_EXPORT_STD template <class _Ty = void>
+struct multiplies {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = _Ty;
+
+    _NODISCARD constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
+        return _Left * _Right;
+    }
+};
+
+_EXPORT_STD template <class _Ty = void>
+struct equal_to {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = bool;
+
+    _NODISCARD constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left == _Right))) /* strengthened */ {
+        return _Left == _Right;
+    }
+};
+
+_EXPORT_STD template <class _Ty = void>
+struct not_equal_to {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = bool;
+
+    _NODISCARD constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left != _Right))) /* strengthened */ {
+        return _Left != _Right;
+    }
+};
+
+_EXPORT_STD template <class _Ty = void>
+struct greater {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = bool;
+
+    _NODISCARD constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left > _Right))) /* strengthened */ {
+        return _Left > _Right;
+    }
+};
+
+_EXPORT_STD template <class _Ty = void>
+struct greater_equal {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = bool;
+
+    _NODISCARD constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left >= _Right))) /* strengthened */ {
+        return _Left >= _Right;
+    }
+};
+
+_EXPORT_STD template <class _Ty = void>
+struct less_equal {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = bool;
+
+    _NODISCARD constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left <= _Right))) /* strengthened */ {
+        return _Left <= _Right;
+    }
+};
+
+template <>
+struct plus<void> {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        noexcept(noexcept(static_cast<_Ty1&&>(_Left) + static_cast<_Ty2&&>(_Right))) // strengthened
+        -> decltype(static_cast<_Ty1&&>(_Left) + static_cast<_Ty2&&>(_Right)) {
+        return static_cast<_Ty1&&>(_Left) + static_cast<_Ty2&&>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+template <>
+struct minus<void> {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        noexcept(noexcept(static_cast<_Ty1&&>(_Left) - static_cast<_Ty2&&>(_Right))) // strengthened
+        -> decltype(static_cast<_Ty1&&>(_Left) - static_cast<_Ty2&&>(_Right)) {
+        return static_cast<_Ty1&&>(_Left) - static_cast<_Ty2&&>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+template <>
+struct multiplies<void> {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        noexcept(noexcept(static_cast<_Ty1&&>(_Left) * static_cast<_Ty2&&>(_Right))) // strengthened
+        -> decltype(static_cast<_Ty1&&>(_Left) * static_cast<_Ty2&&>(_Right)) {
+        return static_cast<_Ty1&&>(_Left) * static_cast<_Ty2&&>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+template <>
+struct equal_to<void> {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        noexcept(noexcept(static_cast<_Ty1&&>(_Left) == static_cast<_Ty2&&>(_Right))) // strengthened
+        -> decltype(static_cast<_Ty1&&>(_Left) == static_cast<_Ty2&&>(_Right)) {
+        return static_cast<_Ty1&&>(_Left) == static_cast<_Ty2&&>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+template <>
+struct not_equal_to<void> {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        noexcept(noexcept(static_cast<_Ty1&&>(_Left) != static_cast<_Ty2&&>(_Right))) // strengthened
+        -> decltype(static_cast<_Ty1&&>(_Left) != static_cast<_Ty2&&>(_Right)) {
+        return static_cast<_Ty1&&>(_Left) != static_cast<_Ty2&&>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+template <>
+struct greater<void> {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        noexcept(noexcept(static_cast<_Ty1&&>(_Left) > static_cast<_Ty2&&>(_Right))) // strengthened
+        -> decltype(static_cast<_Ty1&&>(_Left) > static_cast<_Ty2&&>(_Right)) {
+        return static_cast<_Ty1&&>(_Left) > static_cast<_Ty2&&>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+template <>
+struct greater_equal<void> {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        noexcept(noexcept(static_cast<_Ty1&&>(_Left) >= static_cast<_Ty2&&>(_Right))) // strengthened
+        -> decltype(static_cast<_Ty1&&>(_Left) >= static_cast<_Ty2&&>(_Right)) {
+        return static_cast<_Ty1&&>(_Left) >= static_cast<_Ty2&&>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+template <>
+struct less_equal<void> {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        noexcept(noexcept(static_cast<_Ty1&&>(_Left) <= static_cast<_Ty2&&>(_Right))) // strengthened
+        -> decltype(static_cast<_Ty1&&>(_Left) <= static_cast<_Ty2&&>(_Right)) {
+        return static_cast<_Ty1&&>(_Left) <= static_cast<_Ty2&&>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+template <class _Fx>
+struct _Ref_fn { // pass function object by value as a reference
+    // _Ref_fn is an aggregate so it can be enregistered, unlike reference_wrapper
+
+    template <class... _Args>
+    constexpr decltype(auto) operator()(_Args&&... _Vals) noexcept(
+        _Select_invoke_traits<_Fx&, _Args...>::_Is_nothrow_invocable::value) { // forward function call operator
+        if constexpr (is_member_pointer_v<_Fx>) {
+            return _STD invoke(_Fn, _STD forward<_Args>(_Vals)...);
+        } else {
+            return _Fn(_STD forward<_Args>(_Vals)...);
+        }
+    }
+
+    _Fx& _Fn;
+};
+
+template <class _Fn>
+_NODISCARD constexpr auto _Pass_fn(_Fn& _Func) noexcept {
+    constexpr bool _Pass_by_value = conjunction_v<bool_constant<sizeof(_Fn) <= sizeof(void*)>,
+        is_trivially_copy_constructible<_Fn>, is_trivially_destructible<_Fn>>;
+    if constexpr (_Pass_by_value) {
+        return _Func;
+    } else {
+        return _Ref_fn<_Fn>{_Func}; // pass functor by "reference"
+    }
+}
+
+#if _HAS_CXX23
+_EXPORT_STD template <class _Result_type, class _Callable, class... _Types>
+    requires is_invocable_r_v<_Result_type, _Callable, _Types...>
+_NODISCARD constexpr _Result_type invoke_r(_Callable&& _Obj, _Types&&... _Args) noexcept(
+    is_nothrow_invocable_r_v<_Result_type, _Callable, _Types...>) {
+    if constexpr (is_void_v<_Result_type>) {
+        (void) _STD invoke(static_cast<_Callable&&>(_Obj), static_cast<_Types&&>(_Args)...);
+    } else {
+        return _STD invoke(static_cast<_Callable&&>(_Obj), static_cast<_Types&&>(_Args)...);
+    }
+}
+#endif // _HAS_CXX23
+
+struct _Unused_parameter { // generic unused parameter struct
+    constexpr _Unused_parameter() noexcept = default;
+    template <class _Ty>
+    constexpr _Unused_parameter(_Ty&&) noexcept {}
+};
+
+template <class _Ty, class = void> // checks whether a container/view is a non-customized specialization
+constexpr bool _Has_unchecked_begin_end = false;
+
+template <class _Ty>
+constexpr bool _Has_unchecked_begin_end<_Ty,
+    void_t<decltype(_STD declval<_Ty&>()._Unchecked_begin()), decltype(_STD declval<_Ty&>()._Unchecked_end())>> = true;
+
+template <class _Ty>
+using _Algorithm_int_t = conditional_t<is_integral_v<_Ty>, _Ty, ptrdiff_t>;
+
+#if _HAS_CXX20
+template <class _Ty>
+concept _Destructible_object = is_object_v<_Ty> && destructible<_Ty>;
+
+template <template <class...> class _Template, class... _Args>
+void _Derived_from_specialization_impl(const _Template<_Args...>&);
+
+template <class _Ty, template <class...> class _Template>
+concept _Derived_from_specialization_of = requires(const _Ty& _Obj) {
+    _STD _Derived_from_specialization_impl<_Template>(_Obj); // qualified: avoid ADL, handle incomplete types
+};
+
+namespace ranges {
+    namespace _Iter_move {
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1681199
+        void iter_move() = delete; // Block unqualified name lookup
+#else // ^^^ no workaround / workaround vvv
+        void iter_move();
+#endif // ^^^ workaround ^^^
+
+        template <class _Ty>
+        concept _Has_ADL = _Has_class_or_enum_type<_Ty> && requires(_Ty&& __t) {
+            iter_move(static_cast<_Ty&&>(__t)); // intentional ADL
+        };
+
+        template <class _Ty>
+        concept _Can_deref = requires(_Ty&& __t) { *static_cast<_Ty&&>(__t); };
+
+        class _Cpo {
+        private:
+            enum class _St { _None, _Custom, _Fallback };
+
+            template <class _Ty>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                if constexpr (_Has_ADL<_Ty>) {
+                    return {_St::_Custom, noexcept(iter_move(_STD declval<_Ty>()))}; // intentional ADL
+                } else if constexpr (_Can_deref<_Ty>) {
+                    return {_St::_Fallback, noexcept(*_STD declval<_Ty>())};
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _Ty>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();
+
+        public:
+            template <class _Ty>
+                requires (_Choice<_Ty>._Strategy != _St::_None)
+            _NODISCARD _STATIC_CALL_OPERATOR constexpr decltype(auto) operator()(_Ty && _Val) _CONST_CALL_OPERATOR
+                noexcept(_Choice<_Ty>._No_throw) {
+                constexpr _St _Strat = _Choice<_Ty>._Strategy;
+
+                if constexpr (_Strat == _St::_Custom) {
+                    return iter_move(static_cast<_Ty&&>(_Val)); // intentional ADL
+                } else if constexpr (_Strat == _St::_Fallback) {
+                    using _Ref = decltype(*static_cast<_Ty&&>(_Val));
+                    if constexpr (is_lvalue_reference_v<_Ref>) {
+                        return _STD move(*static_cast<_Ty&&>(_Val));
+                    } else {
+                        return *static_cast<_Ty&&>(_Val);
+                    }
+                } else {
+                    _STL_INTERNAL_STATIC_ASSERT(false); // unexpected strategy
+                }
+            }
+        };
+    } // namespace _Iter_move
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Iter_move::_Cpo iter_move;
+    }
+} // namespace ranges
+
+// iter_swap defined below since it depends on indirectly_movable_storable
+
+_EXPORT_STD template <class _Ty>
+    requires _Dereferenceable<_Ty> && requires(_Ty& __t) {
+        { _RANGES iter_move(__t) } -> _Can_reference;
+    }
+using iter_rvalue_reference_t = decltype(_RANGES iter_move(_STD declval<_Ty&>()));
+
+template <class _It>
+concept _Indirectly_readable_impl =
+    requires(const _It __i) {
+        typename iter_value_t<_It>;
+        typename iter_reference_t<_It>;
+        typename iter_rvalue_reference_t<_It>;
+        { *__i } -> same_as<iter_reference_t<_It>>;
+        { _RANGES iter_move(__i) } -> same_as<iter_rvalue_reference_t<_It>>;
+    } && common_reference_with<iter_reference_t<_It>&&, iter_value_t<_It>&>
+    && common_reference_with<iter_reference_t<_It>&&, iter_rvalue_reference_t<_It>&&>
+    && common_reference_with<iter_rvalue_reference_t<_It>&&, const iter_value_t<_It>&>;
+
+_EXPORT_STD template <class _It>
+concept indirectly_readable = _Indirectly_readable_impl<remove_cvref_t<_It>>;
+
+template <class _Ty>
+struct _Indirect_value_impl {
+    using type = iter_value_t<_Ty>&;
+};
+
+template <indirectly_readable _It>
+using _Indirect_value_t = _Indirect_value_impl<_It>::type;
+
+_EXPORT_STD template <indirectly_readable _Ty>
+using iter_common_reference_t = common_reference_t<iter_reference_t<_Ty>, _Indirect_value_t<_Ty>>;
+
+_EXPORT_STD template <class _It, class _Ty>
+concept indirectly_writable = requires(_It&& __i, _Ty&& __t) {
+    *__i                                                                = static_cast<_Ty&&>(__t);
+    *static_cast<_It&&>(__i)                                            = static_cast<_Ty&&>(__t);
+    const_cast<const iter_reference_t<_It>&&>(*__i)                     = static_cast<_Ty&&>(__t);
+    const_cast<const iter_reference_t<_It>&&>(*static_cast<_It&&>(__i)) = static_cast<_Ty&&>(__t);
+};
+
+template <bool _Is_integer_class>
+struct _Make_unsigned_like_impl {
+    template <class _Ty>
+    using _Apply = _Ty::_Unsigned_type;
+};
+template <>
+struct _Make_unsigned_like_impl<false> {
+    template <class _Ty>
+    using _Apply = make_unsigned_t<_Ty>;
+};
+
+template <class _Ty>
+using _Make_unsigned_like_t = _Make_unsigned_like_impl<_Integer_class<_Ty>>::template _Apply<_Ty>;
+
+template <_Integer_like _Ty>
+_NODISCARD constexpr auto _To_unsigned_like(const _Ty _Value) noexcept {
+    return static_cast<_Make_unsigned_like_t<_Ty>>(_Value);
+}
+
+template <bool _Is_integer_class>
+struct _Make_signed_like_impl {
+    template <class _Ty>
+    using _Apply = _Ty::_Signed_type;
+};
+template <>
+struct _Make_signed_like_impl<false> {
+    template <class _Ty>
+    using _Apply = make_signed_t<_Ty>;
+};
+
+template <class _Ty>
+using _Make_signed_like_t = _Make_signed_like_impl<_Integer_class<_Ty>>::template _Apply<_Ty>;
+
+_EXPORT_STD template <class _Ty>
+concept incrementable = regular<_Ty> && weakly_incrementable<_Ty> && requires(_Ty __t) {
+    { __t++ } -> same_as<_Ty>;
+};
+
+template <bool _Iterator_category_present>
+struct _Iter_concept_impl2 {
+    template <class _It, class _Traits>
+    using _Apply = _Traits::iterator_category;
+};
+template <>
+struct _Iter_concept_impl2<false> {
+    template <class _It, class _Traits>
+        requires _Is_from_primary<iterator_traits<_It>>
+    using _Apply = random_access_iterator_tag;
+};
+
+template <bool _Iterator_concept_present>
+struct _Iter_concept_impl1 {
+    template <class _It, class _Traits>
+    using _Apply = _Traits::iterator_concept;
+};
+template <>
+struct _Iter_concept_impl1<false> {
+    template <class _It, class _Traits>
+    using _Apply = _Iter_concept_impl2<_Has_member_iterator_category<_Traits>>::template _Apply<_It, _Traits>;
+};
+
+template <class _It, class _Traits = conditional_t<_Is_from_primary<iterator_traits<_It>>, _It, iterator_traits<_It>>>
+using _Iter_concept = _Iter_concept_impl1<_Has_member_iterator_concept<_Traits>>::template _Apply<_It, _Traits>;
+
+// clang-format off
+_EXPORT_STD template <class _It>
+concept input_iterator = input_or_output_iterator<_It> && indirectly_readable<_It>
+    && requires { typename _Iter_concept<_It>; }
+    && derived_from<_Iter_concept<_It>, input_iterator_tag>;
+
+_EXPORT_STD template <class _It, class _Ty>
+concept output_iterator = input_or_output_iterator<_It> && indirectly_writable<_It, _Ty>
+    && requires(_It __i, _Ty&& __t) {
+        *__i++ = static_cast<_Ty&&>(__t);
+    };
+
+_EXPORT_STD template <class _It>
+concept forward_iterator = input_iterator<_It> && derived_from<_Iter_concept<_It>, forward_iterator_tag>
+    && incrementable<_It> && sentinel_for<_It, _It>;
+
+_EXPORT_STD template <class _It>
+concept bidirectional_iterator = forward_iterator<_It> && derived_from<_Iter_concept<_It>, bidirectional_iterator_tag>
+    && requires(_It __i) {
+        { --__i } -> same_as<_It&>;
+        { __i-- } -> same_as<_It>;
+    };
+
+_EXPORT_STD template <class _It>
+concept random_access_iterator = bidirectional_iterator<_It>
+    && derived_from<_Iter_concept<_It>, random_access_iterator_tag> && totally_ordered<_It>
+    && sized_sentinel_for<_It, _It> && requires(_It __i, const _It __j, const iter_difference_t<_It> __n) {
+        { __i += __n } -> same_as<_It&>;
+        { __j + __n } -> same_as<_It>;
+        { __n + __j } -> same_as<_It>;
+        { __i -= __n } -> same_as<_It&>;
+        { __j - __n } -> same_as<_It>;
+        { __j[__n] } -> same_as<iter_reference_t<_It>>;
+    };
+
+_EXPORT_STD template <class _It>
+concept contiguous_iterator = random_access_iterator<_It>
+    && derived_from<_Iter_concept<_It>, contiguous_iterator_tag>
+    && is_lvalue_reference_v<iter_reference_t<_It>>
+    && same_as<iter_value_t<_It>, remove_cvref_t<iter_reference_t<_It>>>
+    && requires(const _It& __i) {
+        { _STD to_address(__i) } -> same_as<add_pointer_t<iter_reference_t<_It>>>;
+    };
+// clang-format on
+
+_EXPORT_STD template <class _Fn, class _It>
+concept indirectly_unary_invocable = indirectly_readable<_It> && copy_constructible<_Fn>
+                                  && invocable<_Fn&, _Indirect_value_t<_It>> && invocable<_Fn&, iter_reference_t<_It>>
+                                  && common_reference_with<invoke_result_t<_Fn&, _Indirect_value_t<_It>>,
+                                      invoke_result_t<_Fn&, iter_reference_t<_It>>>;
+
+_EXPORT_STD template <class _Fn, class _It>
+concept indirectly_regular_unary_invocable =
+    indirectly_readable<_It> && copy_constructible<_Fn> && regular_invocable<_Fn&, _Indirect_value_t<_It>>
+    && regular_invocable<_Fn&, iter_reference_t<_It>>
+    && common_reference_with<invoke_result_t<_Fn&, _Indirect_value_t<_It>>,
+        invoke_result_t<_Fn&, iter_reference_t<_It>>>;
+
+_EXPORT_STD template <class _Fn, class _It>
+concept indirect_unary_predicate = indirectly_readable<_It> && copy_constructible<_Fn>
+                                && predicate<_Fn&, _Indirect_value_t<_It>> && predicate<_Fn&, iter_reference_t<_It>>;
+
+_EXPORT_STD template <class _Fn, class _It1, class _It2>
+concept indirect_binary_predicate = indirectly_readable<_It1> && indirectly_readable<_It2> && copy_constructible<_Fn>
+                                 && predicate<_Fn&, _Indirect_value_t<_It1>, _Indirect_value_t<_It2>>
+                                 && predicate<_Fn&, _Indirect_value_t<_It1>, iter_reference_t<_It2>>
+                                 && predicate<_Fn&, iter_reference_t<_It1>, _Indirect_value_t<_It2>>
+                                 && predicate<_Fn&, iter_reference_t<_It1>, iter_reference_t<_It2>>;
+
+_EXPORT_STD template <class _Fn, class _It1, class _It2 = _It1>
+concept indirect_equivalence_relation =
+    indirectly_readable<_It1> && indirectly_readable<_It2> && copy_constructible<_Fn>
+    && equivalence_relation<_Fn&, _Indirect_value_t<_It1>, _Indirect_value_t<_It2>>
+    && equivalence_relation<_Fn&, _Indirect_value_t<_It1>, iter_reference_t<_It2>>
+    && equivalence_relation<_Fn&, iter_reference_t<_It1>, _Indirect_value_t<_It2>>
+    && equivalence_relation<_Fn&, iter_reference_t<_It1>, iter_reference_t<_It2>>;
+
+_EXPORT_STD template <class _Fn, class _It1, class _It2 = _It1>
+concept indirect_strict_weak_order = indirectly_readable<_It1> && indirectly_readable<_It2> && copy_constructible<_Fn>
+                                  && strict_weak_order<_Fn&, _Indirect_value_t<_It1>, _Indirect_value_t<_It2>>
+                                  && strict_weak_order<_Fn&, _Indirect_value_t<_It1>, iter_reference_t<_It2>>
+                                  && strict_weak_order<_Fn&, iter_reference_t<_It1>, _Indirect_value_t<_It2>>
+                                  && strict_weak_order<_Fn&, iter_reference_t<_It1>, iter_reference_t<_It2>>;
+
+_EXPORT_STD template <class _Fn, class... _Its>
+    requires (indirectly_readable<_Its> && ...) && invocable<_Fn, iter_reference_t<_Its>...>
+using indirect_result_t = invoke_result_t<_Fn, iter_reference_t<_Its>...>;
+
+template <class _It>
+struct _Projected_difference_type_impl {
+    struct _Base {};
+};
+
+template <weakly_incrementable _It>
+struct _Projected_difference_type_impl<_It> {
+    struct _Base {
+        using difference_type = iter_difference_t<_It>;
+    };
+};
+
+template <class _It, class _Proj>
+struct _Projected_impl {
+    struct _Type : _Projected_difference_type_impl<_It>::_Base {
+        using _Iterator   = _It;
+        using _Projection = _Proj;
+
+        using value_type = remove_cvref_t<indirect_result_t<_Proj&, _It>>;
+        [[noreturn]] indirect_result_t<_Proj&, _It> operator*() const {
+            _CSTD abort(); // shouldn't be called, see GH-3888
+        }
+    };
+};
+
+_EXPORT_STD template <indirectly_readable _It, indirectly_regular_unary_invocable<_It> _Proj>
+using projected = _Projected_impl<_It, _Proj>::_Type;
+
+template <class _Ty>
+concept _Projected_specialization = same_as<_Ty, projected<typename _Ty::_Iterator, typename _Ty::_Projection>>;
+
+template <_Projected_specialization _ProjTy>
+struct _Indirect_value_impl<_ProjTy> {
+    using type = invoke_result_t<typename _ProjTy::_Projection&, _Indirect_value_t<typename _ProjTy::_Iterator>>;
+};
+
+_EXPORT_STD template <class _In, class _Out>
+concept indirectly_movable = indirectly_readable<_In> && indirectly_writable<_Out, iter_rvalue_reference_t<_In>>;
+
+_EXPORT_STD template <class _In, class _Out>
+concept indirectly_movable_storable =
+    indirectly_movable<_In, _Out> && indirectly_writable<_Out, iter_value_t<_In>> && movable<iter_value_t<_In>>
+    && constructible_from<iter_value_t<_In>, iter_rvalue_reference_t<_In>>
+    && assignable_from<iter_value_t<_In>&, iter_rvalue_reference_t<_In>>;
+
+_EXPORT_STD template <class _In, class _Out>
+concept indirectly_copyable = indirectly_readable<_In> && indirectly_writable<_Out, iter_reference_t<_In>>;
+
+// clang-format off
+_EXPORT_STD template <class _In, class _Out>
+concept indirectly_copyable_storable = indirectly_copyable<_In, _Out>
+    && indirectly_writable<_Out, iter_value_t<_In>&>
+    && indirectly_writable<_Out, const iter_value_t<_In>&>
+    && indirectly_writable<_Out, iter_value_t<_In>&&>
+    && indirectly_writable<_Out, const iter_value_t<_In>&&>
+    && copyable<iter_value_t<_In>>
+    && constructible_from<iter_value_t<_In>, iter_reference_t<_In>>
+    && assignable_from<iter_value_t<_In>&, iter_reference_t<_In>>;
+// clang-format on
+
+namespace ranges {
+    namespace _Iter_swap {
+        template <class _Ty1, class _Ty2>
+        void iter_swap(_Ty1, _Ty2) = delete;
+
+        // clang-format off
+        template <class _Ty1, class _Ty2>
+        concept _Has_ADL = (_Has_class_or_enum_type<_Ty1> || _Has_class_or_enum_type<_Ty2>)
+            && requires(_Ty1&& __t1, _Ty2&& __t2) {
+                iter_swap(static_cast<_Ty1&&>(__t1), static_cast<_Ty2&&>(__t2)); // intentional ADL
+            };
+        // clang-format on
+
+        template <class _Ty1, class _Ty2>
+        concept _Can_swap_references =
+            indirectly_readable<remove_reference_t<_Ty1>> && indirectly_readable<remove_reference_t<_Ty2>>
+            && swappable_with<iter_reference_t<_Ty1>, iter_reference_t<_Ty2>>;
+
+        template <class _Ty1, class _Ty2>
+        concept _Symmetric_indirectly_movable_storable =
+            indirectly_movable_storable<remove_reference_t<_Ty1>, remove_reference_t<_Ty2>>
+            && indirectly_movable_storable<remove_reference_t<_Ty2>, remove_reference_t<_Ty1>>;
+
+        template <class _Xty, class _Yty>
+        _NODISCARD constexpr iter_value_t<remove_reference_t<_Xty>> _Iter_exchange_move(_Xty&& _XVal,
+            _Yty&& _YVal) noexcept(noexcept(iter_value_t<remove_reference_t<_Xty>>(_RANGES iter_move(_XVal)))) {
+            iter_value_t<remove_reference_t<_Xty>> _Tmp(_RANGES iter_move(_XVal));
+            *_XVal = _RANGES iter_move(_YVal);
+            return _Tmp;
+        }
+
+        class _Cpo {
+        private:
+            enum class _St { _None, _Custom, _Swap, _Exchange };
+
+            template <class _Ty1, class _Ty2>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                if constexpr (_Has_ADL<_Ty1, _Ty2>) {
+                    return {_St::_Custom,
+                        noexcept(iter_swap(_STD declval<_Ty1>(), _STD declval<_Ty2>()))}; // intentional ADL
+                } else if constexpr (_Can_swap_references<_Ty1, _Ty2>) {
+                    return {_St::_Swap, noexcept(_RANGES swap(*_STD declval<_Ty1>(), *_STD declval<_Ty2>()))};
+                } else if constexpr (_Symmetric_indirectly_movable_storable<_Ty1, _Ty2>) {
+                    constexpr auto _Nothrow = noexcept(*_STD declval<_Ty1>() = _Iter_swap::_Iter_exchange_move(
+                                                           _STD declval<_Ty2>(), _STD declval<_Ty1>()));
+                    return {_St::_Exchange, _Nothrow};
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _Ty1, class _Ty2>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty1, _Ty2>();
+
+        public:
+            template <class _Ty1, class _Ty2>
+                requires (_Choice<_Ty1, _Ty2>._Strategy != _St::_None)
+            _STATIC_CALL_OPERATOR constexpr void operator()(_Ty1&& _Val1, _Ty2&& _Val2) _CONST_CALL_OPERATOR
+                noexcept(_Choice<_Ty1, _Ty2>._No_throw) {
+                constexpr _St _Strat = _Choice<_Ty1, _Ty2>._Strategy;
+
+                if constexpr (_Strat == _St::_Custom) {
+                    (void) iter_swap(static_cast<_Ty1&&>(_Val1), static_cast<_Ty2&&>(_Val2)); // intentional ADL
+                } else if constexpr (_Strat == _St::_Swap) {
+                    _RANGES swap(*static_cast<_Ty1&&>(_Val1), *static_cast<_Ty2&&>(_Val2));
+                } else if constexpr (_Strat == _St::_Exchange) {
+                    *static_cast<_Ty1&&>(_Val1) =
+                        _Iter_swap::_Iter_exchange_move(static_cast<_Ty2&&>(_Val2), static_cast<_Ty1&&>(_Val1));
+                } else {
+                    _STL_INTERNAL_STATIC_ASSERT(false); // unexpected strategy
+                }
+            }
+        };
+    } // namespace _Iter_swap
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Iter_swap::_Cpo iter_swap;
+    }
+} // namespace ranges
+
+_EXPORT_STD template <class _It1, class _It2 = _It1>
+concept indirectly_swappable =
+    indirectly_readable<_It1> && indirectly_readable<_It2> && requires(const _It1 __i1, const _It2 __i2) {
+        _RANGES iter_swap(__i1, __i1);
+        _RANGES iter_swap(__i2, __i2);
+        _RANGES iter_swap(__i1, __i2);
+        _RANGES iter_swap(__i2, __i1);
+    };
+
+_EXPORT_STD template <class _It1, class _It2, class _Rel, class _Proj1 = identity, class _Proj2 = identity>
+concept indirectly_comparable = indirect_binary_predicate<_Rel, projected<_It1, _Proj1>, projected<_It2, _Proj2>>;
+
+_EXPORT_STD template <class _It>
+concept permutable = forward_iterator<_It> && indirectly_movable_storable<_It, _It> && indirectly_swappable<_It, _It>;
+
+namespace ranges {
+    _EXPORT_STD struct less;
+} // namespace ranges
+
+_EXPORT_STD template <class _It1, class _It2, class _Out, class _Pr = ranges::less, class _Pj1 = identity,
+    class _Pj2 = identity>
+concept mergeable =
+    input_iterator<_It1> && input_iterator<_It2> && weakly_incrementable<_Out> && indirectly_copyable<_It1, _Out>
+    && indirectly_copyable<_It2, _Out> && indirect_strict_weak_order<_Pr, projected<_It1, _Pj1>, projected<_It2, _Pj2>>;
+
+_EXPORT_STD template <class _It, class _Pr = ranges::less, class _Proj = identity>
+concept sortable = permutable<_It> && indirect_strict_weak_order<_Pr, projected<_It, _Proj>>;
+
+template <class _Iter>
+using _Iter_ref_t = iter_reference_t<_Iter>;
+
+template <class _Iter>
+using _Iter_value_t = iter_value_t<_Iter>;
+
+template <class _Iter>
+using _Iter_diff_t = iter_difference_t<_Iter>;
+
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Iter>
+using _Iter_ref_t = typename iterator_traits<_Iter>::reference;
+
+template <class _Iter>
+using _Iter_value_t = typename iterator_traits<_Iter>::value_type;
+
+template <class _Iter>
+using _Iter_diff_t = typename iterator_traits<_Iter>::difference_type;
+
+template <class _Ty>
+using _Make_unsigned_like_t = make_unsigned_t<_Ty>;
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+template <class... _Iters>
+using _Common_diff_t = common_type_t<_Iter_diff_t<_Iters>...>;
+
+template <class _Iter>
+using _Iter_cat_t = typename iterator_traits<_Iter>::iterator_category;
+
+#if _HAS_CXX20
+template <class _Ty>
+concept _Iterator_for_container = requires { typename _Iter_cat_t<_Ty>; };
+
+template <class _Ty>
+constexpr bool _Is_iterator_v = _Iterator_for_container<_Ty>;
+
+template <class _Ty>
+struct _Is_iterator : bool_constant<_Iterator_for_container<_Ty>> {};
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Ty, class = void>
+constexpr bool _Is_iterator_v = false;
+
+template <class _Ty>
+constexpr bool _Is_iterator_v<_Ty, void_t<_Iter_cat_t<_Ty>>> = true;
+
+template <class _Ty>
+struct _Is_iterator : bool_constant<_Is_iterator_v<_Ty>> {};
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+template <class _Iter>
+constexpr bool _Is_cpp17_input_iter_v = is_convertible_v<_Iter_cat_t<_Iter>, input_iterator_tag>;
+
+template <class _Iter>
+constexpr bool _Is_ranges_input_iter_v =
+#if _HAS_CXX20
+    (input_iterator<_Iter> && sentinel_for<_Iter, _Iter>) ||
+#endif
+    _Is_cpp17_input_iter_v<_Iter>;
+
+template <class _Iter>
+constexpr bool _Is_cpp17_fwd_iter_v = is_convertible_v<_Iter_cat_t<_Iter>, forward_iterator_tag>;
+
+template <class _Iter>
+constexpr bool _Is_ranges_fwd_iter_v =
+#if _HAS_CXX20
+    forward_iterator<_Iter> ||
+#endif
+    _Is_cpp17_fwd_iter_v<_Iter>;
+
+template <class _Iter>
+constexpr bool _Is_cpp17_bidi_iter_v = is_convertible_v<_Iter_cat_t<_Iter>, bidirectional_iterator_tag>;
+
+template <class _Iter>
+constexpr bool _Is_ranges_bidi_iter_v =
+#if _HAS_CXX20
+    bidirectional_iterator<_Iter> ||
+#endif
+    _Is_cpp17_bidi_iter_v<_Iter>;
+
+template <class _Iter>
+constexpr bool _Is_cpp17_random_iter_v = is_convertible_v<_Iter_cat_t<_Iter>, random_access_iterator_tag>;
+
+template <class _Iter>
+constexpr bool _Is_ranges_random_iter_v =
+#if _HAS_CXX20
+    random_access_iterator<_Iter> ||
+#endif
+    _Is_cpp17_random_iter_v<_Iter>;
+
+#define _REQUIRE_CPP17_MUTABLE_ITERATOR(_Iter) \
+    static_assert(_Is_cpp17_fwd_iter_v<_Iter>, \
+        "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators or stronger.")
+
+#define _REQUIRE_CPP17_MUTABLE_BIDIRECTIONAL_ITERATOR(_Iter) \
+    static_assert(_Is_cpp17_bidi_iter_v<_Iter>,              \
+        "This algorithm requires that mutable iterators be Cpp17BidirectionalIterators or stronger.")
+
+template <class, class = void>
+struct _Is_checked_helper {}; // default definition, no longer used, retained due to pseudo-documentation
+
+#if _ITERATOR_DEBUG_LEVEL != 0
+template <class _Ty>
+constexpr void _Verify_range(const _Ty* const _First, const _Ty* const _Last) noexcept {
+    // special case range verification for pointers
+    _STL_VERIFY(_First <= _Last, "transposed pointer range");
+}
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+template <class _Iter, class = void>
+constexpr bool _Allow_inheriting_unwrap_v = true;
+
+template <class _Iter>
+constexpr bool _Allow_inheriting_unwrap_v<_Iter, void_t<typename _Iter::_Prevent_inheriting_unwrap>> =
+    is_same_v<_Iter, typename _Iter::_Prevent_inheriting_unwrap>;
+
+template <class _Iter, class _Sentinel = _Iter, class = void>
+constexpr bool _Range_verifiable_v = false;
+
+template <class _Iter, class _Sentinel>
+constexpr bool _Range_verifiable_v<_Iter, _Sentinel,
+    void_t<decltype(_Verify_range(_STD declval<const _Iter&>(), _STD declval<const _Sentinel&>()))>> =
+    _Allow_inheriting_unwrap_v<_Iter>;
+
+template <class _Iter, class _Sentinel>
+constexpr void _Adl_verify_range(const _Iter& _First, const _Sentinel& _Last) {
+    // check that [_First, _Last) forms an iterator range
+    if constexpr (is_pointer_v<_Iter> && is_pointer_v<_Sentinel>) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_First <= _Last, "transposed pointer range");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+    } else if constexpr (_Range_verifiable_v<_Iter, _Sentinel>) {
+        _Verify_range(_First, _Last);
+    }
+}
+
+template <class _Iter, class = void>
+constexpr bool _Unwrappable_v = false;
+
+template <class _Iter>
+constexpr bool _Unwrappable_v<_Iter,
+    void_t<decltype(_STD declval<_Remove_cvref_t<_Iter>&>()._Seek_to(_STD declval<_Iter>()._Unwrapped()))>> =
+    _Allow_inheriting_unwrap_v<_Remove_cvref_t<_Iter>>;
+
+template <class _Iter, class = void>
+constexpr bool _Has_nothrow_unwrapped = false;
+template <class _Iter>
+constexpr bool _Has_nothrow_unwrapped<_Iter, void_t<decltype(_STD declval<_Iter>()._Unwrapped())>> =
+    noexcept(_STD declval<_Iter>()._Unwrapped());
+
+template <class _Iter>
+_NODISCARD constexpr decltype(auto) _Get_unwrapped(_Iter&& _It) noexcept(
+    !_Unwrappable_v<_Iter> || _Has_nothrow_unwrapped<_Iter>) {
+    // unwrap an iterator previously subjected to _Adl_verify_range or otherwise validated
+    if constexpr (is_pointer_v<decay_t<_Iter>>) { // special-case pointers and arrays
+        return _It + 0;
+    } else if constexpr (_Unwrappable_v<_Iter>) {
+        return static_cast<_Iter&&>(_It)._Unwrapped();
+    } else {
+        return static_cast<_Iter&&>(_It);
+    }
+}
+
+template <class _Iter>
+using _Unwrapped_t = _Remove_cvref_t<decltype(_STD _Get_unwrapped(_STD declval<_Iter>()))>;
+
+template <class _Iter, class = bool>
+constexpr bool _Do_unwrap_when_unverified_v = false;
+
+template <class _Iter>
+constexpr bool _Do_unwrap_when_unverified_v<_Iter, decltype(static_cast<bool>(_Iter::_Unwrap_when_unverified))> =
+    static_cast<bool>(_Iter::_Unwrap_when_unverified);
+
+template <class _Iter>
+constexpr bool _Unwrappable_for_unverified_v =
+    _Unwrappable_v<_Iter> && _Do_unwrap_when_unverified_v<_Remove_cvref_t<_Iter>>;
+
+template <class _Iter>
+_NODISCARD constexpr decltype(auto) _Get_unwrapped_unverified(_Iter&& _It) {
+    // unwrap an iterator not previously subjected to _Adl_verify_range
+    if constexpr (is_pointer_v<decay_t<_Iter>>) { // special-case pointers and arrays
+        return _It + 0;
+    } else if constexpr (_Unwrappable_for_unverified_v<_Iter>) {
+        return static_cast<_Iter&&>(_It)._Unwrapped();
+    } else {
+        return static_cast<_Iter&&>(_It);
+    }
+}
+
+template <class _Iter>
+using _Unwrapped_unverified_t = _Remove_cvref_t<decltype(_Get_unwrapped_unverified(_STD declval<_Iter>()))>;
+
+struct _Distance_unknown {
+    constexpr _Distance_unknown operator-() const noexcept {
+        return {};
+    }
+};
+
+template <class _Diff>
+constexpr _Diff _Max_possible_v{static_cast<_Make_unsigned_like_t<_Diff>>(-1) >> 1};
+
+template <class _Diff>
+constexpr _Diff _Min_possible_v{-_Max_possible_v<_Diff> - 1};
+
+template <class _Iter, class = void>
+constexpr bool _Offset_verifiable_v = false;
+
+template <class _Iter>
+constexpr bool
+    _Offset_verifiable_v<_Iter, void_t<decltype(_STD declval<const _Iter&>()._Verify_offset(_Iter_diff_t<_Iter>{}))>> =
+        true;
+
+template <class _Iter>
+constexpr bool _Unwrappable_for_offset_v = _Unwrappable_v<_Iter> && _Offset_verifiable_v<_Remove_cvref_t<_Iter>>;
+
+template <class _Iter, class _Diff>
+_NODISCARD constexpr decltype(auto) _Get_unwrapped_n(_Iter&& _It, const _Diff _Off) {
+    if constexpr (is_pointer_v<decay_t<_Iter>>) {
+        return _It + 0;
+    } else if constexpr (_Unwrappable_for_offset_v<_Iter> && is_integral_v<_Diff>) {
+        // ask an iterator to assert that the iterator moved _Off positions is valid, and unwrap
+        using _IDiff     = _Iter_diff_t<_Remove_cvref_t<_Iter>>;
+        using _CDiff     = common_type_t<_Diff, _IDiff>;
+        const auto _COff = static_cast<_CDiff>(_Off);
+
+        _STL_ASSERT(_COff <= static_cast<_CDiff>(_Max_possible_v<_IDiff>)
+                        && (is_unsigned_v<_Diff> || static_cast<_CDiff>(_Min_possible_v<_IDiff>) <= _COff),
+            "integer overflow");
+        (void) _COff;
+
+        _It._Verify_offset(static_cast<_IDiff>(_Off));
+        return static_cast<_Iter&&>(_It)._Unwrapped();
+    } else if constexpr (_Unwrappable_for_unverified_v<_Iter>) {
+        // iterator doesn't support offset-based asserts, or offset unknown; defer to unverified unwrap
+        return static_cast<_Iter&&>(_It)._Unwrapped();
+    } else {
+        // pass through iterator that doesn't participate in checking
+        return static_cast<_Iter&&>(_It);
+    }
+}
+
+template <class _Iter, class _UIter, class = void>
+constexpr bool _Wrapped_seekable_v = false;
+
+template <class _Iter, class _UIter>
+constexpr bool
+    _Wrapped_seekable_v<_Iter, _UIter, void_t<decltype(_STD declval<_Iter&>()._Seek_to(_STD declval<_UIter>()))>> =
+        true;
+
+template <class _Iter, class _UIter>
+constexpr void _Seek_wrapped(_Iter& _It, _UIter&& _UIt) {
+    if constexpr (_Wrapped_seekable_v<_Iter, _UIter>) {
+        _It._Seek_to(_STD forward<_UIter>(_UIt));
+    } else {
+        _It = _STD forward<_UIter>(_UIt);
+    }
+}
+
+#if _HAS_CXX17
+#if _HAS_CXX20
+// detects whether _Ty resembles an allocator, N4981 [container.reqmts]/69
+template <class _Ty>
+concept _Allocator_for_container = requires(_Ty& _Alloc) {
+    typename _Ty::value_type;
+    _Alloc.deallocate(_Alloc.allocate(size_t{1}), size_t{1});
+};
+
+template <class _Ty>
+struct _Is_allocator : bool_constant<_Allocator_for_container<_Ty>> {};
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Ty, class = void>
+struct _Is_allocator : false_type {}; // selected when _Ty can't possibly be an allocator
+
+template <class _Ty>
+struct _Is_allocator<_Ty, void_t<typename _Ty::value_type, decltype(_STD declval<_Ty&>().deallocate(
+                                                               _STD declval<_Ty&>().allocate(size_t{1}), size_t{1}))>>
+    : true_type {}; // selected when _Ty resembles an allocator, N4950 [container.reqmts]/69
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+// deduction guide utilities (N4950 [associative.general]/2)
+template <class _Iter>
+using _Guide_key_t =
+#if _HAS_CXX23
+    remove_const_t<tuple_element_t<0, typename iterator_traits<_Iter>::value_type>>;
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+    remove_const_t<typename iterator_traits<_Iter>::value_type::first_type>;
+#endif // ^^^ !_HAS_CXX23 ^^^
+
+template <class _Iter>
+using _Guide_val_t =
+#if _HAS_CXX23
+    tuple_element_t<1, typename iterator_traits<_Iter>::value_type>;
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+    typename iterator_traits<_Iter>::value_type::second_type;
+#endif // ^^^ !_HAS_CXX23 ^^^
+
+template <class _Iter>
+using _Guide_pair_t =
+#if _HAS_CXX23
+    pair<add_const_t<tuple_element_t<0, typename iterator_traits<_Iter>::value_type>>,
+        tuple_element_t<1, typename iterator_traits<_Iter>::value_type>>;
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+    pair<add_const_t<typename iterator_traits<_Iter>::value_type::first_type>,
+        typename iterator_traits<_Iter>::value_type::second_type>;
+#endif // ^^^ !_HAS_CXX23 ^^^
+
+_EXPORT_STD template <class _Ty>
+struct is_execution_policy : false_type {};
+
+_EXPORT_STD template <class _Ty>
+constexpr bool is_execution_policy_v = is_execution_policy<_Ty>::value;
+
+// Note: The noexcept specifiers on all parallel algorithm overloads enforce termination as per
+// N4950 [execpol.seq]/2, [execpol.par]/2, [execpol.parunseq]/2, and [execpol.unseq]/2
+template <class _ExPo>
+using _Enable_if_execution_policy_t = typename remove_reference_t<_ExPo>::_Standard_execution_policy;
+
+#define _REQUIRE_PARALLEL_ITERATOR(_Iter) \
+    static_assert(_Is_ranges_fwd_iter_v<_Iter>, "Parallel algorithms require forward iterators or stronger.")
+
+#endif // _HAS_CXX17
+
+template <class _Checked, class _Iter>
+_NODISCARD constexpr auto _Idl_distance(const _Iter& _First, const _Iter& _Last) {
+    // tries to get the distance between _First and _Last if they are random-access iterators
+    if constexpr (_Is_ranges_random_iter_v<_Iter>) {
+        return static_cast<_Iter_diff_t<_Checked>>(_Last - _First);
+    } else {
+        return _Distance_unknown{};
+    }
+}
+
+template <class _Elem, bool _Is_enum = is_enum_v<_Elem>>
+struct _Unwrap_enum { // if _Elem is an enum, gets its underlying type; otherwise leaves _Elem unchanged
+    using type = underlying_type_t<_Elem>;
+};
+
+template <class _Elem>
+struct _Unwrap_enum<_Elem, false> { // passthrough non-enum type
+    using type = _Elem;
+};
+
+template <class _Elem>
+using _Unwrap_enum_t = typename _Unwrap_enum<_Elem>::type;
+
+#if _ITERATOR_DEBUG_LEVEL < 2
+#define _DEBUG_LT_PRED(pred, x, y) static_cast<bool>(pred(x, y))
+#define _DEBUG_ORDER_UNWRAPPED(first, last, pred)
+#define _DEBUG_ORDER_SET_UNWRAPPED(otherIter, first, last, pred)
+
+#else // ^^^ _ITERATOR_DEBUG_LEVEL < 2 / _ITERATOR_DEBUG_LEVEL == 2 vvv
+#define _DEBUG_LT_PRED(pred, x, y)                _STD _Debug_lt_pred(pred, x, y)
+#define _DEBUG_ORDER_UNWRAPPED(first, last, pred) _STD _Debug_order_unchecked(first, last, pred)
+#define _DEBUG_ORDER_SET_UNWRAPPED(otherIter, first, last, pred) \
+    _STD _Debug_order_set_unchecked<otherIter>(first, last, pred)
+
+template <class _Pr, class _Ty1, class _Ty2>
+constexpr bool _Enable_debug_lt_pred_order_check = is_same_v<_Remove_cvref_t<_Ty1>, _Remove_cvref_t<_Ty2>>;
+
+template <class _Pr, class _Ty1, class _Ty2, bool _Order_check = _Enable_debug_lt_pred_order_check<_Pr, _Ty1, _Ty2>>
+constexpr bool _Debug_lt_pred_order_check_noexcept =
+    noexcept(_STD declval<_Pr&>()(_STD declval<_Ty2&>(), _STD declval<_Ty1&>()));
+
+template <class _Pr, class _Ty1, class _Ty2>
+constexpr bool _Debug_lt_pred_order_check_noexcept<_Pr, _Ty1, _Ty2, false> = true;
+
+template <class _Pr, class _Ty1, class _Ty2>
+_NODISCARD constexpr bool _Debug_lt_pred(_Pr&& _Pred, _Ty1&& _Left, _Ty2&& _Right) noexcept(
+    noexcept(_Pred(_Left, _Right)) && _Debug_lt_pred_order_check_noexcept<_Pr, _Ty1, _Ty2>) {
+    const auto _Result = static_cast<bool>(_Pred(_Left, _Right));
+
+    if constexpr (_Enable_debug_lt_pred_order_check<_Pr, _Ty1, _Ty2>) {
+        if (_Result) {
+            _STL_VERIFY(!_Pred(_Right, _Left), "invalid comparator");
+        }
+    }
+
+    return _Result;
+}
+
+template <class _InIt, class _Sentinel, class _Pr>
+constexpr void _Debug_order_unchecked(_InIt _First, _Sentinel _Last, _Pr&& _Pred) {
+    // test if range is ordered by predicate
+    if constexpr (_Is_ranges_fwd_iter_v<_InIt>) {
+        if (_First != _Last) {
+            for (auto _Next = _First; ++_Next != _Last; _First = _Next) {
+                _STL_VERIFY(!static_cast<bool>(_Pred(*_Next, *_First)), "sequence not ordered");
+            }
+        }
+    }
+}
+
+template <class _OtherIt, class _InIt, class _Pr>
+constexpr void _Debug_order_set_unchecked(_InIt _First, _InIt _Last, _Pr&& _Pred) {
+    // test if range is ordered by predicate
+    if constexpr (is_same_v<_Iter_value_t<_OtherIt>, _Iter_value_t<_InIt>>) {
+        _STD _Debug_order_unchecked(_First, _Last, _Pred);
+    }
+}
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 2 ^^^
+
+// from <iterator>
+_EXPORT_STD template <class _InIt, class _Diff>
+_CONSTEXPR17 void advance(_InIt& _Where, _Diff _Off) { // increment iterator by offset
+    if constexpr (_Is_ranges_random_iter_v<_InIt>) {
+        _Where += _Off;
+    } else {
+        if constexpr (is_signed_v<_Diff> && !_Is_ranges_bidi_iter_v<_InIt>) {
+            _STL_ASSERT(_Off >= 0, "negative advance of non-bidirectional iterator");
+        }
+
+        decltype(auto) _UWhere      = _STD _Get_unwrapped_n(_STD move(_Where), _Off);
+        constexpr bool _Need_rewrap = !is_reference_v<decltype(_STD _Get_unwrapped_n(_STD move(_Where), _Off))>;
+
+        if constexpr (is_signed_v<_Diff> && _Is_ranges_bidi_iter_v<_InIt>) {
+            for (; _Off < 0; ++_Off) {
+                --_UWhere;
+            }
+        }
+
+        for (; 0 < _Off; --_Off) {
+            ++_UWhere;
+        }
+
+        if constexpr (_Need_rewrap) {
+            _STD _Seek_wrapped(_Where, _STD move(_UWhere));
+        }
+    }
+}
+
+_EXPORT_STD template <class _InIt>
+_NODISCARD _CONSTEXPR17 _Iter_diff_t<_InIt> distance(_InIt _First, _InIt _Last) {
+    if constexpr (_Is_ranges_random_iter_v<_InIt>) {
+        return _Last - _First; // assume the iterator will do debug checking
+    } else {
+        _STD _Adl_verify_range(_First, _Last);
+        auto _UFirst             = _STD _Get_unwrapped(_First);
+        const auto _ULast        = _STD _Get_unwrapped(_Last);
+        _Iter_diff_t<_InIt> _Off = 0;
+        for (; _UFirst != _ULast; ++_UFirst) {
+            ++_Off;
+        }
+
+        return _Off;
+    }
+}
+
+template <class _InIt>
+constexpr _InIt _Next_iter(_InIt _First) { // increment iterator
+    return ++_First;
+}
+
+_EXPORT_STD template <class _InIt>
+_NODISCARD _CONSTEXPR17 _InIt next(
+    _InIt _First, typename iterator_traits<_InIt>::difference_type _Off = 1) { // increment iterator
+    static_assert(_Is_ranges_input_iter_v<_InIt>, "next requires input iterator");
+
+    _STD advance(_First, _Off);
+    return _First;
+}
+
+template <class _BidIt>
+constexpr _BidIt _Prev_iter(_BidIt _First) { // decrement iterator
+    return --_First;
+}
+
+_EXPORT_STD template <class _BidIt>
+_NODISCARD _CONSTEXPR17 _BidIt prev(
+    _BidIt _First, typename iterator_traits<_BidIt>::difference_type _Off = 1) { // decrement iterator
+    static_assert(_Is_ranges_bidi_iter_v<_BidIt>, "prev requires bidirectional iterator");
+
+    _STD advance(_First, -_Off);
+    return _First;
+}
+
+template <class _Iter, class _Pointer, bool = is_pointer_v<_Remove_cvref_t<_Iter>>>
+constexpr bool _Has_nothrow_operator_arrow = _Is_nothrow_convertible_v<_Iter, _Pointer>;
+
+template <class _Iter, class _Pointer>
+constexpr bool _Has_nothrow_operator_arrow<_Iter, _Pointer, false> =
+    noexcept(_STD _Fake_copy_init<_Pointer>(_STD declval<_Iter>().operator->()));
+
+_EXPORT_STD template <class _BidIt>
+class reverse_iterator {
+public:
+    using iterator_type = _BidIt;
+
+#if _HAS_CXX20
+    using iterator_concept =
+        conditional_t<random_access_iterator<_BidIt>, random_access_iterator_tag, bidirectional_iterator_tag>;
+    using iterator_category = conditional_t<derived_from<_Iter_cat_t<_BidIt>, random_access_iterator_tag>,
+        random_access_iterator_tag, _Iter_cat_t<_BidIt>>;
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    using iterator_category = _Iter_cat_t<_BidIt>;
+#endif // ^^^ !_HAS_CXX20 ^^^
+    using value_type      = _Iter_value_t<_BidIt>;
+    using difference_type = _Iter_diff_t<_BidIt>;
+    using pointer         = typename iterator_traits<_BidIt>::pointer;
+    using reference       = _Iter_ref_t<_BidIt>;
+
+    template <class>
+    friend class reverse_iterator;
+
+    _CONSTEXPR17 reverse_iterator() = default;
+
+    _CONSTEXPR17 explicit reverse_iterator(_BidIt _Right) noexcept(
+        is_nothrow_move_constructible_v<_BidIt>) // strengthened
+        : current(_STD move(_Right)) {}
+
+    template <class _Other>
+#if _HAS_CXX20
+        requires (!is_same_v<_Other, _BidIt>) && convertible_to<const _Other&, _BidIt>
+#endif // _HAS_CXX20
+    _CONSTEXPR17 reverse_iterator(const reverse_iterator<_Other>& _Right) noexcept(
+        is_nothrow_constructible_v<_BidIt, const _Other&>) // strengthened
+        : current(_Right.current) {
+    }
+
+    template <class _Other>
+#if _HAS_CXX20
+        requires (!is_same_v<_Other, _BidIt>)
+              && convertible_to<const _Other&, _BidIt> && assignable_from<_BidIt&, const _Other&>
+#endif // _HAS_CXX20
+    _CONSTEXPR17 reverse_iterator& operator=(const reverse_iterator<_Other>& _Right) noexcept(
+        is_nothrow_assignable_v<_BidIt&, const _Other&>) /* strengthened */ {
+        current = _Right.current;
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR17 _BidIt base() const noexcept(is_nothrow_copy_constructible_v<_BidIt>) /* strengthened */ {
+        return current;
+    }
+
+    _NODISCARD _CONSTEXPR17 reference operator*() const noexcept(is_nothrow_copy_constructible_v<_BidIt> //
+            && noexcept(*--(_STD declval<_BidIt&>()))) /* strengthened */ {
+        _BidIt _Tmp = current;
+        return *--_Tmp;
+    }
+
+    _NODISCARD _CONSTEXPR17 pointer operator->() const
+        noexcept(is_nothrow_copy_constructible_v<_BidIt> //
+                     && noexcept(--(_STD declval<_BidIt&>()))
+                 && _Has_nothrow_operator_arrow<_BidIt&, pointer>) /* strengthened */
+#if _HAS_CXX20
+        requires (is_pointer_v<_BidIt> || requires(const _BidIt __i) { __i.operator->(); })
+#endif
+    {
+        _BidIt _Tmp = current;
+        --_Tmp;
+        if constexpr (is_pointer_v<_BidIt>) {
+            return _Tmp;
+        } else {
+            return _Tmp.operator->();
+        }
+    }
+
+    _CONSTEXPR17 reverse_iterator& operator++() noexcept(noexcept(--current)) /* strengthened */ {
+        --current;
+        return *this;
+    }
+
+    _CONSTEXPR17 reverse_iterator operator++(int) noexcept(is_nothrow_copy_constructible_v<_BidIt> //
+            && noexcept(--current)) /* strengthened */ {
+        reverse_iterator _Tmp = *this;
+        --current;
+        return _Tmp;
+    }
+
+    _CONSTEXPR17 reverse_iterator& operator--() noexcept(noexcept(++current)) /* strengthened */ {
+        ++current;
+        return *this;
+    }
+
+    _CONSTEXPR17 reverse_iterator operator--(int) noexcept(is_nothrow_copy_constructible_v<_BidIt> //
+            && noexcept(++current)) /* strengthened */ {
+        reverse_iterator _Tmp = *this;
+        ++current;
+        return _Tmp;
+    }
+
+    _NODISCARD _CONSTEXPR17 reverse_iterator operator+(const difference_type _Off) const
+        noexcept(noexcept(reverse_iterator(current - _Off))) /* strengthened */ {
+        return reverse_iterator(current - _Off);
+    }
+
+    _CONSTEXPR17 reverse_iterator& operator+=(const difference_type _Off) noexcept(
+        noexcept(current -= _Off)) /* strengthened */ {
+        current -= _Off;
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR17 reverse_iterator operator-(const difference_type _Off) const
+        noexcept(noexcept(reverse_iterator(current + _Off))) /* strengthened */ {
+        return reverse_iterator(current + _Off);
+    }
+
+    _CONSTEXPR17 reverse_iterator& operator-=(const difference_type _Off) noexcept(
+        noexcept(current += _Off)) /* strengthened */ {
+        current += _Off;
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR17 reference operator[](const difference_type _Off) const
+        noexcept(noexcept(_STD _Fake_copy_init<reference>(current[_Off]))) /* strengthened */ {
+        return current[static_cast<difference_type>(-_Off - 1)];
+    }
+
+#if _HAS_CXX20
+    _NODISCARD friend constexpr iter_rvalue_reference_t<_BidIt> iter_move(const reverse_iterator& _It) noexcept(
+        is_nothrow_copy_constructible_v<_BidIt> //
+            && noexcept(_RANGES iter_move(--_STD declval<_BidIt&>()))) {
+        auto _Tmp = _It.current;
+        --_Tmp;
+        return _RANGES iter_move(_Tmp);
+    }
+
+    template <indirectly_swappable<_BidIt> _BidIt2>
+    friend constexpr void iter_swap(const reverse_iterator& _Left, const reverse_iterator<_BidIt2>& _Right) noexcept(
+        is_nothrow_copy_constructible_v<_BidIt>
+        && is_nothrow_copy_constructible_v<_BidIt2> //
+            && noexcept(_RANGES iter_swap(--_STD declval<_BidIt&>(), --_STD declval<_BidIt2&>()))) {
+        auto _LTmp = _Left.current;
+        auto _RTmp = _Right.base();
+        --_LTmp;
+        --_RTmp;
+        _RANGES iter_swap(_LTmp, _RTmp);
+    }
+#endif // _HAS_CXX20
+
+    using _Prevent_inheriting_unwrap = reverse_iterator;
+
+    template <class _BidIt2, enable_if_t<_Range_verifiable_v<_BidIt, _BidIt2>, int> = 0>
+    friend constexpr void _Verify_range(
+        const reverse_iterator& _First, const reverse_iterator<_BidIt2>& _Last) noexcept {
+        _Verify_range(_Last._Get_current(), _First.current); // note reversed parameters
+    }
+
+    template <class _BidIt2 = _BidIt, enable_if_t<_Offset_verifiable_v<_BidIt2>, int> = 0>
+    constexpr void _Verify_offset(const difference_type _Off) const noexcept {
+        _STL_VERIFY(_Off != _Min_possible_v<difference_type>, "integer overflow");
+        current._Verify_offset(-_Off);
+    }
+
+    template <class _BidIt2 = _BidIt, enable_if_t<_Unwrappable_v<const _BidIt2&>, int> = 0>
+    _NODISCARD constexpr reverse_iterator<_Unwrapped_t<const _BidIt2&>> _Unwrapped() const& noexcept(
+        noexcept(static_cast<reverse_iterator<_Unwrapped_t<const _BidIt2&>>>(current._Unwrapped()))) {
+        return static_cast<reverse_iterator<_Unwrapped_t<const _BidIt2&>>>(current._Unwrapped());
+    }
+    template <class _BidIt2 = _BidIt, enable_if_t<_Unwrappable_v<_BidIt2>, int> = 0>
+    _NODISCARD constexpr reverse_iterator<_Unwrapped_t<_BidIt2>> _Unwrapped() && noexcept(
+        noexcept(static_cast<reverse_iterator<_Unwrapped_t<_BidIt2>>>(_STD move(current)._Unwrapped()))) {
+        return static_cast<reverse_iterator<_Unwrapped_t<_BidIt2>>>(_STD move(current)._Unwrapped());
+    }
+
+    static constexpr bool _Unwrap_when_unverified = _Do_unwrap_when_unverified_v<_BidIt>;
+
+    template <class _Src, enable_if_t<_Wrapped_seekable_v<_BidIt, const _Src&>, int> = 0>
+    constexpr void _Seek_to(const reverse_iterator<_Src>& _It) noexcept(noexcept(current._Seek_to(_It.current))) {
+        current._Seek_to(_It.current);
+    }
+
+    _NODISCARD constexpr const _BidIt& _Get_current() const noexcept {
+        return current;
+    }
+
+protected:
+    _BidIt current{};
+};
+
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
+_NODISCARD _CONSTEXPR17 bool
+    operator==(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right) noexcept(
+        noexcept(_STD _Fake_copy_init<bool>(_Left._Get_current() == _Right._Get_current()))) /* strengthened */
+#if _HAS_CXX20
+    requires requires {
+        { _Left._Get_current() == _Right._Get_current() } -> _Implicitly_convertible_to<bool>;
+    }
+#endif // _HAS_CXX20
+{
+    return _Left._Get_current() == _Right._Get_current();
+}
+
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
+_NODISCARD _CONSTEXPR17 bool
+    operator!=(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right) noexcept(
+        noexcept(_STD _Fake_copy_init<bool>(_Left._Get_current() != _Right._Get_current()))) /* strengthened */
+#if _HAS_CXX20
+    requires requires {
+        { _Left._Get_current() != _Right._Get_current() } -> _Implicitly_convertible_to<bool>;
+    }
+#endif // _HAS_CXX20
+{
+    return _Left._Get_current() != _Right._Get_current();
+}
+
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
+_NODISCARD _CONSTEXPR17 bool
+    operator<(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right) noexcept(
+        noexcept(_STD _Fake_copy_init<bool>(_Left._Get_current() > _Right._Get_current()))) /* strengthened */
+#if _HAS_CXX20
+    requires requires {
+        { _Left._Get_current() > _Right._Get_current() } -> _Implicitly_convertible_to<bool>;
+    }
+#endif // _HAS_CXX20
+{
+    return _Left._Get_current() > _Right._Get_current();
+}
+
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
+_NODISCARD _CONSTEXPR17 bool
+    operator>(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right) noexcept(
+        noexcept(_STD _Fake_copy_init<bool>(_Left._Get_current() < _Right._Get_current()))) /* strengthened */
+#if _HAS_CXX20
+    requires requires {
+        { _Left._Get_current() < _Right._Get_current() } -> _Implicitly_convertible_to<bool>;
+    }
+#endif // _HAS_CXX20
+{
+    return _Left._Get_current() < _Right._Get_current();
+}
+
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
+_NODISCARD _CONSTEXPR17 bool
+    operator<=(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right) noexcept(
+        noexcept(_STD _Fake_copy_init<bool>(_Left._Get_current() >= _Right._Get_current()))) /* strengthened */
+#if _HAS_CXX20
+    requires requires {
+        { _Left._Get_current() >= _Right._Get_current() } -> _Implicitly_convertible_to<bool>;
+    }
+#endif // _HAS_CXX20
+{
+    return _Left._Get_current() >= _Right._Get_current();
+}
+
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
+_NODISCARD _CONSTEXPR17 bool
+    operator>=(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right) noexcept(
+        noexcept(_STD _Fake_copy_init<bool>(_Left._Get_current() <= _Right._Get_current()))) /* strengthened */
+#if _HAS_CXX20
+    requires requires {
+        { _Left._Get_current() <= _Right._Get_current() } -> _Implicitly_convertible_to<bool>;
+    }
+#endif // _HAS_CXX20
+{
+    return _Left._Get_current() <= _Right._Get_current();
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _BidIt1, three_way_comparable_with<_BidIt1> _BidIt2>
+_NODISCARD constexpr compare_three_way_result_t<_BidIt1, _BidIt2>
+    operator<=>(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right) noexcept(
+        noexcept(_Right._Get_current() <=> _Left._Get_current())) /* strengthened */ {
+    return _Right._Get_current() <=> _Left._Get_current();
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
+_NODISCARD _CONSTEXPR17 auto
+    operator-(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right) noexcept(
+        noexcept(_Right._Get_current() - _Left._Get_current())) /* strengthened */
+    -> decltype(_Right._Get_current() - _Left._Get_current()) {
+    return _Right._Get_current() - _Left._Get_current();
+}
+
+_EXPORT_STD template <class _BidIt>
+_NODISCARD _CONSTEXPR17 reverse_iterator<_BidIt> operator+(typename reverse_iterator<_BidIt>::difference_type _Off,
+    const reverse_iterator<_BidIt>& _Right) noexcept(noexcept(_Right + _Off)) /* strengthened */ {
+    return _Right + _Off;
+}
+
+_EXPORT_STD template <class _BidIt>
+_NODISCARD _CONSTEXPR17 reverse_iterator<_BidIt> make_reverse_iterator(_BidIt _Iter) noexcept(
+    is_nothrow_move_constructible_v<_BidIt>) /* strengthened */ {
+    return reverse_iterator<_BidIt>(_STD move(_Iter));
+}
+
+#if _HAS_CXX20
+template <class _BidIt1, class _BidIt2>
+    requires (!sized_sentinel_for<_BidIt1, _BidIt2>)
+constexpr bool disable_sized_sentinel_for<reverse_iterator<_BidIt1>, reverse_iterator<_BidIt2>> = true;
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR17 auto begin(_Container& _Cont) noexcept(noexcept(_Cont.begin())) /* strengthened */
+    -> decltype(_Cont.begin()) {
+    return _Cont.begin();
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR17 auto begin(const _Container& _Cont) noexcept(noexcept(_Cont.begin())) /* strengthened */
+    -> decltype(_Cont.begin()) {
+    return _Cont.begin();
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR17 auto end(_Container& _Cont) noexcept(noexcept(_Cont.end())) /* strengthened */
+    -> decltype(_Cont.end()) {
+    return _Cont.end();
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR17 auto end(const _Container& _Cont) noexcept(noexcept(_Cont.end())) /* strengthened */
+    -> decltype(_Cont.end()) {
+    return _Cont.end();
+}
+
+_EXPORT_STD template <class _Ty, size_t _Size>
+_NODISCARD constexpr _Ty* begin(_Ty (&_Array)[_Size]) noexcept {
+    return _Array;
+}
+
+_EXPORT_STD template <class _Ty, size_t _Size>
+_NODISCARD constexpr _Ty* end(_Ty (&_Array)[_Size]) noexcept {
+    return _Array + _Size;
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD constexpr auto cbegin(const _Container& _Cont) noexcept(noexcept(_STD begin(_Cont)))
+    -> decltype(_STD begin(_Cont)) {
+    return _STD begin(_Cont);
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD constexpr auto cend(const _Container& _Cont) noexcept(noexcept(_STD end(_Cont)))
+    -> decltype(_STD end(_Cont)) {
+    return _STD end(_Cont);
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR17 auto rbegin(_Container& _Cont) noexcept(noexcept(_Cont.rbegin())) /* strengthened */
+    -> decltype(_Cont.rbegin()) {
+    return _Cont.rbegin();
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR17 auto rbegin(const _Container& _Cont) noexcept(noexcept(_Cont.rbegin())) /* strengthened */
+    -> decltype(_Cont.rbegin()) {
+    return _Cont.rbegin();
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR17 auto rend(_Container& _Cont) noexcept(noexcept(_Cont.rend())) /* strengthened */
+    -> decltype(_Cont.rend()) {
+    return _Cont.rend();
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR17 auto rend(const _Container& _Cont) noexcept(noexcept(_Cont.rend())) /* strengthened */
+    -> decltype(_Cont.rend()) {
+    return _Cont.rend();
+}
+
+_EXPORT_STD template <class _Ty, size_t _Size>
+_NODISCARD _CONSTEXPR17 reverse_iterator<_Ty*> rbegin(_Ty (&_Array)[_Size]) noexcept /* strengthened */ {
+    return reverse_iterator<_Ty*>(_Array + _Size);
+}
+
+_EXPORT_STD template <class _Ty, size_t _Size>
+_NODISCARD _CONSTEXPR17 reverse_iterator<_Ty*> rend(_Ty (&_Array)[_Size]) noexcept /* strengthened */ {
+    return reverse_iterator<_Ty*>(_Array);
+}
+
+_EXPORT_STD template <class _Elem>
+_NODISCARD _CONSTEXPR17 reverse_iterator<const _Elem*> rbegin(initializer_list<_Elem> _Ilist) noexcept
+/* strengthened */ {
+    return reverse_iterator<const _Elem*>(_Ilist.end());
+}
+
+_EXPORT_STD template <class _Elem>
+_NODISCARD _CONSTEXPR17 reverse_iterator<const _Elem*> rend(initializer_list<_Elem> _Ilist) noexcept
+/* strengthened */ {
+    return reverse_iterator<const _Elem*>(_Ilist.begin());
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR17 auto crbegin(const _Container& _Cont) noexcept(noexcept(_STD rbegin(_Cont))) /* strengthened */
+    -> decltype(_STD rbegin(_Cont)) {
+    return _STD rbegin(_Cont);
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR17 auto crend(const _Container& _Cont) noexcept(noexcept(_STD rend(_Cont))) /* strengthened */
+    -> decltype(_STD rend(_Cont)) {
+    return _STD rend(_Cont);
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD constexpr auto size(const _Container& _Cont) noexcept(noexcept(_Cont.size())) /* strengthened */
+    -> decltype(_Cont.size()) {
+    return _Cont.size();
+}
+
+_EXPORT_STD template <class _Ty, size_t _Size>
+_NODISCARD constexpr size_t size(const _Ty (&)[_Size]) noexcept {
+    return _Size;
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Container>
+_NODISCARD constexpr auto ssize(const _Container& _Cont) noexcept(noexcept(
+    static_cast<common_type_t<ptrdiff_t, make_signed_t<decltype(_Cont.size())>>>(_Cont.size()))) /* strengthened */
+    -> common_type_t<ptrdiff_t, make_signed_t<decltype(_Cont.size())>> {
+    using _Common = common_type_t<ptrdiff_t, make_signed_t<decltype(_Cont.size())>>;
+    return static_cast<_Common>(_Cont.size());
+}
+
+_EXPORT_STD template <class _Ty, ptrdiff_t _Size>
+_NODISCARD constexpr ptrdiff_t ssize(const _Ty (&)[_Size]) noexcept {
+    return _Size;
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Container>
+_NODISCARD_EMPTY_NON_MEMBER constexpr auto empty(const _Container& _Cont) noexcept(
+    noexcept(_Cont.empty())) /* strengthened */
+    -> decltype(_Cont.empty()) {
+    return _Cont.empty();
+}
+
+_EXPORT_STD template <class _Ty, size_t _Size>
+_NODISCARD_EMPTY_NON_MEMBER constexpr bool empty(const _Ty (&)[_Size]) noexcept {
+    return false;
+}
+
+_EXPORT_STD template <class _Elem>
+_NODISCARD_EMPTY_NON_MEMBER constexpr bool empty(initializer_list<_Elem> _Ilist) noexcept {
+    return _Ilist.size() == 0;
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD constexpr auto data(_Container& _Cont) noexcept(noexcept(_Cont.data())) /* strengthened */
+    -> decltype(_Cont.data()) {
+    return _Cont.data();
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD constexpr auto data(const _Container& _Cont) noexcept(noexcept(_Cont.data())) /* strengthened */
+    -> decltype(_Cont.data()) {
+    return _Cont.data();
+}
+
+_EXPORT_STD template <class _Ty, size_t _Size>
+_NODISCARD constexpr _Ty* data(_Ty (&_Array)[_Size]) noexcept {
+    return _Array;
+}
+
+_EXPORT_STD template <class _Elem>
+_NODISCARD constexpr const _Elem* data(initializer_list<_Elem> _Ilist) noexcept {
+    return _Ilist.begin();
+}
+
+#if _HAS_CXX20
+#if _HAS_CXX23
+_EXPORT_STD template <indirectly_readable _Ty>
+using iter_const_reference_t = common_reference_t<const iter_value_t<_Ty>&&, iter_reference_t<_Ty>>;
+
+template <indirectly_readable _Iter>
+using _Iter_const_rvalue_reference_t = common_reference_t<const iter_value_t<_Iter>&&, iter_rvalue_reference_t<_Iter>>;
+
+template <class _Ty>
+concept _Constant_iterator = input_iterator<_Ty> && same_as<iter_const_reference_t<_Ty>, iter_reference_t<_Ty>>;
+
+_EXPORT_STD template <input_iterator _Iter>
+class basic_const_iterator;
+
+_EXPORT_STD template <input_iterator _Iter>
+using const_iterator = conditional_t<_Constant_iterator<_Iter>, _Iter, basic_const_iterator<_Iter>>;
+
+template <class _Sent>
+struct _Const_sentinel {
+    using type = _Sent;
+};
+
+template <input_iterator _Sent>
+struct _Const_sentinel<_Sent> {
+    using type = const_iterator<_Sent>;
+};
+
+_EXPORT_STD template <semiregular _Sent>
+using const_sentinel = _Const_sentinel<_Sent>::type;
+
+template <class _Ty>
+concept _Not_a_const_iterator = !_Is_specialization_v<_Ty, basic_const_iterator>;
+
+template <class>
+struct _Basic_const_iterator_category {};
+
+template <forward_iterator _Iter>
+struct _Basic_const_iterator_category<_Iter> {
+    using iterator_category = iterator_traits<_Iter>::iterator_category;
+};
+
+_EXPORT_STD template <input_iterator _Iter>
+class basic_const_iterator : public _Basic_const_iterator_category<_Iter> {
+private:
+    /* [[no_unique_address]] */ _Iter _Current{};
+
+    using _Reference        = iter_const_reference_t<_Iter>;
+    using _Rvalue_reference = _Iter_const_rvalue_reference_t<_Iter>;
+
+    _NODISCARD static consteval auto _Get_iter_concept() noexcept {
+        if constexpr (contiguous_iterator<_Iter>) {
+            return contiguous_iterator_tag{};
+        } else if constexpr (random_access_iterator<_Iter>) {
+            return random_access_iterator_tag{};
+        } else if constexpr (bidirectional_iterator<_Iter>) {
+            return bidirectional_iterator_tag{};
+        } else if constexpr (forward_iterator<_Iter>) {
+            return forward_iterator_tag{};
+        } else {
+            return input_iterator_tag{};
+        }
+    }
+
+public:
+    using iterator_concept = decltype(_Get_iter_concept());
+    using value_type       = iter_value_t<_Iter>;
+    using difference_type  = iter_difference_t<_Iter>;
+
+    // clang-format off
+    basic_const_iterator() requires default_initializable<_Iter> = default;
+    // clang-format on
+
+    constexpr basic_const_iterator(_Iter _Current_) noexcept(is_nothrow_move_constructible_v<_Iter>) // strengthened
+        : _Current(_STD move(_Current_)) {}
+
+    template <convertible_to<_Iter> _Other>
+    constexpr basic_const_iterator(basic_const_iterator<_Other> _Current_) noexcept(
+        is_nothrow_constructible_v<_Iter, _Other>) // strengthened
+        : _Current(_STD move(_Current_._Current)) {}
+
+    template <_Different_from<basic_const_iterator> _Other>
+        requires convertible_to<_Other, _Iter>
+    constexpr basic_const_iterator(_Other&& _Current_) noexcept(
+        is_nothrow_constructible_v<_Iter, _Other>) // strengthened
+        : _Current(_STD forward<_Other>(_Current_)) {}
+
+    _NODISCARD constexpr const _Iter& base() const& noexcept {
+        return _Current;
+    }
+
+    _NODISCARD constexpr _Iter base() && noexcept(is_nothrow_move_constructible_v<_Iter>) /* strengthened */ {
+        return _STD move(_Current);
+    }
+
+    _NODISCARD constexpr _Reference operator*() const
+        noexcept(noexcept(static_cast<_Reference>(*_Current))) /* strengthened */ {
+        return static_cast<_Reference>(*_Current);
+    }
+
+    _NODISCARD constexpr const auto* operator->() const
+        noexcept(contiguous_iterator<_Iter> || noexcept(*_Current)) /* strengthened */
+        requires is_lvalue_reference_v<iter_reference_t<_Iter>>
+              && same_as<remove_cvref_t<iter_reference_t<_Iter>>, value_type>
+    {
+        if constexpr (contiguous_iterator<_Iter>) {
+            return _STD to_address(_Current);
+        } else {
+            return _STD addressof(*_Current);
+        }
+    }
+
+    constexpr basic_const_iterator& operator++() noexcept(noexcept(++_Current)) /* strengthened */ {
+        ++_Current;
+        return *this;
+    }
+
+    constexpr void operator++(int) noexcept(noexcept(++_Current)) /* strengthened */ {
+        ++_Current;
+    }
+
+    constexpr basic_const_iterator operator++(int) noexcept(
+        noexcept(++*this) && is_nothrow_copy_constructible_v<basic_const_iterator>) // strengthened
+        requires forward_iterator<_Iter>
+    {
+        auto _Tmp = *this;
+        ++*this;
+        return _Tmp;
+    }
+
+    constexpr basic_const_iterator& operator--() noexcept(noexcept(--_Current)) // strengthened
+        requires bidirectional_iterator<_Iter>
+    {
+        --_Current;
+        return *this;
+    }
+
+    constexpr basic_const_iterator operator--(int) noexcept(
+        noexcept(--*this) && is_nothrow_copy_constructible_v<basic_const_iterator>) // strengthened
+        requires bidirectional_iterator<_Iter>
+    {
+        auto _Tmp = *this;
+        --*this;
+        return _Tmp;
+    }
+
+    constexpr basic_const_iterator& operator+=(const difference_type _Off) noexcept(
+        noexcept(_Current += _Off)) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        _Current += _Off;
+        return *this;
+    }
+
+    constexpr basic_const_iterator& operator-=(const difference_type _Off) noexcept(
+        noexcept(_Current -= _Off)) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        _Current -= _Off;
+        return *this;
+    }
+
+    _NODISCARD constexpr _Reference operator[](const difference_type _Idx) const
+        noexcept(noexcept(static_cast<_Reference>(_Current[_Idx]))) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        return static_cast<_Reference>(_Current[_Idx]);
+    }
+
+    template <sentinel_for<_Iter> _Sent>
+    _NODISCARD constexpr bool operator==(const _Sent& _Se) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Current == _Se))) /* strengthened */ {
+        return _Current == _Se;
+    }
+
+    template <_Not_a_const_iterator _Other>
+        requires _Constant_iterator<_Other> && convertible_to<const _Iter&, _Other>
+    _NODISCARD constexpr operator _Other() const& noexcept(
+        is_nothrow_convertible_v<const _Iter&, _Other>) /* strengthened */ {
+        return _Current;
+    }
+
+    template <_Not_a_const_iterator _Other>
+        requires _Constant_iterator<_Other> && convertible_to<_Iter, _Other>
+    _NODISCARD constexpr operator _Other() && noexcept(is_nothrow_convertible_v<_Iter, _Other>) /* strengthened */ {
+        return _STD move(_Current);
+    }
+
+    _NODISCARD constexpr bool operator<(const basic_const_iterator& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Current < _Right._Current))) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        return _Current < _Right._Current;
+    }
+
+    _NODISCARD constexpr bool operator>(const basic_const_iterator& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Current > _Right._Current))) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        return _Current > _Right._Current;
+    }
+
+    _NODISCARD constexpr bool operator<=(const basic_const_iterator& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Current <= _Right._Current))) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        return _Current <= _Right._Current;
+    }
+
+    _NODISCARD constexpr bool operator>=(const basic_const_iterator& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Current >= _Right._Current))) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        return _Current >= _Right._Current;
+    }
+
+    _NODISCARD constexpr auto operator<=>(const basic_const_iterator& _Right) const
+        noexcept(noexcept(_Current <=> _Right._Current)) // strengthened
+        requires random_access_iterator<_Iter> && three_way_comparable<_Iter>
+    {
+        return _Current <=> _Right._Current;
+    }
+
+    template <_Different_from<basic_const_iterator> _Other>
+        requires random_access_iterator<_Iter> && totally_ordered_with<_Iter, _Other>
+    _NODISCARD constexpr bool operator<(const _Other& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Current < _Right))) /* strengthened */ {
+        return _Current < _Right;
+    }
+
+    template <_Different_from<basic_const_iterator> _Other>
+        requires random_access_iterator<_Iter> && totally_ordered_with<_Iter, _Other>
+    _NODISCARD constexpr bool operator>(const _Other& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Current > _Right))) /* strengthened */ {
+        return _Current > _Right;
+    }
+
+    template <_Different_from<basic_const_iterator> _Other>
+        requires random_access_iterator<_Iter> && totally_ordered_with<_Iter, _Other>
+    _NODISCARD constexpr bool operator<=(const _Other& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Current <= _Right))) /* strengthened */ {
+        return _Current <= _Right;
+    }
+
+    template <_Different_from<basic_const_iterator> _Other>
+        requires random_access_iterator<_Iter> && totally_ordered_with<_Iter, _Other>
+    _NODISCARD constexpr bool operator>=(const _Other& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Current >= _Right))) /* strengthened */ {
+        return _Current >= _Right;
+    }
+
+    template <_Different_from<basic_const_iterator> _Other>
+        requires random_access_iterator<_Iter> && totally_ordered_with<_Iter, _Other>
+              && three_way_comparable_with<_Iter, _Other>
+    _NODISCARD constexpr auto operator<=>(const _Other& _Right) const
+        noexcept(noexcept(_Current <=> _Right)) /* strengthened */ {
+        return _Current <=> _Right;
+    }
+
+    template <_Not_a_const_iterator _Other>
+        requires random_access_iterator<_Iter> && totally_ordered_with<_Iter, _Other>
+    _NODISCARD friend constexpr bool operator<(const _Other& _Left, const basic_const_iterator& _Right) noexcept(
+        noexcept(_STD _Fake_copy_init<bool>(_Left < _Right._Current))) /* strengthened */ {
+        return _Left < _Right._Current;
+    }
+
+    template <_Not_a_const_iterator _Other>
+        requires random_access_iterator<_Iter> && totally_ordered_with<_Iter, _Other>
+    _NODISCARD friend constexpr bool operator>(const _Other& _Left, const basic_const_iterator& _Right) noexcept(
+        noexcept(_STD _Fake_copy_init<bool>(_Left > _Right._Current))) /* strengthened */ {
+        return _Left > _Right._Current;
+    }
+
+    template <_Not_a_const_iterator _Other>
+        requires random_access_iterator<_Iter> && totally_ordered_with<_Iter, _Other>
+    _NODISCARD friend constexpr bool operator<=(const _Other& _Left, const basic_const_iterator& _Right) noexcept(
+        noexcept(_STD _Fake_copy_init<bool>(_Left <= _Right._Current))) /* strengthened */ {
+        return _Left <= _Right._Current;
+    }
+
+    template <_Not_a_const_iterator _Other>
+        requires random_access_iterator<_Iter> && totally_ordered_with<_Iter, _Other>
+    _NODISCARD friend constexpr bool operator>=(const _Other& _Left, const basic_const_iterator& _Right) noexcept(
+        noexcept(_STD _Fake_copy_init<bool>(_Left >= _Right._Current))) /* strengthened */ {
+        return _Left >= _Right._Current;
+    }
+
+    _NODISCARD friend constexpr basic_const_iterator operator+(const basic_const_iterator& _It,
+        const difference_type _Off) noexcept(noexcept(basic_const_iterator{_It._Current + _Off})) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        return basic_const_iterator{_It._Current + _Off};
+    }
+
+    _NODISCARD friend constexpr basic_const_iterator operator+(const difference_type _Off,
+        const basic_const_iterator& _It) noexcept(noexcept(basic_const_iterator{_It._Current + _Off})) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        return basic_const_iterator{_It._Current + _Off};
+    }
+
+    _NODISCARD friend constexpr basic_const_iterator operator-(const basic_const_iterator& _It,
+        const difference_type _Off) noexcept(noexcept(basic_const_iterator{_It._Current - _Off})) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        return basic_const_iterator{_It._Current - _Off};
+    }
+
+    template <sized_sentinel_for<_Iter> _Sent>
+    _NODISCARD constexpr difference_type operator-(const _Sent& _Se) const
+        noexcept(noexcept(_Current - _Se)) /* strengthened */ {
+        return _Current - _Se;
+    }
+
+    template <_Not_a_const_iterator _Sent>
+        requires sized_sentinel_for<_Sent, _Iter>
+    _NODISCARD friend constexpr difference_type operator-(const _Sent& _Se, const basic_const_iterator& _It) noexcept(
+        noexcept(_Se - _It._Current)) /* strengthened */ {
+        return _Se - _It._Current;
+    }
+
+    _NODISCARD friend constexpr _Rvalue_reference iter_move(const basic_const_iterator& _It) noexcept(
+        noexcept(static_cast<_Rvalue_reference>(_RANGES iter_move(_It._Current)))) {
+        return static_cast<_Rvalue_reference>(_RANGES iter_move(_It._Current));
+    }
+};
+
+template <class _Ty1, common_with<_Ty1> _Ty2>
+    requires input_iterator<common_type_t<_Ty1, _Ty2>>
+struct common_type<basic_const_iterator<_Ty1>, _Ty2> {
+    using type = basic_const_iterator<common_type_t<_Ty1, _Ty2>>;
+};
+
+template <class _Ty1, common_with<_Ty1> _Ty2>
+    requires input_iterator<common_type_t<_Ty1, _Ty2>>
+struct common_type<_Ty2, basic_const_iterator<_Ty1>> {
+    using type = basic_const_iterator<common_type_t<_Ty1, _Ty2>>;
+};
+
+template <class _Ty1, common_with<_Ty1> _Ty2>
+    requires input_iterator<common_type_t<_Ty1, _Ty2>>
+struct common_type<basic_const_iterator<_Ty1>, basic_const_iterator<_Ty2>> {
+    using type = basic_const_iterator<common_type_t<_Ty1, _Ty2>>;
+};
+
+_EXPORT_STD template <input_iterator _Iter>
+_NODISCARD constexpr const_iterator<_Iter> make_const_iterator(_Iter _It) noexcept(
+    is_nothrow_constructible_v<const_iterator<_Iter>, _Iter&>) /* strengthened */ {
+    return _It;
+}
+
+_EXPORT_STD template <semiregular _Sent>
+_NODISCARD constexpr const_sentinel<_Sent> make_const_sentinel(_Sent _Se) noexcept(
+    is_nothrow_constructible_v<const_sentinel<_Sent>, _Sent&>) /* strengthened */ {
+    return _Se;
+}
+#endif // _HAS_CXX23
+
+namespace ranges {
+    template <class>
+    constexpr bool _Has_complete_elements = false;
+
+    template <class _Ty>
+        requires requires(_Ty& __t) { sizeof(__t[0]); }
+    constexpr bool _Has_complete_elements<_Ty> = true;
+
+    _EXPORT_STD template <class>
+    constexpr bool enable_borrowed_range = false;
+
+    template <class _Rng>
+    concept _Should_range_access = is_lvalue_reference_v<_Rng> || enable_borrowed_range<remove_cvref_t<_Rng>>;
+
+    namespace _Begin {
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1681199
+        void begin() = delete; // Block unqualified name lookup
+#else // ^^^ no workaround / workaround vvv
+        void begin();
+#endif // ^^^ workaround ^^^
+
+        template <class _Ty>
+        concept _Has_member = requires(_Ty __t) {
+            { _STD _Fake_copy_init(__t.begin()) } -> input_or_output_iterator;
+        };
+
+        template <class _Ty>
+        concept _Has_ADL = _Has_class_or_enum_type<_Ty> && requires(_Ty __t) {
+            { _STD _Fake_copy_init(begin(__t)) } -> input_or_output_iterator; // intentional ADL
+        };
+
+        class _Cpo {
+        private:
+            enum class _St { _None, _Array, _Member, _Non_member };
+
+            template <class _Ty>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                _STL_INTERNAL_STATIC_ASSERT(is_lvalue_reference_v<_Ty>);
+                if constexpr (is_array_v<remove_reference_t<_Ty>>) {
+                    static_assert(_Has_complete_elements<_Ty>,
+                        "The range access customization point objects "
+                        "std::ranges::begin, std::ranges::end, std::ranges::rbegin, std::ranges::rend, "
+                        "and std::ranges::data do not accept arrays with incomplete element types.");
+                    return {_St::_Array, true};
+                } else if constexpr (_Has_member<_Ty>) {
+                    return {_St::_Member, noexcept(_STD _Fake_copy_init(_STD declval<_Ty>().begin()))};
+                } else if constexpr (_Has_ADL<_Ty>) {
+                    return {_St::_Non_member,
+                        noexcept(_STD _Fake_copy_init(begin(_STD declval<_Ty>())))}; // intentional ADL
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _Ty>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();
+
+        public:
+            template <_Should_range_access _Ty>
+                requires (_Choice<_Ty&>._Strategy != _St::_None)
+            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+                noexcept(_Choice<_Ty&>._No_throw) {
+                constexpr _St _Strat = _Choice<_Ty&>._Strategy;
+
+                if constexpr (_Strat == _St::_Array) {
+                    return _Val;
+                } else if constexpr (_Strat == _St::_Member) {
+                    return _Val.begin();
+                } else if constexpr (_Strat == _St::_Non_member) {
+                    return begin(_Val); // intentional ADL
+                } else {
+                    _STL_INTERNAL_STATIC_ASSERT(false); // unexpected strategy
+                }
+            }
+        };
+    } // namespace _Begin
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Begin::_Cpo begin;
+    }
+
+    _EXPORT_STD template <class _Ty>
+    using iterator_t = decltype(_RANGES begin(_STD declval<_Ty&>()));
+
+    namespace _End {
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1681199
+        void end() = delete; // Block unqualified name lookup
+#else // ^^^ no workaround / workaround vvv
+        void end();
+#endif // ^^^ workaround ^^^
+
+        template <class _Ty>
+        concept _Has_member = requires(_Ty __t) {
+            { _STD _Fake_copy_init(__t.end()) } -> sentinel_for<iterator_t<_Ty>>;
+        };
+
+        template <class _Ty>
+        concept _Has_ADL = _Has_class_or_enum_type<_Ty> && requires(_Ty __t) {
+            { _STD _Fake_copy_init(end(__t)) } -> sentinel_for<iterator_t<_Ty>>; // intentional ADL
+        };
+
+        class _Cpo {
+        private:
+            enum class _St { _None, _Array, _Member, _Non_member };
+
+            template <class _Ty>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                _STL_INTERNAL_STATIC_ASSERT(is_lvalue_reference_v<_Ty>);
+                using _UnRef = remove_reference_t<_Ty>;
+
+                if constexpr (is_array_v<_UnRef>) {
+                    static_assert(_Has_complete_elements<_UnRef>,
+                        "The range access customization point objects "
+                        "std::ranges::begin, std::ranges::end, std::ranges::rbegin, std::ranges::rend, "
+                        "and std::ranges::data do not accept arrays with incomplete element types.");
+                    if constexpr (extent_v<_UnRef> != 0) {
+                        return {_St::_Array, true};
+                    } else {
+                        return {_St::_None};
+                    }
+                } else if constexpr (_Has_member<_Ty>) {
+                    return {_St::_Member, noexcept(_STD _Fake_copy_init(_STD declval<_Ty>().end()))};
+                } else if constexpr (_Has_ADL<_Ty>) {
+                    return {
+                        _St::_Non_member, noexcept(_STD _Fake_copy_init(end(_STD declval<_Ty>())))}; // intentional ADL
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _Ty>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();
+
+        public:
+            template <_Should_range_access _Ty>
+                requires (_Choice<_Ty&>._Strategy != _St::_None)
+            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+                noexcept(_Choice<_Ty&>._No_throw) {
+                constexpr _St _Strat = _Choice<_Ty&>._Strategy;
+
+                if constexpr (_Strat == _St::_Array) {
+                    // extent_v<remove_reference_t<_Ty&>> reuses specializations from _Choose
+                    return _Val + extent_v<remove_reference_t<_Ty&>>;
+                } else if constexpr (_Strat == _St::_Member) {
+                    return _Val.end();
+                } else if constexpr (_Strat == _St::_Non_member) {
+                    return end(_Val); // intentional ADL
+                } else {
+                    _STL_INTERNAL_STATIC_ASSERT(false); // unexpected strategy
+                }
+            }
+        };
+    } // namespace _End
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _End::_Cpo end;
+    }
+
+    _EXPORT_STD template <class _Rng>
+    concept range = requires(_Rng& __r) {
+        _RANGES begin(__r);
+        _RANGES end(__r);
+    };
+
+    _EXPORT_STD template <class _Rng>
+    concept input_range = range<_Rng> && input_iterator<iterator_t<_Rng>>;
+
+    _EXPORT_STD template <range _Rng>
+    using sentinel_t = decltype(_RANGES end(_STD declval<_Rng&>()));
+
+    template <class _Wrapped>
+    concept _Weakly_unwrappable = _Allow_inheriting_unwrap_v<remove_cvref_t<_Wrapped>>
+                               && requires(_Wrapped&& _Wr) { _STD forward<_Wrapped>(_Wr)._Unwrapped(); };
+
+    template <class _Sent>
+    concept _Weakly_unwrappable_sentinel = _Weakly_unwrappable<const remove_reference_t<_Sent>&>;
+
+    template <class _Iter>
+    concept _Weakly_unwrappable_iterator =
+        _Weakly_unwrappable<_Iter> && requires(_Iter&& _It, remove_cvref_t<_Iter>& _MutIt) {
+            _MutIt._Seek_to(_STD forward<_Iter>(_It)._Unwrapped());
+        };
+
+    template <class _Sent, class _Iter>
+    concept _Unwrappable_sentinel_for = _Weakly_unwrappable_sentinel<_Sent> && _Weakly_unwrappable_iterator<_Iter>
+                                     && requires(_Iter&& _It, const remove_reference_t<_Sent>& _Se) {
+                                            {
+                                                _Se._Unwrapped()
+                                            } -> sentinel_for<decltype(_STD forward<_Iter>(_It)._Unwrapped())>;
+                                        };
+
+    template <class _Sent, class _Iter>
+    _NODISCARD constexpr decltype(auto) _Unwrap_iter(_Iter&& _It) noexcept(
+        !_Unwrappable_sentinel_for<_Sent, _Iter> || _Has_nothrow_unwrapped<_Iter>) {
+        _STL_INTERNAL_STATIC_ASSERT(sentinel_for<remove_cvref_t<_Sent>, remove_cvref_t<_Iter>>);
+        if constexpr (is_pointer_v<remove_cvref_t<_Iter>>) {
+            return _It + 0;
+        } else if constexpr (_Unwrappable_sentinel_for<_Sent, _Iter>) {
+            return static_cast<_Iter&&>(_It)._Unwrapped();
+        } else {
+            return static_cast<_Iter&&>(_It);
+        }
+    }
+
+    template <class _Iter, class _Sent>
+    _NODISCARD constexpr decltype(auto) _Unwrap_sent(_Sent&& _Se) noexcept(
+        !_Unwrappable_sentinel_for<_Sent, _Iter> || _Has_nothrow_unwrapped<_Sent>) {
+        _STL_INTERNAL_STATIC_ASSERT(sentinel_for<remove_cvref_t<_Sent>, remove_cvref_t<_Iter>>);
+        if constexpr (is_pointer_v<remove_cvref_t<_Sent>>) {
+            return _Se + 0;
+        } else if constexpr (_Unwrappable_sentinel_for<_Sent, _Iter>) {
+            return static_cast<_Sent&&>(_Se)._Unwrapped();
+        } else {
+            return static_cast<_Sent&&>(_Se);
+        }
+    }
+
+    template <range _Rng, class _Iter>
+    _NODISCARD constexpr decltype(auto) _Unwrap_range_iter(_Iter&& _It) noexcept(
+        noexcept(_RANGES _Unwrap_iter<sentinel_t<_Rng>>(static_cast<_Iter&&>(_It)))) {
+        _STL_INTERNAL_STATIC_ASSERT(same_as<remove_cvref_t<_Iter>, iterator_t<_Rng>>);
+        return _RANGES _Unwrap_iter<sentinel_t<_Rng>>(static_cast<_Iter&&>(_It));
+    }
+
+    template <range _Rng, class _Sent>
+    _NODISCARD constexpr decltype(auto) _Unwrap_range_sent(_Sent&& _Se) noexcept(
+        noexcept(_RANGES _Unwrap_sent<iterator_t<_Rng>>(static_cast<_Sent&&>(_Se)))) {
+        _STL_INTERNAL_STATIC_ASSERT(same_as<remove_cvref_t<_Sent>, sentinel_t<_Rng>>);
+        return _RANGES _Unwrap_sent<iterator_t<_Rng>>(static_cast<_Sent&&>(_Se));
+    }
+
+    template <class _Iter, class _Sent>
+    using _Unwrap_iter_t = remove_cvref_t<decltype(_RANGES _Unwrap_iter<_Sent>(_STD declval<_Iter>()))>;
+    template <class _Sent, class _Iter>
+    using _Unwrap_sent_t = remove_cvref_t<decltype(_RANGES _Unwrap_sent<_Iter>(_STD declval<_Sent>()))>;
+
+    template <range _Rng>
+    using _Unwrapped_iterator_t = _Unwrap_iter_t<iterator_t<_Rng>, sentinel_t<_Rng>>;
+    template <range _Rng>
+    using _Unwrapped_sentinel_t = _Unwrap_sent_t<sentinel_t<_Rng>, iterator_t<_Rng>>;
+
+    namespace _Unchecked_begin {
+        template <class _Ty>
+        concept _Has_member = requires(_Ty& __t) {
+            { __t._Unchecked_begin() } -> input_or_output_iterator;
+        };
+
+        template <class _Ty>
+        concept _Can_begin = requires(_Ty& __t) { _RANGES _Unwrap_range_iter<_Ty>(_RANGES begin(__t)); };
+
+        class _Cpo {
+        private:
+            enum class _St { _None, _Member, _Unwrap };
+
+            template <class _Ty>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                _STL_INTERNAL_STATIC_ASSERT(is_lvalue_reference_v<_Ty>);
+                if constexpr (_Has_member<_Ty>) {
+                    _STL_INTERNAL_STATIC_ASSERT(
+                        same_as<decltype(_STD declval<_Ty>()._Unchecked_begin()), _Unwrapped_iterator_t<_Ty>>);
+                    return {_St::_Member, noexcept(_STD _Fake_copy_init(_STD declval<_Ty>()._Unchecked_begin()))};
+                } else if constexpr (_Can_begin<_Ty>) {
+                    return {_St::_Unwrap, noexcept(_STD _Fake_copy_init(
+                                              _RANGES _Unwrap_range_iter<_Ty>(_RANGES begin(_STD declval<_Ty>()))))};
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _Ty>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();
+
+        public:
+            template <_Should_range_access _Ty>
+                requires (_Choice<_Ty&>._Strategy != _St::_None)
+            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+                noexcept(_Choice<_Ty&>._No_throw) {
+                constexpr _St _Strat = _Choice<_Ty&>._Strategy;
+
+                if constexpr (_Strat == _St::_Member) {
+                    return _Val._Unchecked_begin();
+                } else if constexpr (_Strat == _St::_Unwrap) {
+                    return _RANGES _Unwrap_range_iter<_Ty>(_RANGES begin(_Val));
+                } else {
+                    _STL_INTERNAL_STATIC_ASSERT(false); // unexpected strategy
+                }
+            }
+        };
+    } // namespace _Unchecked_begin
+
+    inline namespace _Cpos {
+        inline constexpr _Unchecked_begin::_Cpo _Ubegin;
+    }
+
+    namespace _Unchecked_end {
+        template <class _Ty>
+        concept _Has_member = _Unchecked_begin::_Has_member<_Ty> && requires(_Ty& __t) {
+            __t._Unchecked_begin(); // required explicitly for better diagnostics
+            { __t._Unchecked_end() } -> sentinel_for<decltype(__t._Unchecked_begin())>;
+        };
+
+        template <class _Ty>
+        concept _Can_end = requires(_Ty& __t) { _RANGES _Unwrap_range_sent<_Ty>(_RANGES end(__t)); };
+
+        class _Cpo {
+        private:
+            enum class _St { _None, _Member, _Unwrap };
+
+            template <class _Ty>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                _STL_INTERNAL_STATIC_ASSERT(is_lvalue_reference_v<_Ty>);
+                if constexpr (_Has_member<_Ty>) {
+                    return {_St::_Member, noexcept(_STD declval<_Ty>()._Unchecked_end())};
+                } else if constexpr (_Can_end<_Ty>) {
+                    return {_St::_Unwrap, noexcept(_RANGES _Unwrap_range_sent<_Ty>(_RANGES end(_STD declval<_Ty>())))};
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _Ty>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();
+
+        public:
+            template <_Should_range_access _Ty>
+                requires (_Choice<_Ty&>._Strategy != _St::_None)
+            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+                noexcept(_Choice<_Ty&>._No_throw) {
+                constexpr _St _Strat = _Choice<_Ty&>._Strategy;
+
+                if constexpr (_Strat == _St::_Member) {
+                    return _Val._Unchecked_end();
+                } else if constexpr (_Strat == _St::_Unwrap) {
+                    return _RANGES _Unwrap_range_sent<_Ty>(_RANGES end(_Val));
+                } else {
+                    _STL_INTERNAL_STATIC_ASSERT(false); // unexpected strategy
+                }
+            }
+        };
+    } // namespace _Unchecked_end
+
+    inline namespace _Cpos {
+        inline constexpr _Unchecked_end::_Cpo _Uend;
+    }
+
+    _EXPORT_STD template <class _Rng>
+    concept borrowed_range = range<_Rng> && _Should_range_access<_Rng>;
+
+    _EXPORT_STD template <range _Rng>
+    using range_difference_t = iter_difference_t<iterator_t<_Rng>>;
+
+    _EXPORT_STD template <range _Rng>
+    using range_value_t = iter_value_t<iterator_t<_Rng>>;
+
+    _EXPORT_STD template <range _Rng>
+    using range_reference_t = iter_reference_t<iterator_t<_Rng>>;
+
+    _EXPORT_STD template <range _Rng>
+    using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<_Rng>>;
+
+    _EXPORT_STD template <range _Rng>
+    using range_common_reference_t = iter_common_reference_t<iterator_t<_Rng>>;
+
+#if _HAS_CXX23
+    _EXPORT_STD template <class _Rng>
+    concept constant_range = input_range<_Rng> && _Constant_iterator<iterator_t<_Rng>>;
+
+    template <input_range _Rng>
+    _NODISCARD _MSVC_INTRINSIC constexpr auto& _Possibly_const_range(_Rng& _Range) noexcept {
+        if constexpr (constant_range<const _Rng> && !constant_range<_Rng>) {
+            return _STD as_const(_Range);
+        } else {
+            return _Range;
+        }
+    }
+
+    template <class _Ty>
+    _NODISCARD _MSVC_INTRINSIC constexpr auto _As_const_pointer(const _Ty* _Ptr) noexcept {
+        return _Ptr;
+    }
+#endif // _HAS_CXX23
+
+    struct _Cbegin_fn {
+#if _HAS_CXX23
+        template <class _Ty>
+        using _Begin_on_const = decltype(_RANGES begin(_RANGES _Possibly_const_range(_STD declval<_Ty&>())));
+
+        template <_Should_range_access _Ty>
+            requires requires(_Ty& _Val) {
+                typename _Begin_on_const<_Ty>;
+                typename const_iterator<_Begin_on_const<_Ty>>;
+                const_iterator<_Begin_on_const<_Ty>>{_RANGES begin(_RANGES _Possibly_const_range(_Val))};
+            }
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR noexcept(
+            noexcept(const_iterator<_Begin_on_const<_Ty>>{_RANGES begin(_RANGES _Possibly_const_range(_Val))})) {
+            return const_iterator<_Begin_on_const<_Ty>>{_RANGES begin(_RANGES _Possibly_const_range(_Val))};
+        }
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+        template <class _Ty, class _CTy = _Const_thru_ref<_Ty>>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+            noexcept(noexcept(_RANGES begin(static_cast<_CTy&&>(_Val))))
+            requires requires { _RANGES begin(static_cast<_CTy&&>(_Val)); }
+        {
+            return _RANGES begin(static_cast<_CTy&&>(_Val));
+        }
+#endif // ^^^ !_HAS_CXX23 ^^^
+    };
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Cbegin_fn cbegin;
+    }
+
+    struct _Cend_fn {
+#if _HAS_CXX23
+        template <class _Ty>
+        using _End_on_const = decltype(_RANGES end(_RANGES _Possibly_const_range(_STD declval<_Ty&>())));
+
+        template <_Should_range_access _Ty>
+            requires requires(_Ty& _Val) {
+                typename _End_on_const<_Ty>;
+                typename const_sentinel<_End_on_const<_Ty>>;
+                const_sentinel<_End_on_const<_Ty>>{_RANGES end(_RANGES _Possibly_const_range(_Val))};
+            }
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+            noexcept(noexcept(const_sentinel<_End_on_const<_Ty>>{_RANGES end(_RANGES _Possibly_const_range(_Val))})) {
+            return const_sentinel<_End_on_const<_Ty>>{_RANGES end(_RANGES _Possibly_const_range(_Val))};
+        }
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+        template <class _Ty, class _CTy = _Const_thru_ref<_Ty>>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+            noexcept(noexcept(_RANGES end(static_cast<_CTy&&>(_Val))))
+            requires requires { _RANGES end(static_cast<_CTy&&>(_Val)); }
+        {
+            return _RANGES end(static_cast<_CTy&&>(_Val));
+        }
+#endif // ^^^ !_HAS_CXX23 ^^^
+    };
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Cend_fn cend;
+    }
+
+    namespace _Rbegin {
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1681199
+        void rbegin() = delete; // Block unqualified name lookup
+#else // ^^^ no workaround / workaround vvv
+        void rbegin();
+#endif // ^^^ workaround ^^^
+
+        template <class _Ty>
+        concept _Has_member = requires(_Ty __t) {
+            { _STD _Fake_copy_init(__t.rbegin()) } -> input_or_output_iterator;
+        };
+
+        template <class _Ty>
+        concept _Has_ADL = _Has_class_or_enum_type<_Ty> && requires(_Ty __t) {
+            { _STD _Fake_copy_init(rbegin(__t)) } -> input_or_output_iterator; // intentional ADL
+        };
+
+        template <class _Ty>
+        concept _Can_make_reverse = requires(_Ty __t) {
+            { _RANGES begin(__t) } -> bidirectional_iterator;
+            { _RANGES end(__t) } -> same_as<decltype(_RANGES begin(__t))>;
+        };
+
+        class _Cpo {
+        private:
+            enum class _St { _None, _Member, _Non_member, _Make_reverse };
+
+            template <class _Ty>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                _STL_INTERNAL_STATIC_ASSERT(is_lvalue_reference_v<_Ty>);
+                if constexpr (_Has_member<_Ty>) {
+                    return {_St::_Member, noexcept(_STD _Fake_copy_init(_STD declval<_Ty>().rbegin()))};
+                } else if constexpr (_Has_ADL<_Ty>) {
+                    return {_St::_Non_member,
+                        noexcept(_STD _Fake_copy_init(rbegin(_STD declval<_Ty>())))}; // intentional ADL
+                } else if constexpr (_Can_make_reverse<_Ty>) {
+                    return {_St::_Make_reverse, noexcept(_STD make_reverse_iterator(_RANGES end(_STD declval<_Ty>())))};
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _Ty>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();
+
+        public:
+            template <_Should_range_access _Ty>
+                requires (_Choice<_Ty&>._Strategy != _St::_None)
+            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+                noexcept(_Choice<_Ty&>._No_throw) {
+                constexpr _St _Strat = _Choice<_Ty&>._Strategy;
+
+                if constexpr (_Strat == _St::_Member) {
+                    return _Val.rbegin();
+                } else if constexpr (_Strat == _St::_Non_member) {
+                    return rbegin(_Val); // intentional ADL
+                } else if constexpr (_Strat == _St::_Make_reverse) {
+                    return _STD make_reverse_iterator(_RANGES end(_Val));
+                } else {
+                    _STL_INTERNAL_STATIC_ASSERT(false); // unexpected strategy
+                }
+            }
+        };
+    } // namespace _Rbegin
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Rbegin::_Cpo rbegin;
+    }
+
+    namespace _Rend {
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1681199
+        void rend() = delete; // Block unqualified name lookup
+#else // ^^^ no workaround / workaround vvv
+        void rend();
+#endif // ^^^ workaround ^^^
+
+        template <class _Ty>
+        concept _Has_member = requires(_Ty __t) {
+            { _STD _Fake_copy_init(__t.rend()) } -> sentinel_for<decltype(_RANGES rbegin(__t))>;
+        };
+
+        template <class _Ty>
+        concept _Has_ADL = _Has_class_or_enum_type<_Ty> && requires(_Ty __t) {
+            // intentional ADL
+            { _STD _Fake_copy_init(rend(__t)) } -> sentinel_for<decltype(_RANGES rbegin(__t))>;
+        };
+
+        template <class _Ty>
+        concept _Can_make_reverse = requires(_Ty __t) {
+            { _RANGES begin(__t) } -> bidirectional_iterator;
+            { _RANGES end(__t) } -> same_as<decltype(_RANGES begin(__t))>;
+        };
+
+        class _Cpo {
+        private:
+            enum class _St { _None, _Member, _Non_member, _Make_reverse };
+
+            template <class _Ty>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                _STL_INTERNAL_STATIC_ASSERT(is_lvalue_reference_v<_Ty>);
+                if constexpr (_Has_member<_Ty>) {
+                    return {_St::_Member, noexcept(_STD _Fake_copy_init(_STD declval<_Ty>().rend()))};
+                } else if constexpr (_Has_ADL<_Ty>) {
+                    return {
+                        _St::_Non_member, noexcept(_STD _Fake_copy_init(rend(_STD declval<_Ty>())))}; // intentional ADL
+                } else if constexpr (_Can_make_reverse<_Ty>) {
+                    return {
+                        _St::_Make_reverse, noexcept(_STD make_reverse_iterator(_RANGES begin(_STD declval<_Ty>())))};
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _Ty>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();
+
+        public:
+            template <_Should_range_access _Ty>
+                requires (_Choice<_Ty&>._Strategy != _St::_None)
+            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+                noexcept(_Choice<_Ty&>._No_throw) {
+                constexpr _St _Strat = _Choice<_Ty&>._Strategy;
+
+                if constexpr (_Strat == _St::_Member) {
+                    return _Val.rend();
+                } else if constexpr (_Strat == _St::_Non_member) {
+                    return rend(_Val); // intentional ADL
+                } else if constexpr (_Strat == _St::_Make_reverse) {
+                    return _STD make_reverse_iterator(_RANGES begin(_Val));
+                } else {
+                    _STL_INTERNAL_STATIC_ASSERT(false); // unexpected strategy
+                }
+            }
+        };
+    } // namespace _Rend
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Rend::_Cpo rend;
+    }
+
+    struct _Crbegin_fn {
+#if _HAS_CXX23
+        template <class _Ty>
+        using _Rbegin_on_const = decltype(_RANGES rbegin(_RANGES _Possibly_const_range(_STD declval<_Ty&>())));
+
+        template <_Should_range_access _Ty>
+            requires requires(_Ty& _Val) {
+                typename _Rbegin_on_const<_Ty>;
+                typename const_iterator<_Rbegin_on_const<_Ty>>;
+                const_iterator<_Rbegin_on_const<_Ty>>{_RANGES rbegin(_RANGES _Possibly_const_range(_Val))};
+            }
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR noexcept(
+            noexcept(const_iterator<_Rbegin_on_const<_Ty>>{_RANGES rbegin(_RANGES _Possibly_const_range(_Val))})) {
+            return const_iterator<_Rbegin_on_const<_Ty>>{_RANGES rbegin(_RANGES _Possibly_const_range(_Val))};
+        }
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+        template <class _Ty, class _CTy = _Const_thru_ref<_Ty>>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+            noexcept(noexcept(_RANGES rbegin(static_cast<_CTy&&>(_Val))))
+            requires requires { _RANGES rbegin(static_cast<_CTy&&>(_Val)); }
+        {
+            return _RANGES rbegin(static_cast<_CTy&&>(_Val));
+        }
+#endif // ^^^ !_HAS_CXX23 ^^^
+    };
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Crbegin_fn crbegin;
+    }
+
+    struct _Crend_fn {
+#if _HAS_CXX23
+        template <class _Ty>
+        using _Rend_on_const = decltype(_RANGES rend(_RANGES _Possibly_const_range(_STD declval<_Ty&>())));
+
+        template <_Should_range_access _Ty>
+            requires requires(_Ty& _Val) {
+                typename _Rend_on_const<_Ty>;
+                typename const_sentinel<_Rend_on_const<_Ty>>;
+                const_sentinel<_Rend_on_const<_Ty>>{_RANGES rend(_RANGES _Possibly_const_range(_Val))};
+            }
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+            noexcept(noexcept(const_sentinel<_Rend_on_const<_Ty>>{_RANGES rend(_RANGES _Possibly_const_range(_Val))})) {
+            return const_sentinel<_Rend_on_const<_Ty>>{_RANGES rend(_RANGES _Possibly_const_range(_Val))};
+        }
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+        template <class _Ty, class _CTy = _Const_thru_ref<_Ty>>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+            noexcept(noexcept(_RANGES rend(static_cast<_CTy&&>(_Val))))
+            requires requires { _RANGES rend(static_cast<_CTy&&>(_Val)); }
+        {
+            return _RANGES rend(static_cast<_CTy&&>(_Val));
+        }
+#endif // ^^^ !_HAS_CXX23 ^^^
+    };
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Crend_fn crend;
+    }
+
+    _EXPORT_STD template <class>
+    constexpr bool disable_sized_range = false;
+
+    namespace _Size {
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1681199
+        void size() = delete; // Block unqualified name lookup
+#else // ^^^ no workaround / workaround vvv
+        void size();
+#endif // ^^^ workaround ^^^
+
+        template <class _Ty, class _UnCV>
+        concept _Has_member = !disable_sized_range<_UnCV> && requires(_Ty __t) {
+            { _STD _Fake_copy_init(__t.size()) } -> _Integer_like;
+        };
+
+        template <class _Ty, class _UnCV>
+        concept _Has_ADL = _Has_class_or_enum_type<_Ty> && !disable_sized_range<_UnCV> && requires(_Ty __t) {
+            { _STD _Fake_copy_init(size(__t)) } -> _Integer_like; // intentional ADL
+        };
+
+        template <class _Ty>
+        concept _Can_difference = requires(_Ty __t) {
+            { _RANGES begin(__t) } -> forward_iterator;
+            { _RANGES end(__t) } -> sized_sentinel_for<decltype(_RANGES begin(__t))>;
+        };
+
+        class _Cpo {
+        private:
+            enum class _St { _None, _Array, _Member, _Non_member, _Subtract };
+
+            template <class _Ty>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                _STL_INTERNAL_STATIC_ASSERT(is_lvalue_reference_v<_Ty>);
+                using _UnCV = remove_cvref_t<_Ty>;
+
+                if constexpr (is_array_v<_UnCV>) {
+                    if constexpr (extent_v<_UnCV> != 0) {
+                        return {_St::_Array, true};
+                    } else {
+                        return {_St::_None};
+                    }
+                } else if constexpr (_Has_member<_Ty, _UnCV>) {
+                    return {_St::_Member, noexcept(_STD _Fake_copy_init(_STD declval<_Ty>().size()))};
+                } else if constexpr (_Has_ADL<_Ty, _UnCV>) {
+                    return {
+                        _St::_Non_member, noexcept(_STD _Fake_copy_init(size(_STD declval<_Ty>())))}; // intentional ADL
+                } else if constexpr (_Can_difference<_Ty>) {
+                    return {_St::_Subtract,
+                        noexcept(_RANGES end(_STD declval<_Ty>()) - _RANGES begin(_STD declval<_Ty>()))};
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _Ty>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();
+
+        public:
+            template <class _Ty>
+                requires (_Choice<_Ty&>._Strategy != _St::_None)
+            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+                noexcept(_Choice<_Ty&>._No_throw) {
+                constexpr _St _Strat = _Choice<_Ty&>._Strategy;
+
+                if constexpr (_Strat == _St::_Array) {
+                    // extent_v<remove_cvref_t<_Ty&>> reuses specializations from _Choose
+                    return extent_v<remove_cvref_t<_Ty&>>;
+                } else if constexpr (_Strat == _St::_Member) {
+                    return _Val.size();
+                } else if constexpr (_Strat == _St::_Non_member) {
+                    return size(_Val); // intentional ADL
+                } else if constexpr (_Strat == _St::_Subtract) {
+                    const auto _Delta = _RANGES end(_Val) - _RANGES begin(_Val);
+                    return static_cast<_Make_unsigned_like_t<remove_cv_t<decltype(_Delta)>>>(_Delta);
+                } else {
+                    _STL_INTERNAL_STATIC_ASSERT(false); // unexpected strategy
+                }
+            }
+        };
+    } // namespace _Size
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Size::_Cpo size;
+    }
+
+    namespace _Empty {
+        template <class _Ty>
+        concept _Has_member = requires(_Ty __t) { static_cast<bool>(__t.empty()); };
+
+        template <class _Ty>
+        concept _Has_size = requires(_Ty __t) { _RANGES size(__t); };
+
+        template <class _Ty>
+        concept _Can_begin_end = requires(_Ty __t) {
+            { _RANGES begin(__t) } -> forward_iterator;
+            _RANGES end(__t);
+        };
+
+        class _Cpo {
+        private:
+            enum class _St { _None, _Member, _Size, _Compare };
+
+            template <class _Ty>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                _STL_INTERNAL_STATIC_ASSERT(is_lvalue_reference_v<_Ty>);
+                if constexpr (is_unbounded_array_v<remove_reference_t<_Ty>>) {
+                    return {_St::_None};
+                } else if constexpr (_Has_member<_Ty>) {
+                    return {_St::_Member, noexcept(static_cast<bool>(_STD declval<_Ty>().empty()))};
+                } else if constexpr (_Has_size<_Ty>) {
+                    return {_St::_Size, noexcept(_RANGES size(_STD declval<_Ty>()))};
+                } else if constexpr (_Can_begin_end<_Ty>) {
+                    constexpr auto _Nothrow = noexcept(
+                        static_cast<bool>(_RANGES begin(_STD declval<_Ty>()) == _RANGES end(_STD declval<_Ty>())));
+                    return {_St::_Compare, _Nothrow};
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _Ty>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();
+
+        public:
+            template <class _Ty>
+                requires (_Choice<_Ty&>._Strategy != _St::_None)
+            _NODISCARD _STATIC_CALL_OPERATOR constexpr bool operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+                noexcept(_Choice<_Ty&>._No_throw) {
+                constexpr _St _Strat = _Choice<_Ty&>._Strategy;
+
+                if constexpr (_Strat == _St::_Member) {
+                    return static_cast<bool>(_Val.empty());
+                } else if constexpr (_Strat == _St::_Size) {
+                    return _RANGES size(_Val) == 0;
+                } else if constexpr (_Strat == _St::_Compare) {
+                    return static_cast<bool>(_RANGES begin(_Val) == _RANGES end(_Val));
+                } else {
+                    _STL_INTERNAL_STATIC_ASSERT(false); // unexpected strategy
+                }
+            }
+        };
+    } // namespace _Empty
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Empty::_Cpo empty;
+    }
+
+    namespace _Data {
+        template <class _Ty>
+        concept _Points_to_object = is_pointer_v<_Ty> && is_object_v<remove_pointer_t<_Ty>>;
+
+        template <class _Ty>
+        concept _Has_member = requires(_Ty __t) {
+            { _STD _Fake_copy_init(__t.data()) } -> _Points_to_object;
+        };
+
+        template <class _Ty>
+        concept _Has_contiguous_iterator = requires(_Ty __t) {
+            { _RANGES begin(__t) } -> contiguous_iterator;
+        };
+
+        class _Cpo {
+        private:
+            enum class _St { _None, _Member, _Address };
+
+            template <class _Ty>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                _STL_INTERNAL_STATIC_ASSERT(is_lvalue_reference_v<_Ty>);
+                if constexpr (_Has_member<_Ty>) {
+                    return {_St::_Member, noexcept(_STD declval<_Ty>().data())};
+                } else if constexpr (_Has_contiguous_iterator<_Ty>) {
+                    return {_St::_Address, noexcept(_STD to_address(_RANGES begin(_STD declval<_Ty>())))};
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _Ty>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();
+
+        public:
+            template <_Should_range_access _Ty>
+                requires (_Choice<_Ty&>._Strategy != _St::_None)
+            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+                noexcept(_Choice<_Ty&>._No_throw) {
+                constexpr _St _Strat = _Choice<_Ty&>._Strategy;
+
+                if constexpr (_Strat == _St::_Member) {
+                    return _Val.data();
+                } else if constexpr (_Strat == _St::_Address) {
+                    return _STD to_address(_RANGES begin(_Val));
+                } else {
+                    _STL_INTERNAL_STATIC_ASSERT(false); // unexpected strategy
+                }
+            }
+        };
+    } // namespace _Data
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Data::_Cpo data;
+    }
+
+    struct _Cdata_fn {
+#if _HAS_CXX23
+        template <_Should_range_access _Ty>
+            requires requires(_Ty& _Val) { //
+                _RANGES _As_const_pointer(_RANGES data(_RANGES _Possibly_const_range(_Val)));
+            }
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+            noexcept(noexcept(_RANGES data(_RANGES _Possibly_const_range(_Val)))) {
+            return _RANGES _As_const_pointer(_RANGES data(_RANGES _Possibly_const_range(_Val)));
+        }
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+        template <class _Ty, class _CTy = _Const_thru_ref<_Ty>>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+            noexcept(noexcept(_RANGES data(static_cast<_CTy&&>(_Val))))
+            requires requires { _RANGES data(static_cast<_CTy&&>(_Val)); }
+        {
+            return _RANGES data(static_cast<_CTy&&>(_Val));
+        }
+#endif // ^^^ !_HAS_CXX23 ^^^
+    };
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Cdata_fn cdata;
+    }
+
+    _EXPORT_STD template <class _Rng>
+    concept sized_range = range<_Rng> && requires(_Rng& __r) { _RANGES size(__r); };
+
+    _EXPORT_STD template <sized_range _Rng>
+    using range_size_t = decltype(_RANGES size(_STD declval<_Rng&>()));
+
+    _EXPORT_STD struct view_base {};
+
+    template <class _Ty, template <class...> class _Template>
+    concept _Strictly_derived_from_specialization_of =
+        is_object_v<_Ty> && _Derived_from_specialization_of<_Ty, _Template>;
+
+    _EXPORT_STD template <class _Derived>
+        requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
+    class view_interface;
+
+    _EXPORT_STD template <class _Ty>
+    constexpr bool enable_view =
+        derived_from<_Ty, view_base> || _Strictly_derived_from_specialization_of<_Ty, view_interface>;
+
+    _EXPORT_STD template <class _Ty>
+    concept view = range<_Ty> && movable<_Ty> && enable_view<_Ty>;
+
+    _EXPORT_STD template <class _Rng, class _Ty>
+    concept output_range = range<_Rng> && output_iterator<iterator_t<_Rng>, _Ty>;
+
+    _EXPORT_STD template <class _Rng>
+    concept forward_range = range<_Rng> && forward_iterator<iterator_t<_Rng>>;
+
+    _EXPORT_STD template <class _Rng>
+    concept bidirectional_range = range<_Rng> && bidirectional_iterator<iterator_t<_Rng>>;
+
+    _EXPORT_STD template <class _Rng>
+    concept random_access_range = range<_Rng> && random_access_iterator<iterator_t<_Rng>>;
+
+    _EXPORT_STD template <class _Rng>
+    concept contiguous_range = range<_Rng> && contiguous_iterator<iterator_t<_Rng>> && requires(_Rng& __r) {
+        { _RANGES data(__r) } -> same_as<add_pointer_t<range_reference_t<_Rng>>>;
+    };
+
+    class _Advance_fn {
+    public:
+        template <input_or_output_iterator _It>
+        _STATIC_CALL_OPERATOR constexpr void operator()(_It& _Where, iter_difference_t<_It> _Off) _CONST_CALL_OPERATOR {
+            if constexpr (random_access_iterator<_It>) {
+                _Where += _Off;
+            } else {
+                if constexpr (!bidirectional_iterator<_It>) {
+                    _STL_ASSERT(_Off >= 0, "negative advance of non-bidirectional iterator");
+                }
+
+                decltype(auto) _UWhere      = _STD _Get_unwrapped_n(_STD move(_Where), _Off);
+                constexpr bool _Need_rewrap = !is_reference_v<decltype(_STD _Get_unwrapped_n(_STD move(_Where), _Off))>;
+
+                if constexpr (bidirectional_iterator<_It>) {
+                    for (; _Off < 0; ++_Off) {
+                        --_UWhere;
+                    }
+                }
+
+                for (; _Off > 0; --_Off) {
+                    ++_UWhere;
+                }
+
+                if constexpr (_Need_rewrap) {
+                    _STD _Seek_wrapped(_Where, _STD move(_UWhere));
+                }
+            }
+        }
+
+        template <input_or_output_iterator _It, sentinel_for<_It> _Se>
+        _STATIC_CALL_OPERATOR constexpr void operator()(_It& _Where, _Se _Last) _CONST_CALL_OPERATOR {
+            if constexpr (assignable_from<_It&, _Se>) {
+                _Where = static_cast<_Se&&>(_Last);
+            } else if constexpr (sized_sentinel_for<_Se, _It>) {
+                operator()(_Where, _Last - _Where);
+            } else {
+                _STD _Adl_verify_range(_Where, _Last);
+
+                decltype(auto) _UWhere = _RANGES _Unwrap_iter<_Se>(static_cast<_It&&>(_Where));
+                constexpr bool _Need_rewrap =
+                    !is_reference_v<decltype(_RANGES _Unwrap_iter<_Se>(static_cast<_It&&>(_Where)))>;
+                decltype(auto) _ULast = _RANGES _Unwrap_sent<_It>(static_cast<_Se&&>(_Last));
+
+                while (_UWhere != _ULast) {
+                    ++_UWhere;
+                }
+
+                if constexpr (_Need_rewrap) {
+                    _STD _Seek_wrapped(_Where, _STD move(_UWhere));
+                }
+            }
+        }
+
+        template <input_or_output_iterator _It, sentinel_for<_It> _Se>
+        _STATIC_CALL_OPERATOR constexpr iter_difference_t<_It> operator()(
+            _It& _Where, iter_difference_t<_It> _Off, _Se _Last) _CONST_CALL_OPERATOR {
+            if constexpr (sized_sentinel_for<_Se, _It>) {
+                const iter_difference_t<_It> _Delta = _Last - _Where;
+                if ((_Off < 0 && _Off <= _Delta) || (_Off > 0 && _Off >= _Delta)) {
+                    if constexpr (assignable_from<_It&, _Se>) {
+                        _Where = static_cast<_Se&&>(_Last);
+                    } else {
+                        operator()(_Where, _Delta);
+                    }
+                    return _Off - _Delta;
+                }
+
+                operator()(_Where, _Off);
+                return 0;
+            } else {
+                // performance note: develop unwrapping technology for (i, n, s)?
+                if constexpr (bidirectional_iterator<_It>) {
+                    for (; _Off < 0 && _Where != _Last; ++_Off) {
+                        --_Where;
+                    }
+                } else {
+                    _STL_ASSERT(_Off >= 0, "negative advance of non-bidirectional iterator");
+                }
+
+                for (; _Off > 0 && _Where != _Last; --_Off) {
+                    ++_Where;
+                }
+
+                return _Off;
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Advance_fn advance;
+
+    class _Distance_fn {
+    public:
+        template <class _It, sentinel_for<_It> _Se>
+            requires (!sized_sentinel_for<_Se, _It>)
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr iter_difference_t<_It> operator()(
+            _It _First, _Se _Last) _CONST_CALL_OPERATOR
+            noexcept(noexcept(_Distance_unchecked(
+                _STD _Get_unwrapped(_STD move(_First)), _STD _Get_unwrapped(_STD move(_Last))))) /* strengthened */ {
+            _STD _Adl_verify_range(_First, _Last);
+            return _Distance_unchecked(
+                _RANGES _Unwrap_iter<_Se>(_STD move(_First)), _RANGES _Unwrap_sent<_It>(_STD move(_Last)));
+        }
+
+        template <class _It, sized_sentinel_for<decay_t<_It>> _Se>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr iter_difference_t<decay_t<_It>> operator()(
+            _It&& _First, const _Se _Last) _CONST_CALL_OPERATOR
+            noexcept(noexcept(_Last - static_cast<const decay_t<_It>&>(_First))) /* strengthened */ {
+            return _Last - static_cast<const decay_t<_It>&>(_First);
+        }
+
+        template <range _Rng>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr range_difference_t<_Rng> operator()(
+            _Rng&& _Range) _CONST_CALL_OPERATOR noexcept(_Nothrow_size<_Rng>) /* strengthened */ {
+            if constexpr (sized_range<_Rng>) {
+                return static_cast<range_difference_t<_Rng>>(_RANGES size(_Range));
+            } else {
+                return _Distance_unchecked(_Ubegin(_Range), _Uend(_Range));
+            }
+        }
+
+    private:
+        template <class _It, class _Se>
+        _NODISCARD static constexpr iter_difference_t<_It> _Distance_unchecked(_It _First, const _Se _Last) noexcept(
+            noexcept(++_First != _Last)) {
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+
+            iter_difference_t<_It> _Count = 0;
+            for (; _First != _Last; ++_First) {
+                ++_Count;
+            }
+
+            return _Count;
+        }
+
+        template <class _Rng>
+        static constexpr bool _Nothrow_size =
+            noexcept(_Distance_unchecked(_Ubegin(_STD declval<_Rng&>()), _Uend(_STD declval<_Rng&>())));
+
+        template <sized_range _Rng>
+        static constexpr bool _Nothrow_size<_Rng> = noexcept(_RANGES size(_STD declval<_Rng&>()));
+    };
+
+    _EXPORT_STD inline constexpr _Distance_fn distance;
+
+    class _Ssize_fn {
+    public:
+        template <class _Rng>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Rng&& _Range) _CONST_CALL_OPERATOR
+            noexcept(noexcept(_RANGES size(_Range)))
+            requires requires { _RANGES size(_Range); }
+        {
+            using _Sty = _Make_signed_like_t<decltype(_RANGES size(_Range))>;
+            using _Ty  = common_type_t<conditional_t<is_integral_v<_Sty>, ptrdiff_t, _Sty>, _Sty>;
+            return static_cast<_Ty>(_RANGES size(_Range));
+        }
+    };
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Ssize_fn ssize;
+    }
+
+    class _Next_fn {
+    public:
+        template <input_or_output_iterator _It>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr _It operator()(_It _Where) _CONST_CALL_OPERATOR {
+            ++_Where;
+            return _Where;
+        }
+
+        template <input_or_output_iterator _It>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr _It operator()(
+            _It _Where, const iter_difference_t<_It> _Off) _CONST_CALL_OPERATOR {
+            _RANGES advance(_Where, _Off);
+            return _Where;
+        }
+
+        template <input_or_output_iterator _It, sentinel_for<_It> _Se>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr _It operator()(_It _Where, _Se _Last) _CONST_CALL_OPERATOR {
+            _RANGES advance(_Where, static_cast<_Se&&>(_Last));
+            return _Where;
+        }
+
+        template <input_or_output_iterator _It, sentinel_for<_It> _Se>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr _It operator()(
+            _It _Where, const iter_difference_t<_It> _Off, _Se _Last) _CONST_CALL_OPERATOR {
+            _RANGES advance(_Where, _Off, static_cast<_Se&&>(_Last));
+            return _Where;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Next_fn next;
+
+    class _Prev_fn {
+    public:
+        template <bidirectional_iterator _It>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr _It operator()(_It _Where) _CONST_CALL_OPERATOR {
+            --_Where;
+            return _Where;
+        }
+
+        template <bidirectional_iterator _It>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr _It operator()(
+            _It _Where, const iter_difference_t<_It> _Off) _CONST_CALL_OPERATOR {
+            _STL_ASSERT(_Off != _Min_possible_v<iter_difference_t<_It>>, "integer overflow");
+            _RANGES advance(_Where, -_Off);
+            return _Where;
+        }
+
+        template <bidirectional_iterator _It>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr _It operator()(
+            _It _Where, const iter_difference_t<_It> _Off, _It _Last) _CONST_CALL_OPERATOR {
+            _STL_ASSERT(_Off != _Min_possible_v<iter_difference_t<_It>>, "integer overflow");
+            _RANGES advance(_Where, -_Off, static_cast<_It&&>(_Last));
+            return _Where;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Prev_fn prev;
+
+    template <forward_iterator _It, sentinel_for<_It> _Se>
+    _NODISCARD constexpr _It _Find_last_iterator(
+        const _It& _First, const _Se& _Last, const iter_difference_t<_It> _Count) {
+        // Find the iterator in [_First, _Last) (of length _Count) which equals _Last
+        _STL_INTERNAL_CHECK(_RANGES distance(_First, _Last) == _Count);
+        if constexpr (is_same_v<_It, _Se>) {
+            return _Last;
+        } else {
+            return _RANGES next(_First, _Count);
+        }
+    }
+
+    _EXPORT_STD struct equal_to {
+        template <class _Ty1, class _Ty2>
+            requires equality_comparable_with<_Ty1, _Ty2>
+        _NODISCARD constexpr bool operator()(_Ty1&& _Left, _Ty2&& _Right) const noexcept(
+            noexcept(static_cast<bool>(static_cast<_Ty1&&>(_Left) == static_cast<_Ty2&&>(_Right)))) /* strengthened */ {
+            return static_cast<bool>(static_cast<_Ty1&&>(_Left) == static_cast<_Ty2&&>(_Right));
+        }
+
+        using is_transparent = int;
+    };
+
+    _EXPORT_STD struct less {
+        template <class _Ty1, class _Ty2>
+            requires totally_ordered_with<_Ty1, _Ty2>
+        _NODISCARD constexpr bool operator()(_Ty1&& _Left, _Ty2&& _Right) const noexcept(
+            noexcept(static_cast<bool>(static_cast<_Ty1&&>(_Left) < static_cast<_Ty2&&>(_Right)))) /* strengthened */ {
+            return static_cast<bool>(static_cast<_Ty1&&>(_Left) < static_cast<_Ty2&&>(_Right));
+        }
+
+        using is_transparent = int;
+    };
+
+    _EXPORT_STD struct greater {
+        template <class _Ty1, class _Ty2>
+            requires totally_ordered_with<_Ty1, _Ty2>
+        _NODISCARD constexpr bool operator()(_Ty1&& _Left, _Ty2&& _Right) const noexcept(
+            noexcept(static_cast<bool>(static_cast<_Ty2&&>(_Right) < static_cast<_Ty1&&>(_Left)))) /* strengthened */ {
+            return static_cast<bool>(static_cast<_Ty2&&>(_Right) < static_cast<_Ty1&&>(_Left));
+        }
+
+        using is_transparent = int;
+    };
+
+    _EXPORT_STD template <class _Rng>
+    concept common_range = range<_Rng> && same_as<iterator_t<_Rng>, sentinel_t<_Rng>>;
+
+    template <class _It, class _Se>
+    concept _Bidi_common = is_same_v<_It, _Se> && bidirectional_iterator<_It>;
+    template <class _Rng>
+    concept _Bidi_common_range = common_range<_Rng> && bidirectional_iterator<iterator_t<_Rng>>;
+
+    template <class _Ty>
+    concept _Can_empty = requires(_Ty __t) { _RANGES empty(__t); };
+
+    _EXPORT_STD template <class _Derived>
+        requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
+    class view_interface {
+    private:
+        _NODISCARD constexpr _Derived& _Cast() noexcept {
+            static_assert(derived_from<_Derived, view_interface>,
+                "view_interface's template argument D must derive from view_interface<D> "
+                "(N4950 [view.interface.general]/2).");
+            static_assert(view<_Derived>,
+                "view_interface's template argument must model the view concept (N4950 [view.interface.general]/2).");
+            return static_cast<_Derived&>(*this);
+        }
+
+        _NODISCARD constexpr const _Derived& _Cast() const noexcept {
+            static_assert(derived_from<_Derived, view_interface>,
+                "view_interface's template argument D must derive from view_interface<D> "
+                "(N4950 [view.interface.general]/2).");
+            static_assert(view<_Derived>,
+                "view_interface's template argument must model the view concept (N4950 [view.interface.general]/2).");
+            return static_cast<const _Derived&>(*this);
+        }
+
+    public:
+        _NODISCARD constexpr bool empty()
+            requires sized_range<_Derived> || forward_range<_Derived>
+        {
+            auto& _Self = _Cast();
+            if constexpr (sized_range<_Derived>) {
+                return _RANGES size(_Self) == 0;
+            } else {
+                return _RANGES begin(_Self) == _RANGES end(_Self);
+            }
+        }
+
+        _NODISCARD constexpr bool empty() const
+            requires sized_range<const _Derived> || forward_range<const _Derived>
+        {
+            auto& _Self = _Cast();
+            if constexpr (sized_range<const _Derived>) {
+                return _RANGES size(_Self) == 0;
+            } else {
+                return _RANGES begin(_Self) == _RANGES end(_Self);
+            }
+        }
+
+#if _HAS_CXX23
+        _NODISCARD constexpr auto cbegin()
+            requires input_range<_Derived>
+        {
+            return _RANGES cbegin(_Cast());
+        }
+
+        _NODISCARD constexpr auto cbegin() const
+            requires input_range<const _Derived>
+        {
+            return _RANGES cbegin(_Cast());
+        }
+
+        _NODISCARD constexpr auto cend()
+            requires input_range<_Derived>
+        {
+            return _RANGES cend(_Cast());
+        }
+
+        _NODISCARD constexpr auto cend() const
+            requires input_range<const _Derived>
+        {
+            return _RANGES cend(_Cast());
+        }
+#endif // _HAS_CXX23
+
+        constexpr explicit operator bool()
+            requires _Can_empty<_Derived>
+        {
+            return !_RANGES empty(_Cast());
+        }
+
+        constexpr explicit operator bool() const
+            requires _Can_empty<const _Derived>
+        {
+            return !_RANGES empty(_Cast());
+        }
+
+        _NODISCARD constexpr auto data()
+            requires contiguous_iterator<iterator_t<_Derived>>
+        {
+            return _STD to_address(_RANGES begin(_Cast()));
+        }
+
+        _NODISCARD constexpr auto data() const
+            requires range<const _Derived> && contiguous_iterator<iterator_t<const _Derived>>
+        {
+            return _STD to_address(_RANGES begin(_Cast()));
+        }
+
+        _NODISCARD constexpr auto size()
+            requires forward_range<_Derived> && sized_sentinel_for<sentinel_t<_Derived>, iterator_t<_Derived>>
+        {
+            auto& _Self = _Cast();
+            return _STD _To_unsigned_like(_RANGES end(_Self) - _RANGES begin(_Self));
+        }
+
+        _NODISCARD constexpr auto size() const
+            requires forward_range<const _Derived>
+                  && sized_sentinel_for<sentinel_t<const _Derived>, iterator_t<const _Derived>>
+        {
+            auto& _Self = _Cast();
+            return _STD _To_unsigned_like(_RANGES end(_Self) - _RANGES begin(_Self));
+        }
+
+        _NODISCARD constexpr decltype(auto) front()
+            requires forward_range<_Derived>
+        {
+            auto& _Self = _Cast();
+#if _CONTAINER_DEBUG_LEVEL > 0
+            _STL_VERIFY(!_RANGES empty(_Self), "front called on empty view_interface");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+            return *_RANGES begin(_Self);
+        }
+
+        _NODISCARD constexpr decltype(auto) front() const
+            requires forward_range<const _Derived>
+        {
+            auto& _Self = _Cast();
+#if _CONTAINER_DEBUG_LEVEL > 0
+            _STL_VERIFY(!_RANGES empty(_Self), "front called on empty view_interface");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+            return *_RANGES begin(_Self);
+        }
+
+        _NODISCARD constexpr decltype(auto) back()
+            requires bidirectional_range<_Derived> && common_range<_Derived>
+        {
+            auto& _Self = _Cast();
+#if _CONTAINER_DEBUG_LEVEL > 0
+            _STL_VERIFY(!_RANGES empty(_Self), "back called on empty view_interface");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+            auto _Last = _RANGES end(_Self);
+            return *--_Last;
+        }
+
+        _NODISCARD constexpr decltype(auto) back() const
+            requires bidirectional_range<const _Derived> && common_range<const _Derived>
+        {
+            auto& _Self = _Cast();
+#if _CONTAINER_DEBUG_LEVEL > 0
+            _STL_VERIFY(!_RANGES empty(_Self), "back called on empty view_interface");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+            auto _Last = _RANGES end(_Self);
+            return *--_Last;
+        }
+
+        template <random_access_range _Rng = _Derived>
+        _NODISCARD constexpr decltype(auto) operator[](const range_difference_t<_Rng> _Idx) {
+            auto& _Self = _Cast();
+#if _CONTAINER_DEBUG_LEVEL > 0
+            if constexpr (sized_range<_Derived>) {
+                using _U_diff = _Make_unsigned_like_t<range_difference_t<_Rng>>;
+                _STL_VERIFY(static_cast<_U_diff>(_Idx) < static_cast<_U_diff>(_RANGES size(_Self)),
+                    "index out of range for view_interface");
+            }
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+            return _RANGES begin(_Self)[_Idx];
+        }
+
+        template <random_access_range _Rng = const _Derived>
+        _NODISCARD constexpr decltype(auto) operator[](const range_difference_t<_Rng> _Idx) const {
+            auto& _Self = _Cast();
+#if _CONTAINER_DEBUG_LEVEL > 0
+            if constexpr (sized_range<_Derived>) {
+                using _U_diff = _Make_unsigned_like_t<range_difference_t<_Rng>>;
+                _STL_VERIFY(static_cast<_U_diff>(_Idx) < static_cast<_U_diff>(_RANGES size(_Self)),
+                    "index out of range for view_interface");
+            }
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+            return _RANGES begin(_Self)[_Idx];
+        }
+    };
+} // namespace ranges
+
+namespace ranges {
+    template <class _From, class _To>
+    concept _Uses_nonqualification_pointer_conversion =
+        is_pointer_v<_From> && is_pointer_v<_To>
+        && !convertible_to<remove_pointer_t<_From> (*)[], remove_pointer_t<_To> (*)[]>;
+
+    template <class _From, class _To>
+    concept _Convertible_to_non_slicing =
+        convertible_to<_From, _To> && !_Uses_nonqualification_pointer_conversion<decay_t<_From>, decay_t<_To>>;
+
+#if !_HAS_CXX23
+    template <class _Ty>
+    concept _Pair_like = !is_reference_v<_Ty> && requires(_Ty __t) {
+        typename tuple_size<_Ty>::type;
+        requires derived_from<tuple_size<_Ty>, integral_constant<size_t, 2>>;
+        typename tuple_element_t<0, remove_const_t<_Ty>>;
+        typename tuple_element_t<1, remove_const_t<_Ty>>;
+        { _STD get<0>(__t) } -> convertible_to<const tuple_element_t<0, _Ty>&>;
+        { _STD get<1>(__t) } -> convertible_to<const tuple_element_t<1, _Ty>&>;
+    };
+#endif // !_HAS_CXX23
+
+    template <class _Ty, class _First, class _Second>
+    concept _Pair_like_convertible_from = !range<_Ty>
+#if _HAS_CXX23
+                                       && !is_reference_v<_Ty>
+#endif // _HAS_CXX23
+                                       && _Pair_like<_Ty> && constructible_from<_Ty, _First, _Second>
+                                       && _Convertible_to_non_slicing<_First, tuple_element_t<0, _Ty>>
+                                       && convertible_to<_Second, tuple_element_t<1, _Ty>>;
+
+    template <class _It, class _Se, subrange_kind _Ki>
+    concept _Store_size = (_Ki == subrange_kind::sized) && !sized_sentinel_for<_Se, _It>;
+
+    template <class _It, class _Se, subrange_kind _Ki>
+    class _Subrange_base : public view_interface<subrange<_It, _Se, _Ki>> {
+    protected:
+        using _Size_type = _Make_unsigned_like_t<iter_difference_t<_It>>;
+
+    public:
+        _Subrange_base() = default;
+        constexpr explicit _Subrange_base(const _Size_type&) noexcept {}
+    };
+
+    template <class _It, class _Se, subrange_kind _Ki>
+        requires _Store_size<_It, _Se, _Ki>
+    class _Subrange_base<_It, _Se, _Ki> : public view_interface<subrange<_It, _Se, _Ki>> {
+    protected:
+        using _Size_type = _Make_unsigned_like_t<iter_difference_t<_It>>;
+
+        _Size_type _Size = 0;
+
+    public:
+        _Subrange_base() = default;
+        constexpr explicit _Subrange_base(const _Size_type& _Size_) noexcept : _Size(_Size_) {}
+    };
+
+    _EXPORT_STD template <input_or_output_iterator _It, sentinel_for<_It> _Se, subrange_kind _Ki>
+        requires (_Ki == subrange_kind::sized || !sized_sentinel_for<_Se, _It>)
+    class subrange : public _Subrange_base<_It, _Se, _Ki> {
+    private:
+        using _Size_type = _Make_unsigned_like_t<iter_difference_t<_It>>;
+
+        // TRANSITION, [[no_unique_address]]:
+        /* [[no_unique_address]] */ _It _First{};
+        /* [[no_unique_address]] */ _Se _Last{};
+        // [[no_unique_address]] conditional_t<_Store_size<_It, _Se, _Ki>, _Size_type, _Nil> _Size{};
+
+        template <class _Rng>
+        constexpr subrange(true_type, _Rng&& _Val)
+            : subrange(_STD forward<_Rng>(_Val), static_cast<_Size_type>(_RANGES size(_Val))) {
+            // delegation target for subrange(_Rng&&) when we must store the range size
+            _STL_INTERNAL_STATIC_ASSERT(_Store_size<_It, _Se, _Ki>);
+        }
+
+        template <class _Rng>
+        constexpr subrange(false_type, _Rng&& _Val) : subrange(_RANGES begin(_Val), _RANGES end(_Val)) {
+            // delegation target for subrange(_Rng&&) when we need not store the range size
+            _STL_INTERNAL_STATIC_ASSERT(!_Store_size<_It, _Se, _Ki>);
+        }
+
+    public:
+        // clang-format off
+        subrange() requires default_initializable<_It> = default;
+        // clang-format on
+
+        template <_Convertible_to_non_slicing<_It> _It2>
+        constexpr subrange(_It2 _First_, _Se _Last_)
+            requires (!_Store_size<_It, _Se, _Ki>)
+            : _First(_STD move(_First_)), _Last(_STD move(_Last_)) {}
+
+        template <_Convertible_to_non_slicing<_It> _It2>
+        constexpr subrange(_It2 _First_, _Se _Last_, const _Size_type _Size_)
+            requires (_Ki == subrange_kind::sized)
+            : _Subrange_base<_It, _Se, _Ki>(_Size_), _First(_STD move(_First_)), _Last(_STD move(_Last_)) {
+            if constexpr (sized_sentinel_for<_Se, _It>) {
+                _STL_ASSERT(_Size_ == static_cast<_Size_type>(_Last - _First),
+                    "This constructor's third argument should be equal to the distance "
+                    "between the first and second arguments (N4950 [range.subrange.ctor]/3).");
+            }
+        }
+
+        template <_Different_from<subrange> _Rng>
+            requires (borrowed_range<_Rng> && _Convertible_to_non_slicing<iterator_t<_Rng>, _It>
+                      && convertible_to<sentinel_t<_Rng>, _Se>)
+        constexpr subrange(_Rng&& _Val)
+            requires (!_Store_size<_It, _Se, _Ki> || sized_range<_Rng>)
+            : subrange{bool_constant<_Store_size<_It, _Se, _Ki>>{}, _STD forward<_Rng>(_Val)} {}
+
+        template <borrowed_range _Rng>
+            requires (_Convertible_to_non_slicing<iterator_t<_Rng>, _It> && convertible_to<sentinel_t<_Rng>, _Se>)
+        constexpr subrange(_Rng&& _Val, const _Size_type _Count)
+            requires (_Ki == subrange_kind::sized)
+            : subrange{_RANGES begin(_Val), _RANGES end(_Val), _Count} {}
+
+        template <_Different_from<subrange> _Pair_like>
+            requires _Pair_like_convertible_from<_Pair_like, const _It&, const _Se&>
+        constexpr operator _Pair_like() const {
+            return _Pair_like(_First, _Last);
+        }
+
+        _NODISCARD constexpr _It begin() const
+            requires copyable<_It>
+        {
+            return _First;
+        }
+        _NODISCARD constexpr _It begin()
+            requires (!copyable<_It>)
+        {
+            return _STD move(_First);
+        }
+
+        _NODISCARD constexpr _Se end() const {
+            return _Last;
+        }
+
+        _NODISCARD constexpr bool empty() const {
+            return _First == _Last;
+        }
+
+        _NODISCARD constexpr _Size_type size() const
+            requires (_Ki == subrange_kind::sized)
+        {
+            if constexpr (_Store_size<_It, _Se, _Ki>) {
+                return this->_Size;
+            } else {
+                return static_cast<_Size_type>(_Last - _First);
+            }
+        }
+
+        _NODISCARD constexpr subrange next() const&
+            requires forward_iterator<_It>
+        {
+            auto _Tmp = *this;
+            if (_Tmp._First != _Tmp._Last) {
+                ++_Tmp._First;
+                if constexpr (_Store_size<_It, _Se, _Ki>) {
+                    --_Tmp._Size;
+                }
+            }
+            return _Tmp;
+        }
+        _NODISCARD constexpr subrange next(const iter_difference_t<_It> _Count) const&
+            requires forward_iterator<_It>
+        {
+            auto _Tmp = *this;
+            _Tmp.advance(_Count);
+            return _Tmp;
+        }
+
+        _NODISCARD constexpr subrange next() && {
+            if (_First != _Last) {
+                ++_First;
+                if constexpr (_Store_size<_It, _Se, _Ki>) {
+                    --this->_Size;
+                }
+            }
+            return _STD move(*this);
+        }
+        _NODISCARD constexpr subrange next(const iter_difference_t<_It> _Count) && {
+            advance(_Count);
+            return _STD move(*this);
+        }
+
+        _NODISCARD constexpr subrange prev() const
+            requires bidirectional_iterator<_It>
+        {
+            auto _Tmp = *this;
+            --_Tmp._First;
+            if constexpr (_Store_size<_It, _Se, _Ki>) {
+                ++_Tmp._Size;
+            }
+            return _Tmp;
+        }
+        _NODISCARD constexpr subrange prev(const iter_difference_t<_It> _Count) const
+            requires bidirectional_iterator<_It>
+        {
+            auto _Tmp = *this;
+            _Tmp.advance(-_Count);
+            return _Tmp;
+        }
+
+        constexpr subrange& advance(const iter_difference_t<_It> _Count) {
+            if constexpr (bidirectional_iterator<_It>) {
+                if (_Count < 0) {
+                    _RANGES advance(_First, _Count);
+                    if constexpr (_Store_size<_It, _Se, _Ki>) {
+                        this->_Size += static_cast<_Size_type>(-_Count);
+                    }
+                    return *this;
+                }
+            }
+
+            const auto _Remainder = _RANGES advance(_First, _Count, _Last);
+            if constexpr (_Store_size<_It, _Se, _Ki>) {
+                this->_Size -= static_cast<_Size_type>(_Count - _Remainder);
+            }
+            return *this;
+        }
+    };
+
+    template <input_or_output_iterator _It, sentinel_for<_It> _Se>
+    subrange(_It, _Se) -> subrange<_It, _Se>;
+
+    template <input_or_output_iterator _It, sentinel_for<_It> _Se>
+    subrange(_It, _Se, _Make_unsigned_like_t<iter_difference_t<_It>>) -> subrange<_It, _Se, subrange_kind::sized>;
+
+    template <borrowed_range _Rng>
+    subrange(_Rng&&) -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>,
+        (sized_range<_Rng> || sized_sentinel_for<sentinel_t<_Rng>, iterator_t<_Rng>>) ? subrange_kind::sized
+                                                                                      : subrange_kind::unsized>;
+
+    template <borrowed_range _Rng>
+    subrange(_Rng&&, _Make_unsigned_like_t<range_difference_t<_Rng>>)
+        -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>, subrange_kind::sized>;
+
+    template <class _It, class _Se, subrange_kind _Ki>
+    constexpr bool enable_borrowed_range<subrange<_It, _Se, _Ki>> = true;
+
+    _EXPORT_STD template <size_t _Idx, class _It, class _Se, subrange_kind _Ki>
+        requires ((_Idx == 0 && copyable<_It>) || _Idx == 1)
+    _NODISCARD constexpr auto get(const subrange<_It, _Se, _Ki>& _Val) {
+        if constexpr (_Idx == 0) {
+            return _Val.begin();
+        } else {
+            return _Val.end();
+        }
+    }
+
+    _EXPORT_STD template <size_t _Idx, class _It, class _Se, subrange_kind _Ki>
+        requires (_Idx < 2)
+    _NODISCARD constexpr auto get(subrange<_It, _Se, _Ki>&& _Val) {
+        if constexpr (_Idx == 0) {
+            return _Val.begin();
+        } else {
+            return _Val.end();
+        }
+    }
+
+    _EXPORT_STD struct dangling {
+        constexpr dangling() noexcept = default;
+        template <class... _Args>
+        constexpr dangling(_Args&&...) noexcept {}
+    };
+
+    _EXPORT_STD template <range _Rng>
+    using borrowed_iterator_t = conditional_t<borrowed_range<_Rng>, iterator_t<_Rng>, dangling>;
+
+    _EXPORT_STD template <range _Rng>
+    using borrowed_subrange_t = conditional_t<borrowed_range<_Rng>, subrange<iterator_t<_Rng>>, dangling>;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+struct _Container_proxy;
+struct _Iterator_base12;
+
+struct _Default_sentinel {}; // empty struct to serve as the end of a range
+
+#if _HAS_CXX20
+_EXPORT_STD template <semiregular>
+class move_sentinel;
+
+template <class>
+struct _Move_iterator_category {};
+
+template <class _Iter>
+    requires requires { typename _Iter_cat_t<_Iter>; }
+struct _Move_iterator_category<_Iter> {
+    using iterator_category = conditional_t<derived_from<_Iter_cat_t<_Iter>, random_access_iterator_tag>,
+        random_access_iterator_tag, _Iter_cat_t<_Iter>>;
+};
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Iter>
+struct _Move_iterator_category {
+    using iterator_category = _Iter_cat_t<_Iter>;
+};
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+_EXPORT_STD template <class _Iter>
+class move_iterator : public _Move_iterator_category<_Iter> {
+private:
+    _Iter _Current{};
+
+public:
+    using iterator_type   = _Iter;
+    using value_type      = _Iter_value_t<_Iter>;
+    using difference_type = _Iter_diff_t<_Iter>;
+    using pointer         = _Iter;
+
+#if _HAS_CXX20
+private:
+    static constexpr auto _Get_iter_concept() {
+        if constexpr (random_access_iterator<_Iter>) {
+            return random_access_iterator_tag{};
+        } else if constexpr (bidirectional_iterator<_Iter>) {
+            return bidirectional_iterator_tag{};
+        } else if constexpr (forward_iterator<_Iter>) {
+            return forward_iterator_tag{};
+        } else {
+            return input_iterator_tag{};
+        }
+    }
+
+public:
+    using iterator_concept = decltype(_Get_iter_concept());
+
+    using reference = iter_rvalue_reference_t<_Iter>;
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    using reference =
+        conditional_t<is_reference_v<_Iter_ref_t<_Iter>>, remove_reference_t<_Iter_ref_t<_Iter>>&&, _Iter_ref_t<_Iter>>;
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    _CONSTEXPR17 move_iterator() = default;
+
+    _CONSTEXPR17 explicit move_iterator(_Iter _Right) noexcept(is_nothrow_move_constructible_v<_Iter>) // strengthened
+        : _Current(_STD move(_Right)) {}
+
+    template <class _Other>
+#if _HAS_CXX20
+        requires (!is_same_v<_Other, _Iter>) && convertible_to<const _Other&, _Iter>
+#endif // _HAS_CXX20
+    _CONSTEXPR17 move_iterator(const move_iterator<_Other>& _Right) noexcept(
+        is_nothrow_constructible_v<_Iter, const _Other&>) // strengthened
+        : _Current(_Right.base()) {
+    }
+
+    template <class _Other>
+#if _HAS_CXX20
+        requires (!is_same_v<_Other, _Iter>)
+              && convertible_to<const _Other&, _Iter> && assignable_from<_Iter&, const _Other&>
+#endif // _HAS_CXX20
+    _CONSTEXPR17 move_iterator& operator=(const move_iterator<_Other>& _Right) noexcept(
+        is_nothrow_assignable_v<_Iter&, const _Other&>) /* strengthened */ {
+        _Current = _Right.base();
+        return *this;
+    }
+
+#if _HAS_CXX20
+    _NODISCARD constexpr const iterator_type& base() const& noexcept {
+        return _Current;
+    }
+    _NODISCARD constexpr iterator_type base() && noexcept(is_nothrow_move_constructible_v<_Iter>) /* strengthened */ {
+        return _STD move(_Current);
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD _CONSTEXPR17 iterator_type base() const
+        noexcept(is_nothrow_copy_constructible_v<_Iter>) /* strengthened */ {
+        return _Current;
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    _NODISCARD _CONSTEXPR17 reference operator*() const
+#if _HAS_CXX20
+        noexcept(noexcept(_RANGES iter_move(_Current))) /* strengthened */ {
+        return _RANGES iter_move(_Current);
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+        noexcept(noexcept(static_cast<reference>(*_Current))) /* strengthened */ {
+        return static_cast<reference>(*_Current);
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    _CXX20_DEPRECATE_MOVE_ITERATOR_ARROW _NODISCARD _CONSTEXPR17 pointer operator->() const
+        noexcept(is_nothrow_copy_constructible_v<_Iter>) /* strengthened */ {
+        return _Current;
+    }
+
+    _CONSTEXPR17 move_iterator& operator++() noexcept(noexcept(++_Current)) /* strengthened */ {
+        ++_Current;
+        return *this;
+    }
+
+    _CONSTEXPR17 auto operator++(int) noexcept(is_nothrow_copy_constructible_v<_Iter> //
+            && noexcept(++_Current)) /* strengthened */ {
+#if _HAS_CXX20
+        if constexpr (forward_iterator<_Iter>) {
+#endif // _HAS_CXX20
+            move_iterator _Tmp = *this;
+            ++_Current;
+            return _Tmp;
+#if _HAS_CXX20
+        } else {
+            ++_Current;
+        }
+#endif // _HAS_CXX20
+    }
+
+    _CONSTEXPR17 move_iterator& operator--() noexcept(noexcept(--_Current)) /* strengthened */ {
+        --_Current;
+        return *this;
+    }
+
+    _CONSTEXPR17 move_iterator operator--(int) noexcept(is_nothrow_copy_constructible_v<_Iter> //
+            && noexcept(--_Current)) /* strengthened */ {
+        move_iterator _Tmp = *this;
+        --_Current;
+        return _Tmp;
+    }
+
+    template <class _Iter2 = _Iter>
+    _NODISCARD auto operator==(_Default_sentinel _Sentinel) const noexcept
+        -> decltype(_STD declval<const _Iter2&>() == _Sentinel) {
+        return _Current == _Sentinel;
+    }
+
+    template <class _Iter2 = _Iter>
+    _NODISCARD auto operator!=(_Default_sentinel _Sentinel) const noexcept
+        -> decltype(_STD declval<const _Iter2&>() != _Sentinel) {
+        return _Current != _Sentinel;
+    }
+
+    _NODISCARD _CONSTEXPR17 move_iterator operator+(const difference_type _Off) const
+        noexcept(noexcept(move_iterator(_Current + _Off))) /* strengthened */ {
+        return move_iterator(_Current + _Off);
+    }
+
+    _CONSTEXPR17 move_iterator& operator+=(const difference_type _Off) noexcept(
+        noexcept(_Current += _Off)) /* strengthened */ {
+        _Current += _Off;
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR17 move_iterator operator-(const difference_type _Off) const
+        noexcept(noexcept(move_iterator(_Current - _Off))) /* strengthened */ {
+        return move_iterator(_Current - _Off);
+    }
+
+    _CONSTEXPR17 move_iterator& operator-=(const difference_type _Off) noexcept(
+        noexcept(_Current -= _Off)) /* strengthened */ {
+        _Current -= _Off;
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR17 reference operator[](const difference_type _Off) const
+#if _HAS_CXX20
+        noexcept(noexcept(_RANGES iter_move(_Current + _Off))) /* strengthened */ {
+        return _RANGES iter_move(_Current + _Off);
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+        noexcept(noexcept(_STD move(_Current[_Off]))) /* strengthened */ {
+        return _STD move(_Current[_Off]);
+#endif // ^^^ !_HAS_CXX20 ^^^
+    }
+
+#if _HAS_CXX20
+    template <sentinel_for<_Iter> _Sent>
+    _NODISCARD friend constexpr bool
+        operator==(const move_iterator& _Left, const move_sentinel<_Sent>& _Right) noexcept(
+            noexcept(_STD _Fake_copy_init<bool>(_Left._Current == _Right._Get_last()))) /* strengthened */ {
+        return _Left._Current == _Right._Get_last();
+    }
+
+    template <sized_sentinel_for<_Iter> _Sent>
+    _NODISCARD friend constexpr difference_type operator-(const move_sentinel<_Sent>& _Left,
+        const move_iterator& _Right) noexcept(noexcept(_Left._Get_last() - _Right._Current)) /* strengthened */ {
+        return _Left._Get_last() - _Right._Current;
+    }
+
+    template <sized_sentinel_for<_Iter> _Sent>
+    _NODISCARD friend constexpr difference_type operator-(const move_iterator& _Left,
+        const move_sentinel<_Sent>& _Right) noexcept(noexcept(_Left._Current - _Right._Get_last())) /* strengthened */ {
+        return _Left._Current - _Right._Get_last();
+    }
+
+    _NODISCARD friend constexpr reference iter_move(const move_iterator& _It) noexcept(
+        noexcept(_RANGES iter_move(_It._Current))) {
+        return _RANGES iter_move(_It._Current);
+    }
+
+    template <indirectly_swappable<_Iter> _Iter2>
+    friend constexpr void iter_swap(const move_iterator& _Left, const move_iterator<_Iter2>& _Right) noexcept(
+        noexcept(_RANGES iter_swap(_Left._Current, _Right.base()))) {
+        _RANGES iter_swap(_Left._Current, _Right.base());
+    }
+#endif // _HAS_CXX20
+
+    template <class _Iter2, enable_if_t<_Range_verifiable_v<_Iter, _Iter2>, int> = 0>
+    friend constexpr void _Verify_range(const move_iterator& _First, const move_iterator<_Iter2>& _Last) noexcept {
+        _Verify_range(_First._Current, _Last._Get_current());
+    }
+#if _HAS_CXX20
+    template <sentinel_for<_Iter> _Sent>
+        requires _Range_verifiable_v<_Iter, _Sent>
+    friend constexpr void _Verify_range(const move_iterator& _First, const move_sentinel<_Sent>& _Last) noexcept {
+        _Verify_range(_First._Current, _Last._Get_last());
+    }
+#endif // _HAS_CXX20
+
+    using _Prevent_inheriting_unwrap = move_iterator;
+
+    template <class _Iter2 = iterator_type, enable_if_t<_Offset_verifiable_v<_Iter2>, int> = 0>
+    constexpr void _Verify_offset(const difference_type _Off) const noexcept {
+        _Current._Verify_offset(_Off);
+    }
+
+    template <class _Iter2 = iterator_type, enable_if_t<_Unwrappable_v<const _Iter2&>, int> = 0>
+    _NODISCARD constexpr move_iterator<_Unwrapped_t<const _Iter2&>> _Unwrapped() const& noexcept(
+        noexcept(static_cast<move_iterator<_Unwrapped_t<const _Iter2&>>>(_Current._Unwrapped()))) {
+        return static_cast<move_iterator<_Unwrapped_t<const _Iter2&>>>(_Current._Unwrapped());
+    }
+    template <class _Iter2 = iterator_type, enable_if_t<_Unwrappable_v<_Iter2>, int> = 0>
+    _NODISCARD constexpr move_iterator<_Unwrapped_t<_Iter2>> _Unwrapped() && noexcept(
+        noexcept(static_cast<move_iterator<_Unwrapped_t<_Iter2>>>(_STD move(_Current)._Unwrapped()))) {
+        return static_cast<move_iterator<_Unwrapped_t<_Iter2>>>(_STD move(_Current)._Unwrapped());
+    }
+
+    static constexpr bool _Unwrap_when_unverified = _Do_unwrap_when_unverified_v<iterator_type>;
+
+    template <class _Src, enable_if_t<_Wrapped_seekable_v<iterator_type, const _Src&>, int> = 0>
+    constexpr void _Seek_to(const move_iterator<_Src>& _It) noexcept(noexcept(_Current._Seek_to(_It._Get_current()))) {
+        _Current._Seek_to(_It._Get_current());
+    }
+    template <class _Src, enable_if_t<_Wrapped_seekable_v<iterator_type, _Src>, int> = 0>
+    constexpr void _Seek_to(move_iterator<_Src>&& _It) noexcept(
+        noexcept(_Current._Seek_to(_STD move(_It)._Get_current()))) {
+        _Current._Seek_to(_STD move(_It)._Get_current());
+    }
+
+    _NODISCARD constexpr const iterator_type& _Get_current() const& noexcept {
+        return _Current;
+    }
+    _NODISCARD constexpr iterator_type&& _Get_current() && noexcept {
+        return _STD move(_Current);
+    }
+};
+
+_EXPORT_STD template <class _Iter1, class _Iter2>
+_NODISCARD _CONSTEXPR17 bool
+    operator==(const move_iterator<_Iter1>& _Left, const move_iterator<_Iter2>& _Right) noexcept(
+        noexcept(_STD _Fake_copy_init<bool>(_Left.base() == _Right.base()))) /* strengthened */
+#if _HAS_CXX20
+    requires requires {
+        { _Left.base() == _Right.base() } -> _Implicitly_convertible_to<bool>;
+    }
+#endif // _HAS_CXX20
+{
+    return _Left.base() == _Right.base();
+}
+
+#if !_HAS_CXX20
+template <class _Iter1, class _Iter2>
+_NODISCARD _CONSTEXPR17 bool operator!=(const move_iterator<_Iter1>& _Left,
+    const move_iterator<_Iter2>& _Right) noexcept(noexcept(_Left == _Right)) /* strengthened */ {
+    return !(_Left == _Right);
+}
+#endif // !_HAS_CXX20
+
+_EXPORT_STD template <class _Iter1, class _Iter2>
+_NODISCARD _CONSTEXPR17 bool
+    operator<(const move_iterator<_Iter1>& _Left, const move_iterator<_Iter2>& _Right) noexcept(
+        noexcept(_STD _Fake_copy_init<bool>(_Left.base() < _Right.base()))) /* strengthened */
+#if _HAS_CXX20
+    requires requires {
+        { _Left.base() < _Right.base() } -> _Implicitly_convertible_to<bool>;
+    }
+#endif // _HAS_CXX20
+{
+    return _Left.base() < _Right.base();
+}
+
+_EXPORT_STD template <class _Iter1, class _Iter2>
+_NODISCARD _CONSTEXPR17 bool operator>(const move_iterator<_Iter1>& _Left,
+    const move_iterator<_Iter2>& _Right) noexcept(noexcept(_Right < _Left)) /* strengthened */
+#if _HAS_CXX20
+    requires requires { _Right < _Left; }
+#endif // _HAS_CXX20
+{
+    return _Right < _Left;
+}
+
+_EXPORT_STD template <class _Iter1, class _Iter2>
+_NODISCARD _CONSTEXPR17 bool operator<=(const move_iterator<_Iter1>& _Left,
+    const move_iterator<_Iter2>& _Right) noexcept(noexcept(_Right < _Left)) /* strengthened */
+#if _HAS_CXX20
+    requires requires { _Right < _Left; }
+#endif // _HAS_CXX20
+{
+    return !(_Right < _Left);
+}
+
+_EXPORT_STD template <class _Iter1, class _Iter2>
+_NODISCARD _CONSTEXPR17 bool operator>=(const move_iterator<_Iter1>& _Left,
+    const move_iterator<_Iter2>& _Right) noexcept(noexcept(_Left < _Right)) /* strengthened */
+#if _HAS_CXX20
+    requires requires { _Left < _Right; }
+#endif // _HAS_CXX20
+{
+    return !(_Left < _Right);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Iter1, three_way_comparable_with<_Iter1> _Iter2>
+_NODISCARD constexpr compare_three_way_result_t<_Iter1, _Iter2> operator<=>(const move_iterator<_Iter1>& _Left,
+    const move_iterator<_Iter2>& _Right) noexcept(noexcept(_Left.base() <=> _Right.base())) /* strengthened */ {
+    return _Left.base() <=> _Right.base();
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Iter1, class _Iter2>
+_NODISCARD _CONSTEXPR17 auto operator-(const move_iterator<_Iter1>& _Left,
+    const move_iterator<_Iter2>& _Right) noexcept(noexcept(_Left.base() - _Right.base())) /* strengthened */
+    -> decltype(_Left.base() - _Right.base()) {
+    return _Left.base() - _Right.base();
+}
+
+_EXPORT_STD template <class _Iter>
+_NODISCARD _CONSTEXPR17 move_iterator<_Iter>
+    operator+(typename move_iterator<_Iter>::difference_type _Off, const move_iterator<_Iter>& _Right) noexcept(
+        noexcept(move_iterator<_Iter>(_Right.base() + _Off))) /* strengthened */
+#if _HAS_CXX20
+    requires requires {
+        { _Right.base() + _Off } -> same_as<_Iter>;
+    }
+#endif // _HAS_CXX20
+{
+    return move_iterator<_Iter>(_Right.base() + _Off);
+}
+
+_EXPORT_STD template <class _Iter>
+_NODISCARD _CONSTEXPR17 move_iterator<_Iter> make_move_iterator(_Iter _It) noexcept(
+    is_nothrow_move_constructible_v<_Iter>) /* strengthened */ {
+    return move_iterator<_Iter>(_STD move(_It));
+}
+
+#if _HAS_CXX20
+template <class _Iter1, class _Iter2>
+    requires (!sized_sentinel_for<_Iter1, _Iter2>)
+constexpr bool disable_sized_sentinel_for<move_iterator<_Iter1>, move_iterator<_Iter2>> = true;
+
+_EXPORT_STD struct unreachable_sentinel_t;
+namespace _Unreachable_sentinel_detail {
+    struct _Base {
+        template <weakly_incrementable _Winc>
+        _NODISCARD friend constexpr bool operator==(const unreachable_sentinel_t&, const _Winc&) noexcept {
+            return false;
+        }
+    };
+} // namespace _Unreachable_sentinel_detail
+_EXPORT_STD struct unreachable_sentinel_t : _Unreachable_sentinel_detail::_Base {}; // TRANSITION, /permissive-
+
+_EXPORT_STD inline constexpr unreachable_sentinel_t unreachable_sentinel{};
+#endif // _HAS_CXX20
+
+// _Iterator_is_contiguous<_Iter> reports whether an iterator is known to be contiguous.
+// (Without concepts, this detection is limited, which will limit when we can activate optimizations.)
+
+#if _HAS_CXX20
+// When concepts are available, we can detect arbitrary contiguous iterators.
+template <class _Iter>
+constexpr bool _Iterator_is_contiguous = contiguous_iterator<_Iter>;
+
+template <class _Iter>
+_NODISCARD constexpr auto _To_address(const _Iter& _Val) noexcept {
+    _STL_INTERNAL_STATIC_ASSERT(contiguous_iterator<_Iter>);
+    return _STD to_address(_Val);
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+// When concepts aren't available, we can detect pointers. (Iterators should be unwrapped before using this.)
+template <class _Iter>
+constexpr bool _Iterator_is_contiguous = is_pointer_v<_Iter>;
+
+template <class _Iter>
+_NODISCARD constexpr auto _To_address(const _Iter& _Val) noexcept {
+    _STL_INTERNAL_STATIC_ASSERT(is_pointer_v<_Iter>);
+    return _Val;
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+template <class _Iter>
+_NODISCARD constexpr auto _To_address(const move_iterator<_Iter>& _Val) noexcept {
+    return _To_address(_Val.base());
+}
+
+// _Iterators_are_contiguous<_Iter1, _Iter2> reports whether both iterators are known to be contiguous.
+
+template <class _Iter1, class _Iter2>
+constexpr bool _Iterators_are_contiguous = _Iterator_is_contiguous<_Iter1> && _Iterator_is_contiguous<_Iter2>;
+
+template <class _Iter>
+constexpr bool _Iterator_is_volatile = is_volatile_v<remove_reference_t<_Iter_ref_t<_Iter>>>;
+
+template <class _Source, class _Dest>
+constexpr bool _Is_pointer_address_convertible = is_void_v<_Source>
+                                              || is_void_v<_Dest>
+                                              // NOTE: is_same_v is required for function pointers to work
+                                              || is_same_v<remove_cv_t<_Source>, remove_cv_t<_Dest>>
+#ifdef __cpp_lib_is_pointer_interconvertible
+                                              || is_pointer_interconvertible_base_of_v<_Dest, _Source>
+#endif // defined(__cpp_lib_is_pointer_interconvertible)
+    ;
+
+template <class _Source, class _Dest, class _SourceRef, class _DestRef>
+struct _Trivial_cat {
+    using _USource = _Unwrap_enum_t<_Source>;
+    using _UDest   = _Unwrap_enum_t<_Dest>;
+
+    static constexpr bool _Same_size_and_compatible =
+        sizeof(_Source) == sizeof(_Dest)
+        // If _UDest is bool, _USource also needs to be bool
+        // Conversion from non-bool => non-bool | bool => bool | bool => non-bool is fine.
+        // Conversion from non-bool => bool is not fine.
+        && is_same_v<bool, _USource> >= is_same_v<bool, _UDest>
+        && (is_same_v<_USource, _UDest> || (is_integral_v<_USource> && is_integral_v<_UDest>)
+            || (is_floating_point_v<_USource> && is_floating_point_v<_UDest>) );
+
+    static constexpr bool _Bitcopy_constructible =
+        _Same_size_and_compatible && is_trivially_constructible_v<_Dest, _SourceRef>;
+
+    static constexpr bool _Bitcopy_assignable =
+        _Same_size_and_compatible && is_trivially_assignable_v<_DestRef, _SourceRef>;
+};
+
+template <class _Source, class _Dest, class _SourceRef, class _DestRef>
+struct _Trivial_cat<_Source*, _Dest*, _SourceRef, _DestRef> {
+    static constexpr bool _Bitcopy_constructible =
+        _Is_pointer_address_convertible<_Source, _Dest> && is_trivially_constructible_v<_Dest*, _SourceRef>;
+
+    static constexpr bool _Bitcopy_assignable =
+        _Is_pointer_address_convertible<_Source, _Dest> && is_trivially_assignable_v<_DestRef, _SourceRef>;
+};
+
+struct _False_trivial_cat {
+    static constexpr bool _Bitcopy_constructible = false;
+    static constexpr bool _Bitcopy_assignable    = false;
+};
+
+template <class _SourceIt, class _DestIt,
+    bool _Are_contiguous = _Iterators_are_contiguous<_SourceIt, _DestIt> && !_Iterator_is_volatile<_SourceIt>
+                        && !_Iterator_is_volatile<_DestIt>>
+struct _Iter_move_cat : _Trivial_cat<_Iter_value_t<_SourceIt>, _Iter_value_t<_DestIt>,
+                            remove_reference_t<_Iter_ref_t<_SourceIt>>&&, _Iter_ref_t<_DestIt>> {};
+
+template <class _SourceIt, class _DestIt>
+struct _Iter_move_cat<_SourceIt, _DestIt, false> : _False_trivial_cat {};
+
+template <class _SourceIt, class _DestIt>
+struct _Iter_move_cat<move_iterator<_SourceIt>, _DestIt, false> : _Iter_move_cat<_SourceIt, _DestIt> {};
+
+template <class _SourceIt, class _DestIt,
+    bool _Are_contiguous = _Iterators_are_contiguous<_SourceIt, _DestIt> && !_Iterator_is_volatile<_SourceIt>
+                        && !_Iterator_is_volatile<_DestIt>>
+struct _Iter_copy_cat
+    : _Trivial_cat<_Iter_value_t<_SourceIt>, _Iter_value_t<_DestIt>, _Iter_ref_t<_SourceIt>, _Iter_ref_t<_DestIt>> {};
+
+template <class _SourceIt, class _DestIt>
+struct _Iter_copy_cat<_SourceIt, _DestIt, false> : _False_trivial_cat {};
+
+template <class _SourceIt, class _DestIt>
+struct _Iter_copy_cat<move_iterator<_SourceIt>, _DestIt, false> : _Iter_move_cat<_SourceIt, _DestIt> {};
+
+template <class _Iter1, class _Sent1, class _Iter2>
+_CONSTEXPR20 void _Verify_ranges_do_not_overlap(const _Iter1& _First1, const _Sent1& _Last1, const _Iter2& _First2) {
+#if _ITERATOR_DEBUG_LEVEL == 2
+    if constexpr (_Iterators_are_contiguous<_Iter1, _Iter2>
+#if _HAS_CXX20
+                  && sized_sentinel_for<_Sent1, _Iter1>
+#endif // _HAS_CXX20
+    ) {
+#if _HAS_CXX20
+        if (_STD is_constant_evaluated()) {
+            return;
+        }
+#endif // _HAS_CXX20
+
+        const auto _Offset     = _Last1 - _First1;
+        const auto _Ptr1Offset = _Offset * sizeof(*_STD _To_address(_First1));
+        const auto _Ptr2Offset = _Offset * sizeof(*_STD _To_address(_First2));
+        // This cast to `cv char*` allows us to compare pointers to distinct types,
+        // in case one range provides storage for the other.
+        const auto _PtrFirst1 = reinterpret_cast<const volatile char*>(_STD _To_address(_First1));
+        const auto _PtrLast1  = _PtrFirst1 + _Ptr1Offset;
+        const auto _PtrFirst2 = reinterpret_cast<const volatile char*>(_STD _To_address(_First2));
+        const auto _PtrLast2  = _PtrFirst2 + _Ptr2Offset;
+        _STL_VERIFY(_PtrLast1 <= _PtrFirst2 || _PtrLast2 <= _PtrFirst1, "ranges should not overlap each other");
+    }
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 2 / _ITERATOR_DEBUG_LEVEL != 2 vvv
+    (void) _First1;
+    (void) _Last1;
+    (void) _First2;
+#endif // _ITERATOR_DEBUG_LEVEL != 2 ^^^
+}
+
+template <class _CtgIt, class _OutCtgIt>
+_OutCtgIt _Copy_memmove(_CtgIt _First, _CtgIt _Last, _OutCtgIt _Dest) {
+    auto _FirstPtr              = _STD _To_address(_First);
+    auto _LastPtr               = _STD _To_address(_Last);
+    auto _DestPtr               = _STD _To_address(_Dest);
+    const char* const _First_ch = const_cast<const char*>(reinterpret_cast<const volatile char*>(_FirstPtr));
+    const char* const _Last_ch  = const_cast<const char*>(reinterpret_cast<const volatile char*>(_LastPtr));
+    char* const _Dest_ch        = const_cast<char*>(reinterpret_cast<const volatile char*>(_DestPtr));
+    const auto _Count           = static_cast<size_t>(_Last_ch - _First_ch);
+    _CSTD memmove(_Dest_ch, _First_ch, _Count);
+    if constexpr (is_pointer_v<_OutCtgIt>) {
+        // CodeQL [SM02986] This cast is correct: we're bypassing pointer arithmetic for performance.
+        return reinterpret_cast<_OutCtgIt>(_Dest_ch + _Count);
+    } else {
+        return _Dest + static_cast<_Iter_diff_t<_OutCtgIt>>(_LastPtr - _FirstPtr);
+    }
+}
+
+template <class _CtgIt, class _OutCtgIt>
+_OutCtgIt _Copy_memmove_n(_CtgIt _First, const size_t _Count, _OutCtgIt _Dest) {
+    const auto _Result = _STD _Copy_memmove(_First, _First + _Count, _Dest);
+    if constexpr (is_pointer_v<_OutCtgIt>) {
+        return _Result;
+    } else { // _Result is unused so the compiler can optimize it away
+        return _Dest + static_cast<_Iter_diff_t<_OutCtgIt>>(_Count);
+    }
+}
+
+template <class _It, bool _RequiresMutable = false>
+constexpr bool _Is_vb_iterator = false;
+
+template <class _VbIt, class _OutIt>
+_CONSTEXPR20 _OutIt _Copy_vbool(_VbIt _First, _VbIt _Last, _OutIt _Dest);
+
+template <class _VbIt>
+_NODISCARD _CONSTEXPR20 _Iter_diff_t<_VbIt> _Count_vbool(_VbIt _First, _VbIt _Last, bool _Val) noexcept;
+
+template <class _VbIt>
+_CONSTEXPR20 void _Fill_vbool(_VbIt _First, _VbIt _Last, bool _Val) noexcept;
+
+template <class _VbIt>
+_NODISCARD _CONSTEXPR20 _VbIt _Find_vbool(_VbIt _First, _VbIt _Last, bool _Val) noexcept;
+
+template <class _InIt, class _SizeTy, class _OutIt>
+_CONSTEXPR20 _OutIt _Copy_n_unchecked4(_InIt _First, _SizeTy _Count, _OutIt _Dest) {
+    // copy _First + [0, _Count) to _Dest + [0, _Count), returning _Dest + _Count
+    // note: has callers outside the copy family
+#if _HAS_CXX20
+    _STL_INTERNAL_STATIC_ASSERT(_Integer_like<_SizeTy>);
+#endif // _HAS_CXX20
+
+    if constexpr (_Iter_copy_cat<_InIt, _OutIt>::_Bitcopy_assignable) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            return _Copy_memmove_n(_First, static_cast<size_t>(_Count), _Dest);
+        }
+    }
+
+    for (; _Count != 0; ++_Dest, (void) ++_First, --_Count) {
+        *_Dest = *_First;
+    }
+
+    return _Dest;
+}
+
+template <class _InIt, class _Sent, class _OutIt>
+using _Sent_copy_cat = conditional_t<
+#if _HAS_CXX20
+    is_same_v<_Sent, _InIt> || sized_sentinel_for<_Sent, _InIt>,
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    is_same_v<_Sent, _InIt>,
+#endif // ^^^ !_HAS_CXX20 ^^^
+    _Iter_copy_cat<_InIt, _OutIt>, _False_trivial_cat>;
+
+template <class _InIt, class _Sent, class _OutIt>
+_CONSTEXPR20 _OutIt _Copy_unchecked(_InIt _First, _Sent _Last, _OutIt _Dest) {
+    // copy [_First, _Last) to [_Dest, ...)
+    // note: _Copy_unchecked has callers other than the copy family
+    if constexpr (_Is_vb_iterator<_InIt> && _Is_vb_iterator<_OutIt, true>) {
+        return _STD _Copy_vbool(_First, _Last, _Dest);
+    } else {
+        if constexpr (_Sent_copy_cat<_InIt, _Sent, _OutIt>::_Bitcopy_assignable) {
+#if _HAS_CXX20
+            if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+            {
+#if _HAS_CXX20
+                if constexpr (!is_same_v<_InIt, _Sent>) {
+                    return _STD _Copy_memmove_n(_First, static_cast<size_t>(_Last - _First), _Dest);
+                } else
+#endif // _HAS_CXX20
+                {
+                    return _STD _Copy_memmove(_First, _Last, _Dest);
+                }
+            }
+        }
+
+        for (; _First != _Last; ++_Dest, (void) ++_First) {
+            *_Dest = *_First;
+        }
+
+        return _Dest;
+    }
+}
+
+_EXPORT_STD template <class _InIt, class _OutIt>
+_CONSTEXPR20 _OutIt copy(_InIt _First, _InIt _Last, _OutIt _Dest) { // copy [_First, _Last) to [_Dest, ...)
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    const auto _UDest  = _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_InIt>(_UFirst, _ULast));
+    _STD _Seek_wrapped(_Dest, _STD _Copy_unchecked(_UFirst, _ULast, _UDest));
+    return _Dest;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt2 copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest) noexcept /* terminates */ {
+    // copy [_First, _Last) to [_Dest, ...)
+    // not parallelized as benchmarks show it isn't worth it
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt2);
+    return _STD copy(_First, _Last, _Dest);
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    template <class _To, class _From>
+    concept _Convertible_from = convertible_to<_From, _To>;
+
+    _EXPORT_STD template <class _In, class _Out>
+    struct in_out_result {
+        /* [[no_unique_address]] */ _In in;
+        /* [[no_unique_address]] */ _Out out;
+
+        template <_Convertible_from<const _In&> _IIn, _Convertible_from<const _Out&> _OOut>
+        constexpr operator in_out_result<_IIn, _OOut>() const& {
+            return {in, out};
+        }
+
+        template <_Convertible_from<_In> _IIn, _Convertible_from<_Out> _OOut>
+        constexpr operator in_out_result<_IIn, _OOut>() && {
+            return {_STD move(in), _STD move(out)};
+        }
+    };
+
+    template <forward_iterator _It, class _Se>
+        requires sentinel_for<remove_cvref_t<_Se>, _It>
+    _NODISCARD constexpr _Unwrap_iter_t<_It, _Se> _Get_final_iterator_unwrapped(
+        const _Unwrap_iter_t<_It, _Se>& _UFirst, _Se&& _Last) {
+        // find the iterator in [_UFirst, _Unwrap_sent<_It>(_Last)) which equals _Unwrap_sent<_It>(_Last)
+        // [possibly O(N)]
+        if constexpr (is_same_v<_Unwrap_iter_t<_It, _Se>, _Unwrap_sent_t<_Se, _It>>) {
+            return _RANGES _Unwrap_sent<_It>(_STD forward<_Se>(_Last));
+        } else {
+            return _RANGES next(_UFirst, _RANGES _Unwrap_sent<_It>(_STD forward<_Se>(_Last)));
+        }
+    }
+
+    template <forward_range _Rng>
+    _NODISCARD constexpr auto _Get_final_iterator_unwrapped(_Rng& _Range) {
+        // find the (unwrapped) iterator in _Range which equals _Uend(_Range) [possibly O(N)]
+        if constexpr (common_range<_Rng>) {
+            if constexpr (same_as<decltype(_Uend(_Range)), _Unwrapped_iterator_t<_Rng>>) {
+                return _Uend(_Range);
+            } else {
+                return _RANGES _Unwrap_range_sent<_Rng>(_RANGES end(_Range));
+            }
+        } else if constexpr (sized_range<_Rng>) {
+            return _RANGES next(_Ubegin(_Range), _RANGES distance(_Range));
+        } else {
+            return _RANGES next(_Ubegin(_Range), _Uend(_Range));
+        }
+    }
+
+    template <forward_range _Rng>
+    _NODISCARD constexpr auto _Get_final_iterator_unwrapped(_Rng& _Range, const _Unwrapped_iterator_t<_Rng>& _Mid) {
+        // find the (unwrapped) iterator in _Range which equals _Uend(_Range) [possibly O(N)]
+        // Pre: [ranges::begin(_Range), _Mid) and [_Mid, ranges::end(_Range)) denote ranges
+        if constexpr (common_range<_Rng>) {
+            if constexpr (same_as<decltype(_Uend(_Range)), _Unwrapped_iterator_t<_Rng>>) {
+                return _Uend(_Range);
+            } else {
+                return _Unwrap_range_sent<_Rng>(_RANGES end(_Range));
+            }
+        } else if constexpr (sized_range<_Rng>) {
+            const auto _Dist = _RANGES distance(_Range);
+            if constexpr (sized_sentinel_for<_Unwrapped_iterator_t<_Rng>, _Unwrapped_iterator_t<_Rng>>) {
+                return _RANGES next(_Mid, _Dist - (_Mid - _Ubegin(_Range)));
+            } else {
+                return _RANGES next(_Ubegin(_Range), _Dist);
+            }
+        } else {
+            return _RANGES next(_Mid, _Uend(_Range));
+        }
+    }
+
+#if _HAS_CXX23
+    _EXPORT_STD template <class _Out, class _Ty>
+    struct out_value_result {
+        /* [[no_unique_address]] */ _Out out;
+        /* [[no_unique_address]] */ _Ty value;
+
+        template <_Convertible_from<const _Out&> _OOut, _Convertible_from<const _Ty&> _TTy>
+        constexpr operator out_value_result<_OOut, _TTy>() const& {
+            return {out, value};
+        }
+
+        template <_Convertible_from<_Out> _OOut, _Convertible_from<_Ty> _TTy>
+        constexpr operator out_value_result<_OOut, _TTy>() && {
+            return {_STD move(out), _STD move(value)};
+        }
+    };
+#endif // _HAS_CXX23
+
+    _EXPORT_STD template <class _In, class _Out>
+    using copy_result = in_out_result<_In, _Out>;
+
+    template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out>
+        requires indirectly_copyable<_It, _Out>
+    _NODISCARD constexpr copy_result<_It, _Out> _Copy_unchecked(_It _First, _Se _Last, _Out _Result) {
+        if constexpr (_Sent_copy_cat<_It, _Se, _Out>::_Bitcopy_assignable) {
+            if (!_STD is_constant_evaluated()) {
+                if constexpr (is_same_v<_It, _Se>) {
+                    _Result = _STD _Copy_memmove(_STD move(_First), _Last, _STD move(_Result));
+                    return {_STD move(_Last), _STD move(_Result)};
+                } else {
+                    const auto _Count = static_cast<size_t>(_Last - _First);
+                    _Result           = _STD _Copy_memmove_n(_First, _Count, _STD move(_Result));
+                    _First += _Count;
+                    return {_STD move(_First), _STD move(_Result)};
+                }
+            }
+        }
+
+        for (; _First != _Last; ++_First, (void) ++_Result) {
+            *_Result = *_First;
+        }
+
+        return {_STD move(_First), _STD move(_Result)};
+    }
+
+    class _Copy_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out>
+            requires indirectly_copyable<_It, _Out>
+        _STATIC_CALL_OPERATOR constexpr copy_result<_It, _Out> operator()(
+            _It _First, _Se _Last, _Out _Result) _CONST_CALL_OPERATOR {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UResult = _RANGES _Copy_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD move(_Result));
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            return {_STD move(_First), _STD move(_UResult.out)};
+        }
+
+        template <input_range _Rng, weakly_incrementable _Out>
+            requires indirectly_copyable<iterator_t<_Rng>, _Out>
+        _STATIC_CALL_OPERATOR constexpr copy_result<borrowed_iterator_t<_Rng>, _Out> operator()(
+            _Rng&& _Range, _Out _Result) _CONST_CALL_OPERATOR {
+            auto _First   = _RANGES begin(_Range);
+            auto _UResult = _RANGES _Copy_unchecked(
+                _RANGES _Unwrap_range_iter<_Rng>(_STD move(_First)), _Uend(_Range), _STD move(_Result));
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            return {_STD move(_First), _STD move(_UResult.out)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Copy_fn copy;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _InIt, class _Diff, class _OutIt>
+_CONSTEXPR20 _OutIt copy_n(_InIt _First, _Diff _Count_raw, _OutIt _Dest) {
+    // copy [_First, _First + _Count) to [_Dest, ...)
+    _Algorithm_int_t<_Diff> _Count = _Count_raw;
+    if (0 < _Count) {
+        if constexpr (_Is_vb_iterator<_InIt> && _Is_vb_iterator<_OutIt, true>) {
+            return _STD _Copy_vbool(_First, _First + _Count, _Dest);
+        } else {
+            auto _UFirst = _STD _Get_unwrapped_n(_First, _Count);
+            auto _UDest  = _STD _Get_unwrapped_n(_Dest, _Count);
+            if constexpr (_Iter_copy_cat<decltype(_UFirst), decltype(_UDest)>::_Bitcopy_assignable) {
+#if _HAS_CXX20
+                if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+                {
+                    _UDest = _STD _Copy_memmove_n(_UFirst, static_cast<size_t>(_Count), _UDest);
+                    _STD _Seek_wrapped(_Dest, _UDest);
+                    return _Dest;
+                }
+            }
+
+            for (;;) {
+                *_UDest = *_UFirst;
+                ++_UDest;
+                --_Count;
+                // note that we avoid an extra ++_First here to allow istream_iterator to work, see LWG-2471
+                if (_Count == 0) {
+                    break;
+                }
+
+                ++_UFirst;
+            }
+
+            _STD _Seek_wrapped(_Dest, _UDest);
+        }
+    }
+
+    return _Dest;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _Diff, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt2 copy_n(_ExPo&&, _FwdIt1 _First, _Diff _Count_raw, _FwdIt2 _Dest) noexcept /* terminates */ {
+    // copy [_First, _First + _Count) to [_Dest, ...)
+    // not parallelized as benchmarks show it isn't worth it
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt2);
+    return _STD copy_n(_First, _Count_raw, _Dest);
+}
+#endif // _HAS_CXX17
+
+template <class _CtgIt1, class _CtgIt2>
+_CtgIt2 _Copy_backward_memmove(_CtgIt1 _First, _CtgIt1 _Last, _CtgIt2 _Dest) {
+    // implement copy_backward-like function as memmove
+    auto _FirstPtr              = _STD _To_address(_First);
+    auto _LastPtr               = _STD _To_address(_Last);
+    auto _DestPtr               = _STD _To_address(_Dest);
+    const char* const _First_ch = const_cast<const char*>(reinterpret_cast<const volatile char*>(_FirstPtr));
+    const char* const _Last_ch  = const_cast<const char*>(reinterpret_cast<const volatile char*>(_LastPtr));
+    char* const _Dest_ch        = const_cast<char*>(reinterpret_cast<const volatile char*>(_DestPtr));
+    const auto _Count           = static_cast<size_t>(_Last_ch - _First_ch);
+    auto _Result                = _CSTD memmove(_Dest_ch - _Count, _First_ch, _Count);
+    if constexpr (is_pointer_v<_CtgIt2>) {
+        return static_cast<_CtgIt2>(_Result);
+    } else {
+        return _Dest - static_cast<_Iter_diff_t<_CtgIt2>>(_LastPtr - _FirstPtr);
+    }
+}
+
+template <class _BidIt1, class _BidIt2>
+_BidIt2 _Copy_backward_memmove(move_iterator<_BidIt1> _First, move_iterator<_BidIt1> _Last, _BidIt2 _Dest) {
+    return _STD _Copy_backward_memmove(_First.base(), _Last.base(), _Dest);
+}
+
+template <class _BidIt1, class _BidIt2>
+_NODISCARD _CONSTEXPR20 _BidIt2 _Copy_backward_unchecked(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest) {
+    // copy [_First, _Last) backwards to [..., _Dest)
+    if constexpr (_Iter_copy_cat<_BidIt1, _BidIt2>::_Bitcopy_assignable) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            return _STD _Copy_backward_memmove(_First, _Last, _Dest);
+        }
+    }
+
+    while (_First != _Last) {
+        *--_Dest = *--_Last;
+    }
+
+    return _Dest;
+}
+
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
+_CONSTEXPR20 _BidIt2 copy_backward(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest) {
+    // copy [_First, _Last) backwards to [..., _Dest)
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    const auto _UDest  = _STD _Get_unwrapped_n(_Dest, -_STD _Idl_distance<_BidIt1>(_UFirst, _ULast));
+    _STD _Seek_wrapped(_Dest, _STD _Copy_backward_unchecked(_UFirst, _ULast, _UDest));
+    return _Dest;
+}
+
+template <class _InIt, class _OutIt>
+_CONSTEXPR20 _OutIt _Move_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest) {
+    // move [_First, _Last) to [_Dest, ...)
+    // note: _Move_unchecked has callers other than the move family
+    if constexpr (_Is_vb_iterator<_InIt> && _Is_vb_iterator<_OutIt, true>) {
+        return _STD _Copy_vbool(_First, _Last, _Dest);
+    } else {
+        if constexpr (_Iter_move_cat<_InIt, _OutIt>::_Bitcopy_assignable) {
+#if _HAS_CXX20
+            if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+            {
+                return _STD _Copy_memmove(_First, _Last, _Dest);
+            }
+        }
+
+        for (; _First != _Last; ++_Dest, (void) ++_First) {
+            *_Dest = _STD move(*_First);
+        }
+
+        return _Dest;
+    }
+}
+
+_EXPORT_STD template <class _InIt, class _OutIt>
+_CONSTEXPR20 _OutIt move(_InIt _First, _InIt _Last, _OutIt _Dest) {
+    // move [_First, _Last) to [_Dest, ...)
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    const auto _UDest  = _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_InIt>(_UFirst, _ULast));
+    _STD _Seek_wrapped(_Dest, _STD _Move_unchecked(_UFirst, _ULast, _UDest));
+    return _Dest;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt2 move(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest) noexcept /* terminates */ {
+    // move [_First, _Last) to [_Dest, ...)
+    // not parallelized as benchmarks show it isn't worth it
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt1);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt2);
+    return _STD move(_First, _Last, _Dest);
+}
+#endif // _HAS_CXX17
+
+template <class _BidIt1, class _BidIt2>
+_CONSTEXPR20 _BidIt2 _Move_backward_unchecked(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest) {
+    // move [_First, _Last) backwards to [..., _Dest)
+    // note: _Move_backward_unchecked has callers other than the move_backward family
+    if constexpr (_Iter_move_cat<_BidIt1, _BidIt2>::_Bitcopy_assignable) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            return _STD _Copy_backward_memmove(_First, _Last, _Dest);
+        }
+    }
+
+    while (_First != _Last) {
+        *--_Dest = _STD move(*--_Last);
+    }
+
+    return _Dest;
+}
+
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
+_CONSTEXPR20 _BidIt2 move_backward(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest) {
+    // move [_First, _Last) backwards to [..., _Dest)
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    const auto _UDest  = _STD _Get_unwrapped_n(_Dest, -_STD _Idl_distance<_BidIt1>(_UFirst, _ULast));
+    _STD _Seek_wrapped(_Dest, _STD _Move_backward_unchecked(_UFirst, _ULast, _UDest));
+    return _Dest;
+}
+
+template <class _Ty>
+struct _Is_character : false_type {}; // by default, not a character type
+
+template <>
+struct _Is_character<char> : true_type {}; // chars are characters
+
+template <>
+struct _Is_character<signed char> : true_type {}; // signed chars are also characters
+
+template <>
+struct _Is_character<unsigned char> : true_type {}; // unsigned chars are also characters
+
+#ifdef __cpp_char8_t
+template <>
+struct _Is_character<char8_t> : true_type {}; // UTF-8 code units are sort-of characters
+#endif // defined(__cpp_char8_t)
+
+template <class _Ty>
+struct _Is_character_or_bool : _Is_character<_Ty>::type {};
+
+template <>
+struct _Is_character_or_bool<bool> : true_type {};
+
+template <class _Ty>
+struct _Is_character_or_byte_or_bool : _Is_character_or_bool<_Ty>::type {};
+
+#ifdef __cpp_lib_byte
+template <>
+struct _Is_character_or_byte_or_bool<byte> : true_type {};
+#endif // defined(__cpp_lib_byte)
+
+// _Fill_memset_is_safe determines if _FwdIt and _Ty are eligible for memset optimization in fill.
+// Need to explicitly test for volatile because _Unwrap_enum_t discards qualifiers.
+template <class _FwdIt, class _Ty, bool = _Iterator_is_contiguous<_FwdIt>>
+constexpr bool _Fill_memset_is_safe = conjunction_v<is_scalar<_Ty>,
+    _Is_character_or_byte_or_bool<_Unwrap_enum_t<remove_reference_t<_Iter_ref_t<_FwdIt>>>>,
+    negation<is_volatile<remove_reference_t<_Iter_ref_t<_FwdIt>>>>, is_assignable<_Iter_ref_t<_FwdIt>, const _Ty&>>;
+
+template <class _FwdIt, class _Ty>
+constexpr bool _Fill_memset_is_safe<_FwdIt, _Ty, false> = false;
+
+template <class _FwdIt, class _Ty, bool = _Iterator_is_contiguous<_FwdIt>>
+constexpr bool _Fill_zero_memset_is_safe =
+    conjunction_v<is_scalar<_Ty>, is_scalar<_Iter_value_t<_FwdIt>>, negation<is_member_pointer<_Iter_value_t<_FwdIt>>>,
+        negation<is_volatile<remove_reference_t<_Iter_ref_t<_FwdIt>>>>, is_assignable<_Iter_ref_t<_FwdIt>, const _Ty&>>;
+
+template <class _FwdIt, class _Ty>
+constexpr bool _Fill_zero_memset_is_safe<_FwdIt, _Ty, false> = false;
+
+template <class _CtgIt, class _Ty>
+void _Fill_memset(_CtgIt _Dest, const _Ty _Val, const size_t _Count) {
+    // implicitly convert (a cast would suppress warnings); also handles _Iter_value_t<_CtgIt> being bool
+    _Iter_value_t<_CtgIt> _Dest_val = _Val;
+    _CSTD memset(_STD _To_address(_Dest), static_cast<unsigned char>(_Dest_val), _Count);
+}
+
+template <class _CtgIt>
+void _Fill_zero_memset(_CtgIt _Dest, const size_t _Count) {
+    _CSTD memset(_STD _To_address(_Dest), 0, _Count * sizeof(_Iter_value_t<_CtgIt>));
+}
+
+template <class _Ty>
+_NODISCARD bool _Is_all_bits_zero(const _Ty& _Val) {
+    // checks if scalar type has all bits set to zero
+    _STL_INTERNAL_STATIC_ASSERT(is_scalar_v<_Ty> && !is_member_pointer_v<_Ty>);
+    if constexpr (is_same_v<_Ty, nullptr_t>) {
+        return true;
+    } else {
+        constexpr _Ty _Zero{};
+        return _CSTD memcmp(&_Val, &_Zero, sizeof(_Ty)) == 0;
+    }
+}
+
+_EXPORT_STD template <class _FwdIt, class _Ty>
+_CONSTEXPR20 void fill(const _FwdIt _First, const _FwdIt _Last, const _Ty& _Val) {
+    // copy _Val through [_First, _Last)
+    _STD _Adl_verify_range(_First, _Last);
+    if constexpr (_Is_vb_iterator<_FwdIt, true>) {
+        _STD _Fill_vbool(_First, _Last, _Val);
+    } else {
+        auto _UFirst      = _STD _Get_unwrapped(_First);
+        const auto _ULast = _STD _Get_unwrapped(_Last);
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            if constexpr (_Fill_memset_is_safe<decltype(_UFirst), _Ty>) {
+                _STD _Fill_memset(_UFirst, _Val, static_cast<size_t>(_ULast - _UFirst));
+                return;
+            } else if constexpr (_Fill_zero_memset_is_safe<decltype(_UFirst), _Ty>) {
+                if (_STD _Is_all_bits_zero(_Val)) {
+                    _STD _Fill_zero_memset(_UFirst, static_cast<size_t>(_ULast - _UFirst));
+                    return;
+                }
+            }
+        }
+
+        for (; _UFirst != _ULast; ++_UFirst) {
+            *_UFirst = _Val;
+        }
+    }
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+void fill(_ExPo&&, _FwdIt _First, _FwdIt _Last, const _Ty& _Val) noexcept /* terminates */ {
+    // copy _Val through [_First, _Last)
+    // not parallelized as benchmarks show it isn't worth it
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt);
+    return _STD fill(_First, _Last, _Val);
+}
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _OutIt, class _Diff, class _Ty>
+_CONSTEXPR20 _OutIt fill_n(_OutIt _Dest, const _Diff _Count_raw, const _Ty& _Val) {
+    // copy _Val _Count times through [_Dest, ...)
+    _Algorithm_int_t<_Diff> _Count = _Count_raw;
+    if (0 < _Count) {
+        if constexpr (_Is_vb_iterator<_OutIt, true>) {
+            const auto _Last = _Dest + static_cast<typename _OutIt::difference_type>(_Count);
+            _STD _Fill_vbool(_Dest, _Last, _Val);
+            return _Last;
+        } else {
+            auto _UDest = _STD _Get_unwrapped_n(_Dest, _Count);
+#if _HAS_CXX20
+            if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+            {
+                if constexpr (_Fill_memset_is_safe<decltype(_UDest), _Ty>) {
+                    _STD _Fill_memset(_UDest, _Val, static_cast<size_t>(_Count));
+                    _STD _Seek_wrapped(_Dest, _UDest + _Count);
+                    return _Dest;
+                } else if constexpr (_Fill_zero_memset_is_safe<decltype(_UDest), _Ty>) {
+                    if (_STD _Is_all_bits_zero(_Val)) {
+                        _STD _Fill_zero_memset(_UDest, static_cast<size_t>(_Count));
+                        _STD _Seek_wrapped(_Dest, _UDest + _Count);
+                        return _Dest;
+                    }
+                }
+            }
+
+            for (; 0 < _Count; --_Count, (void) ++_UDest) {
+                *_UDest = _Val;
+            }
+
+            _STD _Seek_wrapped(_Dest, _UDest);
+        }
+    }
+    return _Dest;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Diff, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt fill_n(_ExPo&&, _FwdIt _Dest, _Diff _Count_raw, const _Ty& _Val) noexcept /* terminates */ {
+    // copy _Val _Count times through [_Dest, ...)
+    // not parallelized as benchmarks show it isn't worth it
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt);
+    return _STD fill_n(_Dest, _Count_raw, _Val);
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    class _Fill_n_fn {
+    public:
+        template <class _Ty, output_iterator<const _Ty&> _It>
+        _STATIC_CALL_OPERATOR constexpr _It operator()(
+            _It _First, iter_difference_t<_It> _Count, const _Ty& _Value) _CONST_CALL_OPERATOR {
+            if (_Count > 0) {
+                auto _UFirst = _STD _Get_unwrapped_n(_STD move(_First), _Count);
+                if (!_STD is_constant_evaluated()) {
+                    if constexpr (_Fill_memset_is_safe<decltype(_UFirst), _Ty>) {
+                        _STD _Fill_memset(_UFirst, _Value, static_cast<size_t>(_Count));
+                        _STD _Seek_wrapped(_First, _UFirst + _Count); // no need to move since _UFirst is a pointer
+                        return _First;
+                    } else if constexpr (_Fill_zero_memset_is_safe<decltype(_UFirst), _Ty>) {
+                        if (_STD _Is_all_bits_zero(_Value)) {
+                            _STD _Fill_zero_memset(_UFirst, static_cast<size_t>(_Count));
+                            _STD _Seek_wrapped(_First, _UFirst + _Count); // no need to move since _UFirst is a pointer
+                            return _First;
+                        }
+                    }
+                }
+
+                for (; _Count > 0; ++_UFirst, (void) --_Count) {
+                    *_UFirst = _Value;
+                }
+
+                _STD _Seek_wrapped(_First, _STD move(_UFirst));
+            }
+
+            return _First;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Fill_n_fn fill_n;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+template <class _Ty1, class _Ty2, class = void>
+constexpr bool _Can_compare_with_operator_equal = false;
+
+template <class _Ty1, class _Ty2>
+constexpr bool
+    _Can_compare_with_operator_equal<_Ty1, _Ty2, void_t<decltype(_STD declval<_Ty1&>() == _STD declval<_Ty2&>())>> =
+        true;
+
+template <class _Ty1, class _Ty2>
+constexpr bool _Is_pointer_address_comparable =
+    _Can_compare_with_operator_equal<_Ty1*, _Ty2*>
+    && (_Is_pointer_address_convertible<_Ty1, _Ty2> || _Is_pointer_address_convertible<_Ty2, _Ty1>);
+
+// _Can_memcmp_elements<_Elem1, _Elem2> reports whether `_Elem1 == _Elem2` can be optimized to memcmp.
+// Here, _Elem1 and _Elem2 aren't top-level const, because we remove_const_t before using _Can_memcmp_elements.
+
+// Integral types are eligible for memcmp in very specific cases.
+// * They must be the same size. (`int == long` is eligible; `int == long long` isn't.)
+// * The usual arithmetic conversions must preserve bit patterns. (This is true for `int == unsigned int`,
+//   but false for `short == unsigned short`.)
+#pragma warning(push)
+#pragma warning(disable : 4806) // no value of type 'bool' promoted to type 'char' can equal the given constant
+template <class _Elem1, class _Elem2,
+    bool = sizeof(_Elem1) == sizeof(_Elem2) && is_integral_v<_Elem1> && is_integral_v<_Elem2>>
+constexpr bool _Can_memcmp_elements =
+    is_same_v<_Elem1, bool> || is_same_v<_Elem2, bool> || static_cast<_Elem1>(-1) == static_cast<_Elem2>(-1);
+#pragma warning(pop)
+
+#ifdef __cpp_lib_byte
+// Allow memcmping std::byte.
+// inline is required here as explicit specializations of variable templates are problematic in C++14.
+// However, std::byte is C++17 and above so we are safe.
+template <>
+inline constexpr bool _Can_memcmp_elements<byte, byte, false> = true;
+#endif // defined(__cpp_lib_byte)
+
+// Pointer elements are eligible for memcmp when they point to the same type, ignoring cv-qualification.
+// This handles pointers to object types, pointers to void, and pointers to function types.
+template <class _Ty1, class _Ty2>
+constexpr bool _Can_memcmp_elements<_Ty1*, _Ty2*, false> = _Is_pointer_address_comparable<_Ty1, _Ty2>;
+
+template <class _Elem1, class _Elem2>
+constexpr bool _Can_memcmp_elements<_Elem1, _Elem2, false> = false;
+
+// _Can_memcmp_elements_with_pred<_Elem1, _Elem2, _Pr> reports whether the memcmp optimization is applicable,
+// given contiguously stored elements. (This avoids having to repeat the metaprogramming that finds the element types.)
+// _Elem1 and _Elem2 aren't top-level const here.
+template <class _Elem1, class _Elem2, class _Pr>
+constexpr bool _Can_memcmp_elements_with_pred = false;
+
+// With equal_to<_Elem3> we need to make sure that both _Elem1 and _Elem2 are convertible to _Elem3 without changing
+// object representation (we use _Iter_copy_cat for this task) and _Elem3 can be safely memcmp'ed with itself
+template <class _Elem1, class _Elem2, class _Elem3>
+constexpr bool _Can_memcmp_elements_with_pred<_Elem1, _Elem2, equal_to<_Elem3>> =
+    _Iter_copy_cat<_Elem1*, _Elem3*>::_Bitcopy_constructible && _Iter_copy_cat<_Elem2*, _Elem3*>::_Bitcopy_constructible
+    && _Can_memcmp_elements<remove_cv_t<_Elem3>, remove_cv_t<_Elem3>>;
+
+// equal_to<> is transparent.
+template <class _Elem1, class _Elem2>
+constexpr bool _Can_memcmp_elements_with_pred<_Elem1, _Elem2, equal_to<>> = _Can_memcmp_elements<_Elem1, _Elem2>;
+
+#if _HAS_CXX20
+// ranges::equal_to is also transparent.
+template <class _Elem1, class _Elem2>
+constexpr bool _Can_memcmp_elements_with_pred<_Elem1, _Elem2, _RANGES equal_to> = _Can_memcmp_elements<_Elem1, _Elem2>;
+#endif // _HAS_CXX20
+
+// _Equal_memcmp_is_safe<_Iter1, _Iter2, _Pr> reports whether we can activate the memcmp optimization
+// for arbitrary iterators and predicates.
+// It ignores top-level constness on the iterators and on the elements.
+template <class _Iter1, class _Iter2, class _Pr>
+constexpr bool _Equal_memcmp_is_safe_helper =
+    _Iterators_are_contiguous<_Iter1, _Iter2> && !_Iterator_is_volatile<_Iter1> && !_Iterator_is_volatile<_Iter2>
+    && _Can_memcmp_elements_with_pred<_Iter_value_t<_Iter1>, _Iter_value_t<_Iter2>, _Pr>;
+
+template <class _Iter1, class _Iter2, class _Pr>
+constexpr bool _Equal_memcmp_is_safe =
+    _Equal_memcmp_is_safe_helper<remove_const_t<_Iter1>, remove_const_t<_Iter2>, remove_const_t<_Pr>>;
+
+template <class _CtgIt1, class _CtgIt2>
+_NODISCARD int _Memcmp_count(_CtgIt1 _First1, _CtgIt2 _First2, const size_t _Count) {
+    _STL_INTERNAL_STATIC_ASSERT(sizeof(_Iter_value_t<_CtgIt1>) == sizeof(_Iter_value_t<_CtgIt2>));
+    const auto _First1_ch = reinterpret_cast<const char*>(_STD _To_address(_First1));
+    const auto _First2_ch = reinterpret_cast<const char*>(_STD _To_address(_First2));
+    return _CSTD memcmp(_First1_ch, _First2_ch, _Count * sizeof(_Iter_value_t<_CtgIt1>));
+}
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Pr>
+_NODISCARD _CONSTEXPR20 bool equal(const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, _Pr _Pred) {
+    // compare [_First1, _Last1) to [_First2, ...)
+    _STD _Adl_verify_range(_First1, _Last1);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    const auto _ULast1 = _STD _Get_unwrapped(_Last1);
+    auto _UFirst2      = _STD _Get_unwrapped_n(_First2, _STD _Idl_distance<_InIt1>(_UFirst1, _ULast1));
+    if constexpr (_Equal_memcmp_is_safe<decltype(_UFirst1), decltype(_UFirst2), _Pr>) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            _STL_INTERNAL_STATIC_ASSERT(
+                sizeof(_Iter_value_t<decltype(_UFirst1)>) == sizeof(_Iter_value_t<decltype(_UFirst2)>));
+            const auto _First1_ch = reinterpret_cast<const char*>(_STD _To_address(_UFirst1));
+            const auto _Size      = reinterpret_cast<const char*>(_STD _To_address(_ULast1)) - _First1_ch;
+            return _CSTD memcmp(_First1_ch, _STD _To_address(_UFirst2), static_cast<size_t>(_Size)) == 0;
+        }
+    }
+
+    for (; _UFirst1 != _ULast1; ++_UFirst1, (void) ++_UFirst2) {
+        if (!_Pred(*_UFirst1, *_UFirst2)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD bool equal(_ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2,
+    _Pr _Pred) noexcept; // terminates
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _InIt1, class _InIt2>
+_NODISCARD _CONSTEXPR20 bool equal(const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2) {
+    // compare [_First1, _Last1) to [_First2, ...)
+    return _STD equal(_First1, _Last1, _First2, equal_to<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD bool equal(_ExPo&& _Exec, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2) noexcept
+/* terminates */ {
+    // compare [_First1, _Last1) to [_First2, ...)
+    return _STD equal(_STD forward<_ExPo>(_Exec), _First1, _Last1, _First2, equal_to{});
+}
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Pr>
+_NODISCARD _CONSTEXPR20 bool equal(
+    const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, const _InIt2 _Last2, _Pr _Pred) {
+    // compare [_First1, _Last1) to [_First2, _Last2)
+    _STD _Adl_verify_range(_First1, _Last1);
+    _STD _Adl_verify_range(_First2, _Last2);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    const auto _ULast1 = _STD _Get_unwrapped(_Last1);
+    auto _UFirst2      = _STD _Get_unwrapped(_First2);
+    const auto _ULast2 = _STD _Get_unwrapped(_Last2);
+    if constexpr (_Is_ranges_random_iter_v<_InIt1> && _Is_ranges_random_iter_v<_InIt2>) {
+        if (_ULast1 - _UFirst1 != _ULast2 - _UFirst2) {
+            return false;
+        }
+
+        return _STD equal(_UFirst1, _ULast1, _UFirst2, _STD _Pass_fn(_Pred));
+    } else {
+        for (;;) {
+            if (_UFirst1 == _ULast1) {
+                return _UFirst2 == _ULast2;
+            }
+
+            if (_UFirst2 == _ULast2) {
+                return false;
+            }
+
+            if (!_Pred(*_UFirst1, *_UFirst2)) {
+                return false;
+            }
+
+            ++_UFirst1;
+            ++_UFirst2;
+        }
+    }
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD bool equal(
+    _ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred) noexcept; // terminates
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _InIt1, class _InIt2>
+_NODISCARD _CONSTEXPR20 bool equal(
+    const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, const _InIt2 _Last2) {
+    // compare [_First1, _Last1) to [_First2, _Last2)
+    return _STD equal(_First1, _Last1, _First2, _Last2, equal_to<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD bool equal(_ExPo&& _Exec, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2,
+    const _FwdIt2 _Last2) noexcept /* terminates */ {
+    // compare [_First1, _Last1) to [_First2, _Last2)
+    return _STD equal(_STD forward<_ExPo>(_Exec), _First1, _Last1, _First2, _Last2, equal_to{});
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    template <forward_range _Rng, class _It>
+    _NODISCARD constexpr iterator_t<_Rng> _Rewrap_iterator(_Rng&& _Range, _It&& _Val) {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_It>, _Unwrapped_iterator_t<_Rng>>);
+
+        if constexpr (is_same_v<remove_cvref_t<_It>, iterator_t<_Rng>>) {
+            return _STD forward<_It>(_Val);
+        } else {
+            auto _Result = _RANGES begin(_Range);
+            _Result._Seek_to(_STD forward<_It>(_Val));
+            return _Result;
+        }
+    }
+
+    _EXPORT_STD template <class _In1, class _In2>
+    struct in_in_result {
+        /* [[no_unique_address]] */ _In1 in1;
+        /* [[no_unique_address]] */ _In2 in2;
+
+        template <_Convertible_from<const _In1&> _IIn1, _Convertible_from<const _In2&> _IIn2>
+        constexpr operator in_in_result<_IIn1, _IIn2>() const& {
+            return {in1, in2};
+        }
+
+        template <_Convertible_from<_In1> _IIn1, _Convertible_from<_In2> _IIn2>
+        constexpr operator in_in_result<_IIn1, _IIn2>() && {
+            return {_STD move(in1), _STD move(in2)};
+        }
+    };
+
+    _EXPORT_STD template <class _In1, class _In2>
+    using mismatch_result = in_in_result<_In1, _In2>;
+
+    template <input_iterator _It1, input_iterator _It2, class _Pr, class _Pj1, class _Pj2>
+        requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
+    _NODISCARD constexpr mismatch_result<_It1, _It2> _Mismatch_n(
+        _It1 _First1, _It2 _First2, iter_difference_t<_It1> _Count, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+        _STL_INTERNAL_CHECK(_Count >= 0);
+#if _USE_STD_VECTOR_ALGORITHMS
+        if constexpr (_Equal_memcmp_is_safe<_It1, _It2, _Pr> && is_same_v<_Pj1, identity>
+                      && is_same_v<_Pj2, identity>) {
+            if (!_STD is_constant_evaluated()) {
+                constexpr size_t _Elem_size = sizeof(iter_value_t<_It1>);
+
+                const size_t _Pos = _STD _Mismatch_vectorized<_Elem_size>(
+                    _STD _To_address(_First1), _STD _To_address(_First2), static_cast<size_t>(_Count));
+
+                return {_First1 + static_cast<iter_difference_t<_It1>>(_Pos),
+                    _First2 + static_cast<iter_difference_t<_It2>>(_Pos)};
+            }
+        }
+#endif // ^^^ _USE_STD_VECTOR_ALGORITHMS ^^^
+        for (; _Count != 0; ++_First1, (void) ++_First2, --_Count) {
+            if (!_STD invoke(_Pred, _STD invoke(_Proj1, *_First1), _STD invoke(_Proj2, *_First2))) {
+                break;
+            }
+        }
+
+        return {_STD move(_First1), _STD move(_First2)};
+    }
+
+    template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2, class _Pr,
+        class _Pj1, class _Pj2>
+        requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
+    _NODISCARD constexpr mismatch_result<_It1, _It2> _Mismatch_4(
+        _It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+        for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, (void) ++_First2) {
+            if (!_STD invoke(_Pred, _STD invoke(_Proj1, *_First1), _STD invoke(_Proj2, *_First2))) {
+                break;
+            }
+        }
+
+        return {_STD move(_First1), _STD move(_First2)};
+    }
+
+    class _Mismatch_fn {
+    public:
+        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
+            class _Pr = ranges::equal_to, class _Pj1 = identity, class _Pj2 = identity>
+            requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr mismatch_result<_It1, _It2> operator()(_It1 _First1, _Se1 _Last1,
+            _It2 _First2, _Se2 _Last2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+            _STD _Adl_verify_range(_First1, _Last1);
+            _STD _Adl_verify_range(_First2, _Last2);
+
+            if constexpr (sized_sentinel_for<_Se1, _It1> && sized_sentinel_for<_Se2, _It2>) {
+                iter_difference_t<_It1> _Count1       = _Last1 - _First1;
+                const iter_difference_t<_It2> _Count2 = _Last2 - _First2;
+                if (_Count1 > _Count2) {
+                    _Count1 = static_cast<decltype(_Count1)>(_Count2);
+                }
+
+                auto _Result = _RANGES _Mismatch_n(_STD _Get_unwrapped(_STD move(_First1)),
+                    _STD _Get_unwrapped(_STD move(_First2)), _Count1, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1),
+                    _STD _Pass_fn(_Proj2));
+                _STD _Seek_wrapped(_First1, _STD move(_Result.in1));
+                _STD _Seek_wrapped(_First2, _STD move(_Result.in2));
+                return {_STD move(_First1), _STD move(_First2)};
+            } else {
+                auto _Result = _RANGES _Mismatch_4(_RANGES _Unwrap_iter<_Se1>(_STD move(_First1)),
+                    _RANGES _Unwrap_sent<_It1>(_STD move(_Last1)), _RANGES _Unwrap_iter<_Se2>(_STD move(_First2)),
+                    _RANGES _Unwrap_sent<_It2>(_STD move(_Last2)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1),
+                    _STD _Pass_fn(_Proj2));
+                _STD _Seek_wrapped(_First1, _STD move(_Result.in1));
+                _STD _Seek_wrapped(_First2, _STD move(_Result.in2));
+                return {_STD move(_First1), _STD move(_First2)};
+            }
+        }
+
+        template <input_range _Rng1, input_range _Rng2, class _Pr = ranges::equal_to, class _Pj1 = identity,
+            class _Pj2 = identity>
+            requires indirectly_comparable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Pr, _Pj1, _Pj2>
+        _NODISCARD
+            _STATIC_CALL_OPERATOR constexpr mismatch_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>>
+            operator()(_Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {},
+                _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+            if constexpr (sized_range<_Rng1> && sized_range<_Rng2>) {
+                range_difference_t<_Rng1> _Count1       = _RANGES distance(_Range1);
+                const range_difference_t<_Rng2> _Count2 = _RANGES distance(_Range2);
+                if (_Count1 > _Count2) {
+                    _Count1 = static_cast<range_difference_t<_Rng1>>(_Count2);
+                }
+
+                auto _First1 = _RANGES begin(_Range1);
+                auto _First2 = _RANGES begin(_Range2);
+                auto _Result = _RANGES _Mismatch_n(_STD _Get_unwrapped(_STD move(_First1)),
+                    _STD _Get_unwrapped(_STD move(_First2)), _Count1, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1),
+                    _STD _Pass_fn(_Proj2));
+                _STD _Seek_wrapped(_First1, _STD move(_Result.in1));
+                _STD _Seek_wrapped(_First2, _STD move(_Result.in2));
+                return {_STD move(_First1), _STD move(_First2)};
+            } else {
+                auto _First1 = _RANGES begin(_Range1);
+                auto _First2 = _RANGES begin(_Range2);
+                auto _Result = _RANGES _Mismatch_4(_RANGES _Unwrap_range_iter<_Rng1>(_STD move(_First1)),
+                    _Uend(_Range1), _RANGES _Unwrap_range_iter<_Rng2>(_STD move(_First2)), _Uend(_Range2),
+                    _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+                _STD _Seek_wrapped(_First1, _STD move(_Result.in1));
+                _STD _Seek_wrapped(_First2, _STD move(_Result.in2));
+                return {_STD move(_First1), _STD move(_First2)};
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Mismatch_fn mismatch;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+template <class _Elem1, class _Elem2>
+constexpr bool _Lex_compare_memcmp_classify_elements =
+#if _USE_STD_VECTOR_ALGORITHMS
+    is_integral_v<_Elem1> && is_integral_v<_Elem2> && sizeof(_Elem1) == sizeof(_Elem2)
+    && is_unsigned_v<_Elem1> == is_unsigned_v<_Elem2>;
+#else // ^^^ _USE_STD_VECTOR_ALGORITHMS / !_USE_STD_VECTOR_ALGORITHMS vvv
+    conjunction_v<_Is_character_or_bool<_Elem1>, _Is_character_or_bool<_Elem2>, is_unsigned<_Elem1>,
+        is_unsigned<_Elem2>>;
+#endif // ^^^ !_USE_STD_VECTOR_ALGORITHMS ^^^
+
+#ifdef __cpp_lib_byte
+template <>
+inline constexpr bool _Lex_compare_memcmp_classify_elements<byte, byte> = true;
+#endif // defined(__cpp_lib_byte)
+
+template <class _Elem1, class _Elem2, class _Pr>
+struct _Lex_compare_memcmp_classify_pred {
+    using _Pred = void;
+};
+
+template <class _Elem1, class _Elem2, class _Elem3>
+struct _Lex_compare_memcmp_classify_pred<_Elem1, _Elem2, less<_Elem3>> {
+    using _Pred = conditional_t<_Lex_compare_memcmp_classify_elements<_Elem3, _Elem3>
+                                    && _Iter_copy_cat<_Elem1*, _Elem3*>::_Bitcopy_constructible
+                                    && _Iter_copy_cat<_Elem2*, _Elem3*>::_Bitcopy_constructible,
+        less<int>, void>;
+};
+
+template <class _Elem1, class _Elem2>
+struct _Lex_compare_memcmp_classify_pred<_Elem1, _Elem2, less<>> {
+    using _Pred = conditional_t<_Lex_compare_memcmp_classify_elements<_Elem1, _Elem2>, less<int>, void>;
+};
+
+template <class _Elem1, class _Elem2, class _Elem3>
+struct _Lex_compare_memcmp_classify_pred<_Elem1, _Elem2, greater<_Elem3>> {
+    using _Pred = conditional_t<_Lex_compare_memcmp_classify_elements<_Elem3, _Elem3>
+                                    && _Iter_copy_cat<_Elem1*, _Elem3*>::_Bitcopy_constructible
+                                    && _Iter_copy_cat<_Elem2*, _Elem3*>::_Bitcopy_constructible,
+        greater<int>, void>;
+};
+
+template <class _Elem1, class _Elem2>
+struct _Lex_compare_memcmp_classify_pred<_Elem1, _Elem2, greater<>> {
+    using _Pred = conditional_t<_Lex_compare_memcmp_classify_elements<_Elem1, _Elem2>, greater<int>, void>;
+};
+
+#if _HAS_CXX20
+template <class _Elem1, class _Elem2>
+struct _Lex_compare_memcmp_classify_pred<_Elem1, _Elem2, _RANGES less> {
+    using _Pred = conditional_t<_Lex_compare_memcmp_classify_elements<_Elem1, _Elem2>, less<int>, void>;
+};
+
+template <class _Elem1, class _Elem2>
+struct _Lex_compare_memcmp_classify_pred<_Elem1, _Elem2, _RANGES greater> {
+    using _Pred = conditional_t<_Lex_compare_memcmp_classify_elements<_Elem1, _Elem2>, greater<int>, void>;
+};
+#endif // _HAS_CXX20
+
+template <class _It1, class _It2, class _Pr>
+using _Lex_compare_memcmp_classify =
+    conditional_t<_Iterators_are_contiguous<_It1, _It2> && !_Iterator_is_volatile<_It1> && !_Iterator_is_volatile<_It2>,
+        typename _Lex_compare_memcmp_classify_pred<_Iter_value_t<_It1>, _Iter_value_t<_It2>, _Pr>::_Pred, void>;
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Pr>
+_NODISCARD _CONSTEXPR20 bool lexicographical_compare(
+    const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, const _InIt2 _Last2, _Pr _Pred) {
+    // order [_First1, _Last1) vs. [_First2, _Last2)
+    _STD _Adl_verify_range(_First1, _Last1);
+    _STD _Adl_verify_range(_First2, _Last2);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    const auto _ULast1 = _STD _Get_unwrapped(_Last1);
+    auto _UFirst2      = _STD _Get_unwrapped(_First2);
+    const auto _ULast2 = _STD _Get_unwrapped(_Last2);
+
+    using _Memcmp_pred = _Lex_compare_memcmp_classify<decltype(_UFirst1), decltype(_UFirst2), _Pr>;
+    if constexpr (!is_void_v<_Memcmp_pred>) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            const auto _Num1  = static_cast<size_t>(_ULast1 - _UFirst1);
+            const auto _Num2  = static_cast<size_t>(_ULast2 - _UFirst2);
+            const size_t _Num = (_STD min)(_Num1, _Num2);
+#if _USE_STD_VECTOR_ALGORITHMS
+            const auto _First1_ptr = _STD _To_address(_UFirst1);
+            const auto _First2_ptr = _STD _To_address(_UFirst2);
+            const size_t _Pos      = _Mismatch_vectorized<sizeof(*_First1_ptr)>(_First1_ptr, _First2_ptr, _Num);
+            if (_Pos == _Num2) {
+                return false;
+            } else if (_Pos == _Num1) {
+                return true;
+            } else {
+                return _Pred(_First1_ptr[_Pos], _First2_ptr[_Pos]);
+            }
+#else // ^^^ _USE_STD_VECTOR_ALGORITHMS / !_USE_STD_VECTOR_ALGORITHMS vvv
+            const int _Ans = _STD _Memcmp_count(_UFirst1, _UFirst2, _Num);
+            return _Memcmp_pred{}(_Ans, 0) || (_Ans == 0 && _Num1 < _Num2);
+#endif // ^^^ !_USE_STD_VECTOR_ALGORITHMS ^^^
+        }
+    }
+
+    for (; _UFirst1 != _ULast1 && _UFirst2 != _ULast2; ++_UFirst1, (void) ++_UFirst2) { // something to compare, do it
+        if (_DEBUG_LT_PRED(_Pred, *_UFirst1, *_UFirst2)) {
+            return true;
+        } else if (_Pred(*_UFirst2, *_UFirst1)) {
+            return false;
+        }
+    }
+
+    return _UFirst1 == _ULast1 && _UFirst2 != _ULast2;
+}
+
+_EXPORT_STD template <class _InIt1, class _InIt2>
+_NODISCARD _CONSTEXPR20 bool lexicographical_compare(
+    const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, const _InIt2 _Last2) {
+    // order [_First1, _Last1) vs. [_First2, _Last2)
+    return _STD lexicographical_compare(_First1, _Last1, _First2, _Last2, less<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD bool lexicographical_compare(_ExPo&&, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2,
+    const _FwdIt2 _Last2, _Pr _Pred) noexcept /* terminates */ {
+    // order [_First1, _Last1) vs. [_First2, _Last2)
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt2);
+    return _STD lexicographical_compare(_First1, _Last1, _First2, _Last2, _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD bool lexicographical_compare(_ExPo&&, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2,
+    const _FwdIt2 _Last2) noexcept /* terminates */ {
+    // order [_First1, _Last1) vs. [_First2, _Last2)
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt2);
+    return _STD lexicographical_compare(_First1, _Last1, _First2, _Last2);
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+template <class _Elem1, class _Elem2, class _Cmp>
+struct _Lex_compare_three_way_memcmp_classify_comp {
+    using _Comp = void;
+};
+
+template <class _Elem1, class _Elem2>
+struct _Lex_compare_three_way_memcmp_classify_comp<_Elem1, _Elem2, compare_three_way> {
+    using _Comp = conditional_t<_Lex_compare_memcmp_classify_elements<_Elem1, _Elem2>
+                                    && three_way_comparable_with<const _Elem1&, const _Elem2&>,
+        compare_three_way, void>;
+};
+
+template <class _Elem1, class _Elem2>
+struct _Lex_compare_three_way_memcmp_classify_comp<_Elem1, _Elem2, _Strong_order::_Cpo> {
+    using _Comp =
+        conditional_t<_Lex_compare_memcmp_classify_elements<_Elem1, _Elem2> && _Can_strong_order<_Elem1, _Elem2>,
+            _Strong_order::_Cpo, void>;
+};
+
+template <class _Elem1, class _Elem2>
+struct _Lex_compare_three_way_memcmp_classify_comp<_Elem1, _Elem2, _Weak_order::_Cpo> {
+    using _Comp =
+        conditional_t<_Lex_compare_memcmp_classify_elements<_Elem1, _Elem2> && _Can_weak_order<_Elem1, _Elem2>,
+            _Weak_order::_Cpo, void>;
+};
+
+template <class _Elem1, class _Elem2>
+struct _Lex_compare_three_way_memcmp_classify_comp<_Elem1, _Elem2, _Partial_order::_Cpo> {
+    using _Comp =
+        conditional_t<_Lex_compare_memcmp_classify_elements<_Elem1, _Elem2> && _Can_partial_order<_Elem1, _Elem2>,
+            _Partial_order::_Cpo, void>;
+};
+
+template <class _It1, class _It2, class _Cmp>
+using _Lex_compare_three_way_memcmp_classify =
+    conditional_t<_Iterators_are_contiguous<_It1, _It2> && !_Iterator_is_volatile<_It1> && !_Iterator_is_volatile<_It2>,
+        typename _Lex_compare_three_way_memcmp_classify_comp<_Iter_value_t<_It1>, _Iter_value_t<_It2>, _Cmp>::_Comp,
+        void>;
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Cmp>
+_NODISCARD constexpr auto lexicographical_compare_three_way(const _InIt1 _First1, const _InIt1 _Last1,
+    const _InIt2 _First2, const _InIt2 _Last2, _Cmp _Comp) -> decltype(_Comp(*_First1, *_First2)) {
+    static_assert(
+        _Classify_category<decltype(_Comp(*_First1, *_First2))> != _Comparison_category::_Comparison_category_none,
+        "The result of the comparator must have comparison category type (N4988 [alg.three.way]/2).");
+
+    _STD _Adl_verify_range(_First1, _Last1);
+    _STD _Adl_verify_range(_First2, _Last2);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    const auto _ULast1 = _STD _Get_unwrapped(_Last1);
+    auto _UFirst2      = _STD _Get_unwrapped(_First2);
+    const auto _ULast2 = _STD _Get_unwrapped(_Last2);
+
+    using _Memcmp_pred = _Lex_compare_three_way_memcmp_classify<decltype(_UFirst1), decltype(_UFirst2), _Cmp>;
+    if constexpr (!is_void_v<_Memcmp_pred>) {
+        if (!_STD is_constant_evaluated()) {
+            const auto _Num1  = static_cast<size_t>(_ULast1 - _UFirst1);
+            const auto _Num2  = static_cast<size_t>(_ULast2 - _UFirst2);
+            const size_t _Num = (_STD min)(_Num1, _Num2);
+#if _USE_STD_VECTOR_ALGORITHMS
+            const auto _First1_ptr = _STD to_address(_UFirst1);
+            const auto _First2_ptr = _STD to_address(_UFirst2);
+            const size_t _Pos      = _Mismatch_vectorized<sizeof(*_First1_ptr)>(_First1_ptr, _First2_ptr, _Num);
+            if (_Pos == _Num1) {
+                return _Pos == _Num2 ? strong_ordering::equal : strong_ordering::less;
+            } else if (_Pos == _Num2) {
+                return strong_ordering::greater;
+            } else {
+                const auto _Val1 = _First1_ptr[_Pos];
+                const auto _Val2 = _First2_ptr[_Pos];
+                __assume(_Val1 != _Val2); // avoid one comparison
+                return _Comp(_Val1, _Val2);
+            }
+#else // ^^^ _USE_STD_VECTOR_ALGORITHMS / !_USE_STD_VECTOR_ALGORITHMS vvv
+            const int _Ans = _STD _Memcmp_count(_UFirst1, _UFirst2, _Num);
+            if (_Ans == 0) {
+                return _Num1 <=> _Num2;
+            } else {
+                return _Memcmp_pred{}(_Ans, 0);
+            }
+#endif // ^^^ !_USE_STD_VECTOR_ALGORITHMS ^^^
+        }
+    }
+
+    for (;;) {
+        if (_UFirst1 == _ULast1) {
+            return _UFirst2 == _ULast2 ? strong_ordering::equal : strong_ordering::less;
+        }
+
+        if (_UFirst2 == _ULast2) {
+            return strong_ordering::greater;
+        }
+
+        if (const auto _CmpResult = _Comp(*_UFirst1, *_UFirst2); _CmpResult != 0) {
+            return _CmpResult;
+        }
+
+        ++_UFirst1;
+        ++_UFirst2;
+    }
+}
+
+_EXPORT_STD template <class _InIt1, class _InIt2>
+_NODISCARD constexpr auto lexicographical_compare_three_way(
+    const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, const _InIt2 _Last2) {
+    return _STD lexicographical_compare_three_way(_First1, _Last1, _First2, _Last2, compare_three_way{});
+}
+#endif // _HAS_CXX20
+
+template <class _Ty, class _Elem>
+struct _Vector_alg_in_find_is_safe_object_pointers : false_type {};
+template <class _Ty1, class _Ty2>
+struct _Vector_alg_in_find_is_safe_object_pointers<_Ty1*, _Ty2*>
+    : conjunction<
+          // _Ty1* is an object pointer type
+          disjunction<is_object<_Ty1>, is_void<_Ty1>>,
+          // _Ty2* is an object pointer type
+          disjunction<is_object<_Ty2>, is_void<_Ty2>>,
+          // either _Ty1 is the same as _Ty2 (ignoring cv-qualifiers), or one of the two is void
+          disjunction<is_same<remove_cv_t<_Ty1>, remove_cv_t<_Ty2>>, is_void<_Ty1>, is_void<_Ty2>>> {};
+
+// Can we activate the vector algorithms to find a value in a range of elements?
+template <class _Ty, class _Elem>
+constexpr bool _Vector_alg_in_find_is_safe_elem = disjunction_v<
+#ifdef __cpp_lib_byte
+    // We're finding a std::byte in a range of std::byte.
+    conjunction<is_same<_Ty, byte>, is_same<_Elem, byte>>,
+#endif // defined(__cpp_lib_byte)
+    // We're finding an integer in a range of integers.
+    // This case is the one that requires careful runtime handling in _Could_compare_equal_to_value_type.
+    conjunction<is_integral<_Ty>, is_integral<_Elem>>,
+    // We're finding an (object or function) pointer in a range of pointers of the same type.
+    conjunction<is_pointer<_Ty>, is_same<_Ty, _Elem>>,
+    // We're finding a nullptr in a range of (object or function) pointers.
+    conjunction<is_same<_Ty, nullptr_t>, is_pointer<_Elem>>,
+    // We're finding an object pointer in a range of object pointers, and:
+    // - One of the pointer types is a cv void*.
+    // - One of the pointer types is a cv1 U* and the other is a cv2 U*.
+    _Vector_alg_in_find_is_safe_object_pointers<_Ty, _Elem>>;
+
+// Can we activate the vector algorithms for find/count?
+template <class _Iter, class _Ty>
+constexpr bool _Vector_alg_in_find_is_safe =
+    // The iterator must be contiguous so we can get raw pointers.
+    _Iterator_is_contiguous<_Iter>
+    // The iterator must not be volatile.
+    && !_Iterator_is_volatile<_Iter>
+    // The type of the value to find must be compatible with the type of the elements.
+    && _Vector_alg_in_find_is_safe_elem<_Ty, _Iter_value_t<_Iter>>;
+
+template <class _InIt, class _Ty>
+_NODISCARD constexpr bool _Could_compare_equal_to_value_type(const _Ty& _Val) {
+    // check whether _Val is within the limits of _Elem
+    _STL_INTERNAL_STATIC_ASSERT(_Vector_alg_in_find_is_safe<_InIt, _Ty>);
+
+    if constexpr (disjunction_v<
+#ifdef __cpp_lib_byte
+                      is_same<_Ty, byte>,
+#endif // defined(__cpp_lib_byte)
+                      is_same<_Ty, bool>, is_pointer<_Ty>, is_same<_Ty, nullptr_t>>) {
+        return true;
+    } else {
+        using _Elem = _Iter_value_t<_InIt>;
+        _STL_INTERNAL_STATIC_ASSERT(is_integral_v<_Elem> && is_integral_v<_Ty>);
+
+        if constexpr (is_same_v<_Elem, bool>) {
+            return _Val == true || _Val == false;
+        } else if constexpr (is_signed_v<_Elem>) {
+            constexpr _Elem _Min = _STD _Min_limit<_Elem>();
+            constexpr _Elem _Max = _STD _Max_limit<_Elem>();
+
+            if constexpr (is_signed_v<_Ty>) {
+                // signed _Elem, signed _Ty
+                return _Min <= _Val && _Val <= _Max;
+            } else {
+                // signed _Elem, unsigned _Ty
+                if constexpr (_Elem{-1} == static_cast<_Ty>(-1)) {
+                    // negative values of _Elem can compare equal to values of _Ty
+                    return _Val <= _Max || static_cast<_Ty>(_Min) <= _Val;
+                } else {
+                    // negative values of _Elem cannot compare equal to values of _Ty
+                    return _Val <= _Max;
+                }
+            }
+        } else {
+            constexpr _Elem _Max = _STD _Max_limit<_Elem>();
+
+            if constexpr (is_unsigned_v<_Ty>) {
+                // unsigned _Elem, unsigned _Ty
+                return _Val <= _Max;
+            } else {
+                // unsigned _Elem, signed _Ty
+                if constexpr (_Ty{-1} == static_cast<_Elem>(-1)) {
+                    // negative values of _Ty can compare equal to values of _Elem
+                    return _Val <= _Max;
+                } else {
+                    // negative values of _Ty cannot compare equal to values of _Elem
+                    return 0 <= _Val && _Val <= _Max;
+                }
+            }
+        }
+    }
+}
+
+template <class _InIt, class _Ty>
+_NODISCARD _CONSTEXPR20 _InIt _Find_unchecked(_InIt _First, const _InIt _Last, const _Ty& _Val) {
+    // find first matching _Val; choose optimization
+    // activate optimization for contiguous iterators to most scalar types (possibly const-qualified)
+    if constexpr (_Vector_alg_in_find_is_safe<_InIt, _Ty>) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            if (!_STD _Could_compare_equal_to_value_type<_InIt>(_Val)) {
+                return _Last;
+            }
+#if _USE_STD_VECTOR_ALGORITHMS
+            const auto _First_ptr = _STD _To_address(_First);
+            const auto _Result    = _STD _Find_vectorized(_First_ptr, _STD _To_address(_Last), _Val);
+            if constexpr (is_pointer_v<_InIt>) {
+                return _Result;
+            } else {
+                return _First + (_Result - _First_ptr);
+            }
+#else // ^^^ _USE_STD_VECTOR_ALGORITHMS / !_USE_STD_VECTOR_ALGORITHMS vvv
+            if constexpr (sizeof(_Iter_value_t<_InIt>) <= 2) {
+                const auto _First_ptr = _STD _To_address(_First);
+                const auto _Count     = static_cast<size_t>(_Last - _First);
+
+                using _Ptr_t = remove_reference_t<_Iter_ref_t<_InIt>>*;
+                _Ptr_t _Result;
+
+                if constexpr (sizeof(_Iter_value_t<_InIt>) == 1) {
+                    _Result = static_cast<_Ptr_t>(_CSTD memchr(_First_ptr, static_cast<unsigned char>(_Val), _Count));
+                } else {
+                    _STL_INTERNAL_STATIC_ASSERT(sizeof(_Iter_value_t<_InIt>) == 2);
+                    _Result = reinterpret_cast<_Ptr_t>(const_cast<wchar_t*>(_CSTD wmemchr(
+                        reinterpret_cast<const wchar_t*>(_First_ptr), static_cast<wchar_t>(_Val), _Count)));
+                }
+
+                if constexpr (is_pointer_v<_InIt>) {
+                    return _Result ? _Result : _Last;
+                } else {
+                    return _Result ? _First + (_Result - _First_ptr) : _Last;
+                }
+            }
+#endif // ^^^ !_USE_STD_VECTOR_ALGORITHMS ^^^
+        }
+    }
+
+    for (; _First != _Last; ++_First) {
+        if (*_First == _Val) {
+            break;
+        }
+    }
+
+    return _First;
+}
+
+_EXPORT_STD template <class _InIt, class _Ty>
+_NODISCARD _CONSTEXPR20 _InIt find(_InIt _First, const _InIt _Last, const _Ty& _Val) { // find first matching _Val
+    _STD _Adl_verify_range(_First, _Last);
+    if constexpr (_Is_vb_iterator<_InIt> && is_same_v<_Ty, bool>) {
+        return _STD _Find_vbool(_First, _Last, _Val);
+    } else {
+        _STD _Seek_wrapped(_First, _STD _Find_unchecked(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last), _Val));
+        return _First;
+    }
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _FwdIt find(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, const _Ty& _Val) noexcept; // terminates
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    template <class _Se, class _It>
+    concept _Sized_or_unreachable_sentinel_for = sized_sentinel_for<_Se, _It> || same_as<_Se, unreachable_sentinel_t>;
+
+    template <class _Rng>
+    concept _Sized_or_infinite_range =
+        range<_Rng> && (sized_range<_Rng> || same_as<sentinel_t<_Rng>, unreachable_sentinel_t>);
+
+    // concept-constrained for strict enforcement as it is used by several algorithms
+    template <input_iterator _It, sentinel_for<_It> _Se, class _Ty, class _Pj = identity>
+        requires indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty*>
+    _NODISCARD constexpr _It _Find_unchecked(_It _First, const _Se _Last, const _Ty& _Val, _Pj _Proj = {}) {
+        constexpr bool _Elements_are_1_or_2_bytes = sizeof(_Iter_value_t<_It>) <= 2;
+        constexpr bool _Is_sized                  = sized_sentinel_for<_Se, _It>;
+
+        if constexpr (_Vector_alg_in_find_is_safe<_It, _Ty>
+                      && (_Elements_are_1_or_2_bytes ? _Is_sized || same_as<_Se, unreachable_sentinel_t>
+                                                     : _Is_sized && _USE_STD_VECTOR_ALGORITHMS)
+                      && same_as<_Pj, identity>) {
+            if (!_STD is_constant_evaluated()) {
+                if (!_STD _Could_compare_equal_to_value_type<_It>(_Val)) {
+                    if constexpr (_Is_sized) {
+                        return _RANGES next(_STD move(_First), _Last);
+                    } else {
+                        _STL_ASSERT(false, "Tried to find a value in a range with unreachable sentinel "
+                                           "that cannot be represented by the range's value type");
+                    }
+                }
+
+                using _Ptr_t          = remove_reference_t<_Iter_ref_t<_It>>*;
+                const auto _First_ptr = _STD _To_address(_First);
+
+                _Ptr_t _Result;
+#if _USE_STD_VECTOR_ALGORITHMS
+                if constexpr (_Is_sized) {
+                    // When _Is_sized && _Elements_are_1_or_2_bytes, prefer this over memchr()/wmemchr() for performance
+                    const auto _Last_ptr = _First_ptr + (_Last - _First);
+                    _Result              = _STD _Find_vectorized(_First_ptr, _Last_ptr, _Val);
+                } else
+#endif // ^^^ _USE_STD_VECTOR_ALGORITHMS ^^^
+                {
+                    _STL_INTERNAL_STATIC_ASSERT(_Elements_are_1_or_2_bytes);
+                    size_t _Count;
+                    if constexpr (_Is_sized) {
+                        _Count = static_cast<size_t>(_Last - _First);
+                    } else {
+                        _Count = SIZE_MAX;
+                    }
+
+                    if constexpr (sizeof(_Iter_value_t<_It>) == 1) {
+                        _Result =
+                            static_cast<_Ptr_t>(_CSTD memchr(_First_ptr, static_cast<unsigned char>(_Val), _Count));
+                    } else {
+                        _STL_INTERNAL_STATIC_ASSERT(sizeof(_Iter_value_t<_It>) == 2);
+                        _Result = reinterpret_cast<_Ptr_t>(const_cast<wchar_t*>(_CSTD wmemchr(
+                            reinterpret_cast<const wchar_t*>(_First_ptr), static_cast<wchar_t>(_Val), _Count)));
+                    }
+
+                    if constexpr (_Is_sized) {
+                        if (_Result == nullptr) {
+                            return _RANGES next(_STD move(_First), _Last);
+                        }
+                    }
+                }
+
+                if constexpr (is_pointer_v<_It>) {
+                    return _Result;
+                } else {
+                    return _RANGES next(_STD move(_First), _Result - _First_ptr);
+                }
+            }
+        }
+
+        for (; _First != _Last; ++_First) {
+            if (_STD invoke(_Proj, *_First) == _Val) {
+                break;
+            }
+        }
+
+        return _First;
+    }
+
+    class _Find_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se, class _Ty, class _Pj = identity>
+            requires indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty*>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr _It operator()(
+            _It _First, _Se _Last, const _Ty& _Val, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UResult = _RANGES _Find_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _Val, _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult));
+            return _First;
+        }
+
+        template <input_range _Rng, class _Ty, class _Pj = identity>
+            requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Rng>, _Pj>, const _Ty*>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
+            _Rng&& _Range, const _Ty& _Val, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+            auto _First   = _RANGES begin(_Range);
+            auto _UResult = _RANGES _Find_unchecked(
+                _RANGES _Unwrap_range_iter<_Rng>(_STD move(_First)), _Uend(_Range), _Val, _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult));
+            return _First;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Find_fn find;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _InIt, class _Ty>
+_NODISCARD _CONSTEXPR20 _Iter_diff_t<_InIt> count(const _InIt _First, const _InIt _Last, const _Ty& _Val) {
+    // count elements that match _Val
+    _STD _Adl_verify_range(_First, _Last);
+    if constexpr (_Is_vb_iterator<_InIt> && is_same_v<_Ty, bool>) {
+        return _STD _Count_vbool(_First, _Last, _Val);
+    } else {
+        auto _UFirst      = _STD _Get_unwrapped(_First);
+        const auto _ULast = _STD _Get_unwrapped(_Last);
+
+#if _USE_STD_VECTOR_ALGORITHMS
+        if constexpr (_Vector_alg_in_find_is_safe<decltype(_UFirst), _Ty>) {
+#if _HAS_CXX20
+            if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+            {
+                if (!_STD _Could_compare_equal_to_value_type<decltype(_UFirst)>(_Val)) {
+                    return 0;
+                }
+
+                return static_cast<_Iter_diff_t<_InIt>>(
+                    _STD _Count_vectorized(_STD _To_address(_UFirst), _STD _To_address(_ULast), _Val));
+            }
+        }
+#endif // _USE_STD_VECTOR_ALGORITHMS
+
+        _Iter_diff_t<_InIt> _Count = 0;
+
+        for (; _UFirst != _ULast; ++_UFirst) {
+            if (*_UFirst == _Val) {
+                ++_Count;
+            }
+        }
+
+        return _Count;
+    }
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _Iter_diff_t<_FwdIt> count(
+    _ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, const _Ty& _Val) noexcept; // terminates
+#endif // _HAS_CXX17
+
+template <class _InIt, class _Ty, class _Pr>
+_NODISCARD constexpr _InIt _Find_pr(_InIt _First, const _InIt _Last, const _Ty& _Val, _Pr _Pred) {
+    for (; _First != _Last; ++_First) {
+        if (_Pred(*_First, _Val)) {
+            break;
+        }
+    }
+
+    return _First;
+}
+
+template <class _InIt, class _Ty, class _Pr>
+_NODISCARD constexpr _Iter_diff_t<_InIt> _Count_pr(_InIt _First, const _InIt _Last, const _Ty& _Val, _Pr _Pred) {
+    _Iter_diff_t<_InIt> _Count = 0;
+
+    for (; _First != _Last; ++_First) {
+        if (_Pred(*_First, _Val)) {
+            ++_Count;
+        }
+    }
+
+    return _Count;
+}
+
+enum class _TrimResult : unsigned char { _KeepTrimming, _HaveWorkAfterTrimming, _ReturnFalse, _ReturnTrue };
+
+template <class _BidIt1, class _BidIt2, class _Pr>
+_NODISCARD _CONSTEXPR20 _TrimResult _Trim_equal(
+    _BidIt1& _First1, _BidIt1& _Back1, _BidIt2& _First2, _BidIt2& _Back2, _Pr _Pred) {
+    // advances the iterators, trimming matching prefixes then matching suffixes
+    // from [_First1, _Back1] and [_First2, _Back2]
+    _STL_INTERNAL_CHECK(_First1 != _Back1);
+    _STL_INTERNAL_CHECK(_STD distance(_First1, _Back1) == _STD distance(_First2, _Back2));
+    if (_Pred(*_First1, *_First2)) {
+        do {
+            ++_First1;
+            ++_First2;
+            if (_First1 == _Back1) {
+                // only one element is left
+                return _Pred(*_First1, *_First2) ? _TrimResult::_ReturnTrue : _TrimResult::_ReturnFalse;
+            }
+        } while (_Pred(*_First1, *_First2));
+    } else {
+        if (!_Pred(*_Back1, *_Back2)) {
+            // nothing to trim
+            return _TrimResult::_HaveWorkAfterTrimming;
+        }
+        --_Back1;
+        --_Back2;
+    }
+
+    for (;;) {
+        if (_First1 == _Back1) {
+            // only one element is left, it can't match because it wasn't trimmed by the first loop
+            return _TrimResult::_ReturnFalse;
+        }
+
+        if (!_Pred(*_Back1, *_Back2)) {
+            return _TrimResult::_KeepTrimming;
+        }
+        --_Back1;
+        --_Back2;
+    }
+}
+
+template <class _BidIt1, class _BidIt2, class _Pr>
+_NODISCARD _CONSTEXPR20 _TrimResult _Trim_reversed(
+    _BidIt1& _First1, _BidIt1& _Back1, _BidIt2& _First2, _BidIt2& _Back2, _Pr _Pred) {
+    // advances the iterators, trimming each range's prefix that matches the other range's suffix
+    // from [_First1, _Back1] and [_First2, _Back2]
+    _STL_INTERNAL_CHECK(_First1 != _Back1);
+    _STL_INTERNAL_CHECK(_STD distance(_First1, _Back1) == _STD distance(_First2, _Back2));
+    if (_Pred(*_First1, *_Back2)) {
+        do {
+            ++_First1;
+            --_Back2;
+            if (_First1 == _Back1) {
+                // only one element is left
+                return _Pred(*_First1, *_First2) ? _TrimResult::_ReturnTrue : _TrimResult::_ReturnFalse;
+            }
+        } while (_Pred(*_First1, *_Back2));
+    } else {
+        if (!_Pred(*_Back1, *_First2)) {
+            // nothing to trim
+            return _TrimResult::_HaveWorkAfterTrimming;
+        }
+        --_Back1;
+        ++_First2;
+    }
+
+    for (;;) {
+        if (_First1 == _Back1) {
+            // only one element is left, it can't match because it wasn't trimmed by the first loop
+            return _TrimResult::_ReturnFalse;
+        }
+
+        if (!_Pred(*_Back1, *_First2)) {
+            return _TrimResult::_KeepTrimming;
+        }
+        --_Back1;
+        ++_First2;
+    }
+}
+
+template <class _BidIt1, class _BidIt2, class _Pr>
+_NODISCARD _CONSTEXPR20 _TrimResult _Trim_completely(
+    _BidIt1& _First1, _BidIt1& _Back1, _BidIt2& _First2, _BidIt2& _Back2, _Pr _Pred) {
+    // alternates between calling _Trim_reversed and _Trim_equal until no more trimming is possible
+    _TrimResult _Res = _TrimResult::_KeepTrimming;
+
+    for (bool _Check_reversed = true; _Res == _TrimResult::_KeepTrimming; _Check_reversed = !_Check_reversed) {
+        if (_Check_reversed) {
+            _Res = _STD _Trim_reversed(_First1, _Back1, _First2, _Back2, _Pred);
+        } else {
+            _Res = _STD _Trim_equal(_First1, _Back1, _First2, _Back2, _Pred);
+        }
+    }
+
+    return _Res;
+}
+
+template <class _FwdIt1, class _FwdIt2, class _Pr>
+_NODISCARD _CONSTEXPR20 bool _Check_match_counts(
+    _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred) {
+    // test if [_First1, _Last1) == permuted [_First2, _Last2), after matching prefix removal
+    _STL_INTERNAL_CHECK(!_Pred(*_First1, *_First2));
+    _STL_INTERNAL_CHECK(_STD distance(_First1, _Last1) == _STD distance(_First2, _Last2));
+    if constexpr (_Is_ranges_bidi_iter_v<_FwdIt1> && _Is_ranges_bidi_iter_v<_FwdIt2>) {
+        do { // find last inequality
+            --_Last1;
+            --_Last2;
+        } while (_Pred(*_Last1, *_Last2));
+
+        if (_First1 == _Last1) {
+            return false;
+        }
+
+        const _TrimResult _Res = _STD _Trim_completely(_First1, _Last1, _First2, _Last2, _Pred);
+
+        if (_Res != _TrimResult::_HaveWorkAfterTrimming) {
+            return _Res == _TrimResult::_ReturnTrue;
+        }
+
+        ++_Last1;
+        ++_Last2;
+    }
+
+    for (_FwdIt1 _Next1 = _First1; _Next1 != _Last1; ++_Next1) {
+        if (_Next1 == _STD _Find_pr(_First1, _Next1, *_Next1, _Pred)) { // new value, compare match counts
+            _Iter_diff_t<_FwdIt2> _Count2 = _STD _Count_pr(_First2, _Last2, *_Next1, _Pred);
+            if (_Count2 == 0) {
+                return false; // second range lacks value, not a permutation
+            }
+
+            _FwdIt1 _Skip1                = _STD _Next_iter(_Next1);
+            _Iter_diff_t<_FwdIt1> _Count1 = _STD _Count_pr(_Skip1, _Last1, *_Next1, _Pred) + 1;
+            if (_Count2 != _Count1) {
+                return false; // match counts differ, not a permutation
+            }
+        }
+    }
+
+    return true;
+}
+
+_EXPORT_STD template <class _BidIt>
+_CONSTEXPR20 void reverse(const _BidIt _First, const _BidIt _Last) { // reverse elements in [_First, _Last)
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst = _STD _Get_unwrapped(_First);
+    auto _ULast  = _STD _Get_unwrapped(_Last);
+#if _USE_STD_VECTOR_ALGORITHMS
+    using _Elem                         = remove_reference_t<_Iter_ref_t<decltype(_UFirst)>>;
+    constexpr bool _Allow_vectorization = conjunction_v<bool_constant<_Iterator_is_contiguous<decltype(_UFirst)>>,
+        _Is_trivially_swappable<_Elem>, negation<is_volatile<_Elem>>>;
+    constexpr size_t _Nx                = sizeof(_Elem);
+
+    if constexpr (_Allow_vectorization && _Nx <= 8 && (_Nx & (_Nx - 1)) == 0) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            _STD _Reverse_vectorized<_Nx>(_STD _To_address(_UFirst), _STD _To_address(_ULast));
+            return;
+        }
+    }
+#endif // _USE_STD_VECTOR_ALGORITHMS
+
+    for (; _UFirst != _ULast && _UFirst != --_ULast; ++_UFirst) {
+        swap(*_UFirst, *_ULast); // intentional ADL
+    }
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _BidIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+void reverse(_ExPo&&, _BidIt _First, _BidIt _Last) noexcept /* terminates */ {
+    // reverse elements in [_First, _Last)
+    // not parallelized as benchmarks show it isn't worth it
+    _REQUIRE_CPP17_MUTABLE_BIDIRECTIONAL_ITERATOR(_BidIt);
+    return _STD reverse(_First, _Last);
+}
+#endif // _HAS_CXX17
+
+template <class _BidIt>
+constexpr pair<_BidIt, _BidIt> _Reverse_until_sentinel_unchecked(_BidIt _First, _BidIt _Sentinel, _BidIt _Last) {
+    // reverse until either _First or _Last hits _Sentinel
+    while (_First != _Sentinel && _Last != _Sentinel) {
+        swap(*_First, *--_Last); // intentional ADL
+        ++_First;
+    }
+
+    return pair<_BidIt, _BidIt>(_First, _Last);
+}
+
+_EXPORT_STD template <class _FwdIt>
+_CONSTEXPR20 _FwdIt rotate(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last) {
+    // exchange the ranges [_First, _Mid) and [_Mid, _Last)
+    // that is, rotates [_First, _Last) left by distance(_First, _Mid) positions
+    // returns the iterator pointing at *_First's new home
+    _STD _Adl_verify_range(_First, _Mid);
+    _STD _Adl_verify_range(_Mid, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    auto _UMid        = _STD _Get_unwrapped(_Mid);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    if (_UFirst == _UMid) {
+        return _Last;
+    }
+
+    if (_UMid == _ULast) {
+        return _First;
+    }
+
+    if constexpr (_Is_cpp17_random_iter_v<_FwdIt>) {
+        _STD reverse(_UFirst, _UMid);
+        _STD reverse(_UMid, _ULast);
+        _STD reverse(_UFirst, _ULast);
+        _STD _Seek_wrapped(_First, _UFirst + (_ULast - _UMid));
+    } else if constexpr (_Is_cpp17_bidi_iter_v<_FwdIt>) {
+        _STD reverse(_UFirst, _UMid);
+        _STD reverse(_UMid, _ULast);
+        auto _Tmp = _STD _Reverse_until_sentinel_unchecked(_UFirst, _UMid, _ULast);
+        _STD reverse(_Tmp.first, _Tmp.second);
+        _STD _Seek_wrapped(_First, _UMid != _Tmp.first ? _Tmp.first : _Tmp.second);
+    } else {
+        auto _UNext = _UMid;
+        do { // rotate the first cycle
+            swap(*_UFirst, *_UNext); // intentional ADL
+            ++_UFirst;
+            ++_UNext;
+            if (_UFirst == _UMid) {
+                _UMid = _UNext;
+            }
+        } while (_UNext != _ULast);
+        _STD _Seek_wrapped(_First, _UFirst);
+        while (_UMid != _ULast) { // rotate subsequent cycles
+            _UNext = _UMid;
+            do {
+                swap(*_UFirst, *_UNext); // intentional ADL
+                ++_UFirst;
+                ++_UNext;
+                if (_UFirst == _UMid) {
+                    _UMid = _UNext;
+                }
+            } while (_UNext != _ULast);
+        }
+    }
+
+    return _First;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt rotate(_ExPo&&, _FwdIt _First, _FwdIt _Mid, _FwdIt _Last) noexcept /* terminates */ {
+    // rotate [_First, _Last) left by distance(_First, _Mid) positions
+    // not parallelized as benchmarks show it isn't worth it
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt);
+    return _STD rotate(_First, _Mid, _Last);
+}
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _InIt, class _Pr>
+_NODISCARD _CONSTEXPR20 _InIt find_if(_InIt _First, const _InIt _Last, _Pr _Pred) { // find first satisfying _Pred
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    for (; _UFirst != _ULast; ++_UFirst) {
+        if (_Pred(*_UFirst)) {
+            break;
+        }
+    }
+
+    _STD _Seek_wrapped(_First, _UFirst);
+    return _First;
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    template <class _Result, class _Wrapped, class _Unwrapped>
+    _NODISCARD constexpr _Result _Rewrap_subrange(_Wrapped& _Val, subrange<_Unwrapped>&& _UResult) {
+        // conditionally computes a wrapped subrange from a wrapped iterator or range and unwrapped subrange
+        if constexpr (is_same_v<_Result, dangling>) {
+            return dangling{};
+        } else if constexpr (is_same_v<_Result, subrange<_Unwrapped>>) {
+            return _STD move(_UResult);
+        } else if constexpr (range<_Wrapped>) {
+            _STL_INTERNAL_STATIC_ASSERT(forward_range<_Wrapped>);
+            _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Unwrapped, _Unwrapped_iterator_t<_Wrapped>>);
+            _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Result, subrange<iterator_t<_Wrapped>>>);
+
+            auto _First = _RANGES begin(_Val);
+            auto _Last  = _First;
+            _First._Seek_to(_UResult.begin());
+            _Last._Seek_to(_UResult.end());
+            return _Result{_STD move(_First), _STD move(_Last)};
+        } else {
+            _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Unwrapped, _Unwrapped_t<_Wrapped>>);
+            _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Result, subrange<_Wrapped>>);
+
+            auto _Last = _Val;
+            _Val._Seek_to(_UResult.begin());
+            _Last._Seek_to(_UResult.end());
+            return _Result{_STD move(_Val), _STD move(_Last)};
+        }
+    }
+
+    // concept-constrained for strict enforcement as it is used by several algorithms
+    template <input_iterator _It, sentinel_for<_It> _Se, class _Pj, indirect_unary_predicate<projected<_It, _Pj>> _Pr>
+    _NODISCARD constexpr _It _Find_if_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
+        for (; _First != _Last; ++_First) {
+            if (_STD invoke(_Pred, _STD invoke(_Proj, *_First))) {
+                break;
+            }
+        }
+
+        return _First;
+    }
+
+    class _Find_if_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr _It operator()(
+            _It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UResult = _RANGES _Find_if_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult));
+            return _First;
+        }
+
+        template <input_range _Rng, class _Pj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
+            _Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+            auto _First   = _RANGES begin(_Range);
+            auto _UResult = _RANGES _Find_if_unchecked(_RANGES _Unwrap_range_iter<_Rng>(_STD move(_First)),
+                _Uend(_Range), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult));
+            return _First;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Find_if_fn find_if;
+
+    class _Find_if_not_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr _It operator()(
+            _It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+            _STD _Adl_verify_range(_First, _Last);
+
+            auto _UResult = _Find_if_not_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult));
+            return _First;
+        }
+
+        template <input_range _Rng, class _Pj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
+            _Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+            auto _First = _RANGES begin(_Range);
+
+            auto _UResult = _Find_if_not_unchecked(_RANGES _Unwrap_range_iter<_Rng>(_STD move(_First)), _Uend(_Range),
+                _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult));
+            return _First;
+        }
+
+    private:
+        template <class _It, class _Se, class _Pj, class _Pr>
+        _NODISCARD static constexpr _It _Find_if_not_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_unary_predicate<_Pr, projected<_It, _Pj>>);
+
+            for (; _First != _Last; ++_First) {
+                if (!_STD invoke(_Pred, _STD invoke(_Proj, *_First))) {
+                    break;
+                }
+            }
+
+            return _First;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Find_if_not_fn find_if_not;
+
+    class _Adjacent_find_fn {
+    public:
+        template <forward_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_binary_predicate<projected<_It, _Pj>, projected<_It, _Pj>> _Pr = ranges::equal_to>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr _It operator()(
+            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+            _STD _Adl_verify_range(_First, _Last);
+
+            auto _UResult = _Adjacent_find_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult));
+            return _First;
+        }
+
+        template <forward_range _Rng, class _Pj = identity,
+            indirect_binary_predicate<projected<iterator_t<_Rng>, _Pj>, projected<iterator_t<_Rng>, _Pj>> _Pr =
+                ranges::equal_to>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
+            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+            auto _UResult =
+                _Adjacent_find_unchecked(_Ubegin(_Range), _Uend(_Range), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+
+            return _RANGES _Rewrap_iterator(_Range, _STD move(_UResult));
+        }
+
+    private:
+        template <class _It, class _Se, class _Pj, class _Pr>
+        _NODISCARD static constexpr _It _Adjacent_find_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
+            // find first satisfying _Pred with successor
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_binary_predicate<_Pr, projected<_It, _Pj>, projected<_It, _Pj>>);
+
+            if (_First == _Last) {
+                return _First;
+            }
+
+            for (auto _Next = _First;; ++_First) {
+                if (++_Next == _Last) {
+                    return _Next;
+                }
+
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *_First), _STD invoke(_Proj, *_Next))) {
+                    return _First;
+                }
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Adjacent_find_fn adjacent_find;
+
+    template <forward_iterator _It1, input_iterator _It2, sentinel_for<_It2> _Se2, class _Pr, class _Pj1, class _Pj2>
+        requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
+    _NODISCARD constexpr pair<bool, _It1> _Equal_rev_pred(
+        _It1 _First1, _It2 _First2, const _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+        // Returns {true, _First1 + (_Last2 - _First2)} if [_First1, ...) equals [_First2, _Last2), and {false, {}}
+        // otherwise.
+        for (; _First2 != _Last2; ++_First1, (void) ++_First2) {
+            if (!_STD invoke(_Pred, _STD invoke(_Proj1, *_First1), _STD invoke(_Proj2, *_First2))) {
+                return {false, _It1 {}};
+            }
+        }
+
+        return {true, _STD move(_First1)};
+    }
+
+    class _Search_fn {
+    public:
+        template <forward_iterator _It1, sentinel_for<_It1> _Se1, forward_iterator _It2, sentinel_for<_It2> _Se2,
+            class _Pr = ranges::equal_to, class _Pj1 = identity, class _Pj2 = identity>
+            requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr subrange<_It1> operator()(_It1 _First1, _Se1 _Last1, _It2 _First2,
+            _Se2 _Last2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+            _STD _Adl_verify_range(_First1, _Last1);
+            _STD _Adl_verify_range(_First2, _Last2);
+            auto _UFirst1 = _RANGES _Unwrap_iter<_Se1>(_STD move(_First1));
+            auto _ULast1  = _RANGES _Unwrap_sent<_It1>(_STD move(_Last1));
+            auto _UFirst2 = _RANGES _Unwrap_iter<_Se2>(_STD move(_First2));
+            auto _ULast2  = _RANGES _Unwrap_sent<_It2>(_STD move(_Last2));
+
+            if constexpr (sized_sentinel_for<_Se1, _It1> && sized_sentinel_for<_Se2, _It2>) {
+                const auto _Count1 = _ULast1 - _UFirst1;
+                const auto _Count2 = _ULast2 - _UFirst2;
+                auto _UResult = _Search_sized(_STD move(_UFirst1), _STD move(_ULast1), _Count1, _STD move(_UFirst2),
+                    _STD move(_ULast2), _Count2, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+                return _RANGES _Rewrap_subrange<subrange<_It1>>(_First1, _STD move(_UResult));
+            } else {
+                auto _UResult = _Search_unsized(_STD move(_UFirst1), _STD move(_ULast1), _STD move(_UFirst2),
+                    _STD move(_ULast2), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+                return _RANGES _Rewrap_subrange<subrange<_It1>>(_First1, _STD move(_UResult));
+            }
+        }
+
+        template <forward_range _Rng1, forward_range _Rng2, class _Pr = ranges::equal_to, class _Pj1 = identity,
+            class _Pj2 = identity>
+            requires indirectly_comparable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Pr, _Pj1, _Pj2>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr borrowed_subrange_t<_Rng1> operator()(
+            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+            if constexpr (sized_range<_Rng1> && sized_range<_Rng2>) {
+                const auto _Count1 = _RANGES distance(_Range1);
+                const auto _Count2 = _RANGES distance(_Range2);
+                auto _UResult      = _Search_sized(_Ubegin(_Range1), _Uend(_Range1), _Count1, _Ubegin(_Range2),
+                         _Uend(_Range2), _Count2, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+                return _RANGES _Rewrap_subrange<borrowed_subrange_t<_Rng1>>(_Range1, _STD move(_UResult));
+            } else {
+                auto _UResult = _Search_unsized(_Ubegin(_Range1), _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2),
+                    _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+                return _RANGES _Rewrap_subrange<borrowed_subrange_t<_Rng1>>(_Range1, _STD move(_UResult));
+            }
+        }
+
+    private:
+        template <class _It1, class _Se1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
+        _NODISCARD static constexpr subrange<_It1> _Search_sized(_It1 _First1, const _Se1 _Last1,
+            iter_difference_t<_It1> _Count1, _It2 _First2, const _Se2 _Last2, const iter_difference_t<_It2> _Count2,
+            _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It1>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se1, _It1>);
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It2>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se2, _It2>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>);
+            _STL_INTERNAL_CHECK(_RANGES distance(_First1, _Last1) == _Count1);
+            _STL_INTERNAL_CHECK(_RANGES distance(_First2, _Last2) == _Count2);
+
+            for (; _Count1 >= _Count2; ++_First1, (void) --_Count1) {
+                auto _Match_and_mid1 = _RANGES _Equal_rev_pred(_First1, _First2, _Last2, _Pred, _Proj1, _Proj2);
+                if (_Match_and_mid1.first) {
+                    return {_STD move(_First1), _STD move(_Match_and_mid1.second)};
+                }
+            }
+
+            _First1 = _RANGES _Find_last_iterator(_First1, _Last1, _Count1);
+            return {_First1, _First1};
+        }
+
+        template <class _It1, class _Se1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
+        _NODISCARD static constexpr subrange<_It1> _Search_unsized(
+            _It1 _First1, const _Se1 _Last1, _It2 _First2, const _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It1>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se1, _It1>);
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It2>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se2, _It2>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>);
+
+            for (;; ++_First1) {
+                auto _Mid1 = _First1;
+                for (auto _Mid2 = _First2;; ++_Mid1, (void) ++_Mid2) {
+                    if (_Mid2 == _Last2) { // match
+                        return {_STD move(_First1), _STD move(_Mid1)};
+                    }
+
+                    if (_Mid1 == _Last1) { // not enough haystack left to find a match
+                        return {_Mid1, _Mid1};
+                    }
+
+                    if (!_STD invoke(_Pred, _STD invoke(_Proj1, *_Mid1), _STD invoke(_Proj2, *_Mid2))) { // mismatch
+                        break;
+                    }
+                }
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Search_fn search;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+template <class _Iter, class _Pr, class _Elem = _Iter_value_t<_Iter>>
+constexpr bool _Is_min_max_optimization_safe = // Activate the vector algorithms for min_/max_element?
+    _Iterator_is_contiguous<_Iter> // The iterator must be contiguous so we can get raw pointers.
+    && !_Iterator_is_volatile<_Iter> // The iterator must not be volatile.
+    && conjunction_v<disjunction<
+#if _USE_STD_VECTOR_FLOATING_ALGORITHMS
+#if defined(__LDBL_DIG__) && __LDBL_DIG__ == 18
+                         is_same<_Elem, float>, is_same<_Elem, double>,
+#else // ^^^ 80-bit long double (not supported by MSVC in general, see GH-1316) / 64-bit long double vvv
+                         is_floating_point<_Elem>, // Element is floating-point or...
+#endif // ^^^ 64-bit long double ^^^
+#endif // _USE_STD_VECTOR_FLOATING_ALGORITHMS
+                         is_integral<_Elem>, is_pointer<_Elem>>, // ... integral or pointer type.
+        disjunction< // And either of the following:
+#if _HAS_CXX20
+            is_same<_Pr, _RANGES less>, // predicate is ranges::less
+#endif // _HAS_CXX20
+            is_same<_Pr, less<>>, is_same<_Pr, less<_Elem>>>>; // predicate is less
+
+// Unlike the position-based vectorized implementation, the value-based vectorized implementation
+// does not always produce the expected results for floating-point types.
+//
+// Efficient vectorization needs to find the vertical minmax first, and then the horizontal one.
+// This alters the order of comparison: index zero element is first compared against
+// vector size equal index element and only in the end against index one element.
+// With equivalent but distinguishable +0.0 and -0.0 values, the altered comparison order
+// will not produce the expected result in some cases (will return +0.0 instead of -0.0 or the reverse).
+//
+// The result is still acceptable for /fp:fast when +0.0 / -0.0 are not expected to be properly distinguished,
+// and the compiler itself takes advantage of it.
+template <class _Iter, class _Pr, class _Elem = _Iter_value_t<_Iter>>
+constexpr bool _Is_min_max_value_optimization_safe = // Activate the vector algorithms for ranges::min/max?
+#ifndef _M_FP_FAST
+    !is_floating_point_v<_Elem> &&
+#endif // ^^^ !defined(_M_FP_FAST) ^^^
+    _Is_min_max_optimization_safe<_Iter, _Pr, _Elem>;
+
+template <class _FwdIt, class _Pr>
+constexpr _FwdIt _Max_element_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred) { // find largest element
+#if _USE_STD_VECTOR_ALGORITHMS
+    if constexpr (_Is_min_max_optimization_safe<_FwdIt, _Pr>) {
+        if (!_Is_constant_evaluated()) {
+            const auto _First_ptr = _STD _To_address(_First);
+            const auto _Result    = _STD _Max_element_vectorized(_First_ptr, _STD _To_address(_Last));
+            if constexpr (is_pointer_v<_FwdIt>) {
+                return _Result;
+            } else {
+                return _First + (_Result - _First_ptr);
+            }
+        }
+    }
+#endif // _USE_STD_VECTOR_ALGORITHMS
+
+    _FwdIt _Found = _First;
+    if (_First != _Last) {
+        while (++_First != _Last) {
+            if (_DEBUG_LT_PRED(_Pred, *_Found, *_First)) {
+                _Found = _First;
+            }
+        }
+    }
+
+    return _Found;
+}
+
+_EXPORT_STD template <class _FwdIt, class _Pr>
+_NODISCARD constexpr _FwdIt max_element(_FwdIt _First, _FwdIt _Last, _Pr _Pred) { // find largest element
+    _STD _Adl_verify_range(_First, _Last);
+    _STD _Seek_wrapped(_First,
+        _STD _Max_element_unchecked(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last), _STD _Pass_fn(_Pred)));
+    return _First;
+}
+
+_EXPORT_STD template <class _FwdIt>
+_NODISCARD constexpr _FwdIt max_element(_FwdIt _First, _FwdIt _Last) { // find largest element
+    return _STD max_element(_First, _Last, less<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _FwdIt max_element(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
+    // find largest element
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    return _STD max_element(_First, _Last, _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _FwdIt max_element(_ExPo&&, _FwdIt _First, _FwdIt _Last) noexcept /* terminates */ {
+    // find largest element
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    return _STD max_element(_First, _Last);
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    template <class _It, class _Se, class _Pr, class _Pj>
+    _NODISCARD constexpr _It _Max_element_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
+        _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It>);
+        _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+        _STL_INTERNAL_STATIC_ASSERT(indirect_strict_weak_order<_Pr, projected<_It, _Pj>>);
+
+#if _USE_STD_VECTOR_ALGORITHMS
+        if constexpr (is_same_v<_Pj, identity> && _Is_min_max_optimization_safe<_It, _Pr>
+                      && sized_sentinel_for<_Se, _It>) {
+            if (!_STD is_constant_evaluated()) {
+                const auto _First_ptr = _STD to_address(_First);
+                const auto _Last_ptr  = _First_ptr + (_Last - _First);
+                const auto _Result    = _STD _Max_element_vectorized(_First_ptr, _Last_ptr);
+                if constexpr (is_pointer_v<_It>) {
+                    return _Result;
+                } else {
+                    return _First + (_Result - _First_ptr);
+                }
+            }
+        }
+#endif // _USE_STD_VECTOR_ALGORITHMS
+
+        auto _Found = _First;
+        if (_First == _Last) {
+            return _Found;
+        }
+
+        while (++_First != _Last) {
+            if (_STD invoke(_Pred, _STD invoke(_Proj, *_Found), _STD invoke(_Proj, *_First))) {
+                _Found = _First;
+            }
+        }
+
+        return _Found;
+    }
+
+    class _Max_element_fn {
+    public:
+        template <forward_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_strict_weak_order<projected<_It, _Pj>> _Pr = ranges::less>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr _It operator()(
+            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+            _STD _Adl_verify_range(_First, _Last);
+            _STD _Seek_wrapped(
+                _First, _RANGES _Max_element_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                            _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj)));
+            return _First;
+        }
+
+        template <forward_range _Rng, class _Pj = identity,
+            indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
+            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+            auto _UResult = _RANGES _Max_element_unchecked(
+                _Ubegin(_Range), _Uend(_Range), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _RANGES _Rewrap_iterator(_Range, _STD move(_UResult));
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Max_element_fn max_element;
+} // namespace ranges
+#endif // _HAS_CXX20
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Ty, class _Pr>
+_NODISCARD constexpr _Ty(max)(initializer_list<_Ty> _Ilist, _Pr _Pred) {
+    // return leftmost/largest
+    _STL_ASSERT(
+        _Ilist.size() != 0, "An initializer_list passed to std::max must not be empty. (N4971 [alg.min.max]/13)");
+#if _USE_STD_VECTOR_ALGORITHMS
+    if constexpr (_Is_min_max_value_optimization_safe<const _Ty*, _Pr>) {
+        if (!_Is_constant_evaluated()) {
+            return static_cast<_Ty>(_STD _Max_vectorized(_Ilist.begin(), _Ilist.end()));
+        }
+    }
+#endif // _USE_STD_VECTOR_ALGORITHMS
+    const _Ty* _Res = _STD _Max_element_unchecked(_Ilist.begin(), _Ilist.end(), _STD _Pass_fn(_Pred));
+    return *_Res;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD constexpr _Ty(max)(initializer_list<_Ty> _Ilist) {
+    // return leftmost/largest
+    return (_STD max)(_Ilist, less<>{});
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    template <class _It>
+    concept _Prefer_iterator_copies = // When we have a choice, should we copy iterators or copy elements?
+                                      // pre: input_iterator<_It>
+        sizeof(_It) <= 2 * sizeof(iter_value_t<_It>)
+        && (is_trivially_copyable_v<_It> || !is_trivially_copyable_v<iter_value_t<_It>>);
+
+    class _Max_fn {
+    public:
+        template <class _Ty, class _Pj = identity,
+            indirect_strict_weak_order<projected<const _Ty*, _Pj>> _Pr = ranges::less>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr const _Ty& operator()(const _Ty& _Left _MSVC_LIFETIMEBOUND,
+            const _Ty& _Right _MSVC_LIFETIMEBOUND, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+            if (_STD invoke(_Pred, _STD invoke(_Proj, _Left), _STD invoke(_Proj, _Right))) {
+                return _Right;
+            } else {
+                return _Left;
+            }
+        }
+
+        template <copyable _Ty, class _Pj = identity,
+            indirect_strict_weak_order<projected<const _Ty*, _Pj>> _Pr = ranges::less>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr _Ty operator()(
+            initializer_list<_Ty> _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+            const auto _First = _Range.begin();
+            const auto _Last  = _Range.end();
+            _STL_ASSERT(_First != _Last,
+                "An initializer_list passed to std::ranges::max must not be empty. (N4971 [alg.min.max]/13)");
+#if _USE_STD_VECTOR_ALGORITHMS
+            if constexpr (is_same_v<_Pj, identity> && _Is_min_max_value_optimization_safe<const _Ty*, _Pr>) {
+                if (!_STD is_constant_evaluated()) {
+                    return static_cast<_Ty>(_STD _Max_vectorized(_First, _Last));
+                }
+            }
+#endif // _USE_STD_VECTOR_ALGORITHMS
+            return *_RANGES _Max_element_unchecked(_First, _Last, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+        }
+
+        template <input_range _Rng, class _Pj = identity,
+            indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
+            requires indirectly_copyable_storable<iterator_t<_Rng>, range_value_t<_Rng>*>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr range_value_t<_Rng> operator()(
+            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+            auto _UFirst = _Ubegin(_Range);
+            auto _ULast  = _Uend(_Range);
+            _STL_ASSERT(
+                _UFirst != _ULast, "A range passed to std::ranges::max must not be empty. (N4971 [alg.min.max]/13)");
+#if _USE_STD_VECTOR_ALGORITHMS
+            if constexpr (is_same_v<_Pj, identity> && _Is_min_max_value_optimization_safe<decltype(_UFirst), _Pr>
+                          && sized_sentinel_for<decltype(_ULast), decltype(_UFirst)>) {
+                if (!_STD is_constant_evaluated()) {
+                    const auto _First_ptr = _STD to_address(_UFirst);
+                    const auto _Last_ptr  = _First_ptr + (_ULast - _UFirst);
+                    return static_cast<range_value_t<_Rng>>(_STD _Max_vectorized(_First_ptr, _Last_ptr));
+                }
+            }
+#endif // _USE_STD_VECTOR_ALGORITHMS
+            if constexpr (forward_range<_Rng> && _Prefer_iterator_copies<decltype(_UFirst)>) {
+                return static_cast<range_value_t<_Rng>>(*_RANGES _Max_element_unchecked(
+                    _STD move(_UFirst), _STD move(_ULast), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj)));
+            } else {
+                range_value_t<_Rng> _Found(*_UFirst);
+                while (++_UFirst != _ULast) {
+                    if (_STD invoke(_Pred, _STD invoke(_Proj, _Found), _STD invoke(_Proj, *_UFirst))) {
+                        _Found = *_UFirst;
+                    }
+                }
+
+                return _Found;
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Max_fn max;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+template <class _FwdIt, class _Pr>
+constexpr _FwdIt _Min_element_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred) { // find smallest element
+#if _USE_STD_VECTOR_ALGORITHMS
+    if constexpr (_Is_min_max_optimization_safe<_FwdIt, _Pr>) {
+        if (!_Is_constant_evaluated()) {
+            const auto _First_ptr = _STD _To_address(_First);
+            const auto _Result    = _STD _Min_element_vectorized(_First_ptr, _STD _To_address(_Last));
+            if constexpr (is_pointer_v<_FwdIt>) {
+                return _Result;
+            } else {
+                return _First + (_Result - _First_ptr);
+            }
+        }
+    }
+#endif // _USE_STD_VECTOR_ALGORITHMS
+
+    _FwdIt _Found = _First;
+    if (_First != _Last) {
+        while (++_First != _Last) {
+            if (_DEBUG_LT_PRED(_Pred, *_First, *_Found)) {
+                _Found = _First;
+            }
+        }
+    }
+
+    return _Found;
+}
+
+_EXPORT_STD template <class _FwdIt, class _Pr>
+_NODISCARD constexpr _FwdIt min_element(_FwdIt _First, _FwdIt _Last, _Pr _Pred) { // find smallest element
+    _STD _Adl_verify_range(_First, _Last);
+    _STD _Seek_wrapped(_First,
+        _STD _Min_element_unchecked(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last), _STD _Pass_fn(_Pred)));
+    return _First;
+}
+
+_EXPORT_STD template <class _FwdIt>
+_NODISCARD constexpr _FwdIt min_element(_FwdIt _First, _FwdIt _Last) { // find smallest element
+    return _STD min_element(_First, _Last, less<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _FwdIt min_element(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
+    // find smallest element
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    return _STD min_element(_First, _Last, _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _FwdIt min_element(_ExPo&&, _FwdIt _First, _FwdIt _Last) noexcept /* terminates */ {
+    // find smallest element
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    return _STD min_element(_First, _Last);
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    template <class _It, class _Se, class _Pr, class _Pj>
+    _NODISCARD constexpr _It _Min_element_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
+        _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It>);
+        _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+        _STL_INTERNAL_STATIC_ASSERT(indirect_strict_weak_order<_Pr, projected<_It, _Pj>>);
+
+#if _USE_STD_VECTOR_ALGORITHMS
+        if constexpr (is_same_v<_Pj, identity> && _Is_min_max_optimization_safe<_It, _Pr>
+                      && sized_sentinel_for<_Se, _It>) {
+            if (!_STD is_constant_evaluated()) {
+                const auto _First_ptr = _STD to_address(_First);
+                const auto _Last_ptr  = _First_ptr + (_Last - _First);
+                const auto _Result    = _STD _Min_element_vectorized(_First_ptr, _Last_ptr);
+                if constexpr (is_pointer_v<_It>) {
+                    return _Result;
+                } else {
+                    return _First + (_Result - _First_ptr);
+                }
+            }
+        }
+#endif // _USE_STD_VECTOR_ALGORITHMS
+
+        auto _Found = _First;
+        if (_First == _Last) {
+            return _Found;
+        }
+
+        while (++_First != _Last) {
+            if (_STD invoke(_Pred, _STD invoke(_Proj, *_First), _STD invoke(_Proj, *_Found))) {
+                _Found = _First;
+            }
+        }
+
+        return _Found;
+    }
+
+    class _Min_element_fn {
+    public:
+        template <forward_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_strict_weak_order<projected<_It, _Pj>> _Pr = ranges::less>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr _It operator()(
+            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+            _STD _Adl_verify_range(_First, _Last);
+            _STD _Seek_wrapped(
+                _First, _RANGES _Min_element_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                            _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj)));
+            return _First;
+        }
+
+        template <forward_range _Rng, class _Pj = identity,
+            indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
+            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+            auto _UResult = _RANGES _Min_element_unchecked(
+                _Ubegin(_Range), _Uend(_Range), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _RANGES _Rewrap_iterator(_Range, _STD move(_UResult));
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Min_element_fn min_element;
+} // namespace ranges
+#endif // _HAS_CXX20
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Ty, class _Pr>
+_NODISCARD constexpr _Ty(min)(initializer_list<_Ty> _Ilist, _Pr _Pred) {
+    // return leftmost/smallest
+    _STL_ASSERT(
+        _Ilist.size() != 0, "An initializer_list passed to std::min must not be empty. (N4971 [alg.min.max]/5)");
+#if _USE_STD_VECTOR_ALGORITHMS
+    if constexpr (_Is_min_max_value_optimization_safe<const _Ty*, _Pr>) {
+        if (!_Is_constant_evaluated()) {
+            return static_cast<_Ty>(_STD _Min_vectorized(_Ilist.begin(), _Ilist.end()));
+        }
+    }
+#endif // _USE_STD_VECTOR_ALGORITHMS
+    const _Ty* _Res = _STD _Min_element_unchecked(_Ilist.begin(), _Ilist.end(), _STD _Pass_fn(_Pred));
+    return *_Res;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD constexpr _Ty(min)(initializer_list<_Ty> _Ilist) {
+    // return leftmost/smallest
+    return (_STD min)(_Ilist, less<>{});
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    class _Min_fn {
+    public:
+        template <class _Ty, class _Pj = identity,
+            indirect_strict_weak_order<projected<const _Ty*, _Pj>> _Pr = ranges::less>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr const _Ty& operator()(const _Ty& _Left _MSVC_LIFETIMEBOUND,
+            const _Ty& _Right _MSVC_LIFETIMEBOUND, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+            if (_STD invoke(_Pred, _STD invoke(_Proj, _Right), _STD invoke(_Proj, _Left))) {
+                return _Right;
+            } else {
+                return _Left;
+            }
+        }
+
+        template <copyable _Ty, class _Pj = identity,
+            indirect_strict_weak_order<projected<const _Ty*, _Pj>> _Pr = ranges::less>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr _Ty operator()(
+            initializer_list<_Ty> _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+            const auto _First = _Range.begin();
+            const auto _Last  = _Range.end();
+            _STL_ASSERT(_First != _Last,
+                "An initializer_list passed to std::ranges::min must not be empty. (N4971 [alg.min.max]/5)");
+#if _USE_STD_VECTOR_ALGORITHMS
+            if constexpr (is_same_v<_Pj, identity> && _Is_min_max_value_optimization_safe<const _Ty*, _Pr>) {
+                if (!_STD is_constant_evaluated()) {
+                    return static_cast<_Ty>(_STD _Min_vectorized(_First, _Last));
+                }
+            }
+#endif // _USE_STD_VECTOR_ALGORITHMS
+            return *_RANGES _Min_element_unchecked(_First, _Last, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+        }
+
+        template <input_range _Rng, class _Pj = identity,
+            indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
+            requires indirectly_copyable_storable<iterator_t<_Rng>, range_value_t<_Rng>*>
+        _NODISCARD _STATIC_CALL_OPERATOR constexpr range_value_t<_Rng> operator()(
+            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+            auto _UFirst = _Ubegin(_Range);
+            auto _ULast  = _Uend(_Range);
+            _STL_ASSERT(
+                _UFirst != _ULast, "A range passed to std::ranges::min must not be empty. (N4971 [alg.min.max]/5)");
+#if _USE_STD_VECTOR_ALGORITHMS
+            if constexpr (is_same_v<_Pj, identity> && _Is_min_max_value_optimization_safe<decltype(_UFirst), _Pr>
+                          && sized_sentinel_for<decltype(_ULast), decltype(_UFirst)>) {
+                if (!_STD is_constant_evaluated()) {
+                    const auto _First_ptr = _STD to_address(_UFirst);
+                    const auto _Last_ptr  = _First_ptr + (_ULast - _UFirst);
+                    return static_cast<range_value_t<_Rng>>(_STD _Min_vectorized(_First_ptr, _Last_ptr));
+                }
+            }
+#endif // _USE_STD_VECTOR_ALGORITHMS
+            if constexpr (forward_range<_Rng> && _Prefer_iterator_copies<decltype(_UFirst)>) {
+                return static_cast<range_value_t<_Rng>>(*_RANGES _Min_element_unchecked(
+                    _STD move(_UFirst), _STD move(_ULast), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj)));
+            } else {
+                range_value_t<_Rng> _Found(*_UFirst);
+                while (++_UFirst != _ULast) {
+                    if (_STD invoke(_Pred, _STD invoke(_Proj, *_UFirst), _STD invoke(_Proj, _Found))) {
+                        _Found = *_UFirst;
+                    }
+                }
+
+                return _Found;
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Min_fn min;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _FwdIt, class _Ty, class _Pr>
+_NODISCARD _CONSTEXPR20 _FwdIt lower_bound(_FwdIt _First, const _FwdIt _Last, const _Ty& _Val, _Pr _Pred) {
+    // find first element not before _Val
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst                = _STD _Get_unwrapped(_First);
+    _Iter_diff_t<_FwdIt> _Count = _STD distance(_UFirst, _STD _Get_unwrapped(_Last));
+
+    while (0 < _Count) { // divide and conquer, find half that contains answer
+        const _Iter_diff_t<_FwdIt> _Count2 = _Count / 2;
+        const auto _UMid                   = _STD next(_UFirst, _Count2);
+        if (_Pred(*_UMid, _Val)) { // try top half
+            _UFirst = _STD _Next_iter(_UMid);
+            _Count -= _Count2 + 1;
+        } else {
+            _Count = _Count2;
+        }
+    }
+
+    _STD _Seek_wrapped(_First, _UFirst);
+    return _First;
+}
+
+_EXPORT_STD template <class _FwdIt, class _Ty>
+_NODISCARD _CONSTEXPR20 _FwdIt lower_bound(_FwdIt _First, _FwdIt _Last, const _Ty& _Val) {
+    // find first element not before _Val
+    return _STD lower_bound(_First, _Last, _Val, less<>{});
+}
+
+_EXPORT_STD template <class _FwdIt, class _Ty, class _Pr>
+_NODISCARD _CONSTEXPR20 _FwdIt upper_bound(_FwdIt _First, _FwdIt _Last, const _Ty& _Val, _Pr _Pred) {
+    // find first element that _Val is before
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst                = _STD _Get_unwrapped(_First);
+    _Iter_diff_t<_FwdIt> _Count = _STD distance(_UFirst, _STD _Get_unwrapped(_Last));
+
+    while (0 < _Count) { // divide and conquer, find half that contains answer
+        _Iter_diff_t<_FwdIt> _Count2 = _Count / 2;
+        const auto _UMid             = _STD next(_UFirst, _Count2);
+        if (_Pred(_Val, *_UMid)) {
+            _Count = _Count2;
+        } else { // try top half
+            _UFirst = _STD _Next_iter(_UMid);
+            _Count -= _Count2 + 1;
+        }
+    }
+
+    _STD _Seek_wrapped(_First, _UFirst);
+    return _First;
+}
+
+_EXPORT_STD template <class _FwdIt, class _Ty>
+_NODISCARD _CONSTEXPR20 _FwdIt upper_bound(_FwdIt _First, _FwdIt _Last, const _Ty& _Val) {
+    // find first element that _Val is before
+    return _STD upper_bound(_First, _Last, _Val, less<>{});
+}
+
+template <class _FwdIt1, class _FwdIt2>
+_CONSTEXPR20 _FwdIt2 _Swap_ranges_unchecked(_FwdIt1 _First1, const _FwdIt1 _Last1, _FwdIt2 _First2) {
+    // swap [_First1, _Last1) with [_First2, ...)
+
+#if _USE_STD_VECTOR_ALGORITHMS
+    using _Elem1 = remove_reference_t<_Iter_ref_t<_FwdIt1>>;
+    using _Elem2 = remove_reference_t<_Iter_ref_t<_FwdIt2>>;
+    if constexpr (is_same_v<_Elem1, _Elem2> && _Is_trivially_swappable_v<_Elem1>
+                  && _Iterators_are_contiguous<_FwdIt1, _FwdIt2>) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            ::__std_swap_ranges_trivially_swappable_noalias(
+                _STD _To_address(_First1), _STD _To_address(_Last1), _STD _To_address(_First2));
+            return _First2 + (_Last1 - _First1);
+        }
+    }
+#endif // _USE_STD_VECTOR_ALGORITHMS
+
+    for (; _First1 != _Last1; ++_First1, (void) ++_First2) {
+        swap(*_First1, *_First2); // intentional ADL
+    }
+
+    return _First2;
+}
+
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xbad_alloc();
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xinvalid_argument(_In_z_ const char*);
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xlength_error(_In_z_ const char*);
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xout_of_range(_In_z_ const char*);
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xoverflow_error(_In_z_ const char*);
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xruntime_error(_In_z_ const char*);
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _XGetLastError();
+
+_EXPORT_STD template <class _Category, class _Ty, class _Diff = ptrdiff_t, class _Pointer = _Ty*,
+    class _Reference = _Ty&>
+struct _CXX17_DEPRECATE_ITERATOR_BASE_CLASS iterator { // base type for iterator classes
+    using iterator_category = _Category;
+    using value_type        = _Ty;
+    using difference_type   = _Diff;
+    using pointer           = _Pointer;
+    using reference         = _Reference;
+};
+
+#if _HAS_CXX17
+_EXPORT_STD struct monostate {};
+#endif // _HAS_CXX17
+
+#if _HAS_CXX23
+template <_Integer_like _Int>
+_NODISCARD constexpr bool _Add_overflow(const _Int _Left, const _Int _Right, _Int& _Out) {
+#ifdef __clang__
+    if constexpr (integral<_Int>) {
+        return __builtin_add_overflow(_Left, _Right, &_Out);
+    } else
+#endif // defined(__clang__)
+    {
+        if constexpr (!_Signed_integer_like<_Int>) {
+            _Out = static_cast<_Int>(_Left + _Right);
+            return _Out < _Left || _Out < _Right;
+        } else {
+            using _UInt = _Make_unsigned_like_t<_Int>;
+            _Out        = static_cast<_Int>(static_cast<_UInt>(_Left) + static_cast<_UInt>(_Right));
+            return (_Left > 0 && _Right > 0 && _Out <= 0) || (_Left < 0 && _Right < 0 && _Out >= 0);
+        }
+    }
+}
+#endif // _HAS_CXX23
+
+#if _HAS_CXX17
+#if _HAS_CXX20
+template <_Integer_like _Int>
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Int, enable_if_t<_Is_nonbool_integral<_Int>, int> = 0>
+#endif // ^^^ !_HAS_CXX20 ^^^
+_NODISCARD constexpr bool _Mul_overflow(const _Int _Left, const _Int _Right, _Int& _Out) {
+#if defined(__clang__) && !_HAS_CXX20
+    return __builtin_mul_overflow(_Left, _Right, &_Out);
+#else // ^^^ defined(__clang__) && !_HAS_CXX20 / !defined(__clang__) || _HAS_CXX20 vvv
+#ifdef __clang__
+    if constexpr (is_integral_v<_Int>) {
+        return __builtin_mul_overflow(_Left, _Right, &_Out);
+    } else
+#endif // defined(__clang__)
+    {
+        if constexpr (static_cast<_Int>(-1) > static_cast<_Int>(0)) {
+            constexpr auto _UInt_max = _STD _Max_limit<_Int>();
+            const bool _Overflow     = _Left != 0 && _Right > _UInt_max / _Left;
+            if (!_Overflow) {
+                _Out = static_cast<_Int>(_Left * _Right);
+            }
+            return _Overflow;
+        } else {
+            // vvv Based on llvm::MulOverflow vvv
+            // https://github.com/llvm/llvm-project/blob/88e5206/llvm/include/llvm/Support/MathExtras.h#L725-L750
+            //===----------------------------------------------------------------------===//
+            //
+            // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+            // See https://llvm.org/LICENSE.txt for license information.
+            // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+            //
+            //===----------------------------------------------------------------------===//
+            using _UInt = _Make_unsigned_like_t<_Int>;
+            const _UInt _ULeft =
+                static_cast<_UInt>(_Left < 0 ? (0 - static_cast<_UInt>(_Left)) : static_cast<_UInt>(_Left));
+            const _UInt _URight =
+                static_cast<_UInt>(_Right < 0 ? (0 - static_cast<_UInt>(_Right)) : static_cast<_UInt>(_Right));
+            const _UInt _UResult = static_cast<_UInt>(_ULeft * _URight);
+
+            const bool _Negative = (_Left < 0) != (_Right < 0);
+            _Out                 = static_cast<_Int>(_Negative ? (0 - _UResult) : _UResult);
+            if (_ULeft == 0 || _URight == 0) {
+                return false;
+            }
+
+            constexpr auto _Int_max = static_cast<_UInt>(_STD _Max_limit<_Int>());
+            if (_Negative) {
+                return _ULeft > (_Int_max + _UInt{1}) / _URight;
+            } else {
+                return _ULeft > _Int_max / _URight;
+            }
+            // ^^^ Based on llvm::MulOverflow ^^^
+        }
+    }
+#endif // ^^^ !defined(__clang__) || _HAS_CXX20 ^^^
+}
+#endif // _HAS_CXX17
+
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("lifetimebound")
+#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 // _XUTILITY_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xxamp.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xxamp.h
new file mode 100644
index 0000000000000000000000000000000000000000..e4b7aba8e6bfdcc39fc196b1e6fd2ac75ff9fd4c
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xxamp.h
@@ -0,0 +1,1414 @@
+/***
+* ==++==
+*
+* Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+* ==--==
+* =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+*
+* xxamp.h
+*
+* C++ AMP Library helper classes
+*
+* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+****/
+
+#pragma once
+
+#ifndef _SILENCE_AMP_DEPRECATION_WARNINGS
+#error <xxamp.h> is part of C++ AMP which is deprecated by Microsoft and will be REMOVED. \
+You can define _SILENCE_AMP_DEPRECATION_WARNINGS to acknowledge that you have received this warning.
+#endif // _SILENCE_AMP_DEPRECATION_WARNINGS
+
+#define CPP_AMP_MAX_RANK 128
+#define _CPP_AMP_VERIFY_RANK(_Rank, _Type_name) \
+    static_assert(((_Rank) > 0) && ((_Rank) <= CPP_AMP_MAX_RANK), "The _Rank of " #_Type_name " should be greater than 0 and <= 128.")
+
+// This macro is used to determine whether a specified iterator is a mutable iterator
+// by ensuring that the iterator_category iterator_trait is or inherits from either the
+// output_iterator_tag or forward_iterator_tag. We use a static_assert to emit a compilation
+// error when the iterator does not meet this requirement. This macro is used for verifying that
+// the destination iterator passed to the concurrency::copy overloads is of the right type.
+#define _CPP_AMP_VERIFY_MUTABLE_ITERATOR(_Type_name) \
+    static_assert((std::is_base_of<std::output_iterator_tag, typename std::iterator_traits<_Type_name>::iterator_category>::value \
+                  || std::is_base_of<std::forward_iterator_tag, typename std::iterator_traits<_Type_name>::iterator_category>::value), \
+                  "Invalid destination argument type to concurrency::copy.")
+
+#pragma pack(push,8)
+
+//=============================================================================
+// Internal Intrinsic Functions used for implementing libraries
+//=============================================================================
+extern "C"
+{
+//=============================================================================
+// Intrinsics that access textures
+//=============================================================================
+void __dp_read_texture(const void * /* pTex */,
+                       _Out_ void * /* pRet */,
+                       unsigned int /* x */,
+                       unsigned int /* y */,
+                       unsigned int /* z */,
+                       unsigned int /* Miplevel */)  __GPU_ONLY;
+
+void __dp_write_texture(_Out_ void * /* pTex */,
+                        const void * /* pValue */,
+                        unsigned int /* x */,
+                        unsigned int /* y */,
+                        unsigned int /* z */) __GPU_ONLY;
+
+void __dp_sample_texture(const void * /* pTex */,
+                         const void * /* pSampler */,
+                         _Out_ void* /* pRet */,
+                         float /* x */,
+                         float /* y */,
+                         float /* z */,
+                         unsigned int /* kind: 0 - GatherRed, 1 - GatherGreen, 2 - GatherBlue, 3 - GatherAlpha, 4 - Sample */,
+                         float /* LevelOfDetail */) __GPU_ONLY;
+
+void __dp_sample_texture_predefined(const void * /* pTex */,
+                                    _Out_ void * /* pRet */,
+                                    float /* x */,
+                                    float /* y */,
+                                    float /* z */,
+                                    unsigned int /* predefinedSamplerId: filter_mode << 16 | address_mode */,
+                                    unsigned int /* kind: 0 - GatherRed, 1 - GatherGreen, 2 - GatherBlue, 3 - GatherAlpha, 4 - Sample */,
+                                    float /* LevelOfDetail */) __GPU_ONLY;
+}
+
+namespace Concurrency
+{
+    // forward decls
+    template <typename _Value_type, int _Rank>
+    class array;
+
+    template <typename _Value_type, int _Rank>
+    class array_view;
+
+    template <int _Dim0, int _Dim1 = 0, int _Dim2 = 0>
+    class tiled_extent;
+
+    template <int _Rank>
+    class extent;
+
+    template <int _Rank>
+    class index;
+
+namespace details
+{
+    // forward decls
+    template <int _Rank, int _Element_size>
+    class _Array_view_shape;
+
+    template <int _Rank, int _Element_size>
+    class _Array_view_base;
+
+    // Helper class to avoid static_assertion errors on uninstantiated
+    // templates.
+    template <typename _T>
+    struct _Falsifier
+    {
+        static const bool value = false;
+    };
+
+    // Helper classes for array and array_view projection
+    template <typename _T, int _R>
+    class _Projection_result_type
+    {
+        static_assert(!std::is_const<_T>::value, "const _T is not supported");
+        static_assert(_R >= 2, "Rank must be greater than or equal to 2");
+
+    public:
+        typedef array_view<const _T,_R-1> _Const_result_type;
+        typedef array_view<_T,_R-1> _Result_type;
+    };
+
+    template <typename _T>
+    class _Projection_result_type<_T,1>
+    {
+        static_assert(!std::is_const<_T>::value, "const _T is not supported");
+
+    public:
+        typedef const _T& _Const_result_type;
+        typedef _T& _Result_type;
+    };
+
+    template <typename _T, int _R>
+    class _Const_array_view_projection_helper
+    {
+        static_assert(!std::is_const<_T>::value, "const _T is not supported");
+        static_assert(_R >= 2, "Rank must be greater than or equal to 2");
+
+    public:
+        static typename _Projection_result_type<_T,_R>::_Const_result_type _Project0(const array_view<const _T,_R>* _Arr_view, int _I) __GPU;
+    };
+
+    template <typename _T>
+    class _Const_array_view_projection_helper<_T,1>
+    {
+        static_assert(!std::is_const<_T>::value, "const _T is not supported");
+
+    public:
+        static typename _Projection_result_type<_T,1>::_Const_result_type _Project0(const array_view<const _T,1>* _Arr_view, int _I) __GPU;
+    };
+
+    template <typename _T, int _R>
+    class _Array_view_projection_helper
+    {
+        static_assert(!std::is_const<_T>::value, "const _T is not supported");
+        static_assert(_R >= 2, "Rank must be greater than or equal to 2");
+
+    public:
+        static typename _Projection_result_type<_T,_R>::_Result_type _Project0(const array_view<_T,_R>* _Arr_view, int _I) __GPU;
+    };
+
+    template <typename _T>
+    class _Array_view_projection_helper<_T,1>
+    {
+        static_assert(!std::is_const<_T>::value, "const _T is not supported");
+
+    public:
+        static typename _Projection_result_type<_T,1>::_Result_type _Project0(const array_view<_T,1>* _Arr_view, int _I) __GPU;
+    };
+
+    template <typename _T, int _R>
+    class _Const_array_projection_helper
+    {
+        static_assert(!std::is_const<_T>::value, "const _T is not supported");
+        static_assert(_R >= 2, "Rank must be greater than or equal to 2");
+
+    public:
+        static typename _Projection_result_type<_T,_R>::_Const_result_type _Project0(const array<_T,_R>* _Array, int _I) __GPU;
+    };
+
+    template <typename _T>
+    class _Const_array_projection_helper<_T,1>
+    {
+        static_assert(!std::is_const<_T>::value, "const _T is not supported");
+
+    public:
+        static typename _Projection_result_type<_T,1>::_Const_result_type _Project0(const array<_T,1>* _Array, int _I) __GPU;
+    };
+
+    template <typename _T, int _R>
+    class _Array_projection_helper
+    {
+        static_assert(!std::is_const<_T>::value, "const _T is not supported");
+        static_assert(_R >= 2, "Rank must be greater than or equal to 2");
+
+    public:
+        static typename _Projection_result_type<_T,_R>::_Result_type _Project0(_In_ array<_T,_R>* _Array, int _I) __GPU;
+    };
+
+    template <typename _T>
+    class _Array_projection_helper<_T,1>
+    {
+        static_assert(!std::is_const<_T>::value, "const _T is not supported");
+
+    public:
+        static typename _Projection_result_type<_T,1>::_Result_type _Project0(_In_ array<_T,1>* _Array, int _I) __GPU;
+    };
+
+    // leading underscore implies 'private'
+    enum _eInitializeState {
+        _do_not_initialize
+    };
+
+    // Helpers to create not initialized tuples
+    template<class _Tuple_type>
+    _Tuple_type _Create_uninitialized_tuple() __GPU
+    {
+        return _Tuple_type(details::_do_not_initialize);
+    };
+
+
+    // ========================================================
+    // helpers for unroll the loops for lower rank
+    // ========================================================
+
+    // operation kinds
+    enum _op_kind
+    {
+        // cmp op
+        opEq,      // a == b
+        opNeq,     // a != b
+        // not op
+        opNot,     // !a
+        // compound assignment
+        opAssign,  // a = b
+        opAddEq,   // a += b;
+        opSubEq,   // a -= b;
+        opMulEq,   // a *= b
+        opDivEq,   // a /= b
+        opModEq,   // a %= b
+        // arithmetic ops
+        opAdd,     // c = a + b
+        opSub,     // c = a - b
+        opMul,     // c = a * b
+        opDiv,     // c = a / b
+        opMod,     // c = a % b
+    };
+
+    const static int LOOP_UNROLL_THRESHOLD = 4;
+
+    // forward declarations
+    template<typename _T, _op_kind _Kind, int _Rank = _T::rank, bool _Unroll = (_Rank > 1 && _Rank <= LOOP_UNROLL_THRESHOLD)>
+    struct _cmp_op_loop_helper;
+
+    template<typename _T, _op_kind _Kind, int _Rank = _T::rank, bool _Unroll = (_Rank > 1 && _Rank <= LOOP_UNROLL_THRESHOLD)>
+    struct _compound_assign_op_loop_helper;
+
+    template<typename _T, _op_kind _Kind, int _Rank = _T::rank, bool _Unroll = (_Rank > 1 && _Rank <= LOOP_UNROLL_THRESHOLD)>
+    struct _arithmetic_op_loop_helper;
+
+    template<typename _T, int _Rank = _T::rank, bool _Unroll = (_Rank > 1 && _Rank <= LOOP_UNROLL_THRESHOLD)>
+    struct _product_helper;
+
+    // comparison operations
+    template<typename _T, _op_kind _Kind>
+    struct _cmp_op_helper;
+
+    template<typename _T>
+    struct _cmp_op_helper<_T, opEq>
+    {
+        static bool func(const _T & a, const _T & b) __GPU { return a == b; }
+    };
+
+    template<typename _T>
+    struct _cmp_op_helper<_T, opNeq>
+    {
+        static bool func(const _T & a, const _T & b) __GPU { return a != b; }
+    };
+
+    template<typename _T, _op_kind _Kind>
+    struct _cmp_op_helper
+    {
+        static bool func(const _T & a, const _T & b) __GPU { static_assert(_Falsifier<_T>::value, "invalid op"); return false;}
+    };
+
+    // operations:  a op= b
+    template<typename _T, _op_kind _Kind>
+    struct _compound_assign_op_helper;
+
+    template<typename _T>
+    struct _compound_assign_op_helper<_T, opAssign>
+    {
+        static void func(_T & a, const _T & b) __GPU { a = b; }
+    };
+
+    template<typename _T>
+    struct _compound_assign_op_helper<_T, opAddEq>
+    {
+        static void func(_T & a, const _T & b) __GPU { a += b; }
+    };
+
+    template<typename _T>
+    struct _compound_assign_op_helper<_T, opSubEq>
+    {
+        static void func(_T & a, const _T & b) __GPU { a -= b; }
+    };
+
+    template<typename _T>
+    struct _compound_assign_op_helper<_T, opMulEq>
+    {
+        static void func(_T & a, const _T & b) __GPU { a *= b; }
+    };
+
+    template<typename _T>
+    struct _compound_assign_op_helper<_T, opDivEq>
+    {
+        static void func(_T & a, const _T & b) __GPU { a /= b; }
+    };
+
+    template<typename _T>
+    struct _compound_assign_op_helper<_T, opModEq>
+    {
+        static void func(_T & a, const _T & b) __GPU { a %= b; }
+    };
+
+    template<typename _T, _op_kind _Kind>
+    struct _compound_assign_op_helper
+    {
+        static void func(_T & a, const _T & b) __GPU { static_assert(_Falsifier<_T>::value, "invalid op"); }
+    };
+
+    // operations:  a = b + c
+    template<typename _T, _op_kind _Kind>
+    struct _arithmetic_op_helper;
+
+    template<typename _T>
+    struct _arithmetic_op_helper<_T, opAdd>
+    {
+        static void func(_T & a, const _T & b, const _T & c) __GPU { a = b + c; }
+    };
+
+    template<typename _T>
+    struct _arithmetic_op_helper<_T, opSub>
+    {
+        static void func(_T & a, const _T & b, const _T & c) __GPU { a = b - c; }
+    };
+
+    template<typename _T>
+    struct _arithmetic_op_helper<_T, opMul>
+    {
+        static void func(_T & a, const _T & b, const _T & c) __GPU { a = b * c; }
+    };
+
+    template<typename _T>
+    struct _arithmetic_op_helper<_T, opDiv>
+    {
+        static void func(_T & a, const _T & b, const _T & c) __GPU { a = b / c; }
+    };
+
+    template<typename _T>
+    struct _arithmetic_op_helper<_T, opMod>
+    {
+        static void func(_T & a, const _T & b, const _T & c) __GPU { a = b % c; }
+    };
+
+    template<typename _T, _op_kind _Kind>
+    struct _arithmetic_op_helper
+    {
+        static void func(_T & a, const _T & b, const _T & c) __GPU { static_assert(_Falsifier<_T>::value, "invalid op"); }
+    };
+
+
+#pragma warning( push )
+#pragma warning( disable : 4100 ) // unreferenced formal parameter
+    template<typename _T1>
+    struct _index_helper
+    {
+        template<typename _T2>
+        static typename _T1::value_type func(const _T2 & a, int i) __GPU
+        {
+            return a[i];
+        }
+
+        static typename _T1::value_type func(typename _T1::value_type a[_T1::rank], int i) __GPU
+        {
+            return a[i];
+        }
+
+        static typename _T1::value_type func(typename _T1::value_type a, int i) __GPU
+        {
+            return a;
+        }
+    };
+#pragma warning( pop )
+
+    // loop unrolling helpers, unroll the loop if rank <= LOOP_UNROLL_THRESHOLD
+
+
+    // helper class to unroll the loop that uses cmp ops
+
+    // a[i] op b[i]
+    template<typename _T, _op_kind _Kind>
+    struct _cmp_op_loop_helper<_T, _Kind, 1, false /* _Unroll */ >
+    {
+        static bool func(const _T& a, const _T& b) __GPU
+        {
+            return _cmp_op_helper<typename _T::value_type, _Kind>::func(a[0], b[0]);
+        }
+    };
+
+    template<typename _T, _op_kind _Kind, int _Rank>
+    struct _cmp_op_loop_helper<_T, _Kind, _Rank, true /* _Unroll */ >
+    {
+        static bool func(const _T& a, const _T& b) __GPU
+        {
+            if (!_cmp_op_helper<typename _T::value_type, _Kind>::func(a[_Rank - 1], b[_Rank - 1]))
+                return false;
+            else
+                return _cmp_op_loop_helper<_T, _Kind, _Rank - 1>::func(a, b);
+        }
+    };
+
+    template<typename _T, _op_kind _Kind, int _Rank>
+    struct _cmp_op_loop_helper<_T, _Kind, _Rank, false /* _Unroll */ >
+    {
+        static bool func(const _T& a, const _T& b) __GPU
+        {
+            for (int i = 0; i < _Rank; i++)
+            {
+                if (!_cmp_op_helper<typename _T::value_type, _Kind>::func(a[i], b[i]))
+                    return false;
+            }
+            return true;
+        }
+    };
+
+    // helper class for loop that uses  a op= b
+
+    template<typename _T, _op_kind _Kind>
+    struct _compound_assign_op_loop_helper<_T, _Kind, 1, false /* _Unroll */>
+    {
+        template<typename _T2>
+        static void func(_T& a, const _T2& b) __GPU
+        {
+            _compound_assign_op_helper<typename _T::value_type, _Kind>::func(a[0], _index_helper<_T>::func(b, 0));
+        }
+    };
+
+    template<typename _T, _op_kind _Kind, int _Rank>
+    struct _compound_assign_op_loop_helper<_T, _Kind, _Rank, true /* _Unroll */>
+    {
+        template<typename _T2>
+        static void func(_T& a, const _T2& b) __GPU
+        {
+            _compound_assign_op_loop_helper<_T, _Kind, _Rank - 1>::func(a, b);
+            _compound_assign_op_helper<typename _T::value_type, _Kind>::func(a[_Rank - 1], _index_helper<_T>::func(b, _Rank - 1));
+        }
+    };
+
+    template<_op_kind _Kind,  typename _T, int _Rank>
+    struct _compound_assign_op_loop_helper<_T, _Kind, _Rank, false /* _Unroll */>
+    {
+        template<typename _T2>
+        static void func(_T& a, const _T2& b) __GPU
+        {
+            for (int i = 0; i < _Rank; i++)
+            {
+                _compound_assign_op_helper<typename _T::value_type, _Kind>::func(a[i], _index_helper<_T>::func(b, i));
+            }
+        }
+    };
+
+    // specialization of _compound_assign_op_loop_helper for opAssign
+    template<typename _T>
+    struct _compound_assign_op_loop_helper<_T, opAssign, 1, false /* _Unroll */>
+    {
+        template<typename _T2>
+        static void func(_T& a, const _T2& b) __GPU
+        {
+            a[0] = b[0];
+        }
+
+        static void func(_T& a, typename _T::value_type b) __GPU
+        {
+            a[0] = b;
+        }
+    };
+
+    template<typename _T>
+    struct _compound_assign_op_loop_helper<_T, opAssign, 2, true /* _Unroll */>
+    {
+        template<typename _T2>
+        static void func(_T& a, const _T2& b) __GPU
+        {
+            a[0] = b[0];
+            a[1] = b[1];
+        }
+
+        static void func(_T& a, typename _T::value_type b) __GPU
+        {
+            a[0] = b;
+            a[1] = b;
+        }
+    };
+
+    template<typename _T>
+    struct _compound_assign_op_loop_helper<_T, opAssign, 3, true /* _Unroll */>
+    {
+        template<typename _T2>
+        static void func(_T& a, const _T2& b) __GPU
+        {
+            a[0] = b[0];
+            a[1] = b[1];
+            a[2] = b[2];
+        }
+
+        static void func(_T& a, typename _T::value_type b) __GPU
+        {
+            a[0] = b;
+            a[1] = b;
+            a[2] = b;
+        }
+    };
+
+    template<typename _T>
+    struct _compound_assign_op_loop_helper<_T, opAssign, 4, true /* _Unroll */>
+    {
+        template<typename _T2>
+        static void func(_T& a, const _T2& b) __GPU
+        {
+            a[0] = b[0];
+            a[1] = b[1];
+            a[2] = b[2];
+            a[3] = b[3];
+        }
+
+        static void func(_T& a, typename _T::value_type b) __GPU
+        {
+            a[0] = b;
+            a[1] = b;
+            a[2] = b;
+            a[3] = b;
+        }
+    };
+
+    // helper class for loop that uses  a = b op c
+
+    template<typename _T, _op_kind _Kind>
+    struct _arithmetic_op_loop_helper<_T, _Kind, 1, false /* _Unroll */>
+    {
+        template<typename _T1, typename _T2>
+        static void func(_T& a, const _T1& b, const _T2& c) __GPU
+        {
+            _arithmetic_op_helper<typename _T::value_type, _Kind>::func(a[0],
+                                                               _index_helper<_T>::func(b, 0),
+                                                               _index_helper<_T>::func(c, 0));
+        }
+    };
+
+    template<typename _T, _op_kind _Kind, int _Rank>
+    struct _arithmetic_op_loop_helper<_T, _Kind, _Rank, true /* _Unroll */>
+    {
+        template<typename _T1, typename _T2>
+        static void func(_T& a, const _T1& b, const _T2& c) __GPU
+        {
+            _arithmetic_op_loop_helper<_T, _Kind, _Rank - 1>::func(a, b, c);
+            _arithmetic_op_helper<typename _T::value_type, _Kind>::func(a[_Rank - 1],
+                                                               _index_helper<_T>::func(b, _Rank - 1),
+                                                               _index_helper<_T>::func(c, _Rank - 1));
+        }
+    };
+
+    template<typename _T, _op_kind _Kind, int _Rank>
+    struct _arithmetic_op_loop_helper<_T, _Kind, _Rank, false /* _Unroll */>
+    {
+        template<typename _T1, typename _T2>
+        static void func(_T& a, const _T1& b, const _T2& c) __GPU
+        {
+            for (int i = 0; i < _Rank; i++)
+            {
+                _arithmetic_op_helper<typename _T::value_type, _Kind>::func(a[i],
+                                                                   _index_helper<_T>::func(b, i),
+                                                                   _index_helper<_T>::func(c, i));
+            }
+        }
+    };
+
+    // helper for unroll the loop for product operation
+
+    template<typename _T>
+    struct _product_helper<_T, 1, false /* _Unroll */>
+    {
+        template<typename _T1>
+        static typename _T::value_type func(const _T1 & a) __GPU
+        {
+            return a[0];
+        }
+    };
+
+    template<typename _T, int _Rank>
+    struct _product_helper<_T, _Rank, true /* _Unroll */>
+    {
+        template<typename _T1>
+        static typename _T::value_type func(const _T1 & a) __GPU
+        {
+            return _product_helper<_T, _Rank - 1>::func(a) * a[_Rank - 1];
+        }
+    };
+
+    template<typename _T, int _Rank>
+    struct _product_helper<_T, _Rank, false /* _Unroll */>
+    {
+        template<typename _T1>
+        static typename _T::value_type func(const _T1 & a) __GPU
+        {
+            typename _T::value_type _e = a[0];
+            for (int i = 1; i < _Rank; i++)
+            {
+                _e *= a[i];
+            }
+            return _e;
+        }
+    };
+
+    template<typename _T1, int _Rank = _T1::rank>
+    struct _map_index;
+
+#pragma warning( push )
+#pragma warning( disable : 4100 ) // unreferenced formal parameter
+    template<typename _T1>
+    struct _map_index<_T1, 1>
+    {
+        template<typename _T2>
+        static _T1 func(int _Flat_index, const _T2 _Base) __GPU
+        {
+            _T1 _index = _Create_uninitialized_tuple<_T1>();
+            _index[0]   = _Flat_index;
+            return _index;
+        }
+    };
+
+    template<typename _T1>
+    struct _map_index<_T1, 2>
+    {
+        template<typename _T2>
+        static _T1 func(int _Flat_index, const _T2 _Base) __GPU
+        {
+            _T1 _index = _Create_uninitialized_tuple<_T1>();
+            _index[1]   = static_cast<unsigned int>(_Flat_index) % static_cast<unsigned int>(_Base[1]);
+            _index[0]   = static_cast<unsigned int>(_Flat_index) / static_cast<unsigned int>(_Base[1]);
+            return _index;
+        }
+    };
+
+    template<typename _T1>
+    struct _map_index<_T1, 3>
+    {
+        template<typename _T2>
+        static _T1 func(int _Flat_index, const _T2 _Base) __GPU
+        {
+            _T1 _index = _Create_uninitialized_tuple<_T1>();
+
+            _index[2]   = static_cast<unsigned int>(_Flat_index) % static_cast<unsigned int>(_Base[2]);
+            _Flat_index = static_cast<unsigned int>(_Flat_index) / static_cast<unsigned int>(_Base[2]);
+            _index[1]   = static_cast<unsigned int>(_Flat_index) % static_cast<unsigned int>(_Base[1]);
+            _index[0]   = static_cast<unsigned int>(_Flat_index) / static_cast<unsigned int>(_Base[1]);
+            return _index;
+        }
+    };
+
+    template<typename _T1>
+    struct _map_index<_T1, 4>
+    {
+        template<typename _T2>
+        static _T1 func(int _Flat_index, const _T2 _Base) __GPU
+        {
+            _T1 _index = _Create_uninitialized_tuple<_T1>();
+            _index[3]   = static_cast<unsigned int>(_Flat_index) % static_cast<unsigned int>(_Base[3]);
+            _Flat_index = static_cast<unsigned int>(_Flat_index) / static_cast<unsigned int>(_Base[3]);
+            _index[2]   = static_cast<unsigned int>(_Flat_index) % static_cast<unsigned int>(_Base[2]);
+            _Flat_index = static_cast<unsigned int>(_Flat_index) / static_cast<unsigned int>(_Base[2]);
+            _index[1]   = static_cast<unsigned int>(_Flat_index) % static_cast<unsigned int>(_Base[1]);
+            _index[0]   = static_cast<unsigned int>(_Flat_index) / static_cast<unsigned int>(_Base[1]);
+            return _index;
+        }
+    };
+
+    template<typename _T1, int _Rank>
+    struct _map_index
+    {
+        template<typename _T2>
+        static _T1 func(int _Flat_index, const _T2 _Base) __GPU
+        {
+            _T1 _index = _Create_uninitialized_tuple<_T1>();
+            for (int i = _Rank - 1; i > 0; --i)
+            {
+                _index[i] = static_cast<unsigned int>(_Flat_index) % static_cast<unsigned int>(_Base[i]);
+                _Flat_index = static_cast<unsigned int>(_Flat_index) / static_cast<unsigned int>(_Base[i]);
+            }
+            _index[0] = _Flat_index;
+            return _index;
+        }
+    };
+#pragma warning( pop )
+
+    // Helper class for unrolling extent<N>::contains
+
+#pragma warning( push )
+#pragma warning( disable : 4100 ) // unreferenced formal parameter
+
+    template<typename _EXT, typename _IDX, int _R>
+    struct _contains
+    {
+        static bool func(const _EXT& _Ext, const _IDX& _Idx) __GPU
+		{
+			for (int _I=0; _I<_R; _I++)
+			{
+				if ((_Idx[_I] < 0) | (_Idx[_I] >= _Ext[_I]))
+					return false;
+			}
+			return true;
+		}
+    };
+
+    template<typename _EXT, typename _IDX>
+    struct _contains<_EXT,_IDX,1>
+    {
+        static bool func(const _EXT& _Ext, const _IDX& _Idx) __GPU
+		{
+			return (_Idx[0] >= 0) & (_Idx[0] < _Ext[0]);
+		}
+    };
+
+    template<typename _EXT, typename _IDX>
+    struct _contains<_EXT,_IDX,2>
+    {
+        static bool func(const _EXT& _Ext, const _IDX& _Idx) __GPU
+		{
+			return (_Idx[0] >= 0) & (_Idx[0] < _Ext[0]) &
+				   (_Idx[1] >= 0) & (_Idx[1] < _Ext[1]);
+		}
+    };
+
+    template<typename _EXT, typename _IDX>
+    struct _contains<_EXT,_IDX,3>
+    {
+        static bool func(const _EXT& _Ext, const _IDX& _Idx) __GPU
+		{
+			return (_Idx[0] >= 0) & (_Idx[0] < _Ext[0]) &
+				   (_Idx[1] >= 0) & (_Idx[1] < _Ext[1]) &
+				   (_Idx[2] >= 0) & (_Idx[2] < _Ext[2]);
+		}
+    };
+
+#pragma warning( pop )
+
+    // Helper class for loop unrolling of array projection
+
+#pragma warning( push )
+#pragma warning( disable : 4100 ) // unreferenced formal parameter
+
+    template<typename _RES_EXT, typename _SRC_EXT, typename _RES_IDX, typename _SRC_IDX, int _R>
+    struct _project0
+    {
+		static_assert(_RES_EXT::rank == _R-1, "Result extent rank must be _R-1");
+		static_assert(_SRC_EXT::rank == _R, "Source extent rank must be _R");
+		static_assert(_RES_IDX::rank == _R-1, "Result index rank must be _R-1");
+		static_assert(_SRC_IDX::rank == _R, "Source index rank must be _R");
+
+        static void func(_RES_EXT& _ResArrayExtent, const _SRC_EXT& _SrcArrayExtent,
+                         _RES_EXT& _ResArrayMultiplier, const _SRC_EXT& _SrcArrayMultiplier,
+                         _RES_IDX& _ResViewOffset, const _SRC_IDX& _SrcViewOffset,
+                         _RES_EXT& _ResViewExtent, const _SRC_EXT& _SrcViewExtent) __GPU
+        {
+            for (int _I=0; _I<=_R-3; _I++)
+            {
+                _ResArrayExtent    [_I] = _SrcArrayExtent    [_I+1];
+                _ResArrayMultiplier[_I] = _SrcArrayMultiplier[_I+1];
+                _ResViewOffset     [_I] = _SrcViewOffset     [_I+1];
+                _ResViewExtent     [_I] = _SrcViewExtent     [_I+1];
+            }
+
+            _ResArrayExtent    [_R-2] = _SrcArrayExtent    [_R-1];
+            _ResViewOffset     [_R-2] = _SrcViewOffset     [_R-1];
+            _ResViewExtent     [_R-2] = _SrcViewExtent     [_R-1];
+        }
+
+    };
+
+    template<typename _RES_EXT, typename _SRC_EXT, typename _RES_IDX, typename _SRC_IDX>
+    struct _project0<_RES_EXT,_SRC_EXT,_RES_IDX,_SRC_IDX,2>
+    {
+        static void func(_RES_EXT& _ResArrayExtent, const _SRC_EXT& _SrcArrayExtent,
+                         _RES_EXT& /*_ResArrayMultiplier*/, const _SRC_EXT& /*_SrcArrayMultiplier*/,
+                         _RES_IDX& _ResViewOffset, const _SRC_IDX& _SrcViewOffset,
+                         _RES_EXT& _ResViewExtent, const _SRC_EXT& _SrcViewExtent) __GPU
+        {
+            _ResArrayExtent[0] = _SrcArrayExtent[1];
+            _ResViewOffset [0] = _SrcViewOffset [1];
+            _ResViewExtent [0] = _SrcViewExtent [1];
+        }
+    };
+
+    template<typename _RES_EXT, typename _SRC_EXT, typename _RES_IDX, typename _SRC_IDX>
+    struct _project0<_RES_EXT,_SRC_EXT,_RES_IDX,_SRC_IDX,3>
+    {
+        static void func(_RES_EXT& _ResArrayExtent, const _SRC_EXT& _SrcArrayExtent,
+                         _RES_EXT& _ResArrayMultiplier, const _SRC_EXT& _SrcArrayMultiplier,
+                         _RES_IDX& _ResViewOffset, const _SRC_IDX& _SrcViewOffset,
+                         _RES_EXT& _ResViewExtent, const _SRC_EXT& _SrcViewExtent) __GPU
+        {
+            _ResArrayExtent    [0] = _SrcArrayExtent    [1];
+            _ResArrayMultiplier[0] = _SrcArrayMultiplier[1];
+            _ResViewOffset     [0] = _SrcViewOffset     [1];
+            _ResViewExtent     [0] = _SrcViewExtent     [1];
+
+            _ResArrayExtent    [1] = _SrcArrayExtent    [2];
+            _ResViewOffset     [1] = _SrcViewOffset     [2];
+            _ResViewExtent     [1] = _SrcViewExtent     [2];
+        }
+
+    };
+
+#pragma warning( pop )
+
+
+    // helper class for loop unrolling.
+    template<typename _T1, typename _T2, int _Rank = _T2::rank>
+    struct _Array_init_helper;
+
+#pragma warning( push )
+#pragma warning( disable : 4100 ) // unreferenced formal parameter
+    template<typename _T1, typename _T2>
+    struct _Array_init_helper<_T1, _T2, 1>
+    {
+        static void func(unsigned int & _Total_extent, _T1 & _Multiplier, const _T2 & _Extent) __GPU
+        {
+            return;
+        }
+    };
+#pragma warning( pop )
+
+    template<typename _T1, typename _T2>
+    struct _Array_init_helper<_T1, _T2, 2>
+    {
+        static void func(unsigned int & _Total_extent, _T1 & _Multiplier, const _T2 & _Extent) __GPU
+        {
+            _Multiplier[0] = _Total_extent;
+            _Total_extent *= _Extent[0];
+        }
+    };
+
+    template<typename _T1, typename _T2>
+    struct _Array_init_helper<_T1, _T2, 3>
+    {
+        static void func(unsigned int & _Total_extent, _T1 & _Multiplier, const _T2 & _Extent) __GPU
+        {
+            _Multiplier[1] = _Total_extent;
+            _Total_extent *= _Extent[1];
+            _Multiplier[0] = _Total_extent;
+            _Total_extent *= _Extent[0];
+        }
+    };
+
+    template<typename _T1, typename _T2>
+    struct _Array_init_helper<_T1, _T2, 4>
+    {
+        static void func(unsigned int & _Total_extent, _T1 & _Multiplier, const _T2 & _Extent) __GPU
+        {
+            _Multiplier[2] = _Total_extent;
+            _Total_extent *= _Extent[2];
+            _Multiplier[1] = _Total_extent;
+            _Total_extent *= _Extent[1];
+            _Multiplier[0] = _Total_extent;
+            _Total_extent *= _Extent[0];
+        }
+    };
+
+    template<typename _T1, typename _T2, int _Rank>
+    struct _Array_init_helper
+    {
+        static void func(unsigned int & _Total_extent, _T1 & _Multiplier, const _T2 & _Extent) __GPU
+        {
+            _Multiplier[_Rank-2] = _Total_extent;
+            for (int i = _Rank-2; i >= 1; --i) {
+                _Total_extent *= _Extent[i];
+                _Multiplier[i-1] = _Total_extent;
+            }
+            _Total_extent *= _Extent[0];
+        }
+    };
+
+    template<int _Rank, typename _T1, typename _T2>
+    struct _Array_flatten_helper;
+
+    template<typename _T1, typename _T2>
+    struct _Array_flatten_helper<1, _T1, _T2>
+    {
+        static _T2 func(const _T1 * /*_Multiplier*/, const _T2 *_Index) __GPU
+        {
+            return _Index[0];
+        }
+    };
+
+    template<typename _T1, typename _T2>
+    struct _Array_flatten_helper<2, _T1, _T2>
+    {
+        static _T2 func(const _T1 *_Multiplier, const _T2 *_Index) __GPU
+        {
+            return ((_Multiplier[0] * _Index[0]) + _Index[1]);
+        }
+    };
+
+    template<typename _T1, typename _T2>
+    struct _Array_flatten_helper<3, _T1, _T2>
+    {
+        static _T2 func(const _T1 *_Multiplier, const _T2 *_Index) __GPU
+        {
+            return ((_Multiplier[0] * _Index[0]) + (_Multiplier[1] * _Index[1]) + _Index[2]);
+        }
+    };
+
+    template<int _Rank, typename _T1, typename _T2>
+    struct _Array_flatten_helper
+    {
+        static _T2 func(const _T1 *_Multiplier, const _T2 *_Index) __GPU
+        {
+            _T2 _Offset = _Index[_Rank - 1];
+            for (int _I = 0; _I < (_Rank - 1); _I++)
+            {
+                _Offset += (_Multiplier[_I] * _Index[_I]);
+            }
+            return _Offset;
+        }
+    };
+
+
+    template<typename _T, int _Rank>
+    struct _Texture_read_helper;
+
+    // rank == 1
+    template<typename _T>
+    struct _Texture_read_helper<_T, 1>
+    {
+        static void func(const void * _Tex_data, _Out_ void * _Val, const _T & _Index, unsigned int _Mip_level) __GPU_ONLY
+        {
+            __dp_read_texture(_Tex_data, _Val, static_cast<unsigned int>(_Index[0]), 1, 1, _Mip_level);
+        }
+    };
+
+    template<typename _T>
+    struct _Texture_read_helper<_T, 2>
+    {
+        static void func(const void * _Tex_data, _Out_ void * _Val, const _T & _Index, unsigned int _Mip_level) __GPU_ONLY
+        {
+            __dp_read_texture(_Tex_data, _Val, static_cast<unsigned int>(_Index[1]), static_cast<unsigned int>(_Index[0]), 1, _Mip_level);
+        }
+    };
+
+    template<typename _T>
+    struct _Texture_read_helper<_T, 3>
+    {
+        static void func(const void * _Tex_data, _Out_ void * _Val, const _T & _Index, unsigned int _Mip_level) __GPU_ONLY
+        {
+            __dp_read_texture(_Tex_data, _Val, static_cast<unsigned int>(_Index[2]), static_cast<unsigned int>(_Index[1]), static_cast<unsigned int>(_Index[0]), _Mip_level);
+        }
+    };
+
+    template<typename _T, int _Rank>
+    struct _Texture_write_helper;
+
+    // rank == 1
+    template<typename _T>
+    struct _Texture_write_helper<_T, 1>
+    {
+        static void func(_Out_ void * _Tex_data, const void * _Ret, const _T & _Index) __GPU_ONLY
+        {
+            __dp_write_texture(_Tex_data, _Ret, static_cast<unsigned int>(_Index[0]), 1, 1);
+        }
+    };
+
+    template<typename _T>
+    struct _Texture_write_helper<_T, 2>
+    {
+        static void func(_Out_ void * _Tex_data, const void * _Ret, const _T & _Index) __GPU_ONLY
+        {
+            __dp_write_texture(_Tex_data, _Ret, static_cast<unsigned int>(_Index[1]), static_cast<unsigned int>(_Index[0]), 1);
+        }
+    };
+
+    template<typename _T>
+    struct _Texture_write_helper<_T, 3>
+    {
+        static void func(_Out_ void * _Tex_data, const void * _Ret, const _T & _Index) __GPU_ONLY
+        {
+            __dp_write_texture(_Tex_data, _Ret, static_cast<unsigned int>(_Index[2]), static_cast<unsigned int>(_Index[1]), static_cast<unsigned int>(_Index[0]));
+        }
+    };
+
+    template<typename _T, int _Rank>
+    struct _Texture_sample_helper;
+
+    // rank == 1
+    template<typename _T>
+    struct _Texture_sample_helper<_T, 1>
+    {
+        static void func(const void * _Tex_data, const void* _Sampler, _Out_ void * _Val, const _T & _Coord, unsigned int _Kind, float _Level_of_detail) __GPU_ONLY
+        {
+            __dp_sample_texture(_Tex_data, _Sampler, _Val, _Coord, 1.0f, 1.0f, _Kind, _Level_of_detail);
+        }
+    };
+
+    template<typename _T>
+    struct _Texture_sample_helper<_T, 2>
+    {
+        static void func(const void * _Tex_data, const void* _Sampler, _Out_ void * _Val, const _T & _Coord, unsigned int _Kind, float _Level_of_detail) __GPU_ONLY
+        {
+            __dp_sample_texture(_Tex_data, _Sampler, _Val, _Coord.x, _Coord.y, 1.0f, _Kind, _Level_of_detail);
+        }
+    };
+
+    template<typename _T>
+    struct _Texture_sample_helper<_T, 3>
+    {
+        static void func(const void * _Tex_data, const void* _Sampler, _Out_ void * _Val, const _T & _Coord, unsigned int _Kind, float _Level_of_detail) __GPU_ONLY
+        {
+            __dp_sample_texture(_Tex_data, _Sampler, _Val, _Coord.x, _Coord.y, _Coord.z, _Kind, _Level_of_detail);
+        }
+    };
+
+    template<typename _T, int _Rank>
+    struct _Texture_predefined_sample_helper;
+
+    // rank == 1
+    template<typename _T>
+    struct _Texture_predefined_sample_helper<_T, 1>
+    {
+        static void func(const void * _Tex_data, _Out_ void * _Val, const _T & _Coord, unsigned int _Predefined_sampler_id, unsigned int _Kind, float _Level_of_detail) __GPU_ONLY
+        {
+            __dp_sample_texture_predefined(_Tex_data, _Val, _Coord, 1.0f, 1.0f, _Predefined_sampler_id, _Kind, _Level_of_detail);
+        }
+    };
+
+    template<typename _T>
+    struct _Texture_predefined_sample_helper<_T, 2>
+    {
+        static void func(const void * _Tex_data, _Out_ void * _Val, const _T & _Coord, unsigned int _Predefined_sampler_id,unsigned  int _Kind, float _Level_of_detail) __GPU_ONLY
+        {
+            __dp_sample_texture_predefined(_Tex_data, _Val, _Coord.x, _Coord.y, 1.0f, _Predefined_sampler_id, _Kind, _Level_of_detail);
+        }
+    };
+
+    template<typename _T>
+    struct _Texture_predefined_sample_helper<_T, 3>
+    {
+        static void func(const void * _Tex_data, _Out_ void * _Val, const _T & _Coord, unsigned int _Predefined_sampler_id, unsigned int _Kind, float _Level_of_detail) __GPU_ONLY
+        {
+            __dp_sample_texture_predefined(_Tex_data, _Val, _Coord.x, _Coord.y, _Coord.z, _Predefined_sampler_id, _Kind, _Level_of_detail);
+        }
+    };
+
+
+    // Retrieve these fields from arrays
+    template <typename _Array_type>
+    const _Buffer_descriptor& _Get_buffer_descriptor(const _Array_type& _Array) __GPU
+    {
+        return _Array._M_buffer_descriptor;
+    }
+
+    template <typename _Array_type>
+    _Ret_ _Ubiquitous_buffer* _Get_buffer(const _Array_type& _Array) __CPU_ONLY
+    {
+        return _Array._Get_buffer();
+    }
+
+    // Helper method to access the private _Get_access method of the array
+    // object which gets access to the underlying buffer on the array's accelerator_view
+    // by synchronizing any pending modifications on other accelerator_views made through
+    // array_views on the array
+    template <typename _Array_type>
+    _Event _Get_access_async(const _Array_type& _Array, _Access_mode _Mode, _Buffer_ptr &_Buf_ptr) __CPU_ONLY
+    {
+        return _Array._Get_access_async(_Mode, _Buf_ptr);
+    }
+
+    // Helper method to obtain a unique ID for identifying the data source
+    // underlying the array/array_view argument
+    template <typename _Array_type>
+    void *_Get_datasource_identity(const _Array_type &_Array)
+    {
+        return _Get_buffer_descriptor(_Array)._Get_buffer_ptr()._Get_ptr();
+    }
+
+    // Retrieve these fields from textures
+    template <typename _Texture_type>
+    const _Texture_descriptor& _Get_texture_descriptor(const _Texture_type& _Tex) __GPU
+    {
+        return _Tex._M_texture_descriptor;
+    }
+
+    template <typename _Texture_type>
+    _Ret_ _Texture* _Get_texture(const _Texture_type& _Tex) __CPU_ONLY
+    {
+        return _Tex._Get_texture();
+    }
+
+    template<int _Rank, template <int> class _T>
+    static void _Is_positive(const _T<_Rank> &_Tuple) __CPU_ONLY
+    {
+        bool valid = true;
+        for (int i = 0; i < _Rank; ++i)
+        {
+            if (_Tuple[i] <= 0) {
+                valid = false;
+                break;
+            }
+        }
+
+        if (!valid) {
+            throw runtime_exception("Invalid - values for each dimension must be > 0", E_INVALIDARG);
+        }
+    }
+
+    // The GPU version is a no-op for since there is no good exception-like mechanism on GPU
+    template<int _Rank, template <int> class _T>
+    static void _Is_positive(const _T<_Rank> &/*_Tuple*/) __GPU_ONLY
+    {
+    }
+
+
+    template<int _Rank, template <int> class _T>
+    static void _Is_nonnegative(const _T<_Rank> &_Tuple) __CPU_ONLY
+    {
+        bool valid = true;
+        for (int i = 0; i < _Rank; ++i)
+        {
+            if (_Tuple[i] < 0) {
+                valid = false;
+                break;
+            }
+        }
+
+        if (!valid) {
+            throw runtime_exception("Invalid - values for each dimension must be >= 0", E_INVALIDARG);
+        }
+    }
+
+    // The GPU version is a no-op for since there is no good exception-like mechanism on GPU
+    template<int _Rank, template <int> class _T>
+    static void _Is_nonnegative(const _T<_Rank> & /*_Tuple*/) __GPU_ONLY
+    {
+    }
+
+    template<int _Rank, template <int> class _T1, template <int> class _T2>
+    static void _Is_valid_section(
+        const _T2<_Rank>& _Base_extent,
+        const _T1<_Rank>& _Section_origin,
+        const _T2<_Rank>& _Section_extent) __CPU_ONLY
+    {
+        _Is_nonnegative(_Section_origin);
+        _Is_positive(_Section_extent);
+
+        for (int i = 0; i < _Rank; ++i)
+        {
+            if ((_Section_origin[i] + _Section_extent[i]) > _Base_extent[i]) {
+                throw runtime_exception("the specified section index and extent are out of bound", E_INVALIDARG);
+            }
+        }
+    }
+
+    template<int _Rank, template <int> class _T1, template <int> class _T2>
+    static void _Is_valid_section(
+        const _T2<_Rank>& /*_Base_extent*/,
+        const _T1<_Rank>& /*_Section_origin*/,
+        const _T2<_Rank>& /*_Section_extent*/) __GPU_ONLY
+    {
+    };
+
+    template<int _Rank, template <int> class _T1>
+    static void _Is_valid_projection(int _I, const _T1<_Rank>& _Base_extent) __CPU_ONLY
+    {
+        if ((_I < 0) || (_I >= _Base_extent[0])) {
+            throw runtime_exception("the specified projection index is out of bound", E_INVALIDARG);
+        }
+    }
+
+    template<int _Rank, template <int> class _T1>
+    static void _Is_valid_projection(int /*_I*/, const _T1<_Rank>& /*_Base_extent*/) __GPU_ONLY
+    {
+    }
+
+
+    // An extent is valid if the value in each dimension is > 0 and the
+    // size of the extent does not exceed UINT_MAX
+    // Important: This needs to be revisited whenever we change the return
+    // type of extent.size()
+    template<int _Rank, template <int> class _T>
+    static void _Is_valid_extent(const _T<_Rank> &_Tuple) __CPU_ONLY
+    {
+        _Is_positive(_Tuple);
+
+        bool totalSizeValid = true;
+        unsigned long long totalSize = (unsigned long long)_Tuple[0];
+#pragma warning( push )
+#pragma warning( disable : 6294 )
+        for (int i = 1; i < _Rank; ++i)
+        {
+            totalSize *= (unsigned long long)_Tuple[i];
+            if (totalSize > UINT_MAX) {
+                totalSizeValid = false;
+                break;
+            }
+        }
+#pragma warning( pop )
+
+        if (!totalSizeValid) {
+            throw runtime_exception("Invalid - extent size exceeds UINT_MAX", E_INVALIDARG);
+        }
+    }
+
+    // The GPU version is a no-op for since there is no good exception-like mechanism on GPU
+    template<int _Rank, template <int> class _T>
+    static void _Is_valid_extent(const _T<_Rank> & /*_Tuple*/) __GPU_ONLY
+    {
+    }
+
+    template<int _Rank>
+    inline unsigned int _Get_max_mipmap_levels(const extent<_Rank> &_Extent)
+    {
+        unsigned int _Mipmap_levels = 0;
+
+        // Find the largest dimension
+        unsigned int _Max_dim = static_cast<unsigned int>(_Extent[0]);
+        for(int _I=1; _I<_Rank; ++_I)
+        {
+            _Max_dim = static_cast<unsigned int>(_Extent[_I]) > _Max_dim ? static_cast<unsigned int>(_Extent[_I]) : _Max_dim;
+        }
+
+        // Find out how many times we can divide it by 2
+        while(_Max_dim > 0)
+        {
+            _Mipmap_levels++;
+            _Max_dim >>= 1;
+        }
+
+        return _Mipmap_levels;
+    }
+
+    inline void _Are_valid_mipmap_parameters(unsigned int _Most_detailed_mipmap_level, unsigned int _Mipmap_levels = 0)
+    {
+        if (_Most_detailed_mipmap_level >= 32)
+        {
+            throw runtime_exception("The most detailed mipmap level cannot be greater than or equal to 32", E_INVALIDARG);
+        }
+
+        if (_Mipmap_levels > 32)
+        {
+            throw runtime_exception("The number of mipmap levels cannot be greater than 32", E_INVALIDARG);
+        }
+    }
+
+    template<int _Rank>
+    inline extent<_Rank> _Get_extent_at_level_unsafe(const extent<_Rank> &_Base_extent, unsigned int _Level) __GPU;
+
+    template<int _Rank>
+    inline extent<_Rank> _Get_extent_at_level(const extent<_Rank> &_Base_extent, unsigned int _Level);
+
+    // Validate most detailed level and mipmap levels of the new view, given number of mipmap levels on the source
+    inline void _Is_valid_mipmap_range(unsigned int _Src_view_mipmap_levels, unsigned int _Dst_most_detailed_level, unsigned int _Dst_view_mipmap_levels)
+    {
+        _Are_valid_mipmap_parameters(_Dst_most_detailed_level, _Dst_view_mipmap_levels);
+
+        if (_Dst_view_mipmap_levels == 0 || _Src_view_mipmap_levels < _Dst_most_detailed_level + _Dst_view_mipmap_levels)
+        {
+            throw runtime_exception("Invalid texture mipmap range", E_INVALIDARG);
+        }
+    }
+
+    // _Parallel_for_each declarations used by the Concurrency::parallel_for_each functions
+    template <int _Rank, typename _Kernel_type>
+    void _Parallel_for_each(_In_ _Host_Scheduling_info *_Sch_info, extent<_Rank> _Compute_domain, const _Kernel_type &_F);
+
+    template <int _Dim0, int _Dim1, int _Dim2, typename _Kernel_type>
+    void _Parallel_for_each(_In_ _Host_Scheduling_info *_Sch_info, tiled_extent<_Dim0, _Dim1, _Dim2> _Compute_domain, const _Kernel_type &_F);
+
+    template <int _Dim0, int _Dim1, typename _Kernel_type>
+    void _Parallel_for_each(_In_ _Host_Scheduling_info *_Sch_info, tiled_extent<_Dim0, _Dim1> _Compute_domain, const _Kernel_type &_F);
+
+    template <int _Dim0, typename _Kernel_type>
+    void _Parallel_for_each(_In_ _Host_Scheduling_info *_Sch_info, tiled_extent<_Dim0> _Compute_domain, const _Kernel_type &_F);
+
+} // namespace Concurrency::details
+
+} // namespace Concurrency
+
+//=============================================================================
+// Internal Intrinsic Functions used for implementing libraries
+//=============================================================================
+
+extern "C"
+{
+
+//=============================================================================
+// Intrinsics that maps to D3D HLSL intrinsics
+//=============================================================================
+int __dp_d3d_absi(int) __GPU_ONLY;
+void __dp_d3d_all_memory_fence() __GPU_ONLY;
+void __dp_d3d_all_memory_fence_with_tile_barrier() __GPU_ONLY;
+float __dp_d3d_clampf(float, float, float) __GPU_ONLY;
+int __dp_d3d_clampi(int, int, int) __GPU_ONLY;
+unsigned int __dp_d3d_countbitsu(unsigned int) __GPU_ONLY;
+void __dp_d3d_device_memory_fence() __GPU_ONLY;
+void __dp_d3d_device_memory_fence_with_tile_barrier() __GPU_ONLY;
+int __dp_d3d_firstbithighi(int) __GPU_ONLY;
+int __dp_d3d_firstbitlowi(int) __GPU_ONLY;
+unsigned int __dp_d3d_interlocked_add(_Inout_ unsigned int *, unsigned int) __GPU_ONLY;
+unsigned int __dp_d3d_interlocked_and(_Inout_ unsigned int *, unsigned int) __GPU_ONLY;
+unsigned int __dp_d3d_interlocked_exchange(_Inout_ unsigned int *, unsigned int) __GPU_ONLY;
+unsigned int __dp_d3d_interlocked_or(_Inout_ unsigned int *, unsigned int) __GPU_ONLY;
+unsigned int __dp_d3d_interlocked_xor(_Inout_ unsigned int *, unsigned int) __GPU_ONLY;
+unsigned int __dp_d3d_interlocked_compare_exchange(_Inout_ unsigned int *, unsigned int, unsigned int) __GPU_ONLY;
+unsigned int __dp_d3d_interlocked_max_uint(_Inout_ unsigned int *, unsigned int) __GPU_ONLY;
+int __dp_d3d_interlocked_max_int(_Inout_ int *, int) __GPU_ONLY;
+unsigned int __dp_d3d_interlocked_min_uint(_Inout_ unsigned int *, unsigned int) __GPU_ONLY;
+int __dp_d3d_interlocked_min_int(_Inout_ int *, int) __GPU_ONLY;
+float __dp_d3d_madf(float, float, float) __GPU_ONLY;
+double __dp_d3d_madd(double, double, double) __GPU_ONLY;
+int __dp_d3d_madi(int, int, int) __GPU_ONLY;
+int __dp_d3d_mini(int, int) __GPU_ONLY;
+int __dp_d3d_maxi(int, int) __GPU_ONLY;
+unsigned int __dp_d3d_minu(unsigned int, unsigned int) __GPU_ONLY;
+unsigned int __dp_d3d_maxu(unsigned int, unsigned int) __GPU_ONLY;
+unsigned int __dp_d3d_madu(unsigned int, unsigned int, unsigned int) __GPU_ONLY;
+float __dp_d3d_noisef(float) __GPU_ONLY;
+float __dp_d3d_radiansf(float) __GPU_ONLY;
+float __dp_d3d_rcpf(float) __GPU_ONLY;
+unsigned int __dp_d3d_reversebitsu(unsigned int) __GPU_ONLY;
+float __dp_d3d_saturatef (float) __GPU_ONLY;
+int __dp_d3d_signi(int) __GPU_ONLY;
+float __dp_d3d_smoothstepf(float, float, float) __GPU_ONLY;
+float __dp_d3d_stepf(float, float) __GPU_ONLY;
+void __dp_d3d_tile_static_memory_fence() __GPU_ONLY;
+void __dp_d3d_tile_static_memory_fence_with_tile_barrier() __GPU_ONLY;
+void __dp_d3d_msad4(_Out_ unsigned int * /* pointer to the return value */,
+                    unsigned int /* reference */,
+                    unsigned int /* source.x */,
+                    unsigned int /* source.y */,
+                    unsigned int /* accum.x */,
+                    unsigned int /* accum.y */,
+                    unsigned int /* accum.z */,
+                    unsigned int /* accum.w */) __GPU_ONLY;
+
+//=============================================================================
+// Intrinsics that serves as FE/BE interface
+//=============================================================================
+
+// C++ AMP stub only internal intrinsics
+void __dp_stub_info(unsigned int /* x */,
+                    unsigned int /* y */,
+                    unsigned int /* z */,
+                    unsigned int /* group forall? */) __GPU_ONLY;
+
+_Ret_ void * __dp_get_buffer_info(bool /* read write? */,
+                            unsigned int /* unique id */) __GPU_ONLY;
+
+_Ret_ void * __dp_get_texture_info(bool /* read write? */,
+                             unsigned int, /* rank */
+                             unsigned int, /* base type: 0 - int, 1 - uint, 2 - float*/
+                             unsigned int, /* num of channels */
+                             unsigned int /* unique id */) __GPU_ONLY;
+
+_Ret_ void * __dp_get_sampler_info(unsigned int /* unique id */) __GPU_ONLY;
+
+void __dp_init_entry_var(_Out_ unsigned int * /* pointer to the entry symbol */,
+                         unsigned int /* constant buffer id */,
+                         unsigned int /* start pos */,
+                         unsigned int /* end pos */) __GPU_ONLY;
+
+void __dp_entry_var_ptr_info(unsigned int /* pos of a ptr */) __GPU_ONLY;
+
+void __dp_const_buffer_info(unsigned int /* unique id */, unsigned int /* size */) __GPU_ONLY;
+
+unsigned int __dp_read_const_buffer(unsigned int /* const buffer id */, unsigned int /* index */) __GPU_ONLY;
+
+unsigned int __dp_get_physical_id(
+        unsigned int /* 0 - gid, 1 - tid, 2 - dtid */,
+        unsigned int /* 0 - x, 1 - y, 2 - z */) __GPU_ONLY;
+
+// This intrinsic is used to aid line number debug info generation for C++ AMP kernels
+void __dp_no_source_stub() __GPU_ONLY;
+
+// This intrinsic is used to pass the call site info
+void __dp_call_site_info(const char *, int) __GPU_ONLY;
+}
+
+namespace Concurrency
+{
+    namespace details
+    {
+        // This function is used to aid line number debug info generation for C++ AMP kernels
+        // and is called by the C++ AMP FE in the generated kernel_stub for parallel_for_each calls.
+        inline void __dp_no_source_func() __GPU_ONLY
+        {
+            __dp_no_source_stub();
+        }
+    }
+}
+
+namespace concurrency = Concurrency;
+
+#pragma pack(pop)
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xxamp_inl.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xxamp_inl.h
new file mode 100644
index 0000000000000000000000000000000000000000..6cede47d591f4a36b3534133c13bf20d430cdc6d
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/xxamp_inl.h
@@ -0,0 +1,153 @@
+/***
+* ==++==
+*
+* Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+* ==--==
+* =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+*
+* xxamp_inl.h
+*
+* C++ AMP Library helper classes implementations.
+*
+* This file contains the bodies of methods declared in xxamp which rely on
+* amp.h class definitions.
+*
+* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+****/
+
+#pragma once
+
+#ifndef _SILENCE_AMP_DEPRECATION_WARNINGS
+#error <xxamp_inl.h> is part of C++ AMP which is deprecated by Microsoft and will be REMOVED. \
+You can define _AMP_SILENCE_DEPRECATION_WARNINGS to acknowledge that you have received this warning.
+#endif // _SILENCE_AMP_DEPRECATION_WARNINGS
+
+#include <xxamp.h>
+
+
+namespace Concurrency
+{
+namespace details
+{
+
+// Projection Helpers
+
+template <typename _T, int _R>
+/*static*/ inline typename _Projection_result_type<_T,_R>::_Const_result_type
+_Const_array_view_projection_helper<_T,_R>::_Project0(const array_view<const _T,_R>* _Arr_view, int _I) __GPU
+{
+    typename _Projection_result_type<_T,_R>::_Const_result_type _Projected_view;
+    _Arr_view->_Project0(_I, _Projected_view);
+    return _Projected_view;
+}
+
+template <typename _T, int _R>
+/*static*/ inline typename _Projection_result_type<_T,_R>::_Result_type
+_Array_view_projection_helper<_T,_R>::_Project0(const array_view<_T,_R>* _Arr_view, int _I) __GPU
+{
+    typename _Projection_result_type<_T,_R>::_Result_type _Projected_view;
+    _Arr_view->_Project0(_I, _Projected_view);
+    return _Projected_view;
+}
+
+template <typename _T>
+/*static*/ inline typename _Projection_result_type<_T,1>::_Const_result_type
+_Const_array_view_projection_helper<_T,1>::_Project0(const array_view<const _T,1>* _Arr_view, int _I) __GPU
+{
+    return _Arr_view->operator[](index<1>(_I));
+}
+
+template <typename _T>
+/*static*/ inline typename _Projection_result_type<_T,1>::_Result_type
+_Array_view_projection_helper<_T,1>::_Project0(const array_view<_T,1>* _Arr_view, int _I) __GPU
+{
+    return _Arr_view->operator[](index<1>(_I));
+}
+
+template <typename _T, int _R>
+/*static*/ inline typename _Projection_result_type<_T,_R>::_Const_result_type
+_Const_array_projection_helper<_T,_R>::_Project0(const array<_T, _R>* _Array, int _I) __GPU
+{
+    array_view<const _T,_R> _Temp(*_Array);
+    return _Const_array_view_projection_helper<_T,_R>::_Project0(&_Temp, _I);
+}
+
+template <typename _T, int _R>
+/*static*/ inline typename _Projection_result_type<_T,_R>::_Result_type
+_Array_projection_helper<_T,_R>::_Project0(_In_ array<_T, _R>* _Array, int _I) __GPU
+{
+    array_view<_T,_R> _Temp(*_Array);
+    return _Array_view_projection_helper<_T,_R>::_Project0(&_Temp, _I);
+}
+
+template <typename _T>
+/*static*/ inline typename _Projection_result_type<_T,1>::_Const_result_type
+_Const_array_projection_helper<_T,1>::_Project0(const array<_T,1>* _Array, int _I) __GPU
+{
+    return _Array->operator[](index<1>(_I));
+}
+
+template <typename _T>
+/*static*/ inline typename _Projection_result_type<_T,1>::_Result_type
+_Array_projection_helper<_T,1>::_Project0(_In_ array<_T,1>* _Array, int _I) __GPU
+{
+    return _Array->operator[](index<1>(_I));
+}
+
+// Calculate the extent dimensions at selected mipmap level given base extent
+template<int _Rank>
+inline extent<_Rank> _Get_extent_at_level_unsafe(const extent<_Rank> &_Base_extent, unsigned int _Level) __GPU
+{
+    static_assert(_Rank >= 3, "_Rank >= 3");
+}
+
+template<>
+inline extent<1> _Get_extent_at_level_unsafe<1>(const extent<1> &_Base_extent, unsigned int _Level) __GPU
+{
+    extent<1> _Extent_at_level(_Base_extent);
+
+    _Extent_at_level[0] >>= _Level;
+    _Extent_at_level[0] = _Extent_at_level[0] ? _Extent_at_level[0] : 1;
+
+    return _Extent_at_level;
+}
+
+template<>
+inline extent<2> _Get_extent_at_level_unsafe<2>(const extent<2> &_Base_extent, unsigned int _Level) __GPU
+{
+    extent<2> _Extent_at_level(_Base_extent);
+
+    _Extent_at_level[0] >>= _Level;
+    _Extent_at_level[1] >>= _Level;
+    _Extent_at_level[0] = _Extent_at_level[0] ? _Extent_at_level[0] : 1;
+    _Extent_at_level[1] = _Extent_at_level[1] ? _Extent_at_level[1] : 1;
+
+    return _Extent_at_level;
+}
+
+template<>
+inline extent<3> _Get_extent_at_level_unsafe<3>(const extent<3> &_Base_extent, unsigned int _Level) __GPU
+{
+    extent<3> _Extent_at_level(_Base_extent);
+
+    _Extent_at_level[0] >>= _Level;
+    _Extent_at_level[1] >>= _Level;
+    _Extent_at_level[2] >>= _Level;
+    _Extent_at_level[0] = _Extent_at_level[0] ? _Extent_at_level[0] : 1;
+    _Extent_at_level[1] = _Extent_at_level[1] ? _Extent_at_level[1] : 1;
+    _Extent_at_level[2] = _Extent_at_level[2] ? _Extent_at_level[2] : 1;
+
+    return _Extent_at_level;
+}
+
+// Calculate the extent dimensions at selected mipmap level given base extent
+template<int _Rank>
+inline extent<_Rank> _Get_extent_at_level(const extent<_Rank> &_Base_extent, unsigned int _Level)
+{
+    _Are_valid_mipmap_parameters(_Level);
+    return _Get_extent_at_level_unsafe(_Base_extent, _Level);
+}
+
+} // namespace details
+} // namespace concurrency
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/ymath.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/ymath.h
new file mode 100644
index 0000000000000000000000000000000000000000..6c1adbe4421f4a8f84aec8da6327d586a53ba039
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/ymath.h
@@ -0,0 +1,43 @@
+// ymath.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _YMATH
+#define _YMATH
+#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
+
+_EXTERN_C_UNLESS_PURE
+
+// macros for _Dtest return (0 => ZERO)
+#define _INFCODE 1
+#define _NANCODE 2
+
+_CRTIMP2_PURE double __CLRCALL_PURE_OR_CDECL _Cosh(double, double) noexcept;
+_CRTIMP2_PURE double __CLRCALL_PURE_OR_CDECL _Sinh(double, double) noexcept;
+_CRTIMP2_PURE short __CLRCALL_PURE_OR_CDECL _Exp(double*, double, short) noexcept;
+
+_CRTIMP2_PURE float __CLRCALL_PURE_OR_CDECL _FCosh(float, float) noexcept;
+_CRTIMP2_PURE float __CLRCALL_PURE_OR_CDECL _FSinh(float, float) noexcept;
+_CRTIMP2_PURE short __CLRCALL_PURE_OR_CDECL _FExp(float*, float, short) noexcept;
+
+_CRTIMP2_PURE long double __CLRCALL_PURE_OR_CDECL _LCosh(long double, long double) noexcept;
+_CRTIMP2_PURE short __CLRCALL_PURE_OR_CDECL _LDtest(long double*) noexcept;
+_CRTIMP2_PURE long double __CLRCALL_PURE_OR_CDECL _LSinh(long double, long double) noexcept;
+_CRTIMP2_PURE short __CLRCALL_PURE_OR_CDECL _LExp(long double*, long double, short) noexcept;
+
+_END_EXTERN_C_UNLESS_PURE
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _YMATH
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/yvals.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/yvals.h
new file mode 100644
index 0000000000000000000000000000000000000000..33ac7c512032ddd2898059c8378418ffeb189267
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/yvals.h
@@ -0,0 +1,466 @@
+// yvals.h 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 => yvals.h).
+// MAJOR LIMITATIONS apply to what can be included here!
+// Before editing this file, read: /docs/import_library.md
+
+#ifndef _YVALS
+#define _YVALS
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#ifdef _ENFORCE_ONLY_CORE_HEADERS
+_EMIT_STL_ERROR(
+    STL1005, "Tried to include a non-core C++ Standard Library header file with _ENFORCE_ONLY_CORE_HEADERS defined.");
+#endif // defined(_ENFORCE_ONLY_CORE_HEADERS)
+
+#include <crtdbg.h>
+#include <crtdefs.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
+
+#if defined(MRTDLL) && defined(_CRTBLD)
+// process-global is the default for code built with /clr or /clr:oldSyntax.
+// appdomain-global is the default for code built with /clr:pure.
+// Code in MSVCM is built with /clr, but is used by user code built with /clr:pure
+// so it must conform to the expectations of /clr:pure clients.
+// Use __PURE_APPDOMAIN_GLOBAL when a global needs to be appdomain-global for pure
+// clients and process-global for mixed clients.
+#define __PURE_APPDOMAIN_GLOBAL __declspec(appdomain)
+#else
+#define __PURE_APPDOMAIN_GLOBAL
+#endif
+
+#ifndef _CRT_MSVCP_CURRENT
+#ifdef _CRT_WINDOWS
+// Windows
+#ifdef _DEBUG
+#define _CRT_MSVCP_CURRENT "msvcpd_win.dll"
+#else
+#define _CRT_MSVCP_CURRENT "msvcp_win.dll"
+#endif
+#else // ^^^ defined(_CRT_WINDOWS) / !defined(_CRT_WINDOWS) vvv
+// Visual Studio
+#ifdef _DEBUG
+#define _CRT_MSVCP_CURRENT "msvcp140d.dll"
+#else
+#define _CRT_MSVCP_CURRENT "msvcp140.dll"
+#endif
+#endif // ^^^ !defined(_CRT_WINDOWS) ^^^
+#endif // !defined(_CRT_MSVCP_CURRENT)
+
+#ifdef _ITERATOR_DEBUG_LEVEL // A. _ITERATOR_DEBUG_LEVEL is already defined.
+
+// A1. Validate _ITERATOR_DEBUG_LEVEL.
+#if _ITERATOR_DEBUG_LEVEL > 2 && defined(_DEBUG)
+#error _ITERATOR_DEBUG_LEVEL > 2 is not supported in debug mode.
+#elif _ITERATOR_DEBUG_LEVEL > 1 && !defined(_DEBUG)
+#error _ITERATOR_DEBUG_LEVEL > 1 is not supported in release mode.
+#endif
+
+// A2. Inspect _HAS_ITERATOR_DEBUGGING.
+#ifdef _HAS_ITERATOR_DEBUGGING // A2i. _HAS_ITERATOR_DEBUGGING is already defined, validate it.
+#if _ITERATOR_DEBUG_LEVEL == 2 && _HAS_ITERATOR_DEBUGGING != 1
+#error _ITERATOR_DEBUG_LEVEL == 2 must imply _HAS_ITERATOR_DEBUGGING == 1.
+#elif _ITERATOR_DEBUG_LEVEL < 2 && _HAS_ITERATOR_DEBUGGING != 0
+#error _ITERATOR_DEBUG_LEVEL < 2 must imply _HAS_ITERATOR_DEBUGGING == 0.
+#endif
+#else // A2ii. _HAS_ITERATOR_DEBUGGING is not yet defined, derive it.
+#if _ITERATOR_DEBUG_LEVEL == 2
+#define _HAS_ITERATOR_DEBUGGING 1
+#else
+#define _HAS_ITERATOR_DEBUGGING 0
+#endif
+#endif // ^^^ !defined(_HAS_ITERATOR_DEBUGGING) ^^^
+
+// A3. Inspect _SECURE_SCL.
+#ifdef _SECURE_SCL // A3i. _SECURE_SCL is already defined, validate it.
+#if _ITERATOR_DEBUG_LEVEL > 0 && _SECURE_SCL != 1
+#error _ITERATOR_DEBUG_LEVEL > 0 must imply _SECURE_SCL == 1.
+#elif _ITERATOR_DEBUG_LEVEL == 0 && _SECURE_SCL != 0
+#error _ITERATOR_DEBUG_LEVEL == 0 must imply _SECURE_SCL == 0.
+#endif
+#else // A3ii. _SECURE_SCL is not yet defined, derive it.
+#if _ITERATOR_DEBUG_LEVEL > 0
+#define _SECURE_SCL 1
+#else
+#define _SECURE_SCL 0
+#endif
+#endif // ^^^ !defined(_SECURE_SCL) ^^^
+
+#else // B. _ITERATOR_DEBUG_LEVEL is not yet defined.
+
+// B1. Inspect _HAS_ITERATOR_DEBUGGING.
+#ifdef _HAS_ITERATOR_DEBUGGING // B1i. _HAS_ITERATOR_DEBUGGING is already defined, validate it.
+#if _HAS_ITERATOR_DEBUGGING > 1
+#error _HAS_ITERATOR_DEBUGGING must be either 0 or 1.
+#elif _HAS_ITERATOR_DEBUGGING == 1 && !defined(_DEBUG)
+#error _HAS_ITERATOR_DEBUGGING == 1 is not supported in release mode.
+#endif
+#else // B1ii. _HAS_ITERATOR_DEBUGGING is not yet defined, default it.
+#ifdef _DEBUG
+#define _HAS_ITERATOR_DEBUGGING 1
+#else
+#define _HAS_ITERATOR_DEBUGGING 0
+#endif
+#endif // ^^^ !defined(_HAS_ITERATOR_DEBUGGING) ^^^
+
+// B2. Inspect _SECURE_SCL.
+#ifdef _SECURE_SCL // B2i. _SECURE_SCL is already defined, validate it.
+#if _SECURE_SCL > 1
+#error _SECURE_SCL must be either 0 or 1.
+#endif
+#else // B2ii. _SECURE_SCL is not yet defined, default it.
+#if _HAS_ITERATOR_DEBUGGING == 1
+#define _SECURE_SCL 1
+#else
+#define _SECURE_SCL 0
+#endif
+#endif // ^^^ !defined(_SECURE_SCL) ^^^
+
+// B3. Derive _ITERATOR_DEBUG_LEVEL.
+#if _HAS_ITERATOR_DEBUGGING
+#define _ITERATOR_DEBUG_LEVEL 2
+#elif _SECURE_SCL
+#define _ITERATOR_DEBUG_LEVEL 1
+#else // ^^^ _SECURE_SCL / !_SECURE_SCL vvv
+#define _ITERATOR_DEBUG_LEVEL 0
+#endif // ^^^ !_HAS_ITERATOR_DEBUGGING && !_SECURE_SCL ^^^
+
+#endif // ^^^ !defined(_ITERATOR_DEBUG_LEVEL) ^^^
+
+#ifndef _ALLOW_MSC_VER_MISMATCH
+#pragma detect_mismatch("_MSC_VER", "1900")
+#endif // !defined(_ALLOW_MSC_VER_MISMATCH)
+
+#ifndef _ALLOW_ITERATOR_DEBUG_LEVEL_MISMATCH
+#pragma detect_mismatch("_ITERATOR_DEBUG_LEVEL", _STL_STRINGIZE(_ITERATOR_DEBUG_LEVEL))
+#endif // !defined(_ALLOW_ITERATOR_DEBUG_LEVEL_MISMATCH)
+
+#ifndef _ALLOW_RUNTIME_LIBRARY_MISMATCH
+#if !defined(_DLL) && !defined(_DEBUG)
+#pragma detect_mismatch("RuntimeLibrary", "MT_StaticRelease")
+#elif !defined(_DLL) && defined(_DEBUG)
+#pragma detect_mismatch("RuntimeLibrary", "MTd_StaticDebug")
+#elif defined(_DLL) && !defined(_DEBUG)
+#pragma detect_mismatch("RuntimeLibrary", "MD_DynamicRelease")
+#elif defined(_DLL) && defined(_DEBUG)
+#pragma detect_mismatch("RuntimeLibrary", "MDd_DynamicDebug")
+#endif // defined(_DLL) etc.
+#endif // !defined(_ALLOW_RUNTIME_LIBRARY_MISMATCH)
+
+#ifndef _CONTAINER_DEBUG_LEVEL
+#if _ITERATOR_DEBUG_LEVEL == 0
+#define _CONTAINER_DEBUG_LEVEL 0
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 0 / _ITERATOR_DEBUG_LEVEL != 0 vvv
+#define _CONTAINER_DEBUG_LEVEL 1
+#endif // _ITERATOR_DEBUG_LEVEL == 0
+#endif // !defined(_CONTAINER_DEBUG_LEVEL)
+
+#if _ITERATOR_DEBUG_LEVEL != 0 && _CONTAINER_DEBUG_LEVEL == 0
+#error _ITERATOR_DEBUG_LEVEL != 0 must imply _CONTAINER_DEBUG_LEVEL == 1.
+#endif // _ITERATOR_DEBUG_LEVEL != 0 && _CONTAINER_DEBUG_LEVEL == 0
+
+#ifndef _STL_CRT_SECURE_INVALID_PARAMETER
+#ifdef _STL_CALL_ABORT_INSTEAD_OF_INVALID_PARAMETER
+#define _STL_CRT_SECURE_INVALID_PARAMETER(expr) _CSTD abort()
+#elif defined(_DEBUG) // Avoid emitting unused long strings for function names; see GH-1956.
+// static_cast<unsigned int>(__LINE__) avoids warning C4365 (signed/unsigned mismatch) with the /ZI compiler option.
+#define _STL_CRT_SECURE_INVALID_PARAMETER(expr) \
+    ::_invalid_parameter(_CRT_WIDE(#expr), L"", __FILEW__, static_cast<unsigned int>(__LINE__), 0)
+#else // ^^^ defined(_DEBUG) / !defined(_DEBUG) vvv
+#define _STL_CRT_SECURE_INVALID_PARAMETER(expr) _CRT_SECURE_INVALID_PARAMETER(expr)
+#endif // ^^^ !defined(_DEBUG) ^^^
+#endif // !defined(_STL_CRT_SECURE_INVALID_PARAMETER)
+
+#define _STL_REPORT_ERROR(mesg)                  \
+    do {                                         \
+        _RPTF0(_CRT_ASSERT, mesg);               \
+        _STL_CRT_SECURE_INVALID_PARAMETER(mesg); \
+    } while (false)
+
+#ifdef __clang__
+#define _STL_VERIFY(cond, mesg)                                                            \
+    _Pragma("clang diagnostic push") _Pragma("clang diagnostic ignored \"-Wassume\"") do { \
+        if (cond) { /* contextually convertible to bool paranoia */                        \
+        } else {                                                                           \
+            _STL_REPORT_ERROR(mesg);                                                       \
+        }                                                                                  \
+                                                                                           \
+        _Analysis_assume_(cond);                                                           \
+    }                                                                                      \
+    while (false)                                                                          \
+    _Pragma("clang diagnostic pop")
+#else // ^^^ Clang / MSVC vvv
+#define _STL_VERIFY(cond, mesg)                                     \
+    do {                                                            \
+        if (cond) { /* contextually convertible to bool paranoia */ \
+        } else {                                                    \
+            _STL_REPORT_ERROR(mesg);                                \
+        }                                                           \
+                                                                    \
+        _Analysis_assume_(cond);                                    \
+    } while (false)
+#endif // ^^^ MSVC ^^^
+
+#ifdef _DEBUG
+#define _STL_ASSERT(cond, mesg) _STL_VERIFY(cond, mesg)
+#else // ^^^ defined(_DEBUG) / !defined(_DEBUG) vvv
+#define _STL_ASSERT(cond, mesg) _Analysis_assume_(cond)
+#endif // ^^^ !defined(_DEBUG) ^^^
+
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+#define _STL_INTERNAL_CHECK(...) _STL_VERIFY(__VA_ARGS__, "STL internal check: " #__VA_ARGS__)
+#else // ^^^ defined(_ENABLE_STL_INTERNAL_CHECK) / !defined(_ENABLE_STL_INTERNAL_CHECK) vvv
+#define _STL_INTERNAL_CHECK(...) _Analysis_assume_(__VA_ARGS__)
+#endif // ^^^ !defined(_ENABLE_STL_INTERNAL_CHECK) ^^^
+
+#ifndef _ENABLE_ATOMIC_REF_ALIGNMENT_CHECK
+#ifdef _DEBUG
+#define _ENABLE_ATOMIC_REF_ALIGNMENT_CHECK 1
+#else // ^^^ defined(_DEBUG) / !defined(_DEBUG) vvv
+#define _ENABLE_ATOMIC_REF_ALIGNMENT_CHECK 0
+#endif // ^^^ !defined(_DEBUG) ^^^
+#endif // !defined(_ENABLE_ATOMIC_REF_ALIGNMENT_CHECK)
+
+#if _ENABLE_ATOMIC_REF_ALIGNMENT_CHECK
+#define _ATOMIC_REF_CHECK_ALIGNMENT(cond, mesg) _STL_VERIFY(cond, mesg)
+#else
+#define _ATOMIC_REF_CHECK_ALIGNMENT(cond, mesg) _Analysis_assume_(cond)
+#endif
+
+#include <use_ansi.h>
+
+#ifdef _STATIC_CPPLIB
+#ifndef _DISABLE_DEPRECATE_STATIC_CPPLIB
+#ifdef _DLL
+_EMIT_STL_WARNING(STL4000, "_STATIC_CPPLIB is deprecated and will be REMOVED.");
+#endif
+#ifdef _M_CEE_MIXED
+#error _STATIC_CPPLIB is not supported while building with /clr
+#endif
+#endif // !defined(_DISABLE_DEPRECATE_STATIC_CPPLIB)
+#ifdef _M_CEE_PURE
+#error _STATIC_CPPLIB cannot be used with /clr:pure (the resulting assembly would not be pure)
+#endif
+#endif // defined(_STATIC_CPPLIB)
+
+#if defined(_M_CEE_PURE) && !defined(_SILENCE_CLR_PURE_DEPRECATION_WARNING)
+_EMIT_STL_WARNING(STL4001, "/clr:pure is deprecated and will be REMOVED.");
+#endif
+
+#ifndef _MRTIMP2_PURE
+#ifdef _M_CEE_PURE
+#define _MRTIMP2_PURE
+#else
+#define _MRTIMP2_PURE _MRTIMP2
+#endif
+#endif // !defined(_MRTIMP2_PURE)
+
+#if defined(_DLL) && !defined(_STATIC_CPPLIB) && !defined(_M_CEE_PURE)
+#define _DLL_CPPLIB
+#endif
+
+#ifndef _CRTIMP2_PURE
+#ifdef _M_CEE_PURE
+#define _CRTIMP2_PURE
+#else
+#define _CRTIMP2_PURE _CRTIMP2
+#endif
+#endif // !defined(_CRTIMP2_PURE)
+
+#ifndef _CRTIMP2_IMPORT
+#if defined(CRTDLL2) && defined(_CRTBLD)
+#define _CRTIMP2_IMPORT __declspec(dllexport)
+#elif defined(_DLL) && !defined(_STATIC_CPPLIB)
+#define _CRTIMP2_IMPORT __declspec(dllimport)
+#else // ^^^ defined(_DLL) && !defined(_STATIC_CPPLIB) / !defined(_DLL) || defined(_STATIC_CPPLIB) vvv
+#define _CRTIMP2_IMPORT
+#endif // ^^^ !defined(_DLL) || defined(_STATIC_CPPLIB) ^^^
+#endif // !defined(_CRTIMP2_IMPORT)
+
+#ifndef _CRTIMP2_PURE_IMPORT
+#ifdef _M_CEE_PURE
+#define _CRTIMP2_PURE_IMPORT
+#else
+#define _CRTIMP2_PURE_IMPORT _CRTIMP2_IMPORT
+#endif
+#endif // !defined(_CRTIMP2_PURE_IMPORT)
+
+#ifndef _CRTIMP2_PURE_IMPORT_UNLESS_CODECVT_ID_SATELLITE
+#ifdef _BUILDING_SATELLITE_CODECVT_IDS
+#define _CRTIMP2_PURE_IMPORT_UNLESS_CODECVT_ID_SATELLITE
+#else
+#define _CRTIMP2_PURE_IMPORT_UNLESS_CODECVT_ID_SATELLITE _CRTIMP2_PURE_IMPORT
+#endif
+#endif // !defined(_CRTIMP2_PURE_IMPORT_UNLESS_CODECVT_ID_SATELLITE)
+
+#ifndef _CRTDATA2_IMPORT
+#if defined(MRTDLL) && defined(_CRTBLD)
+#define _CRTDATA2_IMPORT
+#else
+#define _CRTDATA2_IMPORT _CRTIMP2_IMPORT
+#endif
+#endif // !defined(_CRTDATA2_IMPORT)
+
+#define _LOCK_LOCALE 0
+#define _LOCK_STREAM 2
+#define _LOCK_DEBUG  3
+
+_STD_BEGIN
+enum _Uninitialized { // tag for suppressing initialization
+    _Noinit
+};
+
+extern "C++" class _CRTIMP2_PURE_IMPORT _Lockit { // lock while object in existence -- MUST NEST
+public:
+#ifdef _M_CEE_PURE
+    __CLR_OR_THIS_CALL _Lockit() noexcept : _Locktype(0) {
+        _Lockit_ctor(this);
+    }
+
+    explicit __CLR_OR_THIS_CALL _Lockit(int _Kind) noexcept { // set the lock
+        _Lockit_ctor(this, _Kind);
+    }
+
+    __CLR_OR_THIS_CALL ~_Lockit() noexcept { // clear the lock
+        _Lockit_dtor(this);
+    }
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+    __thiscall _Lockit() noexcept;
+    explicit __thiscall _Lockit(int) noexcept; // set the lock
+    __thiscall ~_Lockit() noexcept; // clear the lock
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+
+    static void __cdecl _Lockit_ctor(int) noexcept;
+    static void __cdecl _Lockit_dtor(int) noexcept;
+
+private:
+    static void __cdecl _Lockit_ctor(_Lockit*) noexcept;
+    static void __cdecl _Lockit_ctor(_Lockit*, int) noexcept;
+    static void __cdecl _Lockit_dtor(_Lockit*) noexcept;
+
+public:
+    __CLR_OR_THIS_CALL _Lockit(const _Lockit&)            = delete;
+    _Lockit& __CLR_OR_THIS_CALL operator=(const _Lockit&) = delete;
+
+private:
+    int _Locktype;
+};
+
+#ifdef _M_CEE_PURE
+class _CRTIMP2_PURE_IMPORT _EmptyLockit { // empty lock class used for bin compat
+private:
+    int _Locktype;
+};
+#endif // defined(_M_CEE_PURE)
+
+#ifdef _M_CEE
+#ifndef _PREPARE_CONSTRAINED_REGIONS
+#ifdef _M_CEE_PURE
+#define _PREPARE_CONSTRAINED_REGIONS 1
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+#define _PREPARE_CONSTRAINED_REGIONS 0
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+#endif // !defined(_PREPARE_CONSTRAINED_REGIONS)
+
+#if _PREPARE_CONSTRAINED_REGIONS
+#define _BEGIN_LOCK(_Kind)                                                                  \
+    {                                                                                       \
+        bool _MustReleaseLock = false;                                                      \
+        int _LockKind         = _Kind;                                                      \
+        System::Runtime::CompilerServices::RuntimeHelpers::PrepareConstrainedRegions();     \
+        try {                                                                               \
+            System::Runtime::CompilerServices::RuntimeHelpers::PrepareConstrainedRegions(); \
+            try {                                                                           \
+            } finally {                                                                     \
+                _STD _Lockit::_Lockit_ctor(_LockKind);                                      \
+                _MustReleaseLock = true;                                                    \
+            }
+
+#define _END_LOCK()                                \
+    }                                              \
+    finally {                                      \
+        if (_MustReleaseLock) {                    \
+            _STD _Lockit::_Lockit_dtor(_LockKind); \
+        }                                          \
+    }                                              \
+    }
+
+#else // ^^^ _PREPARE_CONSTRAINED_REGIONS / !_PREPARE_CONSTRAINED_REGIONS vvv
+#define _BEGIN_LOCK(_Kind) \
+    {                      \
+        _STD _Lockit _Lock(_Kind);
+
+#define _END_LOCK() }
+
+#endif // ^^^ !_PREPARE_CONSTRAINED_REGIONS ^^^
+
+#define _BEGIN_LOCINFO(_VarName) \
+    _BEGIN_LOCK(_LOCK_LOCALE)    \
+    _Locinfo _VarName;
+
+#define _END_LOCINFO() _END_LOCK()
+
+#else // ^^^ defined(_M_CEE) / !defined(_M_CEE) vvv
+#define _BEGIN_LOCK(_Kind) \
+    {                      \
+        _STD _Lockit _Lock(_Kind);
+
+#define _END_LOCK() }
+
+#define _BEGIN_LOCINFO(_VarName) \
+    {                            \
+        _Locinfo _VarName;
+
+#define _END_LOCINFO() }
+#endif // ^^^ !defined(_M_CEE) ^^^
+
+#if _HAS_EXCEPTIONS
+#define _TRY_BEGIN try {
+#define _CATCH(x) \
+    }             \
+    catch (x) {
+#define _CATCH_ALL \
+    }              \
+    catch (...) {
+#define _CATCH_END }
+
+#define _RERAISE    throw
+#define _THROW(...) throw(__VA_ARGS__)
+
+#else // ^^^ _HAS_EXCEPTIONS / !_HAS_EXCEPTIONS vvv
+#define _TRY_BEGIN \
+    {              \
+        if (1) {
+#define _CATCH(x) \
+    }             \
+    else if (0) {
+#define _CATCH_ALL \
+    }              \
+    else if (0) {
+#define _CATCH_END \
+    }              \
+    }
+
+#define _RAISE(x) _invoke_watson(nullptr, nullptr, nullptr, 0, 0)
+
+#define _RERAISE
+#define _THROW(...) (__VA_ARGS__)._Raise()
+#endif // ^^^ !_HAS_EXCEPTIONS ^^^
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _YVALS
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/yvals_core.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/yvals_core.h
new file mode 100644
index 0000000000000000000000000000000000000000..bd1a56282822a4810093acdc18cbdb22e9485946
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/yvals_core.h
@@ -0,0 +1,1990 @@
+// yvals_core.h internal header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _YVALS_CORE_H_
+#define _YVALS_CORE_H_
+#ifndef _STL_COMPILER_PREPROCESSOR
+// All STL headers avoid exposing their contents when included by various
+// non-C++-compiler tools to avoid breaking builds when we use newer language
+// features in the headers than such tools understand.
+#if defined(RC_INVOKED) || defined(Q_MOC_RUN) || defined(__midl)
+#define _STL_COMPILER_PREPROCESSOR 0
+#else
+#define _STL_COMPILER_PREPROCESSOR 1
+#endif
+#endif // !defined(_STL_COMPILER_PREPROCESSOR)
+
+#if _STL_COMPILER_PREPROCESSOR
+
+// This does not use `_EMIT_STL_ERROR`, as it is checking the language itself.
+#ifndef __cplusplus
+#error error STL1003: Unexpected compiler, expected C++ compiler.
+#endif // !defined(__cplusplus)
+
+// Implemented unconditionally:
+// N3911 void_t
+// N4089 Safe Conversions In unique_ptr<T[]>
+// N4169 invoke()
+// N4258 noexcept Cleanups
+// N4259 uncaught_exceptions()
+// N4277 Trivially Copyable reference_wrapper
+// N4279 insert_or_assign()/try_emplace() For map/unordered_map
+// N4280 size(), empty(), data()
+// N4366 Precisely Constraining unique_ptr Assignment
+// N4387 Improving pair And tuple
+// N4389 bool_constant
+// N4508 shared_mutex (Untimed)
+// N4510 Supporting Incomplete Types In vector/list/forward_list
+// P0006R0 Variable Templates For Type Traits (is_same_v, etc.)
+// P0007R1 as_const()
+// P0013R1 Logical Operator Type Traits (conjunction, etc.)
+// P0033R1 Rewording enable_shared_from_this
+// P0063R3 C11 Standard Library
+// P0074R0 owner_less<>
+// P0092R1 <chrono> floor(), ceil(), round(), abs()
+// P0340R3 SFINAE-Friendly underlying_type
+// P0414R2 shared_ptr<T[]>, shared_ptr<T[N]>
+// P0418R2 atomic compare_exchange memory_order Requirements
+// P0435R1 Overhauling common_type
+// P0497R0 Fixing shared_ptr For Arrays
+// P0513R0 Poisoning hash
+// P0516R0 Marking shared_future Copying As noexcept
+// P0517R0 Constructing future_error From future_errc
+// P0548R1 Tweaking common_type And duration
+// P0558R1 Resolving atomic<T> Named Base Class Inconsistencies
+// P0599R1 noexcept hash
+// P0738R2 istream_iterator Cleanup
+// P0771R1 noexcept For std::function's Move Constructor
+// P0777R1 Avoiding Unnecessary decay
+// P0809R0 Comparing Unordered Containers
+// P0883R2 Fixing Atomic Initialization
+// P0935R0 Eradicating Unnecessarily Explicit Default Constructors
+// P0941R2 Feature-Test Macros
+// P0952R2 A New Specification For generate_canonical()
+// P0972R0 noexcept For <chrono> zero(), min(), max()
+// P1065R2 constexpr INVOKE
+//     (the std::invoke function only; other components like bind and reference_wrapper are C++20 only)
+// P1164R1 Making create_directory() Intuitive
+// P1165R1 Consistently Propagating Stateful Allocators In basic_string's operator+()
+// P1902R1 Missing Feature-Test Macros 2017-2019
+// P2013R5 Freestanding Language: Optional ::operator new
+//     (no change is needed for our hosted implementation)
+// P2198R7 Freestanding Feature-Test Macros And Implementation-Defined Extensions
+//     (except for __cpp_lib_freestanding_ranges)
+// P2338R4 Freestanding Library: Character Primitives And The C Library
+//     (except for __cpp_lib_freestanding_charconv)
+// P2401R0 Conditional noexcept For exchange()
+// P2407R5 Freestanding Library: Partial Classes
+//     (__cpp_lib_freestanding_algorithm and __cpp_lib_freestanding_array only)
+// P2937R0 Freestanding Library: Remove strtok
+// P2968R2 Make std::ignore A First-Class Object
+
+// _HAS_CXX17 directly controls:
+// P0005R4 not_fn()
+// P0024R2 Parallel Algorithms
+// P0025R1 clamp()
+// P0030R1 hypot(x, y, z)
+// P0031R0 constexpr For <array> (Again) And <iterator>
+// P0032R3 Homogeneous Interface For variant/any/optional
+// P0040R3 Extending Memory Management Tools
+// P0067R5 Elementary String Conversions
+// P0083R3 Splicing Maps And Sets
+// P0084R2 Emplace Return Type
+// P0088R3 <variant>
+// P0137R1 launder()
+// P0152R1 atomic::is_always_lock_free
+// P0154R1 hardware_destructive_interference_size, etc.
+// P0156R2 scoped_lock
+// P0163R0 shared_ptr::weak_type
+// P0185R1 is_swappable, is_nothrow_swappable
+// P0209R2 make_from_tuple()
+// P0218R1 <filesystem>
+// P0220R1 <any>, <memory_resource>, <optional>, <string_view>, apply(), sample(), Boyer-Moore search()
+// P0226R1 Mathematical Special Functions
+// P0253R1 Fixing Searcher Return Types
+// P0254R2 Integrating string_view And std::string
+// P0258R2 has_unique_object_representations
+// P0272R1 Non-const basic_string::data()
+// P0295R0 gcd(), lcm()
+// P0307R2 Making Optional Greater Equal Again
+// P0336R1 Renaming Parallel Execution Policies
+// P0337R0 Deleting polymorphic_allocator Assignment
+// P0358R1 Fixes For not_fn()
+// P0393R3 Making Variant Greater Equal
+// P0394R4 Parallel Algorithms Should terminate() For Exceptions
+// P0403R1 UDLs For <string_view> ("meow"sv, etc.)
+// P0426R1 constexpr For char_traits
+// P0433R2 Deduction Guides For The STL
+// P0452R1 Unifying <numeric> Parallel Algorithms
+// P0504R0 Revisiting in_place_t/in_place_type_t<T>/in_place_index_t<I>
+// P0505R0 constexpr For <chrono> (Again)
+// P0508R0 Clarifying insert_return_type
+// P0510R0 Rejecting variants Of Nothing, Arrays, References, And Incomplete Types
+// P0602R4 Propagating Copy/Move Triviality In variant/optional
+// P0604R0 invoke_result, is_invocable, is_nothrow_invocable
+// P0607R0 Inline Variables For The STL
+// P0608R3 Improving variant's Converting Constructor/Assignment
+// P0682R1 Repairing Elementary String Conversions
+// P0739R0 Improving Class Template Argument Deduction For The STL
+// P0858R0 Constexpr Iterator Requirements
+// P1169R4 static operator()
+// P1518R2 Stop Overconstraining Allocators In Container Deduction Guides
+// P2162R2 Inheriting From variant
+// P2251R1 Require span And basic_string_view To Be Trivially Copyable
+//     (basic_string_view always provides this behavior)
+// P2338R4 Freestanding Library: Character Primitives And The C Library
+//     (including __cpp_lib_freestanding_charconv)
+// P2407R5 Freestanding Library: Partial Classes
+//     (including __cpp_lib_freestanding_optional, __cpp_lib_freestanding_string_view, and
+//     __cpp_lib_freestanding_variant)
+// P2517R1 Conditional noexcept For apply()
+// P2875R4 Undeprecate polymorphic_allocator::destroy
+
+// _HAS_CXX17 indirectly controls:
+// N4190 Removing auto_ptr, random_shuffle(), And Old <functional> Stuff
+// P0003R5 Removing Dynamic Exception Specifications
+// P0004R1 Removing Deprecated Iostreams Aliases
+// P0298R3 std::byte
+// P0302R1 Removing Allocator Support In std::function
+// LWG-2385 function::assign allocator argument doesn't make sense
+// LWG-2921 packaged_task and type-erased allocators
+// LWG-2976 Dangling uses_allocator specialization for packaged_task
+// The non-Standard std::tr1 namespace and TR1-only machinery
+// Enforcement of matching allocator value_types
+
+// _HAS_CXX17 and _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS control:
+// P0174R2 Deprecating Vestigial Library Parts
+// P0521R0 Deprecating shared_ptr::unique()
+// P0618R0 Deprecating <codecvt>
+// Other C++17 deprecation warnings
+
+// Implemented when char8_t is available (C++14/17 with /Zc:char8_t, C++20 without /Zc:char8_t-):
+// P0482R6 Library Support For char8_t
+//     (mbrtoc8 and c8rtomb not yet implemented, see GH-2207)
+
+// _HAS_CXX20 directly controls:
+// P0019R8 atomic_ref
+// P0020R6 atomic<float>, atomic<double>, atomic<long double>
+// P0053R7 <syncstream>
+// P0122R7 <span>
+// P0202R3 constexpr For <algorithm> And exchange()
+// P0318R1 unwrap_reference, unwrap_ref_decay
+// P0325R4 to_array()
+// P0339R6 polymorphic_allocator<>
+// P0355R7 <chrono> Calendars And Time Zones
+// P0356R5 bind_front()
+// P0357R3 Supporting Incomplete Types In reference_wrapper
+// P0408R7 Efficient Access To basic_stringbuf's Buffer
+// P0415R1 constexpr For <complex> (Again)
+// P0439R0 enum class memory_order
+// P0457R2 starts_with()/ends_with() For basic_string/basic_string_view
+// P0458R2 contains() For Ordered And Unordered Associative Containers
+// P0463R1 endian
+// P0466R5 Layout-Compatibility And Pointer-Interconvertibility Traits
+// P0475R1 Guaranteed Copy Elision For Piecewise Construction
+// P0476R2 <bit> bit_cast
+// P0487R1 Fixing operator>>(basic_istream&, CharT*)
+// P0528R3 Atomic Compare-And-Exchange With Padding Bits
+// P0550R2 remove_cvref
+// P0553R4 <bit> Rotating And Counting Functions
+// P0556R3 <bit> Integral Power-Of-2 Operations (renamed by P1956R1)
+// P0586R2 Integer Comparison Functions
+// P0591R4 Utility Functions For Uses-Allocator Construction
+// P0595R2 is_constant_evaluated()
+// P0616R0 Using move() In <numeric>
+// P0631R8 <numbers> Math Constants
+// P0645R10 <format> Text Formatting
+// P0646R1 list/forward_list remove()/remove_if()/unique() Return size_type
+// P0653R2 to_address()
+// P0655R1 visit<R>()
+// P0660R10 <stop_token> And jthread
+// P0674R1 make_shared() For Arrays
+// P0718R2 atomic<shared_ptr<T>>, atomic<weak_ptr<T>>
+// P0753R2 osyncstream Manipulators
+// P0758R1 is_nothrow_convertible
+// P0768R1 Library Support For The Spaceship Comparison Operator <=>
+// P0769R2 shift_left(), shift_right()
+// P0784R7 Library Support For More constexpr Containers
+// P0811R3 midpoint(), lerp()
+// P0849R8 auto(x): decay-copy In The Language
+//     (library part only)
+// P0879R0 constexpr For Swapping Functions
+// P0887R1 type_identity
+// P0896R4 Ranges
+// P0898R3 Standard Library Concepts
+// P0912R5 Library Support For Coroutines
+// P0919R3 Heterogeneous Lookup For Unordered Containers
+// P0966R1 string::reserve() Should Not Shrink
+// P0980R1 constexpr std::string
+// P1001R2 execution::unseq
+// P1004R2 constexpr std::vector
+// P1006R1 constexpr For pointer_traits<T*>::pointer_to()
+// P1007R3 assume_aligned()
+// P1020R1 Smart Pointer Creation With Default Initialization
+// P1023R0 constexpr For std::array Comparisons
+// P1024R3 Enhancing span Usability
+// P1032R1 Miscellaneous constexpr
+// P1035R7 Input Range Adaptors
+// P1065R2 constexpr INVOKE
+//     (except the std::invoke function which is implemented unconditionally)
+// P1085R2 Removing span Comparisons
+// P1115R3 erase()/erase_if() Return size_type
+// P1123R0 Atomic Compare-And-Exchange With Padding Bits For atomic_ref
+// P1135R6 The C++20 Synchronization Library
+// P1207R4 Movability Of Single-Pass Iterators
+// P1208R6 <source_location>
+// P1209R0 erase_if(), erase()
+// P1227R2 Signed std::ssize(), Unsigned span::size()
+// P1243R4 Rangify New Algorithms
+// P1248R1 Fixing Relations
+// P1252R2 Ranges Design Cleanup
+// P1357R1 is_bounded_array, is_unbounded_array
+// P1391R4 Range Constructor For string_view
+// P1394R4 Range Constructor For span
+// P1423R3 char8_t Backward Compatibility Remediation
+// P1456R1 Move-Only Views
+// P1474R1 Helpful Pointers For contiguous_iterator
+// P1522R1 Iterator Difference Type And Integer Overflow
+// P1523R1 Views And Size Types
+// P1612R1 Relocating endian To <bit>
+// P1614R2 Adding Spaceship <=> To The Library
+// P1638R1 basic_istream_view::iterator Should Not Be Copyable
+// P1645R1 constexpr For <numeric> Algorithms
+// P1651R0 bind_front() Should Not Unwrap reference_wrapper
+// P1690R1 Refining Heterogeneous Lookup For Unordered Containers
+// P1716R3 Range Comparison Algorithms Are Over-Constrained
+// P1739R4 Avoiding Template Bloat For Ranges
+// P1754R1 Rename Concepts To standard_case
+// P1862R1 Range Adaptors For Non-Copyable Iterators
+// P1865R1 Adding max() To latch And barrier
+// P1870R1 Rename forwarding-range To borrowed_range (Was safe_range before LWG-3379)
+// P1871R1 disable_sized_sentinel_for
+// P1872R0 span Should Have size_type, Not index_type
+// P1878R1 Constraining Readable Types
+// P1907R2 ranges::ssize
+// P1956R1 <bit> has_single_bit(), bit_ceil(), bit_floor(), bit_width()
+// P1959R0 Removing weak_equality And strong_equality
+// P1960R0 atomic_ref Cleanup
+// P1964R2 Replacing boolean With boolean-testable
+// P1973R1 Renaming default_init To for_overwrite
+// P1976R2 Explicit Constructors For Fixed-Extent span From Dynamic-Extent Ranges
+// P1983R0 Fixing Minor Ranges Issues
+// P1994R1 elements_view Needs Its Own sentinel
+// P2017R1 Conditionally Borrowed Ranges
+// P2091R0 Fixing Issues With Range Access CPOs
+// P2102R0 Making "Implicit Expression Variations" More Explicit
+// P2106R0 Range Algorithm Result Types
+// P2116R0 Removing tuple-Like Protocol Support From Fixed-Extent span
+// P2167R3 Improving boolean-testable Usage
+// P2198R7 Freestanding Feature-Test Macros And Implementation-Defined Extensions
+//     (including __cpp_lib_freestanding_ranges)
+// P2210R2 Superior String Splitting
+// P2216R3 std::format Improvements
+// P2231R1 Completing constexpr In optional And variant
+// P2251R1 Require span And basic_string_view To Be Trivially Copyable
+//     (span always provides this behavior)
+// P2259R1 Repairing Input Range Adaptors And counted_iterator
+// P2281R1 Clarifying Range Adaptor Objects
+// P2325R3 Views Should Not Be Required To Be Default Constructible
+// P2328R1 join_view Should Join All views Of ranges
+// P2367R0 Remove Misuses Of List-Initialization From Clause 24 Ranges
+// P2372R3 Fixing Locale Handling In chrono Formatters
+// P2393R1 Cleaning Up Integer-Class Types
+// P2408R5 Ranges Iterators As Inputs To Non-Ranges Algorithms
+// P2415R2 What Is A view?
+// P2418R2 Add Support For std::generator-like Types To std::format
+// P2419R2 Clarify Handling Of Encodings In Localized Formatting Of chrono Types
+// P2432R1 Fix istream_view
+// P2465R3 Standard Library Modules std And std.compat
+// P2508R1 basic_format_string, format_string, wformat_string
+// P2510R3 Formatting Pointers
+// P2520R0 move_iterator<T*> Should Be A Random-Access Iterator
+// P2538R1 ADL-Proof projected
+// P2572R1 std::format Fill Character Allowances
+// P2588R3 barrier's Phase Completion Guarantees
+// P2602R2 Poison Pills Are Too Toxic
+// P2609R3 Relaxing Ranges Just A Smidge
+// P2655R3 common_reference_t Of reference_wrapper Should Be A Reference Type
+// P2675R1 Improving std::format's Width Estimation
+// P2711R1 Making Multi-Param Constructors Of Views explicit
+// P2736R2 Referencing The Unicode Standard
+// P2770R0 Stashing Stashing Iterators For Proper Flattening
+// P2905R2 Runtime Format Strings
+// P2909R4 Fix Formatting Of Code Units As Integers
+// P2997R1 Removing The Common Reference Requirement From The Indirectly Invocable Concepts
+
+// _HAS_CXX20 indirectly controls:
+// P0619R4 Removing C++17-Deprecated Features
+
+// _HAS_CXX20 and _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS control:
+// P0767R1 Deprecating is_pod
+// P1831R1 Deprecating volatile In The Standard Library
+// Other C++20 deprecation warnings
+
+// _HAS_CXX23 directly controls:
+// P0009R18 <mdspan>
+// P0288R9 move_only_function
+// P0323R12 <expected>
+// P0401R6 Providing Size Feedback In The Allocator Interface
+// P0448R4 <spanstream>
+// P0627R6 unreachable()
+// P0798R8 Monadic Operations For optional
+// P0881R7 <stacktrace>
+// P0943R6 Supporting C Atomics In C++
+// P1048R1 is_scoped_enum
+// P1072R10 basic_string::resize_and_overwrite
+// P1132R7 out_ptr(), inout_ptr()
+// P1147R1 Printing volatile Pointers
+// P1206R7 Conversions From Ranges To Containers
+// P1223R5 ranges::find_last, ranges::find_last_if, ranges::find_last_if_not
+// P1272R4 byteswap()
+// P1328R1 constexpr type_info::operator==()
+// P1425R4 Iterator Pair Constructors For stack And queue
+// P1467R9 Extended Floating-Point Types
+//     (only the <stdfloat> header; we don't support any optional extended floating-point types)
+// P1659R3 ranges::starts_with, ranges::ends_with
+// P1679R3 contains() For basic_string/basic_string_view
+// P1682R3 to_underlying() For Enumerations
+// P1899R3 views::stride
+// P1951R1 Default Template Arguments For pair's Forwarding Constructor
+// P1989R2 Range Constructor For string_view
+// P2077R3 Heterogeneous Erasure Overloads For Associative Containers
+// P2093R14 <print>: Formatted Output
+// P2136R3 invoke_r()
+// P2164R9 views::enumerate
+// P2165R4 Compatibility Between tuple, pair, And tuple-like Objects
+// P2166R1 Prohibiting basic_string And basic_string_view Construction From nullptr
+// P2186R2 Removing Garbage Collection Support
+// P2273R3 constexpr unique_ptr
+// P2278R4 cbegin Should Always Return A Constant Iterator
+// P2286R8 Formatting Ranges
+// P2291R3 constexpr Integral <charconv>
+// P2302R4 ranges::contains, ranges::contains_subrange
+// P2321R2 zip
+// P2322R6 ranges::fold_left, ranges::fold_right, Etc.
+// P2374R4 views::cartesian_product
+// P2387R3 Pipe Support For User-Defined Range Adaptors
+// P2404R3 Move-Only Types For Comparison Concepts
+// P2417R2 More constexpr bitset
+// P2438R2 string::substr() &&
+// P2440R1 ranges::iota, ranges::shift_left, ranges::shift_right
+// P2441R2 views::join_with
+// P2442R1 Windowing Range Adaptors: views::chunk, views::slide
+// P2443R1 views::chunk_by
+// P2445R1 forward_like()
+// P2446R2 views::as_rvalue
+// P2467R1 ios_base::noreplace: Exclusive Mode For fstreams
+// P2474R2 views::repeat
+// P2494R2 Relaxing Range Adaptors To Allow Move-Only Types
+// P2499R0 string_view Range Constructor Should Be explicit
+// P2505R5 Monadic Functions For expected
+// P2539R4 Synchronizing print() With The Underlying Stream
+// P2540R1 Empty Product For Certain Views
+// P2549R1 unexpected<E>::error()
+// P2585R1 Improve Default Container Formatting
+// P2599R2 mdspan: index_type, size_type
+// P2604R0 mdspan: data_handle_type, data_handle(), exhaustive
+// P2613R1 mdspan: empty()
+// P2652R2 Disallowing User Specialization Of allocator_traits
+// P2693R1 Formatting thread::id And stacktrace
+// P2713R1 Escaping Improvements In std::format
+// P2763R1 Fixing layout_stride's Default Constructor For Fully Static Extents
+// P2833R2 Freestanding Library: inout expected span
+//     (except for __cpp_lib_span which also covers C++26 span::at)
+// P2836R1 basic_const_iterator Should Follow Its Underlying Type's Convertibility
+// P3142R0 Printing Blank Lines With println()
+
+// _HAS_CXX23 and _SILENCE_ALL_CXX23_DEPRECATION_WARNINGS control:
+// P1413R3 Deprecate aligned_storage And aligned_union
+// P2614R2 Deprecating float_denorm_style, numeric_limits::has_denorm, numeric_limits::has_denorm_loss
+// Other C++23 deprecation warnings
+
+// Parallel Algorithms Notes
+// C++ allows an implementation to implement parallel algorithms as calls to the serial algorithms.
+// This implementation parallelizes several common algorithm calls, but not all.
+//
+// std::execution::unseq has no direct analogue for any optimizer we target as of 2020-07-29,
+// though we will map it to #pragma loop(ivdep) for the for_each algorithms only as these are the only algorithms where
+// the library does not need to introduce inter-loop-body dependencies to accomplish the algorithm's goals.
+//
+// The following algorithms are parallelized.
+// * adjacent_difference
+// * adjacent_find
+// * all_of
+// * any_of
+// * count
+// * count_if
+// * destroy
+// * destroy_n
+// * equal
+// * exclusive_scan
+// * find
+// * find_end
+// * find_first_of
+// * find_if
+// * find_if_not
+// * for_each
+// * for_each_n
+// * inclusive_scan
+// * is_heap
+// * is_heap_until
+// * is_partitioned
+// * is_sorted
+// * is_sorted_until
+// * mismatch
+// * none_of
+// * partition
+// * reduce
+// * remove
+// * remove_if
+// * replace
+// * replace_if
+// * search
+// * search_n
+// * set_difference
+// * set_intersection
+// * sort
+// * stable_sort
+// * transform
+// * transform_exclusive_scan
+// * transform_inclusive_scan
+// * transform_reduce
+// * uninitialized_default_construct
+// * uninitialized_default_construct_n
+// * uninitialized_value_construct
+// * uninitialized_value_construct_n
+//
+// The following are not presently parallelized:
+//
+// No apparent parallelism performance improvement on target hardware; all algorithms which
+// merely copy or permute elements with no branches are typically memory bandwidth limited.
+// * copy
+// * copy_n
+// * fill
+// * fill_n
+// * move
+// * reverse
+// * reverse_copy
+// * rotate
+// * rotate_copy
+// * shift_left
+// * shift_right
+// * swap_ranges
+//
+// Possibly same as above, but not yet tested.
+// * uninitialized_copy
+// * uninitialized_copy_n
+// * uninitialized_fill
+// * uninitialized_fill_n
+// * uninitialized_move
+// * uninitialized_move_n
+//
+// Confusion over user parallelism requirements exists; likely in the above category anyway.
+// * generate
+// * generate_n
+//
+// Effective parallelism suspected to be infeasible.
+// * partial_sort
+// * partial_sort_copy
+//
+// Not yet evaluated; parallelism may be implemented in a future release and is suspected to be beneficial.
+// * copy_if
+// * includes
+// * inplace_merge
+// * lexicographical_compare
+// * max_element
+// * merge
+// * min_element
+// * minmax_element
+// * nth_element
+// * partition_copy
+// * remove_copy
+// * remove_copy_if
+// * replace_copy
+// * replace_copy_if
+// * set_symmetric_difference
+// * set_union
+// * stable_partition
+// * unique
+// * unique_copy
+
+#include <vcruntime.h>
+#include <xkeycheck.h> // The _HAS_CXX tags must be defined before including this.
+
+#define _STL_STRINGIZE_(S) #S
+#define _STL_STRINGIZE(S)  _STL_STRINGIZE_(S)
+
+// Note that _STL_PRAGMA is load-bearing;
+// it still needs to exist even once CUDA and ICC support _Pragma.
+#if defined(__CUDACC__) || defined(__INTEL_COMPILER)
+#define _STL_PRAGMA(PRAGMA) __pragma(PRAGMA)
+#else
+#define _STL_PRAGMA(PRAGMA) _Pragma(#PRAGMA)
+#endif
+
+#define _STL_PRAGMA_MESSAGE(MESSAGE) _STL_PRAGMA(message(MESSAGE))
+#define _EMIT_STL_MESSAGE(MESSAGE)   _STL_PRAGMA_MESSAGE(__FILE__ "(" _STL_STRINGIZE(__LINE__) "): " MESSAGE)
+
+#define _EMIT_STL_WARNING(NUMBER, MESSAGE) _EMIT_STL_MESSAGE("warning " #NUMBER ": " MESSAGE)
+#define _EMIT_STL_ERROR(NUMBER, MESSAGE)   static_assert(false, "error " #NUMBER ": " MESSAGE)
+
+#ifndef _STL_WARNING_LEVEL
+#if defined(_MSVC_WARNING_LEVEL) && _MSVC_WARNING_LEVEL >= 4
+#define _STL_WARNING_LEVEL 4
+#else // defined(_MSVC_WARNING_LEVEL) && _MSVC_WARNING_LEVEL >= 4
+#define _STL_WARNING_LEVEL 3
+#endif // defined(_MSVC_WARNING_LEVEL) && _MSVC_WARNING_LEVEL >= 4
+#endif // !defined(_STL_WARNING_LEVEL)
+
+#if _STL_WARNING_LEVEL < 3
+#error _STL_WARNING_LEVEL cannot be less than 3.
+#endif // _STL_WARNING_LEVEL < 3
+
+#if _STL_WARNING_LEVEL > 4
+#error _STL_WARNING_LEVEL cannot be greater than 4.
+#endif // _STL_WARNING_LEVEL > 4
+
+#ifndef __has_cpp_attribute
+#define _FALLTHROUGH
+#elif __has_cpp_attribute(fallthrough) >= 201603L
+#define _FALLTHROUGH [[fallthrough]]
+#else
+#define _FALLTHROUGH
+#endif
+
+#ifndef __has_cpp_attribute // vvv no attributes vvv
+#define _LIKELY
+#define _UNLIKELY
+#elif __has_cpp_attribute(likely) >= 201803L && __has_cpp_attribute(unlikely) >= 201803L // ^^^ no attr / C++20 attr vvv
+#define _LIKELY   [[likely]]
+#define _UNLIKELY [[unlikely]]
+#elif defined(__clang__) // ^^^ C++20 attributes / clang attributes and C++17 or C++14 vvv
+#define _LIKELY   [[__likely__]]
+#define _UNLIKELY [[__unlikely__]]
+#else // ^^^ clang attributes and C++17 or C++14 / C1XX attributes and C++17 or C++14 vvv
+#define _LIKELY
+#define _UNLIKELY
+#endif // ^^^ C1XX attributes and C++17 or C++14 ^^^
+
+// _HAS_NODISCARD (in vcruntime.h) controls:
+// [[nodiscard]] attributes on STL functions
+
+// TRANSITION, This should go to vcruntime.h
+#ifndef __has_cpp_attribute
+#define _NODISCARD_MSG(_Msg)
+#elif __has_cpp_attribute(nodiscard) >= 201907L
+#define _NODISCARD_MSG(_Msg) [[nodiscard(_Msg)]]
+#elif __has_cpp_attribute(nodiscard) >= 201603L
+#define _NODISCARD_MSG(_Msg) [[nodiscard]]
+#else
+#define _NODISCARD_MSG(_Msg)
+#endif
+
+#ifndef __has_cpp_attribute
+#define _NODISCARD_CTOR
+#define _NODISCARD_CTOR_MSG(_Msg)
+#elif __has_cpp_attribute(nodiscard) >= 201907L
+#define _NODISCARD_CTOR           _NODISCARD
+#define _NODISCARD_CTOR_MSG(_Msg) _NODISCARD_MSG(_Msg)
+#else // ^^^ __has_cpp_attribute(nodiscard) >= 201907L / __has_cpp_attribute(nodiscard) < 201907L vvv
+#define _NODISCARD_CTOR
+#define _NODISCARD_CTOR_MSG(_Msg)
+#endif // ^^^ defined(__has_cpp_attribute) && __has_cpp_attribute(nodiscard) < 201907L ^^^
+
+#define _NODISCARD_REMOVE_ALG                                                                                    \
+    _NODISCARD_MSG("The 'remove' and 'remove_if' algorithms return the iterator past the last element "          \
+                   "that should be kept. You need to call container.erase(result, container.end()) afterwards. " \
+                   "In C++20, 'std::erase' and 'std::erase_if' are simpler replacements for these two steps.")
+
+#define _NODISCARD_UNIQUE_ALG                                                                                \
+    _NODISCARD_MSG("The 'unique' algorithm returns the iterator past the last element that should be kept. " \
+                   "You need to call container.erase(result, container.end()) afterwards.")
+
+#define _NODISCARD_EMPTY_MEMBER                                                                                     \
+    _NODISCARD_MSG(                                                                                                 \
+        "This member function returns a bool indicating whether the collection is empty and has no other effects. " \
+        "It is not useful to call this member function and discard the return value. "                              \
+        "Use the 'clear()' member function if you want to erase all elements.")
+
+#define _NODISCARD_EMPTY_ARRAY_MEMBER                                                                          \
+    _NODISCARD_MSG(                                                                                            \
+        "This member function returns a bool indicating whether the array is empty and has no other effects. " \
+        "It is not useful to call this member function and discard the return value. "                         \
+        "There's no way to clear an array as its size is fixed.")
+
+#define _NODISCARD_EMPTY_MEMBER_NO_CLEAR                                                                            \
+    _NODISCARD_MSG(                                                                                                 \
+        "This member function returns a bool indicating whether the collection is empty and has no other effects. " \
+        "It is not useful to call this member function and discard the return value. "                              \
+        "This collection can be cleared by assigning an empty value to it.")
+
+#define _NODISCARD_EMPTY_NON_MEMBER                                                               \
+    _NODISCARD_MSG("This function returns a bool indicating whether the collection is empty and " \
+                   "has no other effects. It is not useful to call this function and discard the return value.")
+
+#define _NODISCARD_BARRIER_TOKEN \
+    _NODISCARD_MSG("The token from 'arrive()' should not be discarded; it should be passed to 'wait()'.")
+
+#define _NODISCARD_TRY_WAIT                                                                                    \
+    _NODISCARD_MSG(                                                                                            \
+        "This member function returns the state of the synchronization object and does not do anything else; " \
+        "it is not useful to call this member function and discard the return value.")
+
+#define _NODISCARD_TRY_CHANGE_STATE                                                                    \
+    _NODISCARD_MSG("This function returns whether the operation succeeded in modifying object state. " \
+                   "It is dangerous to ignore the return value.")
+
+#define _NODISCARD_SMART_PTR_ALLOC                                                                            \
+    _NODISCARD_MSG("This function constructs an object wrapped by a smart pointer and has no other effects; " \
+                   "it is not useful to call this function and discard the return value.")
+
+#define _NODISCARD_RAW_PTR_ALLOC                                                \
+    _NODISCARD_MSG("This function allocates memory and returns a raw pointer. " \
+                   "Discarding the return value will cause a memory leak.")
+
+#define _NODISCARD_ASSUME_ALIGNED                                                                                    \
+    _NODISCARD_MSG("'std::assume_aligned' has a potential effect on the return value (not on the passed argument). " \
+                   "It is not useful to call 'std::assume_aligned' and discard the return value.")
+
+#define _NODISCARD_LAUNDER                                                                                    \
+    _NODISCARD_MSG("'std::launder' has a potential effect on the return value (not on the passed argument). " \
+                   "It is not useful to call 'std::launder' and discard the return value.")
+
+#ifdef _SILENCE_NODISCARD_LOCK_WARNINGS
+
+#define _NODISCARD_LOCK
+#define _NODISCARD_CTOR_LOCK
+
+#else // ^^^ defined(_SILENCE_NODISCARD_LOCK_WARNINGS) / !defined(_SILENCE_NODISCARD_LOCK_WARNINGS) vvv
+
+#define _NODISCARD_LOCK                                                                                                \
+    _NODISCARD_MSG("A lock should be stored in a variable to protect the scope. If you're intentionally constructing " \
+                   "a temporary to protect the rest of the current expression using the comma operator, you can cast " \
+                   "the temporary to void or define _SILENCE_NODISCARD_LOCK_WARNINGS to suppress this warning.")
+
+#define _NODISCARD_CTOR_LOCK                                                                                \
+    _NODISCARD_CTOR_MSG(                                                                                    \
+        "A lock should be stored in a variable to protect the scope. If you're intentionally constructing " \
+        "a temporary to protect the rest of the current expression using the comma operator, you can cast " \
+        "the temporary to void or define _SILENCE_NODISCARD_LOCK_WARNINGS to suppress this warning.")
+
+#endif // ^^^ !defined(_SILENCE_NODISCARD_LOCK_WARNINGS) ^^^
+
+#define _NODISCARD_CTOR_THREAD                                                     \
+    _NODISCARD_CTOR_MSG("This temporary 'std::thread' is not joined or detached, " \
+                        "so 'std::terminate' will be called at the end of the statement.")
+
+#define _NODISCARD_CTOR_JTHREAD                                                                            \
+    _NODISCARD_CTOR_MSG("This temporary 'std::jthread' is implicitly joined at the end of the statement. " \
+                        "If this is intentional, you can add '.join()' to suppress this warning. "         \
+                        "Otherwise, this 'std::jthread' should be stored in a variable.")
+
+#define _NODISCARD_ASYNC                                                                                           \
+    _NODISCARD_MSG("The result of 'std::async' should be stored in a variable. If the return value is discarded, " \
+                   "the temporary 'std::future' is destroyed, waiting for an async result or evaluating "          \
+                   "a deferred result, thus defeating the purpose of 'std::async'.")
+
+#define _NODISCARD_GET_FUTURE \
+    _NODISCARD_MSG("Since 'get_future' may be called only once, discarding the result is likely a mistake.")
+
+#pragma push_macro("msvc")
+#pragma push_macro("known_semantics")
+#pragma push_macro("noop_dtor")
+#pragma push_macro("intrinsic")
+#pragma push_macro("lifetimebound")
+#undef msvc
+#undef known_semantics
+#undef noop_dtor
+#undef intrinsic
+#undef lifetimebound
+
+#ifndef __has_cpp_attribute
+#define _HAS_MSVC_ATTRIBUTE(x) 0
+#elif defined(__CUDACC__) // TRANSITION, CUDA - warning: attribute namespace "msvc" is unrecognized
+#define _HAS_MSVC_ATTRIBUTE(x) 0
+#else
+#define _HAS_MSVC_ATTRIBUTE(x) __has_cpp_attribute(msvc::x)
+#endif
+
+// Should we use [[msvc::known_semantics]] to tell the compiler that certain
+// type trait specializations have the standard-mandated semantics?
+#if _HAS_MSVC_ATTRIBUTE(known_semantics)
+#define _MSVC_KNOWN_SEMANTICS [[msvc::known_semantics]]
+#else
+#define _MSVC_KNOWN_SEMANTICS
+#endif
+
+// Should we use [[msvc::noop_dtor]] to tell the compiler that some non-trivial
+// destructors have no effects?
+#if _HAS_MSVC_ATTRIBUTE(noop_dtor)
+#define _MSVC_NOOP_DTOR [[msvc::noop_dtor]]
+#else
+#define _MSVC_NOOP_DTOR
+#endif
+
+// Should we use [[msvc::intrinsic]] allowing the compiler to implement the
+// behavior of certain trivial functions?
+#if _HAS_MSVC_ATTRIBUTE(intrinsic)
+#define _MSVC_INTRINSIC [[msvc::intrinsic]]
+#else
+#define _MSVC_INTRINSIC
+#endif
+
+// Should we enable [[msvc::lifetimebound]] or [[clang::lifetimebound]] warnings?
+#if !defined(__has_cpp_attribute) || defined(_SILENCE_LIFETIMEBOUND_WARNING)
+#define _MSVC_LIFETIMEBOUND
+#elif _HAS_MSVC_ATTRIBUTE(lifetimebound)
+#define _MSVC_LIFETIMEBOUND [[msvc::lifetimebound]]
+#elif __has_cpp_attribute(_Clang::__lifetimebound__)
+#define _MSVC_LIFETIMEBOUND [[_Clang::__lifetimebound__]]
+#else
+#define _MSVC_LIFETIMEBOUND
+#endif
+
+#undef _HAS_MSVC_ATTRIBUTE
+#pragma pop_macro("lifetimebound")
+#pragma pop_macro("intrinsic")
+#pragma pop_macro("noop_dtor")
+#pragma pop_macro("known_semantics")
+#pragma pop_macro("msvc")
+
+// warning C4577: 'noexcept' used with no exception handling mode specified;
+// termination on exception is not guaranteed. Specify /EHsc (/Wall)
+#if _HAS_EXCEPTIONS
+#define _STL_DISABLED_WARNING_C4577
+#else
+#define _STL_DISABLED_WARNING_C4577 4577
+#endif
+
+// warning C4984: 'if constexpr' is a C++17 language extension
+#if !_HAS_CXX17
+#define _STL_DISABLED_WARNING_C4984 4984
+#else
+#define _STL_DISABLED_WARNING_C4984
+#endif
+
+// warning C5053: support for 'explicit(<expr>)' in C++17 and earlier is a vendor extension
+#if !_HAS_CXX20
+#define _STL_DISABLED_WARNING_C5053 5053
+#else
+#define _STL_DISABLED_WARNING_C5053
+#endif
+
+#ifndef _STL_EXTRA_DISABLED_WARNINGS
+#define _STL_EXTRA_DISABLED_WARNINGS
+#endif // !defined(_STL_EXTRA_DISABLED_WARNINGS)
+
+// warning C4180: qualifier applied to function type has no meaning; ignored
+// warning C4324: structure was padded due to alignment specifier
+// warning C4412: function signature contains type 'meow'; C++ objects are unsafe to pass between pure code
+//                and mixed or native. (/Wall)
+// warning C4455: literal suffix identifiers that do not start with an underscore are reserved
+// warning C4494: Ignoring __declspec(allocator) because the function return type is not a pointer or reference
+// warning C4514: unreferenced inline function has been removed (/Wall)
+// warning C4574: 'MACRO' is defined to be '0': did you mean to use '#if MACRO'? (/Wall)
+// warning C4582: 'union': constructor is not implicitly called (/Wall)
+// warning C4583: 'union': destructor is not implicitly called (/Wall)
+// warning C4587: behavior change: constructor is no longer implicitly called (/Wall)
+// warning C4588: behavior change: destructor is no longer implicitly called (/Wall)
+// warning C4619: #pragma warning: there is no warning number 'number' (/Wall)
+// warning C4623: default constructor was implicitly defined as deleted (/Wall)
+// warning C4625: copy constructor was implicitly defined as deleted (/Wall)
+// warning C4626: assignment operator was implicitly defined as deleted (/Wall)
+// warning C4643: Forward declaring 'meow' in namespace std is not permitted by the C++ Standard. (/Wall)
+// warning C4648: standard attribute 'meow' is ignored
+// warning C4702: unreachable code
+// warning C4793: function compiled as native
+// warning C4820: 'N' bytes padding added after data member 'meow' (/Wall)
+// warning C4868: compiler may not enforce left-to-right evaluation order in braced initializer list (/Wall)
+// warning C4988: variable declared outside class/function scope (/Wall /d1WarnOnGlobals)
+// warning C5026: move constructor was implicitly defined as deleted (/Wall)
+// warning C5027: move assignment operator was implicitly defined as deleted (/Wall)
+// warning C5045: Compiler will insert Spectre mitigation for memory load if /Qspectre switch specified (/Wall)
+// warning C5220: a non-static data member with a volatile qualified type no longer implies that compiler generated
+//                copy/move constructors and copy/move assignment operators are not trivial (/Wall)
+// warning C5246: 'member': the initialization of a subobject should be wrapped in braces (/Wall)
+// warning C6294: Ill-defined for-loop: initial condition does not satisfy test. Loop body not executed
+
+#ifndef _STL_DISABLED_WARNINGS
+// clang-format off
+#define _STL_DISABLED_WARNINGS                        \
+    4180 4324 4412 4455 4494 4514 4574 4582 4583 4587 \
+    4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 \
+    4868 4988 5026 5027 5045 5220 5246 6294           \
+    _STL_DISABLED_WARNING_C4577                       \
+    _STL_DISABLED_WARNING_C4984                       \
+    _STL_DISABLED_WARNING_C5053                       \
+    _STL_EXTRA_DISABLED_WARNINGS
+// clang-format on
+#endif // !defined(_STL_DISABLED_WARNINGS)
+
+// warning: constexpr if is a C++17 extension [-Wc++17-extensions]
+// warning: explicit(bool) is a C++20 extension [-Wc++20-extensions]
+// warning: declaring overloaded 'operator()' as 'static' is a C++23 extension [-Wc++23-extensions]
+// warning: ignoring __declspec(allocator) because the function return type '%s' is not a pointer or reference type
+//     [-Wignored-attributes]
+// warning: '#pragma float_control' is not supported on this target - ignored [-Wignored-pragmas]
+// warning: user-defined literal suffixes not starting with '_' are reserved [-Wuser-defined-literals]
+// warning: unknown pragma ignored [-Wunknown-pragmas]
+#ifndef _STL_DISABLE_CLANG_WARNINGS
+#ifdef __clang__
+// clang-format off
+#define _STL_DISABLE_CLANG_WARNINGS                                 \
+    _Pragma("clang diagnostic push")                                \
+    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"")      \
+    _Pragma("clang diagnostic ignored \"-Wc++20-extensions\"")      \
+    _Pragma("clang diagnostic ignored \"-Wc++23-extensions\"")      \
+    _Pragma("clang diagnostic ignored \"-Wignored-attributes\"")    \
+    _Pragma("clang diagnostic ignored \"-Wignored-pragmas\"")       \
+    _Pragma("clang diagnostic ignored \"-Wuser-defined-literals\"") \
+    _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
+// clang-format on
+#else // ^^^ defined(__clang__) / !defined(__clang__) vvv
+#define _STL_DISABLE_CLANG_WARNINGS
+#endif // ^^^ !defined(__clang__) ^^^
+#endif // !defined(_STL_DISABLE_CLANG_WARNINGS)
+
+#ifndef _STL_RESTORE_CLANG_WARNINGS
+#ifdef __clang__
+#define _STL_RESTORE_CLANG_WARNINGS _Pragma("clang diagnostic pop")
+#else // ^^^ defined(__clang__) / !defined(__clang__) vvv
+#define _STL_RESTORE_CLANG_WARNINGS
+#endif // ^^^ !defined(__clang__) ^^^
+#endif // !defined(_STL_RESTORE_CLANG_WARNINGS)
+
+// clang-format off
+#ifndef _STL_DISABLE_DEPRECATED_WARNING
+#ifdef __clang__
+#define _STL_DISABLE_DEPRECATED_WARNING \
+    _Pragma("clang diagnostic push")    \
+    _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif defined(__CUDACC__) || defined(__INTEL_COMPILER)
+#define _STL_DISABLE_DEPRECATED_WARNING \
+    __pragma(warning(push))             \
+    __pragma(warning(disable : 4996)) // was declared deprecated
+#else // vvv MSVC vvv
+#define _STL_DISABLE_DEPRECATED_WARNING \
+    _Pragma("warning(push)")            \
+    _Pragma("warning(disable : 4996)") // was declared deprecated
+#endif // ^^^ MSVC ^^^
+#endif // _STL_DISABLE_DEPRECATED_WARNING
+// clang-format on
+
+#ifndef _STL_RESTORE_DEPRECATED_WARNING
+#ifdef __clang__
+#define _STL_RESTORE_DEPRECATED_WARNING _Pragma("clang diagnostic pop")
+#elif defined(__CUDACC__) || defined(__INTEL_COMPILER)
+#define _STL_RESTORE_DEPRECATED_WARNING __pragma(warning(pop))
+#else // vvv MSVC vvv
+#define _STL_RESTORE_DEPRECATED_WARNING _Pragma("warning(pop)")
+#endif // ^^^ MSVC ^^^
+#endif // !defined(_STL_RESTORE_DEPRECATED_WARNING)
+
+#define _CPPLIB_VER       650
+#define _MSVC_STL_VERSION 143
+#define _MSVC_STL_UPDATE  202408L
+
+#ifndef _ALLOW_COMPILER_AND_STL_VERSION_MISMATCH
+#if defined(__CUDACC__) && defined(__CUDACC_VER_MAJOR__)
+#if __CUDACC_VER_MAJOR__ < 12 || (__CUDACC_VER_MAJOR__ == 12 && __CUDACC_VER_MINOR__ < 4)
+_EMIT_STL_ERROR(STL1002, "Unexpected compiler version, expected CUDA 12.4 or newer.");
+#endif // ^^^ old CUDA ^^^
+#elif defined(__EDG__)
+// not attempting to detect __EDG_VERSION__ being less than expected
+#elif defined(__clang__)
+#if __clang_major__ < 17
+_EMIT_STL_ERROR(STL1000, "Unexpected compiler version, expected Clang 17.0.0 or newer.");
+#endif // ^^^ old Clang ^^^
+#elif defined(_MSC_VER)
+#if _MSC_VER < 1941 // Coarse-grained, not inspecting _MSC_FULL_VER
+_EMIT_STL_ERROR(STL1001, "Unexpected compiler version, expected MSVC 19.41 or newer.");
+#endif // ^^^ old MSVC ^^^
+#else // vvv other compilers vvv
+// not attempting to detect other compilers
+#endif // ^^^ other compilers ^^^
+#endif // !defined(_ALLOW_COMPILER_AND_STL_VERSION_MISMATCH)
+
+#ifndef _HAS_STATIC_RTTI
+#define _HAS_STATIC_RTTI 1
+#endif // !defined(_HAS_STATIC_RTTI)
+
+#if defined(_CPPRTTI) && !_HAS_STATIC_RTTI
+#error /GR implies _HAS_STATIC_RTTI.
+#endif // defined(_CPPRTTI) && !_HAS_STATIC_RTTI
+
+// N4950 [dcl.constexpr]/1: "A function or static data member declared with the
+// constexpr or consteval specifier is implicitly an inline function or variable"
+
+// Functions that became constexpr in C++17
+#if _HAS_CXX17
+#define _CONSTEXPR17 constexpr
+#else // ^^^ constexpr in C++17 and later / inline (not constexpr) in C++14 vvv
+#define _CONSTEXPR17 inline
+#endif // ^^^ inline (not constexpr) in C++14 ^^^
+
+// Functions that became constexpr in C++20
+#if _HAS_CXX20
+#define _CONSTEXPR20 constexpr
+#else // ^^^ constexpr in C++20 and later / inline (not constexpr) in C++17 and earlier vvv
+#define _CONSTEXPR20 inline
+#endif // ^^^ inline (not constexpr) in C++17 and earlier ^^^
+
+// Functions that became constexpr in C++23
+#if _HAS_CXX23
+#define _CONSTEXPR23 constexpr
+#else // ^^^ constexpr in C++23 and later / inline (not constexpr) in C++20 and earlier vvv
+#define _CONSTEXPR23 inline
+#endif // ^^^ inline (not constexpr) in C++20 and earlier ^^^
+
+// P2465R3 Standard Library Modules std And std.compat
+#ifdef _BUILD_STD_MODULE
+#if !_HAS_CXX20
+#error The Standard Library Modules are available only with C++20 or later.
+#endif // ^^^ !_HAS_CXX20 ^^^
+#define _EXPORT_STD export
+#else // ^^^ defined(_BUILD_STD_MODULE) / !defined(_BUILD_STD_MODULE) vvv
+#define _EXPORT_STD
+#endif // ^^^ !defined(_BUILD_STD_MODULE) ^^^
+
+// P0607R0 Inline Variables For The STL
+#if _HAS_CXX17
+#define _INLINE_VAR inline
+#else
+#define _INLINE_VAR
+#endif
+
+// N4190 Removing auto_ptr, random_shuffle(), And Old <functional> Stuff
+#ifndef _HAS_AUTO_PTR_ETC
+#define _HAS_AUTO_PTR_ETC (!_HAS_CXX17)
+#endif // !defined(_HAS_AUTO_PTR_ETC)
+
+// P0003R5 Removing Dynamic Exception Specifications
+#ifndef _HAS_UNEXPECTED
+#define _HAS_UNEXPECTED (!_HAS_CXX17)
+#endif // !defined(_HAS_UNEXPECTED)
+
+#if _HAS_UNEXPECTED && _HAS_CXX23
+_EMIT_STL_ERROR(STL1004, "C++98 unexpected() is incompatible with C++23 unexpected<E>.");
+#endif // _HAS_UNEXPECTED && _HAS_CXX23
+
+// P0004R1 Removing Deprecated Iostreams Aliases
+#ifndef _HAS_OLD_IOSTREAMS_MEMBERS
+#define _HAS_OLD_IOSTREAMS_MEMBERS (!_HAS_CXX17)
+#endif // !defined(_HAS_OLD_IOSTREAMS_MEMBERS)
+
+// P0298R3 std::byte
+#ifndef _HAS_STD_BYTE
+#define _HAS_STD_BYTE _HAS_CXX17
+#endif // !defined(_HAS_STD_BYTE)
+
+// P0302R1 Removing Allocator Support In std::function
+// LWG-2385 function::assign allocator argument doesn't make sense
+// LWG-2921 packaged_task and type-erased allocators
+// LWG-2976 Dangling uses_allocator specialization for packaged_task
+#ifndef _HAS_FUNCTION_ALLOCATOR_SUPPORT
+#define _HAS_FUNCTION_ALLOCATOR_SUPPORT (!_HAS_CXX17)
+#endif // !defined(_HAS_FUNCTION_ALLOCATOR_SUPPORT)
+
+// The non-Standard std::tr1 namespace and TR1-only machinery
+#ifndef _HAS_TR1_NAMESPACE
+#define _HAS_TR1_NAMESPACE (!_HAS_CXX17)
+#endif // !defined(_HAS_TR1_NAMESPACE)
+
+// STL4000 is "_STATIC_CPPLIB is deprecated", currently in yvals.h
+// STL4001 is "/clr:pure is deprecated", currently in yvals.h
+
+#if _HAS_TR1_NAMESPACE
+#ifdef _SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING
+#define _DEPRECATE_TR1_NAMESPACE
+#else // ^^^ warning disabled / warning enabled vvv
+#define _DEPRECATE_TR1_NAMESPACE                                                                                  \
+    [[deprecated(                                                                                                 \
+        "warning STL4002: "                                                                                       \
+        "The non-Standard std::tr1 namespace and TR1-only machinery are deprecated and will be REMOVED. You can " \
+        "define _SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING to suppress this warning.")]]
+#endif // ^^^ warning enabled ^^^
+#endif // _HAS_TR1_NAMESPACE
+
+// STL4003 was "The non-Standard std::identity struct is deprecated and will be REMOVED."
+
+// Enforcement of matching allocator value_types
+#ifndef _ENFORCE_MATCHING_ALLOCATORS
+#define _ENFORCE_MATCHING_ALLOCATORS _HAS_CXX17
+#endif // !defined(_ENFORCE_MATCHING_ALLOCATORS)
+
+#define _MISMATCHED_ALLOCATOR_MESSAGE(_CONTAINER, _VALUE_TYPE)                                                      \
+    _CONTAINER " requires that Allocator's value_type match " _VALUE_TYPE " (See N4950 [container.alloc.reqmts]/5)" \
+               " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0"                      \
+               " to suppress this error."
+
+// Enforcement of Standard facet specializations
+#ifndef _ENFORCE_FACET_SPECIALIZATIONS
+#define _ENFORCE_FACET_SPECIALIZATIONS 0
+#endif // !defined(_ENFORCE_FACET_SPECIALIZATIONS)
+
+#define _FACET_SPECIALIZATION_MESSAGE                                                  \
+    "Unsupported facet specialization; see N4950 [locale.category]. "                  \
+    "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " \
+    "to suppress this error."
+
+// To improve compiler throughput, use 'hidden friend' operators in <system_error> instead of non-members that are
+// depicted in the Standard.
+#ifndef _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS
+#define _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS 1
+#endif // !defined(_STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS)
+
+// Controls whether the STL will force /fp:fast to enable vectorization of algorithms defined
+// in the standard as special cases; such as reduce, transform_reduce, inclusive_scan, exclusive_scan
+#ifndef _STD_VECTORIZE_WITH_FLOAT_CONTROL
+#ifdef _M_FP_EXCEPT
+#define _STD_VECTORIZE_WITH_FLOAT_CONTROL 0
+#else // ^^^ floating-point exceptions enabled / floating-point exceptions disabled (default) vvv
+#define _STD_VECTORIZE_WITH_FLOAT_CONTROL 1
+#endif // ^^^ floating-point exceptions disabled (default) ^^^
+#endif // !defined(_STD_VECTORIZE_WITH_FLOAT_CONTROL)
+
+// P0174R2 Deprecating Vestigial Library Parts
+// P0521R0 Deprecating shared_ptr::unique()
+// Other C++17 deprecation warnings
+
+// N4659 D.4 [depr.cpp.headers]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_C_HEADER                                                               \
+    [[deprecated("warning STL4004: "                                                            \
+                 "<ccomplex>, <cstdalign>, <cstdbool>, and <ctgmath> are deprecated in C++17. " \
+                 "You can define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING "                  \
+                 "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_C_HEADER
+#endif // ^^^ warning disabled ^^^
+
+// N4659 D.6 [depr.str.strstreams]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_STRSTREAM_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_STRSTREAM                                              \
+    [[deprecated("warning STL4005: <strstream> is deprecated in C++17. "        \
+                 "You can define _SILENCE_CXX17_STRSTREAM_DEPRECATION_WARNING " \
+                 "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_STRSTREAM
+#endif // ^^^ warning disabled ^^^
+
+// N4659 D.7 [depr.uncaught]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_UNCAUGHT_EXCEPTION_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_UNCAUGHT_EXCEPTION                                              \
+    [[deprecated("warning STL4006: "                                                     \
+                 "std::uncaught_exception() is deprecated in C++17. "                    \
+                 "It is superseded by std::uncaught_exceptions(), plural. "              \
+                 "You can define _SILENCE_CXX17_UNCAUGHT_EXCEPTION_DEPRECATION_WARNING " \
+                 "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_UNCAUGHT_EXCEPTION
+#endif // ^^^ warning disabled ^^^
+
+// N4659 D.8.1 [depr.weak.result_type]
+// N4659 D.8.2 [depr.func.adaptor.typedefs]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS                                                                         \
+    [[deprecated(                                                                                                 \
+        "warning STL4007: Many result_type typedefs "                                                             \
+        "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " \
+        "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING "                                     \
+        "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS
+#endif // ^^^ warning disabled ^^^
+
+// N4659 D.8.3 [depr.negators]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_NEGATORS_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_NEGATORS                                                                                \
+    [[deprecated("warning STL4008: "                                                                             \
+                 "std::not1(), std::not2(), std::unary_negate, and std::binary_negate are deprecated in C++17. " \
+                 "They are superseded by std::not_fn(). "                                                        \
+                 "You can define _SILENCE_CXX17_NEGATORS_DEPRECATION_WARNING "                                   \
+                 "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_NEGATORS
+#endif // ^^^ warning disabled ^^^
+
+// STL4009 was "std::allocator<void> is deprecated in C++17"
+
+// N4659 D.9 [depr.default.allocator]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS                                              \
+    [[deprecated("warning STL4010: "                                                        \
+                 "Various members of std::allocator are deprecated in C++17. "              \
+                 "Use std::allocator_traits instead of accessing these members directly. "  \
+                 "You can define _SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING " \
+                 "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS
+#endif // ^^^ warning disabled ^^^
+
+// N4659 D.10 [depr.storage.iterator]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_RAW_STORAGE_ITERATOR_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_RAW_STORAGE_ITERATOR                                                  \
+    [[deprecated("warning STL4011: "                                                           \
+                 "std::raw_storage_iterator is deprecated in C++17. "                          \
+                 "Consider using the std::uninitialized_copy() family of algorithms instead. " \
+                 "You can define _SILENCE_CXX17_RAW_STORAGE_ITERATOR_DEPRECATION_WARNING "     \
+                 "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_RAW_STORAGE_ITERATOR
+#endif // ^^^ warning disabled ^^^
+
+// N4659 D.11 [depr.temporary.buffer]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_TEMPORARY_BUFFER_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_TEMPORARY_BUFFER                                                                   \
+    [[deprecated("warning STL4012: "                                                                        \
+                 "std::get_temporary_buffer() and std::return_temporary_buffer() are deprecated in C++17. " \
+                 "You can define _SILENCE_CXX17_TEMPORARY_BUFFER_DEPRECATION_WARNING "                      \
+                 "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_TEMPORARY_BUFFER
+#endif // ^^^ warning disabled ^^^
+
+// N4659 D.12 [depr.meta.types]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_IS_LITERAL_TYPE_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_IS_LITERAL_TYPE                                                     \
+    [[deprecated("warning STL4013: "                                                         \
+                 "std::is_literal_type and std::is_literal_type_v are deprecated in C++17. " \
+                 "You can define _SILENCE_CXX17_IS_LITERAL_TYPE_DEPRECATION_WARNING "        \
+                 "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_IS_LITERAL_TYPE
+#endif // ^^^ warning disabled ^^^
+
+// N4659 D.12 [depr.meta.types]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_RESULT_OF_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_RESULT_OF                                                      \
+    [[deprecated("warning STL4014: "                                                    \
+                 "std::result_of and std::result_of_t are deprecated in C++17. "        \
+                 "They are superseded by std::invoke_result and std::invoke_result_t. " \
+                 "You can define _SILENCE_CXX17_RESULT_OF_DEPRECATION_WARNING "         \
+                 "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_RESULT_OF
+#endif // ^^^ warning disabled ^^^
+
+// N4659 D.13 [depr.iterator.primitives]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_ITERATOR_BASE_CLASS_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_ITERATOR_BASE_CLASS                                                                          \
+    [[deprecated(                                                                                                     \
+        "warning STL4015: "                                                                                           \
+        "The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17. "        \
+        "(The <iterator> header is NOT deprecated.) The C++ Standard has never required user-defined iterators to "   \
+        "derive from std::iterator. To fix this warning, stop deriving from std::iterator and start providing "       \
+        "publicly accessible typedefs named iterator_category, value_type, difference_type, pointer, and reference. " \
+        "Note that value_type is required to be non-const, even for constant iterators. "                             \
+        "You can define _SILENCE_CXX17_ITERATOR_BASE_CLASS_DEPRECATION_WARNING "                                      \
+        "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_ITERATOR_BASE_CLASS
+#endif // ^^^ warning disabled ^^^
+
+// N4659 D.14 [depr.util.smartptr.shared.obs]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_SHARED_PTR_UNIQUE_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_SHARED_PTR_UNIQUE                                              \
+    [[deprecated("warning STL4016: "                                                    \
+                 "std::shared_ptr::unique() is deprecated in C++17. "                   \
+                 "You can define _SILENCE_CXX17_SHARED_PTR_UNIQUE_DEPRECATION_WARNING " \
+                 "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_SHARED_PTR_UNIQUE
+#endif // ^^^ warning disabled ^^^
+
+// N4659 D.15 [depr.locale.stdcvt]
+// N4659 D.16 [depr.conversions]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_CODECVT_HEADER                                                                        \
+    [[deprecated(                                                                                              \
+        "warning STL4017: "                                                                                    \
+        "std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, " \
+        "std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. "        \
+        "(The std::codecvt class template is NOT deprecated.) "                                                \
+        "The C++ Standard doesn't provide equivalent non-deprecated functionality; "                           \
+        "consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. "            \
+        "You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING "                                    \
+        "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_CODECVT_HEADER
+#endif // ^^^ warning disabled ^^^
+
+// STL4018 was "The non-Standard std::tr2::sys namespace is deprecated and will be REMOVED."
+
+// STL4019 was "The member std::fpos::seekpos() is non-Standard, and [...] will be removed"
+
+// P0482R6 Library Support For char8_t
+// Other C++20 deprecation warnings
+
+// N4868 D.23 [depr.locale.category]
+#if _HAS_CXX20 && !defined(_SILENCE_CXX20_CODECVT_FACETS_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
+#define _CXX20_DEPRECATE_CODECVT_FACETS                                                                                \
+    [[deprecated("warning STL4020: "                                                                                   \
+                 "std::codecvt<char16_t, char, mbstate_t>, std::codecvt<char32_t, char, mbstate_t>, "                  \
+                 "std::codecvt_byname<char16_t, char, mbstate_t>, and std::codecvt_byname<char32_t, char, mbstate_t> " \
+                 "are deprecated in C++20. You can define _SILENCE_CXX20_CODECVT_FACETS_DEPRECATION_WARNING "          \
+                 "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX20_DEPRECATE_CODECVT_FACETS
+#endif // ^^^ warning disabled ^^^
+
+// N4868 D.24 [depr.fs.path.factory]
+#if _HAS_CXX20 && defined(__cpp_char8_t) && !defined(_SILENCE_CXX20_U8PATH_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
+#define _CXX20_DEPRECATE_U8PATH                                                                                      \
+    [[deprecated("warning STL4021: "                                                                                 \
+                 "The std::filesystem::u8path() overloads are deprecated in C++20. "                                 \
+                 "The constructors of std::filesystem::path provide equivalent functionality via construction from " \
+                 "u8string, u8string_view, or iterators with value_type char8_t. "                                   \
+                 "You can define _SILENCE_CXX20_U8PATH_DEPRECATION_WARNING "                                         \
+                 "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX20_DEPRECATE_U8PATH
+#endif // ^^^ warning disabled ^^^
+
+// STL4022 warned about "The hash_meow and unordered_meow containers' non-Standard lower_bound() member"
+// STL4023 warned about "The hash_meow and unordered_meow containers' non-Standard upper_bound() member"
+
+// P0966R1 [depr.string.capacity]
+#if _HAS_CXX20 && !defined(_SILENCE_CXX20_STRING_RESERVE_WITHOUT_ARGUMENT_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
+#define _CXX20_DEPRECATE_STRING_RESERVE_WITHOUT_ARGUMENT                                                             \
+    [[deprecated("warning STL4024: "                                                                                 \
+                 "std::string::reserve() without an argument is deprecated in C++20. "                               \
+                 "To shrink the string's capacity, use std::string::shrink_to_fit() instead. Otherwise, provide an " \
+                 "argument to std::string::reserve(). "                                                              \
+                 "You can define _SILENCE_CXX20_STRING_RESERVE_WITHOUT_ARGUMENT_DEPRECATION_WARNING "                \
+                 "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX20_DEPRECATE_STRING_RESERVE_WITHOUT_ARGUMENT
+#endif // ^^^ warning disabled ^^^
+
+// P0767R1 [depr.meta.types]
+#if _HAS_CXX20 && !defined(_SILENCE_CXX20_IS_POD_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
+#define _CXX20_DEPRECATE_IS_POD                                                                                     \
+    [[deprecated("warning STL4025: "                                                                                \
+                 "std::is_pod and std::is_pod_v are deprecated in C++20. "                                          \
+                 "The std::is_trivially_copyable and/or std::is_standard_layout traits likely suit your use case. " \
+                 "You can define _SILENCE_CXX20_IS_POD_DEPRECATION_WARNING "                                        \
+                 "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX20_DEPRECATE_IS_POD
+#endif // ^^^ warning disabled ^^^
+
+// STL4026 was
+// "std::experimental::erase() and std::experimental::erase_if() are deprecated by Microsoft and will be REMOVED."
+
+// P0768R1 [depr.relops]
+#if _HAS_CXX20 && !defined(_SILENCE_CXX20_REL_OPS_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
+#define _CXX20_DEPRECATE_REL_OPS                                                                                      \
+    [[deprecated("warning STL4027: "                                                                                  \
+                 "The namespace std::rel_ops and its contents are deprecated in C++20. "                              \
+                 "Their use is superseded by C++20's <=> operator and automatic rewrites of relational expressions. " \
+                 "You can define _SILENCE_CXX20_REL_OPS_DEPRECATION_WARNING or "                                      \
+                 "_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX20_DEPRECATE_REL_OPS
+#endif // ^^^ warning disabled ^^^
+
+#if _HAS_CXX20 && !defined(_SILENCE_CXX20_ATOMIC_INIT_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
+#define _CXX20_DEPRECATE_ATOMIC_INIT                                                  \
+    [[deprecated("warning STL4028: "                                                  \
+                 "std::atomic_init() overloads are deprecated in C++20. "             \
+                 "The constructors of std::atomic provide equivalent functionality. " \
+                 "You can define _SILENCE_CXX20_ATOMIC_INIT_DEPRECATION_WARNING "     \
+                 "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX20_DEPRECATE_ATOMIC_INIT
+#endif // ^^^ warning disabled ^^^
+
+#if _HAS_CXX20 && !defined(_SILENCE_CXX20_OLD_SHARED_PTR_ATOMIC_SUPPORT_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
+#define _CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT                                              \
+    [[deprecated("warning STL4029: "                                                                \
+                 "std::atomic_*() overloads for shared_ptr are deprecated in C++20. "               \
+                 "The shared_ptr specialization of std::atomic provides superior functionality. "   \
+                 "You can define _SILENCE_CXX20_OLD_SHARED_PTR_ATOMIC_SUPPORT_DEPRECATION_WARNING " \
+                 "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT
+#endif // ^^^ warning disabled ^^^
+
+#if _HAS_CXX20 && !defined(_SILENCE_CXX20_VOLATILE_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
+#define _CXX20_DEPRECATE_VOLATILE                                                                   \
+    [[deprecated("warning STL4030: "                                                                \
+                 "Some operations on volatile-qualified types in the STL are deprecated in C++20. " \
+                 "You can define _SILENCE_CXX20_VOLATILE_DEPRECATION_WARNING "                      \
+                 "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX20_DEPRECATE_VOLATILE
+#endif // ^^^ warning disabled ^^^
+
+#if _HAS_CXX20 && !defined(_SILENCE_CXX20_MOVE_ITERATOR_ARROW_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
+#define _CXX20_DEPRECATE_MOVE_ITERATOR_ARROW                                              \
+    [[deprecated("warning STL4031: "                                                      \
+                 "std::move_iterator::operator->() is deprecated in C++20. "              \
+                 "You can define _SILENCE_CXX20_MOVE_ITERATOR_ARROW_DEPRECATION_WARNING " \
+                 "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX20_DEPRECATE_MOVE_ITERATOR_ARROW
+#endif // ^^^ warning disabled ^^^
+
+// STL4032 was "std::pmr::polymorphic_allocator::destroy() is deprecated in C++17 by LWG-3036." (reverted by P2875R4)
+
+#if _HAS_CXX20 && !defined(_SILENCE_CXX20_IS_ALWAYS_EQUAL_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
+#define _CXX20_DEPRECATE_IS_ALWAYS_EQUAL                                                \
+    [[deprecated("warning STL4033: "                                                    \
+                 "std::allocator::is_always_equal is deprecated in C++20 by LWG-3170. " \
+                 "Prefer std::allocator_traits<allocator<T>>::is_always_equal. "        \
+                 "You can define _SILENCE_CXX20_IS_ALWAYS_EQUAL_DEPRECATION_WARNING "   \
+                 "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX20_DEPRECATE_IS_ALWAYS_EQUAL
+#endif // ^^^ warning disabled ^^^
+
+#if _HAS_CXX23 && !defined(_SILENCE_CXX23_ALIGNED_STORAGE_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX23_DEPRECATION_WARNINGS)
+#define _CXX23_DEPRECATE_ALIGNED_STORAGE                                                     \
+    [[deprecated("warning STL4034: "                                                         \
+                 "std::aligned_storage and std::aligned_storage_t are deprecated in C++23. " \
+                 "Prefer alignas(T) std::byte t_buff[sizeof(T)]. "                           \
+                 "You can define _SILENCE_CXX23_ALIGNED_STORAGE_DEPRECATION_WARNING "        \
+                 "or _SILENCE_ALL_CXX23_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX23_DEPRECATE_ALIGNED_STORAGE
+#endif // ^^^ warning disabled ^^^
+
+#if _HAS_CXX23 && !defined(_SILENCE_CXX23_ALIGNED_UNION_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX23_DEPRECATION_WARNINGS)
+#define _CXX23_DEPRECATE_ALIGNED_UNION                                                   \
+    [[deprecated("warning STL4035: "                                                     \
+                 "std::aligned_union and std::aligned_union_t are deprecated in C++23. " \
+                 "Prefer alignas(Ts...) std::byte t_buff[std::max({sizeof(Ts)...})]. "   \
+                 "You can define _SILENCE_CXX23_ALIGNED_UNION_DEPRECATION_WARNING "      \
+                 "or _SILENCE_ALL_CXX23_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX23_DEPRECATE_ALIGNED_UNION
+#endif // ^^^ warning disabled ^^^
+
+#if _HAS_CXX20 && !defined(_SILENCE_CXX20_CISO646_REMOVED_WARNING) && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
+#define _CXX20_REMOVE_CISO646                                             \
+    [[deprecated("warning STL4036: "                                      \
+                 "<ciso646> is removed in C++20. "                        \
+                 "You can define _SILENCE_CXX20_CISO646_REMOVED_WARNING " \
+                 "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX20_REMOVE_CISO646
+#endif // ^^^ warning disabled ^^^
+
+#if !defined(_SILENCE_NONFLOATING_COMPLEX_DEPRECATION_WARNING)
+#define _DEPRECATE_NONFLOATING_COMPLEX                                                 \
+    [[deprecated("warning STL4037: "                                                   \
+                 "The effect of instantiating the template std::complex for any "      \
+                 "type other than float, double, or long double is unspecified. "      \
+                 "You can define _SILENCE_NONFLOATING_COMPLEX_DEPRECATION_WARNING to " \
+                 "suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _DEPRECATE_NONFLOATING_COMPLEX
+#endif // ^^^ warning disabled ^^^
+
+// STL4038 is used to warn that "The contents of <meow> are available only with C++NN or later."
+
+// STL4039 is used to warn that "The contents of <coroutine> are not available with /await."
+
+// STL4040 is used to warn that "The contents of <any> require static RTTI."
+
+#if _HAS_CXX23 && !defined(_SILENCE_CXX23_UNIX_STREAMS_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX23_DEPRECATION_WARNINGS)
+#define _CXX23_DEPRECATE_UNIX_STREAMS                                                                                  \
+    [[deprecated(                                                                                                      \
+        "warning STL4041: "                                                                                            \
+        "std::errc enumerators std::errc::no_message_available, std::errc::no_stream_resources, "                      \
+        "std::errc::not_a_stream, and std::errc::stream_timeout and their corresponding errno macros ENODATA, ENOSR, " \
+        "ENOSTR, and ETIME are deprecated in C++23 by LWG-3869. These errno macros are deprecated in POSIX 2008 and "  \
+        "removed in POSIX 202x. You can define _SILENCE_CXX23_UNIX_STREAMS_DEPRECATION_WARNING or "                    \
+        "_SILENCE_ALL_CXX23_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX23_DEPRECATE_UNIX_STREAMS
+#endif // ^^^ warning disabled ^^^
+
+#if _HAS_CXX23 && !defined(_SILENCE_CXX23_DENORM_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX23_DEPRECATION_WARNINGS)
+#define _CXX23_DEPRECATE_DENORM                                                                                        \
+    [[deprecated("warning STL4042: "                                                                                   \
+                 "std::float_denorm_style, std::numeric_limits::has_denorm, and std::numeric_limits::has_denorm_loss " \
+                 "are deprecated in C++23. You can define _SILENCE_CXX23_DENORM_DEPRECATION_WARNING or "               \
+                 "_SILENCE_ALL_CXX23_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX23_DEPRECATE_DENORM
+#endif // ^^^ warning disabled ^^^
+
+#if !defined(_SILENCE_STDEXT_ARR_ITERS_DEPRECATION_WARNING) && !defined(_SILENCE_ALL_MS_EXT_DEPRECATION_WARNINGS)
+#define _DEPRECATE_STDEXT_ARR_ITERS                                                                               \
+    [[deprecated(                                                                                                 \
+        "warning STL4043: stdext::checked_array_iterator, stdext::unchecked_array_iterator, and related factory " \
+        "functions are non-Standard extensions and will be removed in the future. std::span (since C++20) and "   \
+        "gsl::span can be used instead. You can define _SILENCE_STDEXT_ARR_ITERS_DEPRECATION_WARNING or "         \
+        "_SILENCE_ALL_MS_EXT_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _DEPRECATE_STDEXT_ARR_ITERS
+#endif // ^^^ warning disabled ^^^
+
+// STL4044 was "The contents of the stdext::cvt namespace are non-Standard extensions and will be removed"
+
+#if !defined(_SILENCE_IO_PFX_SFX_DEPRECATION_WARNING) && !defined(_SILENCE_ALL_MS_EXT_DEPRECATION_WARNINGS)
+#define _DEPRECATE_IO_PFX_SFX                                                                                          \
+    [[deprecated(                                                                                                      \
+        "warning STL4045: The ipfx(), isfx(), opfx(), and osfx() functions are removed before C++98 (see WG21-N0794) " \
+        "but kept as non-Standard extensions. They will be removed in the future, and the member classes sentry "      \
+        "should be used instead. You can define _SILENCE_IO_PFX_SFX_DEPRECATION_WARNING or "                           \
+        "_SILENCE_ALL_MS_EXT_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _DEPRECATE_IO_PFX_SFX
+#endif // ^^^ warning disabled ^^^
+
+#if !defined(_SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING) && !defined(_SILENCE_TR1_RANDOM_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_MS_EXT_DEPRECATION_WARNINGS)
+#define _DEPRECATE_TR1_RANDOM                                                                                          \
+    [[deprecated("warning STL4046: Non-Standard TR1 components in <random> are deprecated and will be REMOVED. You "   \
+                 "can define _SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING, _SILENCE_TR1_RANDOM_DEPRECATION_WARNING, or " \
+                 "_SILENCE_ALL_MS_EXT_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _DEPRECATE_TR1_RANDOM
+#endif // ^^^ warning disabled ^^^
+
+#if _HAS_CXX20 && defined(__cpp_char8_t) && !defined(_SILENCE_CXX20_CODECVT_CHAR8_T_FACETS_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
+#define _CXX20_DEPRECATE_CODECVT_CHAR8_T_FACETS                                                                     \
+    [[deprecated(                                                                                                   \
+        "warning STL4047: std::codecvt<char16_t, char8_t, mbstate_t>, std::codecvt<char32_t, char8_t, mbstate_t>, " \
+        "std::codecvt_byname<char16_t, char8_t, mbstate_t>, and std::codecvt_byname<char32_t, char8_t, mbstate_t> " \
+        "are deprecated by LWG-3767. You can define _SILENCE_CXX20_CODECVT_CHAR8_T_FACETS_DEPRECATION_WARNING or "  \
+        "_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX20_DEPRECATE_CODECVT_CHAR8_T_FACETS
+#endif // ^^^ warning disabled ^^^
+
+// next warning number: STL4048
+
+// next error number: STL1006
+
+// P0619R4 Removing C++17-Deprecated Features
+#ifndef _HAS_FEATURES_REMOVED_IN_CXX20
+#define _HAS_FEATURES_REMOVED_IN_CXX20 (!_HAS_CXX20)
+#endif // !defined(_HAS_FEATURES_REMOVED_IN_CXX20)
+
+#ifndef _HAS_DEPRECATED_ADAPTOR_TYPEDEFS
+#define _HAS_DEPRECATED_ADAPTOR_TYPEDEFS (_HAS_FEATURES_REMOVED_IN_CXX20)
+#endif // !defined(_HAS_DEPRECATED_ADAPTOR_TYPEDEFS)
+
+#ifndef _HAS_DEPRECATED_ALLOCATOR_MEMBERS
+#define _HAS_DEPRECATED_ALLOCATOR_MEMBERS (_HAS_FEATURES_REMOVED_IN_CXX20)
+#endif // !defined(_HAS_DEPRECATED_ALLOCATOR_MEMBERS)
+
+#ifndef _HAS_DEPRECATED_ALLOCATOR_VOID
+#define _HAS_DEPRECATED_ALLOCATOR_VOID (_HAS_FEATURES_REMOVED_IN_CXX20)
+#endif // !defined(_HAS_DEPRECATED_ALLOCATOR_VOID)
+
+#ifndef _HAS_DEPRECATED_IS_LITERAL_TYPE
+#define _HAS_DEPRECATED_IS_LITERAL_TYPE (_HAS_FEATURES_REMOVED_IN_CXX20)
+#endif // !defined(_HAS_DEPRECATED_IS_LITERAL_TYPE)
+
+#ifndef _HAS_DEPRECATED_NEGATORS
+#define _HAS_DEPRECATED_NEGATORS (_HAS_FEATURES_REMOVED_IN_CXX20)
+#endif // !defined(_HAS_DEPRECATED_NEGATORS)
+
+#ifndef _HAS_DEPRECATED_RAW_STORAGE_ITERATOR
+#define _HAS_DEPRECATED_RAW_STORAGE_ITERATOR (_HAS_FEATURES_REMOVED_IN_CXX20)
+#endif // !defined(_HAS_DEPRECATED_RAW_STORAGE_ITERATOR)
+
+#ifndef _HAS_DEPRECATED_RESULT_OF
+#define _HAS_DEPRECATED_RESULT_OF (_HAS_FEATURES_REMOVED_IN_CXX20)
+#endif // !defined(_HAS_DEPRECATED_RESULT_OF)
+
+#ifndef _HAS_DEPRECATED_SHARED_PTR_UNIQUE
+#define _HAS_DEPRECATED_SHARED_PTR_UNIQUE (_HAS_FEATURES_REMOVED_IN_CXX20)
+#endif // !defined(_HAS_DEPRECATED_SHARED_PTR_UNIQUE)
+
+#ifndef _HAS_DEPRECATED_TEMPORARY_BUFFER
+#define _HAS_DEPRECATED_TEMPORARY_BUFFER (_HAS_FEATURES_REMOVED_IN_CXX20)
+#endif // !defined(_HAS_DEPRECATED_TEMPORARY_BUFFER)
+
+#ifndef _HAS_DEPRECATED_UNCAUGHT_EXCEPTION
+#define _HAS_DEPRECATED_UNCAUGHT_EXCEPTION (_HAS_FEATURES_REMOVED_IN_CXX20)
+#endif // !defined(_HAS_DEPRECATED_UNCAUGHT_EXCEPTION)
+
+#if _HAS_DEPRECATED_ADAPTOR_TYPEDEFS
+#define _ARGUMENT_TYPE_NAME        argument_type
+#define _FIRST_ARGUMENT_TYPE_NAME  first_argument_type
+#define _SECOND_ARGUMENT_TYPE_NAME second_argument_type
+#define _RESULT_TYPE_NAME          result_type
+#else // ^^^ _HAS_DEPRECATED_ADAPTOR_TYPEDEFS / !_HAS_DEPRECATED_ADAPTOR_TYPEDEFS vvv
+#define _ARGUMENT_TYPE_NAME        _Unnameable_argument
+#define _FIRST_ARGUMENT_TYPE_NAME  _Unnameable_first_argument
+#define _SECOND_ARGUMENT_TYPE_NAME _Unnameable_second_argument
+#define _RESULT_TYPE_NAME          _Unnameable_result
+#endif // ^^^ !_HAS_DEPRECATED_ADAPTOR_TYPEDEFS ^^^
+
+// P1423R3 char8_t Backward Compatibility Remediation
+// Controls whether we allow the stream insertions this proposal forbids
+#ifndef _HAS_STREAM_INSERTION_OPERATORS_DELETED_IN_CXX20
+#define _HAS_STREAM_INSERTION_OPERATORS_DELETED_IN_CXX20 (_HAS_FEATURES_REMOVED_IN_CXX20)
+#endif // !defined(_HAS_STREAM_INSERTION_OPERATORS_DELETED_IN_CXX20)
+
+#ifndef _HAS_FEATURES_REMOVED_IN_CXX23
+#define _HAS_FEATURES_REMOVED_IN_CXX23 (!_HAS_CXX23)
+#endif // !defined(_HAS_FEATURES_REMOVED_IN_CXX23)
+
+// P2186R2 Removing Garbage Collection Support
+#ifndef _HAS_GARBAGE_COLLECTION_SUPPORT_DELETED_IN_CXX23
+#define _HAS_GARBAGE_COLLECTION_SUPPORT_DELETED_IN_CXX23 (_HAS_FEATURES_REMOVED_IN_CXX23)
+#endif // !defined(_HAS_GARBAGE_COLLECTION_SUPPORT_DELETED_IN_CXX23)
+
+// C++14
+#define __cpp_lib_chrono_udls                      201304L
+#define __cpp_lib_complex_udls                     201309L
+#define __cpp_lib_exchange_function                201304L
+#define __cpp_lib_freestanding_algorithm           202311L
+#define __cpp_lib_freestanding_array               202311L
+#define __cpp_lib_freestanding_char_traits         202306L
+#define __cpp_lib_freestanding_cstdlib             202306L
+#define __cpp_lib_freestanding_cstring             202311L
+#define __cpp_lib_freestanding_cwchar              202306L
+#define __cpp_lib_freestanding_errc                202306L
+#define __cpp_lib_freestanding_feature_test_macros 202306L
+#define __cpp_lib_freestanding_functional          202306L
+#define __cpp_lib_freestanding_iterator            202306L
+#define __cpp_lib_freestanding_memory              202306L
+#define __cpp_lib_freestanding_operator_new        202306L
+#define __cpp_lib_freestanding_ratio               202306L
+#define __cpp_lib_freestanding_tuple               202306L
+#define __cpp_lib_freestanding_utility             202306L
+#define __cpp_lib_generic_associative_lookup       201304L
+#define __cpp_lib_integer_sequence                 201304L
+#define __cpp_lib_integral_constant_callable       201304L
+#define __cpp_lib_is_final                         201402L
+#define __cpp_lib_is_null_pointer                  201309L
+#define __cpp_lib_make_reverse_iterator            201402L
+#define __cpp_lib_make_unique                      201304L
+#define __cpp_lib_null_iterators                   201304L
+#define __cpp_lib_quoted_string_io                 201304L
+#define __cpp_lib_result_of_sfinae                 201210L
+#define __cpp_lib_robust_nonmodifying_seq_ops      201304L
+#ifndef _M_CEE_PURE
+#define __cpp_lib_shared_timed_mutex 201402L
+#endif // !defined(_M_CEE_PURE)
+#define __cpp_lib_string_udls                  201304L
+#define __cpp_lib_transformation_trait_aliases 201304L
+#define __cpp_lib_tuple_element_t              201402L
+#define __cpp_lib_tuples_by_type               201304L
+
+// C++17
+#define __cpp_lib_addressof_constexpr              201603L
+#define __cpp_lib_allocator_traits_is_always_equal 201411L
+#define __cpp_lib_as_const                         201510L
+#define __cpp_lib_bool_constant                    201505L
+#define __cpp_lib_enable_shared_from_this          201603L
+#define __cpp_lib_incomplete_container_elements    201505L
+#define __cpp_lib_invoke                           201411L
+#define __cpp_lib_logical_traits                   201510L
+#define __cpp_lib_map_try_emplace                  201411L
+#define __cpp_lib_nonmember_container_access       201411L
+#define __cpp_lib_shared_mutex                     201505L
+#define __cpp_lib_transparent_operators            201510L
+#define __cpp_lib_type_trait_variable_templates    201510L
+#define __cpp_lib_uncaught_exceptions              201411L
+#define __cpp_lib_unordered_map_try_emplace        201411L
+#define __cpp_lib_void_t                           201411L
+
+#if _HAS_CXX17
+#if _HAS_STATIC_RTTI
+#define __cpp_lib_any 201606L
+#endif // _HAS_STATIC_RTTI
+#define __cpp_lib_apply                      201603L
+#define __cpp_lib_atomic_is_always_lock_free 201603L
+#define __cpp_lib_boyer_moore_searcher       201603L
+#if _HAS_STD_BYTE
+#define __cpp_lib_byte 201603L
+#endif // _HAS_STD_BYTE
+#define __cpp_lib_clamp                             201603L
+#define __cpp_lib_filesystem                        201703L
+#define __cpp_lib_freestanding_charconv             202306L
+#define __cpp_lib_freestanding_optional             202311L
+#define __cpp_lib_freestanding_string_view          202311L
+#define __cpp_lib_freestanding_variant              202311L
+#define __cpp_lib_gcd_lcm                           201606L
+#define __cpp_lib_hardware_interference_size        201703L
+#define __cpp_lib_has_unique_object_representations 201606L
+#define __cpp_lib_hypot                             201603L
+#define __cpp_lib_is_aggregate                      201703L
+#define __cpp_lib_is_invocable                      201703L
+#define __cpp_lib_is_swappable                      201603L
+#define __cpp_lib_launder                           201606L
+#define __cpp_lib_make_from_tuple                   201606L
+#define __cpp_lib_math_special_functions            201603L
+#define __cpp_lib_memory_resource                   201603L
+#define __cpp_lib_node_extract                      201606L
+#define __cpp_lib_not_fn                            201603L
+#ifndef _M_CEE_PURE
+#define __cpp_lib_parallel_algorithm 201603L
+#endif // !defined(_M_CEE_PURE)
+#define __cpp_lib_raw_memory_algorithms 201606L
+#define __cpp_lib_sample                201603L
+#define __cpp_lib_scoped_lock           201703L
+#define __cpp_lib_shared_ptr_weak_type  201606L
+#define __cpp_lib_string_view           201803L
+#define __cpp_lib_to_chars              201611L
+#endif // _HAS_CXX17
+
+// C++20
+#define __cpp_lib_atomic_value_initialization 201911L
+
+#ifdef __cpp_char8_t
+#define __cpp_lib_char8_t 201907L
+#endif // defined(__cpp_char8_t)
+
+#ifdef __cpp_impl_coroutine
+#define __cpp_lib_coroutine 201902L
+#endif // defined(__cpp_impl_coroutine)
+
+#if _HAS_CXX20
+#define __cpp_lib_algorithm_iterator_requirements 202207L
+#define __cpp_lib_assume_aligned                  201811L
+#define __cpp_lib_atomic_flag_test                201907L
+#define __cpp_lib_atomic_float                    201711L
+#define __cpp_lib_atomic_lock_free_type_aliases   201907L
+#define __cpp_lib_atomic_ref                      201806L
+#define __cpp_lib_atomic_shared_ptr               201711L
+#define __cpp_lib_atomic_wait                     201907L
+#define __cpp_lib_barrier                         202302L
+#define __cpp_lib_bind_front                      201907L
+#define __cpp_lib_bit_cast                        201806L
+#define __cpp_lib_bitops                          201907L
+#define __cpp_lib_bounded_array_traits            201902L
+#define __cpp_lib_common_reference                202302L
+#define __cpp_lib_common_reference_wrapper        202302L
+#define __cpp_lib_constexpr_algorithms            201806L
+#define __cpp_lib_constexpr_complex               201711L
+#define __cpp_lib_constexpr_dynamic_alloc         201907L
+#define __cpp_lib_constexpr_functional            201907L
+#define __cpp_lib_constexpr_iterator              201811L
+#define __cpp_lib_constexpr_numeric               201911L
+#define __cpp_lib_constexpr_string                201907L
+#define __cpp_lib_constexpr_string_view           201811L
+#define __cpp_lib_constexpr_tuple                 201811L
+#define __cpp_lib_constexpr_utility               201811L
+#define __cpp_lib_constexpr_vector                201907L
+#define __cpp_lib_destroying_delete               201806L
+#define __cpp_lib_endian                          201907L
+#define __cpp_lib_erase_if                        202002L
+#define __cpp_lib_format                          202304L
+#define __cpp_lib_format_uchar                    202311L
+#define __cpp_lib_freestanding_ranges             202306L
+#define __cpp_lib_generic_unordered_lookup        201811L
+#define __cpp_lib_int_pow2                        202002L
+#define __cpp_lib_integer_comparison_functions    202002L
+#define __cpp_lib_interpolate                     201902L
+#define __cpp_lib_is_constant_evaluated           201811L
+
+#ifndef __clang__ // TRANSITION, LLVM-48860
+#define __cpp_lib_is_layout_compatible 201907L
+#endif // ^^^ no workaround ^^^
+
+#define __cpp_lib_is_nothrow_convertible 201806L
+
+#ifndef __clang__ // TRANSITION, LLVM-48860
+#define __cpp_lib_is_pointer_interconvertible 201907L
+#endif // ^^^ no workaround ^^^
+
+#define __cpp_lib_jthread                 201911L
+#define __cpp_lib_latch                   201907L
+#define __cpp_lib_list_remove_return_type 201806L
+#define __cpp_lib_math_constants          201907L
+
+#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, Clang and EDG support for modules
+#define __cpp_lib_modules 202207L
+#endif // ^^^ no workaround ^^^
+
+#define __cpp_lib_move_iterator_concept   202207L
+#define __cpp_lib_polymorphic_allocator   201902L
+#define __cpp_lib_remove_cvref            201711L
+#define __cpp_lib_semaphore               201907L
+#define __cpp_lib_smart_ptr_for_overwrite 202002L
+#define __cpp_lib_source_location         201907L
+#define __cpp_lib_span                    202002L
+#define __cpp_lib_ssize                   201902L
+#define __cpp_lib_starts_ends_with        201711L
+#define __cpp_lib_syncbuf                 201803L
+#define __cpp_lib_three_way_comparison    201907L
+#define __cpp_lib_to_address              201711L
+#define __cpp_lib_to_array                201907L
+#define __cpp_lib_type_identity           201806L
+#define __cpp_lib_unwrap_ref              201811L
+#endif // _HAS_CXX20
+
+// C++23
+#if _HAS_CXX23
+#define __cpp_lib_adaptor_iterator_pair_constructor 202106L
+#define __cpp_lib_allocate_at_least                 202302L
+#define __cpp_lib_associative_heterogeneous_erasure 202110L
+#define __cpp_lib_bind_back                         202202L
+#define __cpp_lib_byteswap                          202110L
+#define __cpp_lib_constexpr_bitset                  202207L
+#define __cpp_lib_constexpr_charconv                202207L
+#define __cpp_lib_constexpr_typeinfo                202106L
+#define __cpp_lib_containers_ranges                 202202L
+#define __cpp_lib_expected                          202211L
+#define __cpp_lib_format_ranges                     202207L
+#define __cpp_lib_formatters                        202302L
+#define __cpp_lib_forward_like                      202207L
+#define __cpp_lib_freestanding_expected             202311L
+#define __cpp_lib_freestanding_mdspan               202311L
+#define __cpp_lib_invoke_r                          202106L
+#define __cpp_lib_ios_noreplace                     202207L
+#define __cpp_lib_is_scoped_enum                    202011L
+#define __cpp_lib_mdspan                            202207L
+#define __cpp_lib_move_only_function                202110L
+#define __cpp_lib_out_ptr                           202311L
+#define __cpp_lib_print                             202207L
+#define __cpp_lib_ranges_as_const                   202311L
+#define __cpp_lib_ranges_as_rvalue                  202207L
+#define __cpp_lib_ranges_cartesian_product          202207L
+#define __cpp_lib_ranges_chunk                      202202L
+#define __cpp_lib_ranges_chunk_by                   202202L
+#define __cpp_lib_ranges_contains                   202207L
+#define __cpp_lib_ranges_enumerate                  202302L
+#define __cpp_lib_ranges_find_last                  202207L
+#define __cpp_lib_ranges_fold                       202207L
+#define __cpp_lib_ranges_iota                       202202L
+#define __cpp_lib_ranges_join_with                  202202L
+#define __cpp_lib_ranges_repeat                     202207L
+#define __cpp_lib_ranges_slide                      202202L
+#define __cpp_lib_ranges_starts_ends_with           202106L
+#define __cpp_lib_ranges_stride                     202207L
+#define __cpp_lib_ranges_to_container               202202L
+#define __cpp_lib_ranges_zip                        202110L
+#define __cpp_lib_spanstream                        202106L
+#define __cpp_lib_stacktrace                        202011L
+#define __cpp_lib_stdatomic_h                       202011L
+#define __cpp_lib_string_contains                   202011L
+#define __cpp_lib_string_resize_and_overwrite       202110L
+#define __cpp_lib_to_underlying                     202102L
+#define __cpp_lib_tuple_like                        202207L
+#define __cpp_lib_unreachable                       202202L
+#endif // _HAS_CXX23
+
+// macros with language mode sensitivity
+#if _HAS_CXX20
+#define __cpp_lib_array_constexpr 201811L // P1032R1 Miscellaneous constexpr
+#elif _HAS_CXX17
+#define __cpp_lib_array_constexpr 201803L // P0858R0 Constexpr Iterator Requirements
+#endif
+
+#if _HAS_CXX20
+#define __cpp_lib_chrono 201907L // P1466R3 Miscellaneous Minor Fixes For <chrono>
+#elif _HAS_CXX17
+#define __cpp_lib_chrono 201611L // P0505R0 constexpr For <chrono> (Again)
+#else
+#define __cpp_lib_chrono 201510L // P0092R1 <chrono> floor(), ceil(), round(), abs()
+#endif
+
+#if _HAS_CXX23
+#define __cpp_lib_concepts 202207L // P2404R3 Move-Only Types For Comparison Concepts
+#elif _HAS_CXX20
+#define __cpp_lib_concepts 202002L // P1964R2 Replacing boolean With boolean-testable
+#endif
+
+#if _HAS_CXX23
+#define __cpp_lib_constexpr_memory 202202L // P2273R3 constexpr unique_ptr
+#elif _HAS_CXX20
+#define __cpp_lib_constexpr_memory 201811L // P1006R1 constexpr For pointer_traits<T*>::pointer_to()
+#endif
+
+#ifndef _M_CEE_PURE
+#if _HAS_CXX20
+#define __cpp_lib_execution 201902L // P1001R2 execution::unseq
+#elif _HAS_CXX17
+#define __cpp_lib_execution 201603L // P0024R2 Parallel Algorithms
+#endif // language mode
+#endif // !defined(_M_CEE_PURE)
+
+#if _HAS_CXX23
+#define __cpp_lib_optional 202110L // P0798R8 Monadic Operations For optional
+#elif _HAS_CXX20
+#define __cpp_lib_optional 202106L // P2231R1 Completing constexpr In optional And variant
+#elif _HAS_CXX17
+#define __cpp_lib_optional 201606L // P0307R2 Making Optional Greater Equal Again
+#endif
+
+#if _HAS_CXX23
+// P2997R1 Removing The Common Reference Requirement From The Indirectly Invocable Concepts
+#define __cpp_lib_ranges 202406L
+#elif _HAS_CXX20
+#define __cpp_lib_ranges 202110L // P2415R2 What Is A view?
+#endif
+
+#if _HAS_CXX20
+#define __cpp_lib_shared_ptr_arrays 201707L // P0674R1 make_shared() For Arrays
+#else
+#define __cpp_lib_shared_ptr_arrays 201611L // P0497R0 Fixing shared_ptr For Arrays
+#endif
+
+#if _HAS_CXX23
+#define __cpp_lib_shift 202202L // P2440R1 ranges::shift_left, ranges::shift_right
+#elif _HAS_CXX20
+#define __cpp_lib_shift 201806L // P0769R2 shift_left(), shift_right()
+#endif
+
+#if _HAS_CXX20
+#define __cpp_lib_variant 202106L // P2231R1 Completing constexpr In optional And variant
+#elif _HAS_CXX17
+#define __cpp_lib_variant 202102L // P2162R2 Inheriting From variant
+#endif
+
+#define __cpp_lib_experimental_filesystem 201406L
+
+#ifdef _RTC_CONVERSION_CHECKS_ENABLED
+#ifndef _ALLOW_RTCc_IN_STL
+#error /RTCc rejects conformant code, so it is not supported by the C++ Standard Library. Either remove this \
+compiler option, or define _ALLOW_RTCc_IN_STL to suppress this error.
+#endif // !defined(_ALLOW_RTCc_IN_STL)
+#endif // defined(_RTC_CONVERSION_CHECKS_ENABLED)
+
+#define _EMPTY_ARGUMENT // for empty macro argument
+
+// extern "C++" attaches declarations to the global module, see N4964 [module.unit]/7.2.
+// It has no effect in C++14/17.
+
+// In the STL's headers (which might be used to build the named module std), we unconditionally
+// and directly mark declarations of our separately compiled machinery as extern "C++", allowing
+// the named module to work with the separately compiled code (which is always built classically).
+
+// TRANSITION: _USE_EXTERN_CXX_EVERYWHERE_FOR_STL controls whether we also wrap the STL's
+// header-only code in this linkage-specification, as a temporary workaround to allow
+// importing the named module in a translation unit with classic includes.
+
+#ifndef _USE_EXTERN_CXX_EVERYWHERE_FOR_STL
+#define _USE_EXTERN_CXX_EVERYWHERE_FOR_STL _HAS_CXX20
+#endif // ^^^ !defined(_USE_EXTERN_CXX_EVERYWHERE_FOR_STL) ^^^
+
+#if _USE_EXTERN_CXX_EVERYWHERE_FOR_STL
+#define _EXTERN_CXX_WORKAROUND     extern "C++" {
+#define _END_EXTERN_CXX_WORKAROUND }
+#else // ^^^ _USE_EXTERN_CXX_EVERYWHERE_FOR_STL / !_USE_EXTERN_CXX_EVERYWHERE_FOR_STL vvv
+#define _EXTERN_CXX_WORKAROUND
+#define _END_EXTERN_CXX_WORKAROUND
+#endif // ^^^ !_USE_EXTERN_CXX_EVERYWHERE_FOR_STL ^^^
+
+#define _STD_BEGIN         \
+    _EXTERN_CXX_WORKAROUND \
+    namespace std {
+#define _STD_END \
+    }            \
+    _END_EXTERN_CXX_WORKAROUND
+
+#define _STD    ::std::
+#define _CHRONO ::std::chrono::
+#define _RANGES ::std::ranges::
+
+// We use the stdext (standard extension) namespace to contain non-standard extensions
+#pragma push_macro("stdext")
+#undef stdext
+#define _STDEXT_BEGIN      \
+    _EXTERN_CXX_WORKAROUND \
+    namespace stdext {
+#define _STDEXT_END \
+    }               \
+    _END_EXTERN_CXX_WORKAROUND
+
+#define _STDEXT ::stdext::
+#pragma pop_macro("stdext")
+
+#define _CSTD ::
+
+#ifdef _M_CEE_PURE
+#define _EXTERN_C_UNLESS_PURE
+#define _END_EXTERN_C_UNLESS_PURE
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+#define _EXTERN_C_UNLESS_PURE     extern "C" {
+#define _END_EXTERN_C_UNLESS_PURE } // extern "C"
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+
+#if defined(MRTDLL) && !defined(_CRTBLD)
+#error In yvals_core.h, defined(MRTDLL) implies defined(_CRTBLD); !defined(_CRTBLD) implies !defined(MRTDLL)
+#endif // defined(MRTDLL) && !defined(_CRTBLD)
+
+#if defined(MRTDLL) && !defined(_M_CEE_PURE)
+#error In yvals_core.h, defined(MRTDLL) implies defined(_M_CEE_PURE); !defined(_M_CEE_PURE) implies !defined(MRTDLL)
+#endif // defined(MRTDLL) && !defined(_M_CEE_PURE)
+
+#define _STL_WIN32_WINNT_VISTA 0x0600 // _WIN32_WINNT_VISTA from sdkddkver.h
+#define _STL_WIN32_WINNT_WIN7  0x0601 // _WIN32_WINNT_WIN7 from sdkddkver.h
+#define _STL_WIN32_WINNT_WIN8  0x0602 // _WIN32_WINNT_WIN8 from sdkddkver.h
+#define _STL_WIN32_WINNT_WIN10 0x0A00 // _WIN32_WINNT_WIN10 from sdkddkver.h
+
+// Note that the STL DLL builds will set this to XP for ABI compatibility with VS2015 which supported XP.
+#ifndef _STL_WIN32_WINNT
+#if defined(_M_ARM64)
+// The first ARM64 Windows was Windows 10
+#define _STL_WIN32_WINNT _STL_WIN32_WINNT_WIN10
+#elif defined(_M_ARM) || defined(_ONECORE) || defined(_CRT_APP)
+// The first ARM or OneCore or App Windows was Windows 8
+#define _STL_WIN32_WINNT _STL_WIN32_WINNT_WIN8
+#else // ^^^ default to Win8 / default to Win7 vvv
+// The earliest Windows supported by this implementation is Windows 7
+#define _STL_WIN32_WINNT _STL_WIN32_WINNT_WIN7
+#endif // ^^^ !defined(_M_ARM) && !defined(_M_ARM64) && !defined(_ONECORE) && !defined(_CRT_APP) ^^^
+#endif // !defined(_STL_WIN32_WINNT)
+
+#ifdef __cpp_noexcept_function_type
+#define _NOEXCEPT_FNPTR noexcept
+#else // ^^^ defined(__cpp_noexcept_function_type) / !defined(__cpp_noexcept_function_type) vvv
+#define _NOEXCEPT_FNPTR
+#endif // ^^^ !defined(__cpp_noexcept_function_type) ^^^
+
+#ifdef __clang__
+#define _STL_INTRIN_HEADER <intrin.h>
+#define _STL_UNREACHABLE   __builtin_unreachable()
+#else // ^^^ defined(__clang__) / !defined(__clang__) vvv
+#define _STL_INTRIN_HEADER <intrin0.h>
+#define _STL_UNREACHABLE   __assume(false)
+#endif // ^^^ !defined(__clang__) ^^^
+
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+#define _STL_INTERNAL_STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+#else // ^^^ defined(_ENABLE_STL_INTERNAL_CHECK) / !defined(_ENABLE_STL_INTERNAL_CHECK) vvv
+#define _STL_INTERNAL_STATIC_ASSERT(...)
+#endif // ^^^ !defined(_ENABLE_STL_INTERNAL_CHECK) ^^^
+
+#ifdef __cpp_static_call_operator
+#define _STATIC_CALL_OPERATOR static
+#define _CONST_CALL_OPERATOR
+#else // ^^^ defined(__cpp_static_call_operator) / !defined(__cpp_static_call_operator) vvv
+#define _STATIC_CALL_OPERATOR
+#define _CONST_CALL_OPERATOR const
+#endif // ^^^ !defined(__cpp_static_call_operator) ^^^
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _YVALS_CORE_H_
diff --git a/miniMSVC/VC/Tools/MSVC/14.42.34433/include/zmmintrin.h b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/zmmintrin.h
new file mode 100644
index 0000000000000000000000000000000000000000..5da68e786256ca0b2a34c7450584ce7f8777d2fc
--- /dev/null
+++ b/miniMSVC/VC/Tools/MSVC/14.42.34433/include/zmmintrin.h
@@ -0,0 +1,6311 @@
+/*
+ *  Copyright (C) 2007-2021 Intel Corporation.
+ *
+ *  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+/***
+* zmmintrin.h - Meta Header file for Intel(R) Architecture intrinsic functions.
+*
+*******************************************************************************/
+
+
+#ifndef _ZMMINTRIN_H_INCLUDED
+#define _ZMMINTRIN_H_INCLUDED
+
+#ifndef _INCLUDED_IMM
+#error "Header should only be included from <immintrin.h>."
+#endif
+
+//
+// Definitions and declarations for use with 512-bit compiler intrinsics.
+//
+
+//
+// A word about intrinsic function naming conventions.  Most 512-bit
+// vector instructions have names such as v<operation><type>.  For
+// example "vaddps" is an addition operation (add) on packed single-
+// precision (ps) values.  The corresponding intrinsic is usually
+// (not always) named _mm512_<operation>_<type>. For example, the
+// "_mm512_add_ps" function generates VADDPS.  The corresponding
+// masked flavor adds "_mask" to the name, e.g. "_mm512_mask_add_ps".
+//
+// The types include:
+//
+//    ps    -- packed single precision
+//    pd    -- packed double precision
+//    epi32 -- packed 32-bit integers
+//    epu32 -- packed 32-bit unsigned integers
+//    epi64 -- packed 64-bit integers
+//
+
+typedef unsigned char       __mmask8;
+typedef unsigned short      __mmask16;
+typedef unsigned int        __mmask32;
+typedef unsigned __int64    __mmask64;
+
+typedef union __declspec(intrin_type) __declspec(align(64)) __m512 {
+    float m512_f32[16];
+} __m512;
+
+typedef struct __declspec(intrin_type) __declspec(align(64)) __m512d {
+    double m512d_f64[8];
+} __m512d;
+
+typedef union  __declspec(intrin_type) __declspec(align(64)) __m512i {
+    __int8              m512i_i8[64];
+    __int16             m512i_i16[32];
+    __int32             m512i_i32[16];
+    __int64             m512i_i64[8];
+    unsigned __int8     m512i_u8[64];
+    unsigned __int16    m512i_u16[32];
+    unsigned __int32    m512i_u32[16];
+    unsigned __int64    m512i_u64[8];
+} __m512i;
+
+
+#ifdef __cplusplus
+extern "C" {
+// Intrinsic functions use C name-mangling.
+#endif /* __cplusplus */
+
+/* Conversion from one type to another, no change in value. */
+extern __m256  __cdecl _mm512_castps512_ps256(__m512);
+extern __m512  __cdecl _mm512_castpd_ps(__m512d);
+extern __m512  __cdecl _mm512_castps256_ps512(__m256);
+extern __m512  __cdecl _mm512_castsi512_ps(__m512i);
+extern __m512  __cdecl _mm512_castps128_ps512(__m128);
+
+extern __m256d __cdecl _mm512_castpd512_pd256(__m512d);
+extern __m512d __cdecl _mm512_castpd256_pd512(__m256d);
+extern __m512d __cdecl _mm512_castps_pd(__m512);
+extern __m512d __cdecl _mm512_castsi512_pd(__m512i);
+extern __m512d __cdecl _mm512_castpd128_pd512(__m128d);
+
+extern __m256i __cdecl _mm512_castsi512_si256(__m512i);
+extern __m512i __cdecl _mm512_castpd_si512(__m512d);
+extern __m512i __cdecl _mm512_castps_si512(__m512);
+extern __m512i __cdecl _mm512_castsi256_si512(__m256i);
+
+/* Constant for special read-only mask register 'k0'. */
+#define _MM_K0_REG8  (0xff)
+#define _MM_K0_REG16 (0xffff)
+#define _MM_K0_REG32 (0xffffffff)
+#define _MM_K0_REG64 (0xffffffffffffffff)
+
+/* Constants for broadcasts to vectors with 32-bit elements. */
+typedef enum {
+    _MM_BROADCAST32_NONE,   /* identity swizzle/convert */
+#define _MM_BROADCAST_16X16 _MM_BROADCAST32_NONE
+    _MM_BROADCAST_1X16,     /* broadcast x 16 ( aaaa aaaa aaaa aaaa ) */
+    _MM_BROADCAST_4X16      /* broadcast x 4  ( dcba dcba dcba dcba ) */
+} _MM_BROADCAST32_ENUM;
+
+/* Constants for broadcasts to vectors with 64-bit elements. */
+typedef enum {
+    _MM_BROADCAST64_NONE,   /* identity swizzle/convert */
+#define _MM_BROADCAST_8X8 _MM_BROADCAST64_NONE
+    _MM_BROADCAST_1X8,      /* broadcast x 8 ( aaaa aaaa ) */
+    _MM_BROADCAST_4X8       /* broadcast x 2 ( dcba dcba ) */
+} _MM_BROADCAST64_ENUM;
+
+/*
+ * Constants for rounding mode.
+ * These names beginning with "_MM_ROUND" are deprecated.
+ * Use the names beginning with "_MM_FROUND" going forward.
+ */
+typedef enum {
+    _MM_ROUND_MODE_NEAREST,             /* round to nearest (even) */
+    _MM_ROUND_MODE_DOWN,                /* round toward negative infinity */
+    _MM_ROUND_MODE_UP,                  /* round toward positive infinity */
+    _MM_ROUND_MODE_TOWARD_ZERO,         /* round toward zero */
+    _MM_ROUND_MODE_DEFAULT,             /* round mode from MXCSR */
+    _MM_ROUND_MODE_NO_EXC = 8,          /* suppress all exceptions */
+} _MM_ROUND_MODE_ENUM;
+
+/* Constants for exponent adjustment. */
+typedef enum {
+    _MM_EXPADJ_NONE,               /* 2**0  (32.0 - no exp adjustment) */
+    _MM_EXPADJ_4,                  /* 2**4  (28.4)  */
+    _MM_EXPADJ_5,                  /* 2**5  (27.5)  */
+    _MM_EXPADJ_8,                  /* 2**8  (24.8)  */
+    _MM_EXPADJ_16,                 /* 2**16 (16.16) */
+    _MM_EXPADJ_24,                 /* 2**24 (8.24)  */
+    _MM_EXPADJ_31,                 /* 2**31 (1.31)  */
+    _MM_EXPADJ_32                  /* 2**32 (0.32)  */
+} _MM_EXP_ADJ_ENUM;
+
+/* Constants for index scale (vgather/vscatter). */
+typedef enum {
+    _MM_SCALE_1 = 1,
+    _MM_SCALE_2 = 2,
+    _MM_SCALE_4 = 4,
+    _MM_SCALE_8 = 8
+} _MM_INDEX_SCALE_ENUM;
+
+/* Constants for permute/shuffle. */
+typedef enum {
+    _MM_PERM_AAAA = 0x00, _MM_PERM_AAAB = 0x01, _MM_PERM_AAAC = 0x02,
+    _MM_PERM_AAAD = 0x03, _MM_PERM_AABA = 0x04, _MM_PERM_AABB = 0x05,
+    _MM_PERM_AABC = 0x06, _MM_PERM_AABD = 0x07, _MM_PERM_AACA = 0x08,
+    _MM_PERM_AACB = 0x09, _MM_PERM_AACC = 0x0A, _MM_PERM_AACD = 0x0B,
+    _MM_PERM_AADA = 0x0C, _MM_PERM_AADB = 0x0D, _MM_PERM_AADC = 0x0E,
+    _MM_PERM_AADD = 0x0F, _MM_PERM_ABAA = 0x10, _MM_PERM_ABAB = 0x11,
+    _MM_PERM_ABAC = 0x12, _MM_PERM_ABAD = 0x13, _MM_PERM_ABBA = 0x14,
+    _MM_PERM_ABBB = 0x15, _MM_PERM_ABBC = 0x16, _MM_PERM_ABBD = 0x17,
+    _MM_PERM_ABCA = 0x18, _MM_PERM_ABCB = 0x19, _MM_PERM_ABCC = 0x1A,
+    _MM_PERM_ABCD = 0x1B, _MM_PERM_ABDA = 0x1C, _MM_PERM_ABDB = 0x1D,
+    _MM_PERM_ABDC = 0x1E, _MM_PERM_ABDD = 0x1F, _MM_PERM_ACAA = 0x20,
+    _MM_PERM_ACAB = 0x21, _MM_PERM_ACAC = 0x22, _MM_PERM_ACAD = 0x23,
+    _MM_PERM_ACBA = 0x24, _MM_PERM_ACBB = 0x25, _MM_PERM_ACBC = 0x26,
+    _MM_PERM_ACBD = 0x27, _MM_PERM_ACCA = 0x28, _MM_PERM_ACCB = 0x29,
+    _MM_PERM_ACCC = 0x2A, _MM_PERM_ACCD = 0x2B, _MM_PERM_ACDA = 0x2C,
+    _MM_PERM_ACDB = 0x2D, _MM_PERM_ACDC = 0x2E, _MM_PERM_ACDD = 0x2F,
+    _MM_PERM_ADAA = 0x30, _MM_PERM_ADAB = 0x31, _MM_PERM_ADAC = 0x32,
+    _MM_PERM_ADAD = 0x33, _MM_PERM_ADBA = 0x34, _MM_PERM_ADBB = 0x35,
+    _MM_PERM_ADBC = 0x36, _MM_PERM_ADBD = 0x37, _MM_PERM_ADCA = 0x38,
+    _MM_PERM_ADCB = 0x39, _MM_PERM_ADCC = 0x3A, _MM_PERM_ADCD = 0x3B,
+    _MM_PERM_ADDA = 0x3C, _MM_PERM_ADDB = 0x3D, _MM_PERM_ADDC = 0x3E,
+    _MM_PERM_ADDD = 0x3F, _MM_PERM_BAAA = 0x40, _MM_PERM_BAAB = 0x41,
+    _MM_PERM_BAAC = 0x42, _MM_PERM_BAAD = 0x43, _MM_PERM_BABA = 0x44,
+    _MM_PERM_BABB = 0x45, _MM_PERM_BABC = 0x46, _MM_PERM_BABD = 0x47,
+    _MM_PERM_BACA = 0x48, _MM_PERM_BACB = 0x49, _MM_PERM_BACC = 0x4A,
+    _MM_PERM_BACD = 0x4B, _MM_PERM_BADA = 0x4C, _MM_PERM_BADB = 0x4D,
+    _MM_PERM_BADC = 0x4E, _MM_PERM_BADD = 0x4F, _MM_PERM_BBAA = 0x50,
+    _MM_PERM_BBAB = 0x51, _MM_PERM_BBAC = 0x52, _MM_PERM_BBAD = 0x53,
+    _MM_PERM_BBBA = 0x54, _MM_PERM_BBBB = 0x55, _MM_PERM_BBBC = 0x56,
+    _MM_PERM_BBBD = 0x57, _MM_PERM_BBCA = 0x58, _MM_PERM_BBCB = 0x59,
+    _MM_PERM_BBCC = 0x5A, _MM_PERM_BBCD = 0x5B, _MM_PERM_BBDA = 0x5C,
+    _MM_PERM_BBDB = 0x5D, _MM_PERM_BBDC = 0x5E, _MM_PERM_BBDD = 0x5F,
+    _MM_PERM_BCAA = 0x60, _MM_PERM_BCAB = 0x61, _MM_PERM_BCAC = 0x62,
+    _MM_PERM_BCAD = 0x63, _MM_PERM_BCBA = 0x64, _MM_PERM_BCBB = 0x65,
+    _MM_PERM_BCBC = 0x66, _MM_PERM_BCBD = 0x67, _MM_PERM_BCCA = 0x68,
+    _MM_PERM_BCCB = 0x69, _MM_PERM_BCCC = 0x6A, _MM_PERM_BCCD = 0x6B,
+    _MM_PERM_BCDA = 0x6C, _MM_PERM_BCDB = 0x6D, _MM_PERM_BCDC = 0x6E,
+    _MM_PERM_BCDD = 0x6F, _MM_PERM_BDAA = 0x70, _MM_PERM_BDAB = 0x71,
+    _MM_PERM_BDAC = 0x72, _MM_PERM_BDAD = 0x73, _MM_PERM_BDBA = 0x74,
+    _MM_PERM_BDBB = 0x75, _MM_PERM_BDBC = 0x76, _MM_PERM_BDBD = 0x77,
+    _MM_PERM_BDCA = 0x78, _MM_PERM_BDCB = 0x79, _MM_PERM_BDCC = 0x7A,
+    _MM_PERM_BDCD = 0x7B, _MM_PERM_BDDA = 0x7C, _MM_PERM_BDDB = 0x7D,
+    _MM_PERM_BDDC = 0x7E, _MM_PERM_BDDD = 0x7F, _MM_PERM_CAAA = 0x80,
+    _MM_PERM_CAAB = 0x81, _MM_PERM_CAAC = 0x82, _MM_PERM_CAAD = 0x83,
+    _MM_PERM_CABA = 0x84, _MM_PERM_CABB = 0x85, _MM_PERM_CABC = 0x86,
+    _MM_PERM_CABD = 0x87, _MM_PERM_CACA = 0x88, _MM_PERM_CACB = 0x89,
+    _MM_PERM_CACC = 0x8A, _MM_PERM_CACD = 0x8B, _MM_PERM_CADA = 0x8C,
+    _MM_PERM_CADB = 0x8D, _MM_PERM_CADC = 0x8E, _MM_PERM_CADD = 0x8F,
+    _MM_PERM_CBAA = 0x90, _MM_PERM_CBAB = 0x91, _MM_PERM_CBAC = 0x92,
+    _MM_PERM_CBAD = 0x93, _MM_PERM_CBBA = 0x94, _MM_PERM_CBBB = 0x95,
+    _MM_PERM_CBBC = 0x96, _MM_PERM_CBBD = 0x97, _MM_PERM_CBCA = 0x98,
+    _MM_PERM_CBCB = 0x99, _MM_PERM_CBCC = 0x9A, _MM_PERM_CBCD = 0x9B,
+    _MM_PERM_CBDA = 0x9C, _MM_PERM_CBDB = 0x9D, _MM_PERM_CBDC = 0x9E,
+    _MM_PERM_CBDD = 0x9F, _MM_PERM_CCAA = 0xA0, _MM_PERM_CCAB = 0xA1,
+    _MM_PERM_CCAC = 0xA2, _MM_PERM_CCAD = 0xA3, _MM_PERM_CCBA = 0xA4,
+    _MM_PERM_CCBB = 0xA5, _MM_PERM_CCBC = 0xA6, _MM_PERM_CCBD = 0xA7,
+    _MM_PERM_CCCA = 0xA8, _MM_PERM_CCCB = 0xA9, _MM_PERM_CCCC = 0xAA,
+    _MM_PERM_CCCD = 0xAB, _MM_PERM_CCDA = 0xAC, _MM_PERM_CCDB = 0xAD,
+    _MM_PERM_CCDC = 0xAE, _MM_PERM_CCDD = 0xAF, _MM_PERM_CDAA = 0xB0,
+    _MM_PERM_CDAB = 0xB1, _MM_PERM_CDAC = 0xB2, _MM_PERM_CDAD = 0xB3,
+    _MM_PERM_CDBA = 0xB4, _MM_PERM_CDBB = 0xB5, _MM_PERM_CDBC = 0xB6,
+    _MM_PERM_CDBD = 0xB7, _MM_PERM_CDCA = 0xB8, _MM_PERM_CDCB = 0xB9,
+    _MM_PERM_CDCC = 0xBA, _MM_PERM_CDCD = 0xBB, _MM_PERM_CDDA = 0xBC,
+    _MM_PERM_CDDB = 0xBD, _MM_PERM_CDDC = 0xBE, _MM_PERM_CDDD = 0xBF,
+    _MM_PERM_DAAA = 0xC0, _MM_PERM_DAAB = 0xC1, _MM_PERM_DAAC = 0xC2,
+    _MM_PERM_DAAD = 0xC3, _MM_PERM_DABA = 0xC4, _MM_PERM_DABB = 0xC5,
+    _MM_PERM_DABC = 0xC6, _MM_PERM_DABD = 0xC7, _MM_PERM_DACA = 0xC8,
+    _MM_PERM_DACB = 0xC9, _MM_PERM_DACC = 0xCA, _MM_PERM_DACD = 0xCB,
+    _MM_PERM_DADA = 0xCC, _MM_PERM_DADB = 0xCD, _MM_PERM_DADC = 0xCE,
+    _MM_PERM_DADD = 0xCF, _MM_PERM_DBAA = 0xD0, _MM_PERM_DBAB = 0xD1,
+    _MM_PERM_DBAC = 0xD2, _MM_PERM_DBAD = 0xD3, _MM_PERM_DBBA = 0xD4,
+    _MM_PERM_DBBB = 0xD5, _MM_PERM_DBBC = 0xD6, _MM_PERM_DBBD = 0xD7,
+    _MM_PERM_DBCA = 0xD8, _MM_PERM_DBCB = 0xD9, _MM_PERM_DBCC = 0xDA,
+    _MM_PERM_DBCD = 0xDB, _MM_PERM_DBDA = 0xDC, _MM_PERM_DBDB = 0xDD,
+    _MM_PERM_DBDC = 0xDE, _MM_PERM_DBDD = 0xDF, _MM_PERM_DCAA = 0xE0,
+    _MM_PERM_DCAB = 0xE1, _MM_PERM_DCAC = 0xE2, _MM_PERM_DCAD = 0xE3,
+    _MM_PERM_DCBA = 0xE4, _MM_PERM_DCBB = 0xE5, _MM_PERM_DCBC = 0xE6,
+    _MM_PERM_DCBD = 0xE7, _MM_PERM_DCCA = 0xE8, _MM_PERM_DCCB = 0xE9,
+    _MM_PERM_DCCC = 0xEA, _MM_PERM_DCCD = 0xEB, _MM_PERM_DCDA = 0xEC,
+    _MM_PERM_DCDB = 0xED, _MM_PERM_DCDC = 0xEE, _MM_PERM_DCDD = 0xEF,
+    _MM_PERM_DDAA = 0xF0, _MM_PERM_DDAB = 0xF1, _MM_PERM_DDAC = 0xF2,
+    _MM_PERM_DDAD = 0xF3, _MM_PERM_DDBA = 0xF4, _MM_PERM_DDBB = 0xF5,
+    _MM_PERM_DDBC = 0xF6, _MM_PERM_DDBD = 0xF7, _MM_PERM_DDCA = 0xF8,
+    _MM_PERM_DDCB = 0xF9, _MM_PERM_DDCC = 0xFA, _MM_PERM_DDCD = 0xFB,
+    _MM_PERM_DDDA = 0xFC, _MM_PERM_DDDB = 0xFD, _MM_PERM_DDDC = 0xFE,
+    _MM_PERM_DDDD = 0xFF
+} _MM_PERM_ENUM;
+
+/*
+ * Helper type and macro for computing the values of the immediate
+ * used in mm512_fixup_ps.
+ */
+typedef enum {
+    _MM_FIXUP_NO_CHANGE,
+    _MM_FIXUP_NEG_INF,
+    _MM_FIXUP_NEG_ZERO,
+    _MM_FIXUP_POS_ZERO,
+    _MM_FIXUP_POS_INF,
+    _MM_FIXUP_NAN,
+    _MM_FIXUP_MAX_FLOAT,
+    _MM_FIXUP_MIN_FLOAT
+} _MM_FIXUPRESULT_ENUM;
+
+#define _MM_FIXUP(_NegInf, \
+                  _Neg, \
+                  _NegZero, \
+                  _PosZero, \
+                  _Pos, \
+                  _PosInf, \
+                  _Nan) \
+   ((int) (_NegInf) | \
+   ((int) (_Neg) << 3) | \
+   ((int) (_NegZero) << 6) | \
+   ((int) (_PosZero) << 9) | \
+   ((int) (_Pos) << 12) | \
+   ((int) (_PosInf) << 15) | \
+   ((int) (_Nan) << 18))
+
+/*
+* Extract float32 or float64 normalized mantissas.
+*/
+
+/* Constants for mantissa extraction */
+typedef enum {
+    _MM_MANT_NORM_1_2,      /* interval [1, 2)      */
+    _MM_MANT_NORM_p5_2,     /* interval [1.5, 2)    */
+    _MM_MANT_NORM_p5_1,     /* interval [1.5, 1)    */
+    _MM_MANT_NORM_p75_1p5   /* interval [0.75, 1.5) */
+} _MM_MANTISSA_NORM_ENUM;
+
+typedef enum {
+    _MM_MANT_SIGN_src,      /* sign = sign(SRC)     */
+    _MM_MANT_SIGN_zero,     /* sign = 0             */
+    _MM_MANT_SIGN_nan       /* DEST = NaN if sign(SRC) = 1 */
+} _MM_MANTISSA_SIGN_ENUM;
+
+/*
+* Compare float32, float64 or int32 vectors and set mask.
+*/
+
+/* Constants for integer comparison predicates */
+typedef enum {
+    _MM_CMPINT_EQ,      /* Equal */
+    _MM_CMPINT_LT,      /* Less than */
+    _MM_CMPINT_LE,      /* Less than or Equal */
+    _MM_CMPINT_UNUSED,
+    _MM_CMPINT_NE,      /* Not Equal */
+    _MM_CMPINT_NLT,     /* Not Less than */
+#define _MM_CMPINT_GE   _MM_CMPINT_NLT  /* Greater than or Equal */
+    _MM_CMPINT_NLE      /* Not Less than or Equal */
+#define _MM_CMPINT_GT   _MM_CMPINT_NLE  /* Greater than */
+} _MM_CMPINT_ENUM;
+
+
+/*
+* Intel(R) AVX-512 intrinsic functions
+*/
+extern __m512  __cdecl _mm512_setzero_ps(void);
+extern __m512d __cdecl _mm512_setzero_pd(void);
+
+extern __m512  __cdecl _mm512_set_ps(float /* e15 */, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float /* e0 */);
+extern __m512d __cdecl _mm512_set_pd(double /* e7 */, double, double, double, double, double, double, double /* e0 */);
+
+extern __m512  __cdecl _mm512_setr_ps(float /* e0 */, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float /* e15 */);
+extern __m512d __cdecl _mm512_setr_pd(double /* e0 */, double, double, double, double, double, double, double /* e7 */);
+
+extern __m512  __cdecl _mm512_set1_ps(float);
+extern __m512d __cdecl _mm512_set1_pd(double);
+
+extern __m512  __cdecl _mm512_load_ps(void const*);
+extern __m512d __cdecl _mm512_load_pd(void const*);
+extern __m512  __cdecl _mm512_maskz_load_ps(__mmask16, void const*);
+extern __m512d __cdecl _mm512_maskz_load_pd(__mmask8, void const*);
+extern __m512  __cdecl _mm512_mask_load_ps(__m512, __mmask16, void const*);
+extern __m512d __cdecl _mm512_mask_load_pd(__m512d, __mmask8, void const*);
+extern __m512  __cdecl _mm512_loadu_ps(void const*);
+extern __m512d __cdecl _mm512_loadu_pd(void const*);
+extern __m512  __cdecl _mm512_maskz_loadu_ps(__mmask16, void const*);
+extern __m512d __cdecl _mm512_maskz_loadu_pd(__mmask8, void const*);
+extern __m512  __cdecl _mm512_mask_loadu_ps(__m512, __mmask16, void const*);
+extern __m512d __cdecl _mm512_mask_loadu_pd(__m512d, __mmask8, void const*);
+
+extern void    __cdecl _mm512_store_ps(void*, __m512);
+extern void    __cdecl _mm512_store_pd(void*, __m512d);
+extern void    __cdecl _mm512_storeu_ps(void*, __m512);
+extern void    __cdecl _mm512_storeu_pd(void*, __m512d);
+extern void    __cdecl _mm512_mask_store_ps(void*, __mmask16, __m512);
+extern void    __cdecl _mm512_mask_store_pd(void*, __mmask8, __m512d);
+extern void    __cdecl _mm512_mask_storeu_ps(void*, __mmask16, __m512);
+extern void    __cdecl _mm512_mask_storeu_pd(void*, __mmask8, __m512d);
+
+extern __m512  __cdecl _mm512_add_ps(__m512, __m512);
+extern __m512  __cdecl _mm512_maskz_add_ps(__mmask16, __m512, __m512);
+extern __m512  __cdecl _mm512_mask_add_ps(__m512, __mmask16, __m512, __m512);
+extern __m512  __cdecl _mm512_add_round_ps(__m512, __m512, const int /* rounding */);
+extern __m512  __cdecl _mm512_maskz_add_round_ps(__mmask16, __m512, __m512, const int /* rounding */);
+extern __m512  __cdecl _mm512_mask_add_round_ps(__m512, __mmask16, __m512, __m512, const int /* rounding */);
+extern __m512d __cdecl _mm512_add_pd(__m512d, __m512d);
+extern __m512d __cdecl _mm512_maskz_add_pd(__mmask8, __m512d, __m512d);
+extern __m512d __cdecl _mm512_mask_add_pd(__m512d, __mmask8, __m512d, __m512d);
+extern __m512d __cdecl _mm512_add_round_pd(__m512d, __m512d, const int /* rounding */);
+extern __m512d __cdecl _mm512_maskz_add_round_pd(__mmask8, __m512d, __m512d, const int /* rounding */);
+extern __m512d __cdecl _mm512_mask_add_round_pd(__m512d, __mmask8, __m512d, __m512d, const int /* rounding */);
+
+extern __m512  __cdecl _mm512_sub_ps(__m512, __m512);
+extern __m512  __cdecl _mm512_maskz_sub_ps(__mmask16, __m512, __m512);
+extern __m512  __cdecl _mm512_mask_sub_ps(__m512, __mmask16, __m512, __m512);
+extern __m512  __cdecl _mm512_sub_round_ps(__m512, __m512, const int /* rounding */);
+extern __m512  __cdecl _mm512_maskz_sub_round_ps(__mmask16, __m512, __m512, const int /* rounding */);
+extern __m512  __cdecl _mm512_mask_sub_round_ps(__m512, __mmask16, __m512, __m512, const int /* rounding */);
+extern __m512d __cdecl _mm512_sub_pd(__m512d, __m512d);
+extern __m512d __cdecl _mm512_maskz_sub_pd(__mmask8, __m512d, __m512d);
+extern __m512d __cdecl _mm512_mask_sub_pd(__m512d, __mmask8, __m512d, __m512d);
+extern __m512d __cdecl _mm512_sub_round_pd(__m512d, __m512d, const int /* rounding */);
+extern __m512d __cdecl _mm512_maskz_sub_round_pd(__mmask8, __m512d, __m512d, const int /* rounding */);
+extern __m512d __cdecl _mm512_mask_sub_round_pd(__m512d, __mmask8, __m512d, __m512d, const int /* rounding */);
+
+extern __m512  __cdecl _mm512_mul_ps(__m512, __m512);
+extern __m512  __cdecl _mm512_maskz_mul_ps(__mmask16, __m512, __m512);
+extern __m512  __cdecl _mm512_mask_mul_ps(__m512, __mmask16, __m512, __m512);
+extern __m512  __cdecl _mm512_mul_round_ps( __m512, __m512, const int /* rounding */);
+extern __m512  __cdecl _mm512_maskz_mul_round_ps(__mmask16, __m512, __m512, const int /* rounding */);
+extern __m512  __cdecl _mm512_mask_mul_round_ps(__m512, __mmask16, __m512, __m512, const int /* rounding */);
+extern __m512d __cdecl _mm512_mul_pd(__m512d, __m512d);
+extern __m512d __cdecl _mm512_maskz_mul_pd(__mmask8, __m512d, __m512d);
+extern __m512d __cdecl _mm512_mask_mul_pd(__m512d, __mmask8, __m512d, __m512d);
+extern __m512d __cdecl _mm512_mul_round_pd(__m512d, __m512d, const int /* rounding */);
+extern __m512d __cdecl _mm512_maskz_mul_round_pd(__mmask8, __m512d, __m512d, const int /* rounding */);
+extern __m512d __cdecl _mm512_mask_mul_round_pd(__m512d, __mmask8, __m512d, __m512d, const int /* rounding */);
+
+extern __m512  __cdecl _mm512_div_ps(__m512, __m512);
+extern __m512  __cdecl _mm512_maskz_div_ps(__mmask16, __m512, __m512);
+extern __m512  __cdecl _mm512_mask_div_ps(__m512, __mmask16, __m512, __m512);
+extern __m512  __cdecl _mm512_div_round_ps(__m512, __m512, const int /* rounding */);
+extern __m512  __cdecl _mm512_maskz_div_round_ps(__mmask16, __m512, __m512, const int /* rounding */);
+extern __m512  __cdecl _mm512_mask_div_round_ps(__m512, __mmask16, __m512, __m512, const int /* rounding */);
+extern __m512d __cdecl _mm512_div_pd(__m512d, __m512d);
+extern __m512d __cdecl _mm512_maskz_div_pd(__mmask8, __m512d, __m512d);
+extern __m512d __cdecl _mm512_mask_div_pd(__m512d, __mmask8, __m512d, __m512d);
+extern __m512d __cdecl _mm512_div_round_pd(__m512d, __m512d, const int /* rounding */);
+extern __m512d __cdecl _mm512_maskz_div_round_pd(__mmask8, __m512d, __m512d, const int /* rounding */);
+extern __m512d __cdecl _mm512_mask_div_round_pd(__m512d, __mmask8, __m512d, __m512d, const int /* rounding */);
+
+extern __m512  __cdecl _mm512_fmadd_ps(__m512, __m512, __m512);
+extern __m512  __cdecl _mm512_mask_fmadd_ps(__m512, __mmask16, __m512, __m512);
+extern __m512  __cdecl _mm512_mask3_fmadd_ps(__m512, __m512, __m512, __mmask16);
+extern __m512  __cdecl _mm512_maskz_fmadd_ps(__mmask16, __m512, __m512, __m512);
+extern __m512  __cdecl _mm512_fmadd_round_ps(__m512, __m512, __m512, const int /* rounding */);
+extern __m512  __cdecl _mm512_mask_fmadd_round_ps(__m512, __mmask16, __m512, __m512, const int /* rounding */);
+extern __m512  __cdecl _mm512_mask3_fmadd_round_ps(__m512, __m512, __m512, __mmask16, const int /* rounding */);
+extern __m512  __cdecl _mm512_maskz_fmadd_round_ps(__mmask16, __m512, __m512, __m512, const int /* rounding */);
+extern __m512d __cdecl _mm512_fmadd_pd(__m512d, __m512d, __m512d);
+extern __m512d __cdecl _mm512_mask_fmadd_pd(__m512d, __mmask8, __m512d, __m512d);
+extern __m512d __cdecl _mm512_mask3_fmadd_pd(__m512d, __m512d, __m512d, __mmask8);
+extern __m512d __cdecl _mm512_maskz_fmadd_pd(__mmask8, __m512d, __m512d, __m512d);
+extern __m512d __cdecl _mm512_fmadd_round_pd(__m512d, __m512d, __m512d, const int /* rounding */);
+extern __m512d __cdecl _mm512_mask_fmadd_round_pd(__m512d, __mmask8, __m512d, __m512d, const int /* rounding */);
+extern __m512d __cdecl _mm512_mask3_fmadd_round_pd(__m512d, __m512d, __m512d, __mmask8, const int /* rounding */);
+extern __m512d __cdecl _mm512_maskz_fmadd_round_pd(__mmask8, __m512d, __m512d, __m512d, const int /* rounding */);
+
+extern __m512  __cdecl _mm512_fmsub_ps(__m512, __m512, __m512);
+extern __m512  __cdecl _mm512_mask_fmsub_ps(__m512, __mmask16, __m512, __m512);
+extern __m512  __cdecl _mm512_mask3_fmsub_ps(__m512, __m512, __m512, __mmask16);
+extern __m512  __cdecl _mm512_maskz_fmsub_ps(__mmask16, __m512, __m512, __m512);
+extern __m512  __cdecl _mm512_fmsub_round_ps(__m512, __m512, __m512, const int /* rounding */);
+extern __m512  __cdecl _mm512_mask_fmsub_round_ps(__m512, __mmask16, __m512, __m512, const int /* rounding */);
+extern __m512  __cdecl _mm512_mask3_fmsub_round_ps(__m512, __m512, __m512, __mmask16, const int /* rounding */);
+extern __m512  __cdecl _mm512_maskz_fmsub_round_ps(__mmask16, __m512, __m512, __m512, const int /* rounding */);
+extern __m512d __cdecl _mm512_fmsub_pd(__m512d, __m512d, __m512d);
+extern __m512d __cdecl _mm512_mask_fmsub_pd(__m512d, __mmask8, __m512d, __m512d);
+extern __m512d __cdecl _mm512_mask3_fmsub_pd(__m512d, __m512d, __m512d, __mmask8);
+extern __m512d __cdecl _mm512_maskz_fmsub_pd(__mmask8, __m512d, __m512d, __m512d);
+extern __m512d __cdecl _mm512_fmsub_round_pd(__m512d, __m512d, __m512d, const int /* rounding */);
+extern __m512d __cdecl _mm512_mask_fmsub_round_pd(__m512d, __mmask8, __m512d, __m512d, const int /* rounding */);
+extern __m512d __cdecl _mm512_mask3_fmsub_round_pd(__m512d, __m512d, __m512d, __mmask8, const int /* rounding */);
+extern __m512d __cdecl _mm512_maskz_fmsub_round_pd(__mmask8, __m512d, __m512d, __m512d, const int /* rounding */);
+
+extern __m512  __cdecl _mm512_fmaddsub_ps(__m512, __m512, __m512);
+extern __m512  __cdecl _mm512_mask_fmaddsub_ps(__m512, __mmask16, __m512, __m512);
+extern __m512  __cdecl _mm512_mask3_fmaddsub_ps(__m512, __m512, __m512, __mmask16);
+extern __m512  __cdecl _mm512_maskz_fmaddsub_ps(__mmask16, __m512, __m512, __m512);
+extern __m512  __cdecl _mm512_fmaddsub_round_ps(__m512, __m512, __m512, const int /* rounding */);
+extern __m512  __cdecl _mm512_mask_fmaddsub_round_ps(__m512, __mmask16, __m512, __m512, const int /* rounding */);
+extern __m512  __cdecl _mm512_mask3_fmaddsub_round_ps(__m512, __m512, __m512, __mmask16, const int /* rounding */);
+extern __m512  __cdecl _mm512_maskz_fmaddsub_round_ps(__mmask16, __m512, __m512, __m512, const int /* rounding */);
+extern __m512d __cdecl _mm512_fmaddsub_pd(__m512d, __m512d, __m512d);
+extern __m512d __cdecl _mm512_mask_fmaddsub_pd(__m512d, __mmask8, __m512d, __m512d);
+extern __m512d __cdecl _mm512_mask3_fmaddsub_pd(__m512d, __m512d, __m512d, __mmask8);
+extern __m512d __cdecl _mm512_maskz_fmaddsub_pd(__mmask8, __m512d, __m512d, __m512d);
+extern __m512d __cdecl _mm512_fmaddsub_round_pd(__m512d, __m512d, __m512d, const int /* rounding */);
+extern __m512d __cdecl _mm512_mask_fmaddsub_round_pd(__m512d, __mmask8, __m512d, __m512d, const int /* rounding */);
+extern __m512d __cdecl _mm512_mask3_fmaddsub_round_pd(__m512d, __m512d, __m512d, __mmask8, const int /* rounding */);
+extern __m512d __cdecl _mm512_maskz_fmaddsub_round_pd(__mmask8, __m512d, __m512d, __m512d, const int /* rounding */);
+
+extern __m512  __cdecl _mm512_fmsubadd_ps(__m512, __m512, __m512);
+extern __m512  __cdecl _mm512_mask_fmsubadd_ps(__m512, __mmask16, __m512, __m512);
+extern __m512  __cdecl _mm512_mask3_fmsubadd_ps(__m512, __m512, __m512, __mmask16);
+extern __m512  __cdecl _mm512_maskz_fmsubadd_ps(__mmask16, __m512, __m512, __m512);
+extern __m512  __cdecl _mm512_fmsubadd_round_ps(__m512, __m512, __m512, const int /* rounding */);
+extern __m512  __cdecl _mm512_mask_fmsubadd_round_ps(__m512, __mmask16, __m512, __m512, const int /* rounding */);
+extern __m512  __cdecl _mm512_mask3_fmsubadd_round_ps(__m512, __m512, __m512, __mmask16, const int /* rounding */);
+extern __m512  __cdecl _mm512_maskz_fmsubadd_round_ps(__mmask16, __m512, __m512, __m512, const int /* rounding */);
+extern __m512d __cdecl _mm512_fmsubadd_pd(__m512d, __m512d, __m512d);
+extern __m512d __cdecl _mm512_mask_fmsubadd_pd(__m512d, __mmask8, __m512d, __m512d);
+extern __m512d __cdecl _mm512_mask3_fmsubadd_pd(__m512d, __m512d, __m512d, __mmask8);
+extern __m512d __cdecl _mm512_maskz_fmsubadd_pd(__mmask8, __m512d, __m512d, __m512d);
+extern __m512d __cdecl _mm512_fmsubadd_round_pd(__m512d, __m512d, __m512d, const int /* rounding */);
+extern __m512d __cdecl _mm512_mask_fmsubadd_round_pd(__m512d, __mmask8, __m512d, __m512d, const int /* rounding */);
+extern __m512d __cdecl _mm512_mask3_fmsubadd_round_pd(__m512d, __m512d, __m512d, __mmask8, const int /* rounding */);
+extern __m512d __cdecl _mm512_maskz_fmsubadd_round_pd(__mmask8, __m512d, __m512d, __m512d, const int /* rounding */);
+
+extern __m512  __cdecl _mm512_fnmadd_ps(__m512, __m512, __m512);
+extern __m512  __cdecl _mm512_mask_fnmadd_ps(__m512, __mmask16, __m512, __m512);
+extern __m512  __cdecl _mm512_mask3_fnmadd_ps(__m512, __m512, __m512, __mmask16);
+extern __m512  __cdecl _mm512_maskz_fnmadd_ps(__mmask16, __m512, __m512, __m512);
+extern __m512  __cdecl _mm512_fnmadd_round_ps(__m512, __m512, __m512, const int /* rounding */);
+extern __m512  __cdecl _mm512_mask_fnmadd_round_ps(__m512, __mmask16, __m512, __m512, const int /* rounding */);
+extern __m512  __cdecl _mm512_mask3_fnmadd_round_ps(__m512, __m512, __m512, __mmask16, const int /* rounding */);
+extern __m512  __cdecl _mm512_maskz_fnmadd_round_ps(__mmask16, __m512, __m512, __m512, const int /* rounding */);
+extern __m512d __cdecl _mm512_fnmadd_pd(__m512d, __m512d, __m512d);
+extern __m512d __cdecl _mm512_mask_fnmadd_pd(__m512d, __mmask8, __m512d, __m512d);
+extern __m512d __cdecl _mm512_mask3_fnmadd_pd(__m512d, __m512d, __m512d, __mmask8);
+extern __m512d __cdecl _mm512_maskz_fnmadd_pd(__mmask8, __m512d, __m512d, __m512d);
+extern __m512d __cdecl _mm512_fnmadd_round_pd(__m512d, __m512d, __m512d, const int /* rounding */);
+extern __m512d __cdecl _mm512_mask_fnmadd_round_pd(__m512d, __mmask8, __m512d, __m512d, const int /* rounding */);
+extern __m512d __cdecl _mm512_mask3_fnmadd_round_pd(__m512d, __m512d, __m512d, __mmask8, const int /* rounding */);
+extern __m512d __cdecl _mm512_maskz_fnmadd_round_pd(__mmask8, __m512d, __m512d, __m512d, const int /* rounding */);
+
+extern __m512  __cdecl _mm512_fnmsub_ps(__m512, __m512, __m512);
+extern __m512  __cdecl _mm512_mask_fnmsub_ps(__m512, __mmask16, __m512, __m512);
+extern __m512  __cdecl _mm512_mask3_fnmsub_ps(__m512, __m512, __m512, __mmask16);
+extern __m512  __cdecl _mm512_maskz_fnmsub_ps(__mmask16, __m512, __m512, __m512);
+extern __m512  __cdecl _mm512_fnmsub_round_ps(__m512, __m512, __m512, const int /* rounding */);
+extern __m512  __cdecl _mm512_mask_fnmsub_round_ps(__m512, __mmask16, __m512, __m512, const int /* rounding */);
+extern __m512  __cdecl _mm512_mask3_fnmsub_round_ps(__m512, __m512, __m512, __mmask16, const int /* rounding */);
+extern __m512  __cdecl _mm512_maskz_fnmsub_round_ps(__mmask16, __m512, __m512, __m512, const int /* rounding */);
+extern __m512d __cdecl _mm512_fnmsub_pd(__m512d, __m512d, __m512d);
+extern __m512d __cdecl _mm512_mask_fnmsub_pd(__m512d, __mmask8, __m512d, __m512d);
+extern __m512d __cdecl _mm512_mask3_fnmsub_pd(__m512d, __m512d, __m512d, __mmask8);
+extern __m512d __cdecl _mm512_maskz_fnmsub_pd(__mmask8, __m512d, __m512d, __m512d);
+extern __m512d __cdecl _mm512_fnmsub_round_pd(__m512d, __m512d, __m512d, const int /* rounding */);
+extern __m512d __cdecl _mm512_mask_fnmsub_round_pd(__m512d, __mmask8, __m512d, __m512d, const int /* rounding */);
+extern __m512d __cdecl _mm512_mask3_fnmsub_round_pd(__m512d, __m512d, __m512d, __mmask8, const int /* rounding */);
+extern __m512d __cdecl _mm512_maskz_fnmsub_round_pd(__mmask8, __m512d, __m512d, __m512d, const int /* rounding */);
+
+extern __m512  __cdecl _mm512_sqrt_ps(__m512);
+extern __m512d __cdecl _mm512_sqrt_pd(__m512d);
+extern __m512  __cdecl _mm512_maskz_sqrt_ps(__mmask16, __m512);
+extern __m512d __cdecl _mm512_maskz_sqrt_pd(__mmask8, __m512d);
+extern __m512  __cdecl _mm512_mask_sqrt_ps(__m512, __mmask16, __m512);
+extern __m512d __cdecl _mm512_mask_sqrt_pd(__m512d, __mmask8, __m512d);
+extern __m512  __cdecl _mm512_sqrt_round_ps(__m512, const int /* rounding */);
+extern __m512d __cdecl _mm512_sqrt_round_pd(__m512d, const int /* rounding */);
+extern __m512  __cdecl _mm512_maskz_sqrt_round_ps(__mmask16, __m512, const int /* rounding */);
+extern __m512d __cdecl _mm512_maskz_sqrt_round_pd(__mmask8, __m512d, const int /* rounding */);
+extern __m512  __cdecl _mm512_mask_sqrt_round_ps(__m512, __mmask16, __m512, const int /* rounding */);
+extern __m512d __cdecl _mm512_mask_sqrt_round_pd(__m512d, __mmask8, __m512d, const int /* rounding */);
+
+extern __m512  __cdecl _mm512_abs_ps(__m512);
+extern __m512  __cdecl _mm512_maskz_abs_ps(__mmask16, __m512);
+extern __m512  __cdecl _mm512_mask_abs_ps(__m512, __mmask16, __m512);
+extern __m512d __cdecl _mm512_abs_pd(__m512d);
+extern __m512d __cdecl _mm512_maskz_abs_pd(__mmask8, __m512d);
+extern __m512d __cdecl _mm512_mask_abs_pd(__m512d, __mmask8, __m512d);
+
+extern __m512  __cdecl _mm512_max_ps(__m512, __m512);
+extern __m512d __cdecl _mm512_max_pd(__m512d, __m512d);
+extern __m512  __cdecl _mm512_maskz_max_ps(__mmask16, __m512, __m512);
+extern __m512d __cdecl _mm512_maskz_max_pd(__mmask8, __m512d, __m512d);
+extern __m512  __cdecl _mm512_mask_max_ps(__m512, __mmask16, __m512, __m512);
+extern __m512d __cdecl _mm512_mask_max_pd(__m512d, __mmask8, __m512d, __m512d);
+extern __m512  __cdecl _mm512_max_round_ps(__m512, __m512, const int /* rounding */);
+extern __m512d __cdecl _mm512_max_round_pd(__m512d, __m512d, const int /* rounding */);
+extern __m512  __cdecl _mm512_maskz_max_round_ps(__mmask16, __m512, __m512, const int /* rounding */);
+extern __m512d __cdecl _mm512_maskz_max_round_pd(__mmask8, __m512d, __m512d, const int /* rounding */);
+extern __m512  __cdecl _mm512_mask_max_round_ps(__m512, __mmask16, __m512, __m512, const int /* rounding */);
+extern __m512d __cdecl _mm512_mask_max_round_pd(__m512d, __mmask8, __m512d, __m512d, const int /* rounding */);
+
+extern __m512  __cdecl _mm512_min_ps(__m512, __m512);
+extern __m512d __cdecl _mm512_min_pd(__m512d, __m512d);
+extern __m512  __cdecl _mm512_maskz_min_ps(__mmask16, __m512, __m512);
+extern __m512d __cdecl _mm512_maskz_min_pd(__mmask8, __m512d, __m512d);
+extern __m512  __cdecl _mm512_mask_min_ps(__m512, __mmask16, __m512, __m512);
+extern __m512d __cdecl _mm512_mask_min_pd(__m512d, __mmask8, __m512d, __m512d);
+extern __m512  __cdecl _mm512_min_round_ps(__m512, __m512, const int /* rounding */);
+extern __m512d __cdecl _mm512_min_round_pd(__m512d, __m512d, const int /* rounding */);
+extern __m512  __cdecl _mm512_maskz_min_round_ps(__mmask16, __m512, __m512, const int /* rounding */);
+extern __m512d __cdecl _mm512_maskz_min_round_pd(__mmask8, __m512d, __m512d, const int /* rounding */);
+extern __m512  __cdecl _mm512_mask_min_round_ps(__m512, __mmask16, __m512, __m512, const int /* rounding */);
+extern __m512d __cdecl _mm512_mask_min_round_pd(__m512d, __mmask8, __m512d, __m512d, const int /* rounding */);
+
+extern __m512  __cdecl _mm512_rcp14_ps(__m512);
+extern __m512d __cdecl _mm512_rcp14_pd(__m512d);
+extern __m512  __cdecl _mm512_maskz_rcp14_ps(__mmask16, __m512);
+extern __m512d __cdecl _mm512_maskz_rcp14_pd(__mmask8, __m512d);
+extern __m512  __cdecl _mm512_mask_rcp14_ps(__m512, __mmask16, __m512);
+extern __m512d __cdecl _mm512_mask_rcp14_pd(__m512d, __mmask8, __m512d);
+
+extern __m512  __cdecl _mm512_rsqrt14_ps(__m512);
+extern __m512d __cdecl _mm512_rsqrt14_pd(__m512d);
+extern __m512  __cdecl _mm512_maskz_rsqrt14_ps(__mmask16, __m512);
+extern __m512d __cdecl _mm512_maskz_rsqrt14_pd(__mmask8, __m512d);
+extern __m512  __cdecl _mm512_mask_rsqrt14_ps(__m512, __mmask16, __m512);
+extern __m512d __cdecl _mm512_mask_rsqrt14_pd(__m512d, __mmask8, __m512d);
+
+extern __m512d __cdecl _mm512_cvtps_pd(__m256);
+extern __m256  __cdecl _mm512_cvtpd_ps(__m512d);
+extern __m512d __cdecl _mm512_maskz_cvtps_pd(__mmask8, __m256);
+extern __m256  __cdecl _mm512_maskz_cvtpd_ps(__mmask8, __m512d);
+extern __m512d __cdecl _mm512_mask_cvtps_pd(__m512d, __mmask8, __m256);
+extern __m256  __cdecl _mm512_mask_cvtpd_ps(__m256, __mmask8, __m512d);
+extern __m512d __cdecl _mm512_cvt_roundps_pd(__m256, const int /* rounding */);
+extern __m256  __cdecl _mm512_cvt_roundpd_ps(__m512d, const int /* rounding */);
+extern __m512d __cdecl _mm512_maskz_cvt_roundps_pd(__mmask8, __m256, const int /* rounding */);
+extern __m256  __cdecl _mm512_maskz_cvt_roundpd_ps(__mmask8, __m512d, const int /* rounding */);
+extern __m512d __cdecl _mm512_mask_cvt_roundps_pd(__m512d, __mmask8, __m256, const int /* rounding */);
+extern __m256  __cdecl _mm512_mask_cvt_roundpd_ps(__m256, __mmask8, __m512d, const int /* rounding */);
+
+extern __mmask16 __cdecl _mm512_cmp_ps_mask(__m512, __m512, const int);
+extern __mmask16 __cdecl _mm512_mask_cmp_ps_mask(__mmask16, __m512, __m512, const int);
+extern __mmask16 __cdecl _mm512_cmp_round_ps_mask(__m512, __m512, const int, const int /* rounding */);
+extern __mmask16 __cdecl _mm512_mask_cmp_round_ps_mask(__mmask16, __m512, __m512, const int, const int /* rounding */);
+extern __mmask8  __cdecl _mm512_cmp_pd_mask(__m512d, __m512d, const int);
+extern __mmask8  __cdecl _mm512_mask_cmp_pd_mask(__mmask8, __m512d, __m512d, const int);
+extern __mmask8  __cdecl _mm512_cmp_round_pd_mask(__m512d, __m512d, const int, const int /* rounding */);
+extern __mmask8  __cdecl _mm512_mask_cmp_round_pd_mask(__mmask8, __m512d, __m512d, const int, const int /* rounding */);
+
+extern __m512  __cdecl _mm512_broadcast_f32x2(__m128);
+extern __m512  __cdecl _mm512_mask_broadcast_f32x2(__m512, __mmask16, __m128);
+extern __m512  __cdecl _mm512_maskz_broadcast_f32x2(__mmask16, __m128);
+extern __m512  __cdecl _mm512_broadcast_f32x4(__m128);
+extern __m512  __cdecl _mm512_mask_broadcast_f32x4(__m512, __mmask16, __m128);
+extern __m512  __cdecl _mm512_maskz_broadcast_f32x4(__mmask16, __m128);
+extern __m512  __cdecl _mm512_broadcast_f32x8(__m256);
+extern __m512  __cdecl _mm512_mask_broadcast_f32x8(__m512, __mmask16, __m256);
+extern __m512  __cdecl _mm512_maskz_broadcast_f32x8(__mmask16, __m256);
+extern __m512d __cdecl _mm512_broadcast_f64x2(__m128d);
+extern __m512d __cdecl _mm512_mask_broadcast_f64x2(__m512d, __mmask8, __m128d);
+extern __m512d __cdecl _mm512_maskz_broadcast_f64x2(__mmask8, __m128d);
+extern __m512d __cdecl _mm512_broadcast_f64x4(__m256d);
+extern __m512d __cdecl _mm512_mask_broadcast_f64x4(__m512d, __mmask8, __m256d);
+extern __m512d __cdecl _mm512_maskz_broadcast_f64x4(__mmask8, __m256d);
+extern __m512d __cdecl _mm512_broadcastsd_pd(__m128d);
+extern __m512d __cdecl _mm512_mask_broadcastsd_pd(__m512d, __mmask8, __m128d);
+extern __m512d __cdecl _mm512_maskz_broadcastsd_pd(__mmask8, __m128d);
+extern __m512  __cdecl _mm512_broadcastss_ps(__m128);
+extern __m512  __cdecl _mm512_mask_broadcastss_ps(__m512, __mmask16, __m128);
+extern __m512  __cdecl _mm512_maskz_broadcastss_ps(__mmask16, __m128);
+
+extern __m128  __cdecl _mm512_extractf32x4_ps(__m512, int);
+extern __m128  __cdecl _mm512_mask_extractf32x4_ps(__m128, __mmask8, __m512, const int);
+extern __m128  __cdecl _mm512_maskz_extractf32x4_ps(__mmask8, __m512, int);
+extern __m256  __cdecl _mm512_extractf32x8_ps(__m512, int);
+extern __m256  __cdecl _mm512_mask_extractf32x8_ps(__m256, __mmask8, __m512, const int);
+extern __m256  __cdecl _mm512_maskz_extractf32x8_ps(__mmask8, __m512, int);
+extern __m128d __cdecl _mm512_extractf64x2_pd(__m512d, int);
+extern __m128d __cdecl _mm512_mask_extractf64x2_pd(__m128d, __mmask8, __m512d, const int);
+extern __m128d __cdecl _mm512_maskz_extractf64x2_pd(__mmask8, __m512d, int);
+extern __m256d __cdecl _mm512_extractf64x4_pd(__m512d, int);
+extern __m256d __cdecl _mm512_mask_extractf64x4_pd(__m256d, __mmask8, __m512d, const int);
+extern __m256d __cdecl _mm512_maskz_extractf64x4_pd(__mmask8, __m512d, int);
+
+extern __m512  __cdecl _mm512_insertf32x4(__m512, __m128, int);
+extern __m512  __cdecl _mm512_mask_insertf32x4(__m512, __mmask16, __m512, __m128, const int);
+extern __m512  __cdecl _mm512_maskz_insertf32x4(__mmask16, __m512, __m128, int);
+extern __m512  __cdecl _mm512_insertf32x8(__m512, __m256, int);
+extern __m512  __cdecl _mm512_mask_insertf32x8(__m512, __mmask16, __m512, __m256, const int);
+extern __m512  __cdecl _mm512_maskz_insertf32x8(__mmask16, __m512, __m256, int);
+extern __m512d __cdecl _mm512_insertf64x2(__m512d, __m128d, int);
+extern __m512d __cdecl _mm512_mask_insertf64x2(__m512d, __mmask8, __m512d, __m128d, const int);
+extern __m512d __cdecl _mm512_maskz_insertf64x2(__mmask8, __m512d, __m128d, int);
+extern __m512d __cdecl _mm512_insertf64x4(__m512d, __m256d, int);
+extern __m512d __cdecl _mm512_mask_insertf64x4(__m512d, __mmask8, __m512d, __m256d, const int);
+extern __m512d __cdecl _mm512_maskz_insertf64x4(__mmask8, __m512d, __m256d, int);
+
+extern __m512  __cdecl _mm512_shuffle_f32x4(__m512, __m512, const int);
+extern __m512  __cdecl _mm512_mask_shuffle_f32x4(__m512, __mmask16, __m512, __m512, const int);
+extern __m512  __cdecl _mm512_maskz_shuffle_f32x4(__mmask16, __m512, __m512, const int);
+extern __m512d __cdecl _mm512_shuffle_f64x2(__m512d, __m512d, const int);
+extern __m512d __cdecl _mm512_mask_shuffle_f64x2(__m512d, __mmask8, __m512d, __m512d, const int);
+extern __m512d __cdecl _mm512_maskz_shuffle_f64x2(__mmask8, __m512d, __m512d, const int);
+extern __m512d __cdecl _mm512_shuffle_pd(__m512d, __m512d, const int);
+extern __m512d __cdecl _mm512_mask_shuffle_pd(__m512d, __mmask8, __m512d, __m512d, const int);
+extern __m512d __cdecl _mm512_maskz_shuffle_pd(__mmask8, __m512d, __m512d, const int);
+extern __m512  __cdecl _mm512_shuffle_ps(__m512, __m512, const int);
+extern __m512  __cdecl _mm512_mask_shuffle_ps(__m512, __mmask16, __m512, __m512, const int);
+extern __m512  __cdecl _mm512_maskz_shuffle_ps(__mmask16, __m512, __m512, const int);
+
+extern __mmask16 _mm512_cmpeq_ps_mask(__m512, __m512);
+extern __mmask16 _mm512_cmple_ps_mask(__m512, __m512);
+extern __mmask16 _mm512_cmplt_ps_mask(__m512, __m512);
+extern __mmask16 _mm512_cmpneq_ps_mask(__m512, __m512);
+extern __mmask16 _mm512_cmpnle_ps_mask(__m512, __m512);
+extern __mmask16 _mm512_cmpnlt_ps_mask(__m512, __m512);
+extern __mmask16 _mm512_cmpord_ps_mask(__m512, __m512);
+extern __mmask16 _mm512_cmpunord_ps_mask(__m512, __m512);
+
+extern __mmask16 _mm512_mask_cmpeq_ps_mask(__mmask16, __m512, __m512);
+extern __mmask16 _mm512_mask_cmple_ps_mask(__mmask16, __m512, __m512);
+extern __mmask16 _mm512_mask_cmplt_ps_mask(__mmask16, __m512, __m512);
+extern __mmask16 _mm512_mask_cmpneq_ps_mask(__mmask16, __m512, __m512);
+extern __mmask16 _mm512_mask_cmpnle_ps_mask(__mmask16, __m512, __m512);
+extern __mmask16 _mm512_mask_cmpnlt_ps_mask(__mmask16, __m512, __m512);
+extern __mmask16 _mm512_mask_cmpord_ps_mask(__mmask16, __m512, __m512);
+extern __mmask16 _mm512_mask_cmpunord_ps_mask(__mmask16, __m512, __m512);
+
+extern __mmask8 _mm512_cmpeq_pd_mask(__m512d, __m512d);
+extern __mmask8 _mm512_cmple_pd_mask(__m512d, __m512d);
+extern __mmask8 _mm512_cmplt_pd_mask(__m512d, __m512d);
+extern __mmask8 _mm512_cmpneq_pd_mask(__m512d, __m512d);
+extern __mmask8 _mm512_cmpnle_pd_mask(__m512d, __m512d);
+extern __mmask8 _mm512_cmpnlt_pd_mask(__m512d, __m512d);
+extern __mmask8 _mm512_cmpord_pd_mask(__m512d, __m512d);
+extern __mmask8 _mm512_cmpunord_pd_mask(__m512d, __m512d);
+
+extern __mmask8 _mm512_mask_cmpeq_pd_mask(__mmask8, __m512d, __m512d);
+extern __mmask8 _mm512_mask_cmple_pd_mask(__mmask8, __m512d, __m512d);
+extern __mmask8 _mm512_mask_cmplt_pd_mask(__mmask8, __m512d, __m512d);
+extern __mmask8 _mm512_mask_cmpneq_pd_mask(__mmask8, __m512d, __m512d);
+extern __mmask8 _mm512_mask_cmpnle_pd_mask(__mmask8, __m512d, __m512d);
+extern __mmask8 _mm512_mask_cmpnlt_pd_mask(__mmask8, __m512d, __m512d);
+extern __mmask8 _mm512_mask_cmpord_pd_mask(__mmask8, __m512d, __m512d);
+extern __mmask8 _mm512_mask_cmpunord_pd_mask(__mmask8, __m512d, __m512d);
+
+
+#define _mm512_setzero() _mm512_setzero_ps()
+#define _mm512_undefined() _mm512_setzero()
+#define _mm512_undefined_pd() _mm512_setzero_pd()
+#define _mm512_undefined_ps() _mm512_undefined()
+
+#define _mm512_set4_ps(a,b,c,d) \
+    _mm512_set_ps((a), (b), (c), (d), (a), (b), (c), (d), \
+    (a), (b), (c), (d), (a), (b), (c), (d))
+
+#define _mm512_set4_pd(a,b,c,d) \
+    _mm512_set_pd((a), (b), (c), (d), (a), (b), (c), (d))
+
+#define _mm512_set_16to16_ps(e0,e1,e2,e3,e4,e5,e6,e7,e8, \
+    e9, e10, e11, e12, e13, e14, e15) \
+    _mm512_set_ps((e0), (e1), (e2), (e3), (e4), (e5), (e6), (e7), \
+    (e8), (e9), (e10), (e11), (e12), (e13), (e14), (e15))
+
+#define _mm512_set_8to8_pd(e0,e1,e2,e3,e4,e5,e6,e7) \
+    _mm512_set_pd((e0), (e1), (e2), (e3), (e4), (e5), (e6), (e7))
+
+#define _mm512_setr4_ps(a,b,c,d) \
+    _mm512_set4_ps((d), (c), (b), (a))
+
+#define _mm512_set_4to16_ps(a,b,c,d) \
+    _mm512_setr4_ps((a), (b), (c), (d))
+
+#define _mm512_setr4_pd(a,b,c,d) \
+    _mm512_set4_pd((d), (c), (b), (a))
+
+#define _mm512_set_4to8_pd(a,b,c,d) \
+    _mm512_setr4_pd((a), (b), (c), (d))
+
+#define _mm512_set_1to16_ps(x) _mm512_set1_ps((x))
+#define _mm512_set_1to8_pd(x) _mm512_set1_pd((x))
+
+extern __m512i __cdecl _mm512_setzero_si512(void);
+
+extern __m512i __cdecl _mm512_set_epi8(char /* e63 */, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char,
+                                       char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char,
+                                       char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char,
+                                       char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char /* e0 */);
+extern __m512i __cdecl _mm512_set_epi16(short /* e31 */, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short,
+                                        short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short /* e0 */);
+extern __m512i __cdecl _mm512_set_epi32(int /* e15 */, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int /* e0 */);
+extern __m512i __cdecl _mm512_set_epi64(__int64 /* e7 */, __int64, __int64, __int64, __int64, __int64, __int64, __int64 /* e0 */);
+
+extern __m512i __cdecl _mm512_setr_epi8(char /* e0 */, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char,
+                                        char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char,
+                                        char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char,
+                                        char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char /* e63 */);
+extern __m512i __cdecl _mm512_setr_epi16(short /* e0 */, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short,
+                                         short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short /* e31 */);
+extern __m512i __cdecl _mm512_setr_epi32(int /* e0 */, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int /* e15 */);
+extern __m512i __cdecl _mm512_setr_epi64(__int64 /* e0 */, __int64, __int64, __int64, __int64, __int64, __int64, __int64 /* e7 */);
+
+extern __m512i __cdecl _mm512_set1_epi8(char);
+extern __m512i __cdecl _mm512_mask_set1_epi8(__m512i, __mmask64, char);
+extern __m512i __cdecl _mm512_maskz_set1_epi8(__mmask64, char);
+extern __m512i __cdecl _mm512_set1_epi16(short);
+extern __m512i __cdecl _mm512_mask_set1_epi16(__m512i, __mmask32, short);
+extern __m512i __cdecl _mm512_maskz_set1_epi16(__mmask32, short);
+extern __m512i __cdecl _mm512_set1_epi32(int);
+extern __m512i __cdecl _mm512_mask_set1_epi32(__m512i, __mmask16, int);
+extern __m512i __cdecl _mm512_maskz_set1_epi32(__mmask16, int);
+extern __m512i __cdecl _mm512_set1_epi64(__int64);
+extern __m512i __cdecl _mm512_mask_set1_epi64(__m512i, __mmask8, __int64);
+extern __m512i __cdecl _mm512_maskz_set1_epi64(__mmask8, __int64);
+
+extern __m512i __cdecl _mm512_add_epi8(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_add_epi8(__m512i, __mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_add_epi8(__mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_add_epi16(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_add_epi16(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_add_epi16(__mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_add_epi32(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_add_epi32(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_add_epi32(__mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_add_epi64(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_add_epi64(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_add_epi64(__mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_adds_epi8(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_adds_epi8(__m512i, __mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_adds_epi8(__mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_adds_epi16(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_adds_epi16(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_adds_epi16(__mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_adds_epu8(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_adds_epu8(__m512i, __mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_adds_epu8(__mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_adds_epu16(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_adds_epu16(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_adds_epu16(__mmask32, __m512i, __m512i);
+
+extern __m512i __cdecl _mm512_abs_epi8(__m512i);
+extern __m512i __cdecl _mm512_mask_abs_epi8(__m512i, __mmask64, __m512i);
+extern __m512i __cdecl _mm512_maskz_abs_epi8(__mmask64, __m512i);
+extern __m512i __cdecl _mm512_abs_epi16(__m512i);
+extern __m512i __cdecl _mm512_mask_abs_epi16(__m512i, __mmask32, __m512i);
+extern __m512i __cdecl _mm512_maskz_abs_epi16(__mmask32, __m512i);
+extern __m512i __cdecl _mm512_abs_epi32(__m512i);
+extern __m512i __cdecl _mm512_mask_abs_epi32(__m512i, __mmask16, __m512i);
+extern __m512i __cdecl _mm512_maskz_abs_epi32(__mmask16, __m512i);
+extern __m512i __cdecl _mm512_abs_epi64(__m512i);
+extern __m512i __cdecl _mm512_mask_abs_epi64(__m512i, __mmask8, __m512i);
+extern __m512i __cdecl _mm512_maskz_abs_epi64(__mmask8, __m512i);
+
+extern __m512i  __cdecl _mm512_broadcast_i32x2(__m128i);
+extern __m512i  __cdecl _mm512_mask_broadcast_i32x2(__m512i, __mmask16, __m128i);
+extern __m512i  __cdecl _mm512_maskz_broadcast_i32x2(__mmask16, __m128i);
+extern __m512i  __cdecl _mm512_broadcast_i32x4(__m128i);
+extern __m512i  __cdecl _mm512_mask_broadcast_i32x4(__m512i, __mmask16, __m128i);
+extern __m512i  __cdecl _mm512_maskz_broadcast_i32x4(__mmask16, __m128i);
+extern __m512i  __cdecl _mm512_broadcast_i32x8(__m256i);
+extern __m512i  __cdecl _mm512_mask_broadcast_i32x8(__m512i, __mmask16, __m256i);
+extern __m512i  __cdecl _mm512_maskz_broadcast_i32x8(__mmask16, __m256i);
+extern __m512i  __cdecl _mm512_broadcast_i64x2(__m128i);
+extern __m512i  __cdecl _mm512_mask_broadcast_i64x2(__m512i, __mmask8, __m128i);
+extern __m512i  __cdecl _mm512_maskz_broadcast_i64x2(__mmask8, __m128i);
+extern __m512i  __cdecl _mm512_broadcast_i64x4(__m256i);
+extern __m512i  __cdecl _mm512_mask_broadcast_i64x4(__m512i, __mmask8, __m256i);
+extern __m512i  __cdecl _mm512_maskz_broadcast_i64x4(__mmask8, __m256i);
+extern __m512i __cdecl _mm512_broadcastb_epi8(__m128i);
+extern __m512i __cdecl _mm512_mask_broadcastb_epi8(__m512i, __mmask64, __m128i);
+extern __m512i __cdecl _mm512_maskz_broadcastb_epi8(__mmask64, __m128i);
+extern __m512i __cdecl _mm512_broadcastw_epi16(__m128i);
+extern __m512i __cdecl _mm512_mask_broadcastw_epi16(__m512i, __mmask32, __m128i);
+extern __m512i __cdecl _mm512_maskz_broadcastw_epi16(__mmask32, __m128i);
+extern __m512i __cdecl _mm512_broadcastd_epi32(__m128i);
+extern __m512i __cdecl _mm512_mask_broadcastd_epi32(__m512i, __mmask16, __m128i);
+extern __m512i __cdecl _mm512_maskz_broadcastd_epi32(__mmask16, __m128i);
+extern __m512i __cdecl _mm512_broadcastq_epi64(__m128i);
+extern __m512i __cdecl _mm512_mask_broadcastq_epi64(__m512i, __mmask8, __m128i);
+extern __m512i __cdecl _mm512_maskz_broadcastq_epi64(__mmask8, __m128i);
+extern __m512i __cdecl _mm512_broadcastmw_epi32(__mmask16);
+extern __m512i __cdecl _mm512_broadcastmb_epi64(__mmask8);
+
+extern __m512i __cdecl _mm512_sub_epi8(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_sub_epi8(__m512i, __mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_sub_epi8(__mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_sub_epi16(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_sub_epi16(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_sub_epi16(__mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_sub_epi32(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_sub_epi32(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_sub_epi32(__mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_sub_epi64(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_sub_epi64(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_sub_epi64(__mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_subs_epi8(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_subs_epi8(__m512i, __mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_subs_epi8(__mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_subs_epi16(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_subs_epi16(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_subs_epi16(__mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_subs_epu8(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_subs_epu8(__m512i, __mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_subs_epu8(__mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_subs_epu16(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_subs_epu16(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_subs_epu16(__mmask32, __m512i, __m512i);
+
+extern __m512i __cdecl _mm512_max_epi8(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_max_epi8(__m512i, __mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_max_epi8(__mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_max_epi16(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_max_epi16(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_max_epi16(__mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_max_epi32(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_max_epi32(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_max_epi32(__mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_max_epi64(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_max_epi64(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_max_epi64(__mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_max_epu8(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_max_epu8(__m512i, __mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_max_epu8(__mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_max_epu16(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_max_epu16(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_max_epu16(__mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_max_epu32(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_max_epu32(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_max_epu32(__mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_max_epu64(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_max_epu64(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_max_epu64(__mmask8, __m512i, __m512i);
+
+extern __m512i __cdecl _mm512_min_epi8(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_min_epi8(__m512i, __mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_min_epi8(__mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_min_epi16(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_min_epi16(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_min_epi16(__mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_min_epi32(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_min_epi32(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_min_epi32(__mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_min_epi64(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_min_epi64(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_min_epi64(__mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_min_epu8(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_min_epu8(__m512i, __mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_min_epu8(__mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_min_epu16(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_min_epu16(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_min_epu16(__mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_min_epu32(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_min_epu32(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_min_epu32(__mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_min_epu64(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_min_epu64(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_min_epu64(__mmask8, __m512i, __m512i);
+
+extern __m512i __cdecl _mm512_mul_epi32(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_mul_epi32(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_mul_epi32(__mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mul_epu32(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_mul_epu32(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_mul_epu32(__mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mulhi_epi16(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_mulhi_epi16(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_mulhi_epi16(__mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mulhi_epu16(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_mulhi_epu16(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_mulhi_epu16(__mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mullo_epi16(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_mullo_epi16(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_mullo_epi16(__mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mullo_epi32(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_mullo_epi32(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_mullo_epi32(__mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mullo_epi64(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_mullo_epi64(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_mullo_epi64(__mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mullox_epi64(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_mullox_epi64(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mulhrs_epi16(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_mulhrs_epi16(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_mulhrs_epi16(__mmask32, __m512i, __m512i);
+
+extern __m512i __cdecl _mm512_load_epi32(void const*);
+extern __m512i __cdecl _mm512_mask_load_epi32(__m512i, __mmask16, void const*);
+extern __m512i __cdecl _mm512_maskz_load_epi32(__mmask16, void const*);
+extern __m512i __cdecl _mm512_load_epi64(void const*);
+extern __m512i __cdecl _mm512_mask_load_epi64(__m512i, __mmask8, void const*);
+extern __m512i __cdecl _mm512_maskz_load_epi64(__mmask8, void const*);
+extern __m512i __cdecl _mm512_loadu_epi8(void const*);
+extern __m512i __cdecl _mm512_mask_loadu_epi8(__m512i, __mmask64, void const*);
+extern __m512i __cdecl _mm512_maskz_loadu_epi8(__mmask64, void const*);
+extern __m512i __cdecl _mm512_loadu_epi16(void const*);
+extern __m512i __cdecl _mm512_mask_loadu_epi16(__m512i, __mmask32, void const*);
+extern __m512i __cdecl _mm512_maskz_loadu_epi16(__mmask32, void const*);
+extern __m512i __cdecl _mm512_loadu_epi32(void const*);
+extern __m512i __cdecl _mm512_mask_loadu_epi32(__m512i, __mmask16, void const*);
+extern __m512i __cdecl _mm512_maskz_loadu_epi32(__mmask16, void const*);
+extern __m512i __cdecl _mm512_loadu_epi64(void const*);
+extern __m512i __cdecl _mm512_mask_loadu_epi64(__m512i, __mmask8, void const*);
+extern __m512i __cdecl _mm512_maskz_loadu_epi64(__mmask8, void const*);
+
+extern void    __cdecl _mm512_store_epi32(void*, __m512i);
+extern void    __cdecl _mm512_mask_store_epi32(void*, __mmask16, __m512i);
+extern void    __cdecl _mm512_store_epi64(void*, __m512i);
+extern void    __cdecl _mm512_mask_store_epi64(void*, __mmask8, __m512i);
+extern void    __cdecl _mm512_storeu_epi8(void*, __m512i);
+extern void    __cdecl _mm512_mask_storeu_epi8(void*, __mmask64, __m512i);
+extern void    __cdecl _mm512_storeu_epi16(void*, __m512i);
+extern void    __cdecl _mm512_mask_storeu_epi16(void*, __mmask32, __m512i);
+extern void    __cdecl _mm512_storeu_epi32(void*, __m512i);
+extern void    __cdecl _mm512_mask_storeu_epi32(void*, __mmask16, __m512i);
+extern void    __cdecl _mm512_storeu_epi64(void*, __m512i);
+extern void    __cdecl _mm512_mask_storeu_epi64(void*, __mmask8, __m512i);
+
+extern __m128i __cdecl _mm512_extracti32x4_epi32(__m512i, int);
+extern __m128i __cdecl _mm512_mask_extracti32x4_epi32(__m128i, __mmask8, __m512i, int);
+extern __m128i __cdecl _mm512_maskz_extracti32x4_epi32(__mmask8, __m512i, int);
+extern __m256i __cdecl _mm512_extracti32x8_epi32(__m512i, int);
+extern __m256i __cdecl _mm512_mask_extracti32x8_epi32(__m256i, __mmask8, __m512i, int);
+extern __m256i __cdecl _mm512_maskz_extracti32x8_epi32(__mmask8, __m512i, int);
+extern __m128i __cdecl _mm512_extracti64x2_epi64(__m512i, int);
+extern __m128i __cdecl _mm512_mask_extracti64x2_epi64(__m128i, __mmask8, __m512i, int);
+extern __m128i __cdecl _mm512_maskz_extracti64x2_epi64(__mmask8, __m512i, int);
+extern __m256i __cdecl _mm512_extracti64x4_epi64(__m512i, int);
+extern __m256i __cdecl _mm512_mask_extracti64x4_epi64(__m256i, __mmask8, __m512i, int);
+extern __m256i __cdecl _mm512_maskz_extracti64x4_epi64(__mmask8, __m512i, int);
+
+extern __m512i __cdecl _mm512_inserti32x4(__m512i, __m128i, int);
+extern __m512i __cdecl _mm512_mask_inserti32x4(__m512i, __mmask16, __m512i, __m128i, int);
+extern __m512i __cdecl _mm512_maskz_inserti32x4(__mmask16, __m512i, __m128i, int);
+extern __m512i __cdecl _mm512_inserti32x8(__m512i, __m256i, int);
+extern __m512i __cdecl _mm512_mask_inserti32x8(__m512i, __mmask16, __m512i, __m256i, int);
+extern __m512i __cdecl _mm512_maskz_inserti32x8(__mmask16, __m512i, __m256i, int);
+extern __m512i __cdecl _mm512_inserti64x2(__m512i, __m128i, int);
+extern __m512i __cdecl _mm512_mask_inserti64x2(__m512i, __mmask8, __m512i, __m128i, int);
+extern __m512i __cdecl _mm512_maskz_inserti64x2(__mmask8, __m512i, __m128i, int);
+extern __m512i __cdecl _mm512_inserti64x4(__m512i, __m256i, int);
+extern __m512i __cdecl _mm512_mask_inserti64x4(__m512i, __mmask8, __m512i, __m256i, int);
+extern __m512i __cdecl _mm512_maskz_inserti64x4(__mmask8, __m512i, __m256i, int);
+
+extern __m512i __cdecl _mm512_shuffle_epi8(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_shuffle_epi8(__m512i, __mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_shuffle_epi8(__mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_shuffle_epi32(__m512i, int);
+extern __m512i __cdecl _mm512_mask_shuffle_epi32(__m512i, __mmask16, __m512i, int);
+extern __m512i __cdecl _mm512_maskz_shuffle_epi32(__mmask16, __m512i, int);
+extern __m512i __cdecl _mm512_shuffle_i32x4(__m512i, __m512i, const int);
+extern __m512i __cdecl _mm512_mask_shuffle_i32x4(__m512i, __mmask16, __m512i, __m512i, const int);
+extern __m512i __cdecl _mm512_maskz_shuffle_i32x4(__mmask16, __m512i, __m512i, const int);
+extern __m512i __cdecl _mm512_shuffle_i64x2(__m512i, __m512i, const int);
+extern __m512i __cdecl _mm512_mask_shuffle_i64x2(__m512i, __mmask8, __m512i, __m512i, const int);
+extern __m512i __cdecl _mm512_maskz_shuffle_i64x2(__mmask8, __m512i, __m512i, const int);
+extern __m512i __cdecl _mm512_shufflehi_epi16(__m512i, int);
+extern __m512i __cdecl _mm512_mask_shufflehi_epi16(__m512i, __mmask32, __m512i, int);
+extern __m512i __cdecl _mm512_maskz_shufflehi_epi16(__mmask32, __m512i, int);
+extern __m512i __cdecl _mm512_shufflelo_epi16(__m512i, int);
+extern __m512i __cdecl _mm512_mask_shufflelo_epi16(__m512i, __mmask32, __m512i, int);
+extern __m512i __cdecl _mm512_maskz_shufflelo_epi16(__mmask32, __m512i, int);
+
+extern __m512  __cdecl _mm512_mask_mov_ps(__m512, __mmask16, __m512);
+extern __m512  __cdecl _mm512_maskz_mov_ps(__mmask16, __m512);
+extern __m512d __cdecl _mm512_mask_mov_pd(__m512d, __mmask8, __m512d);
+extern __m512d __cdecl _mm512_maskz_mov_pd(__mmask8, __m512d);
+extern __m512i __cdecl _mm512_mask_mov_epi8(__m512i, __mmask64, __m512i);
+extern __m512i __cdecl _mm512_maskz_mov_epi8(__mmask64, __m512i);
+extern __m512i __cdecl _mm512_mask_mov_epi16(__m512i, __mmask32, __m512i);
+extern __m512i __cdecl _mm512_maskz_mov_epi16(__mmask32, __m512i);
+extern __m512i __cdecl _mm512_mask_mov_epi32(__m512i, __mmask16, __m512i);
+extern __m512i __cdecl _mm512_maskz_mov_epi32(__mmask16, __m512i);
+extern __m512i __cdecl _mm512_mask_mov_epi64(__m512i, __mmask8, __m512i);
+extern __m512i __cdecl _mm512_maskz_mov_epi64(__mmask8, __m512i);
+extern __m512d __cdecl _mm512_movedup_pd(__m512d);
+extern __m512d __cdecl _mm512_mask_movedup_pd(__m512d, __mmask8, __m512d);
+extern __m512d __cdecl _mm512_maskz_movedup_pd(__mmask8, __m512d);
+extern __m512  __cdecl _mm512_movehdup_ps(__m512);
+extern __m512  __cdecl _mm512_mask_movehdup_ps(__m512, __mmask16, __m512);
+extern __m512  __cdecl _mm512_maskz_movehdup_ps(__mmask16, __m512);
+extern __m512  __cdecl _mm512_moveldup_ps(__m512);
+extern __m512  __cdecl _mm512_mask_moveldup_ps(__m512, __mmask16, __m512);
+extern __m512  __cdecl _mm512_maskz_moveldup_ps(__mmask16, __m512);
+
+extern __m512i __cdecl _mm512_movm_epi8(__mmask64);
+extern __m512i __cdecl _mm512_movm_epi16(__mmask32);
+extern __m512i __cdecl _mm512_movm_epi32(__mmask16);
+extern __m512i __cdecl _mm512_movm_epi64(__mmask8);
+extern __mmask64 __cdecl _mm512_movepi8_mask(__m512i);
+extern __mmask32 __cdecl _mm512_movepi16_mask(__m512i);
+extern __mmask16 __cdecl _mm512_movepi32_mask(__m512i);
+extern __mmask8  __cdecl _mm512_movepi64_mask(__m512i);
+
+extern __m512i __cdecl _mm512_alignr_epi8(__m512i, __m512i, const int);
+extern __m512i __cdecl _mm512_mask_alignr_epi8(__m512i, __mmask64, __m512i, __m512i, const int);
+extern __m512i __cdecl _mm512_maskz_alignr_epi8(__mmask64, __m512i, __m512i, const int);
+extern __m512i __cdecl _mm512_alignr_epi32(__m512i, __m512i, const int);
+extern __m512i __cdecl _mm512_mask_alignr_epi32(__m512i, __mmask16, __m512i, __m512i, const int /* count */);
+extern __m512i __cdecl _mm512_maskz_alignr_epi32(__mmask16, __m512i, __m512i, const int);
+extern __m512i __cdecl _mm512_alignr_epi64(__m512i, __m512i, const int);
+extern __m512i __cdecl _mm512_mask_alignr_epi64(__m512i, __mmask8, __m512i, __m512i, const int);
+extern __m512i __cdecl _mm512_maskz_alignr_epi64(__mmask8, __m512i, __m512i, const int);
+
+extern __m512d __cdecl _mm512_and_pd(__m512d, __m512d);
+extern __m512d __cdecl _mm512_mask_and_pd(__m512d, __mmask8, __m512d, __m512d);
+extern __m512d __cdecl _mm512_maskz_and_pd(__mmask8, __m512d, __m512d);
+extern __m512  __cdecl _mm512_and_ps(__m512, __m512);
+extern __m512  __cdecl _mm512_mask_and_ps(__m512, __mmask16, __m512, __m512);
+extern __m512  __cdecl _mm512_maskz_and_ps(__mmask16, __m512, __m512);
+extern __m512i __cdecl _mm512_and_epi32(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_and_epi32(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_and_epi32(__mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_and_epi64(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_and_epi64(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_and_epi64(__mmask8, __m512i, __m512i);
+
+extern __m512d __cdecl _mm512_andnot_pd(__m512d, __m512d);
+extern __m512d __cdecl _mm512_mask_andnot_pd(__m512d, __mmask8, __m512d, __m512d);
+extern __m512d __cdecl _mm512_maskz_andnot_pd(__mmask8, __m512d, __m512d);
+extern __m512  __cdecl _mm512_andnot_ps(__m512, __m512);
+extern __m512  __cdecl _mm512_mask_andnot_ps(__m512, __mmask16, __m512, __m512);
+extern __m512  __cdecl _mm512_maskz_andnot_ps(__mmask16, __m512, __m512);
+extern __m512i __cdecl _mm512_andnot_epi32(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_andnot_epi32(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_andnot_epi32(__mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_andnot_epi64(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_andnot_epi64(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_andnot_epi64(__mmask8, __m512i, __m512i);
+
+extern __m512d __cdecl _mm512_or_pd(__m512d, __m512d);
+extern __m512d __cdecl _mm512_mask_or_pd(__m512d, __mmask8, __m512d, __m512d);
+extern __m512d __cdecl _mm512_maskz_or_pd(__mmask8, __m512d, __m512d);
+extern __m512  __cdecl _mm512_or_ps(__m512, __m512);
+extern __m512  __cdecl _mm512_mask_or_ps(__m512, __mmask16, __m512, __m512);
+extern __m512  __cdecl _mm512_maskz_or_ps(__mmask16, __m512, __m512);
+extern __m512i __cdecl _mm512_or_epi32(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_or_epi32(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_or_epi32(__mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_or_epi64(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_or_epi64(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_or_epi64(__mmask8, __m512i, __m512i);
+
+extern __m512d __cdecl _mm512_xor_pd(__m512d, __m512d);
+extern __m512d __cdecl _mm512_mask_xor_pd(__m512d, __mmask8, __m512d, __m512d);
+extern __m512d __cdecl _mm512_maskz_xor_pd(__mmask8, __m512d, __m512d);
+extern __m512  __cdecl _mm512_xor_ps(__m512, __m512);
+extern __m512  __cdecl _mm512_mask_xor_ps(__m512, __mmask16, __m512, __m512);
+extern __m512  __cdecl _mm512_maskz_xor_ps(__mmask16, __m512, __m512);
+extern __m512i __cdecl _mm512_xor_epi32(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_xor_epi32(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_xor_epi32(__mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_xor_epi64(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_xor_epi64(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_xor_epi64(__mmask8, __m512i, __m512i);
+
+extern __m512  __cdecl _mm512_mask_blend_ps(__mmask16, __m512, __m512);
+extern __m512d __cdecl _mm512_mask_blend_pd(__mmask8, __m512d, __m512d);
+extern __m512i __cdecl _mm512_mask_blend_epi8(__mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_blend_epi16(__mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_blend_epi32(__mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_blend_epi64(__mmask8, __m512i, __m512i);
+
+extern __m512i __cdecl _mm512_sll_epi16(__m512i, __m128i);
+extern __m512i __cdecl _mm512_sll_epi32(__m512i, __m128i);
+extern __m512i __cdecl _mm512_sll_epi64(__m512i, __m128i);
+extern __m512i __cdecl _mm512_slli_epi16(__m512i, unsigned int);
+extern __m512i __cdecl _mm512_slli_epi32(__m512i, unsigned int);
+extern __m512i __cdecl _mm512_slli_epi64(__m512i, unsigned int);
+extern __m512i __cdecl _mm512_sllv_epi16(__m512i, __m512i);
+extern __m512i __cdecl _mm512_sllv_epi32(__m512i, __m512i);
+extern __m512i __cdecl _mm512_sllv_epi64(__m512i, __m512i);
+
+extern __m512i __cdecl _mm512_mask_sll_epi16(__m512i, __mmask32, __m512i, __m128i);
+extern __m512i __cdecl _mm512_maskz_sll_epi16(__mmask32, __m512i, __m128i);
+extern __m512i __cdecl _mm512_mask_sll_epi32(__m512i, __mmask16, __m512i, __m128i);
+extern __m512i __cdecl _mm512_maskz_sll_epi32(__mmask16, __m512i, __m128i);
+extern __m512i __cdecl _mm512_mask_sll_epi64(__m512i, __mmask8, __m512i, __m128i);
+extern __m512i __cdecl _mm512_maskz_sll_epi64(__mmask8, __m512i, __m128i);
+extern __m512i __cdecl _mm512_mask_slli_epi16(__m512i, __mmask32, __m512i, unsigned int);
+extern __m512i __cdecl _mm512_maskz_slli_epi16(__mmask32, __m512i, unsigned int);
+extern __m512i __cdecl _mm512_mask_slli_epi32(__m512i, __mmask16, __m512i, unsigned int);
+extern __m512i __cdecl _mm512_maskz_slli_epi32(__mmask16, __m512i, unsigned int);
+extern __m512i __cdecl _mm512_mask_slli_epi64(__m512i, __mmask8, __m512i, unsigned int);
+extern __m512i __cdecl _mm512_maskz_slli_epi64(__mmask8, __m512i, unsigned int);
+extern __m512i __cdecl _mm512_mask_sllv_epi16(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_sllv_epi16(__mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_sllv_epi32(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_sllv_epi32(__mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_sllv_epi64(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_sllv_epi64(__mmask8, __m512i, __m512i);
+
+extern __m512i __cdecl _mm512_srl_epi16(__m512i, __m128i);
+extern __m512i __cdecl _mm512_srl_epi32(__m512i, __m128i);
+extern __m512i __cdecl _mm512_srl_epi64(__m512i, __m128i);
+extern __m512i __cdecl _mm512_srli_epi16(__m512i, int);
+extern __m512i __cdecl _mm512_srli_epi32(__m512i, unsigned int);
+extern __m512i __cdecl _mm512_srli_epi64(__m512i, unsigned int);
+extern __m512i __cdecl _mm512_srlv_epi16(__m512i, __m512i);
+extern __m512i __cdecl _mm512_srlv_epi32(__m512i, __m512i);
+extern __m512i __cdecl _mm512_srlv_epi64(__m512i, __m512i);
+
+extern __m512i __cdecl _mm512_mask_srl_epi16(__m512i, __mmask32, __m512i, __m128i);
+extern __m512i __cdecl _mm512_maskz_srl_epi16(__mmask32, __m512i, __m128i);
+extern __m512i __cdecl _mm512_mask_srl_epi32(__m512i, __mmask16, __m512i, __m128i);
+extern __m512i __cdecl _mm512_maskz_srl_epi32(__mmask16, __m512i, __m128i);
+extern __m512i __cdecl _mm512_mask_srl_epi64(__m512i, __mmask8, __m512i, __m128i);
+extern __m512i __cdecl _mm512_maskz_srl_epi64(__mmask8, __m512i, __m128i);
+extern __m512i __cdecl _mm512_mask_srli_epi16(__m512i, __mmask32, __m512i, unsigned int);
+extern __m512i __cdecl _mm512_maskz_srli_epi16(__mmask32, __m512i, int);
+extern __m512i __cdecl _mm512_mask_srli_epi32(__m512i, __mmask16, __m512i, unsigned int);
+extern __m512i __cdecl _mm512_maskz_srli_epi32(__mmask16, __m512i, unsigned int);
+extern __m512i __cdecl _mm512_mask_srli_epi64(__m512i, __mmask8, __m512i, unsigned int);
+extern __m512i __cdecl _mm512_maskz_srli_epi64(__mmask8, __m512i, unsigned int);
+extern __m512i __cdecl _mm512_mask_srlv_epi16(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_srlv_epi16(__mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_srlv_epi32(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_srlv_epi32(__mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_srlv_epi64(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_srlv_epi64(__mmask8, __m512i, __m512i);
+
+extern __m512i __cdecl _mm512_sra_epi16(__m512i, __m128i);
+extern __m512i __cdecl _mm512_sra_epi32(__m512i, __m128i);
+extern __m512i __cdecl _mm512_sra_epi64(__m512i, __m128i);
+extern __m512i __cdecl _mm512_srai_epi16(__m512i, unsigned int);
+extern __m512i __cdecl _mm512_srai_epi32(__m512i, unsigned int);
+extern __m512i __cdecl _mm512_srai_epi64(__m512i, unsigned int);
+extern __m512i __cdecl _mm512_srav_epi16(__m512i, __m512i);
+extern __m512i __cdecl _mm512_srav_epi32(__m512i, __m512i);
+extern __m512i __cdecl _mm512_srav_epi64(__m512i, __m512i);
+
+extern __m512i __cdecl _mm512_mask_sra_epi16(__m512i, __mmask32, __m512i, __m128i);
+extern __m512i __cdecl _mm512_maskz_sra_epi16(__mmask32, __m512i, __m128i);
+extern __m512i __cdecl _mm512_mask_sra_epi32(__m512i, __mmask16, __m512i, __m128i);
+extern __m512i __cdecl _mm512_maskz_sra_epi32(__mmask16, __m512i, __m128i);
+extern __m512i __cdecl _mm512_mask_sra_epi64(__m512i, __mmask8, __m512i, __m128i);
+extern __m512i __cdecl _mm512_maskz_sra_epi64(__mmask8, __m512i, __m128i);
+extern __m512i __cdecl _mm512_mask_srai_epi16(__m512i, __mmask32, __m512i, unsigned int);
+extern __m512i __cdecl _mm512_maskz_srai_epi16(__mmask32, __m512i, unsigned int);
+extern __m512i __cdecl _mm512_mask_srai_epi32(__m512i, __mmask16, __m512i, unsigned int);
+extern __m512i __cdecl _mm512_maskz_srai_epi32(__mmask16, __m512i, unsigned int);
+extern __m512i __cdecl _mm512_mask_srai_epi64(__m512i, __mmask8, __m512i, unsigned int);
+extern __m512i __cdecl _mm512_maskz_srai_epi64(__mmask8, __m512i, unsigned int);
+extern __m512i __cdecl _mm512_mask_srav_epi16(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_srav_epi16(__mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_srav_epi32(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_srav_epi32(__mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_srav_epi64(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_srav_epi64(__mmask8, __m512i, __m512i);
+
+extern __m512i __cdecl _mm512_bslli_epi128(__m512i, int);
+extern __m512i __cdecl _mm512_bsrli_epi128(__m512i, int);
+
+extern __m512i __cdecl _mm512_rol_epi32(__m512i, const int);
+extern __m512i __cdecl _mm512_mask_rol_epi32(__m512i, __mmask16, __m512i, const int);
+extern __m512i __cdecl _mm512_maskz_rol_epi32(__mmask16, __m512i, const int);
+extern __m512i __cdecl _mm512_rol_epi64(__m512i, const int);
+extern __m512i __cdecl _mm512_mask_rol_epi64(__m512i, __mmask8, __m512i, const int);
+extern __m512i __cdecl _mm512_maskz_rol_epi64(__mmask8, __m512i, const int);
+extern __m512i __cdecl _mm512_rolv_epi32(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_rolv_epi32(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_rolv_epi32(__mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_rolv_epi64(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_rolv_epi64(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_rolv_epi64(__mmask8, __m512i, __m512i);
+
+extern __m512i __cdecl _mm512_ror_epi32(__m512i, int);
+extern __m512i __cdecl _mm512_mask_ror_epi32(__m512i, __mmask16, __m512i, int);
+extern __m512i __cdecl _mm512_maskz_ror_epi32(__mmask16, __m512i, int);
+extern __m512i __cdecl _mm512_ror_epi64(__m512i, int);
+extern __m512i __cdecl _mm512_mask_ror_epi64(__m512i, __mmask8, __m512i, int);
+extern __m512i __cdecl _mm512_maskz_ror_epi64(__mmask8, __m512i, int);
+extern __m512i __cdecl _mm512_rorv_epi32(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_rorv_epi32(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_rorv_epi32(__mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_rorv_epi64(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_rorv_epi64(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_rorv_epi64(__mmask8, __m512i, __m512i);
+
+extern __m512d __cdecl _mm512_unpackhi_pd(__m512d, __m512d);
+extern __m512d __cdecl _mm512_mask_unpackhi_pd(__m512d, __mmask8, __m512d, __m512d);
+extern __m512d __cdecl _mm512_maskz_unpackhi_pd(__mmask8, __m512d, __m512d);
+extern __m512  __cdecl _mm512_unpackhi_ps(__m512, __m512);
+extern __m512  __cdecl _mm512_mask_unpackhi_ps(__m512, __mmask16, __m512, __m512);
+extern __m512  __cdecl _mm512_maskz_unpackhi_ps(__mmask16, __m512, __m512);
+extern __m512d __cdecl _mm512_unpacklo_pd(__m512d, __m512d);
+extern __m512d __cdecl _mm512_mask_unpacklo_pd(__m512d, __mmask8, __m512d, __m512d);
+extern __m512d __cdecl _mm512_maskz_unpacklo_pd(__mmask8, __m512d, __m512d);
+extern __m512  __cdecl _mm512_unpacklo_ps(__m512, __m512);
+extern __m512  __cdecl _mm512_mask_unpacklo_ps(__m512, __mmask16, __m512, __m512);
+extern __m512  __cdecl _mm512_maskz_unpacklo_ps(__mmask16, __m512, __m512);
+extern __m512i __cdecl _mm512_unpackhi_epi8(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_unpackhi_epi8(__m512i, __mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_unpackhi_epi8(__mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_unpackhi_epi16(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_unpackhi_epi16(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_unpackhi_epi16(__mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_unpackhi_epi32(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_unpackhi_epi32(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_unpackhi_epi32(__mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_unpackhi_epi64(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_unpackhi_epi64(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_unpackhi_epi64(__mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_unpacklo_epi8(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_unpacklo_epi8(__m512i, __mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_unpacklo_epi8(__mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_unpacklo_epi16(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_unpacklo_epi16(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_unpacklo_epi16(__mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_unpacklo_epi32(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_unpacklo_epi32(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_unpacklo_epi32(__mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_unpacklo_epi64(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_unpacklo_epi64(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_unpacklo_epi64(__mmask8, __m512i, __m512i);
+
+extern __m512  __cdecl _mm512_getexp_ps(__m512);
+extern __m512  __cdecl _mm512_mask_getexp_ps(__m512, __mmask16, __m512);
+extern __m512  __cdecl _mm512_maskz_getexp_ps(__mmask16, __m512);
+extern __m512  __cdecl _mm512_getexp_round_ps(__m512, int);
+extern __m512  __cdecl _mm512_mask_getexp_round_ps(__m512, __mmask16, __m512, int);
+extern __m512  __cdecl _mm512_maskz_getexp_round_ps(__mmask16, __m512, int);
+extern __m512d __cdecl _mm512_getexp_pd(__m512d);
+extern __m512d __cdecl _mm512_mask_getexp_pd(__m512d, __mmask8, __m512d);
+extern __m512d __cdecl _mm512_maskz_getexp_pd(__mmask8, __m512d);
+extern __m512d __cdecl _mm512_getexp_round_pd(__m512d, int);
+extern __m512d __cdecl _mm512_mask_getexp_round_pd(__m512d, __mmask8, __m512d, int);
+extern __m512d __cdecl _mm512_maskz_getexp_round_pd(__mmask8, __m512d, int);
+
+extern __m512  __cdecl _mm512_getmant_ps(__m512, int, int);
+extern __m512  __cdecl _mm512_mask_getmant_ps(__m512, __mmask16, __m512, int, int);
+extern __m512  __cdecl _mm512_maskz_getmant_ps(__mmask16, __m512, int, int);
+extern __m512  __cdecl _mm512_getmant_round_ps(__m512, int, int, int);
+extern __m512  __cdecl _mm512_mask_getmant_round_ps(__m512, __mmask16, __m512, int, int, int);
+extern __m512  __cdecl _mm512_maskz_getmant_round_ps(__mmask16, __m512, int, int, int);
+extern __m512d __cdecl _mm512_getmant_pd(__m512d, int, int);
+extern __m512d __cdecl _mm512_mask_getmant_pd(__m512d, __mmask8, __m512d, int, int);
+extern __m512d __cdecl _mm512_maskz_getmant_pd(__mmask8, __m512d, int, int);
+extern __m512d __cdecl _mm512_getmant_round_pd(__m512d, int, int, int);
+extern __m512d __cdecl _mm512_mask_getmant_round_pd(__m512d, __mmask8, __m512d, int, int, int);
+extern __m512d __cdecl _mm512_maskz_getmant_round_pd(__mmask8, __m512d, int, int, int);
+
+extern __m512d __cdecl _mm512_permute_pd(__m512d, const int);
+extern __m512d __cdecl _mm512_mask_permute_pd(__m512d, __mmask8, __m512d, const int);
+extern __m512d __cdecl _mm512_maskz_permute_pd(__mmask8, __m512d, const int);
+extern __m512  __cdecl _mm512_permute_ps(__m512, const int);
+extern __m512  __cdecl _mm512_mask_permute_ps(__m512, __mmask16, __m512, const int);
+extern __m512  __cdecl _mm512_maskz_permute_ps(__mmask16, __m512, const int);
+extern __m512d __cdecl _mm512_permutevar_pd(__m512d, __m512i);
+extern __m512d __cdecl _mm512_mask_permutevar_pd(__m512d, __mmask8, __m512d, __m512i);
+extern __m512d __cdecl _mm512_maskz_permutevar_pd(__mmask8, __m512d, __m512i);
+extern __m512  __cdecl _mm512_permutevar_ps(__m512, __m512i);
+extern __m512  __cdecl _mm512_mask_permutevar_ps(__m512, __mmask16, __m512, __m512i);
+extern __m512  __cdecl _mm512_maskz_permutevar_ps(__mmask16, __m512, __m512i);
+extern __m512i __cdecl _mm512_permutevar_epi32(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_permutevar_epi32(__m512i, __mmask16, __m512i, __m512i);
+
+extern __m512d __cdecl _mm512_permutex_pd(__m512d, const int);
+extern __m512d __cdecl _mm512_mask_permutex_pd(__m512d, __mmask8, __m512d, const int);
+extern __m512d __cdecl _mm512_maskz_permutex_pd(__mmask8, __m512d, const int);
+extern __m512i __cdecl _mm512_permutex_epi64(__m512i, const int);
+extern __m512i __cdecl _mm512_mask_permutex_epi64(__m512i, __mmask8, __m512i, const int);
+extern __m512i __cdecl _mm512_maskz_permutex_epi64(__mmask8, __m512i, const int);
+extern __m512d __cdecl _mm512_permutexvar_pd(__m512i, __m512d);
+extern __m512d __cdecl _mm512_mask_permutexvar_pd(__m512d, __mmask8, __m512i, __m512d);
+extern __m512d __cdecl _mm512_maskz_permutexvar_pd(__mmask8, __m512i, __m512d);
+extern __m512  __cdecl _mm512_permutexvar_ps(__m512i, __m512);
+extern __m512  __cdecl _mm512_mask_permutexvar_ps(__m512, __mmask16, __m512i, __m512);
+extern __m512  __cdecl _mm512_maskz_permutexvar_ps(__mmask16, __m512i, __m512);
+extern __m512i __cdecl _mm512_permutexvar_epi16(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_permutexvar_epi16(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_permutexvar_epi16(__mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_permutexvar_epi32(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_permutexvar_epi32(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_permutexvar_epi32(__mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_permutexvar_epi64(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_permutexvar_epi64(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_permutexvar_epi64(__mmask8, __m512i, __m512i);
+
+extern __m512d __cdecl _mm512_permutex2var_pd(__m512d, __m512i /* index */, __m512d);
+extern __m512d __cdecl _mm512_mask_permutex2var_pd(__m512d, __mmask8, __m512i /* index */, __m512d);
+extern __m512d __cdecl _mm512_mask2_permutex2var_pd(__m512d, __m512i /* index */, __mmask8, __m512d);
+extern __m512d __cdecl _mm512_maskz_permutex2var_pd(__mmask8, __m512d, __m512i /* index */, __m512d);
+extern __m512  __cdecl _mm512_permutex2var_ps(__m512, __m512i /* index */, __m512);
+extern __m512  __cdecl _mm512_mask_permutex2var_ps(__m512, __mmask16, __m512i /* index */, __m512);
+extern __m512  __cdecl _mm512_mask2_permutex2var_ps(__m512, __m512i /* index */, __mmask16, __m512);
+extern __m512  __cdecl _mm512_maskz_permutex2var_ps(__mmask16, __m512, __m512i /* index */, __m512);
+extern __m512i __cdecl _mm512_permutex2var_epi16(__m512i, __m512i /* idx */, __m512i);
+extern __m512i __cdecl _mm512_mask_permutex2var_epi16(__m512i, __mmask32, __m512i /* idx */, __m512i);
+extern __m512i __cdecl _mm512_mask2_permutex2var_epi16(__m512i, __m512i /* idx */, __mmask32, __m512i);
+extern __m512i __cdecl _mm512_maskz_permutex2var_epi16(__mmask32, __m512i, __m512i /* idx */, __m512i);
+extern __m512i __cdecl _mm512_permutex2var_epi32(__m512i, __m512i /* idx */, __m512i);
+extern __m512i __cdecl _mm512_mask_permutex2var_epi32(__m512i, __mmask16, __m512i /* idx */, __m512i);
+extern __m512i __cdecl _mm512_mask2_permutex2var_epi32(__m512i, __m512i /* idx */, __mmask16, __m512i);
+extern __m512i __cdecl _mm512_maskz_permutex2var_epi32(__mmask16, __m512i, __m512i /* idx */, __m512i);
+extern __m512i __cdecl _mm512_permutex2var_epi64(__m512i, __m512i /* idx */, __m512i);
+extern __m512i __cdecl _mm512_mask_permutex2var_epi64(__m512i, __mmask8, __m512i /* idx */, __m512i);
+extern __m512i __cdecl _mm512_mask2_permutex2var_epi64(__m512i, __m512i /* idx */, __mmask8, __m512i);
+extern __m512i __cdecl _mm512_maskz_permutex2var_epi64(__mmask8, __m512i, __m512i /* idx */, __m512i);
+
+extern __m512d __cdecl _mm512_mask_compress_pd(__m512d, __mmask8, __m512d);
+extern __m512d __cdecl _mm512_maskz_compress_pd(__mmask8, __m512d);
+extern __m512  __cdecl _mm512_mask_compress_ps(__m512, __mmask16, __m512);
+extern __m512  __cdecl _mm512_maskz_compress_ps(__mmask16, __m512);
+extern __m512i __cdecl _mm512_mask_compress_epi8(__m512i, __mmask64, __m512i);
+extern __m512i __cdecl _mm512_maskz_compress_epi8(__mmask64, __m512i);
+extern __m512i __cdecl _mm512_mask_compress_epi16(__m512i, __mmask32, __m512i);
+extern __m512i __cdecl _mm512_maskz_compress_epi16(__mmask32, __m512i);
+extern __m512i __cdecl _mm512_mask_compress_epi32(__m512i, __mmask16, __m512i);
+extern __m512i __cdecl _mm512_maskz_compress_epi32(__mmask16, __m512i);
+extern __m512i __cdecl _mm512_mask_compress_epi64(__m512i, __mmask8, __m512i);
+extern __m512i __cdecl _mm512_maskz_compress_epi64(__mmask8, __m512i);
+
+extern void    __cdecl _mm512_mask_compressstoreu_pd(void*, __mmask8, __m512d);
+extern void    __cdecl _mm512_mask_compressstoreu_ps(void*, __mmask16, __m512);
+extern void    __cdecl _mm512_mask_compressstoreu_epi8(void*, __mmask64, __m512i);
+extern void    __cdecl _mm512_mask_compressstoreu_epi16(void*, __mmask32, __m512i);
+extern void    __cdecl _mm512_mask_compressstoreu_epi32(void*, __mmask16, __m512i);
+extern void    __cdecl _mm512_mask_compressstoreu_epi64(void*, __mmask8, __m512i);
+
+extern __m512d __cdecl _mm512_mask_expand_pd(__m512d, __mmask8, __m512d);
+extern __m512d __cdecl _mm512_maskz_expand_pd(__mmask8, __m512d);
+extern __m512  __cdecl _mm512_mask_expand_ps(__m512, __mmask16, __m512);
+extern __m512  __cdecl _mm512_maskz_expand_ps(__mmask16, __m512);
+extern __m512i __cdecl _mm512_mask_expand_epi8(__m512i, __mmask64, __m512i);
+extern __m512i __cdecl _mm512_maskz_expand_epi8(__mmask64, __m512i);
+extern __m512i __cdecl _mm512_mask_expand_epi16(__m512i, __mmask32, __m512i);
+extern __m512i __cdecl _mm512_maskz_expand_epi16(__mmask32, __m512i);
+extern __m512i __cdecl _mm512_mask_expand_epi32(__m512i, __mmask16, __m512i);
+extern __m512i __cdecl _mm512_maskz_expand_epi32(__mmask16, __m512i);
+extern __m512i __cdecl _mm512_mask_expand_epi64(__m512i, __mmask8, __m512i);
+extern __m512i __cdecl _mm512_maskz_expand_epi64(__mmask8, __m512i);
+extern __m512d __cdecl _mm512_mask_expandloadu_pd(__m512d, __mmask8, void const*);
+extern __m512d __cdecl _mm512_maskz_expandloadu_pd(__mmask8, void const*);
+extern __m512  __cdecl _mm512_mask_expandloadu_ps(__m512, __mmask16, void const*);
+extern __m512  __cdecl _mm512_maskz_expandloadu_ps(__mmask16, void const*);
+extern __m512i __cdecl _mm512_mask_expandloadu_epi8(__m512i, __mmask64, const void*);
+extern __m512i __cdecl _mm512_maskz_expandloadu_epi8(__mmask64, const void*);
+extern __m512i __cdecl _mm512_mask_expandloadu_epi16(__m512i, __mmask32, const void*);
+extern __m512i __cdecl _mm512_maskz_expandloadu_epi16(__mmask32, const void*);
+extern __m512i __cdecl _mm512_mask_expandloadu_epi32(__m512i, __mmask16, void const*);
+extern __m512i __cdecl _mm512_maskz_expandloadu_epi32(__mmask16, void const*);
+extern __m512i __cdecl _mm512_mask_expandloadu_epi64(__m512i, __mmask8, void const*);
+extern __m512i __cdecl _mm512_maskz_expandloadu_epi64(__mmask8, void const*);
+
+extern __m512i __cdecl _mm512_ternarylogic_epi32(__m512i, __m512i, __m512i, int);
+extern __m512i __cdecl _mm512_mask_ternarylogic_epi32(__m512i, __mmask16, __m512i, __m512i, int);
+extern __m512i __cdecl _mm512_maskz_ternarylogic_epi32(__mmask16, __m512i, __m512i, __m512i, int);
+extern __m512i __cdecl _mm512_ternarylogic_epi64(__m512i, __m512i, __m512i, int);
+extern __m512i __cdecl _mm512_mask_ternarylogic_epi64(__m512i, __mmask8, __m512i, __m512i, int);
+extern __m512i __cdecl _mm512_maskz_ternarylogic_epi64(__mmask8, __m512i, __m512i, __m512i, int);
+
+extern __m512i __cdecl _mm512_conflict_epi32(__m512i);
+extern __m512i __cdecl _mm512_mask_conflict_epi32(__m512i, __mmask16, __m512i);
+extern __m512i __cdecl _mm512_maskz_conflict_epi32(__mmask16, __m512i);
+extern __m512i __cdecl _mm512_conflict_epi64(__m512i);
+extern __m512i __cdecl _mm512_mask_conflict_epi64(__m512i, __mmask8, __m512i);
+extern __m512i __cdecl _mm512_maskz_conflict_epi64(__mmask8, __m512i);
+
+extern __m512i __cdecl _mm512_lzcnt_epi32(__m512i);
+extern __m512i __cdecl _mm512_mask_lzcnt_epi32(__m512i, __mmask16, __m512i);
+extern __m512i __cdecl _mm512_maskz_lzcnt_epi32(__mmask16, __m512i);
+extern __m512i __cdecl _mm512_lzcnt_epi64(__m512i);
+extern __m512i __cdecl _mm512_mask_lzcnt_epi64(__m512i, __mmask8, __m512i);
+extern __m512i __cdecl _mm512_maskz_lzcnt_epi64(__mmask8, __m512i);
+
+extern __m512i __cdecl _mm512_avg_epu8(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_avg_epu8(__m512i, __mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_avg_epu8(__mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_avg_epu16(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_avg_epu16(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_avg_epu16(__mmask32, __m512i, __m512i);
+
+extern __m512i __cdecl _mm512_sad_epu8(__m512i, __m512i);
+extern __m512i __cdecl _mm512_dbsad_epu8(__m512i, __m512i, int);
+extern __m512i __cdecl _mm512_mask_dbsad_epu8(__m512i, __mmask32, __m512i, __m512i, int);
+extern __m512i __cdecl _mm512_maskz_dbsad_epu8(__mmask32, __m512i, __m512i, int);
+
+extern float   __cdecl _mm512_reduce_add_ps(__m512);
+extern float   __cdecl _mm512_mask_reduce_add_ps(__mmask16, __m512);
+extern double  __cdecl _mm512_reduce_add_pd(__m512d);
+extern double  __cdecl _mm512_mask_reduce_add_pd(__mmask8, __m512d);
+extern int     __cdecl _mm512_reduce_add_epi8(__m512i);
+extern int     __cdecl _mm512_mask_reduce_add_epi8(__mmask64, __m512i);
+extern int     __cdecl _mm512_reduce_add_epi16(__m512i);
+extern int     __cdecl _mm512_mask_reduce_add_epi16(__mmask32, __m512i);
+extern int     __cdecl _mm512_reduce_add_epi32(__m512i);
+extern int     __cdecl _mm512_mask_reduce_add_epi32(__mmask16, __m512i);
+extern __int64 __cdecl _mm512_reduce_add_epi64(__m512i);
+extern __int64 __cdecl _mm512_mask_reduce_add_epi64(__mmask8, __m512i);
+extern int     __cdecl _mm512_reduce_add_epu8(__m512i);
+extern int     __cdecl _mm512_mask_reduce_add_epu8(__mmask64, __m512i);
+extern int     __cdecl _mm512_reduce_add_epu16(__m512i);
+extern int     __cdecl _mm512_mask_reduce_add_epu16(__mmask32, __m512i);
+
+extern float   __cdecl _mm512_reduce_mul_ps(__m512);
+extern float   __cdecl _mm512_mask_reduce_mul_ps(__mmask16, __m512);
+extern double  __cdecl _mm512_reduce_mul_pd(__m512d);
+extern double  __cdecl _mm512_mask_reduce_mul_pd(__mmask8, __m512d);
+extern int     __cdecl _mm512_reduce_mul_epi32(__m512i);
+extern int     __cdecl _mm512_mask_reduce_mul_epi32(__mmask16, __m512i);
+extern __int64 __cdecl _mm512_reduce_mul_epi64(__m512i);
+extern __int64 __cdecl _mm512_mask_reduce_mul_epi64(__mmask8, __m512i);
+
+extern float   __cdecl _mm512_reduce_min_ps(__m512);
+extern float   __cdecl _mm512_mask_reduce_min_ps(__mmask16, __m512);
+extern double  __cdecl _mm512_reduce_min_pd(__m512d);
+extern double  __cdecl _mm512_mask_reduce_min_pd(__mmask8, __m512d);
+extern int     __cdecl _mm512_reduce_min_epi32(__m512i);
+extern int     __cdecl _mm512_mask_reduce_min_epi32(__mmask16, __m512i);
+extern __int64 __cdecl _mm512_reduce_min_epi64(__m512i);
+extern __int64 __cdecl _mm512_mask_reduce_min_epi64(__mmask8, __m512i);
+extern unsigned int     __cdecl _mm512_reduce_min_epu32(__m512i);
+extern unsigned int     __cdecl _mm512_mask_reduce_min_epu32(__mmask16, __m512i);
+extern unsigned __int64 __cdecl _mm512_reduce_min_epu64(__m512i);
+extern unsigned __int64 __cdecl _mm512_mask_reduce_min_epu64(__mmask8, __m512i);
+
+extern float   __cdecl _mm512_reduce_max_ps(__m512);
+extern float   __cdecl _mm512_mask_reduce_max_ps(__mmask16, __m512);
+extern double  __cdecl _mm512_reduce_max_pd(__m512d);
+extern double  __cdecl _mm512_mask_reduce_max_pd(__mmask8, __m512d);
+extern int     __cdecl _mm512_reduce_max_epi32(__m512i);
+extern int     __cdecl _mm512_mask_reduce_max_epi32(__mmask16, __m512i);
+extern __int64 __cdecl _mm512_reduce_max_epi64(__m512i);
+extern __int64 __cdecl _mm512_mask_reduce_max_epi64(__mmask8, __m512i);
+extern unsigned int     __cdecl _mm512_reduce_max_epu32(__m512i);
+extern unsigned int     __cdecl _mm512_mask_reduce_max_epu32(__mmask16, __m512i);
+extern unsigned __int64 __cdecl _mm512_reduce_max_epu64(__m512i);
+extern unsigned __int64 __cdecl _mm512_mask_reduce_max_epu64(__mmask8, __m512i);
+
+extern int     __cdecl _mm512_reduce_and_epi32(__m512i);
+extern int     __cdecl _mm512_mask_reduce_and_epi32(__mmask16, __m512i);
+extern __int64 __cdecl _mm512_reduce_and_epi64(__m512i);
+extern __int64 __cdecl _mm512_mask_reduce_and_epi64(__mmask8, __m512i);
+
+extern int     __cdecl _mm512_reduce_or_epi32(__m512i);
+extern int     __cdecl _mm512_mask_reduce_or_epi32(__mmask16, __m512i);
+extern __int64 __cdecl _mm512_reduce_or_epi64(__m512i);
+extern __int64 __cdecl _mm512_mask_reduce_or_epi64(__mmask8, __m512i);
+
+extern int     __cdecl _mm512_reduce_xor_epi32(__m512i);
+extern int     __cdecl _mm512_mask_reduce_xor_epi32(__mmask16, __m512i);
+extern __int64 __cdecl _mm512_reduce_xor_epi64(__m512i);
+extern __int64 __cdecl _mm512_mask_reduce_xor_epi64(__mmask8, __m512i);
+
+extern __m512d __cdecl _mm512_reduce_pd(__m512d, int);
+extern __m512d __cdecl _mm512_mask_reduce_pd(__m512d, __mmask8, __m512d, int);
+extern __m512d __cdecl _mm512_maskz_reduce_pd(__mmask8, __m512d, int);
+extern __m512d __cdecl _mm512_reduce_round_pd(__m512d, int, int);
+extern __m512d __cdecl _mm512_mask_reduce_round_pd(__m512d, __mmask8, __m512d, int, int);
+extern __m512d __cdecl _mm512_maskz_reduce_round_pd(__mmask8, __m512d, int, int);
+extern __m512  __cdecl _mm512_reduce_ps(__m512, int);
+extern __m512  __cdecl _mm512_mask_reduce_ps(__m512, __mmask16, __m512, int);
+extern __m512  __cdecl _mm512_maskz_reduce_ps(__mmask16, __m512, int);
+extern __m512  __cdecl _mm512_reduce_round_ps(__m512, int, int);
+extern __m512  __cdecl _mm512_mask_reduce_round_ps(__m512, __mmask16, __m512, int, int);
+extern __m512  __cdecl _mm512_maskz_reduce_round_ps(__mmask16, __m512, int, int);
+
+extern __m512d __cdecl _mm512_roundscale_pd(__m512d, int);
+extern __m512d __cdecl _mm512_mask_roundscale_pd(__m512d, __mmask8, __m512d, int);
+extern __m512d __cdecl _mm512_maskz_roundscale_pd(__mmask8, __m512d, int);
+extern __m512d __cdecl _mm512_roundscale_round_pd(__m512d, int, int);
+extern __m512d __cdecl _mm512_mask_roundscale_round_pd(__m512d, __mmask8, __m512d, int, int);
+extern __m512d __cdecl _mm512_maskz_roundscale_round_pd(__mmask8, __m512d, int, int);
+extern __m512  __cdecl _mm512_roundscale_ps(__m512, int);
+extern __m512  __cdecl _mm512_mask_roundscale_ps(__m512, __mmask16, __m512, int);
+extern __m512  __cdecl _mm512_maskz_roundscale_ps(__mmask16, __m512, int);
+extern __m512  __cdecl _mm512_roundscale_round_ps(__m512, int, int);
+extern __m512  __cdecl _mm512_mask_roundscale_round_ps(__m512, __mmask16, __m512, int, int);
+extern __m512  __cdecl _mm512_maskz_roundscale_round_ps(__mmask16, __m512, int, int);
+
+extern __m512d __cdecl _mm512_scalef_pd(__m512d, __m512d);
+extern __m512d __cdecl _mm512_mask_scalef_pd(__m512d, __mmask8, __m512d, __m512d);
+extern __m512d __cdecl _mm512_maskz_scalef_pd(__mmask8, __m512d, __m512d);
+extern __m512d __cdecl _mm512_scalef_round_pd(__m512d, __m512d, int);
+extern __m512d __cdecl _mm512_mask_scalef_round_pd(__m512d, __mmask8, __m512d, __m512d, int);
+extern __m512d __cdecl _mm512_maskz_scalef_round_pd(__mmask8, __m512d, __m512d, int);
+extern __m512  __cdecl _mm512_scalef_ps(__m512, __m512);
+extern __m512  __cdecl _mm512_mask_scalef_ps(__m512, __mmask16, __m512, __m512);
+extern __m512  __cdecl _mm512_maskz_scalef_ps(__mmask16, __m512, __m512);
+extern __m512  __cdecl _mm512_scalef_round_ps(__m512, __m512, int);
+extern __m512  __cdecl _mm512_mask_scalef_round_ps(__m512, __mmask16, __m512, __m512, int);
+extern __m512  __cdecl _mm512_maskz_scalef_round_ps(__mmask16, __m512, __m512, int);
+
+extern __m512d __cdecl _mm512_fixupimm_pd(__m512d, __m512d, __m512i, const int);
+extern __m512d __cdecl _mm512_mask_fixupimm_pd(__m512d, __mmask8, __m512d, __m512i, const int);
+extern __m512d __cdecl _mm512_maskz_fixupimm_pd(__mmask8, __m512d, __m512d, __m512i, const int);
+extern __m512d __cdecl _mm512_fixupimm_round_pd(__m512d, __m512d, __m512i, const int, const int);
+extern __m512d __cdecl _mm512_mask_fixupimm_round_pd(__m512d, __mmask8, __m512d, __m512i, const int, const int);
+extern __m512d __cdecl _mm512_maskz_fixupimm_round_pd(__mmask8, __m512d, __m512d, __m512i, const int, const int);
+extern __m512  __cdecl _mm512_fixupimm_ps(__m512, __m512, __m512i, const int);
+extern __m512  __cdecl _mm512_mask_fixupimm_ps(__m512, __mmask16, __m512, __m512i, const int);
+extern __m512  __cdecl _mm512_maskz_fixupimm_ps(__mmask16, __m512, __m512, __m512i, const int);
+extern __m512  __cdecl _mm512_fixupimm_round_ps(__m512, __m512, __m512i, const int, const int);
+extern __m512  __cdecl _mm512_mask_fixupimm_round_ps(__m512, __mmask16, __m512, __m512i, const int, const int);
+extern __m512  __cdecl _mm512_maskz_fixupimm_round_ps(__mmask16, __m512, __m512, __m512i, const int, const int);
+
+extern void    __cdecl _mm512_stream_pd(void*, __m512d);
+extern void    __cdecl _mm512_stream_ps(void*, __m512);
+extern void    __cdecl _mm512_stream_si512(void*, __m512i);
+extern __m512i __cdecl _mm512_stream_load_si512(void const*);
+
+extern __m128d __cdecl _mm512_castpd512_pd128(__m512d);
+extern __m128  __cdecl _mm512_castps512_ps128(__m512);
+extern __m128i __cdecl _mm512_castsi512_si128(__m512i);
+extern __m512i __cdecl _mm512_castsi128_si512(__m128i);
+
+extern __mmask16 __cdecl _mm512_fpclass_ps_mask(__m512, int);
+extern __mmask16 __cdecl _mm512_mask_fpclass_ps_mask(__mmask16, __m512, int);
+extern __mmask8  __cdecl _mm512_fpclass_pd_mask(__m512d, int);
+extern __mmask8  __cdecl _mm512_mask_fpclass_pd_mask(__mmask8, __m512d, int);
+
+extern __m512d __cdecl _mm512_range_pd(__m512d, __m512d, int);
+extern __m512d __cdecl _mm512_mask_range_pd(__m512d, __mmask8, __m512d, __m512d, int);
+extern __m512d __cdecl _mm512_maskz_range_pd(__mmask8, __m512d, __m512d, int);
+extern __m512d __cdecl _mm512_range_round_pd(__m512d, __m512d, int, int);
+extern __m512d __cdecl _mm512_mask_range_round_pd(__m512d, __mmask8, __m512d, __m512d, int, int);
+extern __m512d __cdecl _mm512_maskz_range_round_pd(__mmask8, __m512d, __m512d, int, int);
+extern __m512  __cdecl _mm512_range_ps(__m512, __m512, int);
+extern __m512  __cdecl _mm512_mask_range_ps(__m512, __mmask16, __m512, __m512, int);
+extern __m512  __cdecl _mm512_maskz_range_ps(__mmask16, __m512, __m512, int);
+extern __m512  __cdecl _mm512_range_round_ps(__m512, __m512, int, int);
+extern __m512  __cdecl _mm512_mask_range_round_ps(__m512, __mmask16, __m512, __m512, int, int);
+extern __m512  __cdecl _mm512_maskz_range_round_ps(__mmask16, __m512, __m512, int, int);
+
+extern __m512i __cdecl _mm512_madd_epi16(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_madd_epi16(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_madd_epi16(__mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maddubs_epi16(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_maddubs_epi16(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_maddubs_epi16(__mmask32, __m512i, __m512i);
+
+extern __m512i __cdecl _mm512_packs_epi16(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_packs_epi16(__m512i, __mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_packs_epi16(__mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_packs_epi32(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_packs_epi32(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_packs_epi32(__mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_packus_epi16(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_packus_epi16(__m512i, __mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_packus_epi16(__mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_packus_epi32(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_packus_epi32(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_packus_epi32(__mmask32, __m512i, __m512i);
+
+extern __mmask64 __cdecl _mm512_cmp_epi8_mask(__m512i, __m512i, const int);
+extern __mmask64 __cdecl _mm512_mask_cmp_epi8_mask(__mmask64, __m512i, __m512i, const int);
+extern __mmask32 __cdecl _mm512_cmp_epi16_mask(__m512i, __m512i, const int);
+extern __mmask32 __cdecl _mm512_mask_cmp_epi16_mask(__mmask32, __m512i, __m512i, const int);
+extern __mmask16 __cdecl _mm512_cmp_epi32_mask(__m512i, __m512i, const int);
+extern __mmask16 __cdecl _mm512_mask_cmp_epi32_mask(__mmask16, __m512i, __m512i, const int);
+extern __mmask8  __cdecl _mm512_cmp_epi64_mask(__m512i, __m512i, const int);
+extern __mmask8  __cdecl _mm512_mask_cmp_epi64_mask(__mmask8, __m512i, __m512i, const int);
+extern __mmask64 __cdecl _mm512_cmp_epu8_mask(__m512i, __m512i, const int);
+extern __mmask64 __cdecl _mm512_mask_cmp_epu8_mask(__mmask64, __m512i, __m512i, const int);
+extern __mmask32 __cdecl _mm512_cmp_epu16_mask(__m512i, __m512i, const int);
+extern __mmask32 __cdecl _mm512_mask_cmp_epu16_mask(__mmask32, __m512i, __m512i, const int);
+extern __mmask16 __cdecl _mm512_cmp_epu32_mask(__m512i, __m512i, const int);
+extern __mmask16 __cdecl _mm512_mask_cmp_epu32_mask(__mmask16, __m512i, __m512i, const int);
+extern __mmask8  __cdecl _mm512_cmp_epu64_mask(__m512i, __m512i, const int);
+extern __mmask8  __cdecl _mm512_mask_cmp_epu64_mask(__mmask8, __m512i, __m512i, const int);
+
+extern __mmask64 __cdecl _mm512_test_epi8_mask(__m512i, __m512i);
+extern __mmask64 __cdecl _mm512_mask_test_epi8_mask(__mmask64, __m512i, __m512i);
+extern __mmask32 __cdecl _mm512_test_epi16_mask(__m512i, __m512i);
+extern __mmask32 __cdecl _mm512_mask_test_epi16_mask(__mmask32, __m512i, __m512i);
+extern __mmask64 __cdecl _mm512_testn_epi8_mask(__m512i, __m512i);
+extern __mmask64 __cdecl _mm512_mask_testn_epi8_mask(__mmask64, __m512i, __m512i);
+extern __mmask32 __cdecl _mm512_testn_epi16_mask(__m512i, __m512i);
+extern __mmask32 __cdecl _mm512_mask_testn_epi16_mask(__mmask32, __m512i, __m512i);
+extern __mmask16 __cdecl _mm512_test_epi32_mask(__m512i, __m512i);
+extern __mmask16 __cdecl _mm512_mask_test_epi32_mask(__mmask16, __m512i, __m512i);
+extern __mmask8  __cdecl _mm512_test_epi64_mask(__m512i, __m512i);
+extern __mmask8  __cdecl _mm512_mask_test_epi64_mask(__mmask8, __m512i, __m512i);
+extern __mmask16 __cdecl _mm512_testn_epi32_mask(__m512i, __m512i);
+extern __mmask16 __cdecl _mm512_mask_testn_epi32_mask(__mmask16, __m512i, __m512i);
+extern __mmask8  __cdecl _mm512_testn_epi64_mask(__m512i, __m512i);
+extern __mmask8  __cdecl _mm512_mask_testn_epi64_mask(__mmask8, __m512i, __m512i);
+
+extern __mmask16 __cdecl _mm512_kunpackb(__mmask16, __mmask16);
+extern __mmask32 __cdecl _mm512_kunpackw(__mmask32, __mmask32);
+extern __mmask64 __cdecl _mm512_kunpackd(__mmask64, __mmask64);
+
+extern unsigned char __cdecl _mm512_testz_and_mask8(__mmask8, __mmask8);
+extern unsigned char __cdecl _mm512_testz_and_mask16(__mmask16, __mmask16);
+extern unsigned char __cdecl _mm512_testz_and_mask32(__mmask32, __mmask32);
+extern unsigned char __cdecl _mm512_testz_and_mask64(__mmask64, __mmask64);
+extern unsigned char __cdecl _mm512_testz_andn_mask8(__mmask8, __mmask8);
+extern unsigned char __cdecl _mm512_testz_andn_mask16(__mmask16, __mmask16);
+extern unsigned char __cdecl _mm512_testz_andn_mask32(__mmask32, __mmask32);
+extern unsigned char __cdecl _mm512_testz_andn_mask64(__mmask64, __mmask64);
+extern unsigned char __cdecl _mm512_testz_or_mask8(__mmask8, __mmask8);
+extern unsigned char __cdecl _mm512_testz_or_mask16(__mmask16, __mmask16);
+extern unsigned char __cdecl _mm512_testz_or_mask32(__mmask32, __mmask32);
+extern unsigned char __cdecl _mm512_testz_or_mask64(__mmask64, __mmask64);
+extern unsigned char __cdecl _mm512_testz_nor_mask8(__mmask8, __mmask8);
+extern unsigned char __cdecl _mm512_testz_nor_mask16(__mmask16, __mmask16);
+extern unsigned char __cdecl _mm512_testz_nor_mask32(__mmask32, __mmask32);
+extern unsigned char __cdecl _mm512_testz_nor_mask64(__mmask64, __mmask64);
+
+extern __m512  __cdecl _mm512_i32gather_ps(__m512i, void const*, int);
+extern __m512  __cdecl _mm512_mask_i32gather_ps(__m512, __mmask16, __m512i, void const*, int);
+extern void    __cdecl _mm512_i32scatter_ps(void*, __m512i, __m512, int);
+extern void    __cdecl _mm512_mask_i32scatter_ps(void*, __mmask16, __m512i, __m512, int);
+extern __m512d __cdecl _mm512_i64gather_pd(__m512i, void const*, int);
+extern __m512d __cdecl _mm512_mask_i64gather_pd(__m512d, __mmask8, __m512i, void const*, int);
+extern void    __cdecl _mm512_i64scatter_pd(void*, __m512i, __m512d, int);
+extern void    __cdecl _mm512_mask_i64scatter_pd(void*, __mmask8, __m512i, __m512d, int);
+extern __m512d __cdecl _mm512_i32gather_pd(__m256i, void const*, int);
+extern __m512d __cdecl _mm512_mask_i32gather_pd(__m512d, __mmask8, __m256i, void const*, int);
+extern void    __cdecl _mm512_i32scatter_pd(void*, __m256i, __m512d, int);
+extern void    __cdecl _mm512_mask_i32scatter_pd(void*, __mmask8, __m256i, __m512d, int);
+extern __m512i __cdecl _mm512_i32gather_epi32(__m512i, void const*, int);
+extern __m512i __cdecl _mm512_mask_i32gather_epi32(__m512i, __mmask16, __m512i, void const*, int);
+extern void    __cdecl _mm512_i32scatter_epi32(void*, __m512i, __m512i, int);
+extern void    __cdecl _mm512_mask_i32scatter_epi32(void*, __mmask16, __m512i, __m512i, int);
+extern __m512i __cdecl _mm512_i32gather_epi64(__m256i, void const*, int);
+extern __m512i __cdecl _mm512_mask_i32gather_epi64(__m512i, __mmask8, __m256i, void const*, int);
+extern __m512i __cdecl _mm512_i64gather_epi64(__m512i, void const*, int);
+extern __m512i __cdecl _mm512_mask_i64gather_epi64(__m512i, __mmask8, __m512i, void const*, int);
+extern void    __cdecl _mm512_i32scatter_epi64(void*, __m256i, __m512i, int);
+extern void    __cdecl _mm512_mask_i32scatter_epi64(void*, __mmask8, __m256i, __m512i, int);
+extern void    __cdecl _mm512_i64scatter_epi64(void*, __m512i, __m512i, int);
+extern void    __cdecl _mm512_mask_i64scatter_epi64(void*, __mmask8, __m512i, __m512i, int);
+extern __m256  __cdecl _mm512_i64gather_ps(__m512i, void const*, int);
+extern __m256  __cdecl _mm512_mask_i64gather_ps(__m256, __mmask8, __m512i, void const*, int);
+extern void    __cdecl _mm512_i64scatter_ps(void*, __m512i, __m256, int);
+extern void    __cdecl _mm512_mask_i64scatter_ps(void*, __mmask8, __m512i, __m256, int);
+extern __m256i __cdecl _mm512_i64gather_epi32(__m512i, void const*, int);
+extern __m256i __cdecl _mm512_mask_i64gather_epi32(__m256i, __mmask8, __m512i, void const*, int);
+extern void    __cdecl _mm512_i64scatter_epi32(void*, __m512i, __m256i, int);
+extern void    __cdecl _mm512_mask_i64scatter_epi32(void*, __mmask8, __m512i, __m256i, int);
+
+extern __m512d __cdecl _mm512_cvtpslo_pd(__m512);
+extern __m512d __cdecl _mm512_mask_cvtpslo_pd(__m512d, __mmask8, __m512);
+extern __m512d __cdecl _mm512_cvtepi32lo_pd(__m512i);
+extern __m512d __cdecl _mm512_mask_cvtepi32lo_pd(__m512d, __mmask8, __m512i);
+extern __m512d __cdecl _mm512_cvtepu32lo_pd(__m512i);
+extern __m512d __cdecl _mm512_mask_cvtepu32lo_pd(__m512d, __mmask8, __m512i);
+extern __m512d __cdecl _mm512_cvtepi32_pd(__m256i);
+extern __m512d __cdecl _mm512_mask_cvtepi32_pd(__m512d, __mmask8, __m256i);
+extern __m512d __cdecl _mm512_maskz_cvtepi32_pd(__mmask8, __m256i);
+extern __m512d __cdecl _mm512_cvtepu32_pd(__m256i);
+extern __m512d __cdecl _mm512_mask_cvtepu32_pd(__m512d, __mmask8, __m256i);
+extern __m512d __cdecl _mm512_maskz_cvtepu32_pd(__mmask8, __m256i);
+
+extern __m512  __cdecl _mm512_cvtepi32_ps( __m512i);
+extern __m512  __cdecl _mm512_mask_cvtepi32_ps(__m512, __mmask16, __m512i);
+extern __m512  __cdecl _mm512_maskz_cvtepi32_ps(__mmask16, __m512i);
+extern __m512  __cdecl _mm512_cvt_roundepi32_ps(__m512i, int);
+extern __m512  __cdecl _mm512_mask_cvt_roundepi32_ps(__m512, __mmask16, __m512i, int);
+extern __m512  __cdecl _mm512_maskz_cvt_roundepi32_ps(__mmask16, __m512i, int);
+extern __m512  __cdecl _mm512_cvtepu32_ps( __m512i);
+extern __m512  __cdecl _mm512_mask_cvtepu32_ps(__m512, __mmask16, __m512i);
+extern __m512  __cdecl _mm512_maskz_cvtepu32_ps(__mmask16, __m512i);
+extern __m512  __cdecl _mm512_cvt_roundepu32_ps(__m512i, int);
+extern __m512  __cdecl _mm512_mask_cvt_roundepu32_ps(__m512, __mmask16, __m512i, int);
+extern __m512  __cdecl _mm512_maskz_cvt_roundepu32_ps(__mmask16, __m512i, int);
+extern __m512  __cdecl _mm512_cvtph_ps(__m256i);
+extern __m512  __cdecl _mm512_mask_cvtph_ps(__m512, __mmask16, __m256i);
+extern __m512  __cdecl _mm512_maskz_cvtph_ps(__mmask16, __m256i);
+extern __m512  __cdecl _mm512_cvt_roundph_ps(__m256i, int);
+extern __m512  __cdecl _mm512_mask_cvt_roundph_ps(__m512, __mmask16, __m256i, int);
+extern __m512  __cdecl _mm512_maskz_cvt_roundph_ps(__mmask16, __m256i, int);
+extern __m256i __cdecl _mm512_cvtps_ph(__m512, int);
+extern __m256i __cdecl _mm512_mask_cvtps_ph(__m256i, __mmask16, __m512, int);
+extern __m256i __cdecl _mm512_maskz_cvtps_ph(__mmask16, __m512, int);
+extern __m256i __cdecl _mm512_cvt_roundps_ph(__m512, int);
+extern __m256i __cdecl _mm512_mask_cvt_roundps_ph(__m256i, __mmask16, __m512, int);
+extern __m256i __cdecl _mm512_maskz_cvt_roundps_ph(__mmask16, __m512, int);
+extern __m256  __cdecl _mm512_cvtepi64_ps(__m512i);
+extern __m256  __cdecl _mm512_mask_cvtepi64_ps(__m256, __mmask8, __m512i);
+extern __m256  __cdecl _mm512_maskz_cvtepi64_ps(__mmask8, __m512i);
+extern __m256  __cdecl _mm512_cvt_roundepi64_ps(__m512i, int);
+extern __m256  __cdecl _mm512_mask_cvt_roundepi64_ps(__m256, __mmask8, __m512i, int);
+extern __m256  __cdecl _mm512_maskz_cvt_roundepi64_ps(__mmask8, __m512i, int);
+extern __m256  __cdecl _mm512_cvtepu64_ps(__m512i);
+extern __m256  __cdecl _mm512_mask_cvtepu64_ps(__m256, __mmask8, __m512i);
+extern __m256  __cdecl _mm512_maskz_cvtepu64_ps(__mmask8, __m512i);
+extern __m256  __cdecl _mm512_cvt_roundepu64_ps(__m512i, int);
+extern __m256  __cdecl _mm512_mask_cvt_roundepu64_ps(__m256, __mmask8, __m512i, int);
+extern __m256  __cdecl _mm512_maskz_cvt_roundepu64_ps(__mmask8, __m512i, int);
+
+extern __m512i __cdecl _mm512_cvtepi8_epi32(__m128i);
+extern __m512i __cdecl _mm512_mask_cvtepi8_epi32(__m512i, __mmask16, __m128i);
+extern __m512i __cdecl _mm512_maskz_cvtepi8_epi32(__mmask16, __m128i);
+extern __m512i __cdecl _mm512_cvtepi8_epi64(__m128i);
+extern __m512i __cdecl _mm512_mask_cvtepi8_epi64(__m512i, __mmask8, __m128i);
+extern __m512i __cdecl _mm512_maskz_cvtepi8_epi64(__mmask8, __m128i);
+extern __m512i __cdecl _mm512_cvtepi16_epi32(__m256i);
+extern __m512i __cdecl _mm512_mask_cvtepi16_epi32(__m512i, __mmask16, __m256i);
+extern __m512i __cdecl _mm512_maskz_cvtepi16_epi32(__mmask16, __m256i);
+extern __m512i __cdecl _mm512_cvtepi16_epi64(__m128i);
+extern __m512i __cdecl _mm512_mask_cvtepi16_epi64(__m512i, __mmask8, __m128i);
+extern __m512i __cdecl _mm512_maskz_cvtepi16_epi64(__mmask8, __m128i);
+extern __m128i __cdecl _mm512_cvtepi32_epi8(__m512i);
+extern __m128i __cdecl _mm512_mask_cvtepi32_epi8(__m128i, __mmask16, __m512i);
+extern __m128i __cdecl _mm512_maskz_cvtepi32_epi8(__mmask16, __m512i);
+extern void    __cdecl _mm512_mask_cvtepi32_storeu_epi8(void*, __mmask16, __m512i);
+extern __m128i __cdecl _mm512_cvtsepi32_epi8(__m512i);
+extern __m128i __cdecl _mm512_mask_cvtsepi32_epi8(__m128i, __mmask16, __m512i);
+extern __m128i __cdecl _mm512_maskz_cvtsepi32_epi8(__mmask16, __m512i);
+extern void    __cdecl _mm512_mask_cvtsepi32_storeu_epi8(void*, __mmask16, __m512i);
+extern __m128i __cdecl _mm512_cvtusepi32_epi8(__m512i);
+extern __m128i __cdecl _mm512_mask_cvtusepi32_epi8(__m128i, __mmask16, __m512i);
+extern __m128i __cdecl _mm512_maskz_cvtusepi32_epi8(__mmask16, __m512i);
+extern void    __cdecl _mm512_mask_cvtusepi32_storeu_epi8(void*, __mmask16, __m512i);
+extern __m256i __cdecl _mm512_cvtepi32_epi16(__m512i);
+extern __m256i __cdecl _mm512_mask_cvtepi32_epi16(__m256i, __mmask16, __m512i);
+extern __m256i __cdecl _mm512_maskz_cvtepi32_epi16(__mmask16, __m512i);
+extern void    __cdecl _mm512_mask_cvtepi32_storeu_epi16(void*, __mmask16, __m512i);
+extern __m256i __cdecl _mm512_cvtsepi32_epi16(__m512i);
+extern __m256i __cdecl _mm512_mask_cvtsepi32_epi16(__m256i, __mmask16, __m512i);
+extern __m256i __cdecl _mm512_maskz_cvtsepi32_epi16(__mmask16, __m512i);
+extern void    __cdecl _mm512_mask_cvtsepi32_storeu_epi16(void*, __mmask16, __m512i);
+extern __m256i __cdecl _mm512_cvtusepi32_epi16(__m512i);
+extern __m256i __cdecl _mm512_mask_cvtusepi32_epi16(__m256i, __mmask16, __m512i);
+extern __m256i __cdecl _mm512_maskz_cvtusepi32_epi16(__mmask16, __m512i);
+extern void    __cdecl _mm512_mask_cvtusepi32_storeu_epi16(void*, __mmask16, __m512i);
+extern __m512i __cdecl _mm512_cvtepi32_epi64(__m256i);
+extern __m512i __cdecl _mm512_mask_cvtepi32_epi64(__m512i, __mmask8, __m256i);
+extern __m512i __cdecl _mm512_maskz_cvtepi32_epi64(__mmask8, __m256i);
+extern __m128i __cdecl _mm512_cvtepi64_epi8(__m512i);
+extern __m128i __cdecl _mm512_mask_cvtepi64_epi8(__m128i, __mmask8, __m512i);
+extern __m128i __cdecl _mm512_maskz_cvtepi64_epi8(__mmask8, __m512i);
+extern void    __cdecl _mm512_mask_cvtepi64_storeu_epi8(void*, __mmask8, __m512i);
+extern __m128i __cdecl _mm512_cvtsepi64_epi8(__m512i);
+extern __m128i __cdecl _mm512_mask_cvtsepi64_epi8(__m128i, __mmask8, __m512i);
+extern __m128i __cdecl _mm512_maskz_cvtsepi64_epi8(__mmask8, __m512i);
+extern void    __cdecl _mm512_mask_cvtsepi64_storeu_epi8(void*, __mmask8, __m512i);
+extern __m128i __cdecl _mm512_cvtusepi64_epi8(__m512i);
+extern __m128i __cdecl _mm512_mask_cvtusepi64_epi8(__m128i, __mmask8, __m512i);
+extern __m128i __cdecl _mm512_maskz_cvtusepi64_epi8(__mmask8, __m512i);
+extern void    __cdecl _mm512_mask_cvtusepi64_storeu_epi8(void*, __mmask8, __m512i);
+extern __m128i __cdecl _mm512_cvtepi64_epi16(__m512i);
+extern __m128i __cdecl _mm512_mask_cvtepi64_epi16(__m128i, __mmask8, __m512i);
+extern __m128i __cdecl _mm512_maskz_cvtepi64_epi16(__mmask8, __m512i);
+extern void    __cdecl _mm512_mask_cvtepi64_storeu_epi16(void*, __mmask8, __m512i);
+extern __m128i __cdecl _mm512_cvtsepi64_epi16(__m512i);
+extern __m128i __cdecl _mm512_mask_cvtsepi64_epi16(__m128i, __mmask8, __m512i);
+extern __m128i __cdecl _mm512_maskz_cvtsepi64_epi16(__mmask8, __m512i);
+extern void    __cdecl _mm512_mask_cvtsepi64_storeu_epi16(void*, __mmask8, __m512i);
+extern __m128i __cdecl _mm512_cvtusepi64_epi16(__m512i);
+extern __m128i __cdecl _mm512_mask_cvtusepi64_epi16(__m128i, __mmask8, __m512i);
+extern __m128i __cdecl _mm512_maskz_cvtusepi64_epi16(__mmask8, __m512i);
+extern void    __cdecl _mm512_mask_cvtusepi64_storeu_epi16(void*, __mmask8, __m512i);
+extern __m256i __cdecl _mm512_cvtepi64_epi32(__m512i);
+extern __m256i __cdecl _mm512_mask_cvtepi64_epi32(__m256i, __mmask8, __m512i);
+extern __m256i __cdecl _mm512_maskz_cvtepi64_epi32(__mmask8, __m512i);
+extern void    __cdecl _mm512_mask_cvtepi64_storeu_epi32(void*, __mmask8, __m512i);
+extern __m256i __cdecl _mm512_cvtsepi64_epi32(__m512i);
+extern __m256i __cdecl _mm512_mask_cvtsepi64_epi32(__m256i, __mmask8, __m512i);
+extern __m256i __cdecl _mm512_maskz_cvtsepi64_epi32(__mmask8, __m512i);
+extern void    __cdecl _mm512_mask_cvtsepi64_storeu_epi32(void*, __mmask8, __m512i);
+extern __m256i __cdecl _mm512_cvtusepi64_epi32(__m512i);
+extern __m256i __cdecl _mm512_mask_cvtusepi64_epi32(__m256i, __mmask8, __m512i);
+extern __m256i __cdecl _mm512_maskz_cvtusepi64_epi32(__mmask8, __m512i);
+extern void    __cdecl _mm512_mask_cvtusepi64_storeu_epi32(void*, __mmask8, __m512i);
+extern __m512i __cdecl _mm512_cvtepu8_epi32(__m128i);
+extern __m512i __cdecl _mm512_mask_cvtepu8_epi32(__m512i, __mmask16, __m128i);
+extern __m512i __cdecl _mm512_maskz_cvtepu8_epi32(__mmask16, __m128i);
+extern __m512i __cdecl _mm512_cvtepu8_epi64(__m128i);
+extern __m512i __cdecl _mm512_mask_cvtepu8_epi64(__m512i, __mmask8, __m128i);
+extern __m512i __cdecl _mm512_maskz_cvtepu8_epi64(__mmask8, __m128i);
+extern __m512i __cdecl _mm512_cvtepu16_epi32(__m256i);
+extern __m512i __cdecl _mm512_mask_cvtepu16_epi32(__m512i, __mmask16, __m256i);
+extern __m512i __cdecl _mm512_maskz_cvtepu16_epi32(__mmask16, __m256i);
+extern __m512i __cdecl _mm512_cvtepu16_epi64(__m128i);
+extern __m512i __cdecl _mm512_mask_cvtepu16_epi64(__m512i, __mmask8, __m128i);
+extern __m512i __cdecl _mm512_maskz_cvtepu16_epi64(__mmask8, __m128i);
+extern __m512i __cdecl _mm512_cvtepu32_epi64(__m256i);
+extern __m512i __cdecl _mm512_mask_cvtepu32_epi64(__m512i, __mmask8, __m256i);
+extern __m512i __cdecl _mm512_maskz_cvtepu32_epi64(__mmask8, __m256i);
+
+extern __m512i __cdecl _mm512_cvtps_epi32(__m512);
+extern __m512i __cdecl _mm512_mask_cvtps_epi32(__m512i, __mmask16, __m512);
+extern __m512i __cdecl _mm512_maskz_cvtps_epi32(__mmask16, __m512);
+extern __m512i __cdecl _mm512_cvt_roundps_epi32(__m512, int);
+extern __m512i __cdecl _mm512_mask_cvt_roundps_epi32(__m512i, __mmask16, __m512, int);
+extern __m512i __cdecl _mm512_maskz_cvt_roundps_epi32(__mmask16, __m512, int);
+extern __m512i __cdecl _mm512_cvttps_epi32(__m512);
+extern __m512i __cdecl _mm512_mask_cvttps_epi32(__m512i, __mmask16, __m512);
+extern __m512i __cdecl _mm512_maskz_cvttps_epi32(__mmask16, __m512);
+extern __m512i __cdecl _mm512_cvtt_roundps_epi32(__m512, int);
+extern __m512i __cdecl _mm512_mask_cvtt_roundps_epi32(__m512i, __mmask16, __m512, int);
+extern __m512i __cdecl _mm512_maskz_cvtt_roundps_epi32(__mmask16, __m512, int);
+extern __m512i __cdecl _mm512_cvtps_epu32(__m512);
+extern __m512i __cdecl _mm512_mask_cvtps_epu32(__m512i, __mmask16, __m512);
+extern __m512i __cdecl _mm512_maskz_cvtps_epu32(__mmask16, __m512);
+extern __m512i __cdecl _mm512_cvt_roundps_epu32(__m512, int);
+extern __m512i __cdecl _mm512_mask_cvt_roundps_epu32(__m512i, __mmask16, __m512, int);
+extern __m512i __cdecl _mm512_maskz_cvt_roundps_epu32(__mmask16, __m512, int);
+extern __m512i __cdecl _mm512_cvttps_epu32(__m512);
+extern __m512i __cdecl _mm512_mask_cvttps_epu32(__m512i, __mmask16, __m512);
+extern __m512i __cdecl _mm512_maskz_cvttps_epu32(__mmask16, __m512);
+extern __m512i __cdecl _mm512_cvtt_roundps_epu32(__m512, int);
+extern __m512i __cdecl _mm512_mask_cvtt_roundps_epu32(__m512i, __mmask16, __m512, int);
+extern __m512i __cdecl _mm512_maskz_cvtt_roundps_epu32(__mmask16, __m512, int);
+extern __m256i __cdecl _mm512_cvtpd_epi32(__m512d);
+extern __m256i __cdecl _mm512_mask_cvtpd_epi32(__m256i, __mmask8, __m512d);
+extern __m256i __cdecl _mm512_maskz_cvtpd_epi32(__mmask8, __m512d);
+extern __m256i __cdecl _mm512_cvt_roundpd_epi32(__m512d, int);
+extern __m256i __cdecl _mm512_mask_cvt_roundpd_epi32(__m256i, __mmask8, __m512d, int);
+extern __m256i __cdecl _mm512_maskz_cvt_roundpd_epi32(__mmask8, __m512d, int);
+extern __m256i __cdecl _mm512_cvttpd_epi32(__m512d);
+extern __m256i __cdecl _mm512_mask_cvttpd_epi32(__m256i, __mmask8, __m512d);
+extern __m256i __cdecl _mm512_maskz_cvttpd_epi32(__mmask8, __m512d);
+extern __m256i __cdecl _mm512_cvtt_roundpd_epi32(__m512d, int);
+extern __m256i __cdecl _mm512_mask_cvtt_roundpd_epi32(__m256i, __mmask8, __m512d, int);
+extern __m256i __cdecl _mm512_maskz_cvtt_roundpd_epi32(__mmask8, __m512d, int);
+extern __m256i __cdecl _mm512_cvtpd_epu32(__m512d);
+extern __m256i __cdecl _mm512_mask_cvtpd_epu32(__m256i, __mmask8, __m512d);
+extern __m256i __cdecl _mm512_maskz_cvtpd_epu32(__mmask8, __m512d);
+extern __m256i __cdecl _mm512_cvt_roundpd_epu32(__m512d, int);
+extern __m256i __cdecl _mm512_mask_cvt_roundpd_epu32(__m256i, __mmask8, __m512d, int);
+extern __m256i __cdecl _mm512_maskz_cvt_roundpd_epu32(__mmask8, __m512d, int);
+extern __m256i __cdecl _mm512_cvttpd_epu32(__m512d);
+extern __m256i __cdecl _mm512_mask_cvttpd_epu32(__m256i, __mmask8, __m512d);
+extern __m256i __cdecl _mm512_maskz_cvttpd_epu32(__mmask8, __m512d);
+extern __m256i __cdecl _mm512_cvtt_roundpd_epu32(__m512d, int);
+extern __m256i __cdecl _mm512_mask_cvtt_roundpd_epu32(__m256i, __mmask8, __m512d, int);
+extern __m256i __cdecl _mm512_maskz_cvtt_roundpd_epu32(__mmask8, __m512d, int);
+
+extern __m512i __cdecl _mm512_cvtepi8_epi16(__m256i);
+extern __m512i __cdecl _mm512_mask_cvtepi8_epi16(__m512i, __mmask32, __m256i);
+extern __m512i __cdecl _mm512_maskz_cvtepi8_epi16(__mmask32, __m256i);
+extern __m512i __cdecl _mm512_cvtepu8_epi16(__m256i);
+extern __m512i __cdecl _mm512_mask_cvtepu8_epi16(__m512i, __mmask32, __m256i);
+extern __m512i __cdecl _mm512_maskz_cvtepu8_epi16(__mmask32, __m256i);
+extern __m256i __cdecl _mm512_cvtepi16_epi8(__m512i);
+extern __m256i __cdecl _mm512_mask_cvtepi16_epi8(__m256i, __mmask32, __m512i);
+extern __m256i __cdecl _mm512_maskz_cvtepi16_epi8(__mmask32, __m512i);
+extern void    __cdecl _mm512_mask_cvtepi16_storeu_epi8(void*, __mmask32, __m512i);
+extern __m256i __cdecl _mm512_cvtsepi16_epi8(__m512i);
+extern __m256i __cdecl _mm512_mask_cvtsepi16_epi8(__m256i, __mmask32, __m512i);
+extern __m256i __cdecl _mm512_maskz_cvtsepi16_epi8(__mmask32, __m512i);
+extern void    __cdecl _mm512_mask_cvtsepi16_storeu_epi8(void*, __mmask32, __m512i);
+extern __m256i __cdecl _mm512_cvtusepi16_epi8(__m512i);
+extern __m256i __cdecl _mm512_mask_cvtusepi16_epi8(__m256i, __mmask32, __m512i);
+extern __m256i __cdecl _mm512_maskz_cvtusepi16_epi8(__mmask32, __m512i);
+extern void    __cdecl _mm512_mask_cvtusepi16_storeu_epi8(void*, __mmask32, __m512i);
+
+extern __m512d __cdecl _mm512_cvtepi64_pd(__m512i);
+extern __m512d __cdecl _mm512_mask_cvtepi64_pd(__m512d, __mmask8, __m512i);
+extern __m512d __cdecl _mm512_maskz_cvtepi64_pd(__mmask8, __m512i);
+extern __m512d __cdecl _mm512_cvt_roundepi64_pd(__m512i, int);
+extern __m512d __cdecl _mm512_mask_cvt_roundepi64_pd(__m512d, __mmask8, __m512i, int);
+extern __m512d __cdecl _mm512_maskz_cvt_roundepi64_pd(__mmask8, __m512i, int);
+extern __m512d __cdecl _mm512_cvtepu64_pd(__m512i);
+extern __m512d __cdecl _mm512_mask_cvtepu64_pd(__m512d, __mmask8, __m512i);
+extern __m512d __cdecl _mm512_maskz_cvtepu64_pd(__mmask8, __m512i);
+extern __m512d __cdecl _mm512_cvt_roundepu64_pd(__m512i, int);
+extern __m512d __cdecl _mm512_mask_cvt_roundepu64_pd(__m512d, __mmask8, __m512i, int);
+extern __m512d __cdecl _mm512_maskz_cvt_roundepu64_pd(__mmask8, __m512i, int);
+extern __m512i __cdecl _mm512_cvtpd_epi64(__m512d);
+extern __m512i __cdecl _mm512_mask_cvtpd_epi64(__m512i, __mmask8, __m512d);
+extern __m512i __cdecl _mm512_maskz_cvtpd_epi64(__mmask8, __m512d);
+extern __m512i __cdecl _mm512_cvt_roundpd_epi64(__m512d, int);
+extern __m512i __cdecl _mm512_mask_cvt_roundpd_epi64(__m512i, __mmask8, __m512d, int);
+extern __m512i __cdecl _mm512_maskz_cvt_roundpd_epi64(__mmask8, __m512d, int);
+extern __m512i __cdecl _mm512_cvtpd_epu64(__m512d);
+extern __m512i __cdecl _mm512_mask_cvtpd_epu64(__m512i, __mmask8, __m512d);
+extern __m512i __cdecl _mm512_maskz_cvtpd_epu64(__mmask8, __m512d);
+extern __m512i __cdecl _mm512_cvt_roundpd_epu64(__m512d, int);
+extern __m512i __cdecl _mm512_mask_cvt_roundpd_epu64(__m512i, __mmask8, __m512d, int);
+extern __m512i __cdecl _mm512_maskz_cvt_roundpd_epu64(__mmask8, __m512d, int);
+extern __m512i __cdecl _mm512_cvttpd_epi64(__m512d);
+extern __m512i __cdecl _mm512_mask_cvttpd_epi64(__m512i, __mmask8, __m512d);
+extern __m512i __cdecl _mm512_maskz_cvttpd_epi64(__mmask8, __m512d);
+extern __m512i __cdecl _mm512_cvtt_roundpd_epi64(__m512d, int);
+extern __m512i __cdecl _mm512_mask_cvtt_roundpd_epi64(__m512i, __mmask8, __m512d, int);
+extern __m512i __cdecl _mm512_maskz_cvtt_roundpd_epi64(__mmask8, __m512d, int);
+extern __m512i __cdecl _mm512_cvttpd_epu64(__m512d);
+extern __m512i __cdecl _mm512_mask_cvttpd_epu64(__m512i, __mmask8, __m512d);
+extern __m512i __cdecl _mm512_maskz_cvttpd_epu64(__mmask8, __m512d);
+extern __m512i __cdecl _mm512_cvtt_roundpd_epu64(__m512d, int);
+extern __m512i __cdecl _mm512_mask_cvtt_roundpd_epu64(__m512i, __mmask8, __m512d, int);
+extern __m512i __cdecl _mm512_maskz_cvtt_roundpd_epu64(__mmask8, __m512d, int);
+extern __m512i __cdecl _mm512_cvtps_epi64(__m256);
+extern __m512i __cdecl _mm512_mask_cvtps_epi64(__m512i, __mmask8, __m256);
+extern __m512i __cdecl _mm512_maskz_cvtps_epi64(__mmask8, __m256);
+extern __m512i __cdecl _mm512_cvt_roundps_epi64(__m256, int);
+extern __m512i __cdecl _mm512_mask_cvt_roundps_epi64(__m512i, __mmask8, __m256, int);
+extern __m512i __cdecl _mm512_maskz_cvt_roundps_epi64(__mmask8, __m256, int);
+extern __m512i __cdecl _mm512_cvtps_epu64(__m256);
+extern __m512i __cdecl _mm512_mask_cvtps_epu64(__m512i, __mmask8, __m256);
+extern __m512i __cdecl _mm512_maskz_cvtps_epu64(__mmask8, __m256);
+extern __m512i __cdecl _mm512_cvt_roundps_epu64(__m256, int);
+extern __m512i __cdecl _mm512_mask_cvt_roundps_epu64(__m512i, __mmask8, __m256, int);
+extern __m512i __cdecl _mm512_maskz_cvt_roundps_epu64(__mmask8, __m256, int);
+extern __m512i __cdecl _mm512_cvttps_epi64(__m256);
+extern __m512i __cdecl _mm512_mask_cvttps_epi64(__m512i, __mmask8, __m256);
+extern __m512i __cdecl _mm512_maskz_cvttps_epi64(__mmask8, __m256);
+extern __m512i __cdecl _mm512_cvtt_roundps_epi64(__m256, int);
+extern __m512i __cdecl _mm512_mask_cvtt_roundps_epi64(__m512i, __mmask8, __m256, int);
+extern __m512i __cdecl _mm512_maskz_cvtt_roundps_epi64(__mmask8, __m256, int);
+extern __m512i __cdecl _mm512_cvttps_epu64(__m256);
+extern __m512i __cdecl _mm512_mask_cvttps_epu64(__m512i, __mmask8, __m256);
+extern __m512i __cdecl _mm512_maskz_cvttps_epu64(__mmask8, __m256);
+extern __m512i __cdecl _mm512_cvtt_roundps_epu64(__m256, int);
+extern __m512i __cdecl _mm512_mask_cvtt_roundps_epu64(__m512i, __mmask8, __m256, int);
+extern __m512i __cdecl _mm512_maskz_cvtt_roundps_epu64(__mmask8, __m256, int);
+
+extern __mmask64  __cdecl _mm512_cmpeq_epi8_mask(__m512i, __m512i);
+extern __mmask64  __cdecl _mm512_cmpge_epi8_mask(__m512i, __m512i);
+extern __mmask64  __cdecl _mm512_cmpgt_epi8_mask(__m512i, __m512i);
+extern __mmask64  __cdecl _mm512_cmple_epi8_mask(__m512i, __m512i);
+extern __mmask64  __cdecl _mm512_cmplt_epi8_mask(__m512i, __m512i);
+extern __mmask64  __cdecl _mm512_cmpneq_epi8_mask(__m512i, __m512i);
+extern __mmask64  __cdecl _mm512_cmpeq_epu8_mask(__m512i, __m512i);
+extern __mmask64  __cdecl _mm512_cmpge_epu8_mask(__m512i, __m512i);
+extern __mmask64  __cdecl _mm512_cmpgt_epu8_mask(__m512i, __m512i);
+extern __mmask64  __cdecl _mm512_cmple_epu8_mask(__m512i, __m512i);
+extern __mmask64  __cdecl _mm512_cmplt_epu8_mask(__m512i, __m512i);
+extern __mmask64  __cdecl _mm512_cmpneq_epu8_mask(__m512i, __m512i);
+
+extern __mmask64  __cdecl _mm512_mask_cmpeq_epi8_mask(__mmask64, __m512i, __m512i);
+extern __mmask64  __cdecl _mm512_mask_cmpge_epi8_mask(__mmask64, __m512i, __m512i);
+extern __mmask64  __cdecl _mm512_mask_cmpgt_epi8_mask(__mmask64, __m512i, __m512i);
+extern __mmask64  __cdecl _mm512_mask_cmple_epi8_mask(__mmask64, __m512i, __m512i);
+extern __mmask64  __cdecl _mm512_mask_cmplt_epi8_mask(__mmask64, __m512i, __m512i);
+extern __mmask64  __cdecl _mm512_mask_cmpneq_epi8_mask(__mmask64, __m512i, __m512i);
+extern __mmask64  __cdecl _mm512_mask_cmpeq_epu8_mask(__mmask64, __m512i, __m512i);
+extern __mmask64  __cdecl _mm512_mask_cmpge_epu8_mask(__mmask64, __m512i, __m512i);
+extern __mmask64  __cdecl _mm512_mask_cmpgt_epu8_mask(__mmask64, __m512i, __m512i);
+extern __mmask64  __cdecl _mm512_mask_cmple_epu8_mask(__mmask64, __m512i, __m512i);
+extern __mmask64  __cdecl _mm512_mask_cmplt_epu8_mask(__mmask64, __m512i, __m512i);
+extern __mmask64  __cdecl _mm512_mask_cmpneq_epu8_mask(__mmask64, __m512i, __m512i);
+
+extern __mmask32  __cdecl _mm512_cmpeq_epi16_mask(__m512i, __m512i);
+extern __mmask32  __cdecl _mm512_cmpge_epi16_mask(__m512i, __m512i);
+extern __mmask32  __cdecl _mm512_cmpgt_epi16_mask(__m512i, __m512i);
+extern __mmask32  __cdecl _mm512_cmple_epi16_mask(__m512i, __m512i);
+extern __mmask32  __cdecl _mm512_cmplt_epi16_mask(__m512i, __m512i);
+extern __mmask32  __cdecl _mm512_cmpneq_epi16_mask(__m512i, __m512i);
+extern __mmask32  __cdecl _mm512_cmpeq_epu16_mask(__m512i, __m512i);
+extern __mmask32  __cdecl _mm512_cmpge_epu16_mask(__m512i, __m512i);
+extern __mmask32  __cdecl _mm512_cmpgt_epu16_mask(__m512i, __m512i);
+extern __mmask32  __cdecl _mm512_cmple_epu16_mask(__m512i, __m512i);
+extern __mmask32  __cdecl _mm512_cmplt_epu16_mask(__m512i, __m512i);
+extern __mmask32  __cdecl _mm512_cmpneq_epu16_mask(__m512i, __m512i);
+
+extern __mmask32  __cdecl _mm512_mask_cmpeq_epi16_mask(__mmask32, __m512i, __m512i);
+extern __mmask32  __cdecl _mm512_mask_cmpge_epi16_mask(__mmask32, __m512i, __m512i);
+extern __mmask32  __cdecl _mm512_mask_cmpgt_epi16_mask(__mmask32, __m512i, __m512i);
+extern __mmask32  __cdecl _mm512_mask_cmple_epi16_mask(__mmask32, __m512i, __m512i);
+extern __mmask32  __cdecl _mm512_mask_cmplt_epi16_mask(__mmask32, __m512i, __m512i);
+extern __mmask32  __cdecl _mm512_mask_cmpneq_epi16_mask(__mmask32, __m512i, __m512i);
+extern __mmask32  __cdecl _mm512_mask_cmpeq_epu16_mask(__mmask32, __m512i, __m512i);
+extern __mmask32  __cdecl _mm512_mask_cmpge_epu16_mask(__mmask32, __m512i, __m512i);
+extern __mmask32  __cdecl _mm512_mask_cmpgt_epu16_mask(__mmask32, __m512i, __m512i);
+extern __mmask32  __cdecl _mm512_mask_cmple_epu16_mask(__mmask32, __m512i, __m512i);
+extern __mmask32  __cdecl _mm512_mask_cmplt_epu16_mask(__mmask32, __m512i, __m512i);
+extern __mmask32  __cdecl _mm512_mask_cmpneq_epu16_mask(__mmask32, __m512i, __m512i);
+
+extern __mmask16  __cdecl _mm512_cmpeq_epi32_mask(__m512i, __m512i);
+extern __mmask16  __cdecl _mm512_cmpge_epi32_mask(__m512i, __m512i);
+extern __mmask16  __cdecl _mm512_cmpgt_epi32_mask(__m512i, __m512i);
+extern __mmask16  __cdecl _mm512_cmple_epi32_mask(__m512i, __m512i);
+extern __mmask16  __cdecl _mm512_cmplt_epi32_mask(__m512i, __m512i);
+extern __mmask16  __cdecl _mm512_cmpneq_epi32_mask(__m512i, __m512i);
+extern __mmask16  __cdecl _mm512_cmpeq_epu32_mask(__m512i, __m512i);
+extern __mmask16  __cdecl _mm512_cmpge_epu32_mask(__m512i, __m512i);
+extern __mmask16  __cdecl _mm512_cmpgt_epu32_mask(__m512i, __m512i);
+extern __mmask16  __cdecl _mm512_cmple_epu32_mask(__m512i, __m512i);
+extern __mmask16  __cdecl _mm512_cmplt_epu32_mask(__m512i, __m512i);
+extern __mmask16  __cdecl _mm512_cmpneq_epu32_mask(__m512i, __m512i);
+
+extern __mmask16  __cdecl _mm512_mask_cmpeq_epi32_mask(__mmask16, __m512i, __m512i);
+extern __mmask16  __cdecl _mm512_mask_cmpge_epi32_mask(__mmask16, __m512i, __m512i);
+extern __mmask16  __cdecl _mm512_mask_cmpgt_epi32_mask(__mmask16, __m512i, __m512i);
+extern __mmask16  __cdecl _mm512_mask_cmple_epi32_mask(__mmask16, __m512i, __m512i);
+extern __mmask16  __cdecl _mm512_mask_cmplt_epi32_mask(__mmask16, __m512i, __m512i);
+extern __mmask16  __cdecl _mm512_mask_cmpneq_epi32_mask(__mmask16, __m512i, __m512i);
+extern __mmask16  __cdecl _mm512_mask_cmpeq_epu32_mask(__mmask16, __m512i, __m512i);
+extern __mmask16  __cdecl _mm512_mask_cmpge_epu32_mask(__mmask16, __m512i, __m512i);
+extern __mmask16  __cdecl _mm512_mask_cmpgt_epu32_mask(__mmask16, __m512i, __m512i);
+extern __mmask16  __cdecl _mm512_mask_cmple_epu32_mask(__mmask16, __m512i, __m512i);
+extern __mmask16  __cdecl _mm512_mask_cmplt_epu32_mask(__mmask16, __m512i, __m512i);
+extern __mmask16  __cdecl _mm512_mask_cmpneq_epu32_mask(__mmask16, __m512i, __m512i);
+
+extern __mmask8  __cdecl _mm512_cmpeq_epi64_mask(__m512i, __m512i);
+extern __mmask8  __cdecl _mm512_cmpge_epi64_mask(__m512i, __m512i);
+extern __mmask8  __cdecl _mm512_cmpgt_epi64_mask(__m512i, __m512i);
+extern __mmask8  __cdecl _mm512_cmple_epi64_mask(__m512i, __m512i);
+extern __mmask8  __cdecl _mm512_cmplt_epi64_mask(__m512i, __m512i);
+extern __mmask8  __cdecl _mm512_cmpneq_epi64_mask(__m512i, __m512i);
+extern __mmask8  __cdecl _mm512_cmpeq_epu64_mask(__m512i, __m512i);
+extern __mmask8  __cdecl _mm512_cmpge_epu64_mask(__m512i, __m512i);
+extern __mmask8  __cdecl _mm512_cmpgt_epu64_mask(__m512i, __m512i);
+extern __mmask8  __cdecl _mm512_cmple_epu64_mask(__m512i, __m512i);
+extern __mmask8  __cdecl _mm512_cmplt_epu64_mask(__m512i, __m512i);
+extern __mmask8  __cdecl _mm512_cmpneq_epu64_mask(__m512i, __m512i);
+
+extern __mmask8  __cdecl _mm512_mask_cmpeq_epi64_mask(__mmask8, __m512i, __m512i);
+extern __mmask8  __cdecl _mm512_mask_cmpge_epi64_mask(__mmask8, __m512i, __m512i);
+extern __mmask8  __cdecl _mm512_mask_cmpgt_epi64_mask(__mmask8, __m512i, __m512i);
+extern __mmask8  __cdecl _mm512_mask_cmple_epi64_mask(__mmask8, __m512i, __m512i);
+extern __mmask8  __cdecl _mm512_mask_cmplt_epi64_mask(__mmask8, __m512i, __m512i);
+extern __mmask8  __cdecl _mm512_mask_cmpneq_epi64_mask(__mmask8, __m512i, __m512i);
+extern __mmask8  __cdecl _mm512_mask_cmpeq_epu64_mask(__mmask8, __m512i, __m512i);
+extern __mmask8  __cdecl _mm512_mask_cmpge_epu64_mask(__mmask8, __m512i, __m512i);
+extern __mmask8  __cdecl _mm512_mask_cmpgt_epu64_mask(__mmask8, __m512i, __m512i);
+extern __mmask8  __cdecl _mm512_mask_cmple_epu64_mask(__mmask8, __m512i, __m512i);
+extern __mmask8  __cdecl _mm512_mask_cmplt_epu64_mask(__mmask8, __m512i, __m512i);
+extern __mmask8  __cdecl _mm512_mask_cmpneq_epu64_mask(__mmask8, __m512i, __m512i);
+
+#define _mm512_setzero_epi32 _mm512_setzero_si512
+#define _mm512_set_1to8_pq(x) _mm512_set1_epi64((x))
+#define _mm512_set_1to8_epi64(x) _mm512_set1_epi64((x))
+#define _mm512_set_1to16_pi(x) _mm512_set1_epi32((x))
+#define _mm512_set_1to16_epi32(x) _mm512_set1_epi32((x))
+#define _mm512_set4_epi64(a,b,c,d) \
+    _mm512_set_epi64((a), (b), (c), (d), (a), (b), (c), (d))
+#define _mm512_set4_epi32(a,b,c,d) \
+    _mm512_set_epi32((a), (b), (c), (d), (a), (b), (c), (d), \
+                    (a), (b), (c), (d), (a), (b), (c), (d))
+#define _mm512_setr4_epi64(a,b,c,d) \
+    _mm512_set4_epi64((d),(c),(b),(a))
+#define _mm512_set_4to8_pq(a,b,c,d) \
+    _mm512_setr4_epi64((a),(b),(c),(d))
+#define _mm512_set_4to8_epi64(a,b,c,d) \
+    _mm512_setr4_epi64((a),(b),(c),(d))
+#define _mm512_setr4_epi32(a,b,c,d) \
+    _mm512_set4_epi32((d),(c),(b),(a))
+#define _mm512_set_4to16_pi(a,b,c,d) \
+    _mm512_setr4_epi32((a),(b),(c),(d))
+#define _mm512_set_4to16_epi32(a,b,c,d) \
+    _mm512_setr4_epi32((a),(b),(c),(d))
+#define _mm512_set_16to16_pi(e0,e1,e2,e3,e4,e5,e6,e7,e8, \
+                                e9,e10,e11,e12,e13,e14,e15) \
+    _mm512_set_epi32((e0),(e1),(e2),(e3),(e4),(e5),(e6),(e7), \
+                        (e8),(e9),(e10),(e11),(e12),(e13),(e14),(e15))
+#define _mm512_set_16to16_epi32(e0,e1,e2,e3,e4,e5,e6,e7,e8, \
+                                e9,e10,e11,e12,e13,e14,e15) \
+    _mm512_set_epi32((e0),(e1),(e2),(e3),(e4),(e5),(e6),(e7), \
+                        (e8),(e9),(e10),(e11),(e12),(e13),(e14),(e15))
+#define _mm512_set_8to8_pq(e0,e1,e2,e3,e4,e5,e6,e7) \
+    _mm512_set_epi64((e0),(e1),(e2),(e3),(e4),(e5),(e6),(e7))
+#define _mm512_set_8to8_epi64(e0,e1,e2,e3,e4,e5,e6,e7) \
+    _mm512_set_epi64((e0),(e1),(e2),(e3),(e4),(e5),(e6),(e7))
+
+#define _mm512_load_si512   _mm512_load_epi32
+#define _mm512_loadu_si512  _mm512_loadu_epi32
+#define _mm512_store_si512  _mm512_store_epi32
+#define _mm512_storeu_si512 _mm512_storeu_epi32
+
+#define _mm512_and_si512      _mm512_and_epi32
+#define _mm512_andnot_si512   _mm512_andnot_epi32
+#define _mm512_or_si512       _mm512_or_epi32
+#define _mm512_xor_si512      _mm512_xor_epi32
+
+#define _mm512_undefined_epi32() _mm512_setzero_si512()
+
+#define _mm512_i32logather_epi64(index, addr, scale) \
+    _mm512_i32gather_epi64(_mm512_castsi512_si256(index), (addr), (scale))
+#define _mm512_mask_i32logather_epi64(v1, k1, index, addr, scale) \
+    _mm512_mask_i32gather_epi64((v1), (k1), _mm512_castsi512_si256(index), (addr), (scale))
+#define _mm512_i32logather_pd(index, addr, scale) \
+    _mm512_i32gather_pd(_mm512_castsi512_si256(index), (addr), (scale))
+#define _mm512_mask_i32logather_pd(v1, k1, index, addr, scale) \
+    _mm512_mask_i32gather_pd((v1), (k1), _mm512_castsi512_si256(index), (addr), (scale))
+#define _mm512_i32loscatter_pd(addr, index, v1, scale) \
+    _mm512_i32scatter_pd((addr), _mm512_castsi512_si256(index), (v1), (scale))
+#define _mm512_mask_i32loscatter_pd(addr, k1, index, v1, scale) \
+    _mm512_mask_i32scatter_pd((addr), (k1), _mm512_castsi512_si256(index), (v1), (scale))
+
+
+// AVX512VL functions
+extern __m128i   __cdecl _mm_mask_abs_epi16(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_abs_epi16(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_abs_epi16(__m256i, __mmask16, __m256i);
+extern __m256i   __cdecl _mm256_maskz_abs_epi16(__mmask16, __m256i);
+extern __m128i   __cdecl _mm_mask_abs_epi32(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_abs_epi32(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_abs_epi32(__m256i, __mmask8, __m256i);
+extern __m256i   __cdecl _mm256_maskz_abs_epi32(__mmask8, __m256i);
+extern __m128i   __cdecl _mm_abs_epi64(__m128i);
+extern __m128i   __cdecl _mm_mask_abs_epi64(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_abs_epi64(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_abs_epi64(__m256i);
+extern __m256i   __cdecl _mm256_mask_abs_epi64(__m256i, __mmask8, __m256i);
+extern __m256i   __cdecl _mm256_maskz_abs_epi64(__mmask8, __m256i);
+extern __m128i   __cdecl _mm_mask_abs_epi8(__m128i, __mmask16, __m128i);
+extern __m128i   __cdecl _mm_maskz_abs_epi8(__mmask16, __m128i);
+extern __m256i   __cdecl _mm256_mask_abs_epi8(__m256i, __mmask32, __m256i);
+extern __m256i   __cdecl _mm256_maskz_abs_epi8(__mmask32, __m256i);
+extern __m128i   __cdecl _mm_mask_add_epi16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_add_epi16(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_add_epi16(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_add_epi16(__mmask16, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_add_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_add_epi32(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_add_epi32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_add_epi32(__mmask8, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_add_epi64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_add_epi64(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_add_epi64(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_add_epi64(__mmask8, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_add_epi8(__m128i, __mmask16, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_add_epi8(__mmask16, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_add_epi8(__m256i, __mmask32, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_add_epi8(__mmask32, __m256i, __m256i);
+extern __m128d   __cdecl _mm_mask_add_pd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_add_pd(__mmask8, __m128d, __m128d);
+extern __m256d   __cdecl _mm256_mask_add_pd(__m256d, __mmask8, __m256d, __m256d);
+extern __m256d   __cdecl _mm256_maskz_add_pd(__mmask8, __m256d, __m256d);
+extern __m128    __cdecl _mm_mask_add_ps(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_add_ps(__mmask8, __m128, __m128);
+extern __m256    __cdecl _mm256_mask_add_ps(__m256, __mmask8, __m256, __m256);
+extern __m256    __cdecl _mm256_maskz_add_ps(__mmask8, __m256, __m256);
+extern __m128i   __cdecl _mm_mask_adds_epi16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_adds_epi16(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_adds_epi16(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_adds_epi16(__mmask16, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_adds_epi8(__m128i, __mmask16, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_adds_epi8(__mmask16, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_adds_epi8(__m256i, __mmask32, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_adds_epi8(__mmask32, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_adds_epu16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_adds_epu16(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_adds_epu16(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_adds_epu16(__mmask16, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_adds_epu8(__m128i, __mmask16, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_adds_epu8(__mmask16, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_adds_epu8(__m256i, __mmask32, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_adds_epu8(__mmask32, __m256i, __m256i);
+extern __m128i   __cdecl _mm_alignr_epi32(__m128i, __m128i, const int);
+extern __m128i   __cdecl _mm_mask_alignr_epi32(__m128i, __mmask8, __m128i, __m128i, const int);
+extern __m128i   __cdecl _mm_maskz_alignr_epi32(__mmask8, __m128i, __m128i, const int);
+extern __m256i   __cdecl _mm256_alignr_epi32(__m256i, __m256i, const int);
+extern __m256i   __cdecl _mm256_mask_alignr_epi32(__m256i, __mmask8, __m256i, __m256i, const int);
+extern __m256i   __cdecl _mm256_maskz_alignr_epi32(__mmask8, __m256i, __m256i, const int);
+extern __m128i   __cdecl _mm_alignr_epi64(__m128i, __m128i, const int);
+extern __m128i   __cdecl _mm_mask_alignr_epi64(__m128i, __mmask8, __m128i, __m128i, const int);
+extern __m128i   __cdecl _mm_maskz_alignr_epi64(__mmask8, __m128i, __m128i, const int);
+extern __m256i   __cdecl _mm256_alignr_epi64(__m256i, __m256i, const int);
+extern __m256i   __cdecl _mm256_mask_alignr_epi64(__m256i, __mmask8, __m256i, __m256i, const int);
+extern __m256i   __cdecl _mm256_maskz_alignr_epi64(__mmask8, __m256i, __m256i, const int);
+extern __m128i   __cdecl _mm_mask_alignr_epi8(__m128i, __mmask16, __m128i, __m128i, const int);
+extern __m128i   __cdecl _mm_maskz_alignr_epi8(__mmask16, __m128i, __m128i, const int);
+extern __m256i   __cdecl _mm256_mask_alignr_epi8(__m256i, __mmask32, __m256i, __m256i, const int);
+extern __m256i   __cdecl _mm256_maskz_alignr_epi8(__mmask32, __m256i, __m256i, const int);
+extern __m128i   __cdecl _mm_and_epi32(__m128i, __m128i);
+extern __m128i   __cdecl _mm_mask_and_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_and_epi32(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_and_epi32(__m256i, __m256i);
+extern __m256i   __cdecl _mm256_mask_and_epi32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_and_epi32(__mmask8, __m256i, __m256i);
+extern __m128i   __cdecl _mm_and_epi64(__m128i, __m128i);
+extern __m128i   __cdecl _mm_mask_and_epi64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_and_epi64(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_and_epi64(__m256i, __m256i);
+extern __m256i   __cdecl _mm256_mask_and_epi64(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_and_epi64(__mmask8, __m256i, __m256i);
+extern __m128d   __cdecl _mm_mask_and_pd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_and_pd(__mmask8, __m128d, __m128d);
+extern __m256d   __cdecl _mm256_mask_and_pd(__m256d, __mmask8, __m256d, __m256d);
+extern __m256d   __cdecl _mm256_maskz_and_pd(__mmask8, __m256d, __m256d);
+extern __m128    __cdecl _mm_mask_and_ps(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_and_ps(__mmask8, __m128, __m128);
+extern __m256    __cdecl _mm256_mask_and_ps(__m256, __mmask8, __m256, __m256);
+extern __m256    __cdecl _mm256_maskz_and_ps(__mmask8, __m256, __m256);
+extern __m128i   __cdecl _mm_andnot_epi32(__m128i, __m128i);
+extern __m128i   __cdecl _mm_mask_andnot_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_andnot_epi32(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_andnot_epi32(__m256i, __m256i);
+extern __m256i   __cdecl _mm256_mask_andnot_epi32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_andnot_epi32(__mmask8, __m256i, __m256i);
+extern __m128i   __cdecl _mm_andnot_epi64(__m128i, __m128i);
+extern __m128i   __cdecl _mm_mask_andnot_epi64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_andnot_epi64(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_andnot_epi64(__m256i, __m256i);
+extern __m256i   __cdecl _mm256_mask_andnot_epi64(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_andnot_epi64(__mmask8, __m256i, __m256i);
+extern __m128d   __cdecl _mm_mask_andnot_pd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_andnot_pd(__mmask8, __m128d, __m128d);
+extern __m256d   __cdecl _mm256_mask_andnot_pd(__m256d, __mmask8, __m256d, __m256d);
+extern __m256d   __cdecl _mm256_maskz_andnot_pd(__mmask8, __m256d, __m256d);
+extern __m128    __cdecl _mm_mask_andnot_ps(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_andnot_ps(__mmask8, __m128, __m128);
+extern __m256    __cdecl _mm256_mask_andnot_ps(__m256, __mmask8, __m256, __m256);
+extern __m256    __cdecl _mm256_maskz_andnot_ps(__mmask8, __m256, __m256);
+extern __m128i   __cdecl _mm_mask_avg_epu16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_avg_epu16(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_avg_epu16(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_avg_epu16(__mmask16, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_avg_epu8(__m128i, __mmask16, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_avg_epu8(__mmask16, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_avg_epu8(__m256i, __mmask32, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_avg_epu8(__mmask32, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_blend_epi16(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_blend_epi16(__mmask16, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_blend_epi32(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_blend_epi32(__mmask8, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_blend_epi64(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_blend_epi64(__mmask8, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_blend_epi8(__mmask16, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_blend_epi8(__mmask32, __m256i, __m256i);
+extern __m128d   __cdecl _mm_mask_blend_pd(__mmask8, __m128d, __m128d);
+extern __m256d   __cdecl _mm256_mask_blend_pd(__mmask8, __m256d, __m256d);
+extern __m128    __cdecl _mm_mask_blend_ps(__mmask8, __m128, __m128);
+extern __m256    __cdecl _mm256_mask_blend_ps(__mmask8, __m256, __m256);
+extern __m256    __cdecl _mm256_broadcast_f32x2(__m128);
+extern __m256    __cdecl _mm256_mask_broadcast_f32x2(__m256, __mmask8, __m128);
+extern __m256    __cdecl _mm256_maskz_broadcast_f32x2(__mmask8, __m128);
+extern __m256    __cdecl _mm256_broadcast_f32x4(__m128);
+extern __m256    __cdecl _mm256_mask_broadcast_f32x4(__m256, __mmask8, __m128);
+extern __m256    __cdecl _mm256_maskz_broadcast_f32x4(__mmask8, __m128);
+extern __m256d   __cdecl _mm256_broadcast_f64x2(__m128d);
+extern __m256d   __cdecl _mm256_mask_broadcast_f64x2(__m256d, __mmask8, __m128d);
+extern __m256d   __cdecl _mm256_maskz_broadcast_f64x2(__mmask8, __m128d);
+extern __m128i   __cdecl _mm_broadcast_i32x2(__m128i);
+extern __m128i   __cdecl _mm_mask_broadcast_i32x2(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_broadcast_i32x2(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_broadcast_i32x2(__m128i);
+extern __m256i   __cdecl _mm256_mask_broadcast_i32x2(__m256i, __mmask8, __m128i);
+extern __m256i   __cdecl _mm256_maskz_broadcast_i32x2(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_broadcast_i32x4(__m128i);
+extern __m256i   __cdecl _mm256_mask_broadcast_i32x4(__m256i, __mmask8, __m128i);
+extern __m256i   __cdecl _mm256_maskz_broadcast_i32x4(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_broadcast_i64x2(__m128i);
+extern __m256i   __cdecl _mm256_mask_broadcast_i64x2(__m256i, __mmask8, __m128i);
+extern __m256i   __cdecl _mm256_maskz_broadcast_i64x2(__mmask8, __m128i);
+extern __m128i   __cdecl _mm_mask_broadcastb_epi8(__m128i, __mmask16, __m128i);
+extern __m128i   __cdecl _mm_maskz_broadcastb_epi8(__mmask16, __m128i);
+extern __m256i   __cdecl _mm256_mask_broadcastb_epi8(__m256i, __mmask32, __m128i);
+extern __m256i   __cdecl _mm256_maskz_broadcastb_epi8(__mmask32, __m128i);
+extern __m128i   __cdecl _mm_mask_broadcastd_epi32(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_broadcastd_epi32(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_broadcastd_epi32(__m256i, __mmask8, __m128i);
+extern __m256i   __cdecl _mm256_maskz_broadcastd_epi32(__mmask8, __m128i);
+extern __m128i   __cdecl _mm_broadcastmb_epi64(__mmask8);
+extern __m256i   __cdecl _mm256_broadcastmb_epi64(__mmask8);
+extern __m128i   __cdecl _mm_broadcastmw_epi32(__mmask16);
+extern __m256i   __cdecl _mm256_broadcastmw_epi32(__mmask16);
+extern __m128i   __cdecl _mm_mask_broadcastq_epi64(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_broadcastq_epi64(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_broadcastq_epi64(__m256i, __mmask8, __m128i);
+extern __m256i   __cdecl _mm256_maskz_broadcastq_epi64(__mmask8, __m128i);
+extern __m256d   __cdecl _mm256_mask_broadcastsd_pd(__m256d, __mmask8, __m128d);
+extern __m256d   __cdecl _mm256_maskz_broadcastsd_pd(__mmask8, __m128d);
+extern __m128    __cdecl _mm_mask_broadcastss_ps(__m128, __mmask8, __m128);
+extern __m128    __cdecl _mm_maskz_broadcastss_ps(__mmask8, __m128);
+extern __m256    __cdecl _mm256_mask_broadcastss_ps(__m256, __mmask8, __m128);
+extern __m256    __cdecl _mm256_maskz_broadcastss_ps(__mmask8, __m128);
+extern __m128i   __cdecl _mm_mask_broadcastw_epi16(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_broadcastw_epi16(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_broadcastw_epi16(__m256i, __mmask16, __m128i);
+extern __m256i   __cdecl _mm256_maskz_broadcastw_epi16(__mmask16, __m128i);
+extern __mmask8  __cdecl _mm_cmp_epi16_mask(__m128i, __m128i, const int);
+extern __mmask8  __cdecl _mm_mask_cmp_epi16_mask(__mmask8, __m128i, __m128i, const int);
+extern __mmask16 __cdecl _mm256_cmp_epi16_mask(__m256i, __m256i, const int);
+extern __mmask16 __cdecl _mm256_mask_cmp_epi16_mask(__mmask16, __m256i, __m256i, const int);
+extern __mmask8  __cdecl _mm_cmp_epi32_mask(__m128i, __m128i, int);
+extern __mmask8  __cdecl _mm_mask_cmp_epi32_mask(__mmask8, __m128i, __m128i, int);
+extern __mmask8  __cdecl _mm256_cmp_epi32_mask(__m256i, __m256i, int);
+extern __mmask8  __cdecl _mm256_mask_cmp_epi32_mask(__mmask8, __m256i, __m256i, int);
+extern __mmask8  __cdecl _mm_cmp_epi64_mask(__m128i, __m128i, int);
+extern __mmask8  __cdecl _mm_mask_cmp_epi64_mask(__mmask8, __m128i, __m128i, int);
+extern __mmask8  __cdecl _mm256_cmp_epi64_mask(__m256i, __m256i, int);
+extern __mmask8  __cdecl _mm256_mask_cmp_epi64_mask(__mmask8, __m256i, __m256i, int);
+extern __mmask16 __cdecl _mm_cmp_epi8_mask(__m128i, __m128i, const int);
+extern __mmask16 __cdecl _mm_mask_cmp_epi8_mask(__mmask16, __m128i, __m128i, const int);
+extern __mmask32 __cdecl _mm256_cmp_epi8_mask(__m256i, __m256i, const int);
+extern __mmask32 __cdecl _mm256_mask_cmp_epi8_mask(__mmask32, __m256i, __m256i, const int);
+extern __mmask8  __cdecl _mm_cmp_epu16_mask(__m128i, __m128i, const int);
+extern __mmask8  __cdecl _mm_mask_cmp_epu16_mask(__mmask8, __m128i, __m128i, const int);
+extern __mmask16 __cdecl _mm256_cmp_epu16_mask(__m256i, __m256i, const int);
+extern __mmask16 __cdecl _mm256_mask_cmp_epu16_mask(__mmask16, __m256i, __m256i, const int);
+extern __mmask8  __cdecl _mm_cmp_epu32_mask(__m128i, __m128i, int);
+extern __mmask8  __cdecl _mm_mask_cmp_epu32_mask(__mmask8, __m128i, __m128i, int);
+extern __mmask8  __cdecl _mm256_cmp_epu32_mask(__m256i, __m256i, int);
+extern __mmask8  __cdecl _mm256_mask_cmp_epu32_mask(__mmask8, __m256i, __m256i, int);
+extern __mmask8  __cdecl _mm_cmp_epu64_mask(__m128i, __m128i, int);
+extern __mmask8  __cdecl _mm_mask_cmp_epu64_mask(__mmask8, __m128i, __m128i, int);
+extern __mmask8  __cdecl _mm256_cmp_epu64_mask(__m256i, __m256i, int);
+extern __mmask8  __cdecl _mm256_mask_cmp_epu64_mask(__mmask8, __m256i, __m256i, int);
+extern __mmask16 __cdecl _mm_cmp_epu8_mask(__m128i, __m128i, const int);
+extern __mmask16 __cdecl _mm_mask_cmp_epu8_mask(__mmask16, __m128i, __m128i, const int);
+extern __mmask32 __cdecl _mm256_cmp_epu8_mask(__m256i, __m256i, const int);
+extern __mmask32 __cdecl _mm256_mask_cmp_epu8_mask(__mmask32, __m256i, __m256i, const int);
+extern __mmask8  __cdecl _mm_cmp_pd_mask(__m128d, __m128d, const int);
+extern __mmask8  __cdecl _mm_mask_cmp_pd_mask(__mmask8, __m128d, __m128d, const int);
+extern __mmask8  __cdecl _mm256_cmp_pd_mask(__m256d, __m256d, const int);
+extern __mmask8  __cdecl _mm256_mask_cmp_pd_mask(__mmask8, __m256d, __m256d, const int);
+extern __mmask8  __cdecl _mm_cmp_ps_mask(__m128, __m128, const int);
+extern __mmask8  __cdecl _mm_mask_cmp_ps_mask(__mmask8, __m128, __m128, const int);
+extern __mmask8  __cdecl _mm256_cmp_ps_mask(__m256, __m256, const int);
+extern __mmask8  __cdecl _mm256_mask_cmp_ps_mask(__mmask8, __m256, __m256, const int);
+extern __m128i   __cdecl _mm_mask_compress_epi8(__m128i, __mmask16, __m128i);
+extern __m128i   __cdecl _mm_maskz_compress_epi8(__mmask16, __m128i);
+extern __m256i   __cdecl _mm256_mask_compress_epi8(__m256i, __mmask32, __m256i);
+extern __m256i   __cdecl _mm256_maskz_compress_epi8(__mmask32, __m256i);
+extern __m128i   __cdecl _mm_mask_compress_epi16(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_compress_epi16(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_compress_epi16(__m256i, __mmask16, __m256i);
+extern __m256i   __cdecl _mm256_maskz_compress_epi16(__mmask16, __m256i);
+extern __m128i   __cdecl _mm_mask_compress_epi32(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_compress_epi32(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_compress_epi32(__m256i, __mmask8, __m256i);
+extern __m256i   __cdecl _mm256_maskz_compress_epi32(__mmask8, __m256i);
+extern __m128i   __cdecl _mm_mask_compress_epi64(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_compress_epi64(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_compress_epi64(__m256i, __mmask8, __m256i);
+extern __m256i   __cdecl _mm256_maskz_compress_epi64(__mmask8, __m256i);
+extern __m128d   __cdecl _mm_mask_compress_pd(__m128d, __mmask8, __m128d);
+extern __m128d   __cdecl _mm_maskz_compress_pd(__mmask8, __m128d);
+extern __m256d   __cdecl _mm256_mask_compress_pd(__m256d, __mmask8, __m256d);
+extern __m256d   __cdecl _mm256_maskz_compress_pd(__mmask8, __m256d);
+extern __m128    __cdecl _mm_mask_compress_ps(__m128, __mmask8, __m128);
+extern __m128    __cdecl _mm_maskz_compress_ps(__mmask8, __m128);
+extern __m256    __cdecl _mm256_mask_compress_ps(__m256, __mmask8, __m256);
+extern __m256    __cdecl _mm256_maskz_compress_ps(__mmask8, __m256);
+extern void      __cdecl _mm_mask_compressstoreu_epi8(void*, __mmask16, __m128i);
+extern void      __cdecl _mm256_mask_compressstoreu_epi8(void*, __mmask32, __m256i);
+extern void      __cdecl _mm_mask_compressstoreu_epi16(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_compressstoreu_epi16(void*, __mmask16, __m256i);
+extern void      __cdecl _mm_mask_compressstoreu_epi32(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_compressstoreu_epi32(void*, __mmask8, __m256i);
+extern void      __cdecl _mm_mask_compressstoreu_epi64(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_compressstoreu_epi64(void*, __mmask8, __m256i);
+extern void      __cdecl _mm_mask_compressstoreu_pd(void*, __mmask8, __m128d);
+extern void      __cdecl _mm256_mask_compressstoreu_pd(void*, __mmask8, __m256d);
+extern void      __cdecl _mm_mask_compressstoreu_ps(void*, __mmask8, __m128);
+extern void      __cdecl _mm256_mask_compressstoreu_ps(void*, __mmask8, __m256);
+extern __m128i   __cdecl _mm_conflict_epi32(__m128i);
+extern __m128i   __cdecl _mm_mask_conflict_epi32(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_conflict_epi32(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_conflict_epi32(__m256i);
+extern __m256i   __cdecl _mm256_mask_conflict_epi32(__m256i, __mmask8, __m256i);
+extern __m256i   __cdecl _mm256_maskz_conflict_epi32(__mmask8, __m256i);
+extern __m128i   __cdecl _mm_conflict_epi64(__m128i);
+extern __m128i   __cdecl _mm_mask_conflict_epi64(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_conflict_epi64(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_conflict_epi64(__m256i);
+extern __m256i   __cdecl _mm256_mask_conflict_epi64(__m256i, __mmask8, __m256i);
+extern __m256i   __cdecl _mm256_maskz_conflict_epi64(__mmask8, __m256i);
+extern __m128i   __cdecl _mm_mask_cvtps_ph(__m128i, __mmask8, __m128, int);
+extern __m128i   __cdecl _mm_maskz_cvtps_ph(__mmask8, __m128, int);
+extern __m128i   __cdecl _mm_mask_cvt_roundps_ph(__m128i, __mmask8, __m128, int);
+extern __m128i   __cdecl _mm_maskz_cvt_roundps_ph(__mmask8, __m128, int);
+extern __m128i   __cdecl _mm256_mask_cvtps_ph(__m128i, __mmask8, __m256, int);
+extern __m128i   __cdecl _mm256_maskz_cvtps_ph(__mmask8, __m256, int);
+extern __m128i   __cdecl _mm256_mask_cvt_roundps_ph(__m128i, __mmask8, __m256, int);
+extern __m128i   __cdecl _mm256_maskz_cvt_roundps_ph(__mmask8, __m256, int);
+extern __m128i   __cdecl _mm_mask_cvtepi16_epi32(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtepi16_epi32(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_cvtepi16_epi32(__m256i, __mmask8, __m128i);
+extern __m256i   __cdecl _mm256_maskz_cvtepi16_epi32(__mmask8, __m128i);
+extern __m128i   __cdecl _mm_mask_cvtepi16_epi64(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtepi16_epi64(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_cvtepi16_epi64(__m256i, __mmask8, __m128i);
+extern __m256i   __cdecl _mm256_maskz_cvtepi16_epi64(__mmask8, __m128i);
+extern __m128i   __cdecl _mm_cvtepi16_epi8(__m128i);
+extern __m128i   __cdecl _mm_mask_cvtepi16_epi8(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtepi16_epi8(__mmask8, __m128i);
+extern __m128i   __cdecl _mm256_cvtepi16_epi8(__m256i);
+extern __m128i   __cdecl _mm256_mask_cvtepi16_epi8(__m128i, __mmask16, __m256i);
+extern __m128i   __cdecl _mm256_maskz_cvtepi16_epi8(__mmask16, __m256i);
+extern void      __cdecl _mm_mask_cvtepi16_storeu_epi8(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_cvtepi16_storeu_epi8(void*, __mmask16, __m256i);
+extern __m128i   __cdecl _mm_cvtepi32_epi16(__m128i);
+extern __m128i   __cdecl _mm_mask_cvtepi32_epi16(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtepi32_epi16(__mmask8, __m128i);
+extern __m128i   __cdecl _mm256_cvtepi32_epi16(__m256i);
+extern __m128i   __cdecl _mm256_mask_cvtepi32_epi16(__m128i, __mmask8, __m256i);
+extern __m128i   __cdecl _mm256_maskz_cvtepi32_epi16(__mmask8, __m256i);
+extern __m128i   __cdecl _mm_mask_cvtepi32_epi64(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtepi32_epi64(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_cvtepi32_epi64(__m256i, __mmask8, __m128i);
+extern __m256i   __cdecl _mm256_maskz_cvtepi32_epi64(__mmask8, __m128i);
+extern __m128i   __cdecl _mm_cvtepi32_epi8(__m128i);
+extern __m128i   __cdecl _mm_mask_cvtepi32_epi8(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtepi32_epi8(__mmask8, __m128i);
+extern __m128i   __cdecl _mm256_cvtepi32_epi8(__m256i);
+extern __m128i   __cdecl _mm256_mask_cvtepi32_epi8(__m128i, __mmask8, __m256i);
+extern __m128i   __cdecl _mm256_maskz_cvtepi32_epi8(__mmask8, __m256i);
+extern __m128d   __cdecl _mm_mask_cvtepi32_pd(__m128d, __mmask8, __m128i);
+extern __m128d   __cdecl _mm_maskz_cvtepi32_pd(__mmask8, __m128i);
+extern __m256d   __cdecl _mm256_mask_cvtepi32_pd(__m256d, __mmask8, __m128i);
+extern __m256d   __cdecl _mm256_maskz_cvtepi32_pd(__mmask8, __m128i);
+extern __m128    __cdecl _mm_mask_cvtepi32_ps(__m128, __mmask8, __m128i);
+extern __m128    __cdecl _mm_maskz_cvtepi32_ps(__mmask8, __m128i);
+extern __m256    __cdecl _mm256_mask_cvtepi32_ps(__m256, __mmask8, __m256i);
+extern __m256    __cdecl _mm256_maskz_cvtepi32_ps(__mmask8, __m256i);
+extern void      __cdecl _mm_mask_cvtepi32_storeu_epi16(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_cvtepi32_storeu_epi16(void*, __mmask8, __m256i);
+extern void      __cdecl _mm_mask_cvtepi32_storeu_epi8(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_cvtepi32_storeu_epi8(void*, __mmask8, __m256i);
+extern __m128i   __cdecl _mm_cvtepi64_epi16(__m128i);
+extern __m128i   __cdecl _mm_mask_cvtepi64_epi16(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtepi64_epi16(__mmask8, __m128i);
+extern __m128i   __cdecl _mm256_cvtepi64_epi16(__m256i);
+extern __m128i   __cdecl _mm256_mask_cvtepi64_epi16(__m128i, __mmask8, __m256i);
+extern __m128i   __cdecl _mm256_maskz_cvtepi64_epi16(__mmask8, __m256i);
+extern __m128i   __cdecl _mm_cvtepi64_epi32(__m128i);
+extern __m128i   __cdecl _mm_mask_cvtepi64_epi32(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtepi64_epi32(__mmask8, __m128i);
+extern __m128i   __cdecl _mm256_cvtepi64_epi32(__m256i);
+extern __m128i   __cdecl _mm256_mask_cvtepi64_epi32(__m128i, __mmask8, __m256i);
+extern __m128i   __cdecl _mm256_maskz_cvtepi64_epi32(__mmask8, __m256i);
+extern __m128i   __cdecl _mm_cvtepi64_epi8(__m128i);
+extern __m128i   __cdecl _mm_mask_cvtepi64_epi8(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtepi64_epi8(__mmask8, __m128i);
+extern __m128i   __cdecl _mm256_cvtepi64_epi8(__m256i);
+extern __m128i   __cdecl _mm256_mask_cvtepi64_epi8(__m128i, __mmask8, __m256i);
+extern __m128i   __cdecl _mm256_maskz_cvtepi64_epi8(__mmask8, __m256i);
+extern __m128d   __cdecl _mm_cvtepi64_pd(__m128i);
+extern __m128d   __cdecl _mm_mask_cvtepi64_pd(__m128d, __mmask8, __m128i);
+extern __m128d   __cdecl _mm_maskz_cvtepi64_pd(__mmask8, __m128i);
+extern __m256d   __cdecl _mm256_cvtepi64_pd(__m256i);
+extern __m256d   __cdecl _mm256_mask_cvtepi64_pd(__m256d, __mmask8, __m256i);
+extern __m256d   __cdecl _mm256_maskz_cvtepi64_pd(__mmask8, __m256i);
+extern __m128    __cdecl _mm_cvtepi64_ps(__m128i);
+extern __m128    __cdecl _mm_mask_cvtepi64_ps(__m128, __mmask8, __m128i);
+extern __m128    __cdecl _mm_maskz_cvtepi64_ps(__mmask8, __m128i);
+extern __m128    __cdecl _mm256_cvtepi64_ps(__m256i);
+extern __m128    __cdecl _mm256_mask_cvtepi64_ps(__m128, __mmask8, __m256i);
+extern __m128    __cdecl _mm256_maskz_cvtepi64_ps(__mmask8, __m256i);
+extern void      __cdecl _mm_mask_cvtepi64_storeu_epi16(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_cvtepi64_storeu_epi16(void*, __mmask8, __m256i);
+extern void      __cdecl _mm_mask_cvtepi64_storeu_epi32(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_cvtepi64_storeu_epi32(void*, __mmask8, __m256i);
+extern void      __cdecl _mm_mask_cvtepi64_storeu_epi8(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_cvtepi64_storeu_epi8(void*, __mmask8, __m256i);
+extern __m128i   __cdecl _mm_mask_cvtepi8_epi16(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtepi8_epi16(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_cvtepi8_epi16(__m256i, __mmask16, __m128i);
+extern __m256i   __cdecl _mm256_maskz_cvtepi8_epi16(__mmask16, __m128i);
+extern __m128i   __cdecl _mm_mask_cvtepi8_epi32(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtepi8_epi32(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_cvtepi8_epi32(__m256i, __mmask8, __m128i);
+extern __m256i   __cdecl _mm256_maskz_cvtepi8_epi32(__mmask8, __m128i);
+extern __m128i   __cdecl _mm_mask_cvtepi8_epi64(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtepi8_epi64(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_cvtepi8_epi64(__m256i, __mmask8, __m128i);
+extern __m256i   __cdecl _mm256_maskz_cvtepi8_epi64(__mmask8, __m128i);
+extern __m128i   __cdecl _mm_mask_cvtepu16_epi32(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtepu16_epi32(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_cvtepu16_epi32(__m256i, __mmask8, __m128i);
+extern __m256i   __cdecl _mm256_maskz_cvtepu16_epi32(__mmask8, __m128i);
+extern __m128i   __cdecl _mm_mask_cvtepu16_epi64(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtepu16_epi64(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_cvtepu16_epi64(__m256i, __mmask8, __m128i);
+extern __m256i   __cdecl _mm256_maskz_cvtepu16_epi64(__mmask8, __m128i);
+extern __m128i   __cdecl _mm_mask_cvtepu32_epi64(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtepu32_epi64(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_cvtepu32_epi64(__m256i, __mmask8, __m128i);
+extern __m256i   __cdecl _mm256_maskz_cvtepu32_epi64(__mmask8, __m128i);
+extern __m128    __cdecl _mm_cvtepu32_ps(__m128i);
+extern __m128    __cdecl _mm_mask_cvtepu32_ps(__m128, __mmask8, __m128i);
+extern __m128    __cdecl _mm_maskz_cvtepu32_ps(__mmask8, __m128i);
+extern __m256    __cdecl _mm256_cvtepu32_ps(__m256i);
+extern __m256    __cdecl _mm256_mask_cvtepu32_ps(__m256, __mmask8, __m256i);
+extern __m256    __cdecl _mm256_maskz_cvtepu32_ps(__mmask8, __m256i);
+extern __m128d   __cdecl _mm_cvtepu32_pd(__m128i);
+extern __m128d   __cdecl _mm_mask_cvtepu32_pd(__m128d, __mmask8, __m128i);
+extern __m128d   __cdecl _mm_maskz_cvtepu32_pd(__mmask8, __m128i);
+extern __m256d   __cdecl _mm256_cvtepu32_pd(__m128i);
+extern __m256d   __cdecl _mm256_mask_cvtepu32_pd(__m256d, __mmask8, __m128i);
+extern __m256d   __cdecl _mm256_maskz_cvtepu32_pd(__mmask8, __m128i);
+extern __m128d   __cdecl _mm_cvtepu64_pd(__m128i);
+extern __m128d   __cdecl _mm_mask_cvtepu64_pd(__m128d, __mmask8, __m128i);
+extern __m128d   __cdecl _mm_maskz_cvtepu64_pd(__mmask8, __m128i);
+extern __m256d   __cdecl _mm256_cvtepu64_pd(__m256i);
+extern __m256d   __cdecl _mm256_mask_cvtepu64_pd(__m256d, __mmask8, __m256i);
+extern __m256d   __cdecl _mm256_maskz_cvtepu64_pd(__mmask8, __m256i);
+extern __m128    __cdecl _mm_cvtepu64_ps(__m128i);
+extern __m128    __cdecl _mm_mask_cvtepu64_ps(__m128, __mmask8, __m128i);
+extern __m128    __cdecl _mm_maskz_cvtepu64_ps(__mmask8, __m128i);
+extern __m128    __cdecl _mm256_cvtepu64_ps(__m256i);
+extern __m128    __cdecl _mm256_mask_cvtepu64_ps(__m128, __mmask8, __m256i);
+extern __m128    __cdecl _mm256_maskz_cvtepu64_ps(__mmask8, __m256i);
+extern __m128i   __cdecl _mm_mask_cvtepu8_epi16(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtepu8_epi16(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_cvtepu8_epi16(__m256i, __mmask16, __m128i);
+extern __m256i   __cdecl _mm256_maskz_cvtepu8_epi16(__mmask16, __m128i);
+extern __m128i   __cdecl _mm_mask_cvtepu8_epi32(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtepu8_epi32(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_cvtepu8_epi32(__m256i, __mmask8, __m128i);
+extern __m256i   __cdecl _mm256_maskz_cvtepu8_epi32(__mmask8, __m128i);
+extern __m128i   __cdecl _mm_mask_cvtepu8_epi64(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtepu8_epi64(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_cvtepu8_epi64(__m256i, __mmask8, __m128i);
+extern __m256i   __cdecl _mm256_maskz_cvtepu8_epi64(__mmask8, __m128i);
+extern __m128i   __cdecl _mm_mask_cvtpd_epi32(__m128i, __mmask8, __m128d);
+extern __m128i   __cdecl _mm_maskz_cvtpd_epi32(__mmask8, __m128d);
+extern __m128i   __cdecl _mm256_mask_cvtpd_epi32(__m128i, __mmask8, __m256d);
+extern __m128i   __cdecl _mm256_maskz_cvtpd_epi32(__mmask8, __m256d);
+extern __m128i   __cdecl _mm_cvtpd_epi64(__m128d);
+extern __m128i   __cdecl _mm_mask_cvtpd_epi64(__m128i, __mmask8, __m128d);
+extern __m128i   __cdecl _mm_maskz_cvtpd_epi64(__mmask8, __m128d);
+extern __m256i   __cdecl _mm256_cvtpd_epi64(__m256d);
+extern __m256i   __cdecl _mm256_mask_cvtpd_epi64(__m256i, __mmask8, __m256d);
+extern __m256i   __cdecl _mm256_maskz_cvtpd_epi64(__mmask8, __m256d);
+extern __m128i   __cdecl _mm_cvtpd_epu32(__m128d);
+extern __m128i   __cdecl _mm_mask_cvtpd_epu32(__m128i, __mmask8, __m128d);
+extern __m128i   __cdecl _mm_maskz_cvtpd_epu32(__mmask8, __m128d);
+extern __m128i   __cdecl _mm256_cvtpd_epu32(__m256d);
+extern __m128i   __cdecl _mm256_mask_cvtpd_epu32(__m128i, __mmask8, __m256d);
+extern __m128i   __cdecl _mm256_maskz_cvtpd_epu32(__mmask8, __m256d);
+extern __m128i   __cdecl _mm_cvtpd_epu64(__m128d);
+extern __m128i   __cdecl _mm_mask_cvtpd_epu64(__m128i, __mmask8, __m128d);
+extern __m128i   __cdecl _mm_maskz_cvtpd_epu64(__mmask8, __m128d);
+extern __m256i   __cdecl _mm256_cvtpd_epu64(__m256d);
+extern __m256i   __cdecl _mm256_mask_cvtpd_epu64(__m256i, __mmask8, __m256d);
+extern __m256i   __cdecl _mm256_maskz_cvtpd_epu64(__mmask8, __m256d);
+extern __m128    __cdecl _mm_mask_cvtpd_ps(__m128, __mmask8, __m128d);
+extern __m128    __cdecl _mm_maskz_cvtpd_ps(__mmask8, __m128d);
+extern __m128    __cdecl _mm256_mask_cvtpd_ps(__m128, __mmask8, __m256d);
+extern __m128    __cdecl _mm256_maskz_cvtpd_ps(__mmask8, __m256d);
+extern __m128    __cdecl _mm_mask_cvtph_ps(__m128, __mmask8, __m128i);
+extern __m128    __cdecl _mm_maskz_cvtph_ps(__mmask8, __m128i);
+extern __m256    __cdecl _mm256_mask_cvtph_ps(__m256, __mmask8, __m128i);
+extern __m256    __cdecl _mm256_maskz_cvtph_ps(__mmask8, __m128i);
+extern __m128i   __cdecl _mm_mask_cvtps_epi32(__m128i, __mmask8, __m128);
+extern __m128i   __cdecl _mm_maskz_cvtps_epi32(__mmask8, __m128);
+extern __m256i   __cdecl _mm256_mask_cvtps_epi32(__m256i, __mmask8, __m256);
+extern __m256i   __cdecl _mm256_maskz_cvtps_epi32(__mmask8, __m256);
+extern __m128i   __cdecl _mm_cvtps_epi64(__m128);
+extern __m128i   __cdecl _mm_mask_cvtps_epi64(__m128i, __mmask8, __m128);
+extern __m128i   __cdecl _mm_maskz_cvtps_epi64(__mmask8, __m128);
+extern __m256i   __cdecl _mm256_cvtps_epi64(__m128);
+extern __m256i   __cdecl _mm256_mask_cvtps_epi64(__m256i, __mmask8, __m128);
+extern __m256i   __cdecl _mm256_maskz_cvtps_epi64(__mmask8, __m128);
+extern __m128i   __cdecl _mm_cvtps_epu32(__m128);
+extern __m128i   __cdecl _mm_mask_cvtps_epu32(__m128i, __mmask8, __m128);
+extern __m128i   __cdecl _mm_maskz_cvtps_epu32(__mmask8, __m128);
+extern __m256i   __cdecl _mm256_cvtps_epu32(__m256);
+extern __m256i   __cdecl _mm256_mask_cvtps_epu32(__m256i, __mmask8, __m256);
+extern __m256i   __cdecl _mm256_maskz_cvtps_epu32(__mmask8, __m256);
+extern __m128i   __cdecl _mm_cvtps_epu64(__m128);
+extern __m128i   __cdecl _mm_mask_cvtps_epu64(__m128i, __mmask8, __m128);
+extern __m128i   __cdecl _mm_maskz_cvtps_epu64(__mmask8, __m128);
+extern __m256i   __cdecl _mm256_cvtps_epu64(__m128);
+extern __m256i   __cdecl _mm256_mask_cvtps_epu64(__m256i, __mmask8, __m128);
+extern __m256i   __cdecl _mm256_maskz_cvtps_epu64(__mmask8, __m128);
+extern __m128d   __cdecl _mm_mask_cvtps_pd(__m128d, __mmask8, __m128);
+extern __m128d   __cdecl _mm_maskz_cvtps_pd(__mmask8, __m128);
+extern __m256d   __cdecl _mm256_mask_cvtps_pd(__m256d, __mmask8, __m128);
+extern __m256d   __cdecl _mm256_maskz_cvtps_pd(__mmask8, __m128);
+extern __m128i   __cdecl _mm_cvtsepi16_epi8(__m128i);
+extern __m128i   __cdecl _mm_mask_cvtsepi16_epi8(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtsepi16_epi8(__mmask8, __m128i);
+extern __m128i   __cdecl _mm256_cvtsepi16_epi8(__m256i);
+extern __m128i   __cdecl _mm256_mask_cvtsepi16_epi8(__m128i, __mmask16, __m256i);
+extern __m128i   __cdecl _mm256_maskz_cvtsepi16_epi8(__mmask16, __m256i);
+extern void      __cdecl _mm_mask_cvtsepi16_storeu_epi8(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_cvtsepi16_storeu_epi8(void*, __mmask16, __m256i);
+extern __m128i   __cdecl _mm_cvtsepi32_epi16(__m128i);
+extern __m128i   __cdecl _mm_mask_cvtsepi32_epi16(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtsepi32_epi16(__mmask8, __m128i);
+extern __m128i   __cdecl _mm256_cvtsepi32_epi16(__m256i);
+extern __m128i   __cdecl _mm256_mask_cvtsepi32_epi16(__m128i, __mmask8, __m256i);
+extern __m128i   __cdecl _mm256_maskz_cvtsepi32_epi16(__mmask8, __m256i);
+extern __m128i   __cdecl _mm_cvtsepi32_epi8(__m128i);
+extern __m128i   __cdecl _mm_mask_cvtsepi32_epi8(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtsepi32_epi8(__mmask8, __m128i);
+extern __m128i   __cdecl _mm256_cvtsepi32_epi8(__m256i);
+extern __m128i   __cdecl _mm256_mask_cvtsepi32_epi8(__m128i, __mmask8, __m256i);
+extern __m128i   __cdecl _mm256_maskz_cvtsepi32_epi8(__mmask8, __m256i);
+extern void      __cdecl _mm_mask_cvtsepi32_storeu_epi16(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_cvtsepi32_storeu_epi16(void*, __mmask8, __m256i);
+extern void      __cdecl _mm_mask_cvtsepi32_storeu_epi8(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_cvtsepi32_storeu_epi8(void*, __mmask8, __m256i);
+extern __m128i   __cdecl _mm_cvtsepi64_epi16(__m128i);
+extern __m128i   __cdecl _mm_mask_cvtsepi64_epi16(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtsepi64_epi16(__mmask8, __m128i);
+extern __m128i   __cdecl _mm256_cvtsepi64_epi16(__m256i);
+extern __m128i   __cdecl _mm256_mask_cvtsepi64_epi16(__m128i, __mmask8, __m256i);
+extern __m128i   __cdecl _mm256_maskz_cvtsepi64_epi16(__mmask8, __m256i);
+extern __m128i   __cdecl _mm_cvtsepi64_epi32(__m128i);
+extern __m128i   __cdecl _mm_mask_cvtsepi64_epi32(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtsepi64_epi32(__mmask8, __m128i);
+extern __m128i   __cdecl _mm256_cvtsepi64_epi32(__m256i);
+extern __m128i   __cdecl _mm256_mask_cvtsepi64_epi32(__m128i, __mmask8, __m256i);
+extern __m128i   __cdecl _mm256_maskz_cvtsepi64_epi32(__mmask8, __m256i);
+extern __m128i   __cdecl _mm_cvtsepi64_epi8(__m128i);
+extern __m128i   __cdecl _mm_mask_cvtsepi64_epi8(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtsepi64_epi8(__mmask8, __m128i);
+extern __m128i   __cdecl _mm256_cvtsepi64_epi8(__m256i);
+extern __m128i   __cdecl _mm256_mask_cvtsepi64_epi8(__m128i, __mmask8, __m256i);
+extern __m128i   __cdecl _mm256_maskz_cvtsepi64_epi8(__mmask8, __m256i);
+extern void      __cdecl _mm_mask_cvtsepi64_storeu_epi16(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_cvtsepi64_storeu_epi16(void*, __mmask8, __m256i);
+extern void      __cdecl _mm_mask_cvtsepi64_storeu_epi32(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_cvtsepi64_storeu_epi32(void*, __mmask8, __m256i);
+extern void      __cdecl _mm_mask_cvtsepi64_storeu_epi8(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_cvtsepi64_storeu_epi8(void*, __mmask8, __m256i);
+extern __m128i   __cdecl _mm_mask_cvttpd_epi32(__m128i, __mmask8, __m128d);
+extern __m128i   __cdecl _mm_maskz_cvttpd_epi32(__mmask8, __m128d);
+extern __m128i   __cdecl _mm256_mask_cvttpd_epi32(__m128i, __mmask8, __m256d);
+extern __m128i   __cdecl _mm256_maskz_cvttpd_epi32(__mmask8, __m256d);
+extern __m128i   __cdecl _mm_cvttpd_epi64(__m128d);
+extern __m128i   __cdecl _mm_mask_cvttpd_epi64(__m128i, __mmask8, __m128d);
+extern __m128i   __cdecl _mm_maskz_cvttpd_epi64(__mmask8, __m128d);
+extern __m256i   __cdecl _mm256_cvttpd_epi64(__m256d);
+extern __m256i   __cdecl _mm256_mask_cvttpd_epi64(__m256i, __mmask8, __m256d);
+extern __m256i   __cdecl _mm256_maskz_cvttpd_epi64(__mmask8, __m256d);
+extern __m128i   __cdecl _mm_cvttpd_epu32(__m128d);
+extern __m128i   __cdecl _mm_mask_cvttpd_epu32(__m128i, __mmask8, __m128d);
+extern __m128i   __cdecl _mm_maskz_cvttpd_epu32(__mmask8, __m128d);
+extern __m128i   __cdecl _mm256_cvttpd_epu32(__m256d);
+extern __m128i   __cdecl _mm256_mask_cvttpd_epu32(__m128i, __mmask8, __m256d);
+extern __m128i   __cdecl _mm256_maskz_cvttpd_epu32(__mmask8, __m256d);
+extern __m128i   __cdecl _mm_cvttpd_epu64(__m128d);
+extern __m128i   __cdecl _mm_mask_cvttpd_epu64(__m128i, __mmask8, __m128d);
+extern __m128i   __cdecl _mm_maskz_cvttpd_epu64(__mmask8, __m128d);
+extern __m256i   __cdecl _mm256_cvttpd_epu64(__m256d);
+extern __m256i   __cdecl _mm256_mask_cvttpd_epu64(__m256i, __mmask8, __m256d);
+extern __m256i   __cdecl _mm256_maskz_cvttpd_epu64(__mmask8, __m256d);
+extern __m128i   __cdecl _mm_mask_cvttps_epi32(__m128i, __mmask8, __m128);
+extern __m128i   __cdecl _mm_maskz_cvttps_epi32(__mmask8, __m128);
+extern __m256i   __cdecl _mm256_mask_cvttps_epi32(__m256i, __mmask8, __m256);
+extern __m256i   __cdecl _mm256_maskz_cvttps_epi32(__mmask8, __m256);
+extern __m128i   __cdecl _mm_cvttps_epi64(__m128);
+extern __m128i   __cdecl _mm_mask_cvttps_epi64(__m128i, __mmask8, __m128);
+extern __m128i   __cdecl _mm_maskz_cvttps_epi64(__mmask8, __m128);
+extern __m256i   __cdecl _mm256_cvttps_epi64(__m128);
+extern __m256i   __cdecl _mm256_mask_cvttps_epi64(__m256i, __mmask8, __m128);
+extern __m256i   __cdecl _mm256_maskz_cvttps_epi64(__mmask8, __m128);
+extern __m128i   __cdecl _mm_cvttps_epu32(__m128);
+extern __m128i   __cdecl _mm_mask_cvttps_epu32(__m128i, __mmask8, __m128);
+extern __m128i   __cdecl _mm_maskz_cvttps_epu32(__mmask8, __m128);
+extern __m256i   __cdecl _mm256_cvttps_epu32(__m256);
+extern __m256i   __cdecl _mm256_mask_cvttps_epu32(__m256i, __mmask8, __m256);
+extern __m256i   __cdecl _mm256_maskz_cvttps_epu32(__mmask8, __m256);
+extern __m128i   __cdecl _mm_cvttps_epu64(__m128);
+extern __m128i   __cdecl _mm_mask_cvttps_epu64(__m128i, __mmask8, __m128);
+extern __m128i   __cdecl _mm_maskz_cvttps_epu64(__mmask8, __m128);
+extern __m256i   __cdecl _mm256_cvttps_epu64(__m128);
+extern __m256i   __cdecl _mm256_mask_cvttps_epu64(__m256i, __mmask8, __m128);
+extern __m256i   __cdecl _mm256_maskz_cvttps_epu64(__mmask8, __m128);
+extern __m128i   __cdecl _mm_cvtusepi16_epi8(__m128i);
+extern __m128i   __cdecl _mm_mask_cvtusepi16_epi8(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtusepi16_epi8(__mmask8, __m128i);
+extern __m128i   __cdecl _mm256_cvtusepi16_epi8(__m256i);
+extern __m128i   __cdecl _mm256_mask_cvtusepi16_epi8(__m128i, __mmask16, __m256i);
+extern __m128i   __cdecl _mm256_maskz_cvtusepi16_epi8(__mmask16, __m256i);
+extern void      __cdecl _mm_mask_cvtusepi16_storeu_epi8(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_cvtusepi16_storeu_epi8(void*, __mmask16, __m256i);
+extern __m128i   __cdecl _mm_cvtusepi32_epi16(__m128i);
+extern __m128i   __cdecl _mm_mask_cvtusepi32_epi16(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtusepi32_epi16(__mmask8, __m128i);
+extern __m128i   __cdecl _mm256_cvtusepi32_epi16(__m256i);
+extern __m128i   __cdecl _mm256_mask_cvtusepi32_epi16(__m128i, __mmask8, __m256i);
+extern __m128i   __cdecl _mm256_maskz_cvtusepi32_epi16(__mmask8, __m256i);
+extern __m128i   __cdecl _mm_cvtusepi32_epi8(__m128i);
+extern __m128i   __cdecl _mm_mask_cvtusepi32_epi8(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtusepi32_epi8(__mmask8, __m128i);
+extern __m128i   __cdecl _mm256_cvtusepi32_epi8(__m256i);
+extern __m128i   __cdecl _mm256_mask_cvtusepi32_epi8(__m128i, __mmask8, __m256i);
+extern __m128i   __cdecl _mm256_maskz_cvtusepi32_epi8(__mmask8, __m256i);
+extern void      __cdecl _mm_mask_cvtusepi32_storeu_epi16(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_cvtusepi32_storeu_epi16(void*, __mmask8, __m256i);
+extern void      __cdecl _mm_mask_cvtusepi32_storeu_epi8(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_cvtusepi32_storeu_epi8(void*, __mmask8, __m256i);
+extern __m128i   __cdecl _mm_cvtusepi64_epi16(__m128i);
+extern __m128i   __cdecl _mm_mask_cvtusepi64_epi16(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtusepi64_epi16(__mmask8, __m128i);
+extern __m128i   __cdecl _mm256_cvtusepi64_epi16(__m256i);
+extern __m128i   __cdecl _mm256_mask_cvtusepi64_epi16(__m128i, __mmask8, __m256i);
+extern __m128i   __cdecl _mm256_maskz_cvtusepi64_epi16(__mmask8, __m256i);
+extern __m128i   __cdecl _mm_cvtusepi64_epi32(__m128i);
+extern __m128i   __cdecl _mm_mask_cvtusepi64_epi32(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtusepi64_epi32(__mmask8, __m128i);
+extern __m128i   __cdecl _mm256_cvtusepi64_epi32(__m256i);
+extern __m128i   __cdecl _mm256_mask_cvtusepi64_epi32(__m128i, __mmask8, __m256i);
+extern __m128i   __cdecl _mm256_maskz_cvtusepi64_epi32(__mmask8, __m256i);
+extern __m128i   __cdecl _mm_cvtusepi64_epi8(__m128i);
+extern __m128i   __cdecl _mm_mask_cvtusepi64_epi8(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_cvtusepi64_epi8(__mmask8, __m128i);
+extern __m128i   __cdecl _mm256_cvtusepi64_epi8(__m256i);
+extern __m128i   __cdecl _mm256_mask_cvtusepi64_epi8(__m128i, __mmask8, __m256i);
+extern __m128i   __cdecl _mm256_maskz_cvtusepi64_epi8(__mmask8, __m256i);
+extern void      __cdecl _mm_mask_cvtusepi64_storeu_epi16(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_cvtusepi64_storeu_epi16(void*, __mmask8, __m256i);
+extern void      __cdecl _mm_mask_cvtusepi64_storeu_epi32(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_cvtusepi64_storeu_epi32(void*, __mmask8, __m256i);
+extern void      __cdecl _mm_mask_cvtusepi64_storeu_epi8(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_cvtusepi64_storeu_epi8(void*, __mmask8, __m256i);
+extern __m128i   __cdecl _mm_dbsad_epu8(__m128i, __m128i, int);
+extern __m128i   __cdecl _mm_mask_dbsad_epu8(__m128i, __mmask8, __m128i, __m128i, int);
+extern __m128i   __cdecl _mm_maskz_dbsad_epu8(__mmask8, __m128i, __m128i, int);
+extern __m256i   __cdecl _mm256_dbsad_epu8(__m256i, __m256i, int);
+extern __m256i   __cdecl _mm256_mask_dbsad_epu8(__m256i, __mmask16, __m256i, __m256i, int);
+extern __m256i   __cdecl _mm256_maskz_dbsad_epu8(__mmask16, __m256i, __m256i, int);
+extern __m128d   __cdecl _mm_mask_div_pd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_div_pd(__mmask8, __m128d, __m128d);
+extern __m256d   __cdecl _mm256_mask_div_pd(__m256d, __mmask8, __m256d, __m256d);
+extern __m256d   __cdecl _mm256_maskz_div_pd(__mmask8, __m256d, __m256d);
+extern __m128    __cdecl _mm_mask_div_ps(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_div_ps(__mmask8, __m128, __m128);
+extern __m256    __cdecl _mm256_mask_div_ps(__m256, __mmask8, __m256, __m256);
+extern __m256    __cdecl _mm256_maskz_div_ps(__mmask8, __m256, __m256);
+extern __m128i   __cdecl _mm_mask_expand_epi8(__m128i, __mmask16, __m128i);
+extern __m128i   __cdecl _mm_maskz_expand_epi8(__mmask16, __m128i);
+extern __m256i   __cdecl _mm256_mask_expand_epi8(__m256i, __mmask32, __m256i);
+extern __m256i   __cdecl _mm256_maskz_expand_epi8(__mmask32, __m256i);
+extern __m128i   __cdecl _mm_mask_expand_epi16(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_expand_epi16(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_expand_epi16(__m256i, __mmask16, __m256i);
+extern __m256i   __cdecl _mm256_maskz_expand_epi16(__mmask16, __m256i);
+extern __m128i   __cdecl _mm_mask_expand_epi32(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_expand_epi32(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_expand_epi32(__m256i, __mmask8, __m256i);
+extern __m256i   __cdecl _mm256_maskz_expand_epi32(__mmask8, __m256i);
+extern __m128i   __cdecl _mm_mask_expand_epi64(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_expand_epi64(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_expand_epi64(__m256i, __mmask8, __m256i);
+extern __m256i   __cdecl _mm256_maskz_expand_epi64(__mmask8, __m256i);
+extern __m128d   __cdecl _mm_mask_expand_pd(__m128d, __mmask8, __m128d);
+extern __m128d   __cdecl _mm_maskz_expand_pd(__mmask8, __m128d);
+extern __m256d   __cdecl _mm256_mask_expand_pd(__m256d, __mmask8, __m256d);
+extern __m256d   __cdecl _mm256_maskz_expand_pd(__mmask8, __m256d);
+extern __m128    __cdecl _mm_mask_expand_ps(__m128, __mmask8, __m128);
+extern __m128    __cdecl _mm_maskz_expand_ps(__mmask8, __m128);
+extern __m256    __cdecl _mm256_mask_expand_ps(__m256, __mmask8, __m256);
+extern __m256    __cdecl _mm256_maskz_expand_ps(__mmask8, __m256);
+extern __m128i   __cdecl _mm_mask_expandloadu_epi8(__m128i, __mmask16, const void*);
+extern __m128i   __cdecl _mm_maskz_expandloadu_epi8(__mmask16, const void*);
+extern __m256i   __cdecl _mm256_mask_expandloadu_epi8(__m256i, __mmask32, const void*);
+extern __m256i   __cdecl _mm256_maskz_expandloadu_epi8(__mmask32, const void*);
+extern __m128i   __cdecl _mm_mask_expandloadu_epi16(__m128i, __mmask8, const void*);
+extern __m128i   __cdecl _mm_maskz_expandloadu_epi16(__mmask8, const void*);
+extern __m256i   __cdecl _mm256_mask_expandloadu_epi16(__m256i, __mmask16, const void*);
+extern __m256i   __cdecl _mm256_maskz_expandloadu_epi16(__mmask16, const void*);
+extern __m128i   __cdecl _mm_mask_expandloadu_epi32(__m128i, __mmask8, void const*);
+extern __m128i   __cdecl _mm_maskz_expandloadu_epi32(__mmask8, void const*);
+extern __m256i   __cdecl _mm256_mask_expandloadu_epi32(__m256i, __mmask8, void const*);
+extern __m256i   __cdecl _mm256_maskz_expandloadu_epi32(__mmask8, void const*);
+extern __m128i   __cdecl _mm_mask_expandloadu_epi64(__m128i, __mmask8, void const*);
+extern __m128i   __cdecl _mm_maskz_expandloadu_epi64(__mmask8, void const*);
+extern __m256i   __cdecl _mm256_mask_expandloadu_epi64(__m256i, __mmask8, void const*);
+extern __m256i   __cdecl _mm256_maskz_expandloadu_epi64(__mmask8, void const*);
+extern __m128d   __cdecl _mm_mask_expandloadu_pd(__m128d, __mmask8, void const*);
+extern __m128d   __cdecl _mm_maskz_expandloadu_pd(__mmask8, void const*);
+extern __m256d   __cdecl _mm256_mask_expandloadu_pd(__m256d, __mmask8, void const*);
+extern __m256d   __cdecl _mm256_maskz_expandloadu_pd(__mmask8, void const*);
+extern __m128    __cdecl _mm_mask_expandloadu_ps(__m128, __mmask8, void const*);
+extern __m128    __cdecl _mm_maskz_expandloadu_ps(__mmask8, void const*);
+extern __m256    __cdecl _mm256_mask_expandloadu_ps(__m256, __mmask8, void const*);
+extern __m256    __cdecl _mm256_maskz_expandloadu_ps(__mmask8, void const*);
+extern __m128    __cdecl _mm256_extractf32x4_ps(__m256, int);
+extern __m128    __cdecl _mm256_mask_extractf32x4_ps(__m128, __mmask8, __m256, int);
+extern __m128    __cdecl _mm256_maskz_extractf32x4_ps(__mmask8, __m256, int);
+extern __m128d   __cdecl _mm256_extractf64x2_pd(__m256d, int);
+extern __m128d   __cdecl _mm256_mask_extractf64x2_pd(__m128d, __mmask8, __m256d, int);
+extern __m128d   __cdecl _mm256_maskz_extractf64x2_pd(__mmask8, __m256d, int);
+extern __m128i   __cdecl _mm256_extracti32x4_epi32(__m256i, int);
+extern __m128i   __cdecl _mm256_mask_extracti32x4_epi32(__m128i, __mmask8, __m256i, int);
+extern __m128i   __cdecl _mm256_maskz_extracti32x4_epi32(__mmask8, __m256i, int);
+extern __m128i   __cdecl _mm256_extracti64x2_epi64(__m256i, int);
+extern __m128i   __cdecl _mm256_mask_extracti64x2_epi64(__m128i, __mmask8, __m256i, int);
+extern __m128i   __cdecl _mm256_maskz_extracti64x2_epi64(__mmask8, __m256i, int);
+extern __m128d   __cdecl _mm_fixupimm_pd(__m128d, __m128d, __m128i, const int);
+extern __m128d   __cdecl _mm_mask_fixupimm_pd(__m128d, __mmask8, __m128d, __m128i, const int);
+extern __m128d   __cdecl _mm_maskz_fixupimm_pd(__mmask8, __m128d, __m128d, __m128i, const int);
+extern __m256d   __cdecl _mm256_fixupimm_pd(__m256d, __m256d, __m256i, const int);
+extern __m256d   __cdecl _mm256_mask_fixupimm_pd(__m256d, __mmask8, __m256d, __m256i, const int);
+extern __m256d   __cdecl _mm256_maskz_fixupimm_pd(__mmask8, __m256d, __m256d, __m256i, const int);
+extern __m128    __cdecl _mm_fixupimm_ps(__m128, __m128, __m128i, const int);
+extern __m128    __cdecl _mm_mask_fixupimm_ps(__m128, __mmask8, __m128, __m128i, const int);
+extern __m128    __cdecl _mm_maskz_fixupimm_ps(__mmask8, __m128, __m128, __m128i, const int);
+extern __m256    __cdecl _mm256_fixupimm_ps(__m256, __m256, __m256i, const int);
+extern __m256    __cdecl _mm256_mask_fixupimm_ps(__m256, __mmask8, __m256, __m256i, const int);
+extern __m256    __cdecl _mm256_maskz_fixupimm_ps(__mmask8, __m256, __m256, __m256i, const int);
+extern __m128d   __cdecl _mm_mask_fmadd_pd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_mask3_fmadd_pd(__m128d, __m128d, __m128d, __mmask8);
+extern __m128d   __cdecl _mm_maskz_fmadd_pd(__mmask8, __m128d, __m128d, __m128d);
+extern __m256d   __cdecl _mm256_mask_fmadd_pd(__m256d, __mmask8, __m256d, __m256d);
+extern __m256d   __cdecl _mm256_mask3_fmadd_pd(__m256d, __m256d, __m256d, __mmask8);
+extern __m256d   __cdecl _mm256_maskz_fmadd_pd(__mmask8, __m256d, __m256d, __m256d);
+extern __m128    __cdecl _mm_mask_fmadd_ps(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_mask3_fmadd_ps(__m128, __m128, __m128, __mmask8);
+extern __m128    __cdecl _mm_maskz_fmadd_ps(__mmask8, __m128, __m128, __m128);
+extern __m256    __cdecl _mm256_mask_fmadd_ps(__m256, __mmask8, __m256, __m256);
+extern __m256    __cdecl _mm256_mask3_fmadd_ps(__m256, __m256, __m256, __mmask8);
+extern __m256    __cdecl _mm256_maskz_fmadd_ps(__mmask8, __m256, __m256, __m256);
+extern __m128d   __cdecl _mm_mask_fmaddsub_pd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_mask3_fmaddsub_pd(__m128d, __m128d, __m128d, __mmask8);
+extern __m128d   __cdecl _mm_maskz_fmaddsub_pd(__mmask8, __m128d, __m128d, __m128d);
+extern __m256d   __cdecl _mm256_mask_fmaddsub_pd(__m256d, __mmask8, __m256d, __m256d);
+extern __m256d   __cdecl _mm256_mask3_fmaddsub_pd(__m256d, __m256d, __m256d, __mmask8);
+extern __m256d   __cdecl _mm256_maskz_fmaddsub_pd(__mmask8, __m256d, __m256d, __m256d);
+extern __m128    __cdecl _mm_mask_fmaddsub_ps(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_mask3_fmaddsub_ps(__m128, __m128, __m128, __mmask8);
+extern __m128    __cdecl _mm_maskz_fmaddsub_ps(__mmask8, __m128, __m128, __m128);
+extern __m256    __cdecl _mm256_mask_fmaddsub_ps(__m256, __mmask8, __m256, __m256);
+extern __m256    __cdecl _mm256_mask3_fmaddsub_ps(__m256, __m256, __m256, __mmask8);
+extern __m256    __cdecl _mm256_maskz_fmaddsub_ps(__mmask8, __m256, __m256, __m256);
+extern __m128d   __cdecl _mm_mask_fmsub_pd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_mask3_fmsub_pd(__m128d, __m128d, __m128d, __mmask8);
+extern __m128d   __cdecl _mm_maskz_fmsub_pd(__mmask8, __m128d, __m128d, __m128d);
+extern __m256d   __cdecl _mm256_mask_fmsub_pd(__m256d, __mmask8, __m256d, __m256d);
+extern __m256d   __cdecl _mm256_mask3_fmsub_pd(__m256d, __m256d, __m256d, __mmask8);
+extern __m256d   __cdecl _mm256_maskz_fmsub_pd(__mmask8, __m256d, __m256d, __m256d);
+extern __m128    __cdecl _mm_mask_fmsub_ps(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_mask3_fmsub_ps(__m128, __m128, __m128, __mmask8);
+extern __m128    __cdecl _mm_maskz_fmsub_ps(__mmask8, __m128, __m128, __m128);
+extern __m256    __cdecl _mm256_mask_fmsub_ps(__m256, __mmask8, __m256, __m256);
+extern __m256    __cdecl _mm256_mask3_fmsub_ps(__m256, __m256, __m256, __mmask8);
+extern __m256    __cdecl _mm256_maskz_fmsub_ps(__mmask8, __m256, __m256, __m256);
+extern __m128d   __cdecl _mm_mask_fmsubadd_pd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_mask3_fmsubadd_pd(__m128d, __m128d, __m128d, __mmask8);
+extern __m128d   __cdecl _mm_maskz_fmsubadd_pd(__mmask8, __m128d, __m128d, __m128d);
+extern __m256d   __cdecl _mm256_mask_fmsubadd_pd(__m256d, __mmask8, __m256d, __m256d);
+extern __m256d   __cdecl _mm256_mask3_fmsubadd_pd(__m256d, __m256d, __m256d, __mmask8);
+extern __m256d   __cdecl _mm256_maskz_fmsubadd_pd(__mmask8, __m256d, __m256d, __m256d);
+extern __m128    __cdecl _mm_mask_fmsubadd_ps(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_mask3_fmsubadd_ps(__m128, __m128, __m128, __mmask8);
+extern __m128    __cdecl _mm_maskz_fmsubadd_ps(__mmask8, __m128, __m128, __m128);
+extern __m256    __cdecl _mm256_mask_fmsubadd_ps(__m256, __mmask8, __m256, __m256);
+extern __m256    __cdecl _mm256_mask3_fmsubadd_ps(__m256, __m256, __m256, __mmask8);
+extern __m256    __cdecl _mm256_maskz_fmsubadd_ps(__mmask8, __m256, __m256, __m256);
+extern __m128d   __cdecl _mm_mask_fnmadd_pd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_mask3_fnmadd_pd(__m128d, __m128d, __m128d, __mmask8);
+extern __m128d   __cdecl _mm_maskz_fnmadd_pd(__mmask8, __m128d, __m128d, __m128d);
+extern __m256d   __cdecl _mm256_mask_fnmadd_pd(__m256d, __mmask8, __m256d, __m256d);
+extern __m256d   __cdecl _mm256_mask3_fnmadd_pd(__m256d, __m256d, __m256d, __mmask8);
+extern __m256d   __cdecl _mm256_maskz_fnmadd_pd(__mmask8, __m256d, __m256d, __m256d);
+extern __m128    __cdecl _mm_mask_fnmadd_ps(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_mask3_fnmadd_ps(__m128, __m128, __m128, __mmask8);
+extern __m128    __cdecl _mm_maskz_fnmadd_ps(__mmask8, __m128, __m128, __m128);
+extern __m256    __cdecl _mm256_mask_fnmadd_ps(__m256, __mmask8, __m256, __m256);
+extern __m256    __cdecl _mm256_mask3_fnmadd_ps(__m256, __m256, __m256, __mmask8);
+extern __m256    __cdecl _mm256_maskz_fnmadd_ps(__mmask8, __m256, __m256, __m256);
+extern __m128d   __cdecl _mm_mask_fnmsub_pd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_mask3_fnmsub_pd(__m128d, __m128d, __m128d, __mmask8);
+extern __m128d   __cdecl _mm_maskz_fnmsub_pd(__mmask8, __m128d, __m128d, __m128d);
+extern __m256d   __cdecl _mm256_mask_fnmsub_pd(__m256d, __mmask8, __m256d, __m256d);
+extern __m256d   __cdecl _mm256_mask3_fnmsub_pd(__m256d, __m256d, __m256d, __mmask8);
+extern __m256d   __cdecl _mm256_maskz_fnmsub_pd(__mmask8, __m256d, __m256d, __m256d);
+extern __m128    __cdecl _mm_mask_fnmsub_ps(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_mask3_fnmsub_ps(__m128, __m128, __m128, __mmask8);
+extern __m128    __cdecl _mm_maskz_fnmsub_ps(__mmask8, __m128, __m128, __m128);
+extern __m256    __cdecl _mm256_mask_fnmsub_ps(__m256, __mmask8, __m256, __m256);
+extern __m256    __cdecl _mm256_mask3_fnmsub_ps(__m256, __m256, __m256, __mmask8);
+extern __m256    __cdecl _mm256_maskz_fnmsub_ps(__mmask8, __m256, __m256, __m256);
+extern __mmask8  __cdecl _mm_fpclass_pd_mask(__m128d, int);
+extern __mmask8  __cdecl _mm_mask_fpclass_pd_mask(__mmask8, __m128d, int);
+extern __mmask8  __cdecl _mm256_fpclass_pd_mask(__m256d, int);
+extern __mmask8  __cdecl _mm256_mask_fpclass_pd_mask(__mmask8, __m256d, int);
+extern __mmask8  __cdecl _mm_fpclass_ps_mask(__m128, int);
+extern __mmask8  __cdecl _mm_mask_fpclass_ps_mask(__mmask8, __m128, int);
+extern __mmask8  __cdecl _mm256_fpclass_ps_mask(__m256, int);
+extern __mmask8  __cdecl _mm256_mask_fpclass_ps_mask(__mmask8, __m256, int);
+extern __m128d   __cdecl _mm_getexp_pd(__m128d);
+extern __m128d   __cdecl _mm_mask_getexp_pd(__m128d, __mmask8, __m128d);
+extern __m128d   __cdecl _mm_maskz_getexp_pd(__mmask8, __m128d);
+extern __m256d   __cdecl _mm256_getexp_pd(__m256d);
+extern __m256d   __cdecl _mm256_mask_getexp_pd(__m256d, __mmask8, __m256d);
+extern __m256d   __cdecl _mm256_maskz_getexp_pd(__mmask8, __m256d);
+extern __m128    __cdecl _mm_getexp_ps(__m128);
+extern __m128    __cdecl _mm_mask_getexp_ps(__m128, __mmask8, __m128);
+extern __m128    __cdecl _mm_maskz_getexp_ps(__mmask8, __m128);
+extern __m256    __cdecl _mm256_getexp_ps(__m256);
+extern __m256    __cdecl _mm256_mask_getexp_ps(__m256, __mmask8, __m256);
+extern __m256    __cdecl _mm256_maskz_getexp_ps(__mmask8, __m256);
+extern __m128d   __cdecl _mm_getmant_pd(__m128d, int, int);
+extern __m128d   __cdecl _mm_mask_getmant_pd(__m128d, __mmask8, __m128d, int, int);
+extern __m128d   __cdecl _mm_maskz_getmant_pd(__mmask8, __m128d, int, int);
+extern __m256d   __cdecl _mm256_getmant_pd(__m256d, int, int);
+extern __m256d   __cdecl _mm256_mask_getmant_pd(__m256d, __mmask8, __m256d, int, int);
+extern __m256d   __cdecl _mm256_maskz_getmant_pd(__mmask8, __m256d, int, int);
+extern __m128    __cdecl _mm_getmant_ps(__m128, int, int);
+extern __m128    __cdecl _mm_mask_getmant_ps(__m128, __mmask8, __m128, int, int);
+extern __m128    __cdecl _mm_maskz_getmant_ps(__mmask8, __m128, int, int);
+extern __m256    __cdecl _mm256_getmant_ps(__m256, int, int);
+extern __m256    __cdecl _mm256_mask_getmant_ps(__m256, __mmask8, __m256, int, int);
+extern __m256    __cdecl _mm256_maskz_getmant_ps(__mmask8, __m256, int, int);
+extern __m128i   __cdecl _mm_mmask_i32gather_epi32(__m128i, __mmask8, __m128i, void const*, const int);
+extern __m256i   __cdecl _mm256_mmask_i32gather_epi32(__m256i, __mmask8, __m256i, void const*, const int);
+extern __m128i   __cdecl _mm_mmask_i32gather_epi64(__m128i, __mmask8, __m128i, void const*, const int);
+extern __m256i   __cdecl _mm256_mmask_i32gather_epi64(__m256i, __mmask8, __m128i, void const*, const int);
+extern __m128d   __cdecl _mm_mmask_i32gather_pd(__m128d, __mmask8, __m128i, void const*, const int);
+extern __m256d   __cdecl _mm256_mmask_i32gather_pd(__m256d, __mmask8, __m128i, void const*, const int);
+extern __m128    __cdecl _mm_mmask_i32gather_ps(__m128, __mmask8, __m128i, void const*, const int);
+extern __m256    __cdecl _mm256_mmask_i32gather_ps(__m256, __mmask8, __m256i, void const*, const int);
+extern void      __cdecl _mm_i32scatter_epi32(void*, __m128i, __m128i, const int);
+extern void      __cdecl _mm_mask_i32scatter_epi32(void*, __mmask8, __m128i, __m128i, const int);
+extern void      __cdecl _mm256_i32scatter_epi32(void*, __m256i, __m256i, const int);
+extern void      __cdecl _mm256_mask_i32scatter_epi32(void*, __mmask8, __m256i, __m256i, const int);
+extern void      __cdecl _mm_i32scatter_epi64(void*, __m128i, __m128i, const int);
+extern void      __cdecl _mm_mask_i32scatter_epi64(void*, __mmask8, __m128i, __m128i, const int);
+extern void      __cdecl _mm256_i32scatter_epi64(void*, __m128i, __m256i, const int);
+extern void      __cdecl _mm256_mask_i32scatter_epi64(void*, __mmask8, __m128i, __m256i, const int);
+extern void      __cdecl _mm_i32scatter_pd(void*, __m128i, __m128d, const int);
+extern void      __cdecl _mm_mask_i32scatter_pd(void*, __mmask8, __m128i, __m128d, const int);
+extern void      __cdecl _mm256_i32scatter_pd(void*, __m128i, __m256d, const int);
+extern void      __cdecl _mm256_mask_i32scatter_pd(void*, __mmask8, __m128i, __m256d, const int);
+extern void      __cdecl _mm_i32scatter_ps(void*, __m128i, __m128, const int);
+extern void      __cdecl _mm_mask_i32scatter_ps(void*, __mmask8, __m128i, __m128, const int);
+extern void      __cdecl _mm256_i32scatter_ps(void*, __m256i, __m256, const int);
+extern void      __cdecl _mm256_mask_i32scatter_ps(void*, __mmask8, __m256i, __m256, const int);
+extern __m128i   __cdecl _mm_mmask_i64gather_epi32(__m128i, __mmask8, __m128i, void const*, const int);
+extern __m128i   __cdecl _mm256_mmask_i64gather_epi32(__m128i, __mmask8, __m256i, void const*, const int);
+extern __m128i   __cdecl _mm_mmask_i64gather_epi64(__m128i, __mmask8, __m128i, void const*, const int);
+extern __m256i   __cdecl _mm256_mmask_i64gather_epi64(__m256i, __mmask8, __m256i, void const*, const int);
+extern __m128d   __cdecl _mm_mmask_i64gather_pd(__m128d, __mmask8, __m128i, void const*, const int);
+extern __m256d   __cdecl _mm256_mmask_i64gather_pd(__m256d, __mmask8, __m256i, void const*, const int);
+extern __m128    __cdecl _mm_mmask_i64gather_ps(__m128, __mmask8, __m128i, void const*, const int);
+extern __m128    __cdecl _mm256_mmask_i64gather_ps(__m128, __mmask8, __m256i, void const*, const int);
+extern void      __cdecl _mm_i64scatter_epi32(void*, __m128i, __m128i, const int);
+extern void      __cdecl _mm_mask_i64scatter_epi32(void*, __mmask8, __m128i, __m128i, const int);
+extern void      __cdecl _mm256_i64scatter_epi32(void*, __m256i, __m128i, const int);
+extern void      __cdecl _mm256_mask_i64scatter_epi32(void*, __mmask8, __m256i, __m128i, const int);
+extern void      __cdecl _mm_i64scatter_epi64(void*, __m128i, __m128i, const int);
+extern void      __cdecl _mm_mask_i64scatter_epi64(void*, __mmask8, __m128i, __m128i, const int);
+extern void      __cdecl _mm256_i64scatter_epi64(void*, __m256i, __m256i, const int);
+extern void      __cdecl _mm256_mask_i64scatter_epi64(void*, __mmask8, __m256i, __m256i, const int);
+extern void      __cdecl _mm_i64scatter_pd(void*, __m128i, __m128d, const int);
+extern void      __cdecl _mm_mask_i64scatter_pd(void*, __mmask8, __m128i, __m128d, const int);
+extern void      __cdecl _mm256_i64scatter_pd(void*, __m256i, __m256d, const int);
+extern void      __cdecl _mm256_mask_i64scatter_pd(void*, __mmask8, __m256i, __m256d, const int);
+extern void      __cdecl _mm_i64scatter_ps(void*, __m128i, __m128, const int);
+extern void      __cdecl _mm_mask_i64scatter_ps(void*, __mmask8, __m128i, __m128, const int);
+extern void      __cdecl _mm256_i64scatter_ps(void*, __m256i, __m128, const int);
+extern void      __cdecl _mm256_mask_i64scatter_ps(void*, __mmask8, __m256i, __m128, const int);
+extern __m256    __cdecl _mm256_insertf32x4(__m256, __m128, int);
+extern __m256    __cdecl _mm256_mask_insertf32x4(__m256, __mmask8, __m256, __m128, int);
+extern __m256    __cdecl _mm256_maskz_insertf32x4(__mmask8, __m256, __m128, int);
+extern __m256d   __cdecl _mm256_insertf64x2(__m256d, __m128d, int);
+extern __m256d   __cdecl _mm256_mask_insertf64x2(__m256d, __mmask8, __m256d, __m128d, int);
+extern __m256d   __cdecl _mm256_maskz_insertf64x2(__mmask8, __m256d, __m128d, int);
+extern __m256i   __cdecl _mm256_inserti32x4(__m256i, __m128i, int);
+extern __m256i   __cdecl _mm256_mask_inserti32x4(__m256i, __mmask8, __m256i, __m128i, int);
+extern __m256i   __cdecl _mm256_maskz_inserti32x4(__mmask8, __m256i, __m128i, int);
+extern __m256i   __cdecl _mm256_inserti64x2(__m256i, __m128i, int);
+extern __m256i   __cdecl _mm256_mask_inserti64x2(__m256i, __mmask8, __m256i, __m128i, int);
+extern __m256i   __cdecl _mm256_maskz_inserti64x2(__mmask8, __m256i, __m128i, int);
+extern __m128i   __cdecl _mm_mask_load_epi32(__m128i, __mmask8, void const*);
+extern __m128i   __cdecl _mm_maskz_load_epi32(__mmask8, void const*);
+extern __m256i   __cdecl _mm256_mask_load_epi32(__m256i, __mmask8, void const*);
+extern __m256i   __cdecl _mm256_maskz_load_epi32(__mmask8, void const*);
+extern __m128i   __cdecl _mm_mask_load_epi64(__m128i, __mmask8, void const*);
+extern __m128i   __cdecl _mm_maskz_load_epi64(__mmask8, void const*);
+extern __m256i   __cdecl _mm256_mask_load_epi64(__m256i, __mmask8, void const*);
+extern __m256i   __cdecl _mm256_maskz_load_epi64(__mmask8, void const*);
+extern __m128d   __cdecl _mm_mask_load_pd(__m128d, __mmask8, void const*);
+extern __m128d   __cdecl _mm_maskz_load_pd(__mmask8, void const*);
+extern __m256d   __cdecl _mm256_mask_load_pd(__m256d, __mmask8, void const*);
+extern __m256d   __cdecl _mm256_maskz_load_pd(__mmask8, void const*);
+extern __m128    __cdecl _mm_mask_load_ps(__m128, __mmask8, void const*);
+extern __m128    __cdecl _mm_maskz_load_ps(__mmask8, void const*);
+extern __m256    __cdecl _mm256_mask_load_ps(__m256, __mmask8, void const*);
+extern __m256    __cdecl _mm256_maskz_load_ps(__mmask8, void const*);
+extern __m128i   __cdecl _mm_loadu_epi16(void const*);
+extern __m128i   __cdecl _mm_mask_loadu_epi16(__m128i, __mmask8, void const*);
+extern __m128i   __cdecl _mm_maskz_loadu_epi16(__mmask8, void const*);
+extern __m256i   __cdecl _mm256_loadu_epi16(void const*);
+extern __m256i   __cdecl _mm256_mask_loadu_epi16(__m256i, __mmask16, void const*);
+extern __m256i   __cdecl _mm256_maskz_loadu_epi16(__mmask16, void const*);
+extern __m128i   __cdecl _mm_loadu_epi32(void const*);
+extern __m128i   __cdecl _mm_mask_loadu_epi32(__m128i, __mmask8, void const*);
+extern __m128i   __cdecl _mm_maskz_loadu_epi32(__mmask8, void const*);
+extern __m256i   __cdecl _mm256_loadu_epi32(void const*);
+extern __m256i   __cdecl _mm256_mask_loadu_epi32(__m256i, __mmask8, void const*);
+extern __m256i   __cdecl _mm256_maskz_loadu_epi32(__mmask8, void const*);
+extern __m128i   __cdecl _mm_loadu_epi64(void const*);
+extern __m128i   __cdecl _mm_mask_loadu_epi64(__m128i, __mmask8, void const*);
+extern __m128i   __cdecl _mm_maskz_loadu_epi64(__mmask8, void const*);
+extern __m256i   __cdecl _mm256_loadu_epi64(void const*);
+extern __m256i   __cdecl _mm256_mask_loadu_epi64(__m256i, __mmask8, void const*);
+extern __m256i   __cdecl _mm256_maskz_loadu_epi64(__mmask8, void const*);
+extern __m128i   __cdecl _mm_loadu_epi8(void const*);
+extern __m128i   __cdecl _mm_mask_loadu_epi8(__m128i, __mmask16, void const*);
+extern __m128i   __cdecl _mm_maskz_loadu_epi8(__mmask16, void const*);
+extern __m256i   __cdecl _mm256_loadu_epi8(void const*);
+extern __m256i   __cdecl _mm256_mask_loadu_epi8(__m256i, __mmask32, void const*);
+extern __m256i   __cdecl _mm256_maskz_loadu_epi8(__mmask32, void const*);
+extern __m128d   __cdecl _mm_mask_loadu_pd(__m128d, __mmask8, void const*);
+extern __m128d   __cdecl _mm_maskz_loadu_pd(__mmask8, void const*);
+extern __m256d   __cdecl _mm256_mask_loadu_pd(__m256d, __mmask8, void const*);
+extern __m256d   __cdecl _mm256_maskz_loadu_pd(__mmask8, void const*);
+extern __m128    __cdecl _mm_mask_loadu_ps(__m128, __mmask8, void const*);
+extern __m128    __cdecl _mm_maskz_loadu_ps(__mmask8, void const*);
+extern __m256    __cdecl _mm256_mask_loadu_ps(__m256, __mmask8, void const*);
+extern __m256    __cdecl _mm256_maskz_loadu_ps(__mmask8, void const*);
+extern __m128i   __cdecl _mm_lzcnt_epi32(__m128i);
+extern __m128i   __cdecl _mm_mask_lzcnt_epi32(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_lzcnt_epi32(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_lzcnt_epi32(__m256i);
+extern __m256i   __cdecl _mm256_mask_lzcnt_epi32(__m256i, __mmask8, __m256i);
+extern __m256i   __cdecl _mm256_maskz_lzcnt_epi32(__mmask8, __m256i);
+extern __m128i   __cdecl _mm_lzcnt_epi64(__m128i);
+extern __m128i   __cdecl _mm_mask_lzcnt_epi64(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_lzcnt_epi64(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_lzcnt_epi64(__m256i);
+extern __m256i   __cdecl _mm256_mask_lzcnt_epi64(__m256i, __mmask8, __m256i);
+extern __m256i   __cdecl _mm256_maskz_lzcnt_epi64(__mmask8, __m256i);
+extern __m128i   __cdecl _mm_mask_madd_epi16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_madd_epi16(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_madd_epi16(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_madd_epi16(__mmask8, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_maddubs_epi16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_maddubs_epi16(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_maddubs_epi16(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_maddubs_epi16(__mmask16, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_max_epi16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_max_epi16(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_max_epi16(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_max_epi16(__mmask16, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_max_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_max_epi32(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_max_epi32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_max_epi32(__mmask8, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_max_epi64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_max_epi64(__mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_max_epi64(__m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_max_epi64(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_max_epi64(__mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_max_epi64(__m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_max_epi8(__m128i, __mmask16, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_max_epi8(__mmask16, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_max_epi8(__m256i, __mmask32, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_max_epi8(__mmask32, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_max_epu16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_max_epu16(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_max_epu16(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_max_epu16(__mmask16, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_max_epu32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_max_epu32(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_max_epu32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_max_epu32(__mmask8, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_max_epu64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_max_epu64(__mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_max_epu64(__m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_max_epu64(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_max_epu64(__mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_max_epu64(__m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_max_epu8(__m128i, __mmask16, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_max_epu8(__mmask16, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_max_epu8(__m256i, __mmask32, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_max_epu8(__mmask32, __m256i, __m256i);
+extern __m128d   __cdecl _mm_mask_max_pd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_max_pd(__mmask8, __m128d, __m128d);
+extern __m256d   __cdecl _mm256_mask_max_pd(__m256d, __mmask8, __m256d, __m256d);
+extern __m256d   __cdecl _mm256_maskz_max_pd(__mmask8, __m256d, __m256d);
+extern __m128    __cdecl _mm_mask_max_ps(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_max_ps(__mmask8, __m128, __m128);
+extern __m256    __cdecl _mm256_mask_max_ps(__m256, __mmask8, __m256, __m256);
+extern __m256    __cdecl _mm256_maskz_max_ps(__mmask8, __m256, __m256);
+extern __m128i   __cdecl _mm_mask_min_epi16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_min_epi16(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_min_epi16(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_min_epi16(__mmask16, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_min_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_min_epi32(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_min_epi32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_min_epi32(__mmask8, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_min_epi64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_min_epi64(__mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_min_epi64(__m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_min_epi64(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_min_epi64(__mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_min_epi64(__m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_min_epi8(__m128i, __mmask16, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_min_epi8(__mmask16, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_min_epi8(__m256i, __mmask32, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_min_epi8(__mmask32, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_min_epu16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_min_epu16(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_min_epu16(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_min_epu16(__mmask16, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_min_epu32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_min_epu32(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_min_epu32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_min_epu32(__mmask8, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_min_epu64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_min_epu64(__mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_min_epu64(__m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_min_epu64(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_min_epu64(__mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_min_epu64(__m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_min_epu8(__m128i, __mmask16, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_min_epu8(__mmask16, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_min_epu8(__m256i, __mmask32, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_min_epu8(__mmask32, __m256i, __m256i);
+extern __m128d   __cdecl _mm_mask_min_pd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_min_pd(__mmask8, __m128d, __m128d);
+extern __m256d   __cdecl _mm256_mask_min_pd(__m256d, __mmask8, __m256d, __m256d);
+extern __m256d   __cdecl _mm256_maskz_min_pd(__mmask8, __m256d, __m256d);
+extern __m128    __cdecl _mm_mask_min_ps(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_min_ps(__mmask8, __m128, __m128);
+extern __m256    __cdecl _mm256_mask_min_ps(__m256, __mmask8, __m256, __m256);
+extern __m256    __cdecl _mm256_maskz_min_ps(__mmask8, __m256, __m256);
+extern __m128i   __cdecl _mm_mask_mov_epi16(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_mov_epi16(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_mov_epi16(__m256i, __mmask16, __m256i);
+extern __m256i   __cdecl _mm256_maskz_mov_epi16(__mmask16, __m256i);
+extern __m128i   __cdecl _mm_mask_mov_epi32(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_mov_epi32(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_mov_epi32(__m256i, __mmask8, __m256i);
+extern __m256i   __cdecl _mm256_maskz_mov_epi32(__mmask8, __m256i);
+extern __m128i   __cdecl _mm_mask_mov_epi64(__m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_mov_epi64(__mmask8, __m128i);
+extern __m256i   __cdecl _mm256_mask_mov_epi64(__m256i, __mmask8, __m256i);
+extern __m256i   __cdecl _mm256_maskz_mov_epi64(__mmask8, __m256i);
+extern __m128i   __cdecl _mm_mask_mov_epi8(__m128i, __mmask16, __m128i);
+extern __m128i   __cdecl _mm_maskz_mov_epi8(__mmask16, __m128i);
+extern __m256i   __cdecl _mm256_mask_mov_epi8(__m256i, __mmask32, __m256i);
+extern __m256i   __cdecl _mm256_maskz_mov_epi8(__mmask32, __m256i);
+extern __m128d   __cdecl _mm_mask_mov_pd(__m128d, __mmask8, __m128d);
+extern __m128d   __cdecl _mm_maskz_mov_pd(__mmask8, __m128d);
+extern __m256d   __cdecl _mm256_mask_mov_pd(__m256d, __mmask8, __m256d);
+extern __m256d   __cdecl _mm256_maskz_mov_pd(__mmask8, __m256d);
+extern __m128    __cdecl _mm_mask_mov_ps(__m128, __mmask8, __m128);
+extern __m128    __cdecl _mm_maskz_mov_ps(__mmask8, __m128);
+extern __m256    __cdecl _mm256_mask_mov_ps(__m256, __mmask8, __m256);
+extern __m256    __cdecl _mm256_maskz_mov_ps(__mmask8, __m256);
+extern __m128d   __cdecl _mm_mask_movedup_pd(__m128d, __mmask8, __m128d);
+extern __m128d   __cdecl _mm_maskz_movedup_pd(__mmask8, __m128d);
+extern __m256d   __cdecl _mm256_mask_movedup_pd(__m256d, __mmask8, __m256d);
+extern __m256d   __cdecl _mm256_maskz_movedup_pd(__mmask8, __m256d);
+extern __m128    __cdecl _mm_mask_movehdup_ps(__m128, __mmask8, __m128);
+extern __m128    __cdecl _mm_maskz_movehdup_ps(__mmask8, __m128);
+extern __m256    __cdecl _mm256_mask_movehdup_ps(__m256, __mmask8, __m256);
+extern __m256    __cdecl _mm256_maskz_movehdup_ps(__mmask8, __m256);
+extern __m128    __cdecl _mm_mask_moveldup_ps(__m128, __mmask8, __m128);
+extern __m128    __cdecl _mm_maskz_moveldup_ps(__mmask8, __m128);
+extern __m256    __cdecl _mm256_mask_moveldup_ps(__m256, __mmask8, __m256);
+extern __m256    __cdecl _mm256_maskz_moveldup_ps(__mmask8, __m256);
+extern __mmask8  __cdecl _mm_movepi16_mask(__m128i);
+extern __mmask16 __cdecl _mm256_movepi16_mask(__m256i);
+extern __mmask8  __cdecl _mm_movepi32_mask(__m128i);
+extern __mmask8  __cdecl _mm256_movepi32_mask(__m256i);
+extern __mmask8  __cdecl _mm_movepi64_mask(__m128i);
+extern __mmask8  __cdecl _mm256_movepi64_mask(__m256i);
+extern __mmask16 __cdecl _mm_movepi8_mask(__m128i);
+extern __mmask32 __cdecl _mm256_movepi8_mask(__m256i);
+extern __m128i   __cdecl _mm_movm_epi16(__mmask8);
+extern __m256i   __cdecl _mm256_movm_epi16(__mmask16);
+extern __m128i   __cdecl _mm_movm_epi32(__mmask8);
+extern __m256i   __cdecl _mm256_movm_epi32(__mmask8);
+extern __m128i   __cdecl _mm_movm_epi64(__mmask8);
+extern __m256i   __cdecl _mm256_movm_epi64(__mmask8);
+extern __m128i   __cdecl _mm_movm_epi8(__mmask16);
+extern __m256i   __cdecl _mm256_movm_epi8(__mmask32);
+extern __m128i   __cdecl _mm_mask_mul_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_mul_epi32(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_mul_epi32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_mul_epi32(__mmask8, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_mul_epu32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_mul_epu32(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_mul_epu32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_mul_epu32(__mmask8, __m256i, __m256i);
+extern __m128d   __cdecl _mm_mask_mul_pd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_mul_pd(__mmask8, __m128d, __m128d);
+extern __m256d   __cdecl _mm256_mask_mul_pd(__m256d, __mmask8, __m256d, __m256d);
+extern __m256d   __cdecl _mm256_maskz_mul_pd(__mmask8, __m256d, __m256d);
+extern __m128    __cdecl _mm_mask_mul_ps(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_mul_ps(__mmask8, __m128, __m128);
+extern __m256    __cdecl _mm256_mask_mul_ps(__m256, __mmask8, __m256, __m256);
+extern __m256    __cdecl _mm256_maskz_mul_ps(__mmask8, __m256, __m256);
+extern __m128i   __cdecl _mm_mask_mulhi_epi16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_mulhi_epi16(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_mulhi_epi16(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_mulhi_epi16(__mmask16, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_mulhi_epu16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_mulhi_epu16(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_mulhi_epu16(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_mulhi_epu16(__mmask16, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_mulhrs_epi16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_mulhrs_epi16(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_mulhrs_epi16(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_mulhrs_epi16(__mmask16, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_mullo_epi16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_mullo_epi16(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_mullo_epi16(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_mullo_epi16(__mmask16, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_mullo_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_mullo_epi32(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_mullo_epi32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_mullo_epi32(__mmask8, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_mullo_epi64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_mullo_epi64(__mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_mullo_epi64(__m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_mullo_epi64(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_mullo_epi64(__mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_mullo_epi64(__m256i, __m256i);
+extern __m128i   __cdecl _mm_or_epi32(__m128i, __m128i);
+extern __m128i   __cdecl _mm_mask_or_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_or_epi32(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_or_epi32(__m256i, __m256i);
+extern __m256i   __cdecl _mm256_mask_or_epi32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_or_epi32(__mmask8, __m256i, __m256i);
+extern __m128i   __cdecl _mm_or_epi64(__m128i, __m128i);
+extern __m128i   __cdecl _mm_mask_or_epi64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_or_epi64(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_or_epi64(__m256i, __m256i);
+extern __m256i   __cdecl _mm256_mask_or_epi64(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_or_epi64(__mmask8, __m256i, __m256i);
+extern __m128d   __cdecl _mm_mask_or_pd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_or_pd(__mmask8, __m128d, __m128d);
+extern __m256d   __cdecl _mm256_mask_or_pd(__m256d, __mmask8, __m256d, __m256d);
+extern __m256d   __cdecl _mm256_maskz_or_pd(__mmask8, __m256d, __m256d);
+extern __m128    __cdecl _mm_mask_or_ps(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_or_ps(__mmask8, __m128, __m128);
+extern __m256    __cdecl _mm256_mask_or_ps(__m256, __mmask8, __m256, __m256);
+extern __m256    __cdecl _mm256_maskz_or_ps(__mmask8, __m256, __m256);
+extern __m128i   __cdecl _mm_mask_packs_epi16(__m128i, __mmask16, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_packs_epi16(__mmask16, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_packs_epi16(__m256i, __mmask32, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_packs_epi16(__mmask32, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_packs_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_packs_epi32(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_packs_epi32(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_packs_epi32(__mmask16, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_packus_epi16(__m128i, __mmask16, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_packus_epi16(__mmask16, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_packus_epi16(__m256i, __mmask32, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_packus_epi16(__mmask32, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_packus_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_packus_epi32(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_packus_epi32(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_packus_epi32(__mmask16, __m256i, __m256i);
+extern __m128d   __cdecl _mm_mask_permute_pd(__m128d, __mmask8, __m128d, const int);
+extern __m128d   __cdecl _mm_maskz_permute_pd(__mmask8, __m128d, const int);
+extern __m256d   __cdecl _mm256_mask_permute_pd(__m256d, __mmask8, __m256d, const int);
+extern __m256d   __cdecl _mm256_maskz_permute_pd(__mmask8, __m256d, const int);
+extern __m128    __cdecl _mm_mask_permute_ps(__m128, __mmask8, __m128, const int);
+extern __m128    __cdecl _mm_maskz_permute_ps(__mmask8, __m128, const int);
+extern __m256    __cdecl _mm256_mask_permute_ps(__m256, __mmask8, __m256, const int);
+extern __m256    __cdecl _mm256_maskz_permute_ps(__mmask8, __m256, const int);
+extern __m128d   __cdecl _mm_mask_permutevar_pd(__m128d, __mmask8, __m128d, __m128i);
+extern __m128d   __cdecl _mm_maskz_permutevar_pd(__mmask8, __m128d, __m128i);
+extern __m256d   __cdecl _mm256_mask_permutevar_pd(__m256d, __mmask8, __m256d, __m256i);
+extern __m256d   __cdecl _mm256_maskz_permutevar_pd(__mmask8, __m256d, __m256i);
+extern __m128    __cdecl _mm_mask_permutevar_ps(__m128, __mmask8, __m128, __m128i);
+extern __m128    __cdecl _mm_maskz_permutevar_ps(__mmask8, __m128, __m128i);
+extern __m256    __cdecl _mm256_mask_permutevar_ps(__m256, __mmask8, __m256, __m256i);
+extern __m256    __cdecl _mm256_maskz_permutevar_ps(__mmask8, __m256, __m256i);
+extern __m256i   __cdecl _mm256_mask_permutex_epi64(__m256i, __mmask8, __m256i, const int);
+extern __m256i   __cdecl _mm256_maskz_permutex_epi64(__mmask8, __m256i, const int);
+extern __m256i   __cdecl _mm256_permutex_epi64(__m256i, const int);
+extern __m256d   __cdecl _mm256_mask_permutex_pd(__m256d, __mmask8, __m256d, const int);
+extern __m256d   __cdecl _mm256_maskz_permutex_pd(__mmask8, __m256d, const int);
+extern __m256d   __cdecl _mm256_permutex_pd(__m256d, const int);
+extern __m128i   __cdecl _mm_mask_permutex2var_epi16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_mask2_permutex2var_epi16(__m128i, __m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_permutex2var_epi16(__mmask8, __m128i, __m128i, __m128i);
+extern __m128i   __cdecl _mm_permutex2var_epi16(__m128i, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_permutex2var_epi16(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_mask2_permutex2var_epi16(__m256i, __m256i, __mmask16, __m256i);
+extern __m256i   __cdecl _mm256_maskz_permutex2var_epi16(__mmask16, __m256i, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_permutex2var_epi16(__m256i, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_permutex2var_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_mask2_permutex2var_epi32(__m128i, __m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_permutex2var_epi32(__mmask8, __m128i, __m128i, __m128i);
+extern __m128i   __cdecl _mm_permutex2var_epi32(__m128i, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_permutex2var_epi32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_mask2_permutex2var_epi32(__m256i, __m256i, __mmask8, __m256i);
+extern __m256i   __cdecl _mm256_maskz_permutex2var_epi32(__mmask8, __m256i, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_permutex2var_epi32(__m256i, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_permutex2var_epi64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_mask2_permutex2var_epi64(__m128i, __m128i, __mmask8, __m128i);
+extern __m128i   __cdecl _mm_maskz_permutex2var_epi64(__mmask8, __m128i, __m128i, __m128i);
+extern __m128i   __cdecl _mm_permutex2var_epi64(__m128i, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_permutex2var_epi64(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_mask2_permutex2var_epi64(__m256i, __m256i, __mmask8, __m256i);
+extern __m256i   __cdecl _mm256_maskz_permutex2var_epi64(__mmask8, __m256i, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_permutex2var_epi64(__m256i, __m256i, __m256i);
+extern __m128d   __cdecl _mm_mask_permutex2var_pd(__m128d, __mmask8, __m128i, __m128d);
+extern __m128d   __cdecl _mm_mask2_permutex2var_pd(__m128d, __m128i, __mmask8, __m128d);
+extern __m128d   __cdecl _mm_maskz_permutex2var_pd(__mmask8, __m128d, __m128i, __m128d);
+extern __m128d   __cdecl _mm_permutex2var_pd(__m128d, __m128i, __m128d);
+extern __m256d   __cdecl _mm256_mask_permutex2var_pd(__m256d, __mmask8, __m256i, __m256d);
+extern __m256d   __cdecl _mm256_mask2_permutex2var_pd(__m256d, __m256i, __mmask8, __m256d);
+extern __m256d   __cdecl _mm256_maskz_permutex2var_pd(__mmask8, __m256d, __m256i, __m256d);
+extern __m256d   __cdecl _mm256_permutex2var_pd(__m256d, __m256i, __m256d);
+extern __m128    __cdecl _mm_mask_permutex2var_ps(__m128, __mmask8, __m128i, __m128);
+extern __m128    __cdecl _mm_mask2_permutex2var_ps(__m128, __m128i, __mmask8, __m128);
+extern __m128    __cdecl _mm_maskz_permutex2var_ps(__mmask8, __m128, __m128i, __m128);
+extern __m128    __cdecl _mm_permutex2var_ps(__m128, __m128i, __m128);
+extern __m256    __cdecl _mm256_mask_permutex2var_ps(__m256, __mmask8, __m256i, __m256);
+extern __m256    __cdecl _mm256_mask2_permutex2var_ps(__m256, __m256i, __mmask8, __m256);
+extern __m256    __cdecl _mm256_maskz_permutex2var_ps(__mmask8, __m256, __m256i, __m256);
+extern __m256    __cdecl _mm256_permutex2var_ps(__m256, __m256i, __m256);
+extern __m128i   __cdecl _mm_mask_permutexvar_epi16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_permutexvar_epi16(__mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_permutexvar_epi16(__m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_permutexvar_epi16(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_permutexvar_epi16(__mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_permutexvar_epi16(__m256i, __m256i);
+extern __m256i   __cdecl _mm256_mask_permutexvar_epi32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_permutexvar_epi32(__mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_permutexvar_epi32(__m256i, __m256i);
+extern __m256i   __cdecl _mm256_mask_permutexvar_epi64(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_permutexvar_epi64(__mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_permutexvar_epi64(__m256i, __m256i);
+extern __m256d   __cdecl _mm256_mask_permutexvar_pd(__m256d, __mmask8, __m256i, __m256d);
+extern __m256d   __cdecl _mm256_maskz_permutexvar_pd(__mmask8, __m256i, __m256d);
+extern __m256d   __cdecl _mm256_permutexvar_pd(__m256i, __m256d);
+extern __m256    __cdecl _mm256_mask_permutexvar_ps(__m256, __mmask8, __m256i, __m256);
+extern __m256    __cdecl _mm256_maskz_permutexvar_ps(__mmask8, __m256i, __m256);
+extern __m256    __cdecl _mm256_permutexvar_ps(__m256i, __m256);
+extern __m128d   __cdecl _mm_mask_range_pd(__m128d, __mmask8, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_maskz_range_pd(__mmask8, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_range_pd(__m128d, __m128d, int);
+extern __m256d   __cdecl _mm256_mask_range_pd(__m256d, __mmask8, __m256d, __m256d, int);
+extern __m256d   __cdecl _mm256_maskz_range_pd(__mmask8, __m256d, __m256d, int);
+extern __m256d   __cdecl _mm256_range_pd(__m256d, __m256d, int);
+extern __m128    __cdecl _mm_mask_range_ps(__m128, __mmask8, __m128, __m128, int);
+extern __m128    __cdecl _mm_maskz_range_ps(__mmask8, __m128, __m128, int);
+extern __m128    __cdecl _mm_range_ps(__m128, __m128, int);
+extern __m256    __cdecl _mm256_mask_range_ps(__m256, __mmask8, __m256, __m256, int);
+extern __m256    __cdecl _mm256_maskz_range_ps(__mmask8, __m256, __m256, int);
+extern __m256    __cdecl _mm256_range_ps(__m256, __m256, int);
+extern __m128d   __cdecl _mm_mask_rcp14_pd(__m128d, __mmask8, __m128d);
+extern __m128d   __cdecl _mm_maskz_rcp14_pd(__mmask8, __m128d);
+extern __m128d   __cdecl _mm_rcp14_pd(__m128d);
+extern __m256d   __cdecl _mm256_mask_rcp14_pd(__m256d, __mmask8, __m256d);
+extern __m256d   __cdecl _mm256_maskz_rcp14_pd(__mmask8, __m256d);
+extern __m256d   __cdecl _mm256_rcp14_pd(__m256d);
+extern __m128    __cdecl _mm_mask_rcp14_ps(__m128, __mmask8, __m128);
+extern __m128    __cdecl _mm_maskz_rcp14_ps(__mmask8, __m128);
+extern __m128    __cdecl _mm_rcp14_ps(__m128);
+extern __m256    __cdecl _mm256_mask_rcp14_ps(__m256, __mmask8, __m256);
+extern __m256    __cdecl _mm256_maskz_rcp14_ps(__mmask8, __m256);
+extern __m256    __cdecl _mm256_rcp14_ps(__m256);
+extern __m128d   __cdecl _mm_mask_reduce_pd(__m128d, __mmask8, __m128d, int);
+extern __m128d   __cdecl _mm_maskz_reduce_pd(__mmask8, __m128d, int);
+extern __m128d   __cdecl _mm_reduce_pd(__m128d, int);
+extern __m256d   __cdecl _mm256_mask_reduce_pd(__m256d, __mmask8, __m256d, int);
+extern __m256d   __cdecl _mm256_maskz_reduce_pd(__mmask8, __m256d, int);
+extern __m256d   __cdecl _mm256_reduce_pd(__m256d, int);
+extern __m128    __cdecl _mm_mask_reduce_ps(__m128, __mmask8, __m128, int);
+extern __m128    __cdecl _mm_maskz_reduce_ps(__mmask8, __m128, int);
+extern __m128    __cdecl _mm_reduce_ps(__m128, int);
+extern __m256    __cdecl _mm256_mask_reduce_ps(__m256, __mmask8, __m256, int);
+extern __m256    __cdecl _mm256_maskz_reduce_ps(__mmask8, __m256, int);
+extern __m256    __cdecl _mm256_reduce_ps(__m256, int);
+extern __m128i   __cdecl _mm_mask_rol_epi32(__m128i, __mmask8, __m128i, const int);
+extern __m128i   __cdecl _mm_maskz_rol_epi32(__mmask8, __m128i, const int);
+extern __m128i   __cdecl _mm_rol_epi32(__m128i, int);
+extern __m256i   __cdecl _mm256_mask_rol_epi32(__m256i, __mmask8, __m256i, const int);
+extern __m256i   __cdecl _mm256_maskz_rol_epi32(__mmask8, __m256i, const int);
+extern __m256i   __cdecl _mm256_rol_epi32(__m256i, const int);
+extern __m128i   __cdecl _mm_mask_rol_epi64(__m128i, __mmask8, __m128i, const int);
+extern __m128i   __cdecl _mm_maskz_rol_epi64(__mmask8, __m128i, const int);
+extern __m128i   __cdecl _mm_rol_epi64(__m128i, const int);
+extern __m256i   __cdecl _mm256_mask_rol_epi64(__m256i, __mmask8, __m256i, const int);
+extern __m256i   __cdecl _mm256_maskz_rol_epi64(__mmask8, __m256i, const int);
+extern __m256i   __cdecl _mm256_rol_epi64(__m256i, const int);
+extern __m128i   __cdecl _mm_mask_rolv_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_rolv_epi32(__mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_rolv_epi32(__m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_rolv_epi32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_rolv_epi32(__mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_rolv_epi32(__m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_rolv_epi64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_rolv_epi64(__mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_rolv_epi64(__m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_rolv_epi64(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_rolv_epi64(__mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_rolv_epi64(__m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_ror_epi32(__m128i, __mmask8, __m128i, const int);
+extern __m128i   __cdecl _mm_maskz_ror_epi32(__mmask8, __m128i, const int);
+extern __m128i   __cdecl _mm_ror_epi32(__m128i, const int);
+extern __m256i   __cdecl _mm256_mask_ror_epi32(__m256i, __mmask8, __m256i, const int);
+extern __m256i   __cdecl _mm256_maskz_ror_epi32(__mmask8, __m256i, const int);
+extern __m256i   __cdecl _mm256_ror_epi32(__m256i, const int);
+extern __m128i   __cdecl _mm_mask_ror_epi64(__m128i, __mmask8, __m128i, const int);
+extern __m128i   __cdecl _mm_maskz_ror_epi64(__mmask8, __m128i, const int);
+extern __m128i   __cdecl _mm_ror_epi64(__m128i, const int);
+extern __m256i   __cdecl _mm256_mask_ror_epi64(__m256i, __mmask8, __m256i, const int);
+extern __m256i   __cdecl _mm256_maskz_ror_epi64(__mmask8, __m256i, const int);
+extern __m256i   __cdecl _mm256_ror_epi64(__m256i, const int);
+extern __m128i   __cdecl _mm_mask_rorv_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_rorv_epi32(__mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_rorv_epi32(__m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_rorv_epi32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_rorv_epi32(__mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_rorv_epi32(__m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_rorv_epi64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_rorv_epi64(__mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_rorv_epi64(__m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_rorv_epi64(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_rorv_epi64(__mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_rorv_epi64(__m256i, __m256i);
+extern __m128d   __cdecl _mm_mask_roundscale_pd(__m128d, __mmask8, __m128d, int);
+extern __m128d   __cdecl _mm_maskz_roundscale_pd(__mmask8, __m128d, int);
+extern __m128d   __cdecl _mm_roundscale_pd(__m128d, int);
+extern __m256d   __cdecl _mm256_mask_roundscale_pd(__m256d, __mmask8, __m256d, int);
+extern __m256d   __cdecl _mm256_maskz_roundscale_pd(__mmask8, __m256d, int);
+extern __m256d   __cdecl _mm256_roundscale_pd(__m256d, int);
+extern __m128    __cdecl _mm_mask_roundscale_ps(__m128, __mmask8, __m128, int);
+extern __m128    __cdecl _mm_maskz_roundscale_ps(__mmask8, __m128, int);
+extern __m128    __cdecl _mm_roundscale_ps(__m128, int);
+extern __m256    __cdecl _mm256_mask_roundscale_ps(__m256, __mmask8, __m256, int);
+extern __m256    __cdecl _mm256_maskz_roundscale_ps(__mmask8, __m256, int);
+extern __m256    __cdecl _mm256_roundscale_ps(__m256, int);
+extern __m128d   __cdecl _mm_mask_rsqrt14_pd(__m128d, __mmask8, __m128d);
+extern __m128d   __cdecl _mm_maskz_rsqrt14_pd(__mmask8, __m128d);
+extern __m256d   __cdecl _mm256_mask_rsqrt14_pd(__m256d, __mmask8, __m256d);
+extern __m256d   __cdecl _mm256_maskz_rsqrt14_pd(__mmask8, __m256d);
+extern __m128    __cdecl _mm_mask_rsqrt14_ps(__m128, __mmask8, __m128);
+extern __m128    __cdecl _mm_maskz_rsqrt14_ps(__mmask8, __m128);
+extern __m256    __cdecl _mm256_mask_rsqrt14_ps(__m256, __mmask8, __m256);
+extern __m256    __cdecl _mm256_maskz_rsqrt14_ps(__mmask8, __m256);
+extern __m128d   __cdecl _mm_mask_scalef_pd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_scalef_pd(__mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_scalef_pd(__m128d, __m128d);
+extern __m256d   __cdecl _mm256_mask_scalef_pd(__m256d, __mmask8, __m256d, __m256d);
+extern __m256d   __cdecl _mm256_maskz_scalef_pd(__mmask8, __m256d, __m256d);
+extern __m256d   __cdecl _mm256_scalef_pd(__m256d, __m256d);
+extern __m128    __cdecl _mm_mask_scalef_ps(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_scalef_ps(__mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_scalef_ps(__m128, __m128);
+extern __m256    __cdecl _mm256_mask_scalef_ps(__m256, __mmask8, __m256, __m256);
+extern __m256    __cdecl _mm256_maskz_scalef_ps(__mmask8, __m256, __m256);
+extern __m256    __cdecl _mm256_scalef_ps(__m256, __m256);
+extern __m128i   __cdecl _mm_mask_set1_epi16(__m128i, __mmask8, short);
+extern __m128i   __cdecl _mm_maskz_set1_epi16(__mmask8, short);
+extern __m256i   __cdecl _mm256_mask_set1_epi16(__m256i, __mmask16, short);
+extern __m256i   __cdecl _mm256_maskz_set1_epi16(__mmask16, short);
+extern __m128i   __cdecl _mm_mask_set1_epi32(__m128i, __mmask8, int);
+extern __m128i   __cdecl _mm_maskz_set1_epi32(__mmask8, int);
+extern __m256i   __cdecl _mm256_mask_set1_epi32(__m256i, __mmask8, int);
+extern __m256i   __cdecl _mm256_maskz_set1_epi32(__mmask8, int);
+extern __m128i   __cdecl _mm_mask_set1_epi64(__m128i, __mmask8, __int64);
+extern __m128i   __cdecl _mm_maskz_set1_epi64(__mmask8, __int64);
+extern __m256i   __cdecl _mm256_mask_set1_epi64(__m256i, __mmask8, __int64);
+extern __m256i   __cdecl _mm256_maskz_set1_epi64(__mmask8, __int64);
+extern __m128i   __cdecl _mm_mask_set1_epi8(__m128i, __mmask16, char);
+extern __m128i   __cdecl _mm_maskz_set1_epi8(__mmask16, char);
+extern __m256i   __cdecl _mm256_mask_set1_epi8(__m256i, __mmask32, char);
+extern __m256i   __cdecl _mm256_maskz_set1_epi8(__mmask32, char);
+extern __m128i   __cdecl _mm_mask_shuffle_epi32(__m128i, __mmask8, __m128i, int);
+extern __m128i   __cdecl _mm_maskz_shuffle_epi32(__mmask8, __m128i, int);
+extern __m256i   __cdecl _mm256_mask_shuffle_epi32(__m256i, __mmask8, __m256i, int);
+extern __m256i   __cdecl _mm256_maskz_shuffle_epi32(__mmask8, __m256i, int);
+extern __m128i   __cdecl _mm_mask_shuffle_epi8(__m128i, __mmask16, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_shuffle_epi8(__mmask16, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_shuffle_epi8(__m256i, __mmask32, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_shuffle_epi8(__mmask32, __m256i, __m256i);
+extern __m256    __cdecl _mm256_mask_shuffle_f32x4(__m256, __mmask8, __m256, __m256, const int);
+extern __m256    __cdecl _mm256_maskz_shuffle_f32x4(__mmask8, __m256, __m256, const int);
+extern __m256    __cdecl _mm256_shuffle_f32x4(__m256, __m256, const int);
+extern __m256d   __cdecl _mm256_mask_shuffle_f64x2(__m256d, __mmask8, __m256d, __m256d, const int);
+extern __m256d   __cdecl _mm256_maskz_shuffle_f64x2(__mmask8, __m256d, __m256d, const int);
+extern __m256d   __cdecl _mm256_shuffle_f64x2(__m256d, __m256d, const int);
+extern __m256i   __cdecl _mm256_mask_shuffle_i32x4(__m256i, __mmask8, __m256i, __m256i, const int);
+extern __m256i   __cdecl _mm256_maskz_shuffle_i32x4(__mmask8, __m256i, __m256i, const int);
+extern __m256i   __cdecl _mm256_shuffle_i32x4(__m256i, __m256i, const int);
+extern __m256i   __cdecl _mm256_mask_shuffle_i64x2(__m256i, __mmask8, __m256i, __m256i, const int);
+extern __m256i   __cdecl _mm256_maskz_shuffle_i64x2(__mmask8, __m256i, __m256i, const int);
+extern __m256i   __cdecl _mm256_shuffle_i64x2(__m256i, __m256i, const int);
+extern __m128d   __cdecl _mm_mask_shuffle_pd(__m128d, __mmask8, __m128d, __m128d, const int);
+extern __m128d   __cdecl _mm_maskz_shuffle_pd(__mmask8, __m128d, __m128d, const int);
+extern __m256d   __cdecl _mm256_mask_shuffle_pd(__m256d, __mmask8, __m256d, __m256d, const int);
+extern __m256d   __cdecl _mm256_maskz_shuffle_pd(__mmask8, __m256d, __m256d, const int);
+extern __m128    __cdecl _mm_mask_shuffle_ps(__m128, __mmask8, __m128, __m128, const int);
+extern __m128    __cdecl _mm_maskz_shuffle_ps(__mmask8, __m128, __m128, const int);
+extern __m256    __cdecl _mm256_mask_shuffle_ps(__m256, __mmask8, __m256, __m256, const int);
+extern __m256    __cdecl _mm256_maskz_shuffle_ps(__mmask8, __m256, __m256, const int);
+extern __m128i   __cdecl _mm_mask_shufflehi_epi16(__m128i, __mmask8, __m128i, int);
+extern __m128i   __cdecl _mm_maskz_shufflehi_epi16(__mmask8, __m128i, int);
+extern __m256i   __cdecl _mm256_mask_shufflehi_epi16(__m256i, __mmask16, __m256i, int);
+extern __m256i   __cdecl _mm256_maskz_shufflehi_epi16(__mmask16, __m256i, int);
+extern __m128i   __cdecl _mm_mask_shufflelo_epi16(__m128i, __mmask8, __m128i, int);
+extern __m128i   __cdecl _mm_maskz_shufflelo_epi16(__mmask8, __m128i, int);
+extern __m256i   __cdecl _mm256_mask_shufflelo_epi16(__m256i, __mmask16, __m256i, int);
+extern __m256i   __cdecl _mm256_maskz_shufflelo_epi16(__mmask16, __m256i, int);
+extern __m128i   __cdecl _mm_mask_sll_epi16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_sll_epi16(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_sll_epi16(__m256i, __mmask16, __m256i, __m128i);
+extern __m256i   __cdecl _mm256_maskz_sll_epi16(__mmask16, __m256i, __m128i);
+extern __m128i   __cdecl _mm_mask_sll_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_sll_epi32(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_sll_epi32(__m256i, __mmask8, __m256i, __m128i);
+extern __m256i   __cdecl _mm256_maskz_sll_epi32(__mmask8, __m256i, __m128i);
+extern __m128i   __cdecl _mm_mask_sll_epi64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_sll_epi64(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_sll_epi64(__m256i, __mmask8, __m256i, __m128i);
+extern __m256i   __cdecl _mm256_maskz_sll_epi64(__mmask8, __m256i, __m128i);
+extern __m128i   __cdecl _mm_mask_slli_epi16(__m128i, __mmask8, __m128i, unsigned int);
+extern __m128i   __cdecl _mm_maskz_slli_epi16(__mmask8, __m128i, unsigned int);
+extern __m256i   __cdecl _mm256_mask_slli_epi16(__m256i, __mmask16, __m256i, unsigned int);
+extern __m256i   __cdecl _mm256_maskz_slli_epi16(__mmask16, __m256i, unsigned int);
+extern __m128i   __cdecl _mm_mask_slli_epi32(__m128i, __mmask8, __m128i, unsigned int);
+extern __m128i   __cdecl _mm_maskz_slli_epi32(__mmask8, __m128i, unsigned int);
+extern __m256i   __cdecl _mm256_mask_slli_epi32(__m256i, __mmask8, __m256i, unsigned int);
+extern __m256i   __cdecl _mm256_maskz_slli_epi32(__mmask8, __m256i, unsigned int);
+extern __m128i   __cdecl _mm_mask_slli_epi64(__m128i, __mmask8, __m128i, unsigned int);
+extern __m128i   __cdecl _mm_maskz_slli_epi64(__mmask8, __m128i, unsigned int);
+extern __m256i   __cdecl _mm256_mask_slli_epi64(__m256i, __mmask8, __m256i, unsigned int);
+extern __m256i   __cdecl _mm256_maskz_slli_epi64(__mmask8, __m256i, unsigned int);
+extern __m128i   __cdecl _mm_mask_sllv_epi16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_sllv_epi16(__mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_sllv_epi16(__m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_sllv_epi16(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_sllv_epi16(__mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_sllv_epi16(__m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_sllv_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_sllv_epi32(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_sllv_epi32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_sllv_epi32(__mmask8, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_sllv_epi64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_sllv_epi64(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_sllv_epi64(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_sllv_epi64(__mmask8, __m256i, __m256i);
+extern __m128d   __cdecl _mm_mask_sqrt_pd(__m128d, __mmask8, __m128d);
+extern __m128d   __cdecl _mm_maskz_sqrt_pd(__mmask8, __m128d);
+extern __m256d   __cdecl _mm256_mask_sqrt_pd(__m256d, __mmask8, __m256d);
+extern __m256d   __cdecl _mm256_maskz_sqrt_pd(__mmask8, __m256d);
+extern __m128    __cdecl _mm_mask_sqrt_ps(__m128, __mmask8, __m128);
+extern __m128    __cdecl _mm_maskz_sqrt_ps(__mmask8, __m128);
+extern __m256    __cdecl _mm256_mask_sqrt_ps(__m256, __mmask8, __m256);
+extern __m256    __cdecl _mm256_maskz_sqrt_ps(__mmask8, __m256);
+extern __m128i   __cdecl _mm_mask_sra_epi16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_sra_epi16(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_sra_epi16(__m256i, __mmask16, __m256i, __m128i);
+extern __m256i   __cdecl _mm256_maskz_sra_epi16(__mmask16, __m256i, __m128i);
+extern __m128i   __cdecl _mm_mask_sra_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_sra_epi32(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_sra_epi32(__m256i, __mmask8, __m256i, __m128i);
+extern __m256i   __cdecl _mm256_maskz_sra_epi32(__mmask8, __m256i, __m128i);
+extern __m128i   __cdecl _mm_mask_sra_epi64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_sra_epi64(__mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_sra_epi64(__m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_sra_epi64(__m256i, __mmask8, __m256i, __m128i);
+extern __m256i   __cdecl _mm256_maskz_sra_epi64(__mmask8, __m256i, __m128i);
+extern __m256i   __cdecl _mm256_sra_epi64(__m256i, __m128i);
+extern __m128i   __cdecl _mm_mask_srai_epi16(__m128i, __mmask8, __m128i, unsigned int);
+extern __m128i   __cdecl _mm_maskz_srai_epi16(__mmask8, __m128i, unsigned int);
+extern __m256i   __cdecl _mm256_mask_srai_epi16(__m256i, __mmask16, __m256i, unsigned int);
+extern __m256i   __cdecl _mm256_maskz_srai_epi16(__mmask16, __m256i, unsigned int);
+extern __m128i   __cdecl _mm_mask_srai_epi32(__m128i, __mmask8, __m128i, unsigned int);
+extern __m128i   __cdecl _mm_maskz_srai_epi32(__mmask8, __m128i, unsigned int);
+extern __m256i   __cdecl _mm256_mask_srai_epi32(__m256i, __mmask8, __m256i, unsigned int);
+extern __m256i   __cdecl _mm256_maskz_srai_epi32(__mmask8, __m256i, unsigned int);
+extern __m128i   __cdecl _mm_mask_srai_epi64(__m128i, __mmask8, __m128i, unsigned int);
+extern __m128i   __cdecl _mm_maskz_srai_epi64(__mmask8, __m128i, unsigned int);
+extern __m128i   __cdecl _mm_srai_epi64(__m128i, unsigned int);
+extern __m256i   __cdecl _mm256_mask_srai_epi64(__m256i, __mmask8, __m256i, unsigned int);
+extern __m256i   __cdecl _mm256_maskz_srai_epi64(__mmask8, __m256i, unsigned int);
+extern __m256i   __cdecl _mm256_srai_epi64(__m256i, unsigned int);
+extern __m128i   __cdecl _mm_mask_srav_epi16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_srav_epi16(__mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_srav_epi16(__m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_srav_epi16(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_srav_epi16(__mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_srav_epi16(__m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_srav_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_srav_epi32(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_srav_epi32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_srav_epi32(__mmask8, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_srav_epi64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_srav_epi64(__mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_srav_epi64(__m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_srav_epi64(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_srav_epi64(__mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_srav_epi64(__m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_srl_epi16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_srl_epi16(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_srl_epi16(__m256i, __mmask16, __m256i, __m128i);
+extern __m256i   __cdecl _mm256_maskz_srl_epi16(__mmask16, __m256i, __m128i);
+extern __m128i   __cdecl _mm_mask_srl_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_srl_epi32(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_srl_epi32(__m256i, __mmask8, __m256i, __m128i);
+extern __m256i   __cdecl _mm256_maskz_srl_epi32(__mmask8, __m256i, __m128i);
+extern __m128i   __cdecl _mm_mask_srl_epi64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_srl_epi64(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_srl_epi64(__m256i, __mmask8, __m256i, __m128i);
+extern __m256i   __cdecl _mm256_maskz_srl_epi64(__mmask8, __m256i, __m128i);
+extern __m128i   __cdecl _mm_mask_srli_epi16(__m128i, __mmask8, __m128i, int);
+extern __m128i   __cdecl _mm_maskz_srli_epi16(__mmask8, __m128i, int);
+extern __m256i   __cdecl _mm256_mask_srli_epi16(__m256i, __mmask16, __m256i, int);
+extern __m256i   __cdecl _mm256_maskz_srli_epi16(__mmask16, __m256i, int);
+extern __m128i   __cdecl _mm_mask_srli_epi32(__m128i, __mmask8, __m128i, unsigned int);
+extern __m128i   __cdecl _mm_maskz_srli_epi32(__mmask8, __m128i, unsigned int);
+extern __m256i   __cdecl _mm256_mask_srli_epi32(__m256i, __mmask8, __m256i, unsigned int);
+extern __m256i   __cdecl _mm256_maskz_srli_epi32(__mmask8, __m256i, unsigned int);
+extern __m128i   __cdecl _mm_mask_srli_epi64(__m128i, __mmask8, __m128i, unsigned int);
+extern __m128i   __cdecl _mm_maskz_srli_epi64(__mmask8, __m128i, unsigned int);
+extern __m256i   __cdecl _mm256_mask_srli_epi64(__m256i, __mmask8, __m256i, unsigned int);
+extern __m256i   __cdecl _mm256_maskz_srli_epi64(__mmask8, __m256i, unsigned int);
+extern __m128i   __cdecl _mm_mask_srlv_epi16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_srlv_epi16(__mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_srlv_epi16(__m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_srlv_epi16(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_srlv_epi16(__mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_srlv_epi16(__m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_srlv_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_srlv_epi32(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_srlv_epi32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_srlv_epi32(__mmask8, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_srlv_epi64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_srlv_epi64(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_srlv_epi64(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_srlv_epi64(__mmask8, __m256i, __m256i);
+extern void      __cdecl _mm_mask_store_epi32(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_store_epi32(void*, __mmask8, __m256i);
+extern void      __cdecl _mm_mask_store_epi64(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_store_epi64(void*, __mmask8, __m256i);
+extern void      __cdecl _mm_mask_store_pd(void*, __mmask8, __m128d);
+extern void      __cdecl _mm256_mask_store_pd(void*, __mmask8, __m256d);
+extern void      __cdecl _mm_mask_store_ps(void*, __mmask8, __m128);
+extern void      __cdecl _mm256_mask_store_ps(void*, __mmask8, __m256);
+extern void      __cdecl _mm_storeu_epi16(void*, __m128i);
+extern void      __cdecl _mm256_storeu_epi16(void*, __m256i);
+extern void      __cdecl _mm_mask_storeu_epi16(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_storeu_epi16(void*, __mmask16, __m256i);
+extern void      __cdecl _mm_storeu_epi32(void*, __m128i);
+extern void      __cdecl _mm256_storeu_epi32(void*, __m256i);
+extern void      __cdecl _mm_mask_storeu_epi32(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_storeu_epi32(void*, __mmask8, __m256i);
+extern void      __cdecl _mm_storeu_epi64(void*, __m128i);
+extern void      __cdecl _mm256_storeu_epi64(void*, __m256i);
+extern void      __cdecl _mm_mask_storeu_epi64(void*, __mmask8, __m128i);
+extern void      __cdecl _mm256_mask_storeu_epi64(void*, __mmask8, __m256i);
+extern void      __cdecl _mm_storeu_epi8(void*, __m128i);
+extern void      __cdecl _mm256_storeu_epi8(void*, __m256i);
+extern void      __cdecl _mm_mask_storeu_epi8(void*, __mmask16, __m128i);
+extern void      __cdecl _mm256_mask_storeu_epi8(void*, __mmask32, __m256i);
+extern void      __cdecl _mm_mask_storeu_pd(void*, __mmask8, __m128d);
+extern void      __cdecl _mm256_mask_storeu_pd(void*, __mmask8, __m256d);
+extern void      __cdecl _mm_mask_storeu_ps(void*, __mmask8, __m128);
+extern void      __cdecl _mm256_mask_storeu_ps(void*, __mmask8, __m256);
+extern __m128i   __cdecl _mm_mask_sub_epi16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_sub_epi16(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_sub_epi16(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_sub_epi16(__mmask16, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_sub_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_sub_epi32(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_sub_epi32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_sub_epi32(__mmask8, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_sub_epi64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_sub_epi64(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_sub_epi64(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_sub_epi64(__mmask8, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_sub_epi8(__m128i, __mmask16, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_sub_epi8(__mmask16, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_sub_epi8(__m256i, __mmask32, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_sub_epi8(__mmask32, __m256i, __m256i);
+extern __m128d   __cdecl _mm_mask_sub_pd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_sub_pd(__mmask8, __m128d, __m128d);
+extern __m256d   __cdecl _mm256_mask_sub_pd(__m256d, __mmask8, __m256d, __m256d);
+extern __m256d   __cdecl _mm256_maskz_sub_pd(__mmask8, __m256d, __m256d);
+extern __m128    __cdecl _mm_mask_sub_ps(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_sub_ps(__mmask8, __m128, __m128);
+extern __m256    __cdecl _mm256_mask_sub_ps(__m256, __mmask8, __m256, __m256);
+extern __m256    __cdecl _mm256_maskz_sub_ps(__mmask8, __m256, __m256);
+extern __m128i   __cdecl _mm_mask_subs_epi16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_subs_epi16(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_subs_epi16(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_subs_epi16(__mmask16, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_subs_epi8(__m128i, __mmask16, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_subs_epi8(__mmask16, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_subs_epi8(__m256i, __mmask32, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_subs_epi8(__mmask32, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_subs_epu16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_subs_epu16(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_subs_epu16(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_subs_epu16(__mmask16, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_subs_epu8(__m128i, __mmask16, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_subs_epu8(__mmask16, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_subs_epu8(__m256i, __mmask32, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_subs_epu8(__mmask32, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_ternarylogic_epi32(__m128i, __mmask8, __m128i, __m128i, int);
+extern __m128i   __cdecl _mm_maskz_ternarylogic_epi32(__mmask8, __m128i, __m128i, __m128i, int);
+extern __m128i   __cdecl _mm_ternarylogic_epi32(__m128i, __m128i, __m128i, int);
+extern __m256i   __cdecl _mm256_mask_ternarylogic_epi32(__m256i, __mmask8, __m256i, __m256i, int);
+extern __m256i   __cdecl _mm256_maskz_ternarylogic_epi32(__mmask8, __m256i, __m256i, __m256i, int);
+extern __m256i   __cdecl _mm256_ternarylogic_epi32(__m256i, __m256i, __m256i, int);
+extern __m128i   __cdecl _mm_mask_ternarylogic_epi64(__m128i, __mmask8, __m128i, __m128i, int);
+extern __m128i   __cdecl _mm_maskz_ternarylogic_epi64(__mmask8, __m128i, __m128i, __m128i, int);
+extern __m128i   __cdecl _mm_ternarylogic_epi64(__m128i, __m128i, __m128i, int);
+extern __m256i   __cdecl _mm256_mask_ternarylogic_epi64(__m256i, __mmask8, __m256i, __m256i, int);
+extern __m256i   __cdecl _mm256_maskz_ternarylogic_epi64(__mmask8, __m256i, __m256i, __m256i, int);
+extern __m256i   __cdecl _mm256_ternarylogic_epi64(__m256i, __m256i, __m256i, int);
+extern __mmask8  __cdecl _mm_mask_test_epi16_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_test_epi16_mask(__m128i, __m128i);
+extern __mmask16 __cdecl _mm256_mask_test_epi16_mask(__mmask16, __m256i, __m256i);
+extern __mmask16 __cdecl _mm256_test_epi16_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm_mask_test_epi32_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_test_epi32_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm256_mask_test_epi32_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_test_epi32_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm_mask_test_epi64_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_test_epi64_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm256_mask_test_epi64_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_test_epi64_mask(__m256i, __m256i);
+extern __mmask16 __cdecl _mm_mask_test_epi8_mask(__mmask16, __m128i, __m128i);
+extern __mmask16 __cdecl _mm_test_epi8_mask(__m128i, __m128i);
+extern __mmask32 __cdecl _mm256_mask_test_epi8_mask(__mmask32, __m256i, __m256i);
+extern __mmask32 __cdecl _mm256_test_epi8_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm_mask_testn_epi16_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_testn_epi16_mask(__m128i, __m128i);
+extern __mmask16 __cdecl _mm256_mask_testn_epi16_mask(__mmask16, __m256i, __m256i);
+extern __mmask16 __cdecl _mm256_testn_epi16_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm_mask_testn_epi32_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_testn_epi32_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm256_mask_testn_epi32_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_testn_epi32_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm_mask_testn_epi64_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_testn_epi64_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm256_mask_testn_epi64_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_testn_epi64_mask(__m256i, __m256i);
+extern __mmask16 __cdecl _mm_mask_testn_epi8_mask(__mmask16, __m128i, __m128i);
+extern __mmask16 __cdecl _mm_testn_epi8_mask(__m128i, __m128i);
+extern __mmask32 __cdecl _mm256_mask_testn_epi8_mask(__mmask32, __m256i, __m256i);
+extern __mmask32 __cdecl _mm256_testn_epi8_mask(__m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_unpackhi_epi16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_unpackhi_epi16(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_unpackhi_epi16(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_unpackhi_epi16(__mmask16, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_unpackhi_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_unpackhi_epi32(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_unpackhi_epi32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_unpackhi_epi32(__mmask8, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_unpackhi_epi64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_unpackhi_epi64(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_unpackhi_epi64(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_unpackhi_epi64(__mmask8, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_unpackhi_epi8(__m128i, __mmask16, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_unpackhi_epi8(__mmask16, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_unpackhi_epi8(__m256i, __mmask32, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_unpackhi_epi8(__mmask32, __m256i, __m256i);
+extern __m128d   __cdecl _mm_mask_unpackhi_pd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_unpackhi_pd(__mmask8, __m128d, __m128d);
+extern __m256d   __cdecl _mm256_mask_unpackhi_pd(__m256d, __mmask8, __m256d, __m256d);
+extern __m256d   __cdecl _mm256_maskz_unpackhi_pd(__mmask8, __m256d, __m256d);
+extern __m128    __cdecl _mm_mask_unpackhi_ps(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_unpackhi_ps(__mmask8, __m128, __m128);
+extern __m256    __cdecl _mm256_mask_unpackhi_ps(__m256, __mmask8, __m256, __m256);
+extern __m256    __cdecl _mm256_maskz_unpackhi_ps(__mmask8, __m256, __m256);
+extern __m128i   __cdecl _mm_mask_unpacklo_epi16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_unpacklo_epi16(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_unpacklo_epi16(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_unpacklo_epi16(__mmask16, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_unpacklo_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_unpacklo_epi32(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_unpacklo_epi32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_unpacklo_epi32(__mmask8, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_unpacklo_epi64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_unpacklo_epi64(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_unpacklo_epi64(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_unpacklo_epi64(__mmask8, __m256i, __m256i);
+extern __m128i   __cdecl _mm_mask_unpacklo_epi8(__m128i, __mmask16, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_unpacklo_epi8(__mmask16, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_mask_unpacklo_epi8(__m256i, __mmask32, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_unpacklo_epi8(__mmask32, __m256i, __m256i);
+extern __m128d   __cdecl _mm_mask_unpacklo_pd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_unpacklo_pd(__mmask8, __m128d, __m128d);
+extern __m256d   __cdecl _mm256_mask_unpacklo_pd(__m256d, __mmask8, __m256d, __m256d);
+extern __m256d   __cdecl _mm256_maskz_unpacklo_pd(__mmask8, __m256d, __m256d);
+extern __m128    __cdecl _mm_mask_unpacklo_ps(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_unpacklo_ps(__mmask8, __m128, __m128);
+extern __m256    __cdecl _mm256_mask_unpacklo_ps(__m256, __mmask8, __m256, __m256);
+extern __m256    __cdecl _mm256_maskz_unpacklo_ps(__mmask8, __m256, __m256);
+extern __m128i   __cdecl _mm_xor_epi32(__m128i, __m128i);
+extern __m128i   __cdecl _mm_mask_xor_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_xor_epi32(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_xor_epi32(__m256i, __m256i);
+extern __m256i   __cdecl _mm256_mask_xor_epi32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_xor_epi32(__mmask8, __m256i, __m256i);
+extern __m128i   __cdecl _mm_xor_epi64(__m128i, __m128i);
+extern __m128i   __cdecl _mm_mask_xor_epi64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i   __cdecl _mm_maskz_xor_epi64(__mmask8, __m128i, __m128i);
+extern __m256i   __cdecl _mm256_xor_epi64(__m256i, __m256i);
+extern __m256i   __cdecl _mm256_mask_xor_epi64(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i   __cdecl _mm256_maskz_xor_epi64(__mmask8, __m256i, __m256i);
+extern __m128d   __cdecl _mm_mask_xor_pd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_xor_pd(__mmask8, __m128d, __m128d);
+extern __m256d   __cdecl _mm256_mask_xor_pd(__m256d, __mmask8, __m256d, __m256d);
+extern __m256d   __cdecl _mm256_maskz_xor_pd(__mmask8, __m256d, __m256d);
+extern __m128    __cdecl _mm_mask_xor_ps(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_xor_ps(__mmask8, __m128, __m128);
+extern __m256    __cdecl _mm256_mask_xor_ps(__m256, __mmask8, __m256, __m256);
+extern __m256    __cdecl _mm256_maskz_xor_ps(__mmask8, __m256, __m256);
+
+extern __mmask16  __cdecl _mm_cmpeq_epi8_mask(__m128i, __m128i);
+extern __mmask16  __cdecl _mm_cmpge_epi8_mask(__m128i, __m128i);
+extern __mmask16  __cdecl _mm_cmpgt_epi8_mask(__m128i, __m128i);
+extern __mmask16  __cdecl _mm_cmple_epi8_mask(__m128i, __m128i);
+extern __mmask16  __cdecl _mm_cmplt_epi8_mask(__m128i, __m128i);
+extern __mmask16  __cdecl _mm_cmpneq_epi8_mask(__m128i, __m128i);
+extern __mmask16  __cdecl _mm_cmpeq_epu8_mask(__m128i, __m128i);
+extern __mmask16  __cdecl _mm_cmpge_epu8_mask(__m128i, __m128i);
+extern __mmask16  __cdecl _mm_cmpgt_epu8_mask(__m128i, __m128i);
+extern __mmask16  __cdecl _mm_cmple_epu8_mask(__m128i, __m128i);
+extern __mmask16  __cdecl _mm_cmplt_epu8_mask(__m128i, __m128i);
+extern __mmask16  __cdecl _mm_cmpneq_epu8_mask(__m128i, __m128i);
+
+extern __mmask16  __cdecl _mm_mask_cmpeq_epi8_mask(__mmask16, __m128i, __m128i);
+extern __mmask16  __cdecl _mm_mask_cmpge_epi8_mask(__mmask16, __m128i, __m128i);
+extern __mmask16  __cdecl _mm_mask_cmpgt_epi8_mask(__mmask16, __m128i, __m128i);
+extern __mmask16  __cdecl _mm_mask_cmple_epi8_mask(__mmask16, __m128i, __m128i);
+extern __mmask16  __cdecl _mm_mask_cmplt_epi8_mask(__mmask16, __m128i, __m128i);
+extern __mmask16  __cdecl _mm_mask_cmpneq_epi8_mask(__mmask16, __m128i, __m128i);
+extern __mmask16  __cdecl _mm_mask_cmpeq_epu8_mask(__mmask16, __m128i, __m128i);
+extern __mmask16  __cdecl _mm_mask_cmpge_epu8_mask(__mmask16, __m128i, __m128i);
+extern __mmask16  __cdecl _mm_mask_cmpgt_epu8_mask(__mmask16, __m128i, __m128i);
+extern __mmask16  __cdecl _mm_mask_cmple_epu8_mask(__mmask16, __m128i, __m128i);
+extern __mmask16  __cdecl _mm_mask_cmplt_epu8_mask(__mmask16, __m128i, __m128i);
+extern __mmask16  __cdecl _mm_mask_cmpneq_epu8_mask(__mmask16, __m128i, __m128i);
+
+extern __mmask8  __cdecl _mm_cmpeq_epi16_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmpge_epi16_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmpgt_epi16_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmple_epi16_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmplt_epi16_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmpneq_epi16_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmpeq_epu16_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmpge_epu16_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmpgt_epu16_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmple_epu16_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmplt_epu16_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmpneq_epu16_mask(__m128i, __m128i);
+
+extern __mmask8  __cdecl _mm_mask_cmpeq_epi16_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmpge_epi16_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmpgt_epi16_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmple_epi16_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmplt_epi16_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmpneq_epi16_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmpeq_epu16_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmpge_epu16_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmpgt_epu16_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmple_epu16_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmplt_epu16_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmpneq_epu16_mask(__mmask8, __m128i, __m128i);
+
+extern __mmask8  __cdecl _mm_cmpeq_epi32_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmpge_epi32_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmpgt_epi32_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmple_epi32_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmplt_epi32_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmpneq_epi32_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmpeq_epu32_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmpge_epu32_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmpgt_epu32_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmple_epu32_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmplt_epu32_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmpneq_epu32_mask(__m128i, __m128i);
+
+extern __mmask8  __cdecl _mm_mask_cmpeq_epi32_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmpge_epi32_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmpgt_epi32_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmple_epi32_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmplt_epi32_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmpneq_epi32_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmpeq_epu32_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmpge_epu32_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmpgt_epu32_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmple_epu32_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmplt_epu32_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmpneq_epu32_mask(__mmask8, __m128i, __m128i);
+
+extern __mmask8  __cdecl _mm_cmpeq_epi64_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmpge_epi64_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmpgt_epi64_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmple_epi64_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmplt_epi64_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmpneq_epi64_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmpeq_epu64_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmpge_epu64_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmpgt_epu64_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmple_epu64_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmplt_epu64_mask(__m128i, __m128i);
+extern __mmask8  __cdecl _mm_cmpneq_epu64_mask(__m128i, __m128i);
+
+extern __mmask8  __cdecl _mm_mask_cmpeq_epi64_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmpge_epi64_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmpgt_epi64_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmple_epi64_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmplt_epi64_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmpneq_epi64_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmpeq_epu64_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmpge_epu64_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmpgt_epu64_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmple_epu64_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmplt_epu64_mask(__mmask8, __m128i, __m128i);
+extern __mmask8  __cdecl _mm_mask_cmpneq_epu64_mask(__mmask8, __m128i, __m128i);
+
+extern __mmask32  __cdecl _mm256_cmpeq_epi8_mask(__m256i, __m256i);
+extern __mmask32  __cdecl _mm256_cmpge_epi8_mask(__m256i, __m256i);
+extern __mmask32  __cdecl _mm256_cmpgt_epi8_mask(__m256i, __m256i);
+extern __mmask32  __cdecl _mm256_cmple_epi8_mask(__m256i, __m256i);
+extern __mmask32  __cdecl _mm256_cmplt_epi8_mask(__m256i, __m256i);
+extern __mmask32  __cdecl _mm256_cmpneq_epi8_mask(__m256i, __m256i);
+extern __mmask32  __cdecl _mm256_cmpeq_epu8_mask(__m256i, __m256i);
+extern __mmask32  __cdecl _mm256_cmpge_epu8_mask(__m256i, __m256i);
+extern __mmask32  __cdecl _mm256_cmpgt_epu8_mask(__m256i, __m256i);
+extern __mmask32  __cdecl _mm256_cmple_epu8_mask(__m256i, __m256i);
+extern __mmask32  __cdecl _mm256_cmplt_epu8_mask(__m256i, __m256i);
+extern __mmask32  __cdecl _mm256_cmpneq_epu8_mask(__m256i, __m256i);
+
+extern __mmask32  __cdecl _mm256_mask_cmpeq_epi8_mask(__mmask32, __m256i, __m256i);
+extern __mmask32  __cdecl _mm256_mask_cmpge_epi8_mask(__mmask32, __m256i, __m256i);
+extern __mmask32  __cdecl _mm256_mask_cmpgt_epi8_mask(__mmask32, __m256i, __m256i);
+extern __mmask32  __cdecl _mm256_mask_cmple_epi8_mask(__mmask32, __m256i, __m256i);
+extern __mmask32  __cdecl _mm256_mask_cmplt_epi8_mask(__mmask32, __m256i, __m256i);
+extern __mmask32  __cdecl _mm256_mask_cmpneq_epi8_mask(__mmask32, __m256i, __m256i);
+extern __mmask32  __cdecl _mm256_mask_cmpeq_epu8_mask(__mmask32, __m256i, __m256i);
+extern __mmask32  __cdecl _mm256_mask_cmpge_epu8_mask(__mmask32, __m256i, __m256i);
+extern __mmask32  __cdecl _mm256_mask_cmpgt_epu8_mask(__mmask32, __m256i, __m256i);
+extern __mmask32  __cdecl _mm256_mask_cmple_epu8_mask(__mmask32, __m256i, __m256i);
+extern __mmask32  __cdecl _mm256_mask_cmplt_epu8_mask(__mmask32, __m256i, __m256i);
+extern __mmask32  __cdecl _mm256_mask_cmpneq_epu8_mask(__mmask32, __m256i, __m256i);
+
+extern __mmask16  __cdecl _mm256_cmpeq_epi16_mask(__m256i, __m256i);
+extern __mmask16  __cdecl _mm256_cmpge_epi16_mask(__m256i, __m256i);
+extern __mmask16  __cdecl _mm256_cmpgt_epi16_mask(__m256i, __m256i);
+extern __mmask16  __cdecl _mm256_cmple_epi16_mask(__m256i, __m256i);
+extern __mmask16  __cdecl _mm256_cmplt_epi16_mask(__m256i, __m256i);
+extern __mmask16  __cdecl _mm256_cmpneq_epi16_mask(__m256i, __m256i);
+extern __mmask16  __cdecl _mm256_cmpeq_epu16_mask(__m256i, __m256i);
+extern __mmask16  __cdecl _mm256_cmpge_epu16_mask(__m256i, __m256i);
+extern __mmask16  __cdecl _mm256_cmpgt_epu16_mask(__m256i, __m256i);
+extern __mmask16  __cdecl _mm256_cmple_epu16_mask(__m256i, __m256i);
+extern __mmask16  __cdecl _mm256_cmplt_epu16_mask(__m256i, __m256i);
+extern __mmask16  __cdecl _mm256_cmpneq_epu16_mask(__m256i, __m256i);
+
+extern __mmask16  __cdecl _mm256_mask_cmpeq_epi16_mask(__mmask16, __m256i, __m256i);
+extern __mmask16  __cdecl _mm256_mask_cmpge_epi16_mask(__mmask16, __m256i, __m256i);
+extern __mmask16  __cdecl _mm256_mask_cmpgt_epi16_mask(__mmask16, __m256i, __m256i);
+extern __mmask16  __cdecl _mm256_mask_cmple_epi16_mask(__mmask16, __m256i, __m256i);
+extern __mmask16  __cdecl _mm256_mask_cmplt_epi16_mask(__mmask16, __m256i, __m256i);
+extern __mmask16  __cdecl _mm256_mask_cmpneq_epi16_mask(__mmask16, __m256i, __m256i);
+extern __mmask16  __cdecl _mm256_mask_cmpeq_epu16_mask(__mmask16, __m256i, __m256i);
+extern __mmask16  __cdecl _mm256_mask_cmpge_epu16_mask(__mmask16, __m256i, __m256i);
+extern __mmask16  __cdecl _mm256_mask_cmpgt_epu16_mask(__mmask16, __m256i, __m256i);
+extern __mmask16  __cdecl _mm256_mask_cmple_epu16_mask(__mmask16, __m256i, __m256i);
+extern __mmask16  __cdecl _mm256_mask_cmplt_epu16_mask(__mmask16, __m256i, __m256i);
+extern __mmask16  __cdecl _mm256_mask_cmpneq_epu16_mask(__mmask16, __m256i, __m256i);
+
+extern __mmask8  __cdecl _mm256_cmpeq_epi32_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm256_cmpge_epi32_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm256_cmpgt_epi32_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm256_cmple_epi32_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm256_cmplt_epi32_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm256_cmpneq_epi32_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm256_cmpeq_epu32_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm256_cmpge_epu32_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm256_cmpgt_epu32_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm256_cmple_epu32_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm256_cmplt_epu32_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm256_cmpneq_epu32_mask(__m256i, __m256i);
+
+extern __mmask8  __cdecl _mm256_mask_cmpeq_epi32_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_mask_cmpge_epi32_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_mask_cmpgt_epi32_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_mask_cmple_epi32_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_mask_cmplt_epi32_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_mask_cmpneq_epi32_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_mask_cmpeq_epu32_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_mask_cmpge_epu32_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_mask_cmpgt_epu32_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_mask_cmple_epu32_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_mask_cmplt_epu32_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_mask_cmpneq_epu32_mask(__mmask8, __m256i, __m256i);
+
+extern __mmask8  __cdecl _mm256_cmpeq_epi64_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm256_cmpge_epi64_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm256_cmpgt_epi64_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm256_cmple_epi64_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm256_cmplt_epi64_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm256_cmpneq_epi64_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm256_cmpeq_epu64_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm256_cmpge_epu64_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm256_cmpgt_epu64_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm256_cmple_epu64_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm256_cmplt_epu64_mask(__m256i, __m256i);
+extern __mmask8  __cdecl _mm256_cmpneq_epu64_mask(__m256i, __m256i);
+
+extern __mmask8  __cdecl _mm256_mask_cmpeq_epi64_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_mask_cmpge_epi64_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_mask_cmpgt_epi64_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_mask_cmple_epi64_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_mask_cmplt_epi64_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_mask_cmpneq_epi64_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_mask_cmpeq_epu64_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_mask_cmpge_epu64_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_mask_cmpgt_epu64_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_mask_cmple_epu64_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_mask_cmplt_epu64_mask(__mmask8, __m256i, __m256i);
+extern __mmask8  __cdecl _mm256_mask_cmpneq_epu64_mask(__mmask8, __m256i, __m256i);
+
+// AVX-512 scalar functions
+extern __m128d   __cdecl _mm_add_round_sd(__m128d, __m128d, int);
+extern __m128d   __cdecl _mm_mask_add_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_maskz_add_round_sd(__mmask8, __m128d, __m128d, int);
+extern __m128    __cdecl _mm_add_round_ss(__m128, __m128, int);
+extern __m128    __cdecl _mm_mask_add_round_ss(__m128, __mmask8, __m128, __m128, int);
+extern __m128    __cdecl _mm_maskz_add_round_ss(__mmask8, __m128, __m128, int);
+extern __m128d   __cdecl _mm_mask_add_sd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_add_sd(__mmask8, __m128d, __m128d);
+extern __m128    __cdecl _mm_mask_add_ss(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_add_ss(__mmask8, __m128, __m128);
+extern __mmask8  __cdecl _mm_cmp_round_sd_mask(__m128d, __m128d, const int, const int);
+extern __mmask8  __cdecl _mm_mask_cmp_round_sd_mask(__mmask8, __m128d, __m128d, const int, const int);
+extern __mmask8  __cdecl _mm_cmp_round_ss_mask(__m128, __m128, const int, const int);
+extern __mmask8  __cdecl _mm_mask_cmp_round_ss_mask(__mmask8, __m128, __m128, const int, const int);
+extern __mmask8  __cdecl _mm_cmp_sd_mask(__m128d, __m128d, const int);
+extern __mmask8  __cdecl _mm_mask_cmp_sd_mask(__mmask8, __m128d, __m128d, const int);
+extern __mmask8  __cdecl _mm_cmp_ss_mask(__m128, __m128, const int);
+extern __mmask8  __cdecl _mm_mask_cmp_ss_mask(__mmask8, __m128, __m128, const int);
+extern int       __cdecl _mm_comi_round_sd(__m128d, __m128d, const int, const int);
+extern int       __cdecl _mm_comi_round_ss(__m128, __m128, const int, const int);
+extern __m128    __cdecl _mm_cvt_roundi32_ss(__m128, int, int);
+extern int       __cdecl _mm_cvt_roundsd_i32(__m128d, int);
+extern int       __cdecl _mm_cvt_roundsd_si32(__m128d, int);
+extern __m128    __cdecl _mm_cvt_roundsd_ss(__m128, __m128d, int);
+extern __m128    __cdecl _mm_mask_cvt_roundsd_ss(__m128, __mmask8, __m128, __m128d, int);
+extern __m128    __cdecl _mm_maskz_cvt_roundsd_ss(__mmask8, __m128, __m128d, int);
+extern unsigned int __cdecl _mm_cvt_roundsd_u32(__m128d, int);
+extern __m128    __cdecl _mm_cvt_roundsi32_ss(__m128, int, int);
+extern int       __cdecl _mm_cvt_roundss_i32(__m128, int);
+extern __m128d   __cdecl _mm_cvt_roundss_sd(__m128d, __m128, int);
+extern __m128d   __cdecl _mm_mask_cvt_roundss_sd(__m128d, __mmask8, __m128d, __m128, int);
+extern __m128d   __cdecl _mm_maskz_cvt_roundss_sd(__mmask8, __m128d, __m128, int);
+extern int       __cdecl _mm_cvt_roundss_si32(__m128, int);
+extern unsigned int __cdecl _mm_cvt_roundss_u32(__m128, int);
+extern __m128    __cdecl _mm_cvt_roundu32_ss(__m128, unsigned int, int);
+extern __m128d   __cdecl _mm_cvti32_sd(__m128d, int);
+extern __m128    __cdecl _mm_cvti32_ss(__m128, int);
+extern int       __cdecl _mm_cvtsd_i32(__m128d);
+extern __m128    __cdecl _mm_mask_cvtsd_ss(__m128, __mmask8, __m128, __m128d);
+extern __m128    __cdecl _mm_maskz_cvtsd_ss(__mmask8, __m128, __m128d);
+extern unsigned int __cdecl _mm_cvtsd_u32(__m128d);
+extern int       __cdecl _mm_cvtss_i32(__m128);
+extern __m128d   __cdecl _mm_mask_cvtss_sd(__m128d, __mmask8, __m128d, __m128);
+extern __m128d   __cdecl _mm_maskz_cvtss_sd(__mmask8, __m128d, __m128);
+extern unsigned int __cdecl _mm_cvtss_u32(__m128);
+extern int       __cdecl _mm_cvtt_roundsd_i32(__m128d, int);
+extern int       __cdecl _mm_cvtt_roundsd_si32(__m128d, int);
+extern unsigned int __cdecl _mm_cvtt_roundsd_u32(__m128d, int);
+extern int       __cdecl _mm_cvtt_roundss_i32(__m128, int);
+extern int       __cdecl _mm_cvtt_roundss_si32(__m128, int);
+extern unsigned int __cdecl _mm_cvtt_roundss_u32(__m128, int);
+extern int       __cdecl _mm_cvttsd_i32(__m128d);
+extern unsigned int __cdecl _mm_cvttsd_u32(__m128d);
+extern int       __cdecl _mm_cvttss_i32(__m128);
+extern unsigned int __cdecl _mm_cvttss_u32(__m128);
+extern __m128d   __cdecl _mm_cvtu32_sd(__m128d, unsigned int);
+extern __m128    __cdecl _mm_cvtu32_ss(__m128, unsigned int);
+extern __m128d   __cdecl _mm_div_round_sd(__m128d, __m128d, int);
+extern __m128d   __cdecl _mm_mask_div_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_maskz_div_round_sd(__mmask8, __m128d, __m128d, int);
+extern __m128    __cdecl _mm_div_round_ss(__m128, __m128, int);
+extern __m128    __cdecl _mm_mask_div_round_ss(__m128, __mmask8, __m128, __m128, int);
+extern __m128    __cdecl _mm_maskz_div_round_ss(__mmask8, __m128, __m128, int);
+extern __m128d   __cdecl _mm_mask_div_sd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_div_sd(__mmask8, __m128d, __m128d);
+extern __m128    __cdecl _mm_mask_div_ss(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_div_ss(__mmask8, __m128, __m128);
+extern __m128d   __cdecl _mm_fixupimm_round_sd(__m128d, __m128d, __m128i, const int, int);
+extern __m128d   __cdecl _mm_mask_fixupimm_round_sd(__m128d, __mmask8, __m128d, __m128i, const int, const int);
+extern __m128d   __cdecl _mm_maskz_fixupimm_round_sd(__mmask8, __m128d, __m128d, __m128i, const int, const int);
+extern __m128    __cdecl _mm_fixupimm_round_ss(__m128, __m128, __m128i, const int, const int);
+extern __m128    __cdecl _mm_mask_fixupimm_round_ss(__m128, __mmask8, __m128, __m128i, const int, const int);
+extern __m128    __cdecl _mm_maskz_fixupimm_round_ss(__mmask8, __m128, __m128, __m128i, const int, const int);
+extern __m128d   __cdecl _mm_fixupimm_sd(__m128d, __m128d, __m128i, const int);
+extern __m128d   __cdecl _mm_mask_fixupimm_sd(__m128d, __mmask8, __m128d, __m128i, const int);
+extern __m128d   __cdecl _mm_maskz_fixupimm_sd(__mmask8, __m128d, __m128d, __m128i, const int);
+extern __m128    __cdecl _mm_fixupimm_ss(__m128, __m128, __m128i, const int);
+extern __m128    __cdecl _mm_mask_fixupimm_ss(__m128, __mmask8, __m128, __m128i, const int);
+extern __m128    __cdecl _mm_maskz_fixupimm_ss(__mmask8, __m128, __m128, __m128i, const int);
+extern __m128d   __cdecl _mm_fmadd_round_sd(__m128d, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_mask_fmadd_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_mask3_fmadd_round_sd(__m128d, __m128d, __m128d, __mmask8, int);
+extern __m128d   __cdecl _mm_maskz_fmadd_round_sd(__mmask8, __m128d, __m128d, __m128d, int);
+extern __m128    __cdecl _mm_fmadd_round_ss(__m128, __m128, __m128, int);
+extern __m128    __cdecl _mm_mask_fmadd_round_ss(__m128, __mmask8, __m128, __m128, int);
+extern __m128    __cdecl _mm_mask3_fmadd_round_ss(__m128, __m128, __m128, __mmask8, int);
+extern __m128    __cdecl _mm_maskz_fmadd_round_ss(__mmask8, __m128, __m128, __m128, int);
+extern __m128d   __cdecl _mm_mask_fmadd_sd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_mask3_fmadd_sd(__m128d, __m128d, __m128d, __mmask8);
+extern __m128d   __cdecl _mm_maskz_fmadd_sd(__mmask8, __m128d, __m128d, __m128d);
+extern __m128    __cdecl _mm_mask_fmadd_ss(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_mask3_fmadd_ss(__m128, __m128, __m128, __mmask8);
+extern __m128    __cdecl _mm_maskz_fmadd_ss(__mmask8, __m128, __m128, __m128);
+extern __m128d   __cdecl _mm_fmsub_round_sd(__m128d, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_mask_fmsub_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_mask3_fmsub_round_sd(__m128d, __m128d, __m128d, __mmask8, int);
+extern __m128d   __cdecl _mm_maskz_fmsub_round_sd(__mmask8, __m128d, __m128d, __m128d, int);
+extern __m128    __cdecl _mm_fmsub_round_ss(__m128, __m128, __m128, int);
+extern __m128    __cdecl _mm_mask_fmsub_round_ss(__m128, __mmask8, __m128, __m128, int);
+extern __m128    __cdecl _mm_mask3_fmsub_round_ss(__m128, __m128, __m128, __mmask8, int);
+extern __m128    __cdecl _mm_maskz_fmsub_round_ss(__mmask8, __m128, __m128, __m128, int);
+extern __m128d   __cdecl _mm_mask_fmsub_sd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_mask3_fmsub_sd(__m128d, __m128d, __m128d, __mmask8);
+extern __m128d   __cdecl _mm_maskz_fmsub_sd(__mmask8, __m128d, __m128d, __m128d);
+extern __m128    __cdecl _mm_mask_fmsub_ss(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_mask3_fmsub_ss(__m128, __m128, __m128, __mmask8);
+extern __m128    __cdecl _mm_maskz_fmsub_ss(__mmask8, __m128, __m128, __m128);
+extern __m128d   __cdecl _mm_fnmadd_round_sd(__m128d, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_mask_fnmadd_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_mask3_fnmadd_round_sd(__m128d, __m128d, __m128d, __mmask8, int);
+extern __m128d   __cdecl _mm_maskz_fnmadd_round_sd(__mmask8, __m128d, __m128d, __m128d, int);
+extern __m128    __cdecl _mm_fnmadd_round_ss(__m128, __m128, __m128, int);
+extern __m128    __cdecl _mm_mask_fnmadd_round_ss(__m128, __mmask8, __m128, __m128, int);
+extern __m128    __cdecl _mm_mask3_fnmadd_round_ss(__m128, __m128, __m128, __mmask8, int);
+extern __m128    __cdecl _mm_maskz_fnmadd_round_ss(__mmask8, __m128, __m128, __m128, int);
+extern __m128d   __cdecl _mm_mask_fnmadd_sd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_mask3_fnmadd_sd(__m128d, __m128d, __m128d, __mmask8);
+extern __m128d   __cdecl _mm_maskz_fnmadd_sd(__mmask8, __m128d, __m128d, __m128d);
+extern __m128    __cdecl _mm_mask_fnmadd_ss(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_mask3_fnmadd_ss(__m128, __m128, __m128, __mmask8);
+extern __m128    __cdecl _mm_maskz_fnmadd_ss(__mmask8, __m128, __m128, __m128);
+extern __m128d   __cdecl _mm_fnmsub_round_sd(__m128d, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_mask_fnmsub_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_mask3_fnmsub_round_sd(__m128d, __m128d, __m128d, __mmask8, int);
+extern __m128d   __cdecl _mm_maskz_fnmsub_round_sd(__mmask8, __m128d, __m128d, __m128d, int);
+extern __m128    __cdecl _mm_fnmsub_round_ss(__m128, __m128, __m128, int);
+extern __m128    __cdecl _mm_mask_fnmsub_round_ss(__m128, __mmask8, __m128, __m128, int);
+extern __m128    __cdecl _mm_mask3_fnmsub_round_ss(__m128, __m128, __m128, __mmask8, int);
+extern __m128    __cdecl _mm_maskz_fnmsub_round_ss(__mmask8, __m128, __m128, __m128, int);
+extern __m128d   __cdecl _mm_mask_fnmsub_sd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_mask3_fnmsub_sd(__m128d, __m128d, __m128d, __mmask8);
+extern __m128d   __cdecl _mm_maskz_fnmsub_sd(__mmask8, __m128d, __m128d, __m128d);
+extern __m128    __cdecl _mm_mask_fnmsub_ss(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_mask3_fnmsub_ss(__m128, __m128, __m128, __mmask8);
+extern __m128    __cdecl _mm_maskz_fnmsub_ss(__mmask8, __m128, __m128, __m128);
+extern __mmask8  __cdecl _mm_fpclass_sd_mask(__m128d, int);
+extern __mmask8  __cdecl _mm_mask_fpclass_sd_mask(__mmask8, __m128d, int);
+extern __mmask8  __cdecl _mm_fpclass_ss_mask(__m128, int);
+extern __mmask8  __cdecl _mm_mask_fpclass_ss_mask(__mmask8, __m128, int);
+extern __m128d   __cdecl _mm_getexp_round_sd(__m128d, __m128d, const int);
+extern __m128d   __cdecl _mm_mask_getexp_round_sd(__m128d, __mmask8, __m128d, __m128d, const int);
+extern __m128d   __cdecl _mm_maskz_getexp_round_sd(__mmask8, __m128d, __m128d, const int);
+extern __m128    __cdecl _mm_getexp_round_ss(__m128, __m128, const int);
+extern __m128    __cdecl _mm_mask_getexp_round_ss(__m128, __mmask8, __m128, __m128, const int);
+extern __m128    __cdecl _mm_maskz_getexp_round_ss(__mmask8, __m128, __m128, const int);
+extern __m128d   __cdecl _mm_getexp_sd(__m128d, __m128d);
+extern __m128d   __cdecl _mm_mask_getexp_sd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_getexp_sd(__mmask8, __m128d, __m128d);
+extern __m128    __cdecl _mm_getexp_ss(__m128, __m128);
+extern __m128    __cdecl _mm_mask_getexp_ss(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_getexp_ss(__mmask8, __m128, __m128);
+extern __m128d   __cdecl _mm_getmant_round_sd(__m128d, __m128d, int, int, int);
+extern __m128d   __cdecl _mm_mask_getmant_round_sd(__m128d, __mmask8, __m128d, __m128d, int, int, int);
+extern __m128d   __cdecl _mm_maskz_getmant_round_sd(__mmask8, __m128d, __m128d, int, int, int);
+extern __m128    __cdecl _mm_getmant_round_ss(__m128, __m128, int, int, int);
+extern __m128    __cdecl _mm_mask_getmant_round_ss(__m128, __mmask8, __m128, __m128, int, int, int);
+extern __m128    __cdecl _mm_maskz_getmant_round_ss(__mmask8, __m128, __m128, int, int, int);
+extern __m128d   __cdecl _mm_getmant_sd(__m128d, __m128d, int, int);
+extern __m128d   __cdecl _mm_mask_getmant_sd(__m128d, __mmask8, __m128d, __m128d, int, int);
+extern __m128d   __cdecl _mm_maskz_getmant_sd(__mmask8, __m128d, __m128d, int, int);
+extern __m128    __cdecl _mm_getmant_ss(__m128, __m128, int, int);
+extern __m128    __cdecl _mm_mask_getmant_ss(__m128, __mmask8, __m128, __m128, int, int);
+extern __m128    __cdecl _mm_maskz_getmant_ss(__mmask8, __m128, __m128, int, int);
+extern __m128d   __cdecl _mm_mask_load_sd(__m128d, __mmask8, const double*);
+extern __m128d   __cdecl _mm_maskz_load_sd(__mmask8, const double*);
+extern __m128    __cdecl _mm_mask_load_ss(__m128, __mmask8, const float*);
+extern __m128    __cdecl _mm_maskz_load_ss(__mmask8, const float*);
+extern __m128d   __cdecl _mm_mask_max_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_maskz_max_round_sd(__mmask8, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_max_round_sd(__m128d, __m128d, int);
+extern __m128    __cdecl _mm_mask_max_round_ss(__m128, __mmask8, __m128, __m128, int);
+extern __m128    __cdecl _mm_maskz_max_round_ss(__mmask8, __m128, __m128, int);
+extern __m128    __cdecl _mm_max_round_ss(__m128, __m128, int);
+extern __m128d   __cdecl _mm_mask_max_sd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_max_sd(__mmask8, __m128d, __m128d);
+extern __m128    __cdecl _mm_mask_max_ss(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_max_ss(__mmask8, __m128, __m128);
+extern __m128d   __cdecl _mm_mask_min_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_maskz_min_round_sd(__mmask8, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_min_round_sd(__m128d, __m128d, int);
+extern __m128    __cdecl _mm_mask_min_round_ss(__m128, __mmask8, __m128, __m128, int);
+extern __m128    __cdecl _mm_maskz_min_round_ss(__mmask8, __m128, __m128, int);
+extern __m128    __cdecl _mm_min_round_ss(__m128, __m128, int);
+extern __m128d   __cdecl _mm_mask_min_sd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_min_sd(__mmask8, __m128d, __m128d);
+extern __m128    __cdecl _mm_mask_min_ss(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_min_ss(__mmask8, __m128, __m128);
+extern __m128d   __cdecl _mm_mask_move_sd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_move_sd(__mmask8, __m128d, __m128d);
+extern __m128    __cdecl _mm_mask_move_ss(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_move_ss(__mmask8, __m128, __m128);
+extern __m128d   __cdecl _mm_mask_mul_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_maskz_mul_round_sd(__mmask8, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_mul_round_sd(__m128d, __m128d, int);
+extern __m128    __cdecl _mm_mask_mul_round_ss(__m128, __mmask8, __m128, __m128, int);
+extern __m128    __cdecl _mm_maskz_mul_round_ss(__mmask8, __m128, __m128, int);
+extern __m128    __cdecl _mm_mul_round_ss(__m128, __m128, int);
+extern __m128d   __cdecl _mm_mask_mul_sd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_mul_sd(__mmask8, __m128d, __m128d);
+extern __m128    __cdecl _mm_mask_mul_ss(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_mul_ss(__mmask8, __m128, __m128);
+extern __m128d   __cdecl _mm_range_sd(__m128d, __m128d, const int);
+extern __m128d   __cdecl _mm_mask_range_sd(__m128d, __mmask8, __m128d, __m128d, const int);
+extern __m128d   __cdecl _mm_maskz_range_sd(__mmask8, __m128d, __m128d, const int);
+extern __m128d   __cdecl _mm_range_round_sd(__m128d, __m128d, const int, int);
+extern __m128d   __cdecl _mm_mask_range_round_sd(__m128d, __mmask8, __m128d, __m128d, const int, int);
+extern __m128d   __cdecl _mm_maskz_range_round_sd(__mmask8, __m128d, __m128d, const int, int);
+extern __m128    __cdecl _mm_range_ss(__m128, __m128, const int);
+extern __m128    __cdecl _mm_mask_range_ss(__m128, __mmask8, __m128, __m128, const int);
+extern __m128    __cdecl _mm_maskz_range_ss(__mmask8, __m128, __m128, const int);
+extern __m128    __cdecl _mm_range_round_ss(__m128, __m128, const int, int);
+extern __m128    __cdecl _mm_mask_range_round_ss(__m128, __mmask8, __m128, __m128, const int, int);
+extern __m128    __cdecl _mm_maskz_range_round_ss(__mmask8, __m128, __m128, const int, int);
+extern __m128d   __cdecl _mm_mask_rcp14_sd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_rcp14_sd(__mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_rcp14_sd(__m128d, __m128d);
+extern __m128    __cdecl _mm_mask_rcp14_ss(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_rcp14_ss(__mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_rcp14_ss(__m128, __m128);
+extern __m128d   __cdecl _mm_mask_rcp28_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_maskz_rcp28_round_sd(__mmask8, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_rcp28_round_sd(__m128d, __m128d, int);
+extern __m128    __cdecl _mm_mask_rcp28_round_ss(__m128, __mmask8, __m128, __m128, int);
+extern __m128    __cdecl _mm_maskz_rcp28_round_ss(__mmask8, __m128, __m128, int);
+extern __m128    __cdecl _mm_rcp28_round_ss(__m128, __m128, int);
+extern __m128d   __cdecl _mm_mask_rcp28_sd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_rcp28_sd(__mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_rcp28_sd(__m128d, __m128d);
+extern __m128    __cdecl _mm_mask_rcp28_ss(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_rcp28_ss(__mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_rcp28_ss(__m128, __m128);
+extern __m128d   __cdecl _mm_mask_reduce_round_sd(__m128d, __mmask8, __m128d, __m128d, const int, int);
+extern __m128d   __cdecl _mm_maskz_reduce_round_sd(__mmask8, __m128d, __m128d, const int, int);
+extern __m128d   __cdecl _mm_reduce_round_sd(__m128d, __m128d, const int, int);
+extern __m128    __cdecl _mm_mask_reduce_round_ss(__m128, __mmask8, __m128, __m128, const int, int);
+extern __m128    __cdecl _mm_maskz_reduce_round_ss(__mmask8, __m128, __m128, const int, int);
+extern __m128    __cdecl _mm_reduce_round_ss(__m128, __m128, const int, int);
+extern __m128d   __cdecl _mm_mask_reduce_sd(__m128d, __mmask8, __m128d, __m128d, const int);
+extern __m128d   __cdecl _mm_maskz_reduce_sd(__mmask8, __m128d, __m128d, const int);
+extern __m128d   __cdecl _mm_reduce_sd(__m128d, __m128d, const int);
+extern __m128    __cdecl _mm_mask_reduce_ss(__m128, __mmask8, __m128, __m128, const int);
+extern __m128    __cdecl _mm_maskz_reduce_ss(__mmask8, __m128, __m128, const int);
+extern __m128    __cdecl _mm_reduce_ss(__m128, __m128, const int);
+extern __m128d   __cdecl _mm_mask_roundscale_round_sd(__m128d, __mmask8, __m128d, __m128d, const int, const int);
+extern __m128d   __cdecl _mm_maskz_roundscale_round_sd(__mmask8, __m128d, __m128d, const int, const int);
+extern __m128d   __cdecl _mm_roundscale_round_sd(__m128d, __m128d, const int, const int);
+extern __m128    __cdecl _mm_mask_roundscale_round_ss(__m128, __mmask8, __m128, __m128, const int, const int);
+extern __m128    __cdecl _mm_maskz_roundscale_round_ss(__mmask8, __m128, __m128, const int, const int);
+extern __m128    __cdecl _mm_roundscale_round_ss(__m128, __m128, const int, const int);
+extern __m128d   __cdecl _mm_mask_roundscale_sd(__m128d, __mmask8, __m128d, __m128d, const int);
+extern __m128d   __cdecl _mm_maskz_roundscale_sd(__mmask8, __m128d, __m128d, const int);
+extern __m128d   __cdecl _mm_roundscale_sd(__m128d, __m128d, const int);
+extern __m128    __cdecl _mm_mask_roundscale_ss(__m128, __mmask8, __m128, __m128, const int);
+extern __m128    __cdecl _mm_maskz_roundscale_ss(__mmask8, __m128, __m128, const int);
+extern __m128    __cdecl _mm_roundscale_ss(__m128, __m128, const int);
+extern __m128d   __cdecl _mm_mask_rsqrt14_sd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_rsqrt14_sd(__mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_rsqrt14_sd(__m128d, __m128d);
+extern __m128    __cdecl _mm_mask_rsqrt14_ss(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_rsqrt14_ss(__mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_rsqrt14_ss(__m128, __m128);
+extern __m128d   __cdecl _mm_mask_rsqrt28_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_maskz_rsqrt28_round_sd(__mmask8, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_rsqrt28_round_sd(__m128d, __m128d, int);
+extern __m128    __cdecl _mm_mask_rsqrt28_round_ss(__m128, __mmask8, __m128, __m128, int);
+extern __m128    __cdecl _mm_maskz_rsqrt28_round_ss(__mmask8, __m128, __m128, int);
+extern __m128    __cdecl _mm_rsqrt28_round_ss(__m128, __m128, int);
+extern __m128d   __cdecl _mm_mask_rsqrt28_sd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_rsqrt28_sd(__mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_rsqrt28_sd(__m128d, __m128d);
+extern __m128    __cdecl _mm_mask_rsqrt28_ss(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_rsqrt28_ss(__mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_rsqrt28_ss(__m128, __m128);
+extern __m128d   __cdecl _mm_mask_scalef_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_maskz_scalef_round_sd(__mmask8, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_scalef_round_sd(__m128d, __m128d, int);
+extern __m128    __cdecl _mm_mask_scalef_round_ss(__m128, __mmask8, __m128, __m128, int);
+extern __m128    __cdecl _mm_maskz_scalef_round_ss(__mmask8, __m128, __m128, int);
+extern __m128    __cdecl _mm_scalef_round_ss(__m128, __m128, int);
+extern __m128d   __cdecl _mm_mask_scalef_sd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_scalef_sd(__mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_scalef_sd(__m128d, __m128d);
+extern __m128    __cdecl _mm_mask_scalef_ss(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_scalef_ss(__mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_scalef_ss(__m128, __m128);
+extern __m128d   __cdecl _mm_mask_sqrt_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_maskz_sqrt_round_sd(__mmask8, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_sqrt_round_sd(__m128d, __m128d, int);
+extern __m128    __cdecl _mm_mask_sqrt_round_ss(__m128, __mmask8, __m128, __m128, int);
+extern __m128    __cdecl _mm_maskz_sqrt_round_ss(__mmask8, __m128, __m128, int);
+extern __m128    __cdecl _mm_sqrt_round_ss(__m128, __m128, int);
+extern __m128d   __cdecl _mm_mask_sqrt_sd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_sqrt_sd(__mmask8, __m128d, __m128d);
+extern __m128    __cdecl _mm_mask_sqrt_ss(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_sqrt_ss(__mmask8, __m128, __m128);
+extern void      __cdecl _mm_mask_store_sd(double*, __mmask8, __m128d);
+extern void      __cdecl _mm_mask_store_ss(float*, __mmask8, __m128);
+extern __m128d   __cdecl _mm_mask_sub_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_maskz_sub_round_sd(__mmask8, __m128d, __m128d, int);
+extern __m128d   __cdecl _mm_sub_round_sd(__m128d, __m128d, int);
+extern __m128    __cdecl _mm_mask_sub_round_ss(__m128, __mmask8, __m128, __m128, int);
+extern __m128    __cdecl _mm_maskz_sub_round_ss(__mmask8, __m128, __m128, int);
+extern __m128    __cdecl _mm_sub_round_ss(__m128, __m128, int);
+extern __m128d   __cdecl _mm_mask_sub_sd(__m128d, __mmask8, __m128d, __m128d);
+extern __m128d   __cdecl _mm_maskz_sub_sd(__mmask8, __m128d, __m128d);
+extern __m128    __cdecl _mm_mask_sub_ss(__m128, __mmask8, __m128, __m128);
+extern __m128    __cdecl _mm_maskz_sub_ss(__mmask8, __m128, __m128);
+
+#if defined (_M_X64)
+
+extern unsigned __int64 __cdecl _mm_cvtsd_u64(__m128d);
+extern unsigned __int64 __cdecl _mm_cvtss_u64(__m128);
+extern unsigned __int64 __cdecl _mm_cvttsd_u64(__m128d);
+extern unsigned __int64 __cdecl _mm_cvttss_u64(__m128);
+extern unsigned __int64 __cdecl _mm_cvt_roundsd_u64(__m128d, int);
+extern unsigned __int64 __cdecl _mm_cvt_roundss_u64(__m128, int);
+extern unsigned __int64 __cdecl _mm_cvtt_roundsd_u64(__m128d, int);
+extern unsigned __int64 __cdecl _mm_cvtt_roundss_u64(__m128, int);
+
+extern __m128d   __cdecl _mm_cvti64_sd(__m128d, __int64);
+extern __m128    __cdecl _mm_cvti64_ss(__m128, __int64);
+extern __int64   __cdecl _mm_cvtsd_i64(__m128d);
+extern __int64   __cdecl _mm_cvtss_i64(__m128);
+extern __int64   __cdecl _mm_cvttsd_i64(__m128d);
+extern __int64   __cdecl _mm_cvttss_i64(__m128);
+extern __int64   __cdecl _mm_cvtt_roundsd_i64(__m128d, int);
+extern __int64   __cdecl _mm_cvtt_roundsd_si64(__m128d, int);
+extern __int64   __cdecl _mm_cvtt_roundss_i64(__m128, int);
+extern __int64   __cdecl _mm_cvtt_roundss_si64(__m128, int);
+extern __m128d   __cdecl _mm_cvtu64_sd(__m128d, unsigned __int64);
+extern __m128    __cdecl _mm_cvtu64_ss(__m128, unsigned __int64);
+extern __m128d   __cdecl _mm_cvt_roundi64_sd(__m128d, __int64, int);
+extern __m128    __cdecl _mm_cvt_roundi64_ss(__m128, __int64, int);
+extern __int64   __cdecl _mm_cvt_roundsd_i64(__m128d, int);
+extern __int64   __cdecl _mm_cvt_roundsd_si64(__m128d, int);
+extern __m128d   __cdecl _mm_cvt_roundsi64_sd(__m128d, __int64, int);
+extern __m128    __cdecl _mm_cvt_roundsi64_ss(__m128, __int64, int);
+extern __int64   __cdecl _mm_cvt_roundss_i64(__m128, int);
+extern __int64   __cdecl _mm_cvt_roundss_si64(__m128, int);
+extern __m128d   __cdecl _mm_cvt_roundu64_sd(__m128d, unsigned __int64, int);
+extern __m128    __cdecl _mm_cvt_roundu64_ss(__m128, unsigned __int64, int);
+
+#endif  /* defined (_M_X64) */
+
+// Zero-extended cast functions
+extern __m512d   __cdecl _mm512_zextpd128_pd512(__m128d);
+extern __m512d   __cdecl _mm512_zextpd256_pd512(__m256d);
+extern __m512    __cdecl _mm512_zextps128_ps512(__m128);
+extern __m512    __cdecl _mm512_zextps256_ps512(__m256);
+extern __m512i   __cdecl _mm512_zextsi128_si512(__m128i);
+extern __m512i   __cdecl _mm512_zextsi256_si512(__m256i);
+
+/*
+ * Convert Scalar Single-Precision Floating-point value in 512-bit vector to
+ * equivalent C/C++ float type.
+ */
+// float _mm512_cvtss_f32 (__m512 a)
+#define _mm512_cvtss_f32(a) (_mm_cvtss_f32(_mm512_castps512_ps128(a)))
+
+/*
+ * Convert Scalar Double-Precision Floating-point value in 512-bit vector to
+ * equivalent C/C++ double type.
+ */
+// double _mm512_cvtsd_f64 (__m512d a)
+#define _mm512_cvtsd_f64(a) (_mm_cvtsd_f64(_mm512_castpd512_pd128(a)))
+
+/*
+ * Convert 32-bit Scalar integer in 512-bit vector to equivalent C/C++ int type.
+ */
+// int _mm512_cvtsi512_si32 (__m512i a)
+#define _mm512_cvtsi512_si32(a) (_mm_cvtsi128_si32(_mm512_castsi512_si128(a)))
+
+#if defined (_M_X64)
+/*
+ * Convert 64-bit Scalar integer in 512-bit vector to equivalent C/C++ __int64 type.
+ */
+// __int64 _mm512_cvtsi512_si64 (__m512i a)
+#define _mm512_cvtsi512_si64(a) (_mm_cvtsi128_si64(_mm512_castsi512_si128(a)))
+#endif  /* defined (_M_X64) */
+
+// AVX512_IFMA intrinsics
+extern __m128i __cdecl _mm_madd52hi_epu64(__m128i, __m128i, __m128i);
+extern __m128i __cdecl _mm_mask_madd52hi_epu64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i __cdecl _mm_maskz_madd52hi_epu64(__mmask8, __m128i, __m128i, __m128i);
+extern __m256i __cdecl _mm256_madd52hi_epu64(__m256i, __m256i, __m256i);
+extern __m256i __cdecl _mm256_mask_madd52hi_epu64(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i __cdecl _mm256_maskz_madd52hi_epu64(__mmask8, __m256i, __m256i, __m256i);
+extern __m512i __cdecl _mm512_madd52hi_epu64(__m512i, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_madd52hi_epu64(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_madd52hi_epu64(__mmask8, __m512i, __m512i, __m512i);
+
+extern __m128i __cdecl _mm_madd52lo_epu64(__m128i, __m128i, __m128i);
+extern __m128i __cdecl _mm_mask_madd52lo_epu64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i __cdecl _mm_maskz_madd52lo_epu64(__mmask8, __m128i, __m128i, __m128i);
+extern __m256i __cdecl _mm256_madd52lo_epu64(__m256i, __m256i, __m256i);
+extern __m256i __cdecl _mm256_mask_madd52lo_epu64(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i __cdecl _mm256_maskz_madd52lo_epu64(__mmask8, __m256i, __m256i, __m256i);
+extern __m512i __cdecl _mm512_madd52lo_epu64(__m512i, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_madd52lo_epu64(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_madd52lo_epu64(__mmask8, __m512i, __m512i, __m512i);
+
+// AVX512_VBMI intrinsics
+extern __m128i __cdecl _mm_permutexvar_epi8(__m128i, __m128i);
+extern __m128i __cdecl _mm_mask_permutexvar_epi8(__m128i, __mmask16, __m128i, __m128i);
+extern __m128i __cdecl _mm_maskz_permutexvar_epi8(__mmask16, __m128i, __m128i);
+extern __m256i __cdecl _mm256_permutexvar_epi8(__m256i, __m256i);
+extern __m256i __cdecl _mm256_mask_permutexvar_epi8(__m256i, __mmask32, __m256i, __m256i);
+extern __m256i __cdecl _mm256_maskz_permutexvar_epi8(__mmask32, __m256i, __m256i);
+extern __m512i __cdecl _mm512_permutexvar_epi8(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_permutexvar_epi8(__m512i, __mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_permutexvar_epi8(__mmask64, __m512i, __m512i);
+
+extern __m128i __cdecl _mm_permutex2var_epi8(__m128i, __m128i /* idx */, __m128i);
+extern __m128i __cdecl _mm_mask_permutex2var_epi8(__m128i, __mmask16, __m128i /* idx */, __m128i);
+extern __m128i __cdecl _mm_mask2_permutex2var_epi8(__m128i, __m128i /* idx */, __mmask16, __m128i);
+extern __m128i __cdecl _mm_maskz_permutex2var_epi8(__mmask16, __m128i, __m128i /* idx */, __m128i);
+extern __m256i __cdecl _mm256_permutex2var_epi8(__m256i, __m256i, __m256i);
+extern __m256i __cdecl _mm256_mask_permutex2var_epi8(__m256i, __mmask32, __m256i, __m256i);
+extern __m256i __cdecl _mm256_mask2_permutex2var_epi8(__m256i, __m256i, __mmask32, __m256i);
+extern __m256i __cdecl _mm256_maskz_permutex2var_epi8(__mmask32, __m256i, __m256i, __m256i);
+extern __m512i __cdecl _mm512_permutex2var_epi8(__m512i, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_permutex2var_epi8(__m512i, __mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mask2_permutex2var_epi8(__m512i, __m512i, __mmask64, __m512i);
+extern __m512i __cdecl _mm512_maskz_permutex2var_epi8(__mmask64, __m512i, __m512i, __m512i);
+
+extern __m128i __cdecl _mm_multishift_epi64_epi8(__m128i, __m128i);
+extern __m128i __cdecl _mm_mask_multishift_epi64_epi8(__m128i, __mmask16, __m128i, __m128i);
+extern __m128i __cdecl _mm_maskz_multishift_epi64_epi8(__mmask16, __m128i, __m128i);
+extern __m256i __cdecl _mm256_multishift_epi64_epi8(__m256i, __m256i);
+extern __m256i __cdecl _mm256_mask_multishift_epi64_epi8(__m256i, __mmask32, __m256i, __m256i);
+extern __m256i __cdecl _mm256_maskz_multishift_epi64_epi8(__mmask32, __m256i, __m256i);
+extern __m512i __cdecl _mm512_multishift_epi64_epi8(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_multishift_epi64_epi8(__m512i, __mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_multishift_epi64_epi8(__mmask64, __m512i, __m512i);
+
+// AVX512_VNNI intrinsics
+extern __m128i __cdecl _mm_dpbusd_epi32(__m128i, __m128i, __m128i);
+extern __m128i __cdecl _mm_mask_dpbusd_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i __cdecl _mm_maskz_dpbusd_epi32(__mmask8, __m128i, __m128i, __m128i);
+extern __m256i __cdecl _mm256_dpbusd_epi32(__m256i, __m256i, __m256i);
+extern __m256i __cdecl _mm256_mask_dpbusd_epi32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i __cdecl _mm256_maskz_dpbusd_epi32(__mmask8, __m256i, __m256i, __m256i);
+extern __m512i __cdecl _mm512_dpbusd_epi32(__m512i, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_dpbusd_epi32(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_dpbusd_epi32(__mmask16, __m512i, __m512i, __m512i);
+
+extern __m128i __cdecl _mm_dpbusds_epi32(__m128i, __m128i, __m128i);
+extern __m128i __cdecl _mm_mask_dpbusds_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i __cdecl _mm_maskz_dpbusds_epi32(__mmask8, __m128i, __m128i, __m128i);
+extern __m256i __cdecl _mm256_dpbusds_epi32(__m256i, __m256i, __m256i);
+extern __m256i __cdecl _mm256_mask_dpbusds_epi32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i __cdecl _mm256_maskz_dpbusds_epi32(__mmask8, __m256i, __m256i, __m256i);
+extern __m512i __cdecl _mm512_dpbusds_epi32(__m512i, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_dpbusds_epi32(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_dpbusds_epi32(__mmask16, __m512i, __m512i, __m512i);
+
+extern __m128i __cdecl _mm_dpwssd_epi32(__m128i, __m128i, __m128i);
+extern __m128i __cdecl _mm_mask_dpwssd_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i __cdecl _mm_maskz_dpwssd_epi32(__mmask8, __m128i, __m128i, __m128i);
+extern __m256i __cdecl _mm256_dpwssd_epi32(__m256i, __m256i, __m256i);
+extern __m256i __cdecl _mm256_mask_dpwssd_epi32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i __cdecl _mm256_maskz_dpwssd_epi32(__mmask8, __m256i, __m256i, __m256i);
+extern __m512i __cdecl _mm512_dpwssd_epi32(__m512i, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_dpwssd_epi32(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_dpwssd_epi32(__mmask16, __m512i, __m512i, __m512i);
+
+extern __m128i __cdecl _mm_dpwssds_epi32(__m128i, __m128i, __m128i);
+extern __m128i __cdecl _mm_mask_dpwssds_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i __cdecl _mm_maskz_dpwssds_epi32(__mmask8, __m128i, __m128i, __m128i);
+extern __m256i __cdecl _mm256_dpwssds_epi32(__m256i, __m256i, __m256i);
+extern __m256i __cdecl _mm256_mask_dpwssds_epi32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i __cdecl _mm256_maskz_dpwssds_epi32(__mmask8, __m256i, __m256i, __m256i);
+extern __m512i __cdecl _mm512_dpwssds_epi32(__m512i, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_dpwssds_epi32(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_dpwssds_epi32(__mmask16, __m512i, __m512i, __m512i);
+
+// VAES
+extern __m256i __cdecl _mm256_aesenc_epi128(__m256i, __m256i);
+extern __m512i __cdecl _mm512_aesenc_epi128(__m512i, __m512i);
+extern __m256i __cdecl _mm256_aesenclast_epi128(__m256i, __m256i);
+extern __m512i __cdecl _mm512_aesenclast_epi128(__m512i, __m512i);
+extern __m256i __cdecl _mm256_aesdec_epi128(__m256i, __m256i);
+extern __m512i __cdecl _mm512_aesdec_epi128(__m512i, __m512i);
+extern __m256i __cdecl _mm256_aesdeclast_epi128(__m256i, __m256i);
+extern __m512i __cdecl _mm512_aesdeclast_epi128(__m512i, __m512i);
+
+// VPCLMULQDQ
+extern __m256i __cdecl _mm256_clmulepi64_epi128(__m256i, __m256i, const int);
+extern __m512i __cdecl _mm512_clmulepi64_epi128(__m512i, __m512i, const int);
+
+// AVX512_VPOPCNTDQ
+extern __m128i __cdecl _mm_popcnt_epi32(__m128i);
+extern __m128i __cdecl _mm_mask_popcnt_epi32(__m128i, __mmask8, __m128i);
+extern __m128i __cdecl _mm_maskz_popcnt_epi32(__mmask8, __m128i);
+extern __m256i __cdecl _mm256_popcnt_epi32(__m256i);
+extern __m256i __cdecl _mm256_mask_popcnt_epi32(__m256i, __mmask8, __m256i);
+extern __m256i __cdecl _mm256_maskz_popcnt_epi32(__mmask8, __m256i);
+extern __m512i __cdecl _mm512_popcnt_epi32(__m512i);
+extern __m512i __cdecl _mm512_mask_popcnt_epi32(__m512i, __mmask16, __m512i);
+extern __m512i __cdecl _mm512_maskz_popcnt_epi32(__mmask16, __m512i);
+
+extern __m128i __cdecl _mm_popcnt_epi64(__m128i);
+extern __m128i __cdecl _mm_mask_popcnt_epi64(__m128i, __mmask8, __m128i);
+extern __m128i __cdecl _mm_maskz_popcnt_epi64(__mmask8, __m128i);
+extern __m256i __cdecl _mm256_popcnt_epi64(__m256i);
+extern __m256i __cdecl _mm256_mask_popcnt_epi64(__m256i, __mmask8, __m256i);
+extern __m256i __cdecl _mm256_maskz_popcnt_epi64(__mmask8, __m256i);
+extern __m512i __cdecl _mm512_popcnt_epi64(__m512i);
+extern __m512i __cdecl _mm512_mask_popcnt_epi64(__m512i, __mmask8, __m512i);
+extern __m512i __cdecl _mm512_maskz_popcnt_epi64(__mmask8, __m512i);
+
+// AVX512_BITALG
+extern __m128i __cdecl _mm_popcnt_epi8(__m128i);
+extern __m128i __cdecl _mm_mask_popcnt_epi8(__m128i, __mmask16, __m128i);
+extern __m128i __cdecl _mm_maskz_popcnt_epi8(__mmask16, __m128i);
+extern __m256i __cdecl _mm256_popcnt_epi8(__m256i);
+extern __m256i __cdecl _mm256_mask_popcnt_epi8(__m256i, __mmask32, __m256i);
+extern __m256i __cdecl _mm256_maskz_popcnt_epi8(__mmask32, __m256i);
+extern __m512i __cdecl _mm512_popcnt_epi8(__m512i);
+extern __m512i __cdecl _mm512_mask_popcnt_epi8(__m512i, __mmask64, __m512i);
+extern __m512i __cdecl _mm512_maskz_popcnt_epi8(__mmask64, __m512i);
+
+extern __m128i __cdecl _mm_popcnt_epi16(__m128i);
+extern __m128i __cdecl _mm_mask_popcnt_epi16(__m128i, __mmask8, __m128i);
+extern __m128i __cdecl _mm_maskz_popcnt_epi16(__mmask8, __m128i);
+extern __m256i __cdecl _mm256_popcnt_epi16(__m256i);
+extern __m256i __cdecl _mm256_mask_popcnt_epi16(__m256i, __mmask16, __m256i);
+extern __m256i __cdecl _mm256_maskz_popcnt_epi16(__mmask16, __m256i);
+extern __m512i __cdecl _mm512_popcnt_epi16(__m512i);
+extern __m512i __cdecl _mm512_mask_popcnt_epi16(__m512i, __mmask32, __m512i);
+extern __m512i __cdecl _mm512_maskz_popcnt_epi16(__mmask32, __m512i);
+
+extern __mmask16 __cdecl _mm_bitshuffle_epi64_mask(__m128i, __m128i);
+extern __mmask16 __cdecl _mm_mask_bitshuffle_epi64_mask(__mmask16, __m128i, __m128i);
+extern __mmask32 __cdecl _mm256_bitshuffle_epi64_mask(__m256i, __m256i);
+extern __mmask32 __cdecl _mm256_mask_bitshuffle_epi64_mask(__mmask32, __m256i, __m256i);
+extern __mmask64 __cdecl _mm512_bitshuffle_epi64_mask(__m512i, __m512i);
+extern __mmask64 __cdecl _mm512_mask_bitshuffle_epi64_mask(__mmask64, __m512i, __m512i);
+
+// GFNI
+extern __m128i __cdecl _mm_gf2p8affineinv_epi64_epi8(__m128i, __m128i, int);
+extern __m128i __cdecl _mm_mask_gf2p8affineinv_epi64_epi8(__m128i, __mmask16, __m128i, __m128i, int);
+extern __m128i __cdecl _mm_maskz_gf2p8affineinv_epi64_epi8(__mmask16, __m128i, __m128i, int);
+extern __m256i __cdecl _mm256_gf2p8affineinv_epi64_epi8(__m256i, __m256i, int);
+extern __m256i __cdecl _mm256_mask_gf2p8affineinv_epi64_epi8(__m256i, __mmask32, __m256i, __m256i, int);
+extern __m256i __cdecl _mm256_maskz_gf2p8affineinv_epi64_epi8(__mmask32, __m256i, __m256i, int);
+extern __m512i __cdecl _mm512_gf2p8affineinv_epi64_epi8(__m512i, __m512i, int);
+extern __m512i __cdecl _mm512_mask_gf2p8affineinv_epi64_epi8(__m512i, __mmask64, __m512i, __m512i, int);
+extern __m512i __cdecl _mm512_maskz_gf2p8affineinv_epi64_epi8(__mmask64, __m512i, __m512i, int);
+extern __m128i __cdecl _mm_gf2p8affine_epi64_epi8(__m128i, __m128i, int);
+extern __m128i __cdecl _mm_mask_gf2p8affine_epi64_epi8(__m128i, __mmask16, __m128i, __m128i, int);
+extern __m128i __cdecl _mm_maskz_gf2p8affine_epi64_epi8(__mmask16, __m128i, __m128i, int);
+extern __m256i __cdecl _mm256_gf2p8affine_epi64_epi8(__m256i, __m256i, int);
+extern __m256i __cdecl _mm256_mask_gf2p8affine_epi64_epi8(__m256i, __mmask32, __m256i, __m256i, int);
+extern __m256i __cdecl _mm256_maskz_gf2p8affine_epi64_epi8(__mmask32, __m256i, __m256i, int);
+extern __m512i __cdecl _mm512_gf2p8affine_epi64_epi8(__m512i, __m512i, int);
+extern __m512i __cdecl _mm512_mask_gf2p8affine_epi64_epi8(__m512i, __mmask64, __m512i, __m512i, int);
+extern __m512i __cdecl _mm512_maskz_gf2p8affine_epi64_epi8(__mmask64, __m512i, __m512i, int);
+extern __m128i __cdecl _mm_gf2p8mul_epi8(__m128i, __m128i);
+extern __m128i __cdecl _mm_mask_gf2p8mul_epi8(__m128i, __mmask16, __m128i, __m128i);
+extern __m128i __cdecl _mm_maskz_gf2p8mul_epi8(__mmask16, __m128i, __m128i);
+extern __m256i __cdecl _mm256_gf2p8mul_epi8(__m256i, __m256i);
+extern __m256i __cdecl _mm256_mask_gf2p8mul_epi8(__m256i, __mmask32, __m256i, __m256i);
+extern __m256i __cdecl _mm256_maskz_gf2p8mul_epi8(__mmask32, __m256i, __m256i);
+extern __m512i __cdecl _mm512_gf2p8mul_epi8(__m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_gf2p8mul_epi8(__m512i, __mmask64, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_gf2p8mul_epi8(__mmask64, __m512i, __m512i);
+
+// VPSHLDW|D|Q, VPSHLDVW|D|Q
+extern __m128i __cdecl _mm_shldi_epi16(__m128i, __m128i, int);
+extern __m128i __cdecl _mm_mask_shldi_epi16(__m128i, __mmask8, __m128i, __m128i, int);
+extern __m128i __cdecl _mm_maskz_shldi_epi16(__mmask8, __m128i, __m128i, int);
+extern __m256i __cdecl _mm256_shldi_epi16(__m256i, __m256i, int);
+extern __m256i __cdecl _mm256_mask_shldi_epi16(__m256i, __mmask16, __m256i, __m256i, int);
+extern __m256i __cdecl _mm256_maskz_shldi_epi16(__mmask16, __m256i, __m256i, int);
+extern __m512i __cdecl _mm512_shldi_epi16(__m512i, __m512i, int);
+extern __m512i __cdecl _mm512_mask_shldi_epi16(__m512i, __mmask32, __m512i, __m512i, int);
+extern __m512i __cdecl _mm512_maskz_shldi_epi16(__mmask32, __m512i, __m512i, int);
+extern __m128i __cdecl _mm_shldi_epi32(__m128i, __m128i, int);
+extern __m128i __cdecl _mm_mask_shldi_epi32(__m128i, __mmask8, __m128i, __m128i, int);
+extern __m128i __cdecl _mm_maskz_shldi_epi32(__mmask8, __m128i, __m128i, int);
+extern __m256i __cdecl _mm256_shldi_epi32(__m256i, __m256i, int);
+extern __m256i __cdecl _mm256_mask_shldi_epi32(__m256i, __mmask8, __m256i, __m256i, int);
+extern __m256i __cdecl _mm256_maskz_shldi_epi32(__mmask8, __m256i, __m256i, int);
+extern __m512i __cdecl _mm512_shldi_epi32(__m512i, __m512i, int);
+extern __m512i __cdecl _mm512_mask_shldi_epi32(__m512i, __mmask16, __m512i, __m512i, int);
+extern __m512i __cdecl _mm512_maskz_shldi_epi32(__mmask16, __m512i, __m512i, int);
+extern __m128i __cdecl _mm_shldi_epi64(__m128i, __m128i, int);
+extern __m128i __cdecl _mm_mask_shldi_epi64(__m128i, __mmask8, __m128i, __m128i, int);
+extern __m128i __cdecl _mm_maskz_shldi_epi64(__mmask8, __m128i, __m128i, int);
+extern __m256i __cdecl _mm256_shldi_epi64(__m256i, __m256i, int);
+extern __m256i __cdecl _mm256_mask_shldi_epi64(__m256i, __mmask8, __m256i, __m256i, int);
+extern __m256i __cdecl _mm256_maskz_shldi_epi64(__mmask8, __m256i, __m256i, int);
+extern __m512i __cdecl _mm512_shldi_epi64(__m512i, __m512i, int);
+extern __m512i __cdecl _mm512_mask_shldi_epi64(__m512i, __mmask8, __m512i, __m512i, int);
+extern __m512i __cdecl _mm512_maskz_shldi_epi64(__mmask8, __m512i, __m512i, int);
+extern __m128i __cdecl _mm_shldv_epi16(__m128i, __m128i, __m128i);
+extern __m128i __cdecl _mm_mask_shldv_epi16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i __cdecl _mm_maskz_shldv_epi16(__mmask8, __m128i, __m128i, __m128i);
+extern __m256i __cdecl _mm256_shldv_epi16(__m256i, __m256i, __m256i);
+extern __m256i __cdecl _mm256_mask_shldv_epi16(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i __cdecl _mm256_maskz_shldv_epi16(__mmask16, __m256i, __m256i, __m256i);
+extern __m512i __cdecl _mm512_shldv_epi16(__m512i, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_shldv_epi16(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_shldv_epi16(__mmask32, __m512i, __m512i, __m512i);
+extern __m128i __cdecl _mm_shldv_epi32(__m128i, __m128i, __m128i);
+extern __m128i __cdecl _mm_mask_shldv_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i __cdecl _mm_maskz_shldv_epi32(__mmask8, __m128i, __m128i, __m128i);
+extern __m256i __cdecl _mm256_shldv_epi32(__m256i, __m256i, __m256i);
+extern __m256i __cdecl _mm256_mask_shldv_epi32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i __cdecl _mm256_maskz_shldv_epi32(__mmask8, __m256i, __m256i, __m256i);
+extern __m512i __cdecl _mm512_shldv_epi32(__m512i, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_shldv_epi32(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_shldv_epi32(__mmask16, __m512i, __m512i, __m512i);
+extern __m128i __cdecl _mm_shldv_epi64(__m128i, __m128i, __m128i);
+extern __m128i __cdecl _mm_mask_shldv_epi64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i __cdecl _mm_maskz_shldv_epi64(__mmask8, __m128i, __m128i, __m128i);
+extern __m256i __cdecl _mm256_shldv_epi64(__m256i, __m256i, __m256i);
+extern __m256i __cdecl _mm256_mask_shldv_epi64(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i __cdecl _mm256_maskz_shldv_epi64(__mmask8, __m256i, __m256i, __m256i);
+extern __m512i __cdecl _mm512_shldv_epi64(__m512i, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_shldv_epi64(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_shldv_epi64(__mmask8, __m512i, __m512i, __m512i);
+
+// VPSHRDW|D|Q, VPSHRDVW|D|Q
+extern __m128i __cdecl _mm_shrdi_epi16(__m128i, __m128i, int);
+extern __m128i __cdecl _mm_mask_shrdi_epi16(__m128i, __mmask8, __m128i, __m128i, int);
+extern __m128i __cdecl _mm_maskz_shrdi_epi16(__mmask8, __m128i, __m128i, int);
+extern __m256i __cdecl _mm256_shrdi_epi16(__m256i, __m256i, int);
+extern __m256i __cdecl _mm256_mask_shrdi_epi16(__m256i, __mmask16, __m256i, __m256i, int);
+extern __m256i __cdecl _mm256_maskz_shrdi_epi16(__mmask16, __m256i, __m256i, int);
+extern __m512i __cdecl _mm512_shrdi_epi16(__m512i, __m512i, int);
+extern __m512i __cdecl _mm512_mask_shrdi_epi16(__m512i, __mmask32, __m512i, __m512i, int);
+extern __m512i __cdecl _mm512_maskz_shrdi_epi16(__mmask32, __m512i, __m512i, int);
+extern __m128i __cdecl _mm_shrdi_epi32(__m128i, __m128i, int);
+extern __m128i __cdecl _mm_mask_shrdi_epi32(__m128i, __mmask8, __m128i, __m128i, int);
+extern __m128i __cdecl _mm_maskz_shrdi_epi32(__mmask8, __m128i, __m128i, int);
+extern __m256i __cdecl _mm256_shrdi_epi32(__m256i, __m256i, int);
+extern __m256i __cdecl _mm256_mask_shrdi_epi32(__m256i, __mmask8, __m256i, __m256i, int);
+extern __m256i __cdecl _mm256_maskz_shrdi_epi32(__mmask8, __m256i, __m256i, int);
+extern __m512i __cdecl _mm512_shrdi_epi32(__m512i, __m512i, int);
+extern __m512i __cdecl _mm512_mask_shrdi_epi32(__m512i, __mmask16, __m512i, __m512i, int);
+extern __m512i __cdecl _mm512_maskz_shrdi_epi32(__mmask16, __m512i, __m512i, int);
+extern __m128i __cdecl _mm_shrdi_epi64(__m128i, __m128i, int);
+extern __m128i __cdecl _mm_mask_shrdi_epi64(__m128i, __mmask8, __m128i, __m128i, int);
+extern __m128i __cdecl _mm_maskz_shrdi_epi64(__mmask8, __m128i, __m128i, int);
+extern __m256i __cdecl _mm256_shrdi_epi64(__m256i, __m256i, int);
+extern __m256i __cdecl _mm256_mask_shrdi_epi64(__m256i, __mmask8, __m256i, __m256i, int);
+extern __m256i __cdecl _mm256_maskz_shrdi_epi64(__mmask8, __m256i, __m256i, int);
+extern __m512i __cdecl _mm512_shrdi_epi64(__m512i, __m512i, int);
+extern __m512i __cdecl _mm512_mask_shrdi_epi64(__m512i, __mmask8, __m512i, __m512i, int);
+extern __m512i __cdecl _mm512_maskz_shrdi_epi64(__mmask8, __m512i, __m512i, int);
+extern __m128i __cdecl _mm_shrdv_epi16(__m128i, __m128i, __m128i);
+extern __m128i __cdecl _mm_mask_shrdv_epi16(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i __cdecl _mm_maskz_shrdv_epi16(__mmask8, __m128i, __m128i, __m128i);
+extern __m256i __cdecl _mm256_shrdv_epi16(__m256i, __m256i, __m256i);
+extern __m256i __cdecl _mm256_mask_shrdv_epi16(__m256i, __mmask16, __m256i, __m256i);
+extern __m256i __cdecl _mm256_maskz_shrdv_epi16(__mmask16, __m256i, __m256i, __m256i);
+extern __m512i __cdecl _mm512_shrdv_epi16(__m512i, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_shrdv_epi16(__m512i, __mmask32, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_shrdv_epi16(__mmask32, __m512i, __m512i, __m512i);
+extern __m128i __cdecl _mm_shrdv_epi32(__m128i, __m128i, __m128i);
+extern __m128i __cdecl _mm_mask_shrdv_epi32(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i __cdecl _mm_maskz_shrdv_epi32(__mmask8, __m128i, __m128i, __m128i);
+extern __m256i __cdecl _mm256_shrdv_epi32(__m256i, __m256i, __m256i);
+extern __m256i __cdecl _mm256_mask_shrdv_epi32(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i __cdecl _mm256_maskz_shrdv_epi32(__mmask8, __m256i, __m256i, __m256i);
+extern __m512i __cdecl _mm512_shrdv_epi32(__m512i, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_shrdv_epi32(__m512i, __mmask16, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_shrdv_epi32(__mmask16, __m512i, __m512i, __m512i);
+extern __m128i __cdecl _mm_shrdv_epi64(__m128i, __m128i, __m128i);
+extern __m128i __cdecl _mm_mask_shrdv_epi64(__m128i, __mmask8, __m128i, __m128i);
+extern __m128i __cdecl _mm_maskz_shrdv_epi64(__mmask8, __m128i, __m128i, __m128i);
+extern __m256i __cdecl _mm256_shrdv_epi64(__m256i, __m256i, __m256i);
+extern __m256i __cdecl _mm256_mask_shrdv_epi64(__m256i, __mmask8, __m256i, __m256i);
+extern __m256i __cdecl _mm256_maskz_shrdv_epi64(__mmask8, __m256i, __m256i, __m256i);
+extern __m512i __cdecl _mm512_shrdv_epi64(__m512i, __m512i, __m512i);
+extern __m512i __cdecl _mm512_mask_shrdv_epi64(__m512i, __mmask8, __m512i, __m512i);
+extern __m512i __cdecl _mm512_maskz_shrdv_epi64(__mmask8, __m512i, __m512i, __m512i);
+
+/*
+* Intrinsic functions for Short Vector Math Library (SVML)
+*/
+
+// vector integer divide and remainder
+extern __m512i _mm512_div_epi8(__m512i, __m512i);
+extern __m512i _mm512_div_epi16(__m512i, __m512i);
+extern __m512i _mm512_div_epi32(__m512i, __m512i);
+extern __m512i _mm512_div_epi64(__m512i, __m512i);
+extern __m512i _mm512_div_epu8(__m512i, __m512i);
+extern __m512i _mm512_div_epu16(__m512i, __m512i);
+extern __m512i _mm512_div_epu32(__m512i, __m512i);
+extern __m512i _mm512_div_epu64(__m512i, __m512i);
+extern __m512i _mm512_mask_div_epi32(__m512i /*src*/, __mmask16, __m512i, __m512i);
+extern __m512i _mm512_mask_div_epu32(__m512i /*src*/, __mmask16, __m512i, __m512i);
+extern __m512i _mm512_rem_epi8(__m512i, __m512i);
+extern __m512i _mm512_rem_epi16(__m512i, __m512i);
+extern __m512i _mm512_rem_epi32(__m512i, __m512i);
+extern __m512i _mm512_rem_epi64(__m512i, __m512i);
+extern __m512i _mm512_rem_epu8(__m512i, __m512i);
+extern __m512i _mm512_rem_epu16(__m512i, __m512i);
+extern __m512i _mm512_rem_epu32(__m512i, __m512i);
+extern __m512i _mm512_rem_epu64(__m512i, __m512i);
+extern __m512i _mm512_mask_rem_epi32(__m512i /*src*/, __mmask16, __m512i, __m512i);
+extern __m512i _mm512_mask_rem_epu32(__m512i /*src*/, __mmask16, __m512i, __m512i);
+
+// Math functions
+extern __m512  _mm512_sin_ps(__m512);
+extern __m512  _mm512_mask_sin_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_sin_pd(__m512d);
+extern __m512d _mm512_mask_sin_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_cos_ps(__m512);
+extern __m512  _mm512_mask_cos_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_cos_pd(__m512d);
+extern __m512d _mm512_mask_cos_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_sincos_ps(__m512  * /*cos_res*/, __m512);
+extern __m512  _mm512_mask_sincos_ps(__m512  * /*cos_res*/, __m512  /*sin_src*/, __m512  /*cos_src*/, __mmask16, __m512);
+extern __m512d _mm512_sincos_pd(__m512d * /*cos_res*/, __m512d);
+extern __m512d _mm512_mask_sincos_pd(__m512d * /*cos_res*/, __m512d /*sin_src*/, __m512d /*cos_src*/, __mmask8, __m512d);
+extern __m512  _mm512_tan_ps(__m512);
+extern __m512  _mm512_mask_tan_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_tan_pd(__m512d);
+extern __m512d _mm512_mask_tan_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_asin_ps(__m512);
+extern __m512  _mm512_mask_asin_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_asin_pd(__m512d);
+extern __m512d _mm512_mask_asin_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_acos_ps(__m512);
+extern __m512  _mm512_mask_acos_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_acos_pd(__m512d);
+extern __m512d _mm512_mask_acos_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_atan_ps(__m512);
+extern __m512  _mm512_mask_atan_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_atan_pd(__m512d);
+extern __m512d _mm512_mask_atan_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_atan2_ps(__m512, __m512);
+extern __m512  _mm512_mask_atan2_ps(__m512  /*src*/, __mmask16, __m512, __m512);
+extern __m512d _mm512_atan2_pd(__m512d, __m512d);
+extern __m512d _mm512_mask_atan2_pd(__m512d /*src*/, __mmask8, __m512d, __m512d);
+extern __m512  _mm512_sind_ps(__m512);
+extern __m512  _mm512_mask_sind_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_sind_pd(__m512d);
+extern __m512d _mm512_mask_sind_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_cosd_ps(__m512);
+extern __m512  _mm512_mask_cosd_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_cosd_pd(__m512d);
+extern __m512d _mm512_mask_cosd_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_tand_ps(__m512);
+extern __m512  _mm512_mask_tand_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_tand_pd(__m512d);
+extern __m512d _mm512_mask_tand_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_sinh_ps(__m512);
+extern __m512  _mm512_mask_sinh_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_sinh_pd(__m512d);
+extern __m512d _mm512_mask_sinh_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_cosh_ps(__m512);
+extern __m512  _mm512_mask_cosh_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_cosh_pd(__m512d);
+extern __m512d _mm512_mask_cosh_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_tanh_ps(__m512);
+extern __m512  _mm512_mask_tanh_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_tanh_pd(__m512d);
+extern __m512d _mm512_mask_tanh_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_asinh_ps(__m512);
+extern __m512  _mm512_mask_asinh_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_asinh_pd(__m512d);
+extern __m512d _mm512_mask_asinh_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_acosh_ps(__m512);
+extern __m512  _mm512_mask_acosh_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_acosh_pd(__m512d);
+extern __m512d _mm512_mask_acosh_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_atanh_ps(__m512);
+extern __m512  _mm512_mask_atanh_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_atanh_pd(__m512d);
+extern __m512d _mm512_mask_atanh_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_log_ps(__m512);
+extern __m512  _mm512_mask_log_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_log_pd(__m512d);
+extern __m512d _mm512_mask_log_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_log1p_ps(__m512);
+extern __m512  _mm512_mask_log1p_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_log1p_pd(__m512d);
+extern __m512d _mm512_mask_log1p_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_log10_ps(__m512);
+extern __m512  _mm512_mask_log10_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_log10_pd(__m512d);
+extern __m512d _mm512_mask_log10_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_log2_ps(__m512);
+extern __m512  _mm512_mask_log2_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_log2_pd(__m512d);
+extern __m512d _mm512_mask_log2_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_logb_ps(__m512);
+extern __m512  _mm512_mask_logb_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_logb_pd(__m512d);
+extern __m512d _mm512_mask_logb_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_exp_ps(__m512);
+extern __m512  _mm512_mask_exp_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_exp_pd(__m512d);
+extern __m512d _mm512_mask_exp_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_exp10_ps(__m512);
+extern __m512  _mm512_mask_exp10_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_exp10_pd(__m512d);
+extern __m512d _mm512_mask_exp10_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_exp2_ps(__m512);
+extern __m512  _mm512_mask_exp2_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_exp2_pd(__m512d);
+extern __m512d _mm512_mask_exp2_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_expm1_ps(__m512);
+extern __m512  _mm512_mask_expm1_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_expm1_pd(__m512d);
+extern __m512d _mm512_mask_expm1_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_pow_ps(__m512, __m512);
+extern __m512  _mm512_mask_pow_ps(__m512  /*src*/, __mmask16, __m512, __m512);
+extern __m512d _mm512_pow_pd(__m512d, __m512d);
+extern __m512d _mm512_mask_pow_pd(__m512d /*src*/, __mmask8, __m512d, __m512d);
+extern __m512  _mm512_trunc_ps(__m512);
+extern __m512  _mm512_mask_trunc_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_trunc_pd(__m512d);
+extern __m512d _mm512_mask_trunc_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_floor_ps(__m512);
+extern __m512  _mm512_mask_floor_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_floor_pd(__m512d);
+extern __m512d _mm512_mask_floor_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_ceil_ps(__m512);
+extern __m512  _mm512_mask_ceil_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_ceil_pd(__m512d);
+extern __m512d _mm512_mask_ceil_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512 _mm512_svml_round_ps(__m512);
+extern __m512 _mm512_mask_svml_round_ps(__m512 /*src*/, __mmask16, __m512);
+extern __m512d _mm512_svml_round_pd(__m512d);
+extern __m512d _mm512_mask_svml_round_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_fmod_ps(__m512, __m512);
+extern __m512  _mm512_mask_fmod_ps(__m512  /*src*/, __mmask16, __m512, __m512);
+extern __m512d _mm512_fmod_pd(__m512d, __m512d);
+extern __m512d _mm512_mask_fmod_pd(__m512d /*src*/, __mmask8, __m512d, __m512d);
+extern __m512  _mm512_rint_ps(__m512);
+extern __m512  _mm512_mask_rint_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_rint_pd(__m512d);
+extern __m512d _mm512_mask_rint_pd(__m512d /*src*/, __mmask8, __m512d);
+
+#define _mm512_recip_ps(a)    _mm512_div_ps(_mm512_set1_ps(1.0f), (a))
+#define _mm512_mask_recip_ps(src,k,a)    _mm512_mask_div_ps((src), (k), _mm512_set1_ps(1.0f), (a))
+#define _mm512_recip_pd(a)    _mm512_div_pd(_mm512_set1_pd(1.0), (a))
+#define _mm512_mask_recip_pd(src,k,a)    _mm512_mask_div_pd((src), (k), _mm512_set1_pd(1.0), (a))
+
+extern __m512  _mm512_invsqrt_ps(__m512);
+extern __m512  _mm512_mask_invsqrt_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_invsqrt_pd(__m512d);
+extern __m512d _mm512_mask_invsqrt_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_cbrt_ps(__m512);
+extern __m512  _mm512_mask_cbrt_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_cbrt_pd(__m512d);
+extern __m512d _mm512_mask_cbrt_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_invcbrt_ps(__m512);
+extern __m512  _mm512_mask_invcbrt_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_invcbrt_pd(__m512d);
+extern __m512d _mm512_mask_invcbrt_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_hypot_ps(__m512, __m512);
+extern __m512  _mm512_mask_hypot_ps(__m512  /*src*/, __mmask16, __m512, __m512);
+extern __m512d _mm512_hypot_pd(__m512d, __m512d);
+extern __m512d _mm512_mask_hypot_pd(__m512d /*src*/, __mmask8, __m512d, __m512d);
+extern __m512  _mm512_cdfnorm_ps(__m512);
+extern __m512  _mm512_mask_cdfnorm_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_cdfnorm_pd(__m512d);
+extern __m512d _mm512_mask_cdfnorm_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_cdfnorminv_ps(__m512);
+extern __m512  _mm512_mask_cdfnorminv_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_cdfnorminv_pd(__m512d);
+extern __m512d _mm512_mask_cdfnorminv_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_erf_ps(__m512);
+extern __m512  _mm512_mask_erf_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_erf_pd(__m512d);
+extern __m512d _mm512_mask_erf_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_erfc_ps(__m512);
+extern __m512  _mm512_mask_erfc_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_erfc_pd(__m512d);
+extern __m512d _mm512_mask_erfc_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_erfcinv_ps(__m512);
+extern __m512  _mm512_mask_erfcinv_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_erfcinv_pd(__m512d);
+extern __m512d _mm512_mask_erfcinv_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_erfinv_ps(__m512);
+extern __m512  _mm512_mask_erfinv_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_erfinv_pd(__m512d);
+extern __m512d _mm512_mask_erfinv_pd(__m512d /*src*/, __mmask8, __m512d);
+extern __m512  _mm512_nearbyint_ps(__m512);
+extern __m512  _mm512_mask_nearbyint_ps(__m512  /*src*/, __mmask16, __m512);
+extern __m512d _mm512_nearbyint_pd(__m512d);
+extern __m512d _mm512_mask_nearbyint_pd(__m512d /*src*/, __mmask8, __m512d);
+
+// BFLOAT16
+typedef __m128i __m128bh;
+typedef __m256i __m256bh;
+typedef __m512i __m512bh;
+typedef unsigned short __bfloat16;
+
+extern __m128bh _mm_cvtneps_pbh(__m128);
+extern __m128bh _mm_mask_cvtneps_pbh(__m128bh, __mmask8, __m128);
+extern __m128bh _mm_maskz_cvtneps_pbh(__mmask8, __m128);
+extern __m128bh _mm_cvtne2ps_pbh(__m128, __m128);
+extern __m128bh _mm_mask_cvtne2ps_pbh(__m128bh, __mmask8, __m128, __m128);
+extern __m128bh _mm_maskz_cvtne2ps_pbh(__mmask8, __m128, __m128);
+extern __m128   _mm_dpbf16_ps(__m128, __m128bh, __m128bh);
+extern __m128   _mm_mask_dpbf16_ps(__m128, __mmask8, __m128bh, __m128bh);
+extern __m128   _mm_maskz_dpbf16_ps(__mmask8, __m128, __m128bh, __m128bh);
+extern __m128bh _mm256_cvtneps_pbh(__m256);
+extern __m128bh _mm256_mask_cvtneps_pbh(__m128bh, __mmask8, __m256);
+extern __m128bh _mm256_maskz_cvtneps_pbh(__mmask8, __m256);
+extern __m256bh _mm256_cvtne2ps_pbh(__m256, __m256);
+extern __m256bh _mm256_mask_cvtne2ps_pbh(__m256bh, __mmask16, __m256, __m256);
+extern __m256bh _mm256_maskz_cvtne2ps_pbh(__mmask16, __m256, __m256);
+extern __m256   _mm256_dpbf16_ps(__m256, __m256bh, __m256bh);
+extern __m256   _mm256_mask_dpbf16_ps(__m256, __mmask8, __m256bh, __m256bh);
+extern __m256   _mm256_maskz_dpbf16_ps(__mmask8, __m256, __m256bh, __m256bh);
+extern __m256bh _mm512_cvtneps_pbh(__m512);
+extern __m256bh _mm512_mask_cvtneps_pbh(__m256bh, __mmask16, __m512);
+extern __m256bh _mm512_maskz_cvtneps_pbh(__mmask16, __m512);
+extern __m512bh _mm512_cvtne2ps_pbh(__m512, __m512);
+extern __m512bh _mm512_mask_cvtne2ps_pbh(__m512bh, __mmask32, __m512, __m512);
+extern __m512bh _mm512_maskz_cvtne2ps_pbh(__mmask32, __m512, __m512);
+extern __m512   _mm512_dpbf16_ps(__m512, __m512bh, __m512bh);
+extern __m512   _mm512_mask_dpbf16_ps(__m512, __mmask16, __m512bh, __m512bh);
+extern __m512   _mm512_maskz_dpbf16_ps(__mmask16, __m512, __m512bh, __m512bh);
+extern __bfloat16 _mm_cvtness_sbh(float);
+extern float      _mm_cvtsbh_ss(__bfloat16);
+extern __m128     _mm_cvtpbh_ps(__m128bh);
+extern __m128     _mm_mask_cvtpbh_ps(__m128, __mmask8, __m128bh);
+extern __m128     _mm_maskz_cvtpbh_ps(__mmask8, __m128bh);
+extern __m256     _mm256_cvtpbh_ps(__m128bh);
+extern __m256     _mm256_mask_cvtpbh_ps(__m256, __mmask8, __m128bh);
+extern __m256     _mm256_maskz_cvtpbh_ps(__mmask8, __m128bh);
+extern __m512     _mm512_cvtpbh_ps(__m256bh);
+extern __m512     _mm512_mask_cvtpbh_ps(__m512, __mmask16, __m256bh);
+extern __m512     _mm512_maskz_cvtpbh_ps(__mmask16, __m256bh);
+
+#define _mm_cvtneps2bf16                _mm_cvtneps_pbh
+#define _mm_mask_cvtneps2bf16           _mm_mask_cvtneps_pbh
+#define _mm_maskz_cvtneps2bf16          _mm_maskz_cvtneps_pbh
+#define _mm256_cvtneps2bf16             _mm256_cvtneps_pbh
+#define _mm256_mask_cvtneps2bf16        _mm256_mask_cvtneps_pbh
+#define _mm256_maskz_cvtneps2bf16       _mm256_maskz_cvtneps_pbh
+#define _mm512_cvtneps2bf16             _mm512_cvtneps_pbh
+#define _mm512_mask_cvtneps2bf16        _mm512_mask_cvtneps_pbh
+#define _mm512_maskz_cvtneps2bf16       _mm512_maskz_cvtneps_pbh
+#define _mm_cvtne2ps2bf16               _mm_cvtne2ps_pbh
+#define _mm_mask_cvtne2ps2bf16          _mm_mask_cvtne2ps_pbh
+#define _mm_maskz_cvtne2ps2bf16         _mm_maskz_cvtne2ps_pbh
+#define _mm256_cvtne2ps2bf16            _mm256_cvtne2ps_pbh
+#define _mm256_mask_cvtne2ps2bf16       _mm256_mask_cvtne2ps_pbh
+#define _mm256_maskz_cvtne2ps2bf16      _mm256_maskz_cvtne2ps_pbh
+#define _mm512_cvtne2ps2bf16            _mm512_cvtne2ps_pbh
+#define _mm512_mask_cvtne2ps2bf16       _mm512_mask_cvtne2ps_pbh
+#define _mm512_maskz_cvtne2ps2bf16      _mm512_maskz_cvtne2ps_pbh
+
+extern __mmask8  __cdecl _kadd_mask8(__mmask8, __mmask8);
+extern __mmask16 __cdecl _kadd_mask16(__mmask16, __mmask16);
+extern __mmask32 __cdecl _kadd_mask32(__mmask32, __mmask32);
+extern __mmask64 __cdecl _kadd_mask64(__mmask64, __mmask64);
+extern __mmask8  __cdecl _kand_mask8(__mmask8, __mmask8);
+extern __mmask16 __cdecl _kand_mask16(__mmask16, __mmask16);
+extern __mmask32 __cdecl _kand_mask32(__mmask32, __mmask32);
+extern __mmask64 __cdecl _kand_mask64(__mmask64, __mmask64);
+extern __mmask8  __cdecl _kandn_mask8(__mmask8, __mmask8);
+extern __mmask16 __cdecl _kandn_mask16(__mmask16, __mmask16);
+extern __mmask32 __cdecl _kandn_mask32(__mmask32, __mmask32);
+extern __mmask64 __cdecl _kandn_mask64(__mmask64, __mmask64);
+extern __mmask8  __cdecl _knot_mask8(__mmask8);
+extern __mmask16 __cdecl _knot_mask16(__mmask16);
+extern __mmask32 __cdecl _knot_mask32(__mmask32);
+extern __mmask64 __cdecl _knot_mask64(__mmask64);
+extern __mmask8  __cdecl _kor_mask8(__mmask8, __mmask8);
+extern __mmask16 __cdecl _kor_mask16(__mmask16, __mmask16);
+extern __mmask32 __cdecl _kor_mask32(__mmask32, __mmask32);
+extern __mmask64 __cdecl _kor_mask64(__mmask64, __mmask64);
+extern __mmask8  __cdecl _kxnor_mask8(__mmask8, __mmask8);
+extern __mmask16 __cdecl _kxnor_mask16(__mmask16, __mmask16);
+extern __mmask32 __cdecl _kxnor_mask32(__mmask32, __mmask32);
+extern __mmask64 __cdecl _kxnor_mask64(__mmask64, __mmask64);
+extern __mmask8  __cdecl _kxor_mask8(__mmask8, __mmask8);
+extern __mmask16 __cdecl _kxor_mask16(__mmask16, __mmask16);
+extern __mmask32 __cdecl _kxor_mask32(__mmask32, __mmask32);
+extern __mmask64 __cdecl _kxor_mask64(__mmask64, __mmask64);
+extern __mmask8  __cdecl _kshiftli_mask8(__mmask8, unsigned int);
+extern __mmask16 __cdecl _kshiftli_mask16(__mmask16, unsigned int);
+extern __mmask32 __cdecl _kshiftli_mask32(__mmask32, unsigned int);
+extern __mmask64 __cdecl _kshiftli_mask64(__mmask64, unsigned int);
+extern __mmask8  __cdecl _kshiftri_mask8(__mmask8, unsigned int);
+extern __mmask16 __cdecl _kshiftri_mask16(__mmask16, unsigned int);
+extern __mmask32 __cdecl _kshiftri_mask32(__mmask32, unsigned int);
+extern __mmask64 __cdecl _kshiftri_mask64(__mmask64, unsigned int);
+extern __mmask8  __cdecl _load_mask8(__mmask8 *);
+extern __mmask16 __cdecl _load_mask16(__mmask16 *);
+extern __mmask32 __cdecl _load_mask32(__mmask32 *);
+extern __mmask64 __cdecl _load_mask64(__mmask64 *);
+extern void      __cdecl _store_mask8(__mmask8 *, __mmask8);
+extern void      __cdecl _store_mask16(__mmask16 *, __mmask16);
+extern void      __cdecl _store_mask32(__mmask32 *, __mmask32);
+extern void      __cdecl _store_mask64(__mmask64 *, __mmask64);
+extern unsigned int     __cdecl _cvtmask8_u32(__mmask8);
+extern unsigned int     __cdecl _cvtmask16_u32(__mmask16);
+extern unsigned int     __cdecl _cvtmask32_u32(__mmask32);
+extern unsigned __int64 __cdecl _cvtmask64_u64(__mmask64);
+extern __mmask8         __cdecl _cvtu32_mask8(unsigned int);
+extern __mmask16        __cdecl _cvtu32_mask16(unsigned int);
+extern __mmask32        __cdecl _cvtu32_mask32(unsigned int);
+extern __mmask64        __cdecl _cvtu64_mask64(unsigned __int64);
+extern __mmask16        __cdecl _mm512_kmov(__mmask16);
+extern unsigned char __cdecl _kortest_mask8_u8(__mmask8, __mmask8, unsigned char *);
+extern unsigned char __cdecl _kortest_mask16_u8(__mmask16, __mmask16, unsigned char *);
+extern unsigned char __cdecl _kortest_mask32_u8(__mmask32, __mmask32, unsigned char *);
+extern unsigned char __cdecl _kortest_mask64_u8(__mmask64, __mmask64, unsigned char *);
+extern unsigned char __cdecl _ktest_mask8_u8(__mmask8, __mmask8, unsigned char *);
+extern unsigned char __cdecl _ktest_mask16_u8(__mmask16, __mmask16, unsigned char *);
+extern unsigned char __cdecl _ktest_mask32_u8(__mmask32, __mmask32, unsigned char *);
+extern unsigned char __cdecl _ktest_mask64_u8(__mmask64, __mmask64, unsigned char *);
+
+#define _mm512_kand(k1, k2)    _kand_mask16((k1), (k2))
+#define _mm512_kandn(k1, k2)   _kandn_mask16((k1), (k2))
+#define _mm512_kor(k1, k2)     _kor_mask16((k1), (k2))
+#define _mm512_kxor(k1, k2)    _kxor_mask16((k1), (k2))
+#define _mm512_kxnor(k1, k2)   _kxnor_mask16((k1), (k2))
+#define _mm512_knot(k1)        _knot_mask16((k1))
+
+#define _kortestc_mask8_u8(k1, k2)    _mm512_testz_nor_mask8((k1), (k2))
+#define _kortestc_mask16_u8(k1, k2)   _mm512_testz_nor_mask16((k1), (k2))
+#define _kortestc_mask32_u8(k1, k2)   _mm512_testz_nor_mask32((k1), (k2))
+#define _kortestc_mask64_u8(k1, k2)   _mm512_testz_nor_mask64((k1), (k2))
+
+#define _kortestz_mask8_u8(k1, k2)    _mm512_testz_or_mask8((k1), (k2))
+#define _kortestz_mask16_u8(k1, k2)   _mm512_testz_or_mask16((k1), (k2))
+#define _kortestz_mask32_u8(k1, k2)   _mm512_testz_or_mask32((k1), (k2))
+#define _kortestz_mask64_u8(k1, k2)   _mm512_testz_or_mask64((k1), (k2))
+
+#define _ktestc_mask8_u8(k1, k2)    _mm512_testz_andn_mask8((k1), (k2))
+#define _ktestc_mask16_u8(k1, k2)   _mm512_testz_andn_mask16((k1), (k2))
+#define _ktestc_mask32_u8(k1, k2)   _mm512_testz_andn_mask32((k1), (k2))
+#define _ktestc_mask64_u8(k1, k2)   _mm512_testz_andn_mask64((k1), (k2))
+
+#define _ktestz_mask8_u8(k1, k2)    _mm512_testz_and_mask8((k1), (k2))
+#define _ktestz_mask16_u8(k1, k2)   _mm512_testz_and_mask16((k1), (k2))
+#define _ktestz_mask32_u8(k1, k2)   _mm512_testz_and_mask32((k1), (k2))
+#define _ktestz_mask64_u8(k1, k2)   _mm512_testz_and_mask64((k1), (k2))
+
+#define _mm512_mask2int(m)    _cvtmask16_u32((m))
+#define _mm512_int2mask(i)    _cvtu32_mask16((i))
+
+#define _mm512_kortestz(m1, m2) ((int)_mm512_testz_or_mask16((m1), (m2)))
+#define _mm512_kortestc(m1, m2) ((int)_mm512_testz_nor_mask16((m1), (m2)))
+
+// These functions are not supported with Windows.
+// They are deprecated and will be removed in a future release
+
+extern __m512  __cdecl _mm512_mask_exp2a23_round_ps(__m512, __mmask16, __m512, int);
+extern __m512  __cdecl _mm512_maskz_exp2a23_round_ps(__mmask16, __m512, int);
+extern __m512d __cdecl _mm512_mask_exp2a23_round_pd(__m512d, __mmask8, __m512d, int);
+extern __m512d __cdecl _mm512_maskz_exp2a23_round_pd(__mmask8, __m512d, int);
+
+#define _mm512_exp2a23_round_ps(v1, e1) \
+    _mm512_maskz_exp2a23_round_ps(_MM_K0_REG16, (v1), (e1))
+#define _mm512_mask_exp2a23_ps(v1, k1, v2) \
+    _mm512_mask_exp2a23_round_ps((v1), (k1), (v2), _MM_FROUND_CUR_DIRECTION)
+#define _mm512_maskz_exp2a23_ps(k1, v1) \
+    _mm512_maskz_exp2a23_round_ps((k1), (v1), _MM_FROUND_CUR_DIRECTION)
+#define _mm512_exp2a23_ps(v1) \
+    _mm512_maskz_exp2a23_ps(_MM_K0_REG16, (v1))
+#define _mm512_exp2a23_round_pd(v1, e1) \
+    _mm512_maskz_exp2a23_round_pd(_MM_K0_REG8, (v1), (e1))
+#define _mm512_mask_exp2a23_pd(v1, k1, v2) \
+    _mm512_mask_exp2a23_round_pd((v1), (k1), (v2), _MM_FROUND_CUR_DIRECTION)
+#define _mm512_maskz_exp2a23_pd(k1, v1) \
+    _mm512_maskz_exp2a23_round_pd((k1), (v1), _MM_FROUND_CUR_DIRECTION)
+#define _mm512_exp2a23_pd(v1) \
+    _mm512_maskz_exp2a23_pd(_MM_K0_REG8, (v1))
+
+extern __m512  __cdecl _mm512_mask_rcp28_round_ps(__m512, __mmask16, __m512, const int);
+extern __m512  __cdecl _mm512_maskz_rcp28_round_ps(__mmask16, __m512, const int);
+extern __m512d __cdecl _mm512_mask_rcp28_round_pd(__m512d, __mmask8, __m512d, const int);
+extern __m512d __cdecl _mm512_maskz_rcp28_round_pd(__mmask8, __m512d, const int);
+
+#define _mm512_mask_rcp28_ps(v1, k1, v2) \
+    _mm512_mask_rcp28_round_ps((v1), (k1), (v2), _MM_FROUND_CUR_DIRECTION)
+#define _mm512_maskz_rcp28_ps(k1, v1) \
+    _mm512_maskz_rcp28_round_ps((k1), (v1), _MM_FROUND_CUR_DIRECTION)
+#define _mm512_rcp28_round_ps(v1, e1) \
+    _mm512_maskz_rcp28_round_ps(_MM_K0_REG16, (v1), (e1))
+#define _mm512_rcp28_ps(v1) \
+    _mm512_maskz_rcp28_ps(_MM_K0_REG16, (v1))
+#define _mm512_mask_rcp28_pd(v1, k1, v2) \
+    _mm512_mask_rcp28_round_pd((v1), (k1), (v2), _MM_FROUND_CUR_DIRECTION)
+#define _mm512_maskz_rcp28_pd(k1, v1) \
+    _mm512_maskz_rcp28_round_pd((k1), (v1), _MM_FROUND_CUR_DIRECTION)
+#define _mm512_rcp28_round_pd(v1, e1) \
+    _mm512_maskz_rcp28_round_pd(_MM_K0_REG8, (v1), (e1))
+#define _mm512_rcp28_pd(v1) \
+    _mm512_maskz_rcp28_pd(_MM_K0_REG8, (v1))
+
+extern __m512  __cdecl _mm512_mask_rsqrt28_round_ps(__m512, __mmask16, __m512, const int);
+extern __m512  __cdecl _mm512_maskz_rsqrt28_round_ps(__mmask16, __m512, const int);
+extern __m512d __cdecl _mm512_mask_rsqrt28_round_pd(__m512d, __mmask8, __m512d, const int);
+extern __m512d __cdecl _mm512_maskz_rsqrt28_round_pd(__mmask8, __m512d, const int);
+
+#define _mm512_mask_rsqrt28_ps(v1, k1, v2) \
+    _mm512_mask_rsqrt28_round_ps((v1), (k1), (v2), _MM_FROUND_CUR_DIRECTION)
+#define _mm512_maskz_rsqrt28_ps(k1, v1) \
+    _mm512_maskz_rsqrt28_round_ps((k1), (v1), _MM_FROUND_CUR_DIRECTION)
+#define _mm512_rsqrt28_round_ps(v1, e1) \
+    _mm512_maskz_rsqrt28_round_ps(_MM_K0_REG16, (v1), (e1))
+#define _mm512_rsqrt28_ps(v1) \
+    _mm512_maskz_rsqrt28_ps(_MM_K0_REG16, (v1))
+#define _mm512_mask_rsqrt28_pd(v1, k1, v2) \
+    _mm512_mask_rsqrt28_round_pd((v1), (k1), (v2), _MM_FROUND_CUR_DIRECTION)
+#define _mm512_maskz_rsqrt28_pd(k1, v1) \
+    _mm512_maskz_rsqrt28_round_pd((k1), (v1), _MM_FROUND_CUR_DIRECTION)
+#define _mm512_rsqrt28_round_pd(v1, e1) \
+    _mm512_maskz_rsqrt28_round_pd(_MM_K0_REG8, (v1), (e1))
+#define _mm512_rsqrt28_pd(v1) \
+    _mm512_maskz_rsqrt28_pd(_MM_K0_REG8, (v1))
+
+extern void __cdecl _mm512_prefetch_i32gather_pd(__m256i vindex, void const* base_addr, int scale, const int hint);
+extern void __cdecl _mm512_prefetch_i32gather_ps(__m512i index, void const* mv, int scale, const int hint);
+extern void __cdecl _mm512_prefetch_i32scatter_pd(void* base_addr, __m256i vindex, int scale, const int hint);
+extern void __cdecl _mm512_prefetch_i32scatter_ps(void* mv, __m512i index, int scale, const int hint);
+extern void __cdecl _mm512_prefetch_i64gather_pd(__m512i vindex, void const* base_addr, int scale, const int hint);
+extern void __cdecl _mm512_prefetch_i64gather_ps(__m512i vindex, void const* base_addr, int scale, const int hint);
+extern void __cdecl _mm512_prefetch_i64scatter_pd(void* base_addr, __m512i vindex, int scale, const int hint);
+extern void __cdecl _mm512_prefetch_i64scatter_ps(void* base_addr, __m512i vindex, int scale, const int hint);
+extern void __cdecl _mm512_mask_prefetch_i32gather_pd(__m256i vindex, __mmask8 mask, void const* base_addr, int scale, const int hint);
+extern void __cdecl _mm512_mask_prefetch_i32gather_ps(__m512i vindex, __mmask16 mask, void const* base_addr, int scale, const int hint);
+extern void __cdecl _mm512_mask_prefetch_i32scatter_pd(void* base_addr, __mmask8 mask, __m256i vinde, int scale, const int hint);
+extern void __cdecl _mm512_mask_prefetch_i32scatter_ps(void* mv, __mmask16 k, __m512i index, int scale, const int hint);
+extern void __cdecl _mm512_mask_prefetch_i64gather_pd(__m512i vindex, __mmask8 mask, void const* base_addr, int scale, const int hint);
+extern void __cdecl _mm512_mask_prefetch_i64gather_ps(__m512i vindex, __mmask8 mask, void const* base_addr, int scale, const int hint);
+extern void __cdecl _mm512_mask_prefetch_i64scatter_pd(void* base_addr, __mmask8 mask, __m512i vindex, int scale, const int hint);
+extern void __cdecl _mm512_mask_prefetch_i64scatter_ps(void* base_addr, __mmask8 mask, __m512i vindex, int scale, const int hint);
+
+// AVX512_VP2INTERSECT
+extern void __cdecl _mm_2intersect_epi32(__m128i, __m128i, __mmask8 *, __mmask8 *);
+extern void __cdecl _mm256_2intersect_epi32(__m256i, __m256i, __mmask8 *, __mmask8 *);
+extern void __cdecl _mm512_2intersect_epi32(__m512i, __m512i, __mmask16 *, __mmask16 *);
+extern void __cdecl _mm_2intersect_epi64(__m128i, __m128i, __mmask8 *, __mmask8 *);
+extern void __cdecl _mm256_2intersect_epi64(__m256i, __m256i, __mmask8 *, __mmask8 *);
+extern void __cdecl _mm512_2intersect_epi64(__m512i, __m512i, __mmask8 *, __mmask8 *);
+
+#if defined (_M_X64)
+
+// AMX
+typedef int __tile;
+
+extern void __cdecl _tile_loadconfig(const void *);
+extern void __cdecl _tile_storeconfig(void *);
+extern void __cdecl _tile_release(void);
+
+extern void __cdecl _tile_loadd(__tile dst, const void *base, int stride);
+extern void __cdecl _tile_stream_loadd(__tile dst, const void *base, int stride);
+extern void __cdecl _tile_stored(__tile src, void *base, int stride);
+extern void __cdecl _tile_zero(__tile dst);
+
+extern void __cdecl _tile_dpbf16ps(__tile dst, __tile src1, __tile src2);
+extern void __cdecl _tile_dpfp16ps(__tile dst, __tile src1, __tile src2);
+extern void __cdecl _tile_dpbssd(__tile dst, __tile src1, __tile src2);
+extern void __cdecl _tile_dpbsud(__tile dst, __tile src1, __tile src2);
+extern void __cdecl _tile_dpbusd(__tile dst, __tile src1, __tile src2);
+extern void __cdecl _tile_dpbuud(__tile dst, __tile src1, __tile src2);
+
+// AMX-COMPLEX
+extern void __cdecl _tile_cmmimfp16ps(__tile dst, __tile src1, __tile src2);
+extern void __cdecl _tile_cmmrlfp16ps(__tile dst, __tile src1, __tile src2);
+
+#endif  /* defined (_M_X64) */
+
+/* hfni */
+typedef __m128i __m128h;
+typedef __m256i __m256h;
+typedef __m512i __m512h;
+
+// VADDPH
+extern __m128h __cdecl _mm_add_ph(__m128h, __m128h);
+extern __m128h __cdecl _mm_mask_add_ph(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_maskz_add_ph(__mmask8, __m128h, __m128h);
+extern __m256h __cdecl _mm256_add_ph(__m256h, __m256h);
+extern __m256h __cdecl _mm256_mask_add_ph(__m256h, __mmask16, __m256h, __m256h);
+extern __m256h __cdecl _mm256_maskz_add_ph(__mmask16, __m256h, __m256h);
+extern __m512h __cdecl _mm512_add_ph(__m512h, __m512h);
+extern __m512h __cdecl _mm512_mask_add_ph(__m512h, __mmask32, __m512h, __m512h);
+extern __m512h __cdecl _mm512_maskz_add_ph(__mmask32, __m512h, __m512h);
+extern __m512h __cdecl _mm512_add_round_ph(__m512h, __m512h, int);
+extern __m512h __cdecl _mm512_mask_add_round_ph(__m512h, __mmask32, __m512h, __m512h, int);
+extern __m512h __cdecl _mm512_maskz_add_round_ph(__mmask32, __m512h, __m512h, int);
+
+// VADDSH
+extern __m128h __cdecl _mm_add_sh(__m128h, __m128h);
+extern __m128h __cdecl _mm_mask_add_sh(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_maskz_add_sh(__mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_add_round_sh(__m128h, __m128h, int);
+extern __m128h __cdecl _mm_mask_add_round_sh(__m128h, __mmask8, __m128h, __m128h, int);
+extern __m128h __cdecl _mm_maskz_add_round_sh(__mmask8, __m128h, __m128h, int);
+/* Intrinsics for broadcasting an fp16 value to vector */
+/*short float data type is not supported in utc*/
+// extern __m128h _mm_set1_ph(short float);
+// extern __m256h _mm256_set1_ph(short float);
+// extern __m512h _mm512_set1_ph(short float);
+
+// VCMPPH
+extern __mmask8 __cdecl _mm_cmp_ph_mask(__m128h, __m128h, const int);
+extern __mmask8 __cdecl _mm_mask_cmp_ph_mask(__mmask8, __m128h, __m128h, const int);
+extern __mmask16 __cdecl _mm256_cmp_ph_mask(__m256h, __m256h, const int);
+extern __mmask16 __cdecl _mm256_mask_cmp_ph_mask(__mmask16, __m256h, __m256h, const int);
+extern __mmask32 __cdecl _mm512_cmp_ph_mask(__m512h, __m512h, const int);
+extern __mmask32 __cdecl _mm512_mask_cmp_ph_mask(__mmask32, __m512h, __m512h, const int);
+extern __mmask32 __cdecl _mm512_cmp_round_ph_mask(__m512h, __m512h, const int, const int);
+extern __mmask32 __cdecl _mm512_mask_cmp_round_ph_mask(__mmask32, __m512h, __m512h, const int, const int);
+
+// VCMPSH
+extern __mmask8 __cdecl _mm_cmp_sh_mask(__m128h, __m128h, const int);
+extern __mmask8 __cdecl _mm_mask_cmp_sh_mask(__mmask8, __m128h, __m128h, const int);
+extern __mmask8 __cdecl _mm_cmp_round_sh_mask(__m128h, __m128h, const int, const int);
+extern __mmask8 __cdecl _mm_mask_cmp_round_sh_mask(__mmask8, __m128h, __m128h, const int, const int);
+
+// VCOMISH
+extern int __cdecl _mm_comi_sh(__m128h, __m128h, const int);
+extern int __cdecl _mm_comi_round_sh(__m128h, __m128h, const int, const int);
+
+// VCVTDQ2PH
+extern __m128h __cdecl _mm_cvtepi32_ph(__m128i);
+extern __m128h __cdecl _mm_mask_cvtepi32_ph(__m128h, __mmask8, __m128i);
+extern __m128h __cdecl _mm_maskz_cvtepi32_ph(__mmask8, __m128i);
+extern __m128h __cdecl _mm256_cvtepi32_ph(__m256i);
+extern __m128h __cdecl _mm256_mask_cvtepi32_ph(__m128h, __mmask8, __m256i);
+extern __m128h __cdecl _mm256_maskz_cvtepi32_ph(__mmask8, __m256i);
+extern __m256h __cdecl _mm512_cvtepi32_ph (__m512i);
+extern __m256h __cdecl _mm512_mask_cvtepi32_ph (__m256h, __mmask16, __m512i);
+extern __m256h __cdecl _mm512_maskz_cvtepi32_ph (__mmask16, __m512i);
+extern __m256h __cdecl _mm512_cvt_roundepi32_ph(__m512i, int);
+extern __m256h __cdecl _mm512_mask_cvt_roundepi32_ph(__m256h, __mmask16, __m512i, int);
+extern __m256h __cdecl _mm512_maskz_cvt_roundepi32_ph(__mmask16, __m512i, int);
+
+//VCVTPD2PH
+extern __m128h __cdecl _mm_cvtpd_ph(__m128d);
+extern __m128h __cdecl _mm_mask_cvtpd_ph(__m128h, __mmask8, __m128d);
+extern __m128h __cdecl _mm_maskz_cvtpd_ph(__mmask8, __m128d);
+extern __m128h __cdecl _mm256_cvtpd_ph(__m256d);
+extern __m128h __cdecl _mm256_mask_cvtpd_ph(__m128h, __mmask8, __m256d);
+extern __m128h __cdecl _mm256_maskz_cvtpd_ph(__mmask8, __m256d);
+extern __m128h __cdecl _mm512_cvtpd_ph (__m512d);
+extern __m128h __cdecl _mm512_mask_cvtpd_ph (__m128h, __mmask8, __m512d);
+extern __m128h __cdecl _mm512_maskz_cvtpd_ph (__mmask8, __m512d);
+extern __m128h __cdecl _mm512_cvt_roundpd_ph(__m512d, int);
+extern __m128h __cdecl _mm512_mask_cvt_roundpd_ph(__m128h, __mmask8, __m512d, int);
+extern __m128h __cdecl _mm512_maskz_cvt_roundpd_ph(__mmask8, __m512d, int);
+
+// VCVTPH2DQ
+extern __m128i __cdecl _mm_cvtph_epi32(__m128h);
+extern __m128i __cdecl _mm_mask_cvtph_epi32(__m128i, __mmask8, __m128h);
+extern __m128i __cdecl _mm_maskz_cvtph_epi32(__mmask8, __m128h);
+extern __m256i __cdecl _mm256_cvtph_epi32(__m128h);
+extern __m256i __cdecl _mm256_mask_cvtph_epi32(__m256i, __mmask8, __m128h);
+extern __m256i __cdecl _mm256_maskz_cvtph_epi32(__mmask8, __m128h);
+extern __m512i __cdecl _mm512_cvtph_epi32 (__m256h);
+extern __m512i __cdecl _mm512_mask_cvtph_epi32 (__m512i, __mmask16, __m256h);
+extern __m512i __cdecl _mm512_maskz_cvtph_epi32 (__mmask16, __m256h);
+extern __m512i __cdecl _mm512_cvt_roundph_epi32(__m256h, int);
+extern __m512i __cdecl _mm512_mask_cvt_roundph_epi32(__m512i, __mmask16, __m256h, int);
+extern __m512i __cdecl _mm512_maskz_cvt_roundph_epi32(__mmask16, __m256h, int);
+
+// VCVTPH2PD
+extern __m128d __cdecl _mm_cvtph_pd(__m128h);
+extern __m128d __cdecl _mm_mask_cvtph_pd(__m128d, __mmask8, __m128h);
+extern __m128d __cdecl _mm_maskz_cvtph_pd(__mmask8, __m128h);
+extern __m256d __cdecl _mm256_cvtph_pd(__m128h);
+extern __m256d __cdecl _mm256_mask_cvtph_pd(__m256d, __mmask8, __m128h);
+extern __m256d __cdecl _mm256_maskz_cvtph_pd(__mmask8, __m128h);
+extern __m512d __cdecl _mm512_cvtph_pd (__m128h);
+extern __m512d __cdecl _mm512_mask_cvtph_pd (__m512d, __mmask8, __m128h);
+extern __m512d __cdecl _mm512_maskz_cvtph_pd (__mmask8, __m128h);
+extern __m512d __cdecl _mm512_cvt_roundph_pd(__m128h, int);
+extern __m512d __cdecl _mm512_mask_cvt_roundph_pd(__m512d, __mmask8, __m128h, int);
+extern __m512d __cdecl _mm512_maskz_cvt_roundph_pd(__mmask8, __m128h, int);
+
+// VCVTPH2PSX
+extern __m128 __cdecl _mm_cvtxph_ps(__m128h);
+extern __m128 __cdecl _mm_mask_cvtxph_ps(__m128, __mmask8, __m128h);
+extern __m128 __cdecl _mm_maskz_cvtxph_ps(__mmask8, __m128h);
+extern __m256 __cdecl _mm256_cvtxph_ps(__m128h);
+extern __m256 __cdecl _mm256_mask_cvtxph_ps(__m256, __mmask8, __m128h);
+extern __m256 __cdecl _mm256_maskz_cvtxph_ps(__mmask8, __m128h);
+extern __m512 __cdecl _mm512_cvtxph_ps(__m256h);
+extern __m512 __cdecl _mm512_mask_cvtxph_ps(__m512, __mmask16, __m256h);
+extern __m512 __cdecl _mm512_maskz_cvtxph_ps(__mmask16, __m256h);
+extern __m512 __cdecl _mm512_cvtx_roundph_ps(__m256h, int);
+extern __m512 __cdecl _mm512_mask_cvtx_roundph_ps(__m512, __mmask16, __m256h, int);
+extern __m512 __cdecl _mm512_maskz_cvtx_roundph_ps(__mmask16, __m256h, int);
+
+// VCVTPH2QQ
+extern __m128i __cdecl _mm_cvtph_epi64(__m128h);
+extern __m128i __cdecl _mm_mask_cvtph_epi64(__m128i, __mmask8, __m128h);
+extern __m128i __cdecl _mm_maskz_cvtph_epi64(__mmask8, __m128h);
+extern __m256i __cdecl _mm256_cvtph_epi64(__m128h);
+extern __m256i __cdecl _mm256_mask_cvtph_epi64(__m256i, __mmask8, __m128h);
+extern __m256i __cdecl _mm256_maskz_cvtph_epi64(__mmask8, __m128h);
+extern __m512i __cdecl _mm512_cvtph_epi64 (__m128h);
+extern __m512i __cdecl _mm512_mask_cvtph_epi64 (__m512i, __mmask8, __m128h);
+extern __m512i __cdecl _mm512_maskz_cvtph_epi64 (__mmask8, __m128h);
+extern __m512i __cdecl _mm512_cvt_roundph_epi64(__m128h, int);
+extern __m512i __cdecl _mm512_mask_cvt_roundph_epi64(__m512i, __mmask8, __m128h, int);
+extern __m512i __cdecl _mm512_maskz_cvt_roundph_epi64(__mmask8, __m128h, int);
+
+// VCVTPH2UDQ
+extern __m128i __cdecl _mm_cvtph_epu32(__m128h);
+extern __m128i __cdecl _mm_mask_cvtph_epu32(__m128i, __mmask8, __m128h);
+extern __m128i __cdecl _mm_maskz_cvtph_epu32(__mmask8, __m128h);
+extern __m256i __cdecl _mm256_cvtph_epu32(__m128h);
+extern __m256i __cdecl _mm256_mask_cvtph_epu32(__m256i, __mmask8, __m128h);
+extern __m256i __cdecl _mm256_maskz_cvtph_epu32(__mmask8, __m128h);
+extern __m512i __cdecl _mm512_cvtph_epu32 (__m256h);
+extern __m512i __cdecl _mm512_mask_cvtph_epu32 (__m512i, __mmask16, __m256h);
+extern __m512i __cdecl _mm512_maskz_cvtph_epu32 (__mmask16, __m256h);
+extern __m512i __cdecl _mm512_cvt_roundph_epu32(__m256h, int);
+extern __m512i __cdecl _mm512_mask_cvt_roundph_epu32(__m512i, __mmask16, __m256h, int);
+extern __m512i __cdecl _mm512_maskz_cvt_roundph_epu32(__mmask16, __m256h, int);
+
+// VCVTPH2UQQ
+extern __m128i __cdecl _mm_cvtph_epu64(__m128h);
+extern __m128i __cdecl _mm_mask_cvtph_epu64(__m128i, __mmask8, __m128h);
+extern __m128i __cdecl _mm_maskz_cvtph_epu64(__mmask8, __m128h);
+extern __m256i __cdecl _mm256_cvtph_epu64(__m128h);
+extern __m256i __cdecl _mm256_mask_cvtph_epu64(__m256i, __mmask8, __m128h);
+extern __m256i __cdecl _mm256_maskz_cvtph_epu64(__mmask8, __m128h);
+extern __m512i __cdecl _mm512_cvtph_epu64 (__m128h);
+extern __m512i __cdecl _mm512_mask_cvtph_epu64 (__m512i, __mmask8, __m128h);
+extern __m512i __cdecl _mm512_maskz_cvtph_epu64 (__mmask8, __m128h);
+extern __m512i __cdecl _mm512_cvt_roundph_epu64(__m128h, int);
+extern __m512i __cdecl _mm512_mask_cvt_roundph_epu64(__m512i, __mmask8, __m128h, int);
+extern __m512i __cdecl _mm512_maskz_cvt_roundph_epu64(__mmask8, __m128h, int);
+
+// VCVTPH2UW
+extern __m128i __cdecl _mm_cvtph_epu16(__m128h);
+extern __m128i __cdecl _mm_mask_cvtph_epu16(__m128i, __mmask8, __m128h);
+extern __m128i __cdecl _mm_maskz_cvtph_epu16(__mmask8, __m128h);
+extern __m256i __cdecl _mm256_cvtph_epu16(__m256h);
+extern __m256i __cdecl _mm256_mask_cvtph_epu16(__m256i, __mmask16, __m256h);
+extern __m256i __cdecl _mm256_maskz_cvtph_epu16(__mmask16, __m256h);
+extern __m512i __cdecl _mm512_cvtph_epu16 (__m512h);
+extern __m512i __cdecl _mm512_mask_cvtph_epu16 (__m512i, __mmask32, __m512h);
+extern __m512i __cdecl _mm512_maskz_cvtph_epu16 (__mmask32, __m512h);
+extern __m512i __cdecl _mm512_cvt_roundph_epu16(__m512h, int);
+extern __m512i __cdecl _mm512_mask_cvt_roundph_epu16(__m512i, __mmask32, __m512h, int);
+extern __m512i __cdecl _mm512_maskz_cvt_roundph_epu16(__mmask32, __m512h, int);
+
+// VCVTPH2W
+extern __m128i __cdecl _mm_cvtph_epi16(__m128h);
+extern __m128i __cdecl _mm_mask_cvtph_epi16(__m128i, __mmask8, __m128h);
+extern __m128i __cdecl _mm_maskz_cvtph_epi16(__mmask8, __m128h);
+extern __m256i __cdecl _mm256_cvtph_epi16(__m256h);
+extern __m256i __cdecl _mm256_mask_cvtph_epi16(__m256i, __mmask16, __m256h);
+extern __m256i __cdecl _mm256_maskz_cvtph_epi16(__mmask16, __m256h);
+extern __m512i __cdecl _mm512_cvtph_epi16 (__m512h);
+extern __m512i __cdecl _mm512_mask_cvtph_epi16 (__m512i, __mmask32, __m512h);
+extern __m512i __cdecl _mm512_maskz_cvtph_epi16 (__mmask32, __m512h);
+extern __m512i __cdecl _mm512_cvt_roundph_epi16(__m512h, int);
+extern __m512i __cdecl _mm512_mask_cvt_roundph_epi16(__m512i, __mmask32, __m512h, int);
+extern __m512i __cdecl _mm512_maskz_cvt_roundph_epi16(__mmask32, __m512h, int);
+
+// VCVTPS2PHX
+extern __m128h __cdecl _mm_cvtxps_ph(__m128);
+extern __m128h __cdecl _mm_mask_cvtxps_ph(__m128h, __mmask8, __m128);
+extern __m128h __cdecl _mm_maskz_cvtxps_ph(__mmask8, __m128);
+extern __m128h __cdecl _mm256_cvtxps_ph(__m256);
+extern __m128h __cdecl _mm256_mask_cvtxps_ph(__m128h, __mmask8, __m256);
+extern __m128h __cdecl _mm256_maskz_cvtxps_ph(__mmask8, __m256);
+extern __m256h __cdecl _mm512_cvtxps_ph(__m512);
+extern __m256h __cdecl _mm512_mask_cvtxps_ph(__m256h, __mmask16, __m512);
+extern __m256h __cdecl _mm512_maskz_cvtxps_ph(__mmask16, __m512);
+extern __m256h __cdecl _mm512_cvtx_roundps_ph(__m512, int);
+extern __m256h __cdecl _mm512_mask_cvtx_roundps_ph(__m256h, __mmask16, __m512, int);
+extern __m256h __cdecl _mm512_maskz_cvtx_roundps_ph(__mmask16, __m512, int);
+
+// VCVTQQ2PH
+extern __m128h __cdecl _mm_cvtepi64_ph(__m128i);
+extern __m128h __cdecl _mm_mask_cvtepi64_ph(__m128h, __mmask8, __m128i);
+extern __m128h __cdecl _mm_maskz_cvtepi64_ph(__mmask8, __m128i);
+extern __m128h __cdecl _mm256_cvtepi64_ph(__m256i);
+extern __m128h __cdecl _mm256_mask_cvtepi64_ph(__m128h, __mmask8, __m256i);
+extern __m128h __cdecl _mm256_maskz_cvtepi64_ph(__mmask8, __m256i);
+extern __m128h __cdecl _mm512_cvtepi64_ph (__m512i);
+extern __m128h __cdecl _mm512_mask_cvtepi64_ph (__m128h, __mmask8, __m512i);
+extern __m128h __cdecl _mm512_maskz_cvtepi64_ph (__mmask8, __m512i);
+extern __m128h __cdecl _mm512_cvt_roundepi64_ph(__m512i, int);
+extern __m128h __cdecl _mm512_mask_cvt_roundepi64_ph(__m128h, __mmask8, __m512i, int);
+extern __m128h __cdecl _mm512_maskz_cvt_roundepi64_ph(__mmask8, __m512i, int);
+
+// VCVTSD2SH
+extern __m128h __cdecl _mm_cvtsd_sh(__m128h, __m128d);
+extern __m128h __cdecl _mm_mask_cvtsd_sh(__m128h, __mmask8, __m128h, __m128d);
+extern __m128h __cdecl _mm_maskz_cvtsd_sh(__mmask8, __m128h, __m128d);
+extern __m128h __cdecl _mm_cvt_roundsd_sh(__m128h, __m128d, const int);
+extern __m128h __cdecl _mm_mask_cvt_roundsd_sh(__m128h, __mmask8, __m128h, __m128d, const int);
+extern __m128h __cdecl _mm_maskz_cvt_roundsd_sh(__mmask8, __m128h, __m128d, const int);
+
+// VCVTSH2SD
+extern __m128d __cdecl _mm_cvtsh_sd(__m128d, __m128h);
+extern __m128d __cdecl _mm_mask_cvtsh_sd(__m128d, __mmask8, __m128d, __m128h);
+extern __m128d __cdecl _mm_maskz_cvtsh_sd(__mmask8, __m128d, __m128h);
+extern __m128d __cdecl _mm_cvt_roundsh_sd(__m128d, __m128h, const int);
+extern __m128d __cdecl _mm_mask_cvt_roundsh_sd(__m128d, __mmask8, __m128d, __m128h, const int);
+extern __m128d __cdecl _mm_maskz_cvt_roundsh_sd(__mmask8, __m128d, __m128h, const int);
+
+// VCVTSH2SI
+extern int __cdecl _mm_cvtsh_i32(__m128h);
+extern __int64 __cdecl _mm_cvtsh_i64(__m128h);
+extern int __cdecl _mm_cvt_roundsh_i32(__m128h, int);
+extern __int64 __cdecl _mm_cvt_roundsh_i64(__m128h, int);
+
+// VCVTSH2SS
+extern __m128 __cdecl _mm_cvtsh_ss(__m128, __m128h);
+extern __m128 __cdecl _mm_mask_cvtsh_ss(__m128, __mmask8, __m128, __m128h);
+extern __m128 __cdecl _mm_maskz_cvtsh_ss(__mmask8, __m128, __m128h);
+extern __m128 __cdecl _mm_cvt_roundsh_ss(__m128, __m128h, const int);
+extern __m128 __cdecl _mm_mask_cvt_roundsh_ss(__m128, __mmask8, __m128, __m128h, const int);
+extern __m128 __cdecl _mm_maskz_cvt_roundsh_ss(__mmask8, __m128, __m128h, const int);
+
+// VCVTSH2USI
+extern unsigned int __cdecl _mm_cvtsh_u32(__m128h);
+extern unsigned __int64 __cdecl _mm_cvtsh_u64(__m128h);
+extern unsigned int __cdecl _mm_cvt_roundsh_u32(__m128h, int);
+extern unsigned __int64 __cdecl _mm_cvt_roundsh_u64(__m128h, int);
+
+// VCVTSI2SH
+extern __m128h __cdecl _mm_cvti32_sh(__m128h, int);
+extern __m128h __cdecl _mm_cvti64_sh(__m128h, __int64);
+extern __m128h __cdecl _mm_cvt_roundi32_sh(__m128h, int, int);
+extern __m128h __cdecl _mm_cvt_roundi64_sh(__m128h, __int64, int);
+
+// VCVTSS2SH
+extern __m128h __cdecl _mm_cvtss_sh(__m128h, __m128);
+extern __m128h __cdecl _mm_mask_cvtss_sh(__m128h, __mmask8, __m128h, __m128);
+extern __m128h __cdecl _mm_maskz_cvtss_sh(__mmask8, __m128h, __m128);
+extern __m128h __cdecl _mm_cvt_roundss_sh(__m128h, __m128, const int);
+extern __m128h __cdecl _mm_mask_cvt_roundss_sh(__m128h, __mmask8, __m128h, __m128, const int);
+extern __m128h __cdecl _mm_maskz_cvt_roundss_sh(__mmask8, __m128h, __m128, const int);
+
+// VCVTTPH2DQ
+extern __m128i __cdecl _mm_cvttph_epi32(__m128h);
+extern __m128i __cdecl _mm_mask_cvttph_epi32(__m128i, __mmask8, __m128h);
+extern __m128i __cdecl _mm_maskz_cvttph_epi32(__mmask8, __m128h);
+extern __m256i __cdecl _mm256_cvttph_epi32(__m128h);
+extern __m256i __cdecl _mm256_mask_cvttph_epi32(__m256i, __mmask8, __m128h);
+extern __m256i __cdecl _mm256_maskz_cvttph_epi32(__mmask8, __m128h);
+extern __m512i __cdecl _mm512_cvttph_epi32 (__m256h);
+extern __m512i __cdecl _mm512_mask_cvttph_epi32 (__m512i, __mmask16, __m256h);
+extern __m512i __cdecl _mm512_maskz_cvttph_epi32 (__mmask16, __m256h);
+extern __m512i __cdecl _mm512_cvtt_roundph_epi32(__m256h, int);
+extern __m512i __cdecl _mm512_mask_cvtt_roundph_epi32(__m512i, __mmask16, __m256h, int);
+extern __m512i __cdecl _mm512_maskz_cvtt_roundph_epi32(__mmask16, __m256h, int);
+
+// VCVTTPH2QQ
+extern __m128i __cdecl _mm_cvttph_epi64(__m128h);
+extern __m128i __cdecl _mm_mask_cvttph_epi64(__m128i, __mmask8, __m128h);
+extern __m128i __cdecl _mm_maskz_cvttph_epi64(__mmask8, __m128h);
+extern __m256i __cdecl _mm256_cvttph_epi64(__m128h);
+extern __m256i __cdecl _mm256_mask_cvttph_epi64(__m256i, __mmask8, __m128h);
+extern __m256i __cdecl _mm256_maskz_cvttph_epi64(__mmask8, __m128h);
+extern __m512i __cdecl _mm512_cvttph_epi64 (__m128h);
+extern __m512i __cdecl _mm512_mask_cvttph_epi64 (__m512i, __mmask8, __m128h);
+extern __m512i __cdecl _mm512_maskz_cvttph_epi64 (__mmask8, __m128h);
+extern __m512i __cdecl _mm512_cvtt_roundph_epi64(__m128h, int);
+extern __m512i __cdecl _mm512_mask_cvtt_roundph_epi64(__m512i, __mmask8, __m128h, int);
+extern __m512i __cdecl _mm512_maskz_cvtt_roundph_epi64(__mmask8, __m128h, int);
+
+// VCVTTPH2UDQ
+extern __m128i __cdecl _mm_cvttph_epu32(__m128h);
+extern __m128i __cdecl _mm_mask_cvttph_epu32(__m128i, __mmask8, __m128h);
+extern __m128i __cdecl _mm_maskz_cvttph_epu32(__mmask8, __m128h);
+extern __m256i __cdecl _mm256_cvttph_epu32(__m128h);
+extern __m256i __cdecl _mm256_mask_cvttph_epu32(__m256i, __mmask8, __m128h);
+extern __m256i __cdecl _mm256_maskz_cvttph_epu32(__mmask8, __m128h);
+extern __m512i __cdecl _mm512_cvttph_epu32 (__m256h);
+extern __m512i __cdecl _mm512_mask_cvttph_epu32 (__m512i, __mmask16, __m256h);
+extern __m512i __cdecl _mm512_maskz_cvttph_epu32 (__mmask16, __m256h);
+extern __m512i __cdecl _mm512_cvtt_roundph_epu32(__m256h, int);
+extern __m512i __cdecl _mm512_mask_cvtt_roundph_epu32(__m512i, __mmask16, __m256h, int);
+extern __m512i __cdecl _mm512_maskz_cvtt_roundph_epu32(__mmask16, __m256h, int);
+
+// VCVTTPH2UQQ
+extern __m128i __cdecl _mm_cvttph_epu64(__m128h);
+extern __m128i __cdecl _mm_mask_cvttph_epu64(__m128i, __mmask8, __m128h);
+extern __m128i __cdecl _mm_maskz_cvttph_epu64(__mmask8, __m128h);
+extern __m256i __cdecl _mm256_cvttph_epu64(__m128h);
+extern __m256i __cdecl _mm256_mask_cvttph_epu64(__m256i, __mmask8, __m128h);
+extern __m256i __cdecl _mm256_maskz_cvttph_epu64(__mmask8, __m128h);
+extern __m512i __cdecl _mm512_cvttph_epu64 (__m128h);
+extern __m512i __cdecl _mm512_mask_cvttph_epu64 (__m512i, __mmask8, __m128h);
+extern __m512i __cdecl _mm512_maskz_cvttph_epu64 (__mmask8, __m128h);
+extern __m512i __cdecl _mm512_cvtt_roundph_epu64(__m128h, int);
+extern __m512i __cdecl _mm512_mask_cvtt_roundph_epu64(__m512i, __mmask8, __m128h, int);
+extern __m512i __cdecl _mm512_maskz_cvtt_roundph_epu64(__mmask8, __m128h, int);
+
+// VCVTTPH2UW
+extern __m128i __cdecl _mm_cvttph_epu16(__m128h);
+extern __m128i __cdecl _mm_mask_cvttph_epu16(__m128i, __mmask8, __m128h);
+extern __m128i __cdecl _mm_maskz_cvttph_epu16(__mmask8, __m128h);
+extern __m256i __cdecl _mm256_cvttph_epu16(__m256h);
+extern __m256i __cdecl _mm256_mask_cvttph_epu16(__m256i, __mmask16, __m256h);
+extern __m256i __cdecl _mm256_maskz_cvttph_epu16(__mmask16, __m256h);
+extern __m512i __cdecl _mm512_cvttph_epu16 (__m512h);
+extern __m512i __cdecl _mm512_mask_cvttph_epu16 (__m512i, __mmask32, __m512h);
+extern __m512i __cdecl _mm512_maskz_cvttph_epu16 (__mmask32, __m512h);
+extern __m512i __cdecl _mm512_cvtt_roundph_epu16(__m512h, int);
+extern __m512i __cdecl _mm512_mask_cvtt_roundph_epu16(__m512i, __mmask32, __m512h, int);
+extern __m512i __cdecl _mm512_maskz_cvtt_roundph_epu16(__mmask32, __m512h, int);
+
+// VCVTTPH2W
+extern __m128i __cdecl _mm_cvttph_epi16(__m128h);
+extern __m128i __cdecl _mm_mask_cvttph_epi16(__m128i, __mmask8, __m128h);
+extern __m128i __cdecl _mm_maskz_cvttph_epi16(__mmask8, __m128h);
+extern __m256i __cdecl _mm256_cvttph_epi16(__m256h);
+extern __m256i __cdecl _mm256_mask_cvttph_epi16(__m256i, __mmask16, __m256h);
+extern __m256i __cdecl _mm256_maskz_cvttph_epi16(__mmask16, __m256h);
+extern __m512i __cdecl _mm512_cvttph_epi16 (__m512h);
+extern __m512i __cdecl _mm512_mask_cvttph_epi16 (__m512i, __mmask32, __m512h);
+extern __m512i __cdecl _mm512_maskz_cvttph_epi16 (__mmask32, __m512h);
+extern __m512i __cdecl _mm512_cvtt_roundph_epi16(__m512h, int);
+extern __m512i __cdecl _mm512_mask_cvtt_roundph_epi16(__m512i, __mmask32, __m512h, int);
+extern __m512i __cdecl _mm512_maskz_cvtt_roundph_epi16(__mmask32, __m512h, int);
+
+// VCVTTSH2SI
+extern int __cdecl _mm_cvttsh_i32(__m128h);
+extern __int64 __cdecl _mm_cvttsh_i64(__m128h);
+extern int __cdecl _mm_cvtt_roundsh_i32(__m128h, int);
+extern __int64 __cdecl _mm_cvtt_roundsh_i64(__m128h, int);
+
+// VCVTTSH2USI
+extern unsigned int __cdecl _mm_cvttsh_u32(__m128h);
+extern unsigned __int64 __cdecl _mm_cvttsh_u64(__m128h);
+extern unsigned int __cdecl _mm_cvtt_roundsh_u32(__m128h, int);
+extern unsigned __int64 __cdecl _mm_cvtt_roundsh_u64(__m128h, int);
+
+//VCVTUDQ2PH
+extern __m128h __cdecl _mm_cvtepu32_ph(__m128i);
+extern __m128h __cdecl _mm_mask_cvtepu32_ph(__m128h, __mmask8, __m128i);
+extern __m128h __cdecl _mm_maskz_cvtepu32_ph(__mmask8, __m128i);
+extern __m128h __cdecl _mm256_cvtepu32_ph(__m256i);
+extern __m128h __cdecl _mm256_mask_cvtepu32_ph(__m128h, __mmask8, __m256i);
+extern __m128h __cdecl _mm256_maskz_cvtepu32_ph(__mmask8, __m256i);
+extern __m256h __cdecl _mm512_cvtepu32_ph (__m512i);
+extern __m256h __cdecl _mm512_mask_cvtepu32_ph (__m256h, __mmask16, __m512i);
+extern __m256h __cdecl _mm512_maskz_cvtepu32_ph (__mmask16, __m512i);
+extern __m256h __cdecl _mm512_cvt_roundepu32_ph(__m512i, int);
+extern __m256h __cdecl _mm512_mask_cvt_roundepu32_ph(__m256h, __mmask16, __m512i, int);
+extern __m256h __cdecl _mm512_maskz_cvt_roundepu32_ph(__mmask16, __m512i, int);
+
+// VCVTUQQ2PH
+extern __m128h __cdecl _mm_cvtepu64_ph(__m128i);
+extern __m128h __cdecl _mm_mask_cvtepu64_ph(__m128h, __mmask8, __m128i);
+extern __m128h __cdecl _mm_maskz_cvtepu64_ph(__mmask8, __m128i);
+extern __m128h __cdecl _mm256_cvtepu64_ph(__m256i);
+extern __m128h __cdecl _mm256_mask_cvtepu64_ph(__m128h, __mmask8, __m256i);
+extern __m128h __cdecl _mm256_maskz_cvtepu64_ph(__mmask8, __m256i);
+extern __m128h __cdecl _mm512_cvtepu64_ph (__m512i);
+extern __m128h __cdecl _mm512_mask_cvtepu64_ph (__m128h, __mmask8, __m512i);
+extern __m128h __cdecl _mm512_maskz_cvtepu64_ph (__mmask8, __m512i);
+extern __m128h __cdecl _mm512_cvt_roundepu64_ph(__m512i, int);
+extern __m128h __cdecl _mm512_mask_cvt_roundepu64_ph(__m128h, __mmask8, __m512i, int);
+extern __m128h __cdecl _mm512_maskz_cvt_roundepu64_ph(__mmask8, __m512i, int);
+
+// VCVTUSI2SH
+extern __m128h __cdecl _mm_cvtu32_sh(__m128h, unsigned int);
+extern __m128h __cdecl _mm_cvtu64_sh(__m128h, unsigned __int64);
+extern __m128h __cdecl _mm_cvt_roundu32_sh(__m128h, unsigned int, int);
+extern __m128h __cdecl _mm_cvt_roundu64_sh(__m128h, unsigned __int64, int);
+
+// VCVTUW2PH
+extern __m128h __cdecl _mm_cvtepu16_ph(__m128i);
+extern __m128h __cdecl _mm_mask_cvtepu16_ph(__m128h, __mmask8, __m128i);
+extern __m128h __cdecl _mm_maskz_cvtepu16_ph(__mmask8, __m128i);
+extern __m256h __cdecl _mm256_cvtepu16_ph(__m256i);
+extern __m256h __cdecl _mm256_mask_cvtepu16_ph(__m256h, __mmask16, __m256i);
+extern __m256h __cdecl _mm256_maskz_cvtepu16_ph(__mmask16, __m256i);
+extern __m512h __cdecl _mm512_cvtepu16_ph (__m512i);
+extern __m512h __cdecl _mm512_mask_cvtepu16_ph (__m512h, __mmask32, __m512i);
+extern __m512h __cdecl _mm512_maskz_cvtepu16_ph (__mmask32, __m512i);
+extern __m512h __cdecl _mm512_cvt_roundepu16_ph(__m512i, int);
+extern __m512h __cdecl _mm512_mask_cvt_roundepu16_ph(__m512h, __mmask32, __m512i, int);
+extern __m512h __cdecl _mm512_maskz_cvt_roundepu16_ph(__mmask32, __m512i, int);
+
+// VCVTW2PH
+extern __m128h __cdecl _mm_cvtepi16_ph(__m128i);
+extern __m128h __cdecl _mm_mask_cvtepi16_ph(__m128h, __mmask8, __m128i);
+extern __m128h __cdecl _mm_maskz_cvtepi16_ph(__mmask8, __m128i);
+extern __m256h __cdecl _mm256_cvtepi16_ph(__m256i);
+extern __m256h __cdecl _mm256_mask_cvtepi16_ph(__m256h, __mmask16, __m256i);
+extern __m256h __cdecl _mm256_maskz_cvtepi16_ph(__mmask16, __m256i);
+extern __m512h __cdecl _mm512_cvtepi16_ph (__m512i);
+extern __m512h __cdecl _mm512_mask_cvtepi16_ph (__m512h, __mmask32, __m512i);
+extern __m512h __cdecl _mm512_maskz_cvtepi16_ph (__mmask32, __m512i);
+extern __m512h __cdecl _mm512_cvt_roundepi16_ph(__m512i, int);
+extern __m512h __cdecl _mm512_mask_cvt_roundepi16_ph(__m512h, __mmask32, __m512i, int);
+extern __m512h __cdecl _mm512_maskz_cvt_roundepi16_ph(__mmask32, __m512i, int);
+
+// VDIVPH
+extern __m128h __cdecl _mm_div_ph(__m128h, __m128h);
+extern __m128h __cdecl _mm_mask_div_ph(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_maskz_div_ph(__mmask8, __m128h, __m128h);
+extern __m256h __cdecl _mm256_div_ph(__m256h, __m256h);
+extern __m256h __cdecl _mm256_mask_div_ph(__m256h, __mmask16, __m256h, __m256h);
+extern __m256h __cdecl _mm256_maskz_div_ph(__mmask16, __m256h, __m256h);
+extern __m512h __cdecl _mm512_div_ph(__m512h, __m512h);
+extern __m512h __cdecl _mm512_mask_div_ph(__m512h, __mmask32, __m512h, __m512h);
+extern __m512h __cdecl _mm512_maskz_div_ph(__mmask32, __m512h, __m512h);
+extern __m512h __cdecl _mm512_div_round_ph(__m512h, __m512h, int);
+extern __m512h __cdecl _mm512_mask_div_round_ph(__m512h, __mmask32, __m512h, __m512h, int);
+extern __m512h __cdecl _mm512_maskz_div_round_ph(__mmask32, __m512h, __m512h, int);
+
+// VDIVSH
+extern __m128h __cdecl _mm_div_sh(__m128h, __m128h);
+extern __m128h __cdecl _mm_mask_div_sh(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_maskz_div_sh(__mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_div_round_sh(__m128h, __m128h, int);
+extern __m128h __cdecl _mm_mask_div_round_sh(__m128h, __mmask8, __m128h, __m128h, int);
+extern __m128h __cdecl _mm_maskz_div_round_sh(__mmask8, __m128h, __m128h, int);
+
+// VFMADDSUB[132,213,231]PH
+extern __m128h __cdecl _mm_fmaddsub_ph(__m128h, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask_fmaddsub_ph(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask3_fmaddsub_ph(__m128h, __m128h, __m128h, __mmask8);
+extern __m128h __cdecl _mm_maskz_fmaddsub_ph(__mmask8, __m128h, __m128h, __m128h);
+extern __m256h __cdecl _mm256_fmaddsub_ph(__m256h, __m256h, __m256h);
+extern __m256h __cdecl _mm256_mask_fmaddsub_ph(__m256h, __mmask16, __m256h, __m256h);
+extern __m256h __cdecl _mm256_mask3_fmaddsub_ph(__m256h, __m256h, __m256h, __mmask16);
+extern __m256h __cdecl _mm256_maskz_fmaddsub_ph(__mmask16, __m256h, __m256h, __m256h);
+extern __m512h __cdecl _mm512_fmaddsub_ph(__m512h, __m512h, __m512h);
+extern __m512h __cdecl _mm512_mask_fmaddsub_ph(__m512h, __mmask32, __m512h, __m512h);
+extern __m512h __cdecl _mm512_mask3_fmaddsub_ph(__m512h, __m512h, __m512h, __mmask32);
+extern __m512h __cdecl _mm512_maskz_fmaddsub_ph(__mmask32, __m512h, __m512h, __m512h);
+extern __m512h __cdecl _mm512_fmaddsub_round_ph(__m512h, __m512h, __m512h, const int);
+extern __m512h __cdecl _mm512_mask_fmaddsub_round_ph(__m512h, __mmask32, __m512h, __m512h, const int);
+extern __m512h __cdecl _mm512_mask3_fmaddsub_round_ph(__m512h, __m512h, __m512h, __mmask32, const int);
+extern __m512h __cdecl _mm512_maskz_fmaddsub_round_ph(__mmask32, __m512h, __m512h, __m512h, const int);
+
+// VFMSUBADD[132,213,231]PH
+extern __m128h __cdecl _mm_fmsubadd_ph(__m128h, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask_fmsubadd_ph(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask3_fmsubadd_ph(__m128h, __m128h, __m128h, __mmask8);
+extern __m128h __cdecl _mm_maskz_fmsubadd_ph(__mmask8, __m128h, __m128h, __m128h);
+extern __m256h __cdecl _mm256_fmsubadd_ph(__m256h, __m256h, __m256h);
+extern __m256h __cdecl _mm256_mask_fmsubadd_ph(__m256h, __mmask16, __m256h, __m256h);
+extern __m256h __cdecl _mm256_mask3_fmsubadd_ph(__m256h, __m256h, __m256h, __mmask16);
+extern __m256h __cdecl _mm256_maskz_fmsubadd_ph(__mmask16, __m256h, __m256h, __m256h);
+extern __m512h __cdecl _mm512_fmsubadd_ph(__m512h, __m512h, __m512h);
+extern __m512h __cdecl _mm512_mask_fmsubadd_ph(__m512h, __mmask32, __m512h, __m512h);
+extern __m512h __cdecl _mm512_mask3_fmsubadd_ph(__m512h, __m512h, __m512h, __mmask32);
+extern __m512h __cdecl _mm512_maskz_fmsubadd_ph(__mmask32, __m512h, __m512h, __m512h);
+extern __m512h __cdecl _mm512_fmsubadd_round_ph(__m512h, __m512h, __m512h, const int);
+extern __m512h __cdecl _mm512_mask_fmsubadd_round_ph(__m512h, __mmask32, __m512h, __m512h, const int);
+extern __m512h __cdecl _mm512_mask3_fmsubadd_round_ph(__m512h, __m512h, __m512h, __mmask32, const int);
+extern __m512h __cdecl _mm512_maskz_fmsubadd_round_ph(__mmask32, __m512h, __m512h, __m512h, const int);
+
+// VFPCLASSPH
+extern __mmask8 __cdecl _mm_fpclass_ph_mask(__m128h, int);
+extern __mmask8 __cdecl _mm_mask_fpclass_ph_mask(__mmask8, __m128h, int);
+extern __mmask16 __cdecl _mm256_fpclass_ph_mask(__m256h, int);
+extern __mmask16 __cdecl _mm256_mask_fpclass_ph_mask(__mmask16, __m256h, int);
+extern __mmask32 __cdecl _mm512_fpclass_ph_mask(__m512h, int);
+extern __mmask32 __cdecl _mm512_mask_fpclass_ph_mask(__mmask32, __m512h, int);
+
+// VFPCLASSSH
+extern __mmask8 __cdecl _mm_fpclass_sh_mask(__m128h, int);
+extern __mmask8 __cdecl _mm_mask_fpclass_sh_mask(__mmask8, __m128h, int);
+
+// VF[,C]MADDCPH
+extern __m128h __cdecl _mm_fmadd_pch(__m128h, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask_fmadd_pch(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask3_fmadd_pch(__m128h, __m128h, __m128h, __mmask8);
+extern __m128h __cdecl _mm_maskz_fmadd_pch(__mmask8, __m128h, __m128h, __m128h);
+extern __m256h __cdecl _mm256_fmadd_pch(__m256h, __m256h, __m256h);
+extern __m256h __cdecl _mm256_mask_fmadd_pch(__m256h, __mmask8, __m256h, __m256h);
+extern __m256h __cdecl _mm256_mask3_fmadd_pch(__m256h, __m256h, __m256h, __mmask8);
+extern __m256h __cdecl _mm256_maskz_fmadd_pch(__mmask8, __m256h, __m256h, __m256h);
+extern __m512h __cdecl _mm512_fmadd_pch(__m512h, __m512h, __m512h);
+extern __m512h __cdecl _mm512_mask_fmadd_pch(__m512h, __mmask16, __m512h, __m512h);
+extern __m512h __cdecl _mm512_mask3_fmadd_pch(__m512h, __m512h, __m512h, __mmask16);
+extern __m512h __cdecl _mm512_maskz_fmadd_pch(__mmask16, __m512h, __m512h, __m512h);
+extern __m512h __cdecl _mm512_fmadd_round_pch(__m512h, __m512h, __m512h, const int);
+extern __m512h __cdecl _mm512_mask_fmadd_round_pch(__m512h, __mmask16, __m512h, __m512h, const int);
+extern __m512h __cdecl _mm512_mask3_fmadd_round_pch(__m512h, __m512h, __m512h, __mmask16, const int);
+extern __m512h __cdecl _mm512_maskz_fmadd_round_pch(__mmask16, __m512h, __m512h, __m512h, const int);
+extern __m128h __cdecl _mm_fcmadd_pch(__m128h, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask_fcmadd_pch(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask3_fcmadd_pch(__m128h, __m128h, __m128h, __mmask8);
+extern __m128h __cdecl _mm_maskz_fcmadd_pch(__mmask8, __m128h, __m128h, __m128h);
+extern __m256h __cdecl _mm256_fcmadd_pch(__m256h, __m256h, __m256h);
+extern __m256h __cdecl _mm256_mask_fcmadd_pch(__m256h, __mmask8, __m256h, __m256h);
+extern __m256h __cdecl _mm256_mask3_fcmadd_pch(__m256h, __m256h, __m256h, __mmask8);
+extern __m256h __cdecl _mm256_maskz_fcmadd_pch(__mmask8, __m256h, __m256h, __m256h);
+extern __m512h __cdecl _mm512_fcmadd_pch(__m512h, __m512h, __m512h);
+extern __m512h __cdecl _mm512_mask_fcmadd_pch(__m512h, __mmask16, __m512h, __m512h);
+extern __m512h __cdecl _mm512_mask3_fcmadd_pch(__m512h, __m512h, __m512h, __mmask16);
+extern __m512h __cdecl _mm512_maskz_fcmadd_pch(__mmask16, __m512h, __m512h, __m512h);
+extern __m512h __cdecl _mm512_fcmadd_round_pch(__m512h, __m512h, __m512h, const int);
+extern __m512h __cdecl _mm512_mask_fcmadd_round_pch(__m512h, __mmask16, __m512h, __m512h, const int);
+extern __m512h __cdecl _mm512_mask3_fcmadd_round_pch(__m512h, __m512h, __m512h, __mmask16, const int);
+extern __m512h __cdecl _mm512_maskz_fcmadd_round_pch(__mmask16, __m512h, __m512h, __m512h, const int);
+
+// VF[,C]MADDCSH
+extern __m128h __cdecl _mm_fcmadd_sch(__m128h, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask_fcmadd_sch(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask3_fcmadd_sch(__m128h, __m128h, __m128h, __mmask8);
+extern __m128h __cdecl _mm_maskz_fcmadd_sch(__mmask8, __m128h, __m128h, __m128h);
+extern __m128h __cdecl _mm_fcmadd_round_sch(__m128h, __m128h, __m128h, const int);
+extern __m128h __cdecl _mm_mask_fcmadd_round_sch(__m128h, __mmask8, __m128h, __m128h, const int);
+extern __m128h __cdecl _mm_mask3_fcmadd_round_sch(__m128h, __m128h, __m128h, __mmask8, const int);
+extern __m128h __cdecl _mm_maskz_fcmadd_round_sch(__mmask8, __m128h, __m128h, __m128h, const int);
+extern __m128h __cdecl _mm_fmadd_sch(__m128h, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask_fmadd_sch(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask3_fmadd_sch(__m128h, __m128h, __m128h, __mmask8);
+extern __m128h __cdecl _mm_maskz_fmadd_sch(__mmask8, __m128h, __m128h, __m128h);
+extern __m128h __cdecl _mm_fmadd_round_sch(__m128h, __m128h, __m128h, const int);
+extern __m128h __cdecl _mm_mask_fmadd_round_sch(__m128h, __mmask8, __m128h, __m128h, const int);
+extern __m128h __cdecl _mm_mask3_fmadd_round_sch(__m128h, __m128h, __m128h, __mmask8, const int);
+extern __m128h __cdecl _mm_maskz_fmadd_round_sch(__mmask8, __m128h, __m128h, __m128h, const int);
+
+// VF[,C]MULCPH
+extern __m128h __cdecl _mm_fcmul_pch(__m128h, __m128h);
+extern __m128h __cdecl _mm_mask_fcmul_pch(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_maskz_fcmul_pch(__mmask8, __m128h, __m128h);
+extern __m256h __cdecl _mm256_fcmul_pch(__m256h, __m256h);
+extern __m256h __cdecl _mm256_mask_fcmul_pch(__m256h, __mmask8, __m256h, __m256h);
+extern __m256h __cdecl _mm256_maskz_fcmul_pch(__mmask8, __m256h, __m256h);
+extern __m512h __cdecl _mm512_fcmul_pch(__m512h, __m512h);
+extern __m512h __cdecl _mm512_mask_fcmul_pch(__m512h, __mmask16, __m512h, __m512h);
+extern __m512h __cdecl _mm512_maskz_fcmul_pch(__mmask16, __m512h, __m512h);
+extern __m512h __cdecl _mm512_fcmul_round_pch(__m512h, __m512h, const int);
+extern __m512h __cdecl _mm512_mask_fcmul_round_pch(__m512h, __mmask16, __m512h, __m512h, const int);
+extern __m512h __cdecl _mm512_maskz_fcmul_round_pch(__mmask16, __m512h, __m512h, const int);
+extern __m128h __cdecl _mm_fmul_pch(__m128h, __m128h);
+extern __m128h __cdecl _mm_mask_fmul_pch(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_maskz_fmul_pch(__mmask8, __m128h, __m128h);
+extern __m256h __cdecl _mm256_fmul_pch(__m256h, __m256h);
+extern __m256h __cdecl _mm256_mask_fmul_pch(__m256h, __mmask8, __m256h, __m256h);
+extern __m256h __cdecl _mm256_maskz_fmul_pch(__mmask8, __m256h, __m256h);
+extern __m512h __cdecl _mm512_fmul_pch(__m512h, __m512h);
+extern __m512h __cdecl _mm512_mask_fmul_pch(__m512h, __mmask16, __m512h, __m512h);
+extern __m512h __cdecl _mm512_maskz_fmul_pch(__mmask16, __m512h, __m512h);
+extern __m512h __cdecl _mm512_fmul_round_pch(__m512h, __m512h, const int);
+extern __m512h __cdecl _mm512_mask_fmul_round_pch(__m512h, __mmask16, __m512h, __m512h, const int);
+extern __m512h __cdecl _mm512_maskz_fmul_round_pch(__mmask16, __m512h, __m512h, const int);
+
+// VF[,C]MULCSH
+extern __m128h __cdecl _mm_fcmul_sch(__m128h, __m128h);
+extern __m128h __cdecl _mm_mask_fcmul_sch(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_maskz_fcmul_sch(__mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_fcmul_round_sch(__m128h, __m128h, const int);
+extern __m128h __cdecl _mm_mask_fcmul_round_sch(__m128h, __mmask8, __m128h, __m128h, const int);
+extern __m128h __cdecl _mm_maskz_fcmul_round_sch(__mmask8, __m128h, __m128h, const int);
+extern __m128h __cdecl _mm_fmul_sch(__m128h, __m128h);
+extern __m128h __cdecl _mm_mask_fmul_sch(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_maskz_fmul_sch(__mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_fmul_round_sch(__m128h, __m128h, const int);
+extern __m128h __cdecl _mm_mask_fmul_round_sch(__m128h, __mmask8, __m128h, __m128h, const int);
+extern __m128h __cdecl _mm_maskz_fmul_round_sch(__mmask8, __m128h, __m128h, const int);
+
+// VF[,N]MADD[132,213,231]PH
+extern __m128h __cdecl _mm_fnmadd_ph(__m128h, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask_fnmadd_ph(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask3_fnmadd_ph(__m128h, __m128h, __m128h, __mmask8);
+extern __m128h __cdecl _mm_maskz_fnmadd_ph(__mmask8, __m128h, __m128h, __m128h);
+extern __m256h __cdecl _mm256_fnmadd_ph(__m256h, __m256h, __m256h);
+extern __m256h __cdecl _mm256_mask_fnmadd_ph(__m256h, __mmask16, __m256h, __m256h);
+extern __m256h __cdecl _mm256_mask3_fnmadd_ph(__m256h, __m256h, __m256h, __mmask16);
+extern __m256h __cdecl _mm256_maskz_fnmadd_ph(__mmask16, __m256h, __m256h, __m256h);
+extern __m512h __cdecl _mm512_fnmadd_ph(__m512h, __m512h, __m512h);
+extern __m512h __cdecl _mm512_mask_fnmadd_ph(__m512h, __mmask32, __m512h, __m512h);
+extern __m512h __cdecl _mm512_mask3_fnmadd_ph(__m512h, __m512h, __m512h, __mmask32);
+extern __m512h __cdecl _mm512_maskz_fnmadd_ph(__mmask32, __m512h, __m512h, __m512h);
+extern __m512h __cdecl _mm512_fnmadd_round_ph(__m512h, __m512h, __m512h, const int);
+extern __m512h __cdecl _mm512_mask_fnmadd_round_ph(__m512h, __mmask32, __m512h, __m512h, const int);
+extern __m512h __cdecl _mm512_mask3_fnmadd_round_ph(__m512h, __m512h, __m512h, __mmask32, const int);
+extern __m512h __cdecl _mm512_maskz_fnmadd_round_ph(__mmask32, __m512h, __m512h, __m512h, const int);
+extern __m128h __cdecl _mm_fmadd_ph(__m128h, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask_fmadd_ph(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask3_fmadd_ph(__m128h, __m128h, __m128h, __mmask8);
+extern __m128h __cdecl _mm_maskz_fmadd_ph(__mmask8, __m128h, __m128h, __m128h);
+extern __m256h __cdecl _mm256_fmadd_ph(__m256h, __m256h, __m256h);
+extern __m256h __cdecl _mm256_mask_fmadd_ph(__m256h, __mmask16, __m256h, __m256h);
+extern __m256h __cdecl _mm256_mask3_fmadd_ph(__m256h, __m256h, __m256h, __mmask16);
+extern __m256h __cdecl _mm256_maskz_fmadd_ph(__mmask16, __m256h, __m256h, __m256h);
+extern __m512h __cdecl _mm512_fmadd_ph(__m512h, __m512h, __m512h);
+extern __m512h __cdecl _mm512_mask_fmadd_ph(__m512h, __mmask32, __m512h, __m512h);
+extern __m512h __cdecl _mm512_mask3_fmadd_ph(__m512h, __m512h, __m512h, __mmask32);
+extern __m512h __cdecl _mm512_maskz_fmadd_ph(__mmask32, __m512h, __m512h, __m512h);
+extern __m512h __cdecl _mm512_fmadd_round_ph(__m512h, __m512h, __m512h, const int);
+extern __m512h __cdecl _mm512_mask_fmadd_round_ph(__m512h, __mmask32, __m512h, __m512h, const int);
+extern __m512h __cdecl _mm512_mask3_fmadd_round_ph(__m512h, __m512h, __m512h, __mmask32, const int);
+extern __m512h __cdecl _mm512_maskz_fmadd_round_ph(__mmask32, __m512h, __m512h, __m512h, const int);
+
+// VF[,N]MADD[132,213,231]SH
+extern __m128h __cdecl _mm_fnmadd_sh(__m128h, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask_fnmadd_sh(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask3_fnmadd_sh(__m128h, __m128h, __m128h, __mmask8);
+extern __m128h __cdecl _mm_maskz_fnmadd_sh(__mmask8, __m128h, __m128h, __m128h);
+extern __m128h __cdecl _mm_fnmadd_round_sh(__m128h, __m128h, __m128h, const int);
+extern __m128h __cdecl _mm_mask_fnmadd_round_sh(__m128h, __mmask8, __m128h, __m128h, const int);
+extern __m128h __cdecl _mm_mask3_fnmadd_round_sh(__m128h, __m128h, __m128h, __mmask8, const int);
+extern __m128h __cdecl _mm_maskz_fnmadd_round_sh(__mmask8, __m128h, __m128h, __m128h, const int);
+extern __m128h __cdecl _mm_fmadd_sh(__m128h, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask_fmadd_sh(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask3_fmadd_sh(__m128h, __m128h, __m128h, __mmask8);
+extern __m128h __cdecl _mm_maskz_fmadd_sh(__mmask8, __m128h, __m128h, __m128h);
+extern __m128h __cdecl _mm_fmadd_round_sh(__m128h, __m128h, __m128h, const int);
+extern __m128h __cdecl _mm_mask_fmadd_round_sh(__m128h, __mmask8, __m128h, __m128h, const int);
+extern __m128h __cdecl _mm_mask3_fmadd_round_sh(__m128h, __m128h, __m128h, __mmask8, const int);
+extern __m128h __cdecl _mm_maskz_fmadd_round_sh(__mmask8, __m128h, __m128h, __m128h, const int);
+
+// VF[,N]MSUB[132,213,231]PH
+extern __m128h __cdecl _mm_fnmsub_ph(__m128h, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask_fnmsub_ph(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask3_fnmsub_ph(__m128h, __m128h, __m128h, __mmask8);
+extern __m128h __cdecl _mm_maskz_fnmsub_ph(__mmask8, __m128h, __m128h, __m128h);
+extern __m256h __cdecl _mm256_fnmsub_ph(__m256h, __m256h, __m256h);
+extern __m256h __cdecl _mm256_mask_fnmsub_ph(__m256h, __mmask16, __m256h, __m256h);
+extern __m256h __cdecl _mm256_mask3_fnmsub_ph(__m256h, __m256h, __m256h, __mmask16);
+extern __m256h __cdecl _mm256_maskz_fnmsub_ph(__mmask16, __m256h, __m256h, __m256h);
+extern __m512h __cdecl _mm512_fnmsub_ph(__m512h, __m512h, __m512h);
+extern __m512h __cdecl _mm512_mask_fnmsub_ph(__m512h, __mmask32, __m512h, __m512h);
+extern __m512h __cdecl _mm512_mask3_fnmsub_ph(__m512h, __m512h, __m512h, __mmask32);
+extern __m512h __cdecl _mm512_maskz_fnmsub_ph(__mmask32, __m512h, __m512h, __m512h);
+extern __m512h __cdecl _mm512_fnmsub_round_ph(__m512h, __m512h, __m512h, const int);
+extern __m512h __cdecl _mm512_mask_fnmsub_round_ph(__m512h, __mmask32, __m512h, __m512h, const int);
+extern __m512h __cdecl _mm512_mask3_fnmsub_round_ph(__m512h, __m512h, __m512h, __mmask32, const int);
+extern __m512h __cdecl _mm512_maskz_fnmsub_round_ph(__mmask32, __m512h, __m512h, __m512h, const int);
+extern __m128h __cdecl _mm_fmsub_ph(__m128h, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask_fmsub_ph(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask3_fmsub_ph(__m128h, __m128h, __m128h, __mmask8);
+extern __m128h __cdecl _mm_maskz_fmsub_ph(__mmask8, __m128h, __m128h, __m128h);
+extern __m256h __cdecl _mm256_fmsub_ph(__m256h, __m256h, __m256h);
+extern __m256h __cdecl _mm256_mask_fmsub_ph(__m256h, __mmask16, __m256h, __m256h);
+extern __m256h __cdecl _mm256_mask3_fmsub_ph(__m256h, __m256h, __m256h, __mmask16);
+extern __m256h __cdecl _mm256_maskz_fmsub_ph(__mmask16, __m256h, __m256h, __m256h);
+extern __m512h __cdecl _mm512_fmsub_ph(__m512h, __m512h, __m512h);
+extern __m512h __cdecl _mm512_mask_fmsub_ph(__m512h, __mmask32, __m512h, __m512h);
+extern __m512h __cdecl _mm512_mask3_fmsub_ph(__m512h, __m512h, __m512h, __mmask32);
+extern __m512h __cdecl _mm512_maskz_fmsub_ph(__mmask32, __m512h, __m512h, __m512h);
+extern __m512h __cdecl _mm512_fmsub_round_ph(__m512h, __m512h, __m512h, const int);
+extern __m512h __cdecl _mm512_mask_fmsub_round_ph(__m512h, __mmask32, __m512h, __m512h, const int);
+extern __m512h __cdecl _mm512_mask3_fmsub_round_ph(__m512h, __m512h, __m512h, __mmask32, const int);
+extern __m512h __cdecl _mm512_maskz_fmsub_round_ph(__mmask32, __m512h, __m512h, __m512h, const int);
+
+// VF[,N]MSUB[132,213,231]SH
+extern __m128h __cdecl _mm_fnmsub_sh(__m128h, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask_fnmsub_sh(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask3_fnmsub_sh(__m128h, __m128h, __m128h, __mmask8);
+extern __m128h __cdecl _mm_maskz_fnmsub_sh(__mmask8, __m128h, __m128h, __m128h);
+extern __m128h __cdecl _mm_fnmsub_round_sh(__m128h, __m128h, __m128h, const int);
+extern __m128h __cdecl _mm_mask_fnmsub_round_sh(__m128h, __mmask8, __m128h, __m128h, const int);
+extern __m128h __cdecl _mm_mask3_fnmsub_round_sh(__m128h, __m128h, __m128h, __mmask8, const int);
+extern __m128h __cdecl _mm_maskz_fnmsub_round_sh(__mmask8, __m128h, __m128h, __m128h, const int);
+extern __m128h __cdecl _mm_fmsub_sh(__m128h, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask_fmsub_sh(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_mask3_fmsub_sh(__m128h, __m128h, __m128h, __mmask8);
+extern __m128h __cdecl _mm_maskz_fmsub_sh(__mmask8, __m128h, __m128h, __m128h);
+extern __m128h __cdecl _mm_fmsub_round_sh(__m128h, __m128h, __m128h, const int);
+extern __m128h __cdecl _mm_mask_fmsub_round_sh(__m128h, __mmask8, __m128h, __m128h, const int);
+extern __m128h __cdecl _mm_mask3_fmsub_round_sh(__m128h, __m128h, __m128h, __mmask8, const int);
+extern __m128h __cdecl _mm_maskz_fmsub_round_sh(__mmask8, __m128h, __m128h, __m128h, const int);
+
+// VGETEXPPH
+extern __m128h __cdecl _mm_getexp_ph(__m128h);
+extern __m128h __cdecl _mm_mask_getexp_ph(__m128h, __mmask8, __m128h);
+extern __m128h __cdecl _mm_maskz_getexp_ph(__mmask8, __m128h);
+extern __m256h __cdecl _mm256_getexp_ph(__m256h);
+extern __m256h __cdecl _mm256_mask_getexp_ph(__m256h, __mmask16, __m256h);
+extern __m256h __cdecl _mm256_maskz_getexp_ph(__mmask16, __m256h);
+extern __m512h __cdecl _mm512_getexp_ph(__m512h);
+extern __m512h __cdecl _mm512_mask_getexp_ph(__m512h, __mmask32, __m512h);
+extern __m512h __cdecl _mm512_maskz_getexp_ph(__mmask32, __m512h);
+extern __m512h __cdecl _mm512_getexp_round_ph(__m512h, const int);
+extern __m512h __cdecl _mm512_mask_getexp_round_ph(__m512h, __mmask32, __m512h, const int);
+extern __m512h __cdecl _mm512_maskz_getexp_round_ph(__mmask32, __m512h, const int);
+
+// VGETEXPSH
+extern __m128h __cdecl _mm_getexp_sh(__m128h, __m128h);
+extern __m128h __cdecl _mm_mask_getexp_sh(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_maskz_getexp_sh(__mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_getexp_round_sh(__m128h, __m128h, const int);
+extern __m128h __cdecl _mm_mask_getexp_round_sh(__m128h, __mmask8, __m128h, __m128h, const int);
+extern __m128h __cdecl _mm_maskz_getexp_round_sh(__mmask8, __m128h, __m128h, const int);
+
+// VGETMANTPH
+extern __m128h __cdecl _mm_getmant_ph(__m128h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
+extern __m128h __cdecl _mm_mask_getmant_ph(__m128h, __mmask8, __m128h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
+extern __m128h __cdecl _mm_maskz_getmant_ph(__mmask8, __m128h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
+extern __m256h __cdecl _mm256_getmant_ph(__m256h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
+extern __m256h __cdecl _mm256_mask_getmant_ph(__m256h, __mmask16, __m256h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
+extern __m256h __cdecl _mm256_maskz_getmant_ph(__mmask16, __m256h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
+extern __m512h __cdecl _mm512_getmant_ph(__m512h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
+extern __m512h __cdecl _mm512_mask_getmant_ph(__m512h, __mmask32, __m512h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
+extern __m512h __cdecl _mm512_maskz_getmant_ph(__mmask32, __m512h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
+extern __m512h __cdecl _mm512_getmant_round_ph(__m512h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM, const int);
+extern __m512h __cdecl _mm512_mask_getmant_round_ph(__m512h, __mmask32, __m512h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM, const int);
+extern __m512h __cdecl _mm512_maskz_getmant_round_ph(__mmask32, __m512h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM, const int);
+
+// VGETMANTSH
+extern __m128h __cdecl _mm_getmant_sh(__m128h, __m128h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
+extern __m128h __cdecl _mm_mask_getmant_sh(__m128h, __mmask8, __m128h, __m128h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
+extern __m128h __cdecl _mm_maskz_getmant_sh(__mmask8, __m128h, __m128h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
+extern __m128h __cdecl _mm_getmant_round_sh(__m128h, __m128h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM, const int);
+extern __m128h __cdecl _mm_mask_getmant_round_sh(__m128h, __mmask8, __m128h, __m128h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM, const int);
+extern __m128h __cdecl _mm_maskz_getmant_round_sh(__mmask8, __m128h, __m128h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM, const int);
+
+// VMAXPH
+extern __m128h __cdecl _mm_max_ph(__m128h, __m128h);
+extern __m128h __cdecl _mm_mask_max_ph(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_maskz_max_ph(__mmask8, __m128h, __m128h);
+extern __m256h __cdecl _mm256_max_ph(__m256h, __m256h);
+extern __m256h __cdecl _mm256_mask_max_ph(__m256h, __mmask16, __m256h, __m256h);
+extern __m256h __cdecl _mm256_maskz_max_ph(__mmask16, __m256h, __m256h);
+extern __m512h __cdecl _mm512_max_ph(__m512h, __m512h);
+extern __m512h __cdecl _mm512_mask_max_ph(__m512h, __mmask32, __m512h, __m512h);
+extern __m512h __cdecl _mm512_maskz_max_ph(__mmask32, __m512h, __m512h);
+extern __m512h __cdecl _mm512_max_round_ph(__m512h, __m512h, int);
+extern __m512h __cdecl _mm512_mask_max_round_ph(__m512h, __mmask32, __m512h, __m512h, int);
+extern __m512h __cdecl _mm512_maskz_max_round_ph(__mmask32, __m512h, __m512h, int);
+
+// VMAXSH
+extern __m128h __cdecl _mm_max_sh(__m128h, __m128h);
+extern __m128h __cdecl _mm_mask_max_sh(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_maskz_max_sh(__mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_max_round_sh(__m128h, __m128h, int);
+extern __m128h __cdecl _mm_mask_max_round_sh(__m128h, __mmask8, __m128h, __m128h, int);
+extern __m128h __cdecl _mm_maskz_max_round_sh(__mmask8, __m128h, __m128h, int);
+
+// VMINPH
+extern __m128h __cdecl _mm_min_ph(__m128h, __m128h);
+extern __m128h __cdecl _mm_mask_min_ph(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_maskz_min_ph(__mmask8, __m128h, __m128h);
+extern __m256h __cdecl _mm256_min_ph(__m256h, __m256h);
+extern __m256h __cdecl _mm256_mask_min_ph(__m256h, __mmask16, __m256h, __m256h);
+extern __m256h __cdecl _mm256_maskz_min_ph(__mmask16, __m256h, __m256h);
+extern __m512h __cdecl _mm512_min_ph(__m512h, __m512h);
+extern __m512h __cdecl _mm512_mask_min_ph(__m512h, __mmask32, __m512h, __m512h);
+extern __m512h __cdecl _mm512_maskz_min_ph(__mmask32, __m512h, __m512h);
+extern __m512h __cdecl _mm512_min_round_ph(__m512h, __m512h, int);
+extern __m512h __cdecl _mm512_mask_min_round_ph(__m512h, __mmask32, __m512h, __m512h, int);
+extern __m512h __cdecl _mm512_maskz_min_round_ph(__mmask32, __m512h, __m512h, int);
+
+// VMINSH
+extern __m128h __cdecl _mm_min_sh(__m128h, __m128h);
+extern __m128h __cdecl _mm_mask_min_sh(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_maskz_min_sh(__mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_min_round_sh(__m128h, __m128h, int);
+extern __m128h __cdecl _mm_mask_min_round_sh(__m128h, __mmask8, __m128h, __m128h, int);
+extern __m128h __cdecl _mm_maskz_min_round_sh(__mmask8, __m128h, __m128h, int);
+
+// VMOVSH
+extern __m128h __cdecl _mm_load_sh(void const*);
+extern __m128h __cdecl _mm_mask_load_sh(__m128h, __mmask8, void const*);
+extern __m128h __cdecl _mm_maskz_load_sh(__mmask8, void const*);
+extern void __cdecl _mm_store_sh(void*, __m128h);
+extern void __cdecl _mm_mask_store_sh(void*, __mmask8, __m128h);
+extern __m128h __cdecl _mm_move_sh(__m128h, __m128h);
+extern __m128h __cdecl _mm_mask_move_sh(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_maskz_move_sh(__mmask8, __m128h, __m128h);
+
+// VMOVW
+extern __m128i __cdecl _mm_cvtsi16_si128(short);
+extern short __cdecl _mm_cvtsi128_si16(__m128i);
+
+// MULPH
+extern __m128h __cdecl _mm_mul_ph(__m128h, __m128h);
+extern __m128h __cdecl _mm_mask_mul_ph(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_maskz_mul_ph(__mmask8, __m128h, __m128h);
+extern __m256h __cdecl _mm256_mul_ph(__m256h, __m256h);
+extern __m256h __cdecl _mm256_mask_mul_ph(__m256h, __mmask16, __m256h, __m256h);
+extern __m256h __cdecl _mm256_maskz_mul_ph(__mmask16, __m256h, __m256h);
+extern __m512h __cdecl _mm512_mul_ph(__m512h, __m512h);
+extern __m512h __cdecl _mm512_mask_mul_ph(__m512h, __mmask32, __m512h, __m512h);
+extern __m512h __cdecl _mm512_maskz_mul_ph(__mmask32, __m512h, __m512h);
+extern __m512h __cdecl _mm512_mul_round_ph(__m512h, __m512h, int);
+extern __m512h __cdecl _mm512_mask_mul_round_ph(__m512h, __mmask32, __m512h, __m512h, int);
+extern __m512h __cdecl _mm512_maskz_mul_round_ph(__mmask32, __m512h, __m512h, int);
+
+// VMULSH
+extern __m128h __cdecl _mm_mul_sh(__m128h, __m128h);
+extern __m128h __cdecl _mm_mask_mul_sh(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_maskz_mul_sh(__mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_mul_round_sh(__m128h, __m128h, int);
+extern __m128h __cdecl _mm_mask_mul_round_sh(__m128h, __mmask8, __m128h, __m128h, int);
+extern __m128h __cdecl _mm_maskz_mul_round_sh(__mmask8, __m128h, __m128h, int);
+
+// VRCPPH
+extern __m128h __cdecl _mm_rcp_ph(__m128h);
+extern __m128h __cdecl _mm_mask_rcp_ph(__m128h, __mmask8, __m128h);
+extern __m128h __cdecl _mm_maskz_rcp_ph(__mmask8, __m128h);
+extern __m256h __cdecl _mm256_rcp_ph(__m256h);
+extern __m256h __cdecl _mm256_mask_rcp_ph(__m256h, __mmask16, __m256h);
+extern __m256h __cdecl _mm256_maskz_rcp_ph(__mmask16, __m256h);
+extern __m512h __cdecl _mm512_rcp_ph(__m512h);
+extern __m512h __cdecl _mm512_mask_rcp_ph(__m512h, __mmask32, __m512h);
+extern __m512h __cdecl _mm512_maskz_rcp_ph(__mmask32, __m512h);
+
+// VRCPSH
+extern __m128h __cdecl _mm_rcp_sh(__m128h, __m128h);
+extern __m128h __cdecl _mm_mask_rcp_sh(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_maskz_rcp_sh(__mmask8, __m128h, __m128h);
+
+// VREDUCEPH
+extern __m128h __cdecl _mm_reduce_ph(__m128h, int);
+extern __m128h __cdecl _mm_mask_reduce_ph(__m128h, __mmask8, __m128h, int);
+extern __m128h __cdecl _mm_maskz_reduce_ph(__mmask8, __m128h, int);
+extern __m256h __cdecl _mm256_reduce_ph(__m256h, int);
+extern __m256h __cdecl _mm256_mask_reduce_ph(__m256h, __mmask16, __m256h, int);
+extern __m256h __cdecl _mm256_maskz_reduce_ph(__mmask16, __m256h, int);
+extern __m512h __cdecl _mm512_reduce_ph(__m512h, int);
+extern __m512h __cdecl _mm512_mask_reduce_ph(__m512h, __mmask32, __m512h, int);
+extern __m512h __cdecl _mm512_maskz_reduce_ph(__mmask32, __m512h, int);
+extern __m512h __cdecl _mm512_reduce_round_ph(__m512h, int, const int);
+extern __m512h __cdecl _mm512_mask_reduce_round_ph(__m512h, __mmask32, __m512h, int, const int);
+extern __m512h __cdecl _mm512_maskz_reduce_round_ph(__mmask32, __m512h, int, const int);
+
+// VREDUCESH
+extern __m128h __cdecl _mm_reduce_sh(__m128h, __m128h, int);
+extern __m128h __cdecl _mm_mask_reduce_sh(__m128h, __mmask8, __m128h, __m128h, int);
+extern __m128h __cdecl _mm_maskz_reduce_sh(__mmask8, __m128h, __m128h, int);
+extern __m128h __cdecl _mm_reduce_round_sh(__m128h, __m128h, int, const int);
+extern __m128h __cdecl _mm_mask_reduce_round_sh(__m128h, __mmask8, __m128h, __m128h, int, const int);
+extern __m128h __cdecl _mm_maskz_reduce_round_sh(__mmask8, __m128h, __m128h, int, const int);
+
+// VRNDSCALEPH
+extern __m128h __cdecl _mm_roundscale_ph(__m128h, int);
+extern __m128h __cdecl _mm_mask_roundscale_ph(__m128h, __mmask8, __m128h, int);
+extern __m128h __cdecl _mm_maskz_roundscale_ph(__mmask8, __m128h, int);
+extern __m256h __cdecl _mm256_roundscale_ph(__m256h, int);
+extern __m256h __cdecl _mm256_mask_roundscale_ph(__m256h, __mmask16, __m256h, int);
+extern __m256h __cdecl _mm256_maskz_roundscale_ph(__mmask16, __m256h, int);
+extern __m512h __cdecl _mm512_roundscale_ph(__m512h, int);
+extern __m512h __cdecl _mm512_mask_roundscale_ph(__m512h, __mmask32, __m512h, int);
+extern __m512h __cdecl _mm512_maskz_roundscale_ph(__mmask32, __m512h, int);
+extern __m512h __cdecl _mm512_roundscale_round_ph(__m512h, int, const int);
+extern __m512h __cdecl _mm512_mask_roundscale_round_ph(__m512h, __mmask32, __m512h, int, const int);
+extern __m512h __cdecl _mm512_maskz_roundscale_round_ph(__mmask32, __m512h, int, const int);
+
+// VRNDSCALESH
+extern __m128h __cdecl _mm_roundscale_sh(__m128h, __m128h, int);
+extern __m128h __cdecl _mm_mask_roundscale_sh(__m128h, __mmask8, __m128h, __m128h, int);
+extern __m128h __cdecl _mm_maskz_roundscale_sh(__mmask8, __m128h, __m128h, int);
+extern __m128h __cdecl _mm_roundscale_round_sh(__m128h, __m128h, int, const int);
+extern __m128h __cdecl _mm_mask_roundscale_round_sh(__m128h, __mmask8, __m128h, __m128h, int, const int);
+extern __m128h __cdecl _mm_maskz_roundscale_round_sh(__mmask8, __m128h, __m128h, int, const int);
+
+// VRSQRTPH
+extern __m128h __cdecl _mm_rsqrt_ph(__m128h);
+extern __m128h __cdecl _mm_mask_rsqrt_ph(__m128h, __mmask8, __m128h);
+extern __m128h __cdecl _mm_maskz_rsqrt_ph(__mmask8, __m128h);
+extern __m256h __cdecl _mm256_rsqrt_ph(__m256h);
+extern __m256h __cdecl _mm256_mask_rsqrt_ph(__m256h, __mmask16, __m256h);
+extern __m256h __cdecl _mm256_maskz_rsqrt_ph(__mmask16, __m256h);
+extern __m512h __cdecl _mm512_rsqrt_ph(__m512h);
+extern __m512h __cdecl _mm512_mask_rsqrt_ph(__m512h, __mmask32, __m512h);
+extern __m512h __cdecl _mm512_maskz_rsqrt_ph(__mmask32, __m512h);
+
+// VRSQRTSH
+extern __m128h __cdecl _mm_rsqrt_sh(__m128h, __m128h);
+extern __m128h __cdecl _mm_mask_rsqrt_sh(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_maskz_rsqrt_sh(__mmask8, __m128h, __m128h);
+
+// VSCALEFPH
+extern __m128h __cdecl _mm_scalef_ph(__m128h, __m128h);
+extern __m128h __cdecl _mm_mask_scalef_ph(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_maskz_scalef_ph(__mmask8, __m128h, __m128h);
+extern __m256h __cdecl _mm256_scalef_ph(__m256h, __m256h);
+extern __m256h __cdecl _mm256_mask_scalef_ph(__m256h, __mmask16, __m256h, __m256h);
+extern __m256h __cdecl _mm256_maskz_scalef_ph(__mmask16, __m256h, __m256h);
+extern __m512h __cdecl _mm512_scalef_ph(__m512h, __m512h);
+extern __m512h __cdecl _mm512_mask_scalef_ph(__m512h, __mmask32, __m512h, __m512h);
+extern __m512h __cdecl _mm512_maskz_scalef_ph(__mmask32, __m512h, __m512h);
+extern __m512h __cdecl _mm512_scalef_round_ph(__m512h, __m512h, const int);
+extern __m512h __cdecl _mm512_mask_scalef_round_ph(__m512h, __mmask32, __m512h, __m512h, const int);
+extern __m512h __cdecl _mm512_maskz_scalef_round_ph(__mmask32, __m512h, __m512h, const int);
+
+// VSCALEFSH
+extern __m128h __cdecl _mm_scalef_sh(__m128h, __m128h);
+extern __m128h __cdecl _mm_mask_scalef_sh(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_maskz_scalef_sh(__mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_scalef_round_sh(__m128h, __m128h, const int);
+extern __m128h __cdecl _mm_mask_scalef_round_sh(__m128h, __mmask8, __m128h, __m128h, const int);
+extern __m128h __cdecl _mm_maskz_scalef_round_sh(__mmask8, __m128h, __m128h, const int);
+
+// VSQRTPH
+extern __m128h __cdecl _mm_sqrt_ph(__m128h);
+extern __m128h __cdecl _mm_mask_sqrt_ph(__m128h, __mmask8, __m128h);
+extern __m128h __cdecl _mm_maskz_sqrt_ph(__mmask8, __m128h);
+extern __m256h __cdecl _mm256_sqrt_ph(__m256h);
+extern __m256h __cdecl _mm256_mask_sqrt_ph(__m256h, __mmask16, __m256h);
+extern __m256h __cdecl _mm256_maskz_sqrt_ph(__mmask16, __m256h);
+extern __m512h __cdecl _mm512_sqrt_ph(__m512h);
+extern __m512h __cdecl _mm512_mask_sqrt_ph(__m512h, __mmask32, __m512h);
+extern __m512h __cdecl _mm512_maskz_sqrt_ph(__mmask32, __m512h);
+extern __m512h __cdecl _mm512_sqrt_round_ph(__m512h, const int);
+extern __m512h __cdecl _mm512_mask_sqrt_round_ph(__m512h, __mmask32, __m512h, const int);
+extern __m512h __cdecl _mm512_maskz_sqrt_round_ph(__mmask32, __m512h, const int);
+
+// VSQRTSH
+extern __m128h __cdecl _mm_sqrt_sh(__m128h, __m128h);
+extern __m128h __cdecl _mm_mask_sqrt_sh(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_maskz_sqrt_sh(__mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_sqrt_round_sh(__m128h, __m128h, const int);
+extern __m128h __cdecl _mm_mask_sqrt_round_sh(__m128h, __mmask8, __m128h, __m128h, const int);
+extern __m128h __cdecl _mm_maskz_sqrt_round_sh(__mmask8, __m128h, __m128h, const int);
+
+// VSUBPH
+extern __m128h __cdecl _mm_sub_ph(__m128h, __m128h);
+extern __m128h __cdecl _mm_mask_sub_ph(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_maskz_sub_ph(__mmask8, __m128h, __m128h);
+extern __m256h __cdecl _mm256_sub_ph(__m256h, __m256h);
+extern __m256h __cdecl _mm256_mask_sub_ph(__m256h, __mmask16, __m256h, __m256h);
+extern __m256h __cdecl _mm256_maskz_sub_ph(__mmask16, __m256h, __m256h);
+extern __m512h __cdecl _mm512_sub_ph(__m512h, __m512h);
+extern __m512h __cdecl _mm512_mask_sub_ph(__m512h, __mmask32, __m512h, __m512h);
+extern __m512h __cdecl _mm512_maskz_sub_ph(__mmask32, __m512h, __m512h);
+extern __m512h __cdecl _mm512_sub_round_ph(__m512h, __m512h, int);
+extern __m512h __cdecl _mm512_mask_sub_round_ph(__m512h, __mmask32, __m512h, __m512h, int);
+extern __m512h __cdecl _mm512_maskz_sub_round_ph(__mmask32, __m512h, __m512h, int);
+
+// VSUBSH
+extern __m128h __cdecl _mm_sub_sh(__m128h, __m128h);
+extern __m128h __cdecl _mm_mask_sub_sh(__m128h, __mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_maskz_sub_sh(__mmask8, __m128h, __m128h);
+extern __m128h __cdecl _mm_sub_round_sh(__m128h, __m128h, int);
+extern __m128h __cdecl _mm_mask_sub_round_sh(__m128h, __mmask8, __m128h, __m128h, int);
+extern __m128h __cdecl _mm_maskz_sub_round_sh(__mmask8, __m128h, __m128h, int);
+
+extern __m128h __cdecl _mm_mask_blend_ph (__mmask8, __m128h, __m128h);
+extern __m256h __cdecl _mm256_mask_blend_ph (__mmask16, __m256h, __m256h);
+extern __m512h __cdecl _mm512_mask_blend_ph (__mmask32, __m512h, __m512h);
+
+// AVX512VL RSQRT14 intrinsics
+extern __m256  __cdecl _mm256_rsqrt14_ps(__m256);
+extern __m256d __cdecl _mm256_rsqrt14_pd(__m256d);
+extern __m128  __cdecl _mm_rsqrt14_ps(__m128);
+extern __m128d __cdecl _mm_rsqrt14_pd(__m128d);
+
+// Scalar FP intrinsics (with double/float arguments)
+extern float  __cdecl __getexp_ss(float);
+extern double __cdecl __getexp_sd(double);
+extern float  __cdecl __getmant_ss(float, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
+extern double __cdecl __getmant_sd(double, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
+extern float  __cdecl __scalef_ss(float, float);
+extern double __cdecl __scalef_sd(double, double);
+
+// Macros for fmul_*ch intrinsics
+#define _mm_mul_pch(A, B) _mm_fmul_pch(A, B)
+#define _mm_mask_mul_pch(W, U, A, B) _mm_mask_fmul_pch(W, U, A, B)
+#define _mm_maskz_mul_pch(U, A, B) _mm_maskz_fmul_pch(U, A, B)
+
+#define _mm256_mul_pch(A, B) _mm256_fmul_pch(A, B)
+#define _mm256_mask_mul_pch(W, U, A, B) _mm256_mask_fmul_pch(W, U, A, B)
+#define _mm256_maskz_mul_pch(U, A, B) _mm256_maskz_fmul_pch(U, A, B)
+
+#define _mm512_mul_pch(A, B) _mm512_fmul_pch(A, B)
+#define _mm512_mask_mul_pch(W, U, A, B) _mm512_mask_fmul_pch(W, U, A, B)
+#define _mm512_maskz_mul_pch(U, A, B) _mm512_maskz_fmul_pch(U, A, B)
+
+#define _mm512_mul_round_pch(A, B, R) _mm512_fmul_round_pch(A, B, R)
+#define _mm512_mask_mul_round_pch(W, U, A, B, R) \
+                                _mm512_mask_fmul_round_pch(W, U, A, B, R)
+#define _mm512_maskz_mul_round_pch(U, A, B, R) \
+                                _mm512_maskz_fmul_round_pch(U, A, B, R)
+
+#define _mm_mul_sch(A, B) _mm_fmul_sch(A, B)
+#define _mm_mask_mul_sch(W, U, A, B) _mm_mask_fmul_sch(W, U, A, B)
+#define _mm_maskz_mul_sch(U, A, B) _mm_maskz_fmul_sch(U, A, B)
+
+#define _mm_mul_round_sch(A, B, R) _mm_fmul_round_sch(A, B, R)
+#define _mm_mask_mul_round_sch(W, U, A, B, R) \
+                                    _mm_mask_fmul_round_sch(W, U, A, B, R)
+#define _mm_maskz_mul_round_sch(U, A, B, R) _mm_maskz_fmul_round_sch(U, A, B, R)
+
+// Macros for fcmul_*ch intrinsics
+#define _mm_cmul_pch(A, B) _mm_fcmul_pch(A, B)
+#define _mm_mask_cmul_pch(W, U, A, B) _mm_mask_fcmul_pch(W, U, A, B)
+#define _mm_maskz_cmul_pch(U, A, B) _mm_maskz_fcmul_pch(U, A, B)
+
+#define _mm256_cmul_pch(A, B) _mm256_fcmul_pch(A, B)
+#define _mm256_mask_cmul_pch(W, U, A, B) _mm256_mask_fcmul_pch(W, U, A, B)
+#define _mm256_maskz_cmul_pch(U, A, B) _mm256_maskz_fcmul_pch(U, A, B)
+
+#define _mm512_cmul_pch(A, B) _mm512_fcmul_pch(A, B)
+#define _mm512_mask_cmul_pch(W, U, A, B) _mm512_mask_fcmul_pch(W, U, A, B)
+#define _mm512_maskz_cmul_pch(U, A, B) _mm512_maskz_fcmul_pch(U, A, B)
+
+#define _mm512_cmul_round_pch(A, B, R) _mm512_fcmul_round_pch(A, B, R)
+#define _mm512_mask_cmul_round_pch(W, U, A, B, R) \
+                                _mm512_mask_fcmul_round_pch(W, U, A, B, R)
+#define _mm512_maskz_cmul_round_pch(U, A, B, R) \
+                                _mm512_maskz_fcmul_round_pch(U, A, B, R)
+
+#define _mm_cmul_sch(A, B) _mm_fcmul_sch(A, B)
+#define _mm_mask_cmul_sch(W, U, A, B) _mm_mask_fcmul_sch(W, U, A, B)
+#define _mm_maskz_cmul_sch(U, A, B) _mm_maskz_fcmul_sch(U, A, B)
+
+#define _mm_cmul_round_sch(A, B, R) _mm_fcmul_round_sch(A, B, R)
+#define _mm_mask_cmul_round_sch(W, U, A, B, R) \
+                                _mm_mask_fcmul_round_sch(W, U, A, B, R)
+#define _mm_maskz_cmul_round_sch(U, A, B, R) \
+                                _mm_maskz_fcmul_round_sch(U, A, B, R)
+
+// FP16 type conversion macros
+#define _mm_castph_ps(x)            _mm_castsi128_ps(x)
+#define _mm256_castph_ps(x)         _mm256_castsi256_ps(x)
+#define _mm512_castph_ps(x)         _mm512_castsi512_ps(x)
+#define _mm_castph_pd(x)            _mm_castsi128_pd(x)
+#define _mm256_castph_pd(x)         _mm256_castsi256_pd(x)
+#define _mm512_castph_pd(x)         _mm512_castsi512_pd(x)
+#define _mm_castph_si128(x)         (x)
+#define _mm256_castph_si256(x)      (x)
+#define _mm512_castph_si512(x)      (x)
+#define _mm_castps_ph(x)            _mm_castps_si128(x)
+#define _mm256_castps_ph(x)         _mm256_castps_si256(x)
+#define _mm512_castps_ph(x)         _mm512_castps_si512(x)
+#define _mm_castpd_ph(x)            _mm_castpd_si128(x)
+#define _mm256_castpd_ph(x)         _mm256_castpd_si256(x)
+#define _mm512_castpd_ph(x)         _mm512_castpd_si512(x)
+#define _mm_castsi128_ph(x)         (x)
+#define _mm256_castsi256_ph(x)      (x)
+#define _mm512_castsi512_ph(x)      (x)
+#define _mm256_castph256_ph128(x)   _mm256_castsi256_si128(x)
+#define _mm512_castph512_ph128(x)   _mm512_castsi512_si128(x)
+#define _mm512_castph512_ph256(x)   _mm512_castsi512_si256(x)
+#define _mm256_castph128_ph256(x)   _mm256_castsi128_si256(x)
+#define _mm512_castph128_ph512(x)   _mm512_castsi128_si512(x)
+#define _mm512_castph256_ph512(x)   _mm512_castsi256_si512(x)
+#define _mm256_zextph128_ph256(x)   _mm256_zextsi128_si256(x)
+#define _mm512_zextph128_ph512(x)   _mm512_zextsi128_si512(x)
+#define _mm512_zextph256_ph512(x)   _mm512_zextsi256_si512(x)
+
+#define _mm_comieq_sh(v1, v2)  _mm_comi_sh((v1), (v2), _CMP_EQ_OQ)
+#define _mm_comilt_sh(v1, v2)  _mm_comi_sh((v1), (v2), _CMP_LT_OQ)
+#define _mm_comile_sh(v1, v2)  _mm_comi_sh((v1), (v2), _CMP_LE_OQ)
+#define _mm_comigt_sh(v1, v2)  _mm_comi_sh((v1), (v2), _CMP_GT_OQ)
+#define _mm_comige_sh(v1, v2)  _mm_comi_sh((v1), (v2), _CMP_GE_OQ)
+#define _mm_comineq_sh(v1, v2) _mm_comi_sh((v1), (v2), _CMP_NEQ_OQ)
+
+#define _mm_ucomieq_sh(v1, v2)  _mm_comi_sh((v1), (v2), _CMP_EQ_OS)
+#define _mm_ucomilt_sh(v1, v2)  _mm_comi_sh((v1), (v2), _CMP_LT_OS)
+#define _mm_ucomile_sh(v1, v2)  _mm_comi_sh((v1), (v2), _CMP_LE_OS)
+#define _mm_ucomigt_sh(v1, v2)  _mm_comi_sh((v1), (v2), _CMP_GT_OS)
+#define _mm_ucomige_sh(v1, v2)  _mm_comi_sh((v1), (v2), _CMP_GE_OS)
+#define _mm_ucomineq_sh(v1, v2) _mm_comi_sh((v1), (v2), _CMP_NEQ_OS)
+
+// FP16 intrinsic macros
+#define _mm_abs_ph(a)                    _mm_and_epi32(_mm_set1_epi32(0x7FFF7FFF), (a))
+#define _mm256_abs_ph(a)                 _mm256_and_epi32(_mm256_set1_epi32(0x7FFF7FFF), (a))
+#define _mm512_abs_ph(a)                 _mm512_and_epi32(_mm512_set1_epi32(0x7FFF7FFF), (a))
+
+#define _mm_conj_pch(a)                  _mm_xor_epi32((a), _mm_set1_epi32(0x80000000))
+#define _mm_mask_conj_pch(src, k, a)     _mm_mask_xor_epi32((src), (k), (a), _mm_set1_epi32(0x80000000))
+#define _mm_maskz_conj_pch(k, a)         _mm_maskz_xor_epi32((k), (a), _mm_set1_epi32(0x80000000))
+
+#define _mm256_conj_pch(a)               _mm256_xor_epi32((a), _mm256_set1_epi32(0x80000000))
+#define _mm256_mask_conj_pch(src, k, a)  _mm256_mask_xor_epi32((src), (k), (a), _mm256_set1_epi32(0x80000000))
+#define _mm256_maskz_conj_pch(k, a)      _mm256_maskz_xor_epi32((k), (a), _mm256_set1_epi32(0x80000000))
+
+#define _mm512_conj_pch(a)               _mm512_xor_epi32((a), _mm512_set1_epi32(0x80000000))
+#define _mm512_mask_conj_pch(src, k, a)  _mm512_mask_xor_epi32((src), (k), (a), _mm512_set1_epi32(0x80000000))
+#define _mm512_maskz_conj_pch(k, a)      _mm512_maskz_xor_epi32((k), (a), _mm512_set1_epi32(0x80000000))
+
+#define _mm_load_ph(x)                   _mm_castps_ph(_mm_load_ps((float *)(x)))
+#define _mm256_load_ph(x)                _mm256_castps_ph(_mm256_load_ps((float *)(x)))
+#define _mm512_load_ph(x)                _mm512_castps_ph(_mm512_load_ps(x))
+
+#define _mm_loadu_ph(x)                  _mm_castps_ph(_mm_loadu_ps((float *)(x)))
+#define _mm256_loadu_ph(x)               _mm256_castps_ph(_mm256_loadu_ps((float *)(x)))
+#define _mm512_loadu_ph(x)               _mm512_castps_ph(_mm512_loadu_ps(x))
+
+#define _mm_store_ph(x, a)               _mm_store_ps((float *)(x), _mm_castph_ps(a))
+#define _mm256_store_ph(x, a)            _mm256_store_ps((float *)(x), _mm256_castph_ps(a))
+#define _mm512_store_ph(x, a)            _mm512_store_ps((x), _mm512_castph_ps(a))
+
+#define _mm_storeu_ph(x, a)              _mm_storeu_ps((float *)(x), _mm_castph_ps(a))
+#define _mm256_storeu_ph(x, a)           _mm256_storeu_ps((float *)(x), _mm256_castph_ps(a))
+#define _mm512_storeu_ph(x, a)           _mm512_storeu_ps((x), _mm512_castph_ps(a))
+
+#define _mm_setzero_ph()                 _mm_castps_ph(_mm_setzero_ps())
+#define _mm256_setzero_ph()              _mm256_castps_ph(_mm256_setzero_ps())
+#define _mm512_setzero_ph()              _mm512_castps_ph(_mm512_setzero_ps())
+
+#define _mm_undefined_ph()               _mm_undefined_si128()
+#define _mm256_undefined_ph()            _mm256_undefined_si256()
+#define _mm512_undefined_ph()            _mm512_undefined_epi32()
+
+#define _mm_permutex2var_ph(a, i, b)     _mm_permutex2var_epi16((a), (i), (b))
+#define _mm256_permutex2var_ph(a, i, b)  _mm256_permutex2var_epi16((a), (i), (b))
+#define _mm512_permutex2var_ph(a, i, b)  _mm512_permutex2var_epi16((a), (i), (b))
+
+#define _mm_permutexvar_ph(i, a)         _mm_permutexvar_epi16((i), (a))
+#define _mm256_permutexvar_ph(i, a)      _mm256_permutexvar_epi16((i), (a))
+#define _mm512_permutexvar_ph(i, a)      _mm512_permutexvar_epi16((i), (a))
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* _ZMMINTRIN_H_INCLUDED */