Add files using upload-large-folder tool

.gitattributes

@@ -109,3 +109,4 @@ miniCUDA124/lib/x64/nvfatbin_static.lib filter=lfs diff=lfs merge=lfs -text
 miniCUDA124/bin/cublas64_12.dll filter=lfs diff=lfs merge=lfs -text
 miniCUDA124/lib/x64/nvrtc-builtins_static.lib filter=lfs diff=lfs merge=lfs -text
 miniMSVC/VC/Redist/MSVC/14.42.34433/debug_nonredist/x64/Microsoft.VC143.DebugCRT/vccorlib140d.dll filter=lfs diff=lfs merge=lfs -text
+miniCUDA124/nvvm/bin/cicc.exe filter=lfs diff=lfs merge=lfs -text

miniCUDA124/nvvm/bin/cicc.exe

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

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vccorlib/tmmta.cpp

@@ -0,0 +1,51 @@
+//
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+#include <crtdbg.h>
+
+// From <vccorlib.h>, which we cannot include here
+#define _VCCORLIB_THREADING_MODEL_DEFAULT  0
+#define _VCCORLIB_THREADING_MODEL_STA      1
+#define _VCCORLIB_THREADING_MODEL_MTA      2
+#define _VCCORLIB_THREADING_MODEL_OVERRIDE 3
+
+extern int __abi___threading_model;
+
+// Compiler is pulling in the following symbol:
+// INCLUDE:___refMTAThread (decorated x86) to enable MTA
+extern "C" int __refMTAThread = 0;
+
+// External symbol to ensure that only one threading model initializer can be
+// linked into a module.  If a project uses both Platform::STAThreadAttribute
+// and Platform::MTAThreadAttribute, this should cause a link error.
+extern "C" int __abi___threading_model_initializer = 0;
+
+static int __cdecl initialize_threading_model_for_mta() throw()
+{
+	// If the threading model is 'override', some prior initializer has requested that
+	// we not initialize the threading model.  This feature exists to support the XAML
+	// designer, which loads EXEs as if they were DLLs, and thus needs to be able to
+	// suppress our initialization.
+	if (__abi___threading_model == _VCCORLIB_THREADING_MODEL_OVERRIDE)
+	{
+		return 0;
+	}
+
+	if (__abi___threading_model != _VCCORLIB_THREADING_MODEL_DEFAULT)
+	{
+		// If you hit this assertion, this indicates that both Platform::STAThreadAttribute
+		// and Platform::MTAThreadAttribute were used in your source files and libraries.
+		// These attributes are mutually exclusive.  Search your sources for the attributes
+		// or link your project with the /verbose option and find which object files caused
+		// the __refSTAThread and __refMTAThread symbols to be linked into your binary.
+		_ASSERTE(("__abi___threading_model has already been initialized", 0));
+		return 1;
+	}
+
+	__abi___threading_model = _VCCORLIB_THREADING_MODEL_MTA;
+	return 0;
+}
+
+#pragma section(".CRT$XIYA", long, read)
+__declspec(allocate(".CRT$XIYA")) static auto initializer = initialize_threading_model_for_mta;

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vccorlib/tmsta.cpp

@@ -0,0 +1,51 @@
+//
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+#include <crtdbg.h>
+
+// From <vccorlib.h>, which we cannot include here
+#define _VCCORLIB_THREADING_MODEL_DEFAULT  0
+#define _VCCORLIB_THREADING_MODEL_STA      1
+#define _VCCORLIB_THREADING_MODEL_MTA      2
+#define _VCCORLIB_THREADING_MODEL_OVERRIDE 3
+
+extern int __abi___threading_model;
+
+// Compiler is pulling in the following symbol:
+// INCLUDE:___refSTAThread (decorated x86) to enable STA
+extern "C" int __refSTAThread = 0;
+
+// External symbol to ensure that only one threading model initializer can be
+// linked into a module.  If a project uses both Platform::STAThreadAttribute
+// and Platform::MTAThreadAttribute, this should cause a link error.
+extern "C" int __abi___threading_model_initializer = 0;
+
+static int __cdecl initialize_threading_model_for_sta() throw()
+{
+	// If the threading model is 'override', some prior initializer has requested that
+	// we not initialize the threading model.  This feature exists to support the XAML
+	// designer, which loads EXEs as if they were DLLs, and thus needs to be able to
+	// suppress our initialization.
+	if (__abi___threading_model == _VCCORLIB_THREADING_MODEL_OVERRIDE)
+	{
+		return 0;
+	}
+
+	if (__abi___threading_model != _VCCORLIB_THREADING_MODEL_DEFAULT)
+	{
+		// If you hit this assertion, this indicates that both Platform::STAThreadAttribute
+		// and Platform::MTAThreadAttribute were used in your source files and libraries.
+		// These attributes are mutually exclusive.  Search your sources for the attributes
+		// or link your project with the /verbose option and find which object files caused
+		// the __refSTAThread and __refMTAThread symbols to be linked into your binary.
+		_ASSERTE(("__abi___threading_model has already been initialized", 0));
+		return 1;
+	}
+
+	__abi___threading_model = _VCCORLIB_THREADING_MODEL_STA;
+	return 0;
+}
+
+#pragma section(".CRT$XIYA", long, read)
+__declspec(allocate(".CRT$XIYA")) static auto initializer = initialize_threading_model_for_sta;

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vccorlib/type.cpp

@@ -0,0 +1,271 @@
+//
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+
+#include "pch.h"
+#pragma hdrstop
+
+#pragma warning(disable:4483)
+
+size_t SafeAdd(size_t left, size_t right)
+{
+	if (static_cast<size_t>(-1) - left < right)
+	{
+		throw ref new ::Platform::COMException(HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW));
+	}
+
+	return left + right;
+}
+
+size_t SafeMultiply(size_t left, size_t right)
+{
+	if (static_cast<size_t>(-1) / left < right)
+	{
+		throw ref new ::Platform::COMException(HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW));
+	}
+
+	return left * right;
+}
+
+struct {
+	const __wchar_t* typeName;
+	const __wchar_t* platformName;
+	::Platform::TypeCode typeId;
+	::Windows::Foundation::PropertyType propertyType;
+} primitiveMatchArr[] = {
+	{ L"Boolean",  L"Boolean",                      ::Platform::TypeCode::Boolean  , ::Windows::Foundation::PropertyType::Boolean    },
+	{ L"Char16",   L"Char16",                       ::Platform::TypeCode::Char16   , ::Windows::Foundation::PropertyType::Char16     },
+	{ L"Int8",     L"Int8",                         ::Platform::TypeCode::Int8     , static_cast<::Windows::Foundation::PropertyType>(-1) },
+	{ L"UInt8",    L"UInt8",                        ::Platform::TypeCode::UInt8    , ::Windows::Foundation::PropertyType::UInt8      },
+	{ L"Int16",    L"Int16",                        ::Platform::TypeCode::Int16    , ::Windows::Foundation::PropertyType::Int16      },
+	{ L"UInt16",   L"UInt16",                       ::Platform::TypeCode::UInt16   , ::Windows::Foundation::PropertyType::UInt16     },
+	{ L"Int32",    L"Int32",                        ::Platform::TypeCode::Int32    , ::Windows::Foundation::PropertyType::Int32      },
+	{ L"UInt32",   L"UInt32",                       ::Platform::TypeCode::UInt32   , ::Windows::Foundation::PropertyType::UInt32     },
+	{ L"Int64",    L"Int64",                        ::Platform::TypeCode::Int64    , ::Windows::Foundation::PropertyType::Int64      },
+	{ L"UInt64",   L"UInt64",                       ::Platform::TypeCode::UInt64   , ::Windows::Foundation::PropertyType::UInt64     },
+	{ L"Single",   L"Single",                       ::Platform::TypeCode::Single   , ::Windows::Foundation::PropertyType::Single     },
+	{ L"Double",   L"Double",                       ::Platform::TypeCode::Double   , ::Windows::Foundation::PropertyType::Double     },
+	{ L"String",   L"Platform.String",              ::Platform::TypeCode::String   , ::Windows::Foundation::PropertyType::String     },
+	{ L"Guid",     L"Platform.Guid",                ::Platform::TypeCode::Guid     , ::Windows::Foundation::PropertyType::Guid       },
+	{ L"DateTime", L"Windows.Foundation.DateTime",  ::Platform::TypeCode::DateTime , ::Windows::Foundation::PropertyType::DateTime   },
+	{ L"TimeSpan", L"Windows.Foundation.TimeSpan",  ::Platform::TypeCode::TimeSpan , ::Windows::Foundation::PropertyType::TimeSpan   },
+	{ L"Point",    L"Windows.Foundation.Point",     ::Platform::TypeCode::Point    , ::Windows::Foundation::PropertyType::Point      },
+	{ L"Rect",     L"Windows.Foundation.Rect",      ::Platform::TypeCode::Rect     , ::Windows::Foundation::PropertyType::Rect       },
+	{ L"Size",     L"Windows.Foundation.Size",      ::Platform::TypeCode::Size     , ::Windows::Foundation::PropertyType::Size       },
+	{ L"Object",   L"Platform.Object",              ::Platform::TypeCode::Object   , ::Windows::Foundation::PropertyType::Inspectable}
+};
+
+__abi_type_descriptor* CreateDescriptior(const __wchar_t* typeName, int typeId)
+{
+	size_t len = ::wcslen(typeName);
+
+	len = SafeAdd(len, 4);
+
+	size_t size = SafeMultiply(len, sizeof(__wchar_t));
+	size = SafeAdd(size, sizeof(__abi_type_descriptor));
+
+	__abi_type_descriptor* descriptor = reinterpret_cast<__abi_type_descriptor*>(Platform::Details::Heap::Allocate(size));
+	descriptor->__typeName = reinterpret_cast<const __wchar_t*>(descriptor + 1);
+	wcscpy_s( const_cast<__wchar_t*>(descriptor->__typeName), len, typeName);
+	descriptor->__typeId = typeId;
+
+	return descriptor;
+}
+
+namespace Platform
+{
+	/*
+    extern "C" CPPCLI_FUNC void __identifier("?<Dispose>@Type@Platform@@U$AAAXXZ")(Platform::Type^ pThis)
+    {
+        // no-op. We don't need 'delete Type' to do anything.
+    }
+	*/
+
+	CPPCLI_FUNC void Type::__identifier("<Dispose>")()
+	{
+		  if (_owndescriptor)
+		  {
+	 		 Platform::Details::Heap::Free(_descriptor);
+		  }
+	}
+
+    // Add this back in when non-virtual private destructors are available.
+	// CPPCLI_FUNC void Type::~Type()
+	// {
+	//	  if (_owndescriptor)
+	//	  {
+	// 		 Platform::Details::Heap::Free(_descriptor);
+	//	  }
+	// }
+
+    CPPCLI_FUNC Type::Type(IntPtr descriptor) : _descriptor( (void *)descriptor ), _owndescriptor(false)
+	{
+	}
+
+	CPPCLI_FUNC Type::Type(Windows::UI::Xaml::Interop::TypeName type) : _descriptor(nullptr), _owndescriptor(true)
+	{
+		const __wchar_t *typeName = type.Name->Data();
+		int typeId = 0;
+
+		switch(type.Kind)
+		{
+		case Windows::UI::Xaml::Interop::TypeKind::Metadata:
+			typeId = static_cast<int>(Platform::TypeCode::Object);
+			break;
+		case Windows::UI::Xaml::Interop::TypeKind::Custom:
+			typeId = static_cast<int>(Platform::TypeCode::Custom);
+			break;
+		case Windows::UI::Xaml::Interop::TypeKind::Primitive:
+			{
+				for(unsigned int i = 0; i < _countof(primitiveMatchArr); i++)
+				{
+					if (::wcscmp(typeName, primitiveMatchArr[i].typeName) == 0)
+					{
+						typeId = static_cast<int>(primitiveMatchArr[i].typeId);
+						typeName = primitiveMatchArr[i].platformName;
+						break;
+					}
+				}
+				break;
+			}
+		default:
+			throw ref new ::Platform::FailureException();
+		}
+
+		_descriptor = CreateDescriptior(typeName, typeId);
+	}
+
+	CPPCLI_FUNC Type::Type(Object^ obj) : _owndescriptor(true)
+	{
+		Windows::Foundation::IPropertyValue^ propertyValue;
+		::Platform::Guid gdIPropertyValue(__uuidof(Windows::Foundation::IPropertyValue^));
+		HRESULT hr = obj->__abi_QueryInterface(gdIPropertyValue, reinterpret_cast<void**>(&propertyValue));
+		if (SUCCEEDED(hr))
+		{
+			auto propertyType = propertyValue->Type;
+
+			for (unsigned int i = 0; i < _countof(primitiveMatchArr); i++)
+			{
+				if (propertyType == primitiveMatchArr[i].propertyType)
+				{
+					_descriptor = CreateDescriptior(primitiveMatchArr[i].platformName, static_cast<int>(primitiveMatchArr[i].typeId));
+					return;
+				}
+			}
+		}
+
+		Platform::String^ typeName;
+		hr = obj->__abi_GetRuntimeClassName(reinterpret_cast<HSTRING*>(&typeName));
+		__abi_ThrowIfFailed(hr);
+
+		int typeId = static_cast<int>(Platform::TypeCode::Object);
+
+		_descriptor = CreateDescriptior(typeName->Data(), typeId);
+	}
+
+	CPPCLI_FUNC String^ Type::FullName::get()
+	{
+		__abi_type_descriptor* descriptor = (__abi_type_descriptor*)(void*)_descriptor;
+		return ref new String(descriptor->__typeName);
+	}
+
+	CPPCLI_FUNC TypeCode Type::GetTypeCode(Type^ type)
+	{
+		if (type == nullptr)
+		{
+			return TypeCode::Empty;
+		}
+
+		__abi_type_descriptor* descriptor = (__abi_type_descriptor*)(void*)type->_descriptor;
+		return (TypeCode)descriptor->__typeId;
+	}
+
+
+	CPPCLI_FUNC int32 Type::GetHashCode()
+	{
+		return Object::GetHashCode();
+	}
+
+	CPPCLI_FUNC String^ Type::ToString()
+	{
+		return FullName;
+	}
+
+	CPPCLI_FUNC bool Type::Equals(Object^ o)
+	{
+		Type^ type = dynamic_cast<Type^>(o);
+		if (type == nullptr)
+		{
+			return this == nullptr;
+		}
+
+		return _descriptor == type->_descriptor;
+	}
+
+	CPPCLI_FUNC Platform::Type::operator class Windows::UI::Xaml::Interop::TypeName(class Platform::Type^ type)
+	{
+		Windows::UI::Xaml::Interop::TypeName typeName;
+		typeName.Name = type->FullName;
+
+		switch(::Platform::Type::GetTypeCode(type))
+		{
+		case ::Platform::TypeCode::Empty:
+		case ::Platform::TypeCode::Object:
+		case ::Platform::TypeCode::DateTime:
+		case ::Platform::TypeCode::TimeSpan:
+		case ::Platform::TypeCode::Point:
+		case ::Platform::TypeCode::Size:
+		case ::Platform::TypeCode::Rect:
+			typeName.Kind = Windows::UI::Xaml::Interop::TypeKind::Metadata;
+			break;
+		case ::Platform::TypeCode::Custom:
+			typeName.Kind = Windows::UI::Xaml::Interop::TypeKind::Custom;
+			break;
+		case ::Platform::TypeCode::Boolean:
+		case ::Platform::TypeCode::Char16:
+		case ::Platform::TypeCode::Int8:
+		case ::Platform::TypeCode::UInt8:
+		case ::Platform::TypeCode::Int16:
+		case ::Platform::TypeCode::UInt16:
+		case ::Platform::TypeCode::Int32:
+		case ::Platform::TypeCode::UInt32:
+		case ::Platform::TypeCode::Int64:
+		case ::Platform::TypeCode::UInt64:
+		case ::Platform::TypeCode::Single:
+		case ::Platform::TypeCode::Double:
+		case ::Platform::TypeCode::String:
+		case ::Platform::TypeCode::Guid:
+			typeName.Kind = Windows::UI::Xaml::Interop::TypeKind::Primitive;
+			break;
+		}
+
+		// Gettting string name from typeName.Name because we hold reference to it
+		const wchar_t *name = typeName.Name->Data();
+		if (name != nullptr)
+		{
+			for(unsigned int i = 0; i < _countof(primitiveMatchArr); i++)
+			{
+				if (::wcscmp(name, primitiveMatchArr[i].platformName) == 0)
+				{
+					typeName.Name = ref new ::Platform::String(primitiveMatchArr[i].typeName);
+					break;
+				}
+			}
+		}
+
+		return typeName;
+	}
+
+	CPPCLI_FUNC Platform::Type::operator class Platform::Type ^(class Windows::UI::Xaml::Interop::TypeName typeName)
+	{
+		return ref new ::Platform::Type(typeName);
+	}
+
+} // namespace Platform
+
+CPPCLI_FUNC Platform::Type^ __stdcall __abi_make_type_id(const __abi_type_descriptor& typeInfo)
+{
+	Platform::IntPtr ptr = const_cast<__abi_type_descriptor*>(&typeInfo);
+	return ref new Platform::Type(ptr);
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vccorlib/vccorlib.cpp

@@ -0,0 +1,116 @@
+//
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+#include "pch.h"
+
+CPPCLI_FUNC void __stdcall FlushFactoryCache();
+CPPCLI_FUNC void EnableFactoryCache();
+void DisableFactoryCache();
+
+__abi_Module* __abi_module = nullptr;
+
+#include "crtdefs.h"
+#include <corecrt_startup.h>
+
+__declspec(noreturn) __declspec(dllexport) void __stdcall __abi_FailFast()
+{
+	_invoke_watson(nullptr, nullptr, nullptr, 0, 0);
+}
+
+namespace Platform {
+	namespace Details {
+
+		class InternalModule :
+			public __abi_Module
+		{
+		public:
+			InternalModule()
+			{
+				__abi_module = this;
+			}
+
+			virtual ~InternalModule()
+			{
+				__abi_module = nullptr;
+			}
+
+			virtual unsigned long __stdcall __abi_IncrementObjectCount()
+			{
+				return 0;
+			}
+
+			virtual unsigned long __stdcall __abi_DecrementObjectCount()
+			{
+				return 0;
+			}
+		};
+
+#pragma warning( disable: 4073 )  // initializers put in library initialization area
+#pragma init_seg( lib )
+
+		InternalModule internalModule_;
+
+		VCCORLIB_API HRESULT InitializeData(int threadingModel)
+		{
+			if (threadingModel != _VCCORLIB_THREADING_MODEL_DEFAULT)
+			{
+				RO_INIT_TYPE initType = threadingModel == _VCCORLIB_THREADING_MODEL_STA
+					? static_cast<RO_INIT_TYPE>(0) /* RO_INIT_SINGLETHREADED */
+					: RO_INIT_MULTITHREADED;
+
+				HRESULT hr = Windows::Foundation::Initialize(initType);
+				if (FAILED(hr))
+				{
+#ifdef _DEBUG
+					if (IsDebuggerPresent())
+					{
+						OutputDebugStringW(L"Call to Windows::Foundation::Initialize failed.");
+					}
+#endif
+					return hr;
+				}
+
+				EnableFactoryCache();
+			}
+			return S_OK;
+		}
+
+		VCCORLIB_API void UninitializeData(int threadingModel)
+		{
+			if (threadingModel != 0)
+			{
+				DisableFactoryCache();
+				Windows::Foundation::Uninitialize();
+			}
+		}
+
+		VCCORLIB_API HRESULT STDMETHODCALLTYPE GetActivationFactory(
+			_In_ Microsoft::WRL::Details::ModuleBase* module,
+			_In_ HSTRING pActivatibleClassId,
+			_Deref_out_ ::IActivationFactory** ppFactory)
+		{
+			return Microsoft::WRL::Details::GetActivationFactory<Microsoft::WRL::InProcDisableCaching>(module, nullptr, pActivatibleClassId, ppFactory);
+		}
+
+		VCCORLIB_API bool STDMETHODCALLTYPE TerminateModule(_In_ Microsoft::WRL::Details::ModuleBase* module)
+		{
+			return Microsoft::WRL::Details::TerminateMap(module, nullptr, false);
+		}
+
+VCCORLIB_API wchar_t** GetCmdArguments(_Out_ int* argc)
+{
+	_ASSERTE(argc != nullptr);
+
+	if (_configure_wide_argv(_get_startup_argv_mode()) != 0)
+	{
+		*argc = 0;
+		return nullptr;
+	}
+
+	*argc = __argc;
+	return __wargv;
+}
+
+
+	} } // namespace Platform::Details

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vccorlib/vcwinrt.cpp

@@ -0,0 +1,494 @@
+//
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+
+#include "pch.h"
+#include <string>
+#include <map>
+#include <unordered_map>
+#include <vector>
+#include "activation.h"
+#pragma hdrstop
+#include <strsafe.h>
+#include <memory>
+#include <combaseapi.h>
+
+using namespace Microsoft::WRL;
+using namespace std;
+
+struct conditional_deleter
+{
+    conditional_deleter(bool bDelete = true) : _bDelete(bDelete)
+    {
+    }
+    conditional_deleter(const conditional_deleter& other) : _bDelete(other._bDelete)
+    {
+    }
+    conditional_deleter(conditional_deleter&& other) : _bDelete(other._bDelete)
+    {
+        other._bDelete = true;
+    }
+    conditional_deleter& operator=(conditional_deleter other)
+    {
+        _bDelete = other._bDelete;
+    }
+    void operator()(const wchar_t* p)
+    {
+        if (_bDelete)
+        {
+            delete p; // TRANSITION, should be delete[]
+        }
+        return;
+    }
+private:
+    bool _bDelete;
+};
+
+template <typename deletor>
+struct hash_unique_wchar
+{
+    size_t operator()(const unique_ptr<const wchar_t, deletor>& ele) const
+    {
+        const wstring_view sv{ele.get()};
+        return hash<wstring_view>{}(sv);
+    }
+};
+
+template <typename deletor>
+struct equal_unique_wchar
+{
+    bool operator()(const unique_ptr<const wchar_t, deletor>& first, const unique_ptr<const wchar_t, deletor>& second) const
+    {
+        return wcscmp(first.get(), second.get()) == 0;
+    }
+};
+
+CPPCLI_FUNC HRESULT __stdcall __getActivationFactoryByHSTRING(HSTRING str, ::Platform::Guid& riid, PVOID * ppActivationFactory)
+{
+    HRESULT hr = S_OK;
+    IActivationFactory* pActivationFactory;
+    hr = Windows::Foundation::GetActivationFactory(str, &pActivationFactory);
+    if (SUCCEEDED(hr))
+    {
+        hr = pActivationFactory->QueryInterface(reinterpret_cast<REFIID>(riid), ppActivationFactory);
+        pActivationFactory->Release();
+    }
+
+    return hr;
+}
+
+class PerApartmentFactoryCache : public RuntimeClass<RuntimeClassFlags<ClassicCom>, IApartmentShutdown, FtmBase>
+{
+    UINT64 _apartmentId;
+protected:
+    typedef unique_ptr<const wchar_t, conditional_deleter> ActivatableID; // TRANSITION, should be const wchar_t[]
+private:
+    unordered_map<ActivatableID,
+        ComPtr<IUnknown>,
+            hash_unique_wchar<conditional_deleter>,
+                equal_unique_wchar<conditional_deleter >> _factoryCache;
+protected:
+    virtual HRESULT AddFactoryInternal(std::pair<ActivatableID, ComPtr<IUnknown> > &&entry)
+    {
+        auto ret = _factoryCache.insert(std::move(entry));
+        if (ret.second == false)
+        {
+            return S_FALSE;
+        }
+
+        return S_OK;
+    }
+
+    virtual HRESULT GetFactoryInternal(const wchar_t* acid, Platform::Guid& iid, void** pFactory, bool& addToCache)
+    {
+        __WRL_ASSERT__(addToCache == true); // The default value for addToCache should be true
+
+        *pFactory = nullptr;
+        // Don't delete buffer
+        ActivatableID activatableID(acid, false);
+        auto it = _factoryCache.find(std::move(activatableID));
+        if (it == _factoryCache.end())
+        {
+            return E_FAIL;
+        }
+
+        // The factory pointer is nullptr only
+        // in case that the factory has proxy
+        IUnknown* unk = it->second.Get();
+        if (unk == nullptr)
+        {
+            addToCache = false;
+            return E_FAIL;
+        }
+
+        return unk->QueryInterface(iid, pFactory);
+    }
+public:
+    HRESULT RuntimeClassInitialize(UINT64 appartmentId)
+    {
+        _apartmentId = appartmentId;
+        return S_OK;
+    }
+
+    HRESULT AddFactory(const wchar_t* acid, IUnknown *factory)
+    {
+        try
+        {
+            auto len = wcslen(acid) + 1;
+            wchar_t* acidCopy = new wchar_t[len];
+            wcscpy_s(acidCopy, len, acid);
+            ActivatableID activatableID(acidCopy);
+
+            ComPtr<IMultiQI> multiQI;
+			// In case of OOP component there is possibility of RPC errors
+			// that can result in cache poisoning as there is no easy way
+			// to detect that the factory encounterd RPC errors.
+			// The QI for IMultiQI allows us to identify the proxy stub for OOP component
+            if (factory->QueryInterface(__uuidof(::IMultiQI), &multiQI) == S_OK)
+            {
+                // Insert empty marker to indicate that it's out of proc factory
+                return AddFactoryInternal(make_pair(std::move(activatableID), nullptr));
+            }
+            else
+            {
+                ComPtr<IUnknown> unk = factory;
+                return AddFactoryInternal(make_pair(std::move(activatableID), std::move(unk)));
+            }
+        }
+        catch (const bad_alloc&)
+        {
+            return E_OUTOFMEMORY;
+        }
+        catch (const exception&)
+        {
+            return E_FAIL;
+        }
+    }
+
+    // addToCache parameter prevents from adding the factory into the cache
+    // this is used for MTA appartment to reduce contention
+    HRESULT GetFactory(const wchar_t* acid, Platform::Guid& iid, void** pFactory, bool& addToCache)
+    {
+        *pFactory = nullptr;
+        try
+        {
+            return GetFactoryInternal(acid, iid, pFactory, addToCache);
+        }
+        catch (const bad_alloc&)
+        {
+            return E_OUTOFMEMORY;
+        }
+    }
+
+    void __stdcall OnUninitialize(UINT64 apartmentIdentifier);
+};
+
+static bool IsMTA()
+{
+    APTTYPE AptType;
+    APTTYPEQUALIFIER AptQualifier;
+    HRESULT hr = CoGetApartmentType(&AptType, &AptQualifier);
+    if (SUCCEEDED(hr) && (AptType == APTTYPE::APTTYPE_MTA || AptType == APTTYPE::APTTYPE_NA))
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+class PerApartmentFactoryCacheMTA : public PerApartmentFactoryCache
+{
+    Wrappers::SRWLock _SRWLock;
+protected:
+    virtual HRESULT AddFactoryInternal(std::pair<ActivatableID, ComPtr<IUnknown> > &&entry)
+    {
+        __WRL_ASSERT__(IsMTA());
+
+        // Lock exclusive on addition so we always make sure that we cache the value
+        auto lock = _SRWLock.LockExclusive();
+        return PerApartmentFactoryCache::AddFactoryInternal(std::move(entry));
+    }
+
+    virtual HRESULT GetFactoryInternal(const wchar_t* acid, Platform::Guid& iid, void** pFactory, bool& addToCache)
+    {
+        __WRL_ASSERT__(IsMTA());
+
+        // If we cannot access cache because of addition or deletion
+        // vccorlib will call windows to create new factory
+        auto lock = _SRWLock.TryLockShared();
+        if (!lock.IsLocked())
+        {
+            // The lock couldn't be taken so there must be either addition or removal happening
+            // in this case we will not try to put the factory to the cache
+            addToCache = false;
+            return E_FAIL;
+        }
+
+        return PerApartmentFactoryCache::GetFactoryInternal(acid, iid, pFactory, addToCache);
+    }
+};
+
+static HRESULT CreateFactoryCache(PerApartmentFactoryCache** pFactory, UINT64 apartmentID)
+{
+    if (IsMTA())
+    {
+        return MakeAndInitialize<PerApartmentFactoryCacheMTA>(reinterpret_cast<PerApartmentFactoryCacheMTA**>(pFactory), apartmentID);
+    }
+    else
+    {
+        return MakeAndInitialize<PerApartmentFactoryCache>(pFactory, apartmentID);
+    }
+}
+
+class FactoryCache
+{
+    vector<pair<UINT64, pair<APARTMENT_SHUTDOWN_REGISTRATION_COOKIE, ComPtr<PerApartmentFactoryCache>>>> perApartmentCache;
+    Wrappers::CriticalSection _criticalSection;
+    static volatile long _cacheEnabled;
+    static volatile long _cacheDestroyed;
+public:
+    static void Enable()
+    {
+        ::_InterlockedCompareExchange(&_cacheEnabled, 1, 0);
+    }
+    static void Disable()
+    {
+        ::_InterlockedCompareExchange(&_cacheEnabled, 0, 1);
+    }
+    static bool IsEnabled()
+    {
+        return (_cacheEnabled == 1);
+    }
+    static bool IsDestroyed()
+    {
+        return (_cacheDestroyed != 0);
+    }
+
+    ~FactoryCache()
+    {
+        Disable();
+        ::_InterlockedIncrement(&_cacheDestroyed);
+        Flush();
+    }
+    void Flush()
+    {
+        auto lock  = _criticalSection.Lock();
+        for(auto it = perApartmentCache.begin(); it != perApartmentCache.end(); it++)
+        {
+            // Ignore any failures when unregistering cookies as there's nothing else we can do
+            (void) ::RoUnregisterForApartmentShutdown(it->second.first);
+
+            // Leak all per apartment factory cache as during shutdown
+            // we may try to release the factories in the wrong context
+            it->second.second.Detach();
+        }
+        perApartmentCache.clear();
+    }
+    HRESULT GetFactory(LPCWSTR acid, Platform::Guid& iid, void** pFactory)
+    {
+        UINT64 apartmentID;
+        bool addToCache = true;
+
+        HRESULT hr = ::RoGetApartmentIdentifier(&apartmentID);
+        ComPtr<PerApartmentFactoryCache> apartmentCache;
+        if (SUCCEEDED(hr) && IsEnabled())
+        {
+            auto lock  = _criticalSection.Lock();
+            for(auto it = perApartmentCache.begin(); it != perApartmentCache.end(); it++)
+            {
+                if (it->first == apartmentID)
+                {
+                    apartmentCache = it->second.second;
+                    lock.Unlock();
+                    hr = apartmentCache->GetFactory(acid, iid, pFactory, addToCache);
+                    if (SUCCEEDED(hr))
+                    {
+                        return hr;
+                    }
+                    break;
+                }
+            }
+            if (apartmentCache == nullptr)
+            {
+                hr = CreateFactoryCache(&apartmentCache, apartmentID);
+                if (SUCCEEDED(hr))
+                {
+                    UINT64 regAppartmentId;
+                    APARTMENT_SHUTDOWN_REGISTRATION_COOKIE regCookie;
+                    hr = ::RoRegisterForApartmentShutdown(apartmentCache.Get(), &regAppartmentId, &regCookie);
+                    if (SUCCEEDED(hr))
+                    {
+                        __WRL_ASSERT__(regAppartmentId == apartmentID);
+                        perApartmentCache.push_back(pair<UINT64,
+                            pair<APARTMENT_SHUTDOWN_REGISTRATION_COOKIE, ComPtr<PerApartmentFactoryCache>>>
+                                (apartmentID, pair<APARTMENT_SHUTDOWN_REGISTRATION_COOKIE, ComPtr<PerApartmentFactoryCache>>(regCookie, apartmentCache.Get())));
+                    }
+                }
+            }
+        }
+
+        // Create Factory
+        HSTRING className;
+        HSTRING_HEADER classNameHeader;
+        hr = ::WindowsCreateStringReference(acid, static_cast<UINT32>(wcslen(acid)), &classNameHeader, &className);
+        if (FAILED(hr))
+        {
+            return hr;
+        }
+
+        ComPtr<IUnknown> factory;
+        Platform::Guid riidUnknown(__uuidof(IUnknown));
+        hr = __getActivationFactoryByHSTRING(className, riidUnknown, &factory);
+
+        ::WindowsDeleteString(className);
+
+        if (FAILED(hr))
+        {
+            return hr;
+        }
+
+        if (apartmentCache != nullptr && addToCache)
+        {
+            apartmentCache->AddFactory(acid, factory.Get());
+        }
+
+        return factory.CopyTo(iid, pFactory);
+    }
+
+    void RemoveApartmentCache(UINT64 apartmentIdentifier)
+    {
+        auto lock  = _criticalSection.Lock();
+
+        for(auto it = perApartmentCache.begin(); it != perApartmentCache.end(); it++)
+        {
+            if (it->first == apartmentIdentifier)
+            {
+                perApartmentCache.erase(it);
+                break;
+            }
+        }
+    }
+};
+
+volatile long FactoryCache::_cacheEnabled = 0;
+volatile long FactoryCache::_cacheDestroyed = 0;
+FactoryCache g_FactoryCache;
+
+void __stdcall PerApartmentFactoryCache::OnUninitialize(UINT64 apartmentIdentifier)
+{
+    if (apartmentIdentifier == _apartmentId)
+    {
+        g_FactoryCache.RemoveApartmentCache(apartmentIdentifier);
+    }
+}
+
+CPPCLI_FUNC void EnableFactoryCache()
+{
+    FactoryCache::Enable();
+}
+
+void DisableFactoryCache()
+{
+    FactoryCache::Disable();
+}
+
+CPPCLI_FUNC void __stdcall FlushFactoryCache()
+{
+    if (!FactoryCache::IsDestroyed())
+    {
+        g_FactoryCache.Flush();
+    }
+}
+
+CPPCLI_FUNC HRESULT __stdcall GetActivationFactoryByPCWSTR(void* str, ::Platform::Guid& riid, void** ppActivationFactory)
+{
+    wchar_t* acid =  static_cast<wchar_t*>(str);
+    if (!FactoryCache::IsEnabled())
+    {
+        HSTRING className;
+        HSTRING_HEADER classNameHeader;
+        HRESULT hr = ::WindowsCreateStringReference(acid, static_cast<UINT32>(wcslen(acid)), &classNameHeader, &className);
+        if (SUCCEEDED(hr))
+        {
+            hr = __getActivationFactoryByHSTRING(className, riid, ppActivationFactory);
+            ::WindowsDeleteString(className);
+        }
+        return hr;
+    }
+    return g_FactoryCache.GetFactory(acid, riid, ppActivationFactory);
+}
+
+CPPCLI_FUNC HRESULT __stdcall GetIidsFn(int nIids, unsigned long* iidCount, const __s_GUID* pIids, ::Platform::Guid** ppDuplicated)
+{
+    int nBytes = nIids * sizeof(::Platform::Guid);
+
+    *ppDuplicated = (::Platform::Guid*)CoTaskMemAlloc(nBytes);
+    if (*ppDuplicated)
+    {
+        memcpy(*ppDuplicated, pIids, nBytes);
+        *iidCount = nIids;
+        return S_OK;
+    }
+
+    *iidCount = 0;
+    return E_OUTOFMEMORY;
+}
+
+#include "compiler.cpp"
+#include "activation.cpp"
+
+
+#pragma warning( disable: 4073 )  // initializers put in library initialization area
+#pragma init_seg( lib )
+
+#include "ehdata.h"
+extern "C" void __cdecl _SetWinRTOutOfMemoryExceptionCallback(PGETWINRT_OOM_EXCEPTION pCallback);
+
+namespace Platform { namespace Details {
+    extern bool  __abi_firstAlloc;
+    extern bool  __abi_is_global_oom_init;
+    extern void* __abi_oom_controlblock;
+    extern IUnknown* __abi_oom_singleton;
+} }
+
+void* __stdcall GetOutOfMemoryExceptionCallback()
+{
+    Platform::Details::__abi_oom_singleton->AddRef();
+    return Platform::Details::__abi_oom_singleton;
+}
+
+class CInitExceptions
+{
+public:
+    CInitExceptions()
+    {
+        // Ignore the effect on the ref new below on __abi_firstAlloc.
+        bool wasFirstAlloc = Platform::Details::__abi_firstAlloc;
+
+        Platform::Details::__abi_is_global_oom_init = true;
+
+        // Would take down the process if it throws. This is fine.
+        Platform::OutOfMemoryException^ oom = ref new Platform::OutOfMemoryException();
+
+        Platform::Details::__abi_is_global_oom_init = false;
+
+        // Recover firstalloc, so that user can set TrackingLevel in main.
+        Platform::Details::__abi_firstAlloc = wasFirstAlloc;
+
+        Platform::Details::__abi_oom_singleton = reinterpret_cast<IUnknown*>(oom);
+        Platform::Details::__abi_oom_singleton->AddRef();
+
+        _SetWinRTOutOfMemoryExceptionCallback(GetOutOfMemoryExceptionCallback);
+    }
+
+    ~CInitExceptions()
+    {
+        _SetWinRTOutOfMemoryExceptionCallback(nullptr);
+        Platform::Details::__abi_oom_singleton->Release();
+    }
+};
+
+CInitExceptions initExceptions;

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vccorlib/weakreference.cpp

@@ -0,0 +1,112 @@
+//
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+
+#include "pch.h"
+#pragma hdrstop
+
+namespace Platform { namespace Details {
+
+	VCCORLIB_API void ControlBlock::ReleaseTarget()
+	{
+		// called by __abi_release after calling the destructor of object
+		if (!__bSingleAllocation && __strongRefCount < 0 && __target != nullptr)
+		{
+			if (__bAlignedAllocation)
+			{
+				if (__bExceptionAllocation)
+				{
+					::Platform::Details::Heap::AlignedFreeException(__target);
+				}
+				else
+				{
+					::Platform::Details::Heap::AlignedFree(__target);
+				}
+			}
+			else
+			{
+				if (__bExceptionAllocation)
+				{
+					::Platform::Details::Heap::FreeException(__target);
+				}
+				else
+				{
+					::Platform::Details::Heap::Free(__target);
+				}
+			}
+			__target = nullptr;
+		}
+	}
+
+	VCCORLIB_API long __stdcall ControlBlock::__abi_Resolve(::Platform::Guid& __riid, __abi_IInspectable ** __objectReference)
+	{
+		for(;;)
+		{
+			long __ref = __strongRefCount;
+			if (__ref <= 0)
+			{
+				return 0;
+			}
+
+			// InterlockedCompareExchange calls _InterlockedCompareExchange intrinsic thus we call directly _InterlockedCompareExchange to save the call
+			if (::_InterlockedCompareExchange(&__strongRefCount, __ref + 1, __ref) == __ref)
+			{
+				break;
+			}
+		}
+
+		long __hr = __target->__abi_QueryInterface(__riid, reinterpret_cast<void**>(__objectReference));
+
+		// Undo the "addref" that happened above during the _InterlockedCompareExchange call
+		__target->__abi_Release();
+
+		return __hr;
+	}
+
+	// Object has a reference to control block
+	VCCORLIB_API void ControlBlock::InitControlBlock(void* __object, bool __bSingleAllocationParam, bool __bAlignedAllocationParam, bool __bExceptionAllocationParam)
+	{
+		__vtable_initialize(ControlBlock);
+		__weakRefCount = 1;
+		__strongRefCount = 1;
+		__target = reinterpret_cast<__abi_IUnknown*>(__object);
+		__bSingleAllocation = __bSingleAllocationParam;
+		__bAlignedAllocation = __bAlignedAllocationParam;
+		__bExceptionAllocation = __bExceptionAllocationParam;
+	}
+
+#pragma warning(push)
+#pragma warning(disable: 4400)
+	VCCORLIB_API __abi_IUnknown* __stdcall GetWeakReference(const volatile Platform::Object^ const other)
+#pragma warning(pop)
+	{
+		if (other == nullptr)
+		{
+			throw ref new ::Platform::InvalidArgumentException();
+		}
+
+		Microsoft::WRL::WeakRef ref;
+		HRESULT hr = Microsoft::WRL::AsWeak(reinterpret_cast<IUnknown*>(const_cast<Platform::Object^>(other)), &ref);
+		__abi_ThrowIfFailed(hr);
+
+		return reinterpret_cast<__abi_IUnknown*>(ref.Detach());
+	}
+
+	VCCORLIB_API
+		__declspec(no_refcount)
+		::Platform::Object^ __stdcall ResolveWeakReference(const ::_GUID& guid, __abi_IUnknown** weakRef)
+	{
+		::Platform::Object ^strongRef = nullptr;
+
+		if (*weakRef != nullptr)
+		{
+			Microsoft::WRL::WeakRef *ref = reinterpret_cast<Microsoft::WRL::WeakRef*>(weakRef);
+			HRESULT hr = ref->CopyTo(guid, reinterpret_cast<IInspectable**>(&strongRef));
+			__abi_ThrowIfFailed(hr);
+		}
+
+		return strongRef;
+	}
+
+} } // namesapce Platform::Details

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vccorlib/winmain.cpp

@@ -0,0 +1,13 @@
+//
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+
+#include "pch.h"
+
+int __cdecl _main();
+
+int CALLBACK WinMain(_In_ HINSTANCE, _In_opt_ HINSTANCE, _In_ LPSTR, _In_ int)
+{
+	return _main();
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/ManagedMain.cpp

@@ -0,0 +1,28 @@
+/***
+*ManagedMain.cpp - Initialization for Windows EXE using CRT DLL and managed entry point
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       This is the startup routine for applications using the managed entry
+*       point int __clrcall main(array<String^>^).
+*       It calls the user's main routine after performing C Run-Time Library initialization.
+*
+*******************************************************************************/
+
+#define _MANAGED_MAIN
+
+#define WPRFLAG 1 /* Flag used by startup code to indicate wide strings */
+
+#ifndef _UNICODE
+#define _UNICODE 1
+#endif  /* _UNICODE */
+
+#ifndef UNICODE
+#define UNICODE 1
+#endif  /* UNICODE */
+
+#undef _MBCS /* UNICODE not _MBCS */
+
+
+#include "mcrtexe.cpp"

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/app_appinit.cpp

@@ -0,0 +1,19 @@
+//
+// app_appinit.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// This object is part of the import library for the Windows Store app CRT.  It
+// coordinates the call to RoInitialize with vccorlib, to ensure that either
+// vccorlib or the CRT (but not both) call RoInitialize.  This object is linked
+// into the client app if and only if it does not use vccorlib.
+//
+#include <roapi.h>
+
+
+
+extern "C" int __crtWinrtInitType = RO_INIT_MULTITHREADED;
+
+
+
+#pragma detect_mismatch("vccorlib_lib_should_be_specified_before_msvcrt_lib_to_linker", "0")

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/argv_mode.cpp

@@ -0,0 +1,16 @@
+//
+// argv_mode.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Gets the default argv population mode, used during executable startup.  This
+// behavior is overridable at link-time by linking with one of the link options.
+//
+#include <vcruntime_startup.h>
+
+
+
+extern "C" _crt_argv_mode __CRTDECL _get_startup_argv_mode()
+{
+    return _crt_argv_unexpanded_arguments;
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/c11_atomic_support.c

@@ -0,0 +1,150 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// C11 atomic support routines: extern inline definitions
+#include <vcruntime_c11_atomic_support.h>
+
+extern inline void _Check_memory_order(const unsigned int _Order);
+extern inline void _Atomic_thread_fence(const unsigned int _Order);
+
+extern inline void _Atomic_lock_acquire(volatile long* _Spinlock);
+extern inline void _Atomic_lock_release(volatile long* _Spinlock);
+
+extern inline void _Atomic_signal_fence(int _Order);
+extern inline _Bool _Atomic_is_lock_free(size_t _Sz);
+
+extern inline void _Atomic_store8(volatile char* _Ptr, char _Desired, int _Order);
+extern inline void _Atomic_store16(volatile short* _Ptr, short _Desired, int _Order);
+extern inline void _Atomic_store32(volatile int* _Ptr, int _Desired, int _Order);
+extern inline void _Atomic_store64(volatile long long* _Ptr, long long _Desired, int _Order);
+extern inline void _Atomic_storef(volatile float* _Ptr, float _Desired, int _Order);
+extern inline void _Atomic_stored(volatile double* _Ptr, double _Desired, int _Order);
+
+extern inline char _Atomic_load8(const volatile char* _Ptr, int _Order);
+extern inline short _Atomic_load16(const volatile short* _Ptr, int _Order);
+extern inline int _Atomic_load32(const volatile int* _Ptr, int _Order);
+extern inline long long _Atomic_load64(const volatile long long* _Ptr, int _Order);
+extern inline float _Atomic_loadf(const volatile float* _Ptr, int _Order);
+extern inline double _Atomic_loadd(const volatile double* _Ptr, int _Order);
+
+extern inline _Bool _Atomic_compare_exchange_strong8(volatile char* _Ptr, char* _Expected, char _Desired, int _Order);
+extern inline _Bool _Atomic_compare_exchange_strong16(
+    volatile short* _Ptr, short* _Expected, short _Desired, int _Order);
+extern inline _Bool _Atomic_compare_exchange_strong32(volatile int* _Ptr, int* _Expected, int _Desired, int _Order);
+extern inline _Bool _Atomic_compare_exchange_strong64(
+    volatile long long* _Ptr, long long* _Expected, long long _Desired, int _Order);
+extern inline _Bool _Atomic_compare_exchange_strongf(volatile float* _Ptr, float* _Expected, float _Desired, int _Order);
+extern inline _Bool _Atomic_compare_exchange_strongd(
+    volatile double* _Ptr, double* _Expected, double _Desired, int _Order);
+
+extern inline char _Atomic_exchange8(volatile char* _Ptr, int _Desired, int _Order);
+extern inline short _Atomic_exchange16(volatile short* _Ptr, int _Desired, int _Order);
+extern inline int _Atomic_exchange32(volatile int* _Ptr, int _Desired, int _Order);
+extern inline long long _Atomic_exchange64(volatile long long* _Ptr, long long _Desired, int _Order);
+extern inline float _Atomic_exchangef(volatile float* _Ptr, float _Desired, int _Order);
+extern inline double _Atomic_exchanged(volatile double* _Ptr, double _Desired, int _Order);
+
+extern inline char _Atomic_fetch_add8(volatile char* _Ptr, int val, int _Order);
+extern inline short _Atomic_fetch_add16(volatile short* _Ptr, int val, int _Order);
+extern inline int _Atomic_fetch_add32(volatile int* _Ptr, int val, int _Order);
+extern inline long long _Atomic_fetch_add64(volatile long long* _Ptr, long long val, int _Order);
+extern inline float _Atomic_fetch_addf(volatile float* _Ptr, float val, int _Order);
+extern inline double _Atomic_fetch_addd(volatile double* _Ptr, double val, int _Order);
+
+extern inline char _Atomic_add_fetch8(volatile char* _Ptr, int val, int _Order);
+extern inline short _Atomic_add_fetch16(volatile short* _Ptr, int val, int _Order);
+extern inline int _Atomic_add_fetch32(volatile int* _Ptr, int val, int _Order);
+extern inline long long _Atomic_add_fetch64(volatile long long* _Ptr, long long val, int _Order);
+extern inline float _Atomic_add_fetchf(volatile float* _Ptr, float val, int _Order);
+extern inline double _Atomic_add_fetchd(volatile double* _Ptr, double val, int _Order);
+
+extern inline char _Atomic_fetch_sub8(volatile char* _Ptr, int val, int _Order);
+extern inline short _Atomic_fetch_sub16(volatile short* _Ptr, int val, int _Order);
+extern inline int _Atomic_fetch_sub32(volatile int* _Ptr, int val, int _Order);
+extern inline long long _Atomic_fetch_sub64(volatile long long* _Ptr, long long val, int _Order);
+extern inline float _Atomic_fetch_subf(volatile float* _Ptr, float val, int _Order);
+extern inline double _Atomic_fetch_subd(volatile double* _Ptr, double val, int _Order);
+
+extern inline char _Atomic_sub_fetch8(volatile char* _Ptr, int val, int _Order);
+extern inline short _Atomic_sub_fetch16(volatile short* _Ptr, int val, int _Order);
+extern inline int _Atomic_sub_fetch32(volatile int* _Ptr, int val, int _Order);
+extern inline long long _Atomic_sub_fetch64(volatile long long* _Ptr, long long val, int _Order);
+extern inline float _Atomic_sub_fetchf(volatile float* _Ptr, float val, int _Order);
+extern inline double _Atomic_sub_fetchd(volatile double* _Ptr, double val, int _Order);
+
+extern inline char _Atomic_fetch_and8(volatile char* _Ptr, int val, int _Order);
+extern inline short _Atomic_fetch_and16(volatile short* _Ptr, int val, int _Order);
+extern inline int _Atomic_fetch_and32(volatile int* _Ptr, int val, int _Order);
+extern inline long long _Atomic_fetch_and64(volatile long long* _Ptr, long long val, int _Order);
+
+extern inline char _Atomic_and_fetch8(volatile char* _Ptr, int val, int _Order);
+extern inline short _Atomic_and_fetch16(volatile short* _Ptr, int val, int _Order);
+extern inline int _Atomic_and_fetch32(volatile int* _Ptr, int val, int _Order);
+extern inline long long _Atomic_and_fetch64(volatile long long* _Ptr, long long val, int _Order);
+
+extern inline char _Atomic_fetch_or8(volatile char* _Ptr, int val, int _Order);
+extern inline short _Atomic_fetch_or16(volatile short* _Ptr, int val, int _Order);
+extern inline int _Atomic_fetch_or32(volatile int* _Ptr, int val, int _Order);
+extern inline long long _Atomic_fetch_or64(volatile long long* _Ptr, long long val, int _Order);
+
+extern inline char _Atomic_or_fetch8(volatile char* _Ptr, int val, int _Order);
+extern inline short _Atomic_or_fetch16(volatile short* _Ptr, int val, int _Order);
+extern inline int _Atomic_or_fetch32(volatile int* _Ptr, int val, int _Order);
+extern inline long long _Atomic_or_fetch64(volatile long long* _Ptr, long long val, int _Order);
+
+extern inline char _Atomic_fetch_xor8(volatile char* _Ptr, int val, int _Order);
+extern inline short _Atomic_fetch_xor16(volatile short* _Ptr, int val, int _Order);
+extern inline int _Atomic_fetch_xor32(volatile int* _Ptr, int val, int _Order);
+extern inline long long _Atomic_fetch_xor64(volatile long long* _Ptr, long long val, int _Order);
+
+extern inline char _Atomic_xor_fetch8(volatile char* _Ptr, int val, int _Order);
+extern inline short _Atomic_xor_fetch16(volatile short* _Ptr, int val, int _Order);
+extern inline int _Atomic_xor_fetch32(volatile int* _Ptr, int val, int _Order);
+extern inline long long _Atomic_xor_fetch64(volatile long long* _Ptr, long long val, int _Order);
+
+extern inline char _Atomic_mult_fetch8(volatile char* _Ptr, int val, int _Order);
+extern inline short _Atomic_mult_fetch16(volatile short* _Ptr, int val, int _Order);
+extern inline int _Atomic_mult_fetch32(volatile int* _Ptr, int val, int _Order);
+extern inline long long _Atomic_mult_fetch64(volatile long long* _Ptr, long long val, int _Order);
+extern inline float _Atomic_mult_fetchf(volatile float* _Ptr, float val, int _Order);
+extern inline double _Atomic_mult_fetchd(volatile double* _Ptr, double val, int _Order);
+
+extern inline unsigned char _Atomic_div_fetch8(volatile unsigned char* _Ptr, unsigned int val, int _Order);
+extern inline unsigned short _Atomic_div_fetch16(volatile unsigned short* _Ptr, unsigned int val, int _Order);
+extern inline unsigned int _Atomic_div_fetch32(volatile unsigned int* _Ptr, unsigned int val, int _Order);
+extern inline unsigned long long _Atomic_div_fetch64(
+    volatile unsigned long long* _Ptr, unsigned long long val, int _Order);
+extern inline float _Atomic_div_fetchf(volatile float* _Ptr, float val, int _Order);
+extern inline double _Atomic_div_fetchd(volatile double* _Ptr, double val, int _Order);
+
+extern inline signed char _Atomic_idiv_fetch8(volatile char* _Ptr, int val, int _Order);
+extern inline short _Atomic_idiv_fetch16(volatile short* _Ptr, int val, int _Order);
+extern inline int _Atomic_idiv_fetch32(volatile int* _Ptr, int val, int _Order);
+extern inline long long _Atomic_idiv_fetch64(volatile long long* _Ptr, long long val, int _Order);
+
+extern inline char _Atomic_shl_fetch8(volatile char* _Ptr, int val, int _Order);
+extern inline short _Atomic_shl_fetch16(volatile short* _Ptr, int val, int _Order);
+extern inline int _Atomic_shl_fetch32(volatile int* _Ptr, int val, int _Order);
+extern inline long long _Atomic_shl_fetch64(volatile long long* _Ptr, long long val, int _Order);
+
+extern inline char _Atomic_shr_fetch8(volatile char* _Ptr, int val, int _Order);
+extern inline short _Atomic_shr_fetch16(volatile short* _Ptr, int val, int _Order);
+extern inline int _Atomic_shr_fetch32(volatile int* _Ptr, int val, int _Order);
+extern inline long long _Atomic_shr_fetch64(volatile long long* _Ptr, long long val, int _Order);
+
+extern inline signed char _Atomic_imod_fetch8(volatile char* _Ptr, int val, int _Order);
+extern inline short _Atomic_imod_fetch16(volatile short* _Ptr, int val, int _Order);
+extern inline int _Atomic_imod_fetch32(volatile int* _Ptr, int val, int _Order);
+extern inline long long _Atomic_imod_fetch64(volatile long long* _Ptr, long long val, int _Order);
+
+extern inline unsigned char _Atomic_mod_fetch8(volatile unsigned char* _Ptr, unsigned int val, int _Order);
+extern inline unsigned short _Atomic_mod_fetch16(volatile unsigned short* _Ptr, unsigned int val, int _Order);
+extern inline unsigned int _Atomic_mod_fetch32(volatile unsigned int* _Ptr, unsigned int val, int _Order);
+extern inline unsigned long long _Atomic_mod_fetch64(
+    volatile unsigned long long* _Ptr, unsigned long long val, int _Order);
+
+extern inline void _Atomic_lock_and_store(volatile void* _Obj, const void* _Desired, int _Offset, size_t _Size);
+extern inline void _Atomic_lock_and_load(volatile void* _Obj, void* _Dest, int _Offset, size_t _Size);
+extern inline void _Atomic_lock_and_exchange(
+    volatile void* _Obj, const void* _Desired, void* _Dest, int _Offset, size_t _Size);
+extern inline _Bool _Atomic_lock_and_compare_exchange_strong(
+    volatile void* _Obj, void* _Expected, const void* _Desired, int _Offset, size_t _Size);

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/checkcfg.c

@@ -0,0 +1,70 @@
+/***
+*checkcfg.c - logic and globals to support the Guard security feature
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Define the globals and default check routine for the Guard security
+*       feature.
+*
+*       N.B.  Code and data declared by this module must be in the form of
+*             selectany COMDATs, so that duplicate definitions between the
+*             CRT and no_cfg_support are permitted for the restricted use
+*             cases of the no_cfg_support module.
+*
+*******************************************************************************/
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+// the codegen from the C version of this breaks ABI on ARM64
+#error "This file should not be built on ARM64"
+#endif
+
+#include <vcruntime_internal.h>
+
+extern PVOID __guard_check_icall_fptr;
+
+typedef
+void
+(__fastcall *GUARDCF_CHECK_ROUTINE) (
+    uintptr_t Target
+    );
+
+#pragma warning(suppress: 4918) // 'y' is not necessarily supported on all architectures
+BEGIN_PRAGMA_OPTIMIZE_ENABLE("y", DevDivVSO:162582, "Required to avoid poor codegen")
+
+extern
+__declspec(guard(ignore))
+__inline
+void
+__fastcall
+_guard_check_icall (
+    _In_ uintptr_t Target
+    )
+
+/*++
+
+Routine Description:
+
+    This function performs an ICall check when invoked by the compiler to
+    check the integrity of a function pointer for Control Flow Guard (/guard).
+
+    N.B.  This function is only retained for compatibility with pre-17.1 LKG4
+          compilers that do not directly invoke through the
+          __guard_check_icall_fptr function pointer.
+
+Arguments:
+
+    Target - Supplies the function pointer to check.
+
+Return Value:
+
+    None.  If the function pointer supplied was invalid, then a fast fail event
+    or an access violation is raised.
+
+--*/
+
+{
+
+    ((GUARDCF_CHECK_ROUTINE)__guard_check_icall_fptr)(Target);
+    return;
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/commit_mode.cpp

@@ -0,0 +1,16 @@
+//
+// commit_mode.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Gets the default commit mode, used during executable startup.  This behavior
+// is overridable at link-time by linking with one of the link options.
+//
+#include <vcruntime.h>
+
+
+
+extern "C" int __CRTDECL _get_startup_commit_mode()
+{
+    return 0; // No commit
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/debugger_jmc.c

@@ -0,0 +1,29 @@
+/***
+*debugger_jmc.c
+*
+*       Copyright (c) Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*       Define the helper function for VS debugger Just My Code stepping feature.
+*
+*******************************************************************************/
+
+#include <Windows.h>
+#include <intrin.h>
+
+#pragma warning( disable : 4102 )
+#pragma warning( disable : 4189 )
+
+#pragma optimize( "", off )
+
+__declspec(selectany) DWORD __DebuggerCurrentSteppingThreadId;
+
+void __fastcall __CheckForDebuggerJustMyCode(unsigned char *JMC_flag)
+{
+    unsigned char *__DebuggerLocalJMCFlag = JMC_flag;
+
+    if (*JMC_flag && __DebuggerCurrentSteppingThreadId != 0 && __DebuggerCurrentSteppingThreadId == GetCurrentThreadId()) {
+NopLabel:
+        __nop();
+    }
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/default_precision.cpp

@@ -0,0 +1,22 @@
+//
+// default_precision.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Initializes the floating point precision to the default state.  This behavior
+// is overridable at link-time by linking with one of the link options.
+//
+#ifndef _M_IX86
+    #error This file may only be built for x86
+#endif
+
+#include <float.h>
+#include <vcstartup_internal.h>
+
+
+
+extern "C" void __CRTDECL _initialize_default_precision()
+{
+    if (_controlfp_s(nullptr, _PC_53, _MCW_PC) != 0)
+        __scrt_fastfail(FAST_FAIL_FATAL_APP_EXIT);
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/delete_array.cpp

@@ -0,0 +1,32 @@
+//
+// delete_array.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the array operator delete.
+//
+#include <vcruntime_internal.h>
+#include <vcruntime_new.h>
+
+////////////////////////////////////////////////////////////////
+// delete() Fallback Ordering
+//
+// +-------------+
+// |delete_scalar<----+-----------------------+
+// +--^----------+    |                       |
+//    |               |                       |
+// +--+---------+  +--+---------------+  +----+----------------+
+// |delete_array|  |delete_scalar_size|  |delete_scalar_nothrow|
+// +--^----^----+  +------------------+  +---------------------+
+//    |    |
+//    |    +-------------------+
+//    |                        |
+// +--+--------------+  +------+-------------+
+// |delete_array_size|  |delete_array_nothrow|
+// +-----------------+  +--------------------+
+
+_CRT_SECURITYCRITICAL_ATTRIBUTE
+void __CRTDECL operator delete[](void* const block) noexcept
+{
+    operator delete(block);
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/delete_array_align.cpp

@@ -0,0 +1,31 @@
+//
+// delete_array_align.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the array operator delete, align_val_t overload.
+//
+#include <vcruntime_internal.h>
+#include <vcruntime_new.h>
+
+//////////////////////////////////////////////////////////////////////////////////
+// Aligned delete() Fallback Ordering
+//
+// +-------------------+
+// |delete_scalar_align<----+---------------------------+
+// +--^----------------+    |                           |
+//    |                     |                           |
+// +--+---------------+  +--+---------------------+  +--+------------------------+
+// |delete_array_align|  |delete_scalar_size_align|  |delete_scalar_align_nothrow|
+// +--^-----^---------+  +------------------------+  +---------------------------+
+//    |     |
+//    |     +------------------------+
+//    |                              |
+// +--+--------------------+  +------+-------------------+
+// |delete_array_size_align|  |delete_array_align_nothrow|
+// +-----------------------+  +--------------------------+
+
+void __CRTDECL operator delete[](void* const block, std::align_val_t const al) noexcept
+{
+    operator delete(block, al);
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/delete_array_align_nothrow.cpp

@@ -0,0 +1,31 @@
+//
+// delete_array_align_nothrow.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the array operator delete, align_val_t and nothrow_t overload.
+//
+#include <vcruntime_internal.h>
+#include <vcruntime_new.h>
+
+//////////////////////////////////////////////////////////////////////////////////
+// Aligned delete() Fallback Ordering
+//
+// +-------------------+
+// |delete_scalar_align<----+---------------------------+
+// +--^----------------+    |                           |
+//    |                     |                           |
+// +--+---------------+  +--+---------------------+  +--+------------------------+
+// |delete_array_align|  |delete_scalar_size_align|  |delete_scalar_align_nothrow|
+// +--^-----^---------+  +------------------------+  +---------------------------+
+//    |     |
+//    |     +------------------------+
+//    |                              |
+// +--+--------------------+  +------+-------------------+
+// |delete_array_size_align|  |delete_array_align_nothrow|
+// +-----------------------+  +--------------------------+
+
+void __CRTDECL operator delete[](void* const block, std::align_val_t const al, std::nothrow_t const&) noexcept
+{
+    operator delete[](block, al);
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/delete_array_nothrow.cpp

@@ -0,0 +1,31 @@
+//
+// delete_array_nothrow.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the array operator delete, nothrow_t overload.
+//
+#include <vcruntime_internal.h>
+#include <vcruntime_new.h>
+
+////////////////////////////////////////////////////////////////
+// delete() Fallback Ordering
+//
+// +-------------+
+// |delete_scalar<----+-----------------------+
+// +--^----------+    |                       |
+//    |               |                       |
+// +--+---------+  +--+---------------+  +----+----------------+
+// |delete_array|  |delete_scalar_size|  |delete_scalar_nothrow|
+// +--^----^----+  +------------------+  +---------------------+
+//    |    |
+//    |    +-------------------+
+//    |                        |
+// +--+--------------+  +------+-------------+
+// |delete_array_size|  |delete_array_nothrow|
+// +-----------------+  +--------------------+
+
+void __CRTDECL operator delete[](void* const block, std::nothrow_t const&) noexcept
+{
+    operator delete[](block);
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/delete_array_size.cpp

@@ -0,0 +1,32 @@
+//
+// delete_array_size.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the array operator delete, size_t overload.
+//
+#include <vcruntime_internal.h>
+#include <vcruntime_new.h>
+
+////////////////////////////////////////////////////////////////
+// delete() Fallback Ordering
+//
+// +-------------+
+// |delete_scalar<----+-----------------------+
+// +--^----------+    |                       |
+//    |               |                       |
+// +--+---------+  +--+---------------+  +----+----------------+
+// |delete_array|  |delete_scalar_size|  |delete_scalar_nothrow|
+// +--^----^----+  +------------------+  +---------------------+
+//    |    |
+//    |    +-------------------+
+//    |                        |
+// +--+--------------+  +------+-------------+
+// |delete_array_size|  |delete_array_nothrow|
+// +-----------------+  +--------------------+
+
+_CRT_SECURITYCRITICAL_ATTRIBUTE
+void __CRTDECL operator delete[](void* const block, size_t const) noexcept
+{
+    operator delete[](block);
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/delete_array_size_align.cpp

@@ -0,0 +1,31 @@
+//
+// delete_array_size_align.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the array operator delete, size_t and align_val_t overload.
+//
+#include <vcruntime_internal.h>
+#include <vcruntime_new.h>
+
+//////////////////////////////////////////////////////////////////////////////////
+// Aligned delete() Fallback Ordering
+//
+// +-------------------+
+// |delete_scalar_align<----+---------------------------+
+// +--^----------------+    |                           |
+//    |                     |                           |
+// +--+---------------+  +--+---------------------+  +--+------------------------+
+// |delete_array_align|  |delete_scalar_size_align|  |delete_scalar_align_nothrow|
+// +--^-----^---------+  +------------------------+  +---------------------------+
+//    |     |
+//    |     +------------------------+
+//    |                              |
+// +--+--------------------+  +------+-------------------+
+// |delete_array_size_align|  |delete_array_align_nothrow|
+// +-----------------------+  +--------------------------+
+
+void __CRTDECL operator delete[](void* const block, size_t const, std::align_val_t const al) noexcept
+{
+    operator delete[](block, al);
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/delete_debug.cpp

@@ -0,0 +1,72 @@
+//
+// delete_debug.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the debug operator delete (both scalar and array forms).
+//
+#include <vcruntime_internal.h>
+#include <vcruntime_new.h>
+
+
+
+#ifdef _DEBUG
+
+    _CRT_SECURITYCRITICAL_ATTRIBUTE
+    void __CRTDECL operator delete(
+        void*       block,
+        int const   block_use,
+        char const* file_name,
+        int const   line_number
+        ) noexcept
+    {
+        UNREFERENCED_PARAMETER(file_name);
+        UNREFERENCED_PARAMETER(line_number);
+
+        _free_dbg(block, block_use);
+    }
+
+    _CRT_SECURITYCRITICAL_ATTRIBUTE
+    void __CRTDECL operator delete[](
+        void*       block,
+        int const   block_use,
+        char const* file_name,
+        int const   line_number
+        ) noexcept
+    {
+        return operator delete(block, block_use, file_name, line_number);
+    }
+
+#else // ^^^ _DEBUG ^^^ // vvv !_DEBUG vvv //
+
+    _CRT_SECURITYCRITICAL_ATTRIBUTE
+    void __CRTDECL operator delete(
+        void*       block,
+        int const   block_use,
+        char const* file_name,
+        int const   line_number
+        ) noexcept
+    {
+        UNREFERENCED_PARAMETER(block_use);
+        UNREFERENCED_PARAMETER(file_name);
+        UNREFERENCED_PARAMETER(line_number);
+
+        return operator delete(block);
+    }
+
+    _CRT_SECURITYCRITICAL_ATTRIBUTE
+    void __CRTDECL operator delete[](
+        void*       block,
+        int const   block_use,
+        char const* file_name,
+        int const   line_number
+        ) noexcept
+    {
+        UNREFERENCED_PARAMETER(block_use);
+        UNREFERENCED_PARAMETER(file_name);
+        UNREFERENCED_PARAMETER(line_number);
+
+        return operator delete[](block);
+    }
+
+#endif

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/delete_scalar.cpp

@@ -0,0 +1,38 @@
+//
+// delete_scalar.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the scalar operator delete.
+//
+#include <crtdbg.h>
+#include <malloc.h>
+#include <vcruntime_new.h>
+#include <vcstartup_internal.h>
+
+////////////////////////////////////////////////////////////////
+// delete() Fallback Ordering
+//
+// +-------------+
+// |delete_scalar<----+-----------------------+
+// +--^----------+    |                       |
+//    |               |                       |
+// +--+---------+  +--+---------------+  +----+----------------+
+// |delete_array|  |delete_scalar_size|  |delete_scalar_nothrow|
+// +--^----^----+  +------------------+  +---------------------+
+//    |    |
+//    |    +-------------------+
+//    |                        |
+// +--+--------------+  +------+-------------+
+// |delete_array_size|  |delete_array_nothrow|
+// +-----------------+  +--------------------+
+
+_CRT_SECURITYCRITICAL_ATTRIBUTE
+void __CRTDECL operator delete(void* const block) noexcept
+{
+    #ifdef _DEBUG
+    _free_dbg(block, _UNKNOWN_BLOCK);
+    #else
+    free(block);
+    #endif
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/delete_scalar_align.cpp

@@ -0,0 +1,33 @@
+//
+// delete_scalar_align.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the scalar operator delete, align_val_t overload.
+//
+#include <malloc.h>
+#include <vcruntime_new.h>
+#include <vcstartup_internal.h>
+
+//////////////////////////////////////////////////////////////////////////////////
+// Aligned delete() Fallback Ordering
+//
+// +-------------------+
+// |delete_scalar_align<----+---------------------------+
+// +--^----------------+    |                           |
+//    |                     |                           |
+// +--+---------------+  +--+---------------------+  +--+------------------------+
+// |delete_array_align|  |delete_scalar_size_align|  |delete_scalar_align_nothrow|
+// +--^-----^---------+  +------------------------+  +---------------------------+
+//    |     |
+//    |     +------------------------+
+//    |                              |
+// +--+--------------------+  +------+-------------------+
+// |delete_array_size_align|  |delete_array_align_nothrow|
+// +-----------------------+  +--------------------------+
+
+_CRT_SECURITYCRITICAL_ATTRIBUTE
+void __CRTDECL operator delete(void* const block, std::align_val_t const) noexcept
+{
+    _aligned_free(block);
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/delete_scalar_align_nothrow.cpp

@@ -0,0 +1,31 @@
+//
+// delete_scalar_align_nothrow.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the scalar operator delete, align_val_t and nothrow_t overload.
+//
+#include <vcruntime_internal.h>
+#include <vcruntime_new.h>
+
+//////////////////////////////////////////////////////////////////////////////////
+// Aligned delete() Fallback Ordering
+//
+// +-------------------+
+// |delete_scalar_align<----+---------------------------+
+// +--^----------------+    |                           |
+//    |                     |                           |
+// +--+---------------+  +--+---------------------+  +--+------------------------+
+// |delete_array_align|  |delete_scalar_size_align|  |delete_scalar_align_nothrow|
+// +--^-----^---------+  +------------------------+  +---------------------------+
+//    |     |
+//    |     +------------------------+
+//    |                              |
+// +--+--------------------+  +------+-------------------+
+// |delete_array_size_align|  |delete_array_align_nothrow|
+// +-----------------------+  +--------------------------+
+
+void __CRTDECL operator delete(void* const block, std::align_val_t const al, std::nothrow_t const&) noexcept
+{
+    operator delete(block, al);
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/delete_scalar_nothrow.cpp

@@ -0,0 +1,31 @@
+//
+// delete_scalar_nothrow.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the scalar operator delete, nothrow_t overload.
+//
+#include <vcruntime_internal.h>
+#include <vcruntime_new.h>
+
+////////////////////////////////////////////////////////////////
+// delete() Fallback Ordering
+//
+// +-------------+
+// |delete_scalar<----+-----------------------+
+// +--^----------+    |                       |
+//    |               |                       |
+// +--+---------+  +--+---------------+  +----+----------------+
+// |delete_array|  |delete_scalar_size|  |delete_scalar_nothrow|
+// +--^----^----+  +------------------+  +---------------------+
+//    |    |
+//    |    +-------------------+
+//    |                        |
+// +--+--------------+  +------+-------------+
+// |delete_array_size|  |delete_array_nothrow|
+// +-----------------+  +--------------------+
+
+void __CRTDECL operator delete(void* const block, std::nothrow_t const&) noexcept
+{
+    operator delete(block);
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/delete_scalar_size.cpp

@@ -0,0 +1,32 @@
+//
+// delete_scalar_size.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the scalar operator delete, size_t overload.
+//
+#include <vcruntime_internal.h>
+#include <vcruntime_new.h>
+
+////////////////////////////////////////////////////////////////
+// delete() Fallback Ordering
+//
+// +-------------+
+// |delete_scalar<----+-----------------------+
+// +--^----------+    |                       |
+//    |               |                       |
+// +--+---------+  +--+---------------+  +----+----------------+
+// |delete_array|  |delete_scalar_size|  |delete_scalar_nothrow|
+// +--^----^----+  +------------------+  +---------------------+
+//    |    |
+//    |    +-------------------+
+//    |                        |
+// +--+--------------+  +------+-------------+
+// |delete_array_size|  |delete_array_nothrow|
+// +-----------------+  +--------------------+
+
+_CRT_SECURITYCRITICAL_ATTRIBUTE
+void __CRTDECL operator delete(void* const block, size_t const) noexcept
+{
+    operator delete(block);
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/delete_scalar_size_align.cpp

@@ -0,0 +1,31 @@
+//
+// delete_scalar_size_align.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the scalar operator delete, size_t and align_val_t overload.
+//
+#include <vcruntime_internal.h>
+#include <vcruntime_new.h>
+
+//////////////////////////////////////////////////////////////////////////////////
+// Aligned delete() Fallback Ordering
+//
+// +-------------------+
+// |delete_scalar_align<----+---------------------------+
+// +--^----------------+    |                           |
+//    |                     |                           |
+// +--+---------------+  +--+---------------------+  +--+------------------------+
+// |delete_array_align|  |delete_scalar_size_align|  |delete_scalar_align_nothrow|
+// +--^-----^---------+  +------------------------+  +---------------------------+
+//    |     |
+//    |     +------------------------+
+//    |                              |
+// +--+--------------------+  +------+-------------------+
+// |delete_array_size_align|  |delete_array_align_nothrow|
+// +-----------------------+  +--------------------------+
+
+void __CRTDECL operator delete(void* const block, size_t const, std::align_val_t const al) noexcept
+{
+    operator delete(block, al);
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/denormal_control.cpp

@@ -0,0 +1,16 @@
+//
+// denormal_control.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Initializes the denormal mode to the default state.  This behavior is
+// overridable at link-time by linking with one of the link options.
+//
+#include <vcruntime.h>
+
+
+
+extern "C" void __CRTDECL _initialize_denormal_control()
+{
+    // No-op
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/dll_dllmain.cpp

@@ -0,0 +1,335 @@
+//
+// dll_dllmain.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The DLL entry point that initializes the DLL and calls the client-defined
+// DllMain entry point.
+//
+#include <vcstartup_internal.h>
+#include <vcruntime_internal.h>
+#include <rtcapi.h>
+
+
+
+// The client may define a _pRawDllMain.  This function gets called for attach
+// notifications before any other function is called, and gets called for detach
+// notifications after any other function is called.  If no _pRawDllMain is
+// defined, it is aliased to the no-op _pDefaultRawDllMain.
+extern "C" extern __scrt_dllmain_type const _pRawDllMain;
+extern "C" extern __scrt_dllmain_type const _pDefaultRawDllMain = nullptr;
+_VCRT_DECLARE_ALTERNATE_NAME_DATA(_pRawDllMain, _pDefaultRawDllMain)
+
+
+
+// This flag is incremented each time DLL_PROCESS_ATTACH is processed successfully
+// and is decremented each time DLL_PROCESS_DETACH is processed (the detach is
+// always assumed to complete successfully).
+static int __proc_attached = 0;
+
+
+
+static BOOL __cdecl dllmain_crt_process_attach(HMODULE const instance,
+    LPVOID const reserved)
+{
+    if (!__scrt_initialize_crt(__scrt_module_type::dll))
+        return FALSE;
+
+    bool const is_nested = __scrt_acquire_startup_lock();
+    bool fail = true;
+    __try
+    {
+        if (__scrt_current_native_startup_state != __scrt_native_startup_state::uninitialized)
+            __scrt_fastfail(FAST_FAIL_FATAL_APP_EXIT);
+
+        __scrt_current_native_startup_state = __scrt_native_startup_state::initializing;
+
+        if (!__scrt_dllmain_before_initialize_c())
+            __leave;
+
+        #ifdef _RTC
+        _RTC_Initialize();
+        #endif
+
+        __scrt_initialize_type_info();
+
+        __scrt_initialize_default_local_stdio_options();
+
+        if (_initterm_e(__xi_a, __xi_z) != 0)
+            __leave;
+
+        if (!__scrt_dllmain_after_initialize_c())
+            __leave;
+
+        _initterm(__xc_a, __xc_z);
+
+        __scrt_current_native_startup_state = __scrt_native_startup_state::initialized;
+        fail = false;
+    }
+    __finally
+    {
+        __scrt_release_startup_lock(is_nested);
+    }
+    if (fail)
+        return FALSE;
+
+    // If we have any dynamically initialized __declspec(thread) variables, we
+    // invoke their initialization for the thread on which the DLL is being
+    // loaded.  We cannot rely on the OS performing the initialization with the
+    // DLL_PROCESS_ATTACH notification because, on Windows Server 2003 and below,
+    // that call happens before the CRT is initialized.
+    PIMAGE_TLS_CALLBACK const* const tls_init_callback = __scrt_get_dyn_tls_init_callback();
+    if (*tls_init_callback != nullptr && __scrt_is_nonwritable_in_current_image(tls_init_callback))
+    {
+        (*tls_init_callback)(instance, DLL_THREAD_ATTACH, reserved);
+    }
+
+    ++__proc_attached;
+    return TRUE;
+}
+
+// clang-format off
+//
+// DLL Uninitialization of the CRT
+//
+// +----------------------+
+// | UserEXE!main returns |
+// +--------+-------------+
+//          |
+// +--------v-----------------------+
+// | ExitProcess/LdrShutdownProcess |
+// +--------+-----------------------+
+//          |
+// +--------v--------+
+// | UserDLL!DLLMain |
+// +--------+--------+
+//          |
+// +--------v----------------------------------------------+
+// | UserDLL!dllmain_crt_process_detach                    |        +-----------------------------+
+// |                                              +-----------------> UCRT _cexit()               |
+// |  + Startup Lock +-------------------+        |        |        |                             |
+// |  |                                  |        |        |        | Run onexit table            |
+// |  |  __scrt_dllmain_uninitialize_c() |        |        |        | Run XP* and XT* terminators |
+// |  |   /MD: Run onexit table          |        |        |        |                             |
+// |  |   /MT: _cexit() +-------------------------+        |        +-----------------------------+
+// |  |                                  |                 |
+// |  |                                  |                 |        +---------------------------------------------+
+// |  |  __scrt_uninitialize_type_info() |                 |    +---> UCRT Uninitializer Order                    |
+// |  |                                  |                 |    |   | (__acrt_uninitialize)                       |
+// |  |  _RTC_Terminate()                |                 |    |   |                                             |
+// |  |   Run RTC terminators            |                 |    |   | Release when terminating:                   |
+// |  |                                  |                 |    |   |  _flushall()                                |
+// |  +----------------------------------+                 |    |   |                                             |
+// |                                                       |    |   | Debug (always), Release unless terminating: |
+// |  __scrt_uninitialize_crt()                            |    |   |  uninitialize_c()                           |
+// |   /MT: __acrt_uninitialize() + __vcrt_uninitialize() +-----+   |  uninitialize_environment()                 |
+// |   /MD: no-op (handled by UCRT/VCRuntime DLL unload)   |    |   |  uninitialize_allocated_memory()            |
+// |                                                       |    |   |  uninitialize_allocated_io_buffers()        |
+// |  + __finally +--------------------------------------+ |    |   |  report_memory_leaks()                      |
+// |  |                                                  | |    |   |  __acrt_uninitialize_command_line()         |
+// |  | __scrt_dllmain_uninitialize_critical()           | |    |   |  __acrt_uninitialize_lowio()                |
+// |  |  /MT: __acrt_uninitialize_ptd() +----------------------------->__acrt_uninitialize_ptd()                  |
+// |  |       __vcrt_uninitialize_ptd() +--------------------+  |   |  uninitialize_vcruntime() (the OS one)      |
+// |  |  /MD: no-op                                      | | |  |   |  __acrt_uninitialize_heap()                 |
+// |  |       (handled by UCRT/VCRuntime DLL unload)     | | |  |   |  __acrt_uninitialize_locks()                |
+// |  |                                                  | | |  |   |  uninitialize_global_state_isolation()      |
+// |  | Ensures PTD is released on error                 | | |  |   |                                             |
+// |  | so FLS callbacks don't refer to unloaded module  | | |  |   +---------------------------------------------+
+// |  |                                                  | | |  |
+// |  +--------------------------------------------------+ | |  |   +--------------------------------------+
+// |                                                       | |  +---> VCRuntime Uninitializer Order        |
+// +-------------------------------------------------------+ |      | (__vcrt_uninitialize)                |
+//                                                           |      |                                      |
+// +---------------------------------+                       |      | Debug unless terminating:            |
+// | /MD Only                        |                       +-------->__vcrt_uninitialize_ptd()           |
+// |                                 |                              |  __vcrt_uninitialize_locks()         |
+// |  ucrtbase(d)!__acrt_DllMain     |                              |  __vcrt_uninitialize_winapi_thunks() |
+// |   __acrt_uninitialize()         |                              |                                      |
+// |                                 |                              +--------------------------------------+
+// |                                 |
+// |  vcruntime140(d)!__vcrt_DllMain |
+// |   __vcrt_uninitialize()         |
+// |                                 |
+// +---------------------------------+
+//
+// clang-format on
+
+static BOOL __cdecl dllmain_crt_process_detach(bool const is_terminating)
+{
+    // If the attach did not complete successfully, or if the detach was already
+    // executed, do not execute the detach:
+    if (__proc_attached <= 0)
+    {
+        return FALSE;
+    }
+
+    --__proc_attached;
+
+    BOOL result = TRUE;
+
+    __try
+    {
+        bool const is_nested = __scrt_acquire_startup_lock();
+        __try
+        {
+            if (__scrt_current_native_startup_state != __scrt_native_startup_state::initialized)
+            {
+                __scrt_fastfail(FAST_FAIL_FATAL_APP_EXIT);
+            }
+
+            __scrt_dllmain_uninitialize_c();
+
+            __scrt_uninitialize_type_info();
+
+            #ifdef _RTC
+            _RTC_Terminate();
+            #endif
+
+            __scrt_current_native_startup_state = __scrt_native_startup_state::uninitialized;
+        }
+        __finally
+        {
+            __scrt_release_startup_lock(is_nested);
+        }
+
+        if (!__scrt_uninitialize_crt(is_terminating, false))
+        {
+            result = FALSE;
+            __leave;
+        }
+    }
+    __finally
+    {
+        __scrt_dllmain_uninitialize_critical();
+    }
+
+    return result;
+}
+
+
+
+static BOOL WINAPI dllmain_crt_dispatch(
+    HINSTANCE const instance,
+    DWORD     const reason,
+    LPVOID    const reserved
+    )
+{
+    switch (reason)
+    {
+    case DLL_PROCESS_ATTACH: return dllmain_crt_process_attach(instance, reserved);
+    case DLL_PROCESS_DETACH: return dllmain_crt_process_detach(reserved != nullptr);
+    case DLL_THREAD_ATTACH:  return __scrt_dllmain_crt_thread_attach();
+    case DLL_THREAD_DETACH:  return __scrt_dllmain_crt_thread_detach();
+    }
+
+    return TRUE;
+}
+
+// Define the _CRT_INIT function for compatibility.
+extern "C" BOOL WINAPI _CRT_INIT(
+    HINSTANCE const instance,
+    DWORD     const reason,
+    LPVOID    const reserved
+    )
+{
+    return dllmain_crt_dispatch(instance, reason, reserved);
+}
+
+static BOOL WINAPI dllmain_raw(
+    HINSTANCE const instance,
+    DWORD     const reason,
+    LPVOID    const reserved
+    )
+{
+    if (!_pRawDllMain)
+        return TRUE;
+
+    return _pRawDllMain(instance, reason, reserved);
+}
+
+
+
+static BOOL __cdecl dllmain_dispatch(
+    HINSTANCE const instance,
+    DWORD     const reason,
+    LPVOID    const reserved
+    )
+{
+    // If this is a process detach notification, check that there was a prior
+    // process attach notification that was processed successfully.  This is
+    // to ensure that we don't detach more times than we attach.
+    if (reason == DLL_PROCESS_DETACH && __proc_attached <= 0)
+    {
+        return FALSE;
+    }
+
+    BOOL result = TRUE;
+
+    __try
+    {
+        if (reason == DLL_PROCESS_ATTACH || reason == DLL_THREAD_ATTACH)
+        {
+            result = dllmain_raw(instance, reason, reserved);
+            if (!result)
+                __leave;
+
+            result = dllmain_crt_dispatch(instance, reason, reserved);
+            if (!result)
+                __leave;
+        }
+
+        result = DllMain(instance, reason, reserved);
+
+        // If the client DllMain routine failed, unwind the initialization:
+        if (reason == DLL_PROCESS_ATTACH && !result)
+        {
+            DllMain(instance, DLL_PROCESS_DETACH, reserved);
+            dllmain_crt_dispatch(instance, DLL_PROCESS_DETACH, reserved);
+            dllmain_raw(instance, DLL_PROCESS_DETACH, reserved);
+        }
+
+        if (reason == DLL_PROCESS_DETACH || reason == DLL_THREAD_DETACH)
+        {
+            result = dllmain_crt_dispatch(instance, reason, reserved);
+            if (!result)
+                __leave;
+
+            result = dllmain_raw(instance, reason, reserved);
+            if (!result)
+                __leave;
+        }
+    }
+    __except(__scrt_dllmain_exception_filter(
+        instance,
+        reason,
+        reserved,
+        dllmain_crt_dispatch,
+        GetExceptionCode(),
+        GetExceptionInformation()))
+    {
+        result = FALSE;
+    }
+
+    return result;
+}
+
+
+
+// The entry point for this DLL.
+extern "C" BOOL WINAPI _DllMainCRTStartup(
+    HINSTANCE const instance,
+    DWORD     const reason,
+    LPVOID    const reserved
+    )
+{
+    if (reason == DLL_PROCESS_ATTACH)
+    {
+        // The /GS security cookie must be initialized before any exception
+        // handling targeting the current image is registered.  No function
+        // using exception handling can be called in the current image until
+        // after this call:
+        __security_init_cookie();
+    }
+
+    return dllmain_dispatch(instance, reason, reserved);
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/dll_dllmain_stub.cpp

@@ -0,0 +1,38 @@
+//
+// dll_dllmain_stub.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// A DllMain to be used if the client does not define one.
+//
+#include <vcstartup_internal.h>
+
+
+
+extern "C" extern __scrt_dllmain_type const _pRawDllMain;
+
+
+
+extern "C" BOOL WINAPI DllMain(
+    _In_ HINSTANCE const instance,
+    _In_ DWORD     const reason,
+    _In_ LPVOID    const reserved
+    )
+{
+    UNREFERENCED_PARAMETER(instance);
+    UNREFERENCED_PARAMETER(reason);
+    UNREFERENCED_PARAMETER(reserved);
+
+    // When the dynamic CRT libraries are used, the client DLL does not need the
+    // thread attach and detach notifications if the client does not provide a
+    // DllMain or _pRawDllMain, so we can disable them.  (When the static CRT
+    // libraries are used, the CRT's DllMain that is linked into the DLL requires
+    // these notifications.)
+    // Enclaves do not support this performance optimization API.
+    #if defined CRTDLL && !defined _SCRT_ENCLAVE_BUILD
+    if (reason == DLL_PROCESS_ATTACH && !_pRawDllMain)
+        DisableThreadLibraryCalls(instance);
+    #endif
+
+    return TRUE;
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/dyn_tls_init.c

@@ -0,0 +1,21 @@
+//
+// dyn_tls_init.c
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// This source file provides a fallback definition of __dyn_tls_init_callback,
+// used whenever TLS initialization is not required.
+//
+// This relies on a feature of the C compiler known as "communal variables."
+// This does not work in C++, and the linker's alternatename features is not
+// sufficient here.
+//
+#include <Windows.h>
+
+#pragma warning(disable: 4132) // const object should be initialized
+const PIMAGE_TLS_CALLBACK __dyn_tls_init_callback;
+
+PIMAGE_TLS_CALLBACK const* __cdecl __scrt_get_dyn_tls_init_callback()
+{
+    return &__dyn_tls_init_callback;
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/ehhelpers.cpp

@@ -0,0 +1,333 @@
+/***
+*ehhelpers.cpp - Some target-independent helper routines used by the EH frame handler.
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+****/
+
+#include <eh.h>         // User-visible routines for eh
+#include <ehassert.h>   // This project's versions of standard assert macros
+#include <ehdata.h>     // Declarations of all types used for EH
+#include <ehdata4.h>
+#include <ehhooks.h>    // Declarations of hook variables and callbacks
+#include <trnsctrl.h>   // Routines to handle transfer of control (trnsctrl.asm)
+#include <vcruntime_exception.h>
+#include <vcruntime_typeinfo.h>
+
+#include <Unknwn.h>
+#include <Windows.h>
+
+#include "ehhelpers.h"
+
+// If we call DestructExceptionObject directly from C_Specific_Handler/
+// _except_handler3, then this obj file will be pulled in by the linker
+// even in programs which do not have C++ exceptions. So we call it using a
+// function pointer _pDestructExceptionObject which gets initialized to 0 by
+// default. If C++ exceptions are present, this file will be pulled in naturally
+// and _pDestructExceptionObject will point to __DestructExceptionObject.
+
+extern "C" void (__cdecl * const _pDestructExceptionObject)(EHExceptionRecord *,BOOLEAN)
+    = &__DestructExceptionObject;
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// __AdjustPointer - Adjust the pointer to the exception object to a pointer to a
+//   base instance.
+//
+// Output:
+//     The address point of the base.
+//
+// Side-effects:
+//     NONE.
+
+extern "C" _VCRTIMP void *__AdjustPointer(
+    void *pThis,                        // Address point of exception object
+    const PMD& pmd                      // Generalized pointer-to-member
+                                        //   descriptor
+) {
+    char *pRet = (char *)pThis + pmd.mdisp;
+
+    if (pmd.pdisp >= 0) {
+        pRet += *(__int32 *)((char *)*(ptrdiff_t *)((char *)pThis + pmd.pdisp)
+#if defined(_WIN64)
+           + (unsigned __int64)pmd.vdisp
+#else
+           + pmd.vdisp
+#endif
+           );
+        pRet += pmd.pdisp;
+    }
+
+    return pRet;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// __GetPlatformExceptionInfo - Get Platform Exception extra information from current exception
+//
+// Output:
+//     The address of WINRTEXCEPTIONINFO structure
+//
+// Side-effects:
+//     NONE.
+extern "C" _VCRTIMP void * __GetPlatformExceptionInfo(
+    int *pIsBadAlloc
+) {
+    *pIsBadAlloc = 0;
+    EHExceptionRecord *pExcept = _pCurrentException;
+    if (pExcept)
+    {
+        ThrowInfo* pTI = PER_PTHROW(pExcept);
+        if (pTI)
+        {
+            if (THROW_ISWINRT( (*pTI) ) )
+            {
+                ULONG_PTR *exceptionInfoPointer = *reinterpret_cast<ULONG_PTR**>(PER_PEXCEPTOBJ(pExcept));
+                exceptionInfoPointer--;
+                return reinterpret_cast<void*>(*exceptionInfoPointer);
+            }
+            else
+            {
+                _EXCEPTION_POINTERS exceptionPointers;
+                exceptionPointers.ExceptionRecord = reinterpret_cast<PEXCEPTION_RECORD>(pExcept);
+                exceptionPointers.ContextRecord = nullptr;
+
+                *pIsBadAlloc = _is_exception_typeof(typeid(std::bad_alloc), &exceptionPointers);
+            }
+        }
+    }
+
+    return nullptr;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// __current_exception(), __current_exception_context(), __processing_throw()
+//                        - Accessors for the per-thread exception state, used
+//                          by the managed EH implementation, exception_ptr, etc.
+//
+
+// Don't define these "locally" for satellite DLL build, the satellite
+// needs to call these from the base vcruntime to infer the location of the PTD
+#if !defined _VCRT_SAT_1
+extern "C" void** __cdecl __current_exception()
+{
+    return &RENAME_BASE_PTD(__vcrt_getptd)()->_curexception;
+}
+
+extern "C" void** __cdecl __current_exception_context()
+{
+    return &RENAME_BASE_PTD(__vcrt_getptd)()->_curcontext;
+}
+
+extern "C" int* __cdecl __processing_throw()
+{
+    return &RENAME_BASE_PTD(__vcrt_getptd)()->_ProcessingThrow;
+}
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// __FrameUnwindFilter - Allows possibility of continuing through SEH during
+//   unwind.
+//
+
+extern "C" _VCRTIMP int __cdecl __FrameUnwindFilter(
+    EXCEPTION_POINTERS *pExPtrs
+) {
+    EHExceptionRecord *pExcept = (EHExceptionRecord *)pExPtrs->ExceptionRecord;
+
+    switch (PER_CODE(pExcept)) {
+    case EH_EXCEPTION_NUMBER:
+        _pCurrentException = pExcept;
+        _pCurrentExContext = pExPtrs->ContextRecord;
+        terminate();
+
+    case MANAGED_EXCEPTION_CODE:
+    case MANAGED_EXCEPTION_CODE_V4:
+        /*
+         See VSW#544593 for more details. __ProcessingThrow is used to implement
+         std::uncaught_exception(). The interaction between C++, SEH and managed
+         exception wrt __ProcessingThrow is unspec'ed. From code inspection, it
+         looks like that __ProcessingThrow works ok with all C++ exceptions.
+
+         In this case, when we encounter a managed exception thrown from a destructor
+         during unwind, we choose to decrement the count. This means that the previous
+         C++ exception which incremented the count won't be considered any longer.
+         In fact, the managed exception will be thrown, and the native C++ one will
+         not have any possibility to be caught any longer.
+
+         We should revisit std::uncaught_exception() and SEH/managed exception in the
+         next version.
+         */
+        if (__ProcessingThrow > 0)
+        {
+            --__ProcessingThrow;
+        }
+        return EXCEPTION_CONTINUE_SEARCH;
+
+    default:
+        return EXCEPTION_CONTINUE_SEARCH;
+    }
+}
+
+
+PGETWINRT_OOM_EXCEPTION __WinRTOutOfMemoryExceptionCallback = nullptr;
+
+extern "C" _VCRTIMP void __cdecl _SetWinRTOutOfMemoryExceptionCallback(PGETWINRT_OOM_EXCEPTION pCallback)
+{
+    __WinRTOutOfMemoryExceptionCallback = pCallback;
+}
+
+//////////////////////////////////////////////////////////////////////////////////
+// __std_terminate: Helper function referenced by the front-end to assist in
+// implementing noexcept. Noexcept termination semantics are generally handled
+// by FindHandler() above, when we cross a function with the noexcept bit set
+// in the xdata when looking for a handler. When noexcept functions are inlined,
+// though, we may no longer cross a noexcept function boundary when searching for
+// a handler. In this case the inlined code contains an EH state that will invoke
+// this function should an exception occur.
+extern "C" __declspec(noreturn) void __cdecl __std_terminate()
+{
+    terminate();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// __DestructExceptionObject - Call the destructor (if any) of the original
+//   exception object.
+//
+// Returns: None.
+//
+// Side-effects:
+//     Original exception object is destructed.
+//
+// Notes:
+//     If destruction throws any exception, and we are destructing the exception
+//       object as a result of a new exception, we give up.  If the destruction
+//       throws otherwise, we let it be.
+
+static DWORD _FilterSetCurrentException(EXCEPTION_POINTERS* pointers, BOOLEAN fThrowNotAllowed)
+{
+    if (fThrowNotAllowed) {
+        const auto eRecord = reinterpret_cast<EHExceptionRecord*>(pointers->ExceptionRecord);
+        if (PER_IS_MSVC_EH(eRecord))
+        {
+            // Can't have new exceptions when we're unwinding due to another
+            // exception.
+            _pCurrentException = eRecord;
+            _pCurrentExContext = pointers->ContextRecord;
+            terminate();
+        }
+    }
+
+    return EXCEPTION_CONTINUE_SEARCH;
+}
+
+extern "C" _VCRTIMP void __cdecl __DestructExceptionObject(
+    EHExceptionRecord *pExcept,         // The original exception record
+    BOOLEAN fThrowNotAllowed            // TRUE if destructor not allowed to
+                                        //   throw
+) {
+    // Ignore if not a C++ exception (since this is now called from
+    // _except_handler3)
+    if (pExcept == nullptr || !(PER_IS_MSVC_EH(pExcept)))
+    {
+        return;
+    }
+
+    EHTRACE_FMT1("Destroying object @ 0x%p", PER_PEXCEPTOBJ(pExcept));
+
+    /*UNDONE:Is this _SYSCRT specific */
+#pragma prefast(suppress:__WARNING_REDUNDANT_POINTER_TEST, "Current definition of PER_CODE ensures that pExcept cannot be nullptr")
+    if (PER_PTHROW(pExcept))  {
+        if (THROW_UNWINDFUNC(*PER_PTHROW(pExcept)) != 0) {
+
+            __try {
+
+#if _EH_RELATIVE_TYPEINFO
+                _CallMemberFunction0(PER_PEXCEPTOBJ(pExcept),
+                    THROW_UNWINDFUNC_IB(*PER_PTHROW(pExcept),(ptrdiff_t)PER_PTHROWIB(pExcept)));
+#else
+                _CallMemberFunction0(PER_PEXCEPTOBJ(pExcept),
+                    THROW_UNWINDFUNC(*PER_PTHROW(pExcept)));
+#endif
+
+            } __except(_FilterSetCurrentException(GetExceptionInformation(), fThrowNotAllowed)) {}
+        }
+        else if (THROW_ISWINRT(*PER_PTHROW(pExcept))) {
+            // Release if WinRT reference type exception
+            IUnknown* const pUnknown = *static_cast<IUnknown**>(PER_PEXCEPTOBJ(pExcept));
+            if (pUnknown) {
+                pUnknown->Release();
+            }
+        }
+    }
+}
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// _IsExceptionObjectToBeDestroyed - Determine if an exception object is still
+//  in use by a more deeply nested catch frame, or if it unused and should be
+//  destroyed on exiting from the current catch block.
+//
+// Returns:
+//      TRUE if exception object not found and should be destroyed.
+//
+extern "C" BOOL __cdecl _IsExceptionObjectToBeDestroyed(
+    PVOID pExceptionObject
+) {
+    FRAMEINFO * pFrameInfo;
+
+    for (pFrameInfo = pFrameInfoChain; pFrameInfo; pFrameInfo = pFrameInfo->pNext ) {
+        if (pFrameInfo->pExceptionObject == pExceptionObject) {
+            return FALSE;
+        }
+    }
+    return TRUE;
+}
+
+//////////////////////////////////////////////////////////////////////////////////
+// _is_exception_typeof - checks if the thrown exception is the type, the caller
+// has passed in.
+//
+extern "C" _VCRTIMP int __cdecl _is_exception_typeof(_In_ const type_info & type, _In_ struct _EXCEPTION_POINTERS * ep)
+{
+    _VCRT_VERIFY(ep);
+
+    EHExceptionRecord *pExcept = (EHExceptionRecord *)ep->ExceptionRecord;
+
+    // Is this our Exception?
+    _VCRT_VERIFY(pExcept && PER_IS_MSVC_EH(pExcept));
+
+#if _EH_RELATIVE_TYPEINFO
+    __int32 const *ppCatchable;
+    ptrdiff_t imgBase = (ptrdiff_t)pExcept->params.pThrowImageBase;
+    ppCatchable = THROW_CTLIST_IB(*PER_PTHROW(pExcept), imgBase );
+    int catchables = THROW_COUNT_IB(*PER_PTHROW(pExcept), imgBase );
+#else
+    CatchableType * const *ppCatchable;
+    ppCatchable = THROW_CTLIST(*PER_PTHROW(pExcept));
+    int catchables = THROW_COUNT(*PER_PTHROW(pExcept));
+#endif
+
+    CatchableType *pCatchable;
+
+    // Scan all types that thrown object can be converted to.
+    for (; catchables > 0; catchables--, ppCatchable++)
+    {
+#if _EH_RELATIVE_TYPEINFO
+        pCatchable = (CatchableType *)(imgBase + *ppCatchable);
+        if(strcmp(type.raw_name(), CT_NAME_IB(*pCatchable, imgBase)) == 0)
+#else
+        pCatchable = *ppCatchable;
+        if(strcmp(type.raw_name(), CT_NAME(*pCatchable)) == 0)
+#endif
+        {
+            // Found a Match.
+            return 1;
+        }
+    }
+
+    return 0;
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/ehhelpers.h

@@ -0,0 +1,87 @@
+//
+// Copyright (c) Microsoft Corporation. All Rights reserved.
+//
+
+#pragma once
+
+#if defined(_M_X64) || defined(_M_ARM_NT) || defined(_M_ARM64) || defined(_CHPE_X86_ARM64_EH_)
+
+#define _pForeignExcept   (*((EHExceptionRecord **)&(RENAME_BASE_PTD(__vcrt_getptd)()->_pForeignException)))
+
+#endif
+
+#define pFrameInfoChain   (*((FRAMEINFO **)    &(RENAME_BASE_PTD(__vcrt_getptd)()->_pFrameInfoChain)))
+
+// Pre-V4 managed exception code
+#define MANAGED_EXCEPTION_CODE  0XE0434F4D
+
+// V4 and later managed exception code
+#define MANAGED_EXCEPTION_CODE_V4  0XE0434352
+
+extern "C" void
+__except_validate_context_record(
+    _In_ PCONTEXT ContextRecord
+    );
+
+extern "C" _VCRTIMP void * __AdjustPointer(
+    void *,
+    const PMD&
+);
+
+extern "C" _VCRTIMP void * __GetPlatformExceptionInfo(
+    int *
+);
+
+extern "C" _VCRTIMP int __cdecl __FrameUnwindFilter(
+    EXCEPTION_POINTERS *
+);
+
+extern PGETWINRT_OOM_EXCEPTION __WinRTOutOfMemoryExceptionCallback;
+
+extern "C" _VCRTIMP void __cdecl __DestructExceptionObject(
+    EHExceptionRecord *,
+    BOOLEAN
+);
+
+extern "C" _VCRTIMP void __cdecl RENAME_EH_EXTERN(__BuildCatchObject)(
+    EHExceptionRecord *,
+    void *,
+    HandlerType *,
+    CatchableType *
+);
+
+extern "C" _VCRTIMP int __cdecl RENAME_EH_EXTERN(__TypeMatch4)(
+    FH4::HandlerType4 *,
+    CatchableType *,
+    ThrowInfo *
+    );
+
+extern "C" _VCRTIMP int __cdecl RENAME_EH_EXTERN(__TypeMatch)(
+    HandlerType *,
+    CatchableType *,
+    ThrowInfo *
+);
+
+//
+// Prototype for the internal handler
+//
+
+template<class T>
+EXCEPTION_DISPOSITION __InternalCxxFrameHandlerWrapper(
+    EHExceptionRecord    *pExcept,
+    EHRegistrationNode   *pRN,
+    CONTEXT              *pContext,
+    DispatcherContext    *pDC,
+    typename T::FuncInfo *pFuncInfo,
+    int                  CatchDepth,
+    EHRegistrationNode   *pMarkerRN,
+    BOOLEAN              recursive);
+
+#if _EH_RELATIVE_TYPEINFO
+
+#undef THROW_COUNT
+#define THROW_COUNT(ti)         THROW_COUNT_IB(ti, _GetThrowImageBase())
+#undef THROW_CTLIST
+#define THROW_CTLIST(ti)        THROW_CTLIST_IB(ti, _GetThrowImageBase())
+
+#endif // _EH_RELATIVE_TYPEINFO

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/ehstate.cpp

@@ -0,0 +1,237 @@
+/***
+* ehstate.cpp
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*Purpose:
+*       Contains state management code for all platforms.
+*
+*/
+
+#include <vcruntime_internal.h>
+#include <eh.h>
+#include <ehassert.h>
+#include <ehdata.h>
+#include <ehdata4.h>
+#include <ehhooks.h>
+#include <trnsctrl.h>
+#include <type_traits>
+#include "ehhelpers.h"
+#include <windows.h>
+
+#if _EH_RELATIVE_FUNCINFO
+#if defined(_M_ARM_NT) || defined(_M_ARM64) || defined(_CHPE_X86_ARM64_EH_) || defined(_M_ARM64EC)
+static uintptr_t adjustIp(DispatcherContext *pDC, uintptr_t Ip)
+{
+#if defined(_M_ARM64EC)
+    if(RtlIsEcCode(Ip)) {
+        PDISPATCHER_CONTEXT_ARM64EC pECDC;
+        pECDC = (PDISPATCHER_CONTEXT_ARM64EC) pDC;
+
+        if(pECDC->ControlPcIsUnwound != FALSE) {
+            Ip -= 4;
+        }
+    }
+#else
+
+   //
+   // If this context came from an unwind to a call, then the ControlPc points
+   // to a return address, which could put us at the start of a neighboring
+   // scope. To correct for this, back the PC up by the minimum instruction
+   // size to ensure we are in the same scope as the original call opcode.
+   //
+   if (pDC->ControlPcIsUnwound) {
+
+#if defined(_M_ARM_NT)
+
+        Ip -= 2;
+
+#else
+
+        Ip -= 4;
+
+#endif // _M_ARM_NT
+
+    }
+
+#endif // _M_ARM64EC
+    return Ip;
+}
+
+#else
+static uintptr_t adjustIp(DispatcherContext* /*pDC*/, uintptr_t Ip)
+{
+    return Ip;
+}
+#endif // (_M_ARM_NT) || defined(_M_ARM64) || defined(_CHPE_X86_ARM64_EH_) || defined(_M_ARM64EC)
+
+__ehstate_t RENAME_EH_EXTERN(__FrameHandler4)::StateFromIp(
+    FuncInfo            *pFuncInfo,
+    DispatcherContext   *pDC,
+    uintptr_t           Ip
+)
+{
+    unsigned int        index;          //  loop control variable
+    unsigned int        nIPMapEntry;    //  # of IpMapEntry; must be > 0
+
+    Ip = adjustIp(pDC, Ip);
+
+    if (pFuncInfo->dispIPtoStateMap == 0)
+    {
+        return EH_EMPTY_STATE;
+    }
+
+    PBYTE buffer = (PBYTE)__RVAtoRealOffset(pDC, pFuncInfo->dispIPtoStateMap);
+
+    nIPMapEntry = FH4::ReadUnsigned(&buffer);
+
+    __ehstate_t prevState = EH_EMPTY_STATE;
+    unsigned int funcRelIP = 0;
+    for (index = 0; index < nIPMapEntry; index++) {
+        // States are delta-encoded relative to start of the function
+        funcRelIP += FH4::ReadUnsigned(&buffer);
+        if (Ip < __FuncRelToRealOffset(pDC, funcRelIP)) {
+            break;
+        }
+        // States are encoded +1 so as to not encode a negative
+        prevState = FH4::ReadUnsigned(&buffer) - 1;
+    }
+
+    if (index == 0) {
+        // We are at the first entry, could be an error
+        return EH_EMPTY_STATE;
+    }
+
+    // We over-shot one iteration; return state from the previous slot
+    return prevState;
+}
+
+__ehstate_t RENAME_EH_EXTERN(__FrameHandler3)::StateFromIp(
+    FuncInfo            *pFuncInfo,
+    DispatcherContext   *pDC,
+    uintptr_t           Ip
+)
+{
+
+    unsigned int        index;          //  loop control variable
+    unsigned int        nIPMapEntry;    //  # of IpMapEntry; must be > 0
+
+    Ip = adjustIp(pDC, Ip);
+
+    _VCRT_VERIFY(pFuncInfo);
+    nIPMapEntry = FUNC_NIPMAPENT(*pFuncInfo);
+
+    _VCRT_VERIFY(FUNC_IPMAP(*pFuncInfo, pDC->ImageBase));
+
+    for (index = 0; index < nIPMapEntry; index++) {
+        IptoStateMapEntry *pIPtoStateMap = FUNC_PIPTOSTATE(*pFuncInfo, index, pDC->ImageBase);
+        if (Ip < (uintptr_t)__RVAtoRealOffset(pDC, pIPtoStateMap->Ip)) {
+            break;
+        }
+    }
+
+    if (index == 0) {
+        // We are at the first entry, could be an error
+
+        return EH_EMPTY_STATE;
+    }
+
+    // We over-shot one iteration; return state from the previous slot
+
+    return FUNC_IPTOSTATE(*pFuncInfo, index - 1, pDC->ImageBase).State;
+
+}
+
+__ehstate_t RENAME_EH_EXTERN(__FrameHandler3)::StateFromControlPc(
+    FuncInfo           *pFuncInfo,
+    DispatcherContext  *pDC
+)
+{
+    uintptr_t Ip = pDC->ControlPc;
+
+    return StateFromIp(pFuncInfo, pDC, Ip);
+}
+
+__ehstate_t RENAME_EH_EXTERN(__FrameHandler4)::StateFromControlPc(
+    FuncInfo           *pFuncInfo,
+    DispatcherContext  *pDC
+)
+{
+    uintptr_t Ip = pDC->ControlPc;
+
+    return StateFromIp(pFuncInfo, pDC, Ip);
+}
+
+void RENAME_EH_EXTERN(__FrameHandler3)::SetUnwindTryBlock(
+    EHRegistrationNode  *pRN,
+    DispatcherContext   *pDC,
+    FuncInfo            *pFuncInfo,
+    int                 curState
+)
+{
+    EHRegistrationNode EstablisherFramePointers;
+    EstablisherFramePointers = *RENAME_EH_EXTERN(__FrameHandler3)::GetEstablisherFrame(pRN, pDC, pFuncInfo, &EstablisherFramePointers);
+    if (curState > UNWINDTRYBLOCK(EstablisherFramePointers, FUNC_DISPUNWINDHELP(*pFuncInfo))) {
+        UNWINDTRYBLOCK(EstablisherFramePointers, FUNC_DISPUNWINDHELP(*pFuncInfo)) = (int)curState;
+    }
+}
+
+__ehstate_t RENAME_EH_EXTERN(__FrameHandler3)::GetUnwindTryBlock(
+    EHRegistrationNode  *pRN,
+    DispatcherContext   *pDC,
+    FuncInfo            *pFuncInfo
+)
+{
+    EHRegistrationNode EstablisherFramePointers;
+    EstablisherFramePointers = *RENAME_EH_EXTERN(__FrameHandler3)::GetEstablisherFrame(pRN, pDC, pFuncInfo, &EstablisherFramePointers);
+    return UNWINDTRYBLOCK(EstablisherFramePointers, FUNC_DISPUNWINDHELP(*pFuncInfo));
+}
+
+__ehstate_t RENAME_EH_EXTERN(__FrameHandler3)::GetCurrentState(
+    EHRegistrationNode  *pRN,
+    DispatcherContext   *pDC,
+    FuncInfo            *pFuncInfo
+)
+{
+    if (UNWINDSTATE(*pRN, FUNC_DISPUNWINDHELP(*pFuncInfo)) == -2) {
+        return RENAME_EH_EXTERN(__FrameHandler3)::StateFromControlPc(pFuncInfo, pDC);
+    }
+    else {
+        return UNWINDSTATE(*pRN, FUNC_DISPUNWINDHELP(*pFuncInfo));
+    }
+}
+
+void RENAME_EH_EXTERN(__FrameHandler3)::SetState(
+    EHRegistrationNode  *pRN,
+    FuncInfo            *pFuncInfo,
+    __ehstate_t          newState
+)
+{
+    UNWINDSTATE(*pRN, FUNC_DISPUNWINDHELP(*pFuncInfo)) = newState;
+}
+#else
+__ehstate_t RENAME_EH_EXTERN(__FrameHandler3)::GetCurrentState(
+    EHRegistrationNode  *pRN,
+    DispatcherContext*  /*pDC*/,
+    FuncInfo            *pFuncInfo
+)
+{
+    // In the initial implementation, the state is simply stored in the registration node.
+    // Added support for byte states when max state <= 128. Note that max state is 1+real max state
+    if (pFuncInfo->maxState <= 128)
+    {
+        return (__ehstate_t)(signed char)((pRN)->state & 0xff);
+    }
+    else {
+        return (pRN)->state;
+    }
+}
+
+void RENAME_EH_EXTERN(__FrameHandler3)::SetState(
+    EHRegistrationNode  *pRN,
+    FuncInfo*           /*pFuncInfo*/,
+    __ehstate_t         newState
+)
+{
+    pRN->state = newState;
+}
+#endif

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/ehvccctr.cpp

@@ -0,0 +1,94 @@
+/***
+*ehvccctr.cpp - EH-aware version of copy constructor iterator helper function
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       These functions are called when constructing and destructing arrays of
+*       objects.  Their purpose is to assure that constructed elements get
+*       destructed if the constructor for one of the elements throws.
+*
+*       Must be compiled using "-d1Binl" to be able to specify __thiscall
+*       at the user level
+****/
+
+#include <eh.h>
+
+/*
+ * Note that we will be compiling all this with /clr option not /clr:pure
+ */
+#if defined _M_CEE
+    #define CALLTYPE  __clrcall
+    #define CALLEETYPE __clrcall
+    #define __RELIABILITY_CONTRACT                                                   \
+        [System::Runtime::ConstrainedExecution::ReliabilityContract(                 \
+            System::Runtime::ConstrainedExecution::Consistency::WillNotCorruptState, \
+            System::Runtime::ConstrainedExecution::Cer::Success                      \
+        )]
+#else
+    #define CALLEETYPE __stdcall
+    #define __RELIABILITY_CONTRACT
+
+    #if defined _M_IX86
+        #define CALLTYPE __thiscall
+    #else
+        #define CALLTYPE __stdcall
+    #endif
+#endif
+
+using constructor_type = void (CALLTYPE*)(void*, void*);
+using destructor_type  = void (CALLTYPE*)(void*);
+
+__RELIABILITY_CONTRACT
+void CALLEETYPE __ArrayUnwind(
+    void*           ptr,            // Pointer to array to destruct
+    size_t          size,           // Size of each element (including padding)
+    size_t          count,          // Number of elements in the array
+    destructor_type destructor      // The destructor to call
+    );
+
+__RELIABILITY_CONTRACT
+void CALLEETYPE __ehvec_copy_ctor(
+    void*            dst,           // Pointer to destination array
+    void*            src,           // Pointer to source array
+    size_t           size,          // Size of each element (including padding)
+    size_t           count,         // Number of elements in the array
+    constructor_type constructor,   // Constructor to call
+    destructor_type  destructor     // Destructor to call should exception be thrown
+    )
+{
+    size_t i{0};
+    bool success{false};
+
+    __try
+    {
+        for (; i != count; ++i)
+        {
+            constructor(dst, src);
+            dst = static_cast<char*>(dst) + size;
+            src = static_cast<char*>(src) + size;
+        }
+
+        success = true;
+    }
+    __finally
+    {
+        if (!success)
+        {
+            __ArrayUnwind(dst, size, i, destructor);
+        }
+    }
+}
+
+__RELIABILITY_CONTRACT
+void CALLEETYPE __ehvec_copy_ctor(
+    void*            dst,           // Pointer to destination array
+    void*            src,           // Pointer to source array
+    size_t           size,          // Size of each element (including padding)
+    int              count,         // Number of elements in the array
+    constructor_type constructor,   // Constructor to call
+    destructor_type  destructor     // Destructor to call should exception be thrown
+    )
+{
+    __ehvec_copy_ctor(dst, src, size, static_cast<size_t>(count), constructor, destructor);
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/ehvcccvb.cpp

@@ -0,0 +1,95 @@
+/***
+*ehvcccvb.cpp - EH copy-ctor iterator helper function for class w/ virtual bases
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       These functions are called when constructing and destructing arrays of
+*       objects.  Their purpose is to assure that constructed elements get
+*       destructed if the constructor for one of the elements throws.
+*
+*       Must be compiled using "-d1Binl" to be able to specify __thiscall
+*       at the user level
+****/
+
+#include <eh.h>
+
+#if defined _M_CEE
+    #define CALLTYPE  __clrcall
+    #define CALLEETYPE __clrcall
+    #define __RELIABILITY_CONTRACT                                                   \
+        [System::Runtime::ConstrainedExecution::ReliabilityContract(                 \
+            System::Runtime::ConstrainedExecution::Consistency::WillNotCorruptState, \
+            System::Runtime::ConstrainedExecution::Cer::Success                      \
+        )]
+#else
+    #define CALLEETYPE __stdcall
+    #define __RELIABILITY_CONTRACT
+
+    #if defined _M_IX86
+        #define CALLTYPE __thiscall
+    #else
+        #define CALLTYPE __stdcall
+    #endif
+#endif
+
+using constructor_type = void (CALLTYPE*)(void*, void*);
+using destructor_type  = void (CALLTYPE*)(void*);
+
+__RELIABILITY_CONTRACT
+void CALLEETYPE __ArrayUnwind(
+    void*           ptr,            // Pointer to array to destruct
+    size_t          size,           // Size of each element (including padding)
+    size_t          count,          // Number of elements in the array
+    destructor_type destructor      // The destructor to call
+    );
+
+__RELIABILITY_CONTRACT
+void CALLEETYPE __ehvec_copy_ctor_vb(
+    void*            dst,           // Pointer to destination array
+    void*            src,           // Pointer to source array
+    size_t           size,          // Size of each element (including padding)
+    size_t           count,         // Number of elements in the array
+    constructor_type constructor,   // Constructor to call
+    destructor_type  destructor     // Destructor to call should exception be thrown
+    )
+{
+    size_t i{0};
+    bool success{false};
+
+    __try
+    {
+        for (; i != count; ++i)
+        {
+            #pragma warning(push)
+            #pragma warning(disable: 4191) // unsafe conversion
+            reinterpret_cast<void (CALLTYPE*)(void*, void*, int)>(constructor)(dst, src, 1);
+            #pragma warning(pop)
+
+            dst = static_cast<char*>(dst) + size;
+            src = static_cast<char*>(src) + size;
+        }
+
+        success = true;
+    }
+    __finally
+    {
+        if (!success)
+        {
+            __ArrayUnwind(dst, size, i, destructor);
+        }
+    }
+}
+
+__RELIABILITY_CONTRACT
+void CALLEETYPE __ehvec_copy_ctor_vb(
+    void*            dst,           // Pointer to destination array
+    void*            src,           // Pointer to source array
+    size_t           size,          // Size of each element (including padding)
+    int              count,         // Number of elements in the array
+    constructor_type constructor,   // Constructor to call
+    destructor_type  destructor     // Destructor to call should exception be thrown
+    )
+{
+    __ehvec_copy_ctor_vb(dst, src, size, static_cast<size_t>(count), constructor, destructor);
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/ehvecctr.cpp

@@ -0,0 +1,89 @@
+/***
+*ehvecctr.cpp - EH-aware version of constructor iterator helper function
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       These functions are called when constructing and destructing arrays of
+*       objects.  Their purpose is to assure that constructed elements get
+*       destructed if the constructor for one of the elements throws.
+*
+*       Must be compiled using "-d1Binl" to be able to specify __thiscall
+*       at the user level
+****/
+
+#include <eh.h>
+
+#if defined _M_CEE
+    #define CALLTYPE  __clrcall
+    #define CALLEETYPE __clrcall
+    #define __RELIABILITY_CONTRACT                                                   \
+        [System::Runtime::ConstrainedExecution::ReliabilityContract(                 \
+            System::Runtime::ConstrainedExecution::Consistency::WillNotCorruptState, \
+            System::Runtime::ConstrainedExecution::Cer::Success                      \
+        )]
+#else
+    #define CALLEETYPE __stdcall
+    #define __RELIABILITY_CONTRACT
+
+    #if defined _M_IX86
+        #define CALLTYPE __thiscall
+    #else
+        #define CALLTYPE __stdcall
+    #endif
+#endif
+
+using constructor_type = void (CALLTYPE*)(void*);
+using destructor_type  = void (CALLTYPE*)(void*);
+
+__RELIABILITY_CONTRACT
+void CALLEETYPE __ArrayUnwind(
+    void*           ptr,            // Pointer to array to destruct
+    size_t          size,           // Size of each element (including padding)
+    size_t          count,          // Number of elements in the array
+    destructor_type destructor      // The destructor to call
+    );
+
+__RELIABILITY_CONTRACT
+void CALLEETYPE __ehvec_ctor(
+    void*            ptr,           // Pointer to array to destruct
+    size_t           size,          // Size of each element (including padding)
+    size_t           count,         // Number of elements in the array
+    constructor_type constructor,   // Constructor to call
+    destructor_type  destructor     // Destructor to call should exception be thrown
+    )
+{
+    size_t i{0};
+    bool success{false};
+
+    __try
+    {
+        for (; i != count; ++i)
+        {
+            constructor(ptr);
+
+            ptr = static_cast<char*>(ptr) + size;
+        }
+
+        success = true;
+    }
+    __finally
+    {
+        if (!success)
+        {
+            __ArrayUnwind(ptr, size, i, destructor);
+        }
+    }
+}
+
+__RELIABILITY_CONTRACT
+void CALLEETYPE __ehvec_ctor(
+    void*            ptr,           // Pointer to array to destruct
+    size_t           size,          // Size of each element (including padding)
+    int              count,         // Number of elements in the array
+    constructor_type constructor,   // Constructor to call
+    destructor_type  destructor     // Destructor to call should exception be thrown
+    )
+{
+    __ehvec_ctor(ptr, size, static_cast<size_t>(count), constructor, destructor);
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/ehveccvb.cpp

@@ -0,0 +1,99 @@
+/***
+*ehveccvb.cpp - EH c-tor iterator helper function for class w/ virtual bases
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       EH-aware version of constructor iterator helper function for class
+*       with virtual bases
+*
+*       These functions are called when constructing and destructing arrays of
+*       objects.  Their purpose is to assure that constructed elements get
+*       destructed if the constructor for one of the elements throws.
+*
+*       These functions are called when constructing and destructing arrays of
+*       objects.  Their purpose is to assure that constructed elements get
+*       destructed if the constructor for one of the elements throws.
+*
+*       Must be compiled using "-d1Binl" to be able to specify __thiscall
+*       at the user level
+****/
+
+#include <eh.h>
+
+#if defined _M_CEE
+    #define CALLTYPE  __clrcall
+    #define CALLEETYPE __clrcall
+    #define __RELIABILITY_CONTRACT                                                   \
+        [System::Runtime::ConstrainedExecution::ReliabilityContract(                 \
+            System::Runtime::ConstrainedExecution::Consistency::WillNotCorruptState, \
+            System::Runtime::ConstrainedExecution::Cer::Success                      \
+        )]
+#else
+    #define CALLEETYPE __stdcall
+    #define __RELIABILITY_CONTRACT
+
+    #if defined _M_IX86
+        #define CALLTYPE __thiscall
+    #else
+        #define CALLTYPE __stdcall
+    #endif
+#endif
+
+using constructor_type = void (CALLTYPE*)(void*);
+using destructor_type  = void (CALLTYPE*)(void*);
+
+__RELIABILITY_CONTRACT
+void CALLEETYPE __ArrayUnwind(
+    void*           ptr,            // Pointer to array to destruct
+    size_t          size,           // Size of each element (including padding)
+    size_t          count,          // Number of elements in the array
+    destructor_type destructor      // The destructor to call
+    );
+
+__RELIABILITY_CONTRACT
+void CALLEETYPE __ehvec_ctor_vb(
+    void*            ptr,           // Pointer to array to destruct
+    size_t           size,          // Size of each element (including padding)
+    size_t           count,         // Number of elements in the array
+    constructor_type constructor,   // Constructor to call
+    destructor_type  destructor     // Destructor to call should exception be thrown
+    )
+{
+    size_t i{0};
+    bool success{false};
+
+    __try
+    {
+        for (; i != count; ++i)
+        {
+            #pragma warning(push)
+            #pragma warning(disable: 4191) // unsafe conversion
+            reinterpret_cast<void (CALLTYPE*)(void*, int)>(constructor)(ptr, 1);
+            #pragma warning(pop)
+
+            ptr = static_cast<char*>(ptr) + size;
+        }
+
+        success = true;
+    }
+    __finally
+    {
+        if (!success)
+        {
+            __ArrayUnwind(ptr, size, i, destructor);
+        }
+    }
+}
+
+__RELIABILITY_CONTRACT
+void CALLEETYPE __ehvec_ctor_vb(
+    void*            ptr,           // Pointer to array to destruct
+    size_t           size,          // Size of each element (including padding)
+    int              count,         // Number of elements in the array
+    constructor_type constructor,   // Constructor to call
+    destructor_type  destructor     // Destructor to call should exception be thrown
+    )
+{
+    __ehvec_ctor_vb(ptr, size, static_cast<size_t>(count), constructor, destructor);
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/ehvecdtr.cpp

@@ -0,0 +1,140 @@
+/***
+*ehvecdtr.cpp - EH-aware version of destructor iterator helper function
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       These functions are called when constructing and destructing arrays of
+*       objects.  Their purpose is to assure that constructed elements get
+*       destructed if the constructor for one of the elements throws.
+*
+*       Must be compiled using "-d1Binl" to be able to specify __thiscall
+*       at the user level
+****/
+
+#include <ehdata.h>
+#include <eh.h>
+#include <trnsctrl.h>
+
+#if defined _M_CEE
+    #define CALLTYPE  __clrcall
+    #define CALLEETYPE __clrcall
+    #define __RELIABILITY_CONTRACT                                                   \
+        [System::Runtime::ConstrainedExecution::ReliabilityContract(                 \
+            System::Runtime::ConstrainedExecution::Consistency::WillNotCorruptState, \
+            System::Runtime::ConstrainedExecution::Cer::Success                      \
+        )]
+
+    #define ASSERT_UNMANAGED_CODE_ATTRIBUTE [System::Security::Permissions::SecurityPermissionAttribute(System::Security::Permissions::SecurityAction::Assert, UnmanagedCode = true)]
+    #define SECURITYCRITICAL_ATTRIBUTE      [System::Security::SecurityCritical]
+#else
+    #define CALLEETYPE __stdcall
+    #define __RELIABILITY_CONTRACT
+    #define ASSERT_UNMANAGED_CODE_ATTRIBUTE
+    #define SECURITYCRITICAL_ATTRIBUTE
+
+    #if defined _M_IX86
+        #define CALLTYPE __thiscall
+    #else
+        #define CALLTYPE __stdcall
+    #endif
+#endif
+
+using destructor_type = void (CALLTYPE*)(void*);
+
+__RELIABILITY_CONTRACT
+void CALLEETYPE __ArrayUnwind(
+    void*           ptr,            // Pointer to array to destruct
+    size_t          size,           // Size of each element (including padding)
+    size_t          count,          // Number of elements in the array
+    destructor_type destructor      // The destructor to call
+    );
+
+__RELIABILITY_CONTRACT
+SECURITYCRITICAL_ATTRIBUTE
+void CALLEETYPE __ehvec_dtor(
+    void*           ptr,            // Pointer to array to destruct
+    size_t          size,           // Size of each element (including padding)
+    size_t          count,          // Number of elements in the array
+    destructor_type destructor      // The destructor to call
+    )
+{
+    bool success{false};
+
+    // Advance pointer past end of array
+    ptr = static_cast<char*>(ptr) + size * count;
+
+    __try
+    {
+        // Destruct elements
+        while (count-- > 0)
+        {
+            ptr = static_cast<char*>(ptr) - size;
+            destructor(ptr);
+        }
+
+        success = true;
+    }
+    __finally
+    {
+        if (!success)
+        {
+            __ArrayUnwind(ptr, size, count, destructor);
+        }
+    }
+}
+
+__RELIABILITY_CONTRACT
+ASSERT_UNMANAGED_CODE_ATTRIBUTE
+SECURITYCRITICAL_ATTRIBUTE
+static int ArrayUnwindFilter(EXCEPTION_POINTERS* pExPtrs)
+{
+    EHExceptionRecord *pExcept = reinterpret_cast<EHExceptionRecord*>(pExPtrs->ExceptionRecord);
+
+    switch(PER_CODE(pExcept))
+    {
+        case EH_EXCEPTION_NUMBER:
+            _pCurrentException = pExcept;
+            _pCurrentExContext = pExPtrs->ContextRecord;
+            terminate();
+        default:
+            return EXCEPTION_CONTINUE_SEARCH;
+    }
+}
+
+__RELIABILITY_CONTRACT
+SECURITYCRITICAL_ATTRIBUTE
+void CALLEETYPE __ArrayUnwind(
+    void*           ptr,          // Pointer to array to destruct
+    size_t          size,         // Size of each element (including padding)
+    size_t          count,        // Number of elements in the array
+    destructor_type destructor    // The destructor to call
+    )
+{
+    // 'unwind' rest of array
+
+    __try
+    {
+        for (size_t i{0}; i != count; ++i)
+        {
+            ptr = static_cast<char*>(ptr) - size;
+            destructor(ptr);
+        }
+    }
+    __except(ArrayUnwindFilter(exception_info()))
+    {
+        ; // Deliberately do nothing
+    }
+}
+
+__RELIABILITY_CONTRACT
+SECURITYCRITICAL_ATTRIBUTE
+void CALLEETYPE __ehvec_dtor(
+    void*           ptr,            // Pointer to array to destruct
+    size_t          size,           // Size of each element (including padding)
+    int             count,          // Number of elements in the array
+    destructor_type destructor      // The destructor to call
+    )
+{
+    __ehvec_dtor(ptr, size, static_cast<size_t>(count), destructor);
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/env_mode.cpp

@@ -0,0 +1,16 @@
+//
+// env_mode.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Specifies whether the environment should be initialized.
+// This behavior is overridable at link-time by linking with noenv.obj.
+//
+#include <vcruntime_startup.h>
+
+
+
+extern "C" bool __CRTDECL _should_initialize_environment()
+{
+    return true;
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/exe_common.inl

@@ -0,0 +1,331 @@
+//
+// exe_common.inl
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The implementation of the common executable entry point code.  There are four
+// executable entry points defined by the CRT, one for each of the user-definable
+// entry points:
+//
+//  * mainCRTStartup     => main
+//  * wmainCRTStartup    => wmain
+//  * WinMainCRTStartup  => WinMain
+//  * wWinMainCRTStartup => wWinMain
+//
+// These functions all behave the same, except for which user-definable main
+// function they call and whether they accumulate and pass narrow or wide string
+// arguments.  This file contains the common code shared by all four of those
+// entry points.
+//
+// The actual entry points are defined in four .cpp files alongside this .inl
+// file.  At most one of these .cpp files will be linked into the resulting
+// executable, so we can treat this .inl file as if its contents are only linked
+// into the executable once as well.
+//
+#include <vcstartup_internal.h>
+#include <vcruntime_internal.h>
+#include <locale.h>
+#include <math.h>
+#include <new.h>
+#include <process.h>
+#include <rtcapi.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Common main()/WinMain() implementation
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+struct __scrt_main_policy
+{
+    static void set_app_type() { _set_app_type(_crt_console_app); }
+};
+
+struct __scrt_winmain_policy
+{
+    static void set_app_type() { _set_app_type(_crt_gui_app); }
+};
+
+struct __scrt_enclavemain_policy
+{
+    static void set_app_type() { }
+};
+
+struct __scrt_file_policy
+{
+    static void set_fmode() { _set_fmode(_get_startup_file_mode()); }
+    static void set_commode() { _commode = _get_startup_commit_mode(); }
+};
+
+struct __scrt_nofile_policy
+{
+    static void set_fmode() { }
+    static void set_commode() { }
+};
+
+#if defined _SCRT_STARTUP_MAIN
+
+    using main_policy = __scrt_main_policy;
+    using file_policy = __scrt_file_policy;
+    using argv_policy = __scrt_narrow_argv_policy;
+    using environment_policy = __scrt_narrow_environment_policy;
+
+    static int __cdecl invoke_main()
+    {
+        return main(__argc, __argv, _get_initial_narrow_environment());
+    }
+
+#elif defined _SCRT_STARTUP_WMAIN
+
+    using main_policy = __scrt_main_policy;
+    using file_policy = __scrt_file_policy;
+    using argv_policy = __scrt_wide_argv_policy;
+    using environment_policy = __scrt_wide_environment_policy;
+
+    static int __cdecl invoke_main()
+    {
+        return wmain(__argc, __wargv, _get_initial_wide_environment());
+    }
+
+#elif defined _SCRT_STARTUP_WINMAIN
+
+    using main_policy = __scrt_winmain_policy;
+    using file_policy = __scrt_file_policy;
+    using argv_policy = __scrt_narrow_argv_policy;
+    using environment_policy = __scrt_narrow_environment_policy;
+
+    static int __cdecl invoke_main()
+    {
+        return WinMain(
+            reinterpret_cast<HINSTANCE>(&__ImageBase),
+            nullptr,
+            _get_narrow_winmain_command_line(),
+            __scrt_get_show_window_mode());
+    }
+
+#elif defined _SCRT_STARTUP_WWINMAIN
+
+    using main_policy = __scrt_winmain_policy;
+    using file_policy = __scrt_file_policy;
+    using argv_policy = __scrt_wide_argv_policy;
+    using environment_policy = __scrt_wide_environment_policy;
+
+    static int __cdecl invoke_main()
+    {
+        return wWinMain(
+            reinterpret_cast<HINSTANCE>(&__ImageBase),
+            nullptr,
+            _get_wide_winmain_command_line(),
+            __scrt_get_show_window_mode());
+    }
+
+#elif defined _SCRT_STARTUP_ENCLAVE || defined _SCRT_STARTUP_WENCLAVE
+
+    using main_policy = __scrt_enclavemain_policy;
+    using file_policy = __scrt_nofile_policy;
+    using argv_policy = __scrt_no_argv_policy;
+    using environment_policy = __scrt_no_environment_policy;
+
+#if defined _SCRT_STARTUP_ENCLAVE
+    static int __cdecl invoke_main()
+    {
+        return main(0, nullptr, nullptr);
+    }
+#else
+    static int __cdecl invoke_main()
+    {
+        return wmain(0, nullptr, nullptr);
+    }
+#endif
+
+#endif
+
+static int __cdecl pre_c_initialization()
+{
+    main_policy::set_app_type();
+
+    file_policy::set_fmode();
+    file_policy::set_commode();
+
+    if (!__scrt_initialize_onexit_tables(__scrt_module_type::exe))
+        __scrt_fastfail(FAST_FAIL_FATAL_APP_EXIT);
+
+    #ifdef _M_IX86
+    // Clear the x87 exception flags.  Any other floating point initialization
+    // should already have taken place before this function is called.
+    _asm { fnclex }
+    #endif
+
+    #ifdef _RTC
+    _RTC_Initialize();
+    atexit(_RTC_Terminate);
+    #endif
+
+    if (argv_policy::configure_argv() != 0)
+        __scrt_fastfail(FAST_FAIL_FATAL_APP_EXIT);
+
+    __scrt_initialize_type_info();
+
+    // If the user provided a _matherr handler, register it with the Universal
+    // CRT.  Windows OS components cannot set a custom matherr handler (this is
+    // a policy decision, to reduce complexity).
+    #ifndef _CRT_WINDOWS
+    if (__scrt_is_user_matherr_present())
+    {
+        __setusermatherr(_matherr);
+    }
+    #endif
+
+    _initialize_invalid_parameter_handler();
+    _initialize_denormal_control();
+
+    #ifdef _M_IX86
+    _initialize_default_precision();
+    #endif
+
+    _configthreadlocale(_get_startup_thread_locale_mode());
+
+    if (_should_initialize_environment())
+        environment_policy::initialize_environment();
+
+    __scrt_initialize_winrt();
+
+    if (__scrt_initialize_mta() != 0)
+    {
+        __scrt_fastfail(FAST_FAIL_FATAL_APP_EXIT);
+    }
+
+    return 0;
+}
+
+static int __cdecl post_pgo_initialization()
+{
+    // This function calls the __local_stdio_{printf,scanf}_options() functions.
+    // These functions are defined in public headers with external linkage and
+    // thus may be PGO-instrumented.  We must not call these functions before the
+    // PGO instrumentation library is initialized.
+    __scrt_initialize_default_local_stdio_options();
+
+    return 0;
+}
+
+static void __cdecl pre_cpp_initialization()
+{
+    // Before we begin C++ initialization, set the unhandled exception
+    // filter so that unhandled C++ exceptions result in std::terminate
+    // being called:
+    __scrt_set_unhandled_exception_filter();
+
+    _set_new_mode(_get_startup_new_mode());
+}
+
+// When both the PGO instrumentation library and the CRT are statically linked,
+// PGO will initialize itself in XIAB.  We do most pre-C initialization before
+// PGO is initialized, but defer some initialization steps to after.  See the
+// commentary in post_pgo_initialization for details.
+_CRTALLOC(".CRT$XIAA") static _PIFV pre_c_initializer    = pre_c_initialization;
+_CRTALLOC(".CRT$XIAC") static _PIFV post_pgo_initializer = post_pgo_initialization;
+_CRTALLOC(".CRT$XCAA") static _PVFV pre_cpp_initializer  = pre_cpp_initialization;
+
+
+
+static __declspec(noinline) int __cdecl __scrt_common_main_seh()
+{
+    if (!__scrt_initialize_crt(__scrt_module_type::exe))
+        __scrt_fastfail(FAST_FAIL_FATAL_APP_EXIT);
+
+    bool has_cctor = false;
+    __try
+    {
+        bool const is_nested = __scrt_acquire_startup_lock();
+
+        if (__scrt_current_native_startup_state == __scrt_native_startup_state::initializing)
+        {
+            __scrt_fastfail(FAST_FAIL_FATAL_APP_EXIT);
+        }
+        else if (__scrt_current_native_startup_state == __scrt_native_startup_state::uninitialized)
+        {
+            __scrt_current_native_startup_state = __scrt_native_startup_state::initializing;
+
+            if (_initterm_e(__xi_a, __xi_z) != 0)
+                return 255;
+
+            _initterm(__xc_a, __xc_z);
+
+            __scrt_current_native_startup_state = __scrt_native_startup_state::initialized;
+        }
+        else
+        {
+            has_cctor = true;
+        }
+
+        __scrt_release_startup_lock(is_nested);
+
+        // If this module has any dynamically initialized __declspec(thread)
+        // variables, then we invoke their initialization for the primary thread
+        // used to start the process:
+        _tls_callback_type const* const tls_init_callback = __scrt_get_dyn_tls_init_callback();
+        if (*tls_init_callback != nullptr && __scrt_is_nonwritable_in_current_image(tls_init_callback))
+        {
+            (*tls_init_callback)(nullptr, DLL_THREAD_ATTACH, nullptr);
+        }
+
+        // If this module has any thread-local destructors, register the
+        // callback function with the Unified CRT to run on exit.
+        _tls_callback_type const * const tls_dtor_callback = __scrt_get_dyn_tls_dtor_callback();
+        if (*tls_dtor_callback != nullptr && __scrt_is_nonwritable_in_current_image(tls_dtor_callback))
+        {
+            _register_thread_local_exe_atexit_callback(*tls_dtor_callback);
+        }
+
+        //
+        // Initialization is complete; invoke main...
+        //
+
+        int const main_result = invoke_main();
+
+        //
+        // main has returned; exit somehow...
+        //
+
+        if (!__scrt_is_managed_app())
+            exit(main_result);
+
+        if (!has_cctor)
+            _cexit();
+
+        // Finally, we terminate the CRT:
+        __scrt_uninitialize_crt(true, false);
+        return main_result;
+    }
+    __except (_seh_filter_exe(GetExceptionCode(), GetExceptionInformation()))
+    {
+        // Note:  We should never reach this except clause.
+        int const main_result = GetExceptionCode();
+
+        if (!__scrt_is_managed_app())
+            _exit(main_result);
+
+        if (!has_cctor)
+            _c_exit();
+
+        return main_result;
+    }
+}
+
+
+
+// This is the common main implementation to which all of the CRT main functions
+// delegate (for executables; DLLs are handled separately).
+static __forceinline int __cdecl __scrt_common_main()
+{
+    // The /GS security cookie must be initialized before any exception handling
+    // targeting the current image is registered.  No function using exception
+    // handling can be called in the current image until after this call:
+    __security_init_cookie();
+
+    return __scrt_common_main_seh();
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/exe_main.cpp

@@ -0,0 +1,17 @@
+//
+// exe_main.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The mainCRTStartup() entry point, linked into client executables that
+// uses main().
+//
+#define _SCRT_STARTUP_MAIN
+#include "exe_common.inl"
+
+
+
+extern "C" DWORD mainCRTStartup(LPVOID)
+{
+    return __scrt_common_main();
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/exe_winmain.cpp

@@ -0,0 +1,17 @@
+//
+// exe_winmain.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The WinMainCRTStartup() entry point, linked into a client executable that
+// uses WinMain().
+//
+#define _SCRT_STARTUP_WINMAIN
+#include "exe_common.inl"
+
+
+
+extern "C" DWORD WinMainCRTStartup(LPVOID)
+{
+    return __scrt_common_main();
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/exe_wmain.cpp

@@ -0,0 +1,17 @@
+//
+// exe_wmain.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The wmainCRTStartup() entry point, linked into client executables that
+// uses wmain().
+//
+#define _SCRT_STARTUP_WMAIN
+#include "exe_common.inl"
+
+
+
+extern "C" DWORD wmainCRTStartup(LPVOID)
+{
+    return __scrt_common_main();
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/exe_wwinmain.cpp

@@ -0,0 +1,17 @@
+//
+// exe_wwinmain.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The wWinMainCRTStartup() entry point, linked into client executables that
+// uses wWinMain().
+//
+#define _SCRT_STARTUP_WWINMAIN
+#include "exe_common.inl"
+
+
+
+extern "C" DWORD wWinMainCRTStartup(LPVOID)
+{
+    return __scrt_common_main();
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/file_mode.cpp

@@ -0,0 +1,17 @@
+//
+// file_mode.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Gets the default file open mode, used during executable startup.  This
+// behavior is overridable at link-time by linking with one of the link options.
+//
+#include <vcruntime.h>
+#include <fcntl.h>
+
+
+
+extern "C" int __CRTDECL _get_startup_file_mode()
+{
+    return _O_TEXT;
+}

miniMSVC/VC/Tools/MSVC/14.42.34433/crt/src/vcruntime/fltused.cpp

@@ -0,0 +1,9 @@
+//
+// fltused.cpp
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Default definition of _fltused.
+//
+
+extern "C" int _fltused{0x9875};