[ros-diffs] [reactos] 02/33: [UCRT] Import Microsoft.Windows.SDK.CRTSource version 10.0.22621.3

16 Jan 2025

diff --git a/sdk/include/ucrt/assert.h b/sdk/include/ucrt/assert.h
new file mode 100644
index 00000000000..be5dbfca7f8
--- /dev/null
+++ b/sdk/include/ucrt/assert.h
@@ -0,0 +1,50 @@
+//
+// assert.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the assert macro and related functionality.
+//
+#if defined _VCRT_BUILD && !defined _ASSERT_OK
+    #error assert.h not for CRT internal use
+#endif
+
+#include <corecrt.h>
+
+#pragma warning(push)
+#pragma warning(disable: _UCRT_DISABLED_WARNINGS)
+_UCRT_DISABLE_CLANG_WARNINGS
+_CRT_BEGIN_C_HEADER
+
+#if _CRT_HAS_C11
+
+#define static_assert _Static_assert
+
+#endif // _CRT_HAS_C11
+
+#undef assert
+
+#ifdef NDEBUG
+
+    #define assert(expression) ((void)0)
+
+#else
+
+    _ACRTIMP void __cdecl _wassert(
+        _In_z_ wchar_t const* _Message,
+        _In_z_ wchar_t const* _File,
+        _In_   unsigned       _Line
+        );
+
+    #define assert(expression) (void)(                                                   
   \
+            (!!(expression)) ||                                                          
   \
+            (_wassert(_CRT_WIDE(#expression), _CRT_WIDE(__FILE__), (unsigned)(__LINE__)),
0) \
+        )
+
+#endif
+
+
+
+_CRT_END_C_HEADER
+_UCRT_RESTORE_CLANG_WARNINGS
+#pragma warning(pop) // _UCRT_DISABLED_WARNINGS
diff --git a/sdk/include/ucrt/complex.h b/sdk/include/ucrt/complex.h
new file mode 100644
index 00000000000..72ee07b1c42
--- /dev/null
+++ b/sdk/include/ucrt/complex.h
@@ -0,0 +1,580 @@
+//
+// complex.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The complex math library.
+//
+#pragma once
+#ifndef _COMPLEX
+#define _COMPLEX
+
+#include <corecrt.h>
+
+#if (_CRT_HAS_CXX17 == 1) && !defined(_CRT_USE_C_COMPLEX_H)
+#include <ccomplex>
+#else // ^^^^ /std:c++17 ^^^^ // vvvv _CRT_USE_C_COMPLEX_H vvvv
+
+#pragma warning(push)
+#pragma warning(disable: _UCRT_DISABLED_WARNINGS)
+_UCRT_DISABLE_CLANG_WARNINGS
+
+_CRT_BEGIN_C_HEADER
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Types
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#ifndef _C_COMPLEX_T
+    #define _C_COMPLEX_T
+    typedef struct _C_double_complex
+    {
+        double _Val[2];
+    } _C_double_complex;
+
+    typedef struct _C_float_complex
+    {
+        float _Val[2];
+    } _C_float_complex;
+
+    typedef struct _C_ldouble_complex
+    {
+        long double _Val[2];
+    } _C_ldouble_complex;
+#endif
+
+typedef _C_double_complex  _Dcomplex;
+typedef _C_float_complex   _Fcomplex;
+typedef _C_ldouble_complex _Lcomplex;
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Macros
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#define _DCOMPLEX_(re, im)  _Cbuild(re, im)
+#define _FCOMPLEX_(re, im)  _FCbuild(re, im)
+#define _LCOMPLEX_(re, im)  _LCbuild(re, im)
+
+#define _Complex_I _FCbuild(0.0F, 1.0F)
+#define I          _Complex_I
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Functions
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+_ACRTIMP double    __cdecl cabs(_In_ _Dcomplex _Z);
+_ACRTIMP _Dcomplex __cdecl cacos(_In_ _Dcomplex _Z);
+_ACRTIMP _Dcomplex __cdecl cacosh(_In_ _Dcomplex _Z);
+_ACRTIMP double    __cdecl carg(_In_ _Dcomplex _Z);
+_ACRTIMP _Dcomplex __cdecl casin(_In_ _Dcomplex _Z);
+_ACRTIMP _Dcomplex __cdecl casinh(_In_ _Dcomplex _Z);
+_ACRTIMP _Dcomplex __cdecl catan(_In_ _Dcomplex _Z);
+_ACRTIMP _Dcomplex __cdecl catanh(_In_ _Dcomplex _Z);
+_ACRTIMP _Dcomplex __cdecl ccos(_In_ _Dcomplex _Z);
+_ACRTIMP _Dcomplex __cdecl ccosh(_In_ _Dcomplex _Z);
+_ACRTIMP _Dcomplex __cdecl cexp(_In_ _Dcomplex _Z);
+_ACRTIMP double    __cdecl cimag(_In_ _Dcomplex _Z);
+_ACRTIMP _Dcomplex __cdecl clog(_In_ _Dcomplex _Z);
+_ACRTIMP _Dcomplex __cdecl clog10(_In_ _Dcomplex _Z);
+_ACRTIMP _Dcomplex __cdecl conj(_In_ _Dcomplex _Z);
+_ACRTIMP _Dcomplex __cdecl cpow(_In_ _Dcomplex _X, _In_ _Dcomplex _Y);
+_ACRTIMP _Dcomplex __cdecl cproj(_In_ _Dcomplex _Z);
+_ACRTIMP double    __cdecl creal(_In_ _Dcomplex _Z);
+_ACRTIMP _Dcomplex __cdecl csin(_In_ _Dcomplex _Z);
+_ACRTIMP _Dcomplex __cdecl csinh(_In_ _Dcomplex _Z);
+_ACRTIMP _Dcomplex __cdecl csqrt(_In_ _Dcomplex _Z);
+_ACRTIMP _Dcomplex __cdecl ctan(_In_ _Dcomplex _Z);
+_ACRTIMP _Dcomplex __cdecl ctanh(_In_ _Dcomplex _Z);
+_ACRTIMP double    __cdecl norm(_In_ _Dcomplex _Z);
+
+_ACRTIMP float     __cdecl cabsf(_In_ _Fcomplex _Z);
+_ACRTIMP _Fcomplex __cdecl cacosf(_In_ _Fcomplex _Z);
+_ACRTIMP _Fcomplex __cdecl cacoshf(_In_ _Fcomplex _Z);
+_ACRTIMP float     __cdecl cargf(_In_ _Fcomplex _Z);
+_ACRTIMP _Fcomplex __cdecl casinf(_In_ _Fcomplex _Z);
+_ACRTIMP _Fcomplex __cdecl casinhf(_In_ _Fcomplex _Z);
+_ACRTIMP _Fcomplex __cdecl catanf(_In_ _Fcomplex _Z);
+_ACRTIMP _Fcomplex __cdecl catanhf(_In_ _Fcomplex _Z);
+_ACRTIMP _Fcomplex __cdecl ccosf(_In_ _Fcomplex _Z);
+_ACRTIMP _Fcomplex __cdecl ccoshf(_In_ _Fcomplex _Z);
+_ACRTIMP _Fcomplex __cdecl cexpf(_In_ _Fcomplex _Z);
+_ACRTIMP float     __cdecl cimagf(_In_ _Fcomplex _Z);
+_ACRTIMP _Fcomplex __cdecl clogf(_In_ _Fcomplex _Z);
+_ACRTIMP _Fcomplex __cdecl clog10f(_In_ _Fcomplex _Z);
+_ACRTIMP _Fcomplex __cdecl conjf(_In_ _Fcomplex _Z);
+_ACRTIMP _Fcomplex __cdecl cpowf(_In_ _Fcomplex _X, _In_ _Fcomplex _Y);
+_ACRTIMP _Fcomplex __cdecl cprojf(_In_ _Fcomplex _Z);
+_ACRTIMP float     __cdecl crealf(_In_ _Fcomplex _Z);
+_ACRTIMP _Fcomplex __cdecl csinf(_In_ _Fcomplex _Z);
+_ACRTIMP _Fcomplex __cdecl csinhf(_In_ _Fcomplex _Z);
+_ACRTIMP _Fcomplex __cdecl csqrtf(_In_ _Fcomplex _Z);
+_ACRTIMP _Fcomplex __cdecl ctanf(_In_ _Fcomplex _Z);
+_ACRTIMP _Fcomplex __cdecl ctanhf(_In_ _Fcomplex _Z);
+_ACRTIMP float     __cdecl normf(_In_ _Fcomplex _Z);
+
+_ACRTIMP long double __cdecl cabsl(_In_ _Lcomplex _Z);
+_ACRTIMP _Lcomplex   __cdecl cacosl(_In_ _Lcomplex _Z);
+_ACRTIMP _Lcomplex   __cdecl cacoshl(_In_ _Lcomplex _Z);
+_ACRTIMP long double __cdecl cargl(_In_ _Lcomplex _Z);
+_ACRTIMP _Lcomplex   __cdecl casinl(_In_ _Lcomplex _Z);
+_ACRTIMP _Lcomplex   __cdecl casinhl(_In_ _Lcomplex _Z);
+_ACRTIMP _Lcomplex   __cdecl catanl(_In_ _Lcomplex _Z);
+_ACRTIMP _Lcomplex   __cdecl catanhl(_In_ _Lcomplex _Z);
+_ACRTIMP _Lcomplex   __cdecl ccosl(_In_ _Lcomplex _Z);
+_ACRTIMP _Lcomplex   __cdecl ccoshl(_In_ _Lcomplex _Z);
+_ACRTIMP _Lcomplex   __cdecl cexpl(_In_ _Lcomplex _Z);
+_ACRTIMP long double __cdecl cimagl(_In_ _Lcomplex _Z);
+_ACRTIMP _Lcomplex   __cdecl clogl(_In_ _Lcomplex _Z);
+_ACRTIMP _Lcomplex   __cdecl clog10l(_In_ _Lcomplex _Z);
+_ACRTIMP _Lcomplex   __cdecl conjl(_In_ _Lcomplex _Z);
+_ACRTIMP _Lcomplex   __cdecl cpowl(_In_ _Lcomplex _X, _In_ _Lcomplex _Y);
+_ACRTIMP _Lcomplex   __cdecl cprojl(_In_ _Lcomplex _Z);
+_ACRTIMP long double __cdecl creall(_In_ _Lcomplex _Z);
+_ACRTIMP _Lcomplex   __cdecl csinl(_In_ _Lcomplex _Z);
+_ACRTIMP _Lcomplex   __cdecl csinhl(_In_ _Lcomplex _Z);
+_ACRTIMP _Lcomplex   __cdecl csqrtl(_In_ _Lcomplex _Z);
+_ACRTIMP _Lcomplex   __cdecl ctanl(_In_ _Lcomplex _Z);
+_ACRTIMP _Lcomplex   __cdecl ctanhl(_In_ _Lcomplex _Z);
+_ACRTIMP long double __cdecl norml(_In_ _Lcomplex _Z);
+
+_ACRTIMP _Dcomplex __cdecl _Cbuild(_In_ double _Re, _In_ double _Im);
+_ACRTIMP _Dcomplex __cdecl _Cmulcc(_In_ _Dcomplex _X, _In_ _Dcomplex _Y);
+_ACRTIMP _Dcomplex __cdecl _Cmulcr(_In_ _Dcomplex _X, _In_ double _Y);
+
+_ACRTIMP _Fcomplex __cdecl _FCbuild(_In_ float _Re, _In_ float _Im);
+_ACRTIMP _Fcomplex __cdecl _FCmulcc(_In_ _Fcomplex _X, _In_ _Fcomplex _Y);
+_ACRTIMP _Fcomplex __cdecl _FCmulcr(_In_ _Fcomplex _X, _In_ float _Y);
+
+_ACRTIMP _Lcomplex __cdecl _LCbuild(_In_ long double _Re, _In_ long double _Im);
+_ACRTIMP _Lcomplex __cdecl _LCmulcc(_In_ _Lcomplex _X, _In_ _Lcomplex _Y);
+_ACRTIMP _Lcomplex __cdecl _LCmulcr(_In_ _Lcomplex _X, _In_ long double _Y);
+
+
+
+#ifdef __cplusplus
+extern "C++"
+{
+    //-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    //
+    // double complex overloads
+    //
+    //-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    inline _Dcomplex __CRTDECL acos(_In_ _Dcomplex _X) throw()
+    {
+        return cacos(_X);
+    }
+
+    inline _Dcomplex __CRTDECL acosh(_In_ _Dcomplex _X) throw()
+    {
+        return cacosh(_X);
+    }
+
+    inline _Dcomplex __CRTDECL asin(_In_ _Dcomplex _X) throw()
+    {
+        return casin(_X);
+    }
+
+    inline _Dcomplex __CRTDECL asinh(_In_ _Dcomplex _X) throw()
+    {
+        return casinh(_X);
+    }
+
+    inline _Dcomplex __CRTDECL atan(_In_ _Dcomplex _X) throw()
+    {
+        return catan(_X);
+    }
+
+    inline _Dcomplex __CRTDECL atanh(_In_ _Dcomplex _X) throw()
+    {
+        return catanh(_X);
+    }
+
+    inline _Dcomplex __CRTDECL cos(_In_ _Dcomplex _X) throw()
+    {
+        return ccos(_X);
+    }
+
+    inline _Dcomplex __CRTDECL cosh(_In_ _Dcomplex _X) throw()
+    {
+        return ccosh(_X);
+    }
+
+    inline _Dcomplex __CRTDECL proj(_In_ _Dcomplex _X) throw()
+    {
+        return cproj(_X);
+    }
+
+    inline _Dcomplex __CRTDECL exp(_In_ _Dcomplex _X) throw()
+    {
+        return cexp(_X);
+    }
+
+    inline _Dcomplex __CRTDECL log(_In_ _Dcomplex _X) throw()
+    {
+        return clog(_X);
+    }
+
+    inline _Dcomplex __CRTDECL log10(_In_ _Dcomplex _X) throw()
+    {
+        return clog10(_X);
+    }
+
+    inline _Dcomplex __CRTDECL pow(_In_ _Dcomplex _X, _In_ _Dcomplex _Y) throw()
+    {
+        return cpow(_X, _Y);
+    }
+
+    inline _Dcomplex __CRTDECL sin(_In_ _Dcomplex _X) throw()
+    {
+        return csin(_X);
+    }
+
+    inline _Dcomplex __CRTDECL sinh(_In_ _Dcomplex _X) throw()
+    {
+        return csinh(_X);
+    }
+
+    inline _Dcomplex __CRTDECL sqrt(_In_ _Dcomplex _X) throw()
+    {
+        return csqrt(_X);
+    }
+
+    inline _Dcomplex __CRTDECL tan(_In_ _Dcomplex _X) throw()
+    {
+        return ctan(_X);
+    }
+
+    inline _Dcomplex __CRTDECL tanh(_In_ _Dcomplex _X) throw()
+    {
+        return ctanh(_X);
+    }
+
+    inline double __CRTDECL abs(_In_ _Dcomplex _X) throw()
+    {
+        return cabs(_X);
+    }
+
+    inline double __CRTDECL arg(_In_ _Dcomplex _X) throw()
+    {
+        return carg(_X);
+    }
+
+    inline double __CRTDECL imag(_In_ _Dcomplex _X) throw()
+    {
+        return cimag(_X);
+    }
+
+    inline double __CRTDECL real(_In_ _Dcomplex _X) throw()
+    {
+        return creal(_X);
+    }
+
+
+
+    //-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    //
+    // float complex overloads
+    //
+    //-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    inline _Fcomplex __CRTDECL acos(_In_ _Fcomplex _X) throw()
+    {
+        return cacosf(_X);
+    }
+
+    inline _Fcomplex __CRTDECL acosh(_In_ _Fcomplex _X) throw()
+    {
+        return cacoshf(_X);
+    }
+
+    inline _Fcomplex __CRTDECL asin(_In_ _Fcomplex _X) throw()
+    {
+        return casinf(_X);
+    }
+
+    inline _Fcomplex __CRTDECL asinh(_In_ _Fcomplex _X) throw()
+    {
+        return casinhf(_X);
+    }
+
+    inline _Fcomplex __CRTDECL atan(_In_ _Fcomplex _X) throw()
+    {
+        return catanf(_X);
+    }
+
+    inline _Fcomplex __CRTDECL atanh(_In_ _Fcomplex _X) throw()
+    {
+        return catanhf(_X);
+    }
+
+    inline _Fcomplex __CRTDECL conj(_In_ _Fcomplex _X) throw()
+    {
+        return conjf(_X);
+    }
+
+    inline _Fcomplex __CRTDECL cos(_In_ _Fcomplex _X) throw()
+    {
+        return ccosf(_X);
+    }
+
+    inline _Fcomplex __CRTDECL cosh(_In_ _Fcomplex _X) throw()
+    {
+        return ccoshf(_X);
+    }
+
+    inline _Fcomplex __CRTDECL cproj(_In_ _Fcomplex _X) throw()
+    {
+        return cprojf(_X);
+    }
+
+    inline _Fcomplex __CRTDECL proj(_In_ _Fcomplex _X) throw()
+    {
+        return cprojf(_X);
+    }
+
+    inline _Fcomplex __CRTDECL exp(_In_ _Fcomplex _X) throw()
+    {
+        return cexpf(_X);
+    }
+
+    inline _Fcomplex __CRTDECL log(_In_ _Fcomplex _X) throw()
+    {
+        return clogf(_X);
+    }
+
+    inline _Fcomplex __CRTDECL log10(_In_ _Fcomplex _X) throw()
+    {
+        return clog10f(_X);
+    }
+
+    inline float __CRTDECL norm(_In_ _Fcomplex _X) throw()
+    {
+        return normf(_X);
+    }
+
+    inline _Fcomplex __CRTDECL pow(_In_ _Fcomplex _X, _In_ _Fcomplex _Y) throw()
+    {
+        return cpowf(_X, _Y);
+    }
+
+    inline _Fcomplex __CRTDECL sin(_In_ _Fcomplex _X) throw()
+    {
+        return csinf(_X);
+    }
+
+    inline _Fcomplex __CRTDECL sinh(_In_ _Fcomplex _X) throw()
+    {
+        return csinhf(_X);
+    }
+
+    inline _Fcomplex __CRTDECL sqrt(_In_ _Fcomplex _X) throw()
+    {
+        return csqrtf(_X);
+    }
+
+    inline _Fcomplex __CRTDECL tan(_In_ _Fcomplex _X) throw()
+    {
+        return ctanf(_X);
+    }
+
+    inline _Fcomplex __CRTDECL tanh(_In_ _Fcomplex _X) throw()
+    {
+        return ctanhf(_X);
+    }
+
+    inline float __CRTDECL abs(_In_ _Fcomplex _X) throw()
+    {
+        return cabsf(_X);
+    }
+
+    inline float __CRTDECL arg(_In_ _Fcomplex _X) throw()
+    {
+        return cargf(_X);
+    }
+
+    inline float __CRTDECL carg(_In_ _Fcomplex _X) throw()
+    {
+        return cargf(_X);
+    }
+
+    inline float __CRTDECL cimag(_In_ _Fcomplex _X) throw()
+    {
+        return cimagf(_X);
+    }
+
+    inline float __CRTDECL creal(_In_ _Fcomplex _X) throw()
+    {
+        return crealf(_X);
+    }
+
+    inline float __CRTDECL imag(_In_ _Fcomplex _X) throw()
+    {
+        return cimagf(_X);
+    }
+
+    inline float __CRTDECL real(_In_ _Fcomplex _X) throw()
+    {
+        return crealf(_X);
+    }
+
+
+
+    //-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    //
+    // long double complex overloads
+    //
+    //-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    inline _Lcomplex __CRTDECL acos(_In_ _Lcomplex _X) throw()
+    {
+        return cacosl(_X);
+    }
+
+    inline _Lcomplex __CRTDECL acosh(_In_ _Lcomplex _X) throw()
+    {
+        return cacoshl(_X);
+    }
+
+    inline _Lcomplex __CRTDECL asin(_In_ _Lcomplex _X) throw()
+    {
+        return casinl(_X);
+    }
+
+    inline _Lcomplex __CRTDECL asinh(_In_ _Lcomplex _X) throw()
+    {
+        return casinhl(_X);
+    }
+
+    inline _Lcomplex __CRTDECL atan(_In_ _Lcomplex _X) throw()
+    {
+        return catanl(_X);
+    }
+
+    inline _Lcomplex __CRTDECL atanh(_In_ _Lcomplex _X) throw()
+    {
+        return catanhl(_X);
+    }
+
+    inline _Lcomplex __CRTDECL conj(_In_ _Lcomplex _X) throw()
+    {
+        return conjl(_X);
+    }
+
+    inline _Lcomplex __CRTDECL cos(_In_ _Lcomplex _X) throw()
+    {
+        return ccosl(_X);
+    }
+
+    inline _Lcomplex __CRTDECL cosh(_In_ _Lcomplex _X) throw()
+    {
+        return ccoshl(_X);
+    }
+
+    inline _Lcomplex __CRTDECL cproj(_In_ _Lcomplex _X) throw()
+    {
+        return cprojl(_X);
+    }
+
+    inline _Lcomplex __CRTDECL proj(_In_ _Lcomplex _X) throw()
+    {
+        return cprojl(_X);
+    }
+
+    inline _Lcomplex __CRTDECL exp(_In_ _Lcomplex _X) throw()
+    {
+        return cexpl(_X);
+    }
+
+    inline _Lcomplex __CRTDECL log(_In_ _Lcomplex _X) throw()
+    {
+        return clogl(_X);
+    }
+
+    inline _Lcomplex __CRTDECL log10(_In_ _Lcomplex _X) throw()
+    {
+        return clog10l(_X);
+    }
+
+    inline long double __CRTDECL norm(_In_ _Lcomplex _X) throw()
+    {
+        return norml(_X);
+    }
+
+    inline _Lcomplex __CRTDECL pow(_In_ _Lcomplex _X, _In_ _Lcomplex _Y) throw()
+    {
+        return cpowl(_X, _Y);
+    }
+
+    inline _Lcomplex __CRTDECL sin(_In_ _Lcomplex _X) throw()
+    {
+        return csinl(_X);
+    }
+
+    inline _Lcomplex __CRTDECL sinh(_In_ _Lcomplex _X) throw()
+    {
+        return csinhl(_X);
+    }
+
+    inline _Lcomplex __CRTDECL sqrt(_In_ _Lcomplex _X) throw()
+    {
+        return csqrtl(_X);
+    }
+
+    inline _Lcomplex __CRTDECL tan(_In_ _Lcomplex _X) throw()
+    {
+        return ctanl(_X);
+    }
+
+    inline _Lcomplex __CRTDECL tanh(_In_ _Lcomplex _X) throw()
+    {
+        return ctanhl(_X);
+    }
+
+    inline long double __CRTDECL abs(_In_ _Lcomplex _X) throw()
+    {
+        return cabsl(_X);
+    }
+
+    inline long double __CRTDECL arg(_In_ _Lcomplex _X) throw()
+    {
+        return cargl(_X);
+    }
+
+    inline long double __CRTDECL carg(_In_ _Lcomplex _X) throw()
+    {
+        return cargl(_X);
+    }
+
+    inline long double __CRTDECL cimag(_In_ _Lcomplex _X) throw()
+    {
+        return cimagl(_X);
+    }
+
+    inline long double __CRTDECL creal(_In_ _Lcomplex _X) throw()
+    {
+        return creall(_X);
+    }
+
+    inline long double __CRTDECL imag(_In_ _Lcomplex _X) throw()
+    {
+        return cimagl(_X);
+    }
+
+    inline long double __CRTDECL real(_In_ _Lcomplex _X) throw()
+    {
+        return creall(_X);
+    }
+
+} // extern "C++"
+#endif // __cplusplus
+
+_CRT_END_C_HEADER
+_UCRT_RESTORE_CLANG_WARNINGS
+#pragma warning(pop) // _UCRT_DISABLED_WARNINGS
+#endif // (_CRT_HAS_CXX17 == 1) && !defined(_CRT_USE_C_COMPLEX_H)
+#endif // _COMPLEX
diff --git a/sdk/include/ucrt/conio.h b/sdk/include/ucrt/conio.h
new file mode 100644
index 00000000000..a0f5e9c192c
--- /dev/null
+++ b/sdk/include/ucrt/conio.h
@@ -0,0 +1,504 @@
+//
+// conio.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// This file declares the direct console I/O functions.
+//
+#pragma once
+#ifndef _INC_CONIO // include guard for 3rd party interop
+#define _INC_CONIO
+
+#include <corecrt.h>
+#include <corecrt_wconio.h>
+
+#pragma warning(push)
+#pragma warning(disable: _UCRT_DISABLED_WARNINGS)
+_UCRT_DISABLE_CLANG_WARNINGS
+
+_CRT_BEGIN_C_HEADER
+
+    _Check_return_wat_
+    _Success_(_BufferCount > 0)
+    _DCRTIMP errno_t __cdecl _cgets_s(
+        _Out_writes_z_(_BufferCount) char*   _Buffer,
+        _In_                         size_t  _BufferCount,
+        _Out_                        size_t* _SizeRead
+        );
+
+    __DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_1(
+        _Success_(return == 0)
+        errno_t, _cgets_s,
+        _Out_writes_z_(*_Buffer) char,    _Buffer,
+        _Out_                    size_t*, _SizeRead
+        )
+
+    _Check_return_opt_
+    _DCRTIMP int __cdecl _cputs(
+        _In_z_ char const* _Buffer
+        );
+
+    //-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    //
+    // Narrow Character Formatted Output Functions (Console)
+    //
+    //-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    _Check_return_opt_
+    _DCRTIMP int __cdecl __conio_common_vcprintf(
+        _In_                                    unsigned __int64 _Options,
+        _In_z_ _Printf_format_string_params_(2) char const*      _Format,
+        _In_opt_                                _locale_t        _Locale,
+                                                va_list          _ArgList
+        );
+
+    _Check_return_opt_
+    _DCRTIMP int __cdecl __conio_common_vcprintf_s(
+        _In_                                    unsigned __int64 _Options,
+        _In_z_ _Printf_format_string_params_(2) char const*      _Format,
+        _In_opt_                                _locale_t        _Locale,
+                                                va_list          _ArgList
+        );
+
+    _Check_return_opt_
+    _DCRTIMP int __cdecl __conio_common_vcprintf_p(
+        _In_                                    unsigned __int64 _Options,
+        _In_z_ _Printf_format_string_params_(2) char const*      _Format,
+        _In_opt_                                _locale_t        _Locale,
+                                                va_list          _ArgList
+        );
+
+    _Check_return_opt_
+    _CRT_STDIO_INLINE int __CRTDECL _vcprintf_l(
+        _In_z_ _Printf_format_string_params_(2) char const* const _Format,
+        _In_opt_                                _locale_t   const _Locale,
+                                                va_list           _ArgList
+        )
+#if defined _NO_CRT_STDIO_INLINE
+;
+#else
+    {
+        return __conio_common_vcprintf(
+            _CRT_INTERNAL_LOCAL_PRINTF_OPTIONS,
+            _Format, _Locale, _ArgList);
+    }
+#endif
+
+    _Check_return_opt_
+    _CRT_STDIO_INLINE int __CRTDECL _vcprintf(
+        _In_z_ _Printf_format_string_ char const* const _Format,
+                                      va_list           _ArgList
+        )
+#if defined _NO_CRT_STDIO_INLINE
+;
+#else
+    {
+        return _vcprintf_l(_Format, NULL, _ArgList);
+    }
+#endif
+
+    _Check_return_opt_
+    _CRT_STDIO_INLINE int __CRTDECL _vcprintf_s_l(
+        _In_z_ _Printf_format_string_params_(2) char const* const _Format,
+        _In_opt_                                _locale_t   const _Locale,
+                                                va_list           _ArgList
+        )
+#if defined _NO_CRT_STDIO_INLINE
+;
+#else
+    {
+        return __conio_common_vcprintf_s(
+            _CRT_INTERNAL_LOCAL_PRINTF_OPTIONS,
+            _Format, _Locale, _ArgList);
+    }
+#endif
+
+    _Check_return_opt_
+    _CRT_STDIO_INLINE int __CRTDECL _vcprintf_s(
+        _In_z_ _Printf_format_string_ char const* const _Format,
+                                      va_list           _ArgList
+        )
+#if defined _NO_CRT_STDIO_INLINE
+;
+#else
+    {
+        return _vcprintf_s_l(_Format, NULL, _ArgList);
+    }
+#endif
+
+    _Check_return_opt_
+    _CRT_STDIO_INLINE int __CRTDECL _vcprintf_p_l(
+        _In_z_ _Printf_format_string_params_(2) char const* const _Format,
+        _In_opt_                                _locale_t   const _Locale,
+                                                va_list           _ArgList
+        )
+#if defined _NO_CRT_STDIO_INLINE
+;
+#else
+    {
+        return __conio_common_vcprintf_p(
+            _CRT_INTERNAL_LOCAL_PRINTF_OPTIONS,
+            _Format, _Locale, _ArgList);
+    }
+#endif
+
+    _Check_return_opt_
+    _CRT_STDIO_INLINE int __CRTDECL _vcprintf_p(
+        _In_z_ char const* const _Format,
+               va_list           _ArgList
+        )
+#if defined _NO_CRT_STDIO_INLINE
+;
+#else
+    {
+        return _vcprintf_p_l(_Format, NULL, _ArgList);
+    }
+#endif
+
+    _Check_return_opt_
+    _CRT_STDIO_INLINE int __CRTDECL _cprintf_l(
+        _In_z_ _Printf_format_string_params_(0) char const* const _Format,
+        _In_opt_                                _locale_t   const _Locale,
+        ...)
+#if defined _NO_CRT_STDIO_INLINE
+;
+#else
+    {
+        int _Result;
+        va_list _ArgList;
+        __crt_va_start(_ArgList, _Locale);
+        _Result = _vcprintf_l(_Format, _Locale, _ArgList);
+        __crt_va_end(_ArgList);
+        return _Result;
+    }
+#endif
+
+    _Check_return_opt_
+    _CRT_STDIO_INLINE int __CRTDECL _cprintf(
+        _In_z_ _Printf_format_string_ char const* const _Format,
+        ...)
+#if defined _NO_CRT_STDIO_INLINE
+;
+#else
+    {
+        int _Result;
+        va_list _ArgList;
+        __crt_va_start(_ArgList, _Format);
+        _Result = _vcprintf_l(_Format, NULL, _ArgList);
+        __crt_va_end(_ArgList);
+        return _Result;
+    }
+#endif
+
+    _Check_return_opt_
+    _CRT_STDIO_INLINE int __CRTDECL _cprintf_s_l(
+        _In_z_ _Printf_format_string_params_(0) char const* const _Format,
+        _In_opt_                                _locale_t   const _Locale,
+        ...)
+#if defined _NO_CRT_STDIO_INLINE
+;
+#else
+    {
+        int _Result;
+        va_list _ArgList;
+        __crt_va_start(_ArgList, _Locale);
+        _Result = _vcprintf_s_l(_Format, _Locale, _ArgList);
+        __crt_va_end(_ArgList);
+        return _Result;
+    }
+#endif
+
+    _Check_return_opt_
+    _CRT_STDIO_INLINE int __CRTDECL _cprintf_s(
+        _In_z_ _Printf_format_string_ char const* const _Format,
+        ...)
+#if defined _NO_CRT_STDIO_INLINE
+;
+#else
+    {
+        int _Result;
+        va_list _ArgList;
+        __crt_va_start(_ArgList, _Format);
+        _Result = _vcprintf_s_l(_Format, NULL, _ArgList);
+        __crt_va_end(_ArgList);
+        return _Result;
+    }
+#endif
+
+    _Check_return_opt_
+    _CRT_STDIO_INLINE int __CRTDECL _cprintf_p_l(
+        _In_z_ _Printf_format_string_params_(0) char const* const _Format,
+        _In_opt_                                _locale_t   const _Locale,
+        ...)
+#if defined _NO_CRT_STDIO_INLINE
+;
+#else
+    {
+        int _Result;
+        va_list _ArgList;
+        __crt_va_start(_ArgList, _Locale);
+        _Result = _vcprintf_p_l(_Format, _Locale, _ArgList);
+        __crt_va_end(_ArgList);
+        return _Result;
+    }
+#endif
+
+    _Check_return_opt_
+    _CRT_STDIO_INLINE int __CRTDECL _cprintf_p(
+        _In_z_ _Printf_format_string_ char const* const _Format,
+        ...)
+#if defined _NO_CRT_STDIO_INLINE
+;
+#else
+    {
+        int _Result;
+        va_list _ArgList;
+        __crt_va_start(_ArgList, _Format);
+        _Result = _vcprintf_p_l(_Format, NULL, _ArgList);
+        __crt_va_end(_ArgList);
+        return _Result;
+    }
+#endif
+
+
+    //-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    //
+    // Narrow Character Formatted Input Functions (Console)
+    //
+    //-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    _Check_return_opt_
+    _DCRTIMP int __cdecl __conio_common_vcscanf(
+        _In_                                   unsigned __int64 _Options,
+        _In_z_ _Scanf_format_string_params_(2) char const*      _Format,
+        _In_opt_                               _locale_t        _Locale,
+                                               va_list          _ArgList
+        );
+
+    _Check_return_opt_ _CRT_INSECURE_DEPRECATE(_vcscanf_s_l)
+    _CRT_STDIO_INLINE int __CRTDECL _vcscanf_l(
+        _In_z_ _Scanf_format_string_params_(2) char const* const _Format,
+        _In_opt_                               _locale_t   const _Locale,
+                                               va_list           _ArgList
+        )
+#if defined _NO_CRT_STDIO_INLINE
+;
+#else
+    {
+        return __conio_common_vcscanf(
+            _CRT_INTERNAL_LOCAL_SCANF_OPTIONS,
+            _Format, _Locale, _ArgList);
+    }
+#endif
+
+    _Check_return_opt_ _CRT_INSECURE_DEPRECATE(_vcscanf_s)
+    _CRT_STDIO_INLINE int __CRTDECL _vcscanf(
+        _In_z_ _Scanf_format_string_params_(1) char const* const _Format,
+                                               va_list           _ArgList
+        )
+#if defined _NO_CRT_STDIO_INLINE
+;
+#else
+    {
+        return _vcscanf_l(_Format, NULL, _ArgList);
+    }
+#endif
+
+    _Check_return_opt_
+    _CRT_STDIO_INLINE int __CRTDECL _vcscanf_s_l(
+        _In_z_ _Scanf_format_string_params_(2) char const* const _Format,
+        _In_opt_                               _locale_t   const _Locale,
+                                               va_list           _ArgList
+        )
+#if defined _NO_CRT_STDIO_INLINE
+;
+#else
+    {
+        return __conio_common_vcscanf(
+            _CRT_INTERNAL_LOCAL_SCANF_OPTIONS | _CRT_INTERNAL_SCANF_SECURECRT,
+            _Format, _Locale, _ArgList);
+    }
+#endif
+
+    _Check_return_opt_
+    _CRT_STDIO_INLINE int __CRTDECL _vcscanf_s(
+        _In_z_ _Scanf_format_string_params_(1) char const* const _Format,
+                                               va_list           _ArgList
+        )
+#if defined _NO_CRT_STDIO_INLINE
+;
+#else
+    {
+        return _vcscanf_s_l(_Format, NULL, _ArgList);
+    }
+#endif
+
+    _Check_return_opt_ _CRT_INSECURE_DEPRECATE(_cscanf_s_l)
+    _CRT_STDIO_INLINE int __CRTDECL _cscanf_l(
+        _In_z_ _Scanf_format_string_params_(0) char const* const _Format,
+        _In_opt_                               _locale_t   const _Locale,
+        ...)
+#if defined _NO_CRT_STDIO_INLINE
+;
+#else
+    {
+        int _Result;
+        va_list _ArgList;
+        __crt_va_start(_ArgList, _Locale);
+
+        _Result = _vcscanf_l(_Format, _Locale, _ArgList);
+
+        __crt_va_end(_ArgList);
+        return _Result;
+    }
+#endif
+
+    _Check_return_opt_ _CRT_INSECURE_DEPRECATE(_cscanf_s)
+    _CRT_STDIO_INLINE int __CRTDECL _cscanf(
+        _In_z_ _Scanf_format_string_ char const* const _Format,
+        ...)
+#if defined _NO_CRT_STDIO_INLINE
+;
+#else
+    {
+        int _Result;
+        va_list _ArgList;
+        __crt_va_start(_ArgList, _Format);
+
+        _Result = _vcscanf_l(_Format, NULL, _ArgList);
+
+        __crt_va_end(_ArgList);
+        return _Result;
+    }
+#endif
+
+    _Check_return_opt_
+    _CRT_STDIO_INLINE int __CRTDECL _cscanf_s_l(
+        _In_z_ _Scanf_format_string_params_(0) char const* const _Format,
+        _In_opt_                               _locale_t   const _Locale,
+        ...)
+#if defined _NO_CRT_STDIO_INLINE
+;
+#else
+    {
+        int _Result;
+        va_list _ArgList;
+        __crt_va_start(_ArgList, _Locale);
+        _Result = _vcscanf_s_l(_Format, _Locale, _ArgList);
+        __crt_va_end(_ArgList);
+        return _Result;
+    }
+#endif
+
+    _Check_return_opt_
+    _CRT_STDIO_INLINE int __CRTDECL _cscanf_s(
+        _In_z_ _Scanf_format_string_ char const* const _Format,
+        ...)
+#if defined _NO_CRT_STDIO_INLINE
+;
+#else
+    {
+        int _Result;
+        va_list _ArgList;
+        __crt_va_start(_ArgList, _Format);
+        _Result = _vcscanf_s_l(_Format, NULL, _ArgList);
+        __crt_va_end(_ArgList);
+        return _Result;
+    }
+#endif
+
+
+    _DCRTIMP int __cdecl _kbhit(void);
+
+    _Check_return_     _DCRTIMP int __cdecl _getch(void);
+    _Check_return_     _DCRTIMP int __cdecl _getche(void);
+    _Check_return_opt_ _DCRTIMP int __cdecl _putch  (_In_ int _Ch);
+    _Check_return_opt_ _DCRTIMP int __cdecl _ungetch(_In_ int _Ch);
+
+    _Check_return_     _DCRTIMP int __cdecl _getch_nolock  (void);
+    _Check_return_     _DCRTIMP int __cdecl _getche_nolock (void);
+    _Check_return_opt_ _DCRTIMP int __cdecl _putch_nolock  (_In_ int _Ch);
+    _Check_return_opt_ _DCRTIMP int __cdecl _ungetch_nolock(_In_ int _Ch);
+
+    #if defined(_CRT_INTERNAL_NONSTDC_NAMES) && _CRT_INTERNAL_NONSTDC_NAMES
+
+        // Suppress double-deprecation warnings:
+        #pragma warning(push)
+        #pragma warning(disable: 4141)
+
+        _Success_(return != 0)
+        _Check_return_opt_ _CRT_NONSTDC_DEPRECATE(_cgets)
_CRT_INSECURE_DEPRECATE(_cgets_s)
+        _DCRTIMP char* __cdecl cgets(
+            _At_(&_Buffer[0], _In_reads_(1))
+            _At_(&_Buffer[1], _Out_writes_(1))
+            _At_(&_Buffer[2], _Post_z_ _Out_writes_to_(_Buffer[0], _Buffer[1]))
+            char* _Buffer
+            );
+
+        #pragma warning(pop)
+
+        _Check_return_opt_ _CRT_NONSTDC_DEPRECATE(_cputs)
+        _DCRTIMP int __cdecl cputs(
+            _In_z_ char const* _String
+            );
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_getch)
+        _DCRTIMP int __cdecl getch(void);
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_getche)
+        _DCRTIMP int __cdecl getche(void);
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_kbhit)
+        _DCRTIMP int __cdecl kbhit(void);
+
+        _Check_return_opt_ _CRT_NONSTDC_DEPRECATE(_putch)
+        _DCRTIMP int __cdecl putch(
+            _In_ int _Ch
+            );
+
+        _Check_return_opt_ _CRT_NONSTDC_DEPRECATE(_ungetch)
+        _DCRTIMP int __cdecl ungetch(
+            _In_ int _Ch
+            );
+
+        _Check_return_opt_ _CRT_NONSTDC_DEPRECATE(_cprintf)
+        _CRT_STDIO_INLINE int __CRTDECL cprintf(
+            _In_z_ _Printf_format_string_ char const* const _Format,
+            ...)
+#if defined _NO_CRT_STDIO_INLINE
+;
+#else
+        {
+            int _Result;
+            va_list _ArgList;
+            __crt_va_start(_ArgList, _Format);
+            _Result = _vcprintf_l(_Format, NULL, _ArgList);
+            __crt_va_end(_ArgList);
+            return _Result;
+        }
+#endif
+
+        _Check_return_opt_ _CRT_NONSTDC_DEPRECATE(_cscanf)
+        _CRT_STDIO_INLINE int __CRTDECL cscanf(
+            _In_z_ _Scanf_format_string_ char const* const _Format,
+            ...)
+#if defined _NO_CRT_STDIO_INLINE
+;
+#else
+        {
+            int _Result;
+            va_list _ArgList;
+            __crt_va_start(_ArgList, _Format);
+
+            _Result = _vcscanf_l(_Format, NULL, _ArgList);
+
+            __crt_va_end(_ArgList);
+            return _Result;
+        }
+#endif
+
+    #endif // _CRT_INTERNAL_NONSTDC_NAMES
+
+_CRT_END_C_HEADER
+
+_UCRT_RESTORE_CLANG_WARNINGS
+#pragma warning(pop) // _UCRT_DISABLED_WARNINGS
+#endif // _INC_CONIO
diff --git a/sdk/include/ucrt/corecrt.h b/sdk/include/ucrt/corecrt.h
new file mode 100644
index 00000000000..b89f0a94c22
--- /dev/null
+++ b/sdk/include/ucrt/corecrt.h
@@ -0,0 +1,2075 @@
+//
+// corecrt.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Declarations used throughout the CoreCRT library.
+//
+#pragma once
+
+#include <vcruntime.h>
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Windows API Partitioning and ARM Desktop Support
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#ifndef _CRT_USE_WINAPI_FAMILY_DESKTOP_APP
+    #ifdef WINAPI_FAMILY
+        #include <winapifamily.h>
+        #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_SYSTEM)
+            #define _CRT_USE_WINAPI_FAMILY_DESKTOP_APP
+        #else
+            #ifdef WINAPI_FAMILY_PHONE_APP
+                #if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
+                    #define _CRT_USE_WINAPI_FAMILY_PHONE_APP
+                #endif
+            #endif
+
+            #ifdef WINAPI_FAMILY_GAMES
+                #if WINAPI_FAMILY == WINAPI_FAMILY_GAMES
+                    #define _CRT_USE_WINAPI_FAMILY_GAMES
+                #endif
+            #endif
+        #endif
+    #else
+        #define _CRT_USE_WINAPI_FAMILY_DESKTOP_APP
+    #endif
+#endif
+
+#ifndef _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE
+    #define _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE 1
+#endif
+
+#ifndef _CRT_BUILD_DESKTOP_APP
+    #ifdef _CRT_USE_WINAPI_FAMILY_DESKTOP_APP
+        #define _CRT_BUILD_DESKTOP_APP 1
+    #else
+        #define _CRT_BUILD_DESKTOP_APP 0
+    #endif
+#endif
+
+// Verify that the ARM Desktop SDK is available when building an ARM Desktop app
+#ifdef _M_ARM
+    #if _CRT_BUILD_DESKTOP_APP && !_ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE
+        #error Compiling Desktop applications for the ARM platform is not supported.
+    #endif
+#endif
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Warning Suppression
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+// C4412: function signature contains type '_locale_t';
+//        C++ objects are unsafe to pass between pure code and mixed or native. (/Wall)
+#ifndef _UCRT_DISABLED_WARNING_4412
+    #ifdef _M_CEE_PURE
+        #define _UCRT_DISABLED_WARNING_4412 4412
+    #else
+        #define _UCRT_DISABLED_WARNING_4412
+    #endif
+#endif
+
+// Use _UCRT_EXTRA_DISABLED_WARNINGS to add additional warning suppressions to UCRT
headers.
+#ifndef _UCRT_EXTRA_DISABLED_WARNINGS
+    #define _UCRT_EXTRA_DISABLED_WARNINGS
+#endif
+
+// C4324: structure was padded due to __declspec(align()) (/W4)
+// C4514: unreferenced inline function has been removed (/Wall)
+// C4574: 'MACRO' is defined to be '0': did you mean to use '#if
MACRO'? (/Wall)
+// C4668: '__cplusplus' is not defined as a preprocessor macro (/Wall)
+// C4710: function not inlined (/Wall)
+// C4793: 'function' is compiled as native code (/Wall and /W1 under /clr:pure)
+// C4820: padding after data member (/Wall)
+// C4995: name was marked #pragma deprecated
+// C4996: __declspec(deprecated)
+// C28719: Banned API, use a more robust and secure replacement.
+// C28726: Banned or deprecated API, use a more robust and secure replacement.
+// C28727: Banned API.
+#ifndef _UCRT_DISABLED_WARNINGS
+    #define _UCRT_DISABLED_WARNINGS 4324 _UCRT_DISABLED_WARNING_4412 4514 4574 4710 4793
4820 4995 4996 28719 28726 28727 _UCRT_EXTRA_DISABLED_WARNINGS
+#endif
+
+#ifndef _UCRT_DISABLE_CLANG_WARNINGS
+    #ifdef __clang__
+    // warning: declspec(deprecated) [-Wdeprecated-declarations]
+    // warning: __declspec attribute 'allocator' is not supported
[-Wignored-attributes]
+    // warning: '#pragma optimize' is not supported [-Wignored-pragma-optimize]
+    // warning: unknown pragma ignored [-Wunknown-pragmas]
+        #define _UCRT_DISABLE_CLANG_WARNINGS                                  \
+            _Pragma("clang diagnostic push")                                 
\
+            _Pragma("clang diagnostic ignored
\"-Wdeprecated-declarations\"") \
+            _Pragma("clang diagnostic ignored
\"-Wignored-attributes\"")      \
+            _Pragma("clang diagnostic ignored
\"-Wignored-pragma-optimize\"") \
+            _Pragma("clang diagnostic ignored
\"-Wunknown-pragmas\"")
+    #else // __clang__
+        #define _UCRT_DISABLE_CLANG_WARNINGS
+    #endif // __clang__
+#endif // _UCRT_DISABLE_CLANG_WARNINGS
+
+#ifndef _UCRT_RESTORE_CLANG_WARNINGS
+    #ifdef __clang__
+        #define _UCRT_RESTORE_CLANG_WARNINGS _Pragma("clang diagnostic pop")
+    #else // __clang__
+        #define _UCRT_RESTORE_CLANG_WARNINGS
+    #endif // __clang__
+#endif // _UCRT_RESTORE_CLANG_WARNINGS
+
+#pragma warning(push)
+#pragma warning(disable: _UCRT_DISABLED_WARNINGS)
+_UCRT_DISABLE_CLANG_WARNINGS
+
+_CRT_BEGIN_C_HEADER
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Annotation Macros
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#ifndef _ACRTIMP
+    #if defined _CRTIMP && !defined _VCRT_DEFINED_CRTIMP
+        #define _ACRTIMP _CRTIMP
+    #elif !defined _CORECRT_BUILD && defined _DLL
+        #define _ACRTIMP __declspec(dllimport)
+    #else
+        #define _ACRTIMP
+    #endif
+#endif
+
+// If you need the ability to remove __declspec(import) from an API, to support static
replacement,
+// declare the API using _ACRTIMP_ALT instead of _ACRTIMP.
+#ifndef _ACRTIMP_ALT
+    #define _ACRTIMP_ALT _ACRTIMP
+#endif
+
+#ifndef _DCRTIMP
+    #if defined _CRTIMP && !defined _VCRT_DEFINED_CRTIMP
+        #define _DCRTIMP _CRTIMP
+    #elif !defined _CORECRT_BUILD && defined _DLL
+        #define _DCRTIMP __declspec(dllimport)
+    #else
+        #define _DCRTIMP
+    #endif
+#endif
+
+#if defined _CRT_SUPPRESS_RESTRICT || defined _CORECRT_BUILD
+    #define _CRTRESTRICT
+#else
+    #define _CRTRESTRICT __declspec(restrict)
+#endif
+
+#if defined _MSC_VER && _MSC_VER >= 1900 && !defined _CORECRT_BUILD
+    #define _CRTALLOCATOR __declspec(allocator)
+#else
+    #define _CRTALLOCATOR
+#endif
+
+#if defined _M_CEE && defined _M_X64
+    // This is only needed when managed code is calling the native APIs,
+    // targeting the 64-bit runtime.
+    #define _CRT_JIT_INTRINSIC __declspec(jitintrinsic)
+#else
+    #define _CRT_JIT_INTRINSIC
+#endif
+
+// __declspec(guard(overflow)) enabled by /sdl compiler switch for CRT allocators
+#ifdef _GUARDOVERFLOW_CRT_ALLOCATORS
+    #define _CRT_GUARDOVERFLOW __declspec(guard(overflow))
+#else
+    #define _CRT_GUARDOVERFLOW
+#endif
+
+#if defined _DLL && (defined _M_HYBRID || defined _M_ARM64EC) && (defined
_CORECRT_BUILD || defined _VCRT_BUILD)
+    #define _CRT_HYBRIDPATCHABLE __declspec(hybrid_patchable)
+#else
+    #define _CRT_HYBRIDPATCHABLE
+#endif
+
+// The CLR requires code calling other SecurityCritical code or using SecurityCritical
types
+// to be marked as SecurityCritical.
+// _CRT_SECURITYCRITICAL_ATTRIBUTE covers this for internal function definitions.
+// _CRT_INLINE_PURE_SECURITYCRITICAL_ATTRIBUTE is for inline pure functions defined in
the header.
+// This is clr:pure-only because for mixed mode we compile inline functions as native.
+#ifdef _M_CEE_PURE
+    #define _CRT_INLINE_PURE_SECURITYCRITICAL_ATTRIBUTE
[System::Security::SecurityCritical]
+#else
+    #define _CRT_INLINE_PURE_SECURITYCRITICAL_ATTRIBUTE
+#endif
+
+#ifndef _CONST_RETURN
+    #ifdef __cplusplus
+        #define _CONST_RETURN const
+        #define _CRT_CONST_CORRECT_OVERLOADS
+    #else
+        #define _CONST_RETURN
+    #endif
+#endif
+
+#define _WConst_return _CONST_RETURN // For backwards compatibility
+
+#ifndef _CRT_ALIGN
+    #ifdef __midl
+        #define _CRT_ALIGN(x)
+    #else
+        #define _CRT_ALIGN(x) __declspec(align(x))
+    #endif
+#endif
+
+#if defined _PREFAST_ && defined _CA_SHOULD_CHECK_RETURN
+    #define _Check_return_opt_ _Check_return_
+#else
+    #define _Check_return_opt_
+#endif
+
+#if defined _PREFAST_ && defined _CA_SHOULD_CHECK_RETURN_WER
+    #define _Check_return_wat_ _Check_return_
+#else
+    #define _Check_return_wat_
+#endif
+
+#if !defined __midl && !defined MIDL_PASS && defined _PREFAST_
+    #define __crt_typefix(ctype) __declspec("SAL_typefix("
_CRT_STRINGIZE(ctype) ")")
+#else
+    #define __crt_typefix(ctype)
+#endif
+
+#ifndef _CRT_NOEXCEPT
+    #ifdef __cplusplus
+        #define _CRT_NOEXCEPT noexcept
+    #else
+        #define _CRT_NOEXCEPT
+    #endif
+#endif
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Miscellaneous Stuff
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#ifdef __cplusplus
+extern "C++"
+{
+    template<bool _Enable, typename _Ty>
+    struct _CrtEnableIf;
+
+    template<typename _Ty>
+    struct _CrtEnableIf<true, _Ty>
+    {
+        typedef _Ty _Type;
+    };
+}
+#endif
+
+#if defined __cplusplus
+    typedef bool  __crt_bool;
+#elif defined __midl
+    // MIDL understands neither bool nor _Bool.  Use char as a best-fit
+    // replacement (the differences won't matter in practice).
+    typedef char __crt_bool;
+#else
+    typedef _Bool __crt_bool;
+#endif
+
+#define _ARGMAX   100
+#define _TRUNCATE ((size_t)-1)
+#define _CRT_INT_MAX 2147483647
+#define _CRT_SIZE_MAX ((size_t)-1)
+
+#define __FILEW__     _CRT_WIDE(__FILE__)
+#define __FUNCTIONW__ _CRT_WIDE(__FUNCTION__)
+
+#ifdef __cplusplus
+    #ifndef _STATIC_ASSERT
+        #define _STATIC_ASSERT(expr) static_assert((expr), #expr)
+    #endif
+#else
+    #ifndef _STATIC_ASSERT
+        #ifdef __clang__
+            #define _STATIC_ASSERT(expr) _Static_assert((expr), #expr)
+        #else
+            #define _STATIC_ASSERT(expr) typedef char __static_assert_t[(expr) != 0]
+        #endif
+    #endif
+#endif
+
+#ifndef NULL
+    #ifdef __cplusplus
+        #define NULL 0
+    #else
+        #define NULL ((void *)0)
+    #endif
+#endif
+
+// CRT headers are included into some kinds of source files where only data type
+// definitions and macro definitions are required but function declarations and
+// inline function definitions are not.  These files include assembly files, IDL
+// files, and resource files.  The tools that process these files often have a
+// limited ability to process C and C++ code.  The _CRT_FUNCTIONS_REQUIRED macro
+// is defined to 1 when we are compiling a file that actually needs functions to
+// be declared (and defined, where applicable), and to 0 when we are compiling a
+// file that does not.  This allows us to suppress declarations and definitions
+// that are not compilable with the aforementioned tools.
+#if !defined _CRT_FUNCTIONS_REQUIRED
+    #if defined __assembler || defined __midl || defined RC_INVOKED
+        #define _CRT_FUNCTIONS_REQUIRED 0
+    #else
+        #define _CRT_FUNCTIONS_REQUIRED 1
+    #endif
+#endif
+
+#if !defined _NO_INLINING && !_CRT_FUNCTIONS_REQUIRED
+        #define _NO_INLINING // Suppress <tchar.h> inlines
+#endif
+
+#ifndef _CRT_UNUSED
+    #define _CRT_UNUSED(x) (void)x
+#endif
+
+#ifndef _CRT_HAS_CXX17
+ #ifdef _MSVC_LANG
+  #if _MSVC_LANG > 201402
+   #define _CRT_HAS_CXX17   1
+  #else /* _MSVC_LANG > 201402 */
+   #define _CRT_HAS_CXX17   0
+  #endif /* _MSVC_LANG > 201402 */
+ #else /* _MSVC_LANG */
+  #if defined __cplusplus && __cplusplus > 201402
+   #define _CRT_HAS_CXX17   1
+  #else /* __cplusplus > 201402 */
+   #define _CRT_HAS_CXX17   0
+  #endif /* __cplusplus > 201402 */
+ #endif /* _MSVC_LANG */
+#endif /* _CRT_HAS_CXX17 */
+
+#ifndef _CRT_HAS_C11
+ #if defined __STDC_VERSION__ && __STDC_VERSION__ >= 201112L
+   #define _CRT_HAS_C11 1
+ #else /* defined __STDC_VERSION__ && __STDC_VERSION__ >= 201112L */
+   #define _CRT_HAS_C11 0
+ #endif /* defined __STDC_VERSION__ && __STDC_VERSION__ >= 201112L */
+#endif /* _CRT_HAS_C11 */
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Invalid Parameter Handler
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#ifdef _DEBUG
+    _ACRTIMP void __cdecl _invalid_parameter(
+        _In_opt_z_ wchar_t const*,
+        _In_opt_z_ wchar_t const*,
+        _In_opt_z_ wchar_t const*,
+        _In_       unsigned int,
+        _In_       uintptr_t
+        );
+#endif
+
+_ACRTIMP_ALT void __cdecl _invalid_parameter_noinfo(void);
+_ACRTIMP __declspec(noreturn) void __cdecl _invalid_parameter_noinfo_noreturn(void);
+
+__declspec(noreturn)
+_ACRTIMP void __cdecl _invoke_watson(
+    _In_opt_z_ wchar_t const* _Expression,
+    _In_opt_z_ wchar_t const* _FunctionName,
+    _In_opt_z_ wchar_t const* _FileName,
+    _In_       unsigned int _LineNo,
+    _In_       uintptr_t _Reserved);
+
+#ifndef _CRT_SECURE_INVALID_PARAMETER
+    #ifdef _DEBUG
+        #define _CRT_SECURE_INVALID_PARAMETER(expr) \
+            ::_invalid_parameter(_CRT_WIDE(#expr), __FUNCTIONW__, __FILEW__, __LINE__,
0)
+    #else
+        // By default, _CRT_SECURE_INVALID_PARAMETER in retail invokes
+        // _invalid_parameter_noinfo_noreturn(), which is marked
+        // __declspec(noreturn) and does not return control to the application.
+        // Even if _set_invalid_parameter_handler() is used to set a new invalid
+        // parameter handler which does return control to the application,
+        // _invalid_parameter_noinfo_noreturn() will terminate the application
+        // and invoke Watson. You can overwrite the definition of
+        // _CRT_SECURE_INVALID_PARAMETER if you need.
+        //
+        // _CRT_SECURE_INVALID_PARAMETER is used in the Standard C++ Libraries
+        // and the SafeInt library.
+        #define _CRT_SECURE_INVALID_PARAMETER(expr) \
+            ::_invalid_parameter_noinfo_noreturn()
+    #endif
+#endif
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Deprecation and Warnings
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#define _CRT_WARNING_MESSAGE(NUMBER, MESSAGE) \
+    __FILE__ "(" _CRT_STRINGIZE(__LINE__) "): warning " NUMBER
": " MESSAGE
+
+#if ( defined _CRT_DECLARE_NONSTDC_NAMES && _CRT_DECLARE_NONSTDC_NAMES) || \
+    (!defined _CRT_DECLARE_NONSTDC_NAMES && !__STDC__                 )
+    #define _CRT_INTERNAL_NONSTDC_NAMES 1
+#else
+    #define _CRT_INTERNAL_NONSTDC_NAMES 0
+#endif
+
+#if defined _CRT_NONSTDC_NO_DEPRECATE && !defined _CRT_NONSTDC_NO_WARNINGS
+    #define _CRT_NONSTDC_NO_WARNINGS
+#endif
+
+#ifndef _CRT_NONSTDC_DEPRECATE
+    #ifdef _CRT_NONSTDC_NO_WARNINGS
+        #define _CRT_NONSTDC_DEPRECATE(_NewName)
+    #else
+        #define _CRT_NONSTDC_DEPRECATE(_NewName) _CRT_DEPRECATE_TEXT(             \
+            "The POSIX name for this item is deprecated. Instead, use the ISO C
" \
+            "and C++ conformant name: " #_NewName ". See online help for
details.")
+    #endif
+#endif
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Managed CRT Support
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#ifndef _PGLOBAL
+    #ifdef _M_CEE
+        #ifdef __cplusplus_cli
+            #define _PGLOBAL __declspec(process)
+        #else
+            #define _PGLOBAL
+        #endif
+    #else
+        #define _PGLOBAL
+    #endif
+#endif
+
+#ifndef _AGLOBAL
+    #ifdef _M_CEE
+        #define _AGLOBAL __declspec(appdomain)
+    #else
+        #define _AGLOBAL
+    #endif
+#endif
+
+#if defined _M_CEE && !defined _M_CEE_PURE
+    #define _M_CEE_MIXED
+#endif
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// SecureCRT Configuration
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#if defined _CRTBLD || defined _CORECRT_BUILD || defined _VCRT_BUILD
+    // Disable C++ overloads internally:
+    #define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES       0
+    #define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT 0
+    #define _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES         0
+#endif
+
+#if !_CRT_FUNCTIONS_REQUIRED
+    // If we don't require function declarations at all, we need not define the
+    // overloads (MIDL and RC do not need the C++ overloads).
+    #undef  _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES
+    #undef  _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT
+    #undef  _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES
+    #undef  _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_MEMORY
+    #undef  _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_MEMORY
+
+    #define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 0
+    #define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT 0
+    #define _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES 0
+    #define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_MEMORY 0
+    #define _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_MEMORY 0
+#endif
+
+#define __STDC_SECURE_LIB__ 200411L
+#define __GOT_SECURE_LIB__ __STDC_SECURE_LIB__ // For backwards compatibility
+
+#ifndef __STDC_WANT_SECURE_LIB__
+    #define __STDC_WANT_SECURE_LIB__ 1
+#endif
+
+#if !__STDC_WANT_SECURE_LIB__ && !defined _CRT_SECURE_NO_WARNINGS
+    #define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#ifndef RC_INVOKED
+    #if defined _CRT_SECURE_NO_DEPRECATE_GLOBALS && !defined
_CRT_SECURE_NO_WARNINGS_GLOBALS
+        #define _CRT_SECURE_NO_WARNINGS_GLOBALS
+    #endif
+#endif
+
+#ifndef _CRT_INSECURE_DEPRECATE_GLOBALS
+    #ifdef RC_INVOKED
+        #define _CRT_INSECURE_DEPRECATE_GLOBALS(replacement)
+    #else
+        #ifdef _CRT_SECURE_NO_WARNINGS_GLOBALS
+            #define _CRT_INSECURE_DEPRECATE_GLOBALS(replacement)
+        #else
+            #define _CRT_INSECURE_DEPRECATE_GLOBALS(replacement)
_CRT_INSECURE_DEPRECATE(replacement)
+        #endif
+    #endif
+#endif
+
+#if defined _CRT_MANAGED_HEAP_NO_DEPRECATE && !defined
_CRT_MANAGED_HEAP_NO_WARNINGS
+    #define _CRT_MANAGED_HEAP_NO_WARNINGS
+#endif
+
+#define _SECURECRT_FILL_BUFFER_PATTERN 0xFE
+
+#if defined _CRT_OBSOLETE_NO_DEPRECATE && !defined _CRT_OBSOLETE_NO_WARNINGS
+    #define _CRT_OBSOLETE_NO_WARNINGS
+#endif
+
+#ifndef _CRT_OBSOLETE
+    #ifdef _CRT_OBSOLETE_NO_WARNINGS
+        #define _CRT_OBSOLETE(_NewItem)
+    #else
+        #define _CRT_OBSOLETE(_NewItem) _CRT_DEPRECATE_TEXT(                   \
+            "This function or variable has been superceded by newer library " 
\
+            "or operating system functionality. Consider using " #_NewItem
" " \
+            "instead. See online help for details.")
+    #endif
+#endif
+
+#ifndef RC_INVOKED
+    #ifndef _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES
+        #define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 0
+    #else
+        #if !__STDC_WANT_SECURE_LIB__ && _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES
+            #error Cannot use Secure CRT C++ overloads when __STDC_WANT_SECURE_LIB__ is
0
+        #endif
+    #endif
+
+    #ifndef _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT
+        // _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT is ignored if
+        // _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES is set to 0
+        #define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT 0
+    #else
+        #if !__STDC_WANT_SECURE_LIB__ &&
_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT
+            #error Cannot use Secure CRT C++ overloads when __STDC_WANT_SECURE_LIB__ is
0
+        #endif
+    #endif
+
+    #ifndef _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES
+        #if __STDC_WANT_SECURE_LIB__
+              #define _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES 1
+        #else
+              #define _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES 0
+        #endif
+    #else
+        #if !__STDC_WANT_SECURE_LIB__ && _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES
+            #error Cannot use Secure CRT C++ overloads when __STDC_WANT_SECURE_LIB__ is
0
+        #endif
+    #endif
+
+    #ifndef _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_MEMORY
+        #define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_MEMORY 0
+    #else
+        #if !__STDC_WANT_SECURE_LIB__ &&
_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_MEMORY
+            #error Cannot use Secure CRT C++ overloads when __STDC_WANT_SECURE_LIB__ is
0
+        #endif
+    #endif
+
+    #ifndef _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_MEMORY
+        #define _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_MEMORY 0
+    #else
+        #if !__STDC_WANT_SECURE_LIB__ &&
_CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_MEMORY
+           #error Cannot use Secure CRT C++ overloads when __STDC_WANT_SECURE_LIB__ is 0
+        #endif
+    #endif
+#endif
+
+#ifndef _CRT_SECURE_CPP_NOTHROW
+    #define _CRT_SECURE_CPP_NOTHROW throw()
+#endif
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Basic Types
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+typedef int                           errno_t;
+typedef unsigned short                wint_t;
+typedef unsigned short                wctype_t;
+typedef long                          __time32_t;
+typedef __int64                       __time64_t;
+
+typedef struct __crt_locale_data_public
+{
+      unsigned short const* _locale_pctype;
+    _Field_range_(1, 2) int _locale_mb_cur_max;
+               unsigned int _locale_lc_codepage;
+} __crt_locale_data_public;
+
+typedef struct __crt_locale_pointers
+{
+    struct __crt_locale_data*    locinfo;
+    struct __crt_multibyte_data* mbcinfo;
+} __crt_locale_pointers;
+
+typedef __crt_locale_pointers* _locale_t;
+
+typedef struct _Mbstatet
+{ // state of a multibyte translation
+    unsigned long _Wchar;
+    unsigned short _Byte, _State;
+} _Mbstatet;
+
+typedef _Mbstatet mbstate_t;
+
+#if defined _USE_32BIT_TIME_T && defined _WIN64
+    #error You cannot use 32-bit time_t (_USE_32BIT_TIME_T) with _WIN64
+#endif
+
+#if defined _VCRT_BUILD || defined _CORECRT_BUILD
+    #define _CRT_NO_TIME_T
+#endif
+
+#ifndef _CRT_NO_TIME_T
+    #ifdef _USE_32BIT_TIME_T
+        typedef __time32_t time_t;
+    #else
+        typedef __time64_t time_t;
+    #endif
+#endif
+
+// Indicate that these common types are defined
+#ifndef _TIME_T_DEFINED
+    #define _TIME_T_DEFINED
+#endif
+
+#if __STDC_WANT_SECURE_LIB__
+    typedef size_t rsize_t;
+#endif
+
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// C++ Secure Overload Generation Macros
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#ifndef RC_INVOKED
+    #if defined __cplusplus && _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES
+
+        #define __DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_0(_ReturnType, _FuncName, _DstType,
_Dst)     \
+            extern "C++"                                                       
                  \
+            {                                                                            
        \
+                template <size_t _Size>                                            
              \
+                inline                                                                   
        \
+                _ReturnType __CRTDECL _FuncName(_DstType (&_Dst)[_Size])
_CRT_SECURE_CPP_NOTHROW  \
+                {                                                                        
        \
+                    return _FuncName(_Dst, _Size);                                       
        \
+                }                                                                        
        \
+            }
+
+        #define __DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_1(_ReturnType, _FuncName, _DstType,
_Dst, _TType1, _TArg1)   \
+            extern "C++"                                                       
                                 \
+            {                                                                            
                       \
+                template <size_t _Size>                                            
                             \
+                inline                                                                   
                       \
+                _ReturnType __CRTDECL _FuncName(_DstType (&_Dst)[_Size], _TType1
_TArg1) _CRT_SECURE_CPP_NOTHROW \
+                {                                                                        
                       \
+                    return _FuncName(_Dst, _Size, _TArg1);                               
                       \
+                }                                                                        
                       \
+            }
+
+        #define __DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_2(_ReturnType, _FuncName, _DstType,
_Dst, _TType1, _TArg1, _TType2, _TArg2)  \
+            extern "C++"                                                       
                                                 \
+            {                                                                            
                                       \
+                template <size_t _Size>                                            
                                             \
+                inline                                                                   
                                       \
+                _ReturnType __CRTDECL _FuncName(_DstType (&_Dst)[_Size], _TType1
_TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW \
+                {                                                                        
                                       \
+                    return _FuncName(_Dst, _Size, _TArg1, _TArg2);                       
                                       \
+                }                                                                        
                                       \
+            }
+
+        #define __DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_3(_ReturnType, _FuncName, _DstType,
_Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3) \
+            extern "C++"                                                       
                                                                 \
+            {                                                                            
                                                       \
+                template <size_t _Size>                                            
                                                             \
+                inline                                                                   
                                                       \
+                _ReturnType __CRTDECL _FuncName(_DstType (&_Dst)[_Size], _TType1
_TArg1, _TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW \
+                {                                                                        
                                                       \
+                    return _FuncName(_Dst, _Size, _TArg1, _TArg2, _TArg3);               
                                                       \
+                }                                                                        
                                                       \
+            }
+
+        #define __DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_4(_ReturnType, _FuncName, _DstType,
_Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3, _TType4, _TArg4) \
+            extern "C++"                                                       
                                                                                  \
+            {                                                                            
                                                                        \
+                template <size_t _Size>                                            
                                                                              \
+                inline                                                                   
                                                                        \
+                _ReturnType __CRTDECL _FuncName(_DstType (&_Dst)[_Size], _TType1
_TArg1, _TType2 _TArg2, _TType3 _TArg3, _TType4 _TArg4) _CRT_SECURE_CPP_NOTHROW  \
+                {                                                                        
                                                                        \
+                    return _FuncName(_Dst, _Size, _TArg1, _TArg2, _TArg3, _TArg4);       
                                                                        \
+                }                                                                        
                                                                        \
+            }
+
+        #define __DEFINE_CPP_OVERLOAD_SECURE_FUNC_1_1(_ReturnType, _FuncName, _HType1,
_HArg1, _DstType, _Dst, _TType1, _TArg1)  \
+            extern "C++"                                                       
                                                 \
+            {                                                                            
                                       \
+                template <size_t _Size>                                            
                                             \
+                inline                                                                   
                                       \
+                _ReturnType __CRTDECL _FuncName(_HType1 _HArg1, _DstType
(&_Dst)[_Size], _TType1 _TArg1) _CRT_SECURE_CPP_NOTHROW \
+                {                                                                        
                                       \
+                    return _FuncName(_HArg1, _Dst, _Size, _TArg1);                       
                                       \
+                }                                                                        
                                       \
+            }
+
+        #define __DEFINE_CPP_OVERLOAD_SECURE_FUNC_1_2(_ReturnType, _FuncName, _HType1,
_HArg1, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2) \
+            extern "C++"                                                       
                                                                 \
+            {                                                                            
                                                       \
+                template <size_t _Size>                                            
                                                             \
+                inline                                                                   
                                                       \
+                _ReturnType __CRTDECL _FuncName(_HType1 _HArg1, _DstType
(&_Dst)[_Size], _TType1 _TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW \
+                {                                                                        
                                                       \
+                    return _FuncName(_HArg1, _Dst, _Size, _TArg1, _TArg2);               
                                                       \
+                }                                                                        
                                                       \
+            }
+
+        #define __DEFINE_CPP_OVERLOAD_SECURE_FUNC_1_3(_ReturnType, _FuncName, _HType1,
_HArg1, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3) \
+            extern "C++"                                                       
                                                                                  \
+            {                                                                            
                                                                        \
+                template <size_t _Size>                                            
                                                                              \
+                inline                                                                   
                                                                        \
+                _ReturnType __CRTDECL _FuncName(_HType1 _HArg1, _DstType
(&_Dst)[_Size], _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3)
_CRT_SECURE_CPP_NOTHROW  \
+                {                                                                        
                                                                        \
+                    return _FuncName(_HArg1, _Dst, _Size, _TArg1, _TArg2, _TArg3);       
                                                                        \
+                }                                                                        
                                                                        \
+            }
+
+        #define __DEFINE_CPP_OVERLOAD_SECURE_FUNC_2_0(_ReturnType, _FuncName, _HType1,
_HArg1, _HType2, _HArg2, _DstType, _Dst)  \
+            extern "C++"                                                       
                                                 \
+            {                                                                            
                                       \
+                template <size_t _Size>                                            
                                             \
+                inline                                                                   
                                       \
+                _ReturnType __CRTDECL _FuncName(_HType1 _HArg1, _HType2 _HArg2, _DstType
(&_Dst)[_Size]) _CRT_SECURE_CPP_NOTHROW \
+                {                                                                        
                                       \
+                    return _FuncName(_HArg1, _HArg2, _Dst, _Size);                       
                                       \
+                }                                                                        
                                       \
+            }
+
+        #define __DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_1_ARGLIST(_ReturnType, _FuncName,
_VFuncName, _DstType, _Dst, _TType1, _TArg1) \
+            extern "C++"                                                       
                                                   \
+            {                                                                            
                                         \
+                template <size_t _Size>                                            
                                               \
+                inline                                                                   
                                         \
+                _ReturnType __CRTDECL _FuncName(_DstType (&_Dst)[_Size], _TType1
_TArg1, ...) _CRT_SECURE_CPP_NOTHROW              \
+                {                                                                        
                                         \
+                    va_list _ArgList;                                                    
                                         \
+                    __crt_va_start(_ArgList, _TArg1);                                    
                                         \
+                    return _VFuncName(_Dst, _Size, _TArg1, _ArgList);                    
                                         \
+                }                                                                        
                                         \
+            }
+
+        #define __DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_2_ARGLIST(_ReturnType, _FuncName,
_VFuncName, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2) \
+            extern "C++"                                                       
                                                                    \
+            {                                                                            
                                                          \
+                template <size_t _Size>                                            
                                                                \
+                inline                                                                   
                                                          \
+                _ReturnType __CRTDECL _FuncName(_DstType (&_Dst)[_Size], _TType1
_TArg1, _TType2 _TArg2, ...) _CRT_SECURE_CPP_NOTHROW               \
+                {                                                                        
                                                          \
+                    va_list _ArgList;                                                    
                                                          \
+                    __crt_va_start(_ArgList, _TArg2);                                    
                                                          \
+                    return _VFuncName(_Dst, _Size, _TArg1, _TArg2, _ArgList);            
                                                          \
+                }                                                                        
                                                          \
+            }
+
+        #define __DEFINE_CPP_OVERLOAD_SECURE_FUNC_SPLITPATH(_ReturnType, _FuncName,
_DstType, _Src)               \
+            extern "C++"                                                       
                                  \
+            {                                                                            
                        \
+                template <size_t _DriveSize, size_t _DirSize, size_t _NameSize, size_t
_ExtSize>                  \
+                inline                                                                   
                        \
+                _ReturnType __CRTDECL _FuncName(                                         
                        \
+                    _In_z_ _DstType const* _Src,                                         
                        \
+                    _Post_z_ _DstType (&_Drive)[_DriveSize],                         
                            \
+                    _Post_z_ _DstType (&_Dir)[_DirSize],                             
                            \
+                    _Post_z_ _DstType (&_Name)[_NameSize],                           
                            \
+                    _Post_z_ _DstType (&_Ext)[_ExtSize]                              
                            \
+                    ) _CRT_SECURE_CPP_NOTHROW                                            
                        \
+                {                                                                        
                        \
+                    return _FuncName(_Src, _Drive, _DriveSize, _Dir, _DirSize, _Name,
_NameSize, _Ext, _ExtSize); \
+                }                                                                        
                        \
+            }
+
+    #else  // ^^^ _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES ^^^ // vvv
!_CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES vvv //
+
+        #define __DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_0(_ReturnType, _FuncName, _DstType,
_Dst)
+        #define __DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_1(_ReturnType, _FuncName, _DstType,
_Dst, _TType1, _TArg1)
+        #define __DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_2(_ReturnType, _FuncName, _DstType,
_Dst, _TType1, _TArg1, _TType2, _TArg2)
+        #define __DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_3(_ReturnType, _FuncName, _DstType,
_Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3)
+        #define __DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_4(_ReturnType, _FuncName, _DstType,
_Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3, _TType4, _TArg4)
+        #define __DEFINE_CPP_OVERLOAD_SECURE_FUNC_1_1(_ReturnType, _FuncName, _HType1,
_HArg1, _DstType, _Dst, _TType1, _TArg1)
+        #define __DEFINE_CPP_OVERLOAD_SECURE_FUNC_1_2(_ReturnType, _FuncName, _HType1,
_HArg1, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2)
+        #define __DEFINE_CPP_OVERLOAD_SECURE_FUNC_1_3(_ReturnType, _FuncName, _HType1,
_HArg1, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3)
+        #define __DEFINE_CPP_OVERLOAD_SECURE_FUNC_2_0(_ReturnType, _FuncName, _HType1,
_HArg1, _HType2, _HArg2, _DstType, _Dst)
+        #define __DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_1_ARGLIST(_ReturnType, _FuncName,
_VFuncName, _DstType, _Dst, _TType1, _TArg1)
+        #define __DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_2_ARGLIST(_ReturnType, _FuncName,
_VFuncName, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2)
+        #define __DEFINE_CPP_OVERLOAD_SECURE_FUNC_SPLITPATH(_ReturnType, _FuncName,
_DstType, _Src)
+
+    #endif // !_CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES
+#endif
+
+
+
+#define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _SalAttributeDst, _DstType, _Dst) \
+    __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0_EX(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _FuncName##_s, _SalAttributeDst, _DstType, _Dst)
+
+#define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1) \
+    __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1_EX(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _FuncName##_s, _DstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1)
+
+#define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2) \
+    __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_EX(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _FuncName##_s, _DstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1,
_TType2, _TArg2)
+
+#define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_3(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3,
_TArg3) \
+    __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_3_EX(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _FuncName##_s, _DstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1,
_TType2, _TArg2, _TType3, _TArg3)
+
+#define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_4(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3,
_TArg3, _TType4, _TArg4) \
+    __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_4_EX(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _FuncName##_s, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2,
_TArg2, _TType3, _TArg3, _TType4, _TArg4)
+
+#define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_1_1(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _HType1, _HArg1, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1) \
+    __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_1_1_EX(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _FuncName##_s, _HType1, _HArg1, _SalAttributeDst, _DstType, _Dst, _TType1,
_TArg1)
+
+#define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_2_0(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _HType1, _HArg1, _HType2, _HArg2, _SalAttributeDst, _DstType, _Dst) \
+    __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_2_0_EX(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _FuncName##_s, _HType1, _HArg1, _HType2, _HArg2, _SalAttributeDst, _DstType,
_Dst)
+
+#define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1_ARGLIST(_ReturnType, _ReturnPolicy,
_DeclSpec, _CC, _FuncName, _VFuncName, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1)
\
+    __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1_ARGLIST_EX(_ReturnType, _ReturnPolicy,
_DeclSpec, _CC, _FuncName, _FuncName##_s, _VFuncName, _VFuncName##_s, _SalAttributeDst,
_DstType, _Dst, _TType1, _TArg1)
+
+#define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_ARGLIST(_ReturnType, _ReturnPolicy,
_DeclSpec, _CC, _FuncName, _VFuncName, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1,
_TType2, _TArg2) \
+    __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_ARGLIST_EX(_ReturnType, _ReturnPolicy,
_DeclSpec, _CC, _FuncName, _VFuncName, _VFuncName##_s, _DstType, _SalAttributeDst,
_DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2)
+
+#define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_SIZE(_DeclSpec, _FuncName,
_SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2) \
+    __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_SIZE_EX(_DeclSpec, _FuncName, _FuncName##_s,
_DstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2)
+
+#define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_3_SIZE(_DeclSpec, _FuncName,
_SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3) \
+    __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_3_SIZE_EX(_DeclSpec, _FuncName, _FuncName##_s,
_DstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3,
_TArg3)
+
+
+
+#define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_0(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _SalAttributeDst, _DstType, _Dst) \
+    __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_0_EX(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _FuncName##_s, _SalAttributeDst, _DstType, _Dst)
+
+#define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_1(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1) \
+    __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_1_EX(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _FuncName##_s, _SalAttributeDst, _DstType, _DstType, _Dst, _TType1, _TArg1)
+
+#define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2) \
+    __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_EX(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _FuncName##_s, _DstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1,
_TType2, _TArg2)
+
+#define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_3(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3,
_TArg3) \
+    __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_3_EX(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _FuncName##_s, _DstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1,
_TType2, _TArg2, _TType3, _TArg3)
+
+#define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_4(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3,
_TArg3, _TType4, _TArg4) \
+    __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_4_EX(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _FuncName##_s, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2,
_TArg2, _TType3, _TArg3, _TType4, _TArg4)
+
+#define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_1_1(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _HType1, _HArg1, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1) \
+    __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_1_1_EX(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _FuncName##_s, _HType1, _HArg1, _SalAttributeDst, _DstType, _Dst, _TType1,
_TArg1)
+
+#define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_2_0(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _HType1, _HArg1, _HType2, _HArg2, _SalAttributeDst, _DstType, _Dst) \
+    __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_2_0_EX(_ReturnType, _ReturnPolicy, _DeclSpec,
_FuncName, _FuncName##_s, _HType1, _HArg1, _HType2, _HArg2, _SalAttributeDst, _DstType,
_Dst)
+
+#define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_1_ARGLIST(_ReturnType, _ReturnPolicy,
_DeclSpec, _FuncName, _VFuncName, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1) \
+    __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_1_ARGLIST_EX(_ReturnType, _ReturnPolicy,
_DeclSpec, __cdecl, _FuncName, _FuncName##_s, _VFuncName, _VFuncName##_s,
_SalAttributeDst, _DstType, _Dst, _TType1, _TArg1)
+
+#define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_SIZE(_DeclSpec, _FuncName,
_SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2) \
+    __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_SIZE_EX(_DeclSpec, _FuncName, _FuncName##_s,
_DstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2)
+
+#define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_3_SIZE(_DeclSpec, _FuncName,
_SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3) \
+    __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_3_SIZE_EX(_DeclSpec, _FuncName, _FuncName##_s,
_DstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3,
_TArg3)
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// C++ Standard Overload Generation Macros
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#ifndef RC_INVOKED
+    #if defined __cplusplus && _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES
+
+        #define __RETURN_POLICY_SAME(_FunctionCall, _Dst) return (_FunctionCall)
+        #define __RETURN_POLICY_DST(_FunctionCall, _Dst)  return ((_FunctionCall) == 0 ?
_Dst : 0)
+        #define __RETURN_POLICY_VOID(_FunctionCall, _Dst) (_FunctionCall); return
+        #define __EMPTY_DECLSPEC
+
+        #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0_EX(_ReturnType, _ReturnPolicy,
_DeclSpec, _FuncName, _SecureFuncName, _SalAttributeDst, _DstType, _Dst) \
+            __inline \
+            _ReturnType __CRTDECL __insecure_##_FuncName(_SalAttributeDst _DstType *_Dst)
\
+            { \
+                _ReturnType __cdecl _FuncName(_SalAttributeDst _DstType *_Dst); \
+                return _FuncName(_Dst); \
+            } \
+            extern "C++" \
+            { \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_T &_Dst) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(static_cast<_DstType *>(_Dst)); \
+            } \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(const _T &_Dst) _CRT_SECURE_CPP_NOTHROW
\
+            { \
+                return __insecure_##_FuncName(static_cast<_DstType *>(_Dst)); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_SalAttributeDst _DstType * &_Dst)
_CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(_Dst); \
+            } \
+            template <size_t _Size> \
+            inline \
+            _ReturnType __CRTDECL _FuncName(_DstType (&_Dst)[_Size])
_CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureFuncName(_Dst, _Size), _Dst); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName<1>(_DstType (&_Dst)[1])
_CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureFuncName(_Dst, 1), _Dst); \
+            } \
+            }
+
+        #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0_CGETS(_ReturnType, _DeclSpec,
_FuncName, _SalAttributeDst, _DstType, _Dst) \
+            __inline \
+            _ReturnType __CRTDECL __insecure_##_FuncName(_SalAttributeDst _DstType *_Dst)
\
+            { \
+                _ReturnType __cdecl _FuncName(_SalAttributeDst _DstType *_Dst); \
+                return _FuncName(_Dst); \
+            } \
+            extern "C++" \
+            { \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_FuncName##_s) \
+            _ReturnType __CRTDECL _FuncName(_T &_Dst) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(static_cast<_DstType *>(_Dst)); \
+            } \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_FuncName##_s) \
+            _ReturnType __CRTDECL _FuncName(const _T &_Dst) _CRT_SECURE_CPP_NOTHROW
\
+            { \
+                return __insecure_##_FuncName(static_cast<_DstType *>(_Dst)); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_FuncName##_s) \
+            _ReturnType __CRTDECL _FuncName(_SalAttributeDst _DstType * &_Dst)
_CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(_Dst); \
+            } \
+            template <size_t _Size> \
+            inline \
+            _ReturnType __CRTDECL _FuncName(_DstType (&_Dst)[_Size])
_CRT_SECURE_CPP_NOTHROW \
+            { \
+                size_t _SizeRead = 0; \
+                errno_t _Err = _FuncName##_s(_Dst + 2, (_Size - 2) < ((size_t)_Dst[0])
? (_Size - 2) : ((size_t)_Dst[0]), &_SizeRead); \
+                _Dst[1] = (_DstType)(_SizeRead); \
+                return (_Err == 0 ? _Dst + 2 : 0); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_FuncName##_s) \
+            _ReturnType __CRTDECL _FuncName<1>(_DstType (&_Dst)[1])
_CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName((_DstType *)_Dst); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_FuncName##_s) \
+            _ReturnType __CRTDECL _FuncName<2>(_DstType (&_Dst)[2])
_CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName((_DstType *)_Dst); \
+            } \
+            }
+
+        #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1_EX(_ReturnType, _ReturnPolicy,
_DeclSpec, _FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst,
_TType1, _TArg1) \
+            __inline \
+            _ReturnType __CRTDECL __insecure_##_FuncName(_SalAttributeDst _DstType *_Dst,
_TType1 _TArg1) \
+            { \
+                _ReturnType __cdecl _FuncName(_SalAttributeDst _DstType *_Dst, _TType1
_TArg1); \
+                return _FuncName(_Dst, _TArg1); \
+            } \
+            extern "C++" \
+            { \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_T &_Dst, _TType1 _TArg1)
_CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(static_cast<_DstType *>(_Dst),
_TArg1); \
+            } \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(const _T &_Dst, _TType1 _TArg1)
_CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(static_cast<_DstType *>(_Dst),
_TArg1); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_SalAttributeDst _DstType * &_Dst,
_TType1 _TArg1) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(_Dst, _TArg1); \
+            } \
+            template <size_t _Size> \
+            inline \
+            _ReturnType __CRTDECL _FuncName(_SecureDstType (&_Dst)[_Size], _TType1
_TArg1) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureFuncName(_Dst, _Size, _TArg1), _Dst); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName<1>(_DstType (&_Dst)[1], _TType1
_TArg1) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureFuncName(_Dst, 1, _TArg1), _Dst); \
+            } \
+            }
+
+        #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_EX(_ReturnType, _ReturnPolicy,
_DeclSpec, _FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst,
_TType1, _TArg1, _TType2, _TArg2) \
+            __inline \
+            _ReturnType __CRTDECL __insecure_##_FuncName(_SalAttributeDst _DstType *_Dst,
_TType1 _TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnType __cdecl _FuncName(_SalAttributeDst _DstType *_Dst, _TType1
_TArg1, _TType2 _TArg2); \
+                return _FuncName(_Dst, _TArg1, _TArg2); \
+            } \
+            extern "C++" \
+            { \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_T &_Dst, _TType1 _TArg1, _TType2 _TArg2)
_CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(static_cast<_DstType *>(_Dst),
_TArg1, _TArg2); \
+            } \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(const _T &_Dst, _TType1 _TArg1, _TType2
_TArg2) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(static_cast<_DstType *>(_Dst),
_TArg1, _TArg2); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_SalAttributeDst _DstType * &_Dst,
_TType1 _TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(_Dst, _TArg1, _TArg2); \
+            } \
+            template <size_t _Size> \
+            inline \
+            _ReturnType __CRTDECL _FuncName(_SecureDstType (&_Dst)[_Size], _TType1
_TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureFuncName(_Dst, _Size, _TArg1, _TArg2), _Dst); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName<1>(_DstType (&_Dst)[1], _TType1
_TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureFuncName(_Dst, 1, _TArg1, _TArg2), _Dst); \
+            } \
+            }
+
+        #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_3_EX(_ReturnType, _ReturnPolicy,
_DeclSpec, _FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst,
_TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3) \
+            __inline \
+            _ReturnType __CRTDECL __insecure_##_FuncName(_SalAttributeDst _DstType *_Dst,
_TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3) \
+            { \
+                _ReturnType __cdecl _FuncName(_SalAttributeDst _DstType *_Dst, _TType1
_TArg1, _TType2 _TArg2, _TType3 _TArg3); \
+                return _FuncName(_Dst, _TArg1, _TArg2, _TArg3); \
+            } \
+            extern "C++" \
+            { \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_T &_Dst, _TType1 _TArg1, _TType2 _TArg2,
_TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(static_cast<_DstType *>(_Dst),
_TArg1, _TArg2, _TArg3); \
+            } \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(const _T &_Dst, _TType1 _TArg1, _TType2
_TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(static_cast<_DstType *>(_Dst),
_TArg1, _TArg2, _TArg3); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_SalAttributeDst _DstType * &_Dst,
_TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(_Dst, _TArg1, _TArg2, _TArg3); \
+            } \
+            template <size_t _Size> \
+            inline \
+            _ReturnType __CRTDECL _FuncName(_SecureDstType (&_Dst)[_Size], _TType1
_TArg1, _TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureFuncName(_Dst, _Size, _TArg1, _TArg2, _TArg3),
_Dst); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName<1>(_DstType (&_Dst)[1], _TType1
_TArg1, _TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureFuncName(_Dst, 1, _TArg1, _TArg2, _TArg3), _Dst); \
+            } \
+            }
+
+        #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_4_EX(_ReturnType, _ReturnPolicy,
_DeclSpec, _FuncName, _SecureFuncName, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1,
_TType2, _TArg2, _TType3, _TArg3, _TType4, _TArg4) \
+            __inline \
+            _ReturnType __CRTDECL __insecure_##_FuncName(_SalAttributeDst _DstType *_Dst,
_TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3, _TType4 _TArg4) \
+            { \
+                _ReturnType __cdecl _FuncName(_SalAttributeDst _DstType *_Dst, _TType1
_TArg1, _TType2 _TArg2, _TType3 _TArg3, _TType4 _TArg4); \
+                return _FuncName(_Dst, _TArg1, _TArg2, _TArg3, _TArg4); \
+            } \
+            extern "C++" \
+            { \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_T &_Dst, _TType1 _TArg1, _TType2 _TArg2,
_TType3 _TArg3, _TType4 _TArg4) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(static_cast<_DstType *>(_Dst),
_TArg1, _TArg2, _TArg3, _TArg4); \
+            } \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(const _T &_Dst, _TType1 _TArg1, _TType2
_TArg2, _TType3 _TArg3, _TType4 _TArg4) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(static_cast<_DstType *>(_Dst),
_TArg1, _TArg2, _TArg3, _TArg4); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_SalAttributeDst _DstType * &_Dst,
_TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3, _TType4 _TArg4) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(_Dst, _TArg1, _TArg2, _TArg3, _TArg4); \
+            } \
+            template <size_t _Size> \
+            inline \
+            _ReturnType __CRTDECL _FuncName(_DstType (&_Dst)[_Size], _TType1 _TArg1,
_TType2 _TArg2, _TType3 _TArg3, _TType4 _TArg4) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureFuncName(_Dst, _Size, _TArg1, _TArg2, _TArg3,
_TArg4), _Dst); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName<1>(_DstType (&_Dst)[1], _TType1
_TArg1, _TType2 _TArg2, _TType3 _TArg3, _TType4 _TArg4) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureFuncName(_Dst, 1, _TArg1, _TArg2, _TArg3, _TArg4),
_Dst); \
+            } \
+            }
+
+        #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_1_1_EX(_ReturnType, _ReturnPolicy,
_DeclSpec, _FuncName, _SecureFuncName, _HType1, _HArg1, _SalAttributeDst, _DstType, _Dst,
_TType1, _TArg1) \
+            __inline \
+            _ReturnType __CRTDECL __insecure_##_FuncName(_HType1 _HArg1, _SalAttributeDst
_DstType *_Dst, _TType1 _TArg1) \
+            { \
+                _ReturnType __cdecl _FuncName(_HType1 _HArg1, _SalAttributeDst _DstType
*_Dst, _TType1 _TArg1); \
+                return _FuncName(_HArg1, _Dst, _TArg1); \
+            } \
+            extern "C++" \
+            { \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_HType1 _HArg1, _T &_Dst, _TType1 _TArg1)
_CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(_HArg1, static_cast<_DstType
*>(_Dst), _TArg1); \
+            } \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_HType1 _HArg1, const _T &_Dst, _TType1
_TArg1) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(_HArg1, static_cast<_DstType
*>(_Dst), _TArg1); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_HType1 _HArg1, _SalAttributeDst _DstType *
&_Dst, _TType1 _TArg1) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(_HArg1, _Dst, _TArg1); \
+            } \
+            template <size_t _Size> \
+            inline \
+            _ReturnType __CRTDECL _FuncName(_HType1 _HArg1, _DstType (&_Dst)[_Size],
_TType1 _TArg1) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureFuncName(_HArg1, _Dst, _Size, _TArg1), _Dst); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName<1>(_HType1 _HArg1, _DstType
(&_Dst)[1], _TType1 _TArg1) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureFuncName(_HArg1, _Dst, 1, _TArg1), _Dst); \
+            } \
+            }
+
+        #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_2_0_EX(_ReturnType, _ReturnPolicy,
_DeclSpec, _FuncName, _SecureFuncName, _HType1, _HArg1, _HType2, _HArg2, _SalAttributeDst,
_DstType, _Dst) \
+            __inline \
+            _ReturnType __CRTDECL __insecure_##_FuncName(_HType1 _HArg1, _HType2 _HArg2,
_SalAttributeDst _DstType *_Dst) \
+            { \
+                _ReturnType __cdecl _FuncName(_HType1 _HArg1, _HType2 _HArg2,
_SalAttributeDst _DstType *_Dst); \
+                return _FuncName(_HArg1, _HArg2, _Dst); \
+            } \
+            extern "C++" \
+            { \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_HType1 _HArg1, _HType2 _HArg2, _T &_Dst)
_CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(_HArg1, _HArg2, static_cast<_DstType
*>(_Dst)); \
+            } \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_HType1 _HArg1, _HType2 _HArg2, const _T
&_Dst) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(_HArg1, _HArg2, static_cast<_DstType
*>(_Dst)); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_HType1 _HArg1, _HType2 _HArg2,
_SalAttributeDst _DstType * &_Dst) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(_HArg1, _HArg2, _Dst); \
+            } \
+            template <size_t _Size> \
+            inline \
+            _ReturnType __CRTDECL _FuncName(_HType1 _HArg1, _HType2 _HArg2, _DstType
(&_Dst)[_Size]) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureFuncName(_HArg1, _HArg2, _Dst, _Size), _Dst); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName<1>(_HType1 _HArg1, _HType2 _HArg2,
_DstType (&_Dst)[1]) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureFuncName(_HArg1, _HArg2, _Dst, 1), _Dst); \
+            } \
+            }
+
+        #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1_ARGLIST_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _CC, _FuncName, _SecureFuncName, _VFuncName, _SecureVFuncName,
_SalAttributeDst, _DstType, _Dst, _TType1, _TArg1) \
+            __inline \
+            _ReturnType __CRTDECL __insecure_##_VFuncName(_SalAttributeDst _DstType
*_Dst, _TType1 _TArg1, va_list _ArgList) \
+            { \
+                _ReturnType _CC _VFuncName(_SalAttributeDst _DstType *_Dst, _TType1
_TArg1, va_list _ArgList); \
+                return _VFuncName(_Dst, _TArg1, _ArgList); \
+            } \
+            extern "C++" \
+            { \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_T &_Dst, _TType1 _TArg1, ...)
_CRT_SECURE_CPP_NOTHROW \
+            { \
+                va_list _ArgList; \
+                __crt_va_start(_ArgList, _TArg1); \
+                return __insecure_##_VFuncName(static_cast<_DstType *>(_Dst),
_TArg1, _ArgList); \
+            } \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(const _T &_Dst, _TType1 _TArg1, ...)
_CRT_SECURE_CPP_NOTHROW \
+            { \
+                va_list _ArgList; \
+                __crt_va_start(_ArgList, _TArg1); \
+                return __insecure_##_VFuncName(static_cast<_DstType *>(_Dst),
_TArg1, _ArgList); \
+            } \
+                \
+                template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_SalAttributeDst _DstType * &_Dst,
_TType1 _TArg1, ...) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                va_list _ArgList; \
+                __crt_va_start(_ArgList, _TArg1); \
+                return __insecure_##_VFuncName(_Dst, _TArg1, _ArgList); \
+            } \
+                \
+                template <size_t _Size> \
+            inline \
+            _ReturnType __CRTDECL _FuncName(_DstType (&_Dst)[_Size], _TType1 _TArg1,
...) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                va_list _ArgList; \
+                __crt_va_start(_ArgList, _TArg1); \
+                _ReturnPolicy(_SecureVFuncName(_Dst, _Size, _TArg1, _ArgList), _Dst); \
+            } \
+                \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName<1>(_DstType (&_Dst)[1], _TType1
_TArg1, ...) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                va_list _ArgList; \
+                __crt_va_start(_ArgList, _TArg1); \
+                _ReturnPolicy(_SecureVFuncName(_Dst, 1, _TArg1, _ArgList), _Dst); \
+            } \
+                \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureVFuncName) \
+            _ReturnType __CRTDECL _VFuncName(_T &_Dst, _TType1 _TArg1, va_list
_ArgList) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_VFuncName(static_cast<_DstType *>(_Dst),
_TArg1, _ArgList); \
+            } \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureVFuncName) \
+            _ReturnType __CRTDECL _VFuncName(const _T &_Dst, _TType1 _TArg1, va_list
_ArgList) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_VFuncName(static_cast<_DstType *>(_Dst),
_TArg1, _ArgList); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureVFuncName) \
+            _ReturnType __CRTDECL _VFuncName(_SalAttributeDst _DstType *&_Dst,
_TType1 _TArg1, va_list _ArgList) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_VFuncName(_Dst, _TArg1, _ArgList); \
+            } \
+            template <size_t _Size> \
+            inline \
+            _ReturnType __CRTDECL _VFuncName(_DstType (&_Dst)[_Size], _TType1 _TArg1,
va_list _ArgList) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureVFuncName(_Dst, _Size, _TArg1, _ArgList), _Dst); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureVFuncName) \
+            _ReturnType __CRTDECL _VFuncName<1>(_DstType (&_Dst)[1], _TType1
_TArg1, va_list _ArgList) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureVFuncName(_Dst, 1, _TArg1, _ArgList), _Dst); \
+            } \
+            }
+
+        #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_ARGLIST_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _CC, _FuncName, _VFuncName, _SecureVFuncName, _SecureDstType,
_SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2) \
+            __inline \
+            _ReturnType __CRTDECL __insecure_##_VFuncName(_SalAttributeDst _DstType
*_Dst, _TType1 _TArg1, _TType2 _TArg2, va_list _ArgList) \
+            { \
+                _ReturnType _CC _VFuncName(_SalAttributeDst _DstType *_Dst, _TType1
_TArg1, _TType2 _TArg2, va_list _ArgList); \
+                return _VFuncName(_Dst, _TArg1, _TArg2, _ArgList); \
+            } \
+            extern "C++" \
+            { \
+            template <typename _T> \
+            inline \
+                _CRT_INSECURE_DEPRECATE(_FuncName##_s) \
+            _ReturnType __CRTDECL _FuncName(_T &_Dst, _TType1 _TArg1, _TType2 _TArg2,
...) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                va_list _ArgList; \
+                __crt_va_start(_ArgList, _TArg2); \
+                return __insecure_##_VFuncName(static_cast<_DstType *>(_Dst),
_TArg1, _TArg2, _ArgList); \
+            } \
+            template <typename _T> \
+            inline \
+                _CRT_INSECURE_DEPRECATE(_FuncName##_s) \
+            _ReturnType __CRTDECL _FuncName(const _T &_Dst, _TType1 _TArg1, _TType2
_TArg2, ...) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                va_list _ArgList; \
+                __crt_va_start(_ArgList, _TArg2); \
+                return __insecure_##_VFuncName(static_cast<_DstType *>(_Dst),
_TArg1, _TArg2, _ArgList); \
+            } \
+                \
+            template <> \
+            inline \
+                _CRT_INSECURE_DEPRECATE(_FuncName##_s) \
+            _ReturnType __CRTDECL _FuncName(_SalAttributeDst _DstType * &_Dst,
_TType1 _TArg1, _TType2 _TArg2, ...) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                va_list _ArgList; \
+                __crt_va_start(_ArgList, _TArg2); \
+                return __insecure_##_VFuncName(_Dst, _TArg1, _TArg2, _ArgList); \
+            } \
+                \
+            template <size_t _Size> \
+            inline \
+            _ReturnType __CRTDECL _FuncName(_SecureDstType (&_Dst)[_Size], _TType1
_TArg1, _TType2 _TArg2, ...) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                va_list _ArgList; \
+                __crt_va_start(_ArgList, _TArg2); \
+                _ReturnPolicy(_SecureVFuncName(_Dst, _Size, _TArg1, _TArg2, _ArgList),
_Dst); \
+            } \
+                \
+            template <> \
+            inline \
+                _CRT_INSECURE_DEPRECATE(_FuncName##_s) \
+            _ReturnType __CRTDECL _FuncName<1>(_DstType (&_Dst)[1], _TType1
_TArg1, _TType2 _TArg2, ...) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                va_list _ArgList; \
+                __crt_va_start(_ArgList, _TArg2); \
+                _ReturnPolicy(_SecureVFuncName(_Dst, 1, _TArg1, _TArg2, _ArgList), _Dst);
\
+            } \
+                \
+            template <typename _T> \
+            inline \
+                _CRT_INSECURE_DEPRECATE(_SecureVFuncName) \
+            _ReturnType __CRTDECL _VFuncName(_T &_Dst, _TType1 _TArg1, _TType2
_TArg2, va_list _ArgList) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_VFuncName(static_cast<_DstType *>(_Dst),
_TArg1, _TArg2, _ArgList); \
+            } \
+            template <typename _T> \
+            inline \
+                _CRT_INSECURE_DEPRECATE(_SecureVFuncName) \
+            _ReturnType __CRTDECL _VFuncName(const _T &_Dst, _TType1 _TArg1, _TType2
_TArg2, va_list _ArgList) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_VFuncName(static_cast<_DstType *>(_Dst),
_TArg1, _TArg2, _ArgList); \
+            } \
+            template <> \
+            inline \
+                _CRT_INSECURE_DEPRECATE(_SecureVFuncName) \
+            _ReturnType __CRTDECL _VFuncName(_SalAttributeDst _DstType *&_Dst,
_TType1 _TArg1, _TType2 _TArg2, va_list _ArgList) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_VFuncName(_Dst, _TArg1, _TArg2, _ArgList); \
+            } \
+            template <size_t _Size> \
+            inline \
+            _ReturnType __CRTDECL _VFuncName(_SecureDstType (&_Dst)[_Size], _TType1
_TArg1, _TType2 _TArg2, va_list _ArgList) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureVFuncName(_Dst, _Size, _TArg1, _TArg2, _ArgList),
_Dst); \
+            } \
+            template <> \
+            inline \
+                _CRT_INSECURE_DEPRECATE(_SecureVFuncName) \
+            _ReturnType __CRTDECL _VFuncName<1>(_DstType (&_Dst)[1], _TType1
_TArg1, _TType2 _TArg2, va_list _ArgList) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureVFuncName(_Dst, 1, _TArg1, _TArg2, _ArgList), _Dst);
\
+            } \
+            }
+
+        #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_SIZE_EX(_DeclSpec, _FuncName,
_SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1,
_TType2, _TArg2) \
+            __inline \
+            size_t __CRTDECL __insecure_##_FuncName(_SalAttributeDst _DstType *_Dst,
_TType1 _TArg1, _TType2 _TArg2) \
+            { \
+                _DeclSpec size_t __cdecl _FuncName(_SalAttributeDst _DstType *_Dst,
_TType1 _TArg1, _TType2 _TArg2); \
+                return _FuncName(_Dst, _TArg1, _TArg2); \
+            } \
+            extern "C++" \
+            { \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            size_t __CRTDECL _FuncName(_T &_Dst, _TType1 _TArg1, _TType2 _TArg2)
_CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(static_cast<_DstType *>(_Dst),
_TArg1, _TArg2); \
+            } \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            size_t __CRTDECL _FuncName(const _T &_Dst, _TType1 _TArg1, _TType2
_TArg2) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(static_cast<_DstType *>(_Dst),
_TArg1, _TArg2); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            size_t __CRTDECL _FuncName(_SalAttributeDst _DstType * &_Dst, _TType1
_TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(_Dst, _TArg1, _TArg2); \
+            } \
+            template <size_t _Size> \
+            inline \
+            size_t __CRTDECL _FuncName(_SecureDstType (&_Dst)[_Size], _TType1 _TArg1,
_TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                size_t _Ret = 0; \
+                _SecureFuncName(&_Ret, _Dst, _Size, _TArg1, _TArg2); \
+                return (_Ret > 0 ? (_Ret - 1) : _Ret); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            size_t __CRTDECL _FuncName<1>(_DstType (&_Dst)[1], _TType1 _TArg1,
_TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                size_t _Ret = 0; \
+                _SecureFuncName(&_Ret, _Dst, 1, _TArg1, _TArg2); \
+                return (_Ret > 0 ? (_Ret - 1) : _Ret); \
+            } \
+            }
+
+        #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_3_SIZE_EX(_DeclSpec, _FuncName,
_SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1,
_TType2, _TArg2, _TType3, _TArg3) \
+            __inline \
+            size_t __CRTDECL __insecure_##_FuncName(_SalAttributeDst _DstType *_Dst,
_TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3) \
+            { \
+                _DeclSpec size_t __cdecl _FuncName(_SalAttributeDst _DstType *_Dst,
_TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3); \
+                return _FuncName(_Dst, _TArg1, _TArg2, _TArg3); \
+            } \
+            extern "C++" \
+            { \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            size_t __CRTDECL _FuncName(_T &_Dst, _TType1 _TArg1, _TType2 _TArg2,
_TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(static_cast<_DstType *>(_Dst),
_TArg1, _TArg2, _TArg3); \
+            } \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            size_t __CRTDECL _FuncName(const _T &_Dst, _TType1 _TArg1, _TType2
_TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(static_cast<_DstType *>(_Dst),
_TArg1, _TArg2, _TArg3); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            size_t __CRTDECL _FuncName(_SalAttributeDst _DstType * &_Dst, _TType1
_TArg1, _TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(_Dst, _TArg1, _TArg2, _TArg3); \
+            } \
+            template <size_t _Size> \
+            inline \
+            size_t __CRTDECL _FuncName(_SecureDstType (&_Dst)[_Size], _TType1 _TArg1,
_TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                size_t _Ret = 0; \
+                _SecureFuncName(&_Ret, _Dst, _Size, _TArg1, _TArg2, _TArg3); \
+                return (_Ret > 0 ? (_Ret - 1) : _Ret); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            size_t __CRTDECL _FuncName<1>(_DstType (&_Dst)[1], _TType1 _TArg1,
_TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                size_t _Ret = 0; \
+                _SecureFuncName(&_Ret, _Dst, 1, _TArg1, _TArg2, _TArg3); \
+                return (_Ret > 0 ? (_Ret - 1) : _Ret); \
+            } \
+            }
+
+        #define __DECLARE_CPP_OVERLOAD_INLINE_FUNC_0_0_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst) \
+            __inline \
+            _ReturnType __CRTDECL __insecure_##_FuncName(_DstType *_Dst)
+
+        #define __DEFINE_CPP_OVERLOAD_INLINE_FUNC_0_0_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst) \
+            extern "C++" \
+            { \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_T &_Dst) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(static_cast<_DstType *>(_Dst)); \
+            } \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(const _T &_Dst) _CRT_SECURE_CPP_NOTHROW
\
+            { \
+                return __insecure_##_FuncName(static_cast<_DstType *>(_Dst)); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_DstType * &_Dst) _CRT_SECURE_CPP_NOTHROW
\
+            { \
+                return __insecure_##_FuncName(_Dst); \
+            } \
+            template <size_t _Size> \
+            inline \
+            _ReturnType __CRTDECL _FuncName(_SecureDstType (&_Dst)[_Size])
_CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureFuncName(_Dst, _Size), _Dst); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName<1>(_DstType (&_Dst)[1])
_CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureFuncName(_Dst, 1), _Dst); \
+            } \
+            }
+
+        #define __DECLARE_CPP_OVERLOAD_INLINE_FUNC_0_1_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1, _TArg1) \
+            __inline \
+            _ReturnType __CRTDECL __insecure_##_FuncName(_DstType *_Dst, _TType1 _TArg1)
+
+        #define __DEFINE_CPP_OVERLOAD_INLINE_FUNC_0_1_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1, _TArg1) \
+            extern "C++" \
+            { \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_T &_Dst, _TType1 _TArg1)
_CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(static_cast<_DstType *>(_Dst),
_TArg1); \
+            } \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(const _T &_Dst, _TType1 _TArg1)
_CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(static_cast<_DstType *>(_Dst),
_TArg1); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_DstType * &_Dst, _TType1 _TArg1)
_CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(_Dst, _TArg1); \
+            } \
+            template <size_t _Size> \
+            inline \
+            _ReturnType __CRTDECL _FuncName(_SecureDstType (&_Dst)[_Size], _TType1
_TArg1) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureFuncName(_Dst, _Size, _TArg1), _Dst); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName<1>(_DstType (&_Dst)[1], _TType1
_TArg1) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureFuncName(_Dst, 1, _TArg1), _Dst); \
+            } \
+            }
+
+        #define __DECLARE_CPP_OVERLOAD_INLINE_FUNC_0_2_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1, _TArg1, _TType2,
_TArg2) \
+            __inline \
+            _ReturnType __CRTDECL __insecure_##_FuncName(_DstType *_Dst, _TType1 _TArg1,
_TType2 _TArg2)
+
+        #define __DEFINE_CPP_OVERLOAD_INLINE_FUNC_0_2_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1,
_TArg1, _TType2, _TArg2) \
+            extern "C++" \
+            { \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_T &_Dst, _TType1 _TArg1, _TType2 _TArg2)
_CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(static_cast<_DstType *>(_Dst),
_TArg1, _TArg2); \
+            } \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(const _T &_Dst, _TType1 _TArg1, _TType2
_TArg2) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(static_cast<_DstType *>(_Dst),
_TArg1, _TArg2); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_SalAttributeDst _DstType * &_Dst,
_TType1 _TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(_Dst, _TArg1, _TArg2); \
+            } \
+            template <size_t _Size> \
+            inline \
+            _ReturnType __CRTDECL _FuncName(_SecureDstType (&_Dst)[_Size], _TType1
_TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureFuncName(_Dst, _Size, _TArg1, _TArg2), _Dst); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName<1>(_DstType (&_Dst)[1], _TType1
_TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureFuncName(_Dst, 1, _TArg1, _TArg2), _Dst); \
+            } \
+            }
+
+        #define __DECLARE_CPP_OVERLOAD_INLINE_FUNC_0_3_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1, _TArg1, _TType2,
_TArg2, _TType3, _TArg3) \
+            __inline \
+            _ReturnType __CRTDECL __insecure_##_FuncName(_DstType *_Dst, _TType1 _TArg1,
_TType2 _TArg2, _TType3 _TArg3)
+
+        #define __DEFINE_CPP_OVERLOAD_INLINE_FUNC_0_3_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1,
_TArg1, _TType2, _TArg2, _TType3, _TArg3) \
+            extern "C++" \
+            { \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_T &_Dst, _TType1 _TArg1, _TType2 _TArg2,
_TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(static_cast<_DstType *>(_Dst),
_TArg1, _TArg2, _TArg3); \
+            } \
+            template <typename _T> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(const _T &_Dst, _TType1 _TArg1, _TType2
_TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(static_cast<_DstType *>(_Dst),
_TArg1, _TArg2, _TArg3); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName(_SalAttributeDst _DstType * &_Dst,
_TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                return __insecure_##_FuncName(_Dst, _TArg1, _TArg2, _TArg3); \
+            } \
+            template <size_t _Size> \
+            inline \
+            _ReturnType __CRTDECL _FuncName(_SecureDstType (&_Dst)[_Size], _TType1
_TArg1, _TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureFuncName(_Dst, _Size, _TArg1, _TArg2, _TArg3),
_Dst); \
+            } \
+            template <> \
+            inline \
+            _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+            _ReturnType __CRTDECL _FuncName<1>(_DstType (&_Dst)[1], _TType1
_TArg1, _TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW \
+            { \
+                _ReturnPolicy(_SecureFuncName(_Dst, 1, _TArg1, _TArg2, _TArg3), _Dst); \
+            } \
+            }
+
+        #if _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_0_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _SalAttributeDst, _DstType, _Dst) \
+                __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0_EX(_ReturnType, _ReturnPolicy,
_DeclSpec, _FuncName, _SecureFuncName, _SalAttributeDst, _DstType, _Dst)
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_0_CGETS(_ReturnType,
_DeclSpec, _FuncName, _SalAttributeDst, _DstType, _Dst) \
+                __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0_CGETS(_ReturnType, _DeclSpec,
_FuncName, _SalAttributeDst, _DstType, _Dst)
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_1_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst,
_DstType, _Dst, _TType1, _TArg1) \
+                __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1_EX(_ReturnType, _ReturnPolicy,
_DeclSpec, _FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst,
_TType1, _TArg1)
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst,
_DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2) \
+                __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_EX(_ReturnType, _ReturnPolicy,
_DeclSpec, _FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst,
_TType1, _TArg1, _TType2, _TArg2)
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_3_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst,
_DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3) \
+                __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_3_EX(_ReturnType, _ReturnPolicy,
_DeclSpec, _FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst,
_TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3)
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_4_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _SalAttributeDst, _DstType, _Dst,
_TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3, _TType4) \
+                __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_4_EX(_ReturnType, _ReturnPolicy,
_DeclSpec, _FuncName, _SecureFuncName, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1,
_TType2, _TArg2, _TType3, _TArg3, _TType4)
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_1_1_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _HType1, _HArg1, _SalAttributeDst,
_DstType, _Dst, _TType1, _TArg1) \
+                __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_1_1_EX(_ReturnType, _ReturnPolicy,
_DeclSpec, _FuncName, _SecureFuncName, _HType1, _HArg1, _SalAttributeDst, _DstType, _Dst,
_TType1, _TArg1)
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_2_0_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _HType1, _HArg1, _HType2, _HArg2,
_SalAttributeDst, _DstType, _Dst) \
+                __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_2_0_EX(_ReturnType, _ReturnPolicy,
_DeclSpec, _FuncName, _SecureFuncName, _HType1, _HArg1, _HType2, _HArg2, _SalAttributeDst,
_DstType, _Dst)
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_1_ARGLIST_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _CC, _FuncName, _SecureFuncName, _VFuncName, _SecureVFuncName,
_SalAttributeDst, _DstType, _Dst, _TType1, _TArg1) \
+                __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1_ARGLIST_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _CC, _FuncName, _SecureFuncName, _VFuncName, _SecureVFuncName,
_SalAttributeDst, _DstType, _Dst, _TType1, _TArg1)
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_ARGLIST(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _VFuncName, _SalAttributeDst, _DstType, _Dst,
_TType1, _TArg1, _TType2, _TArg2) \
+                __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_ARGLIST(_ReturnType,
_ReturnPolicy, _DeclSpec, __cdecl, _FuncName, _VFuncName, _SalAttributeDst, _DstType,
_Dst, _TType1, _TArg1, _TType2, _TArg2)
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_ARGLIST_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _CC, _FuncName, _VFuncName, _SecureDstType, _SalAttributeDst,
_DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2) \
+                __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_ARGLIST_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _CC, _FuncName, _VFuncName, _VFuncName##_s, _SecureDstType,
_SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2)
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_SIZE_EX(_DeclSpec,
_FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1,
_TArg1, _TType2, _TArg2) \
+                __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_SIZE_EX(_DeclSpec, _FuncName,
_SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1,
_TType2, _TArg2)
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_3_SIZE_EX(_DeclSpec,
_FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1,
_TArg1, _TType2, _TArg2, _TType3, _TArg3) \
+                __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_3_SIZE_EX(_DeclSpec, _FuncName,
_SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1,
_TType2, _TArg2, _TType3, _TArg3)
+
+
+            #define __DECLARE_CPP_OVERLOAD_INLINE_NFUNC_0_0_EX(_ReturnType,
_ReturnPolicy, _FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst) \
+                __DECLARE_CPP_OVERLOAD_INLINE_FUNC_0_0_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType _DstType, _Dst)
+
+            #define __DEFINE_CPP_OVERLOAD_INLINE_NFUNC_0_0_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst) \
+                __DEFINE_CPP_OVERLOAD_INLINE_FUNC_0_0_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst)
+
+            #define __DECLARE_CPP_OVERLOAD_INLINE_NFUNC_0_1_EX(_ReturnType,
_ReturnPolicy, _FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1,
_TArg1) \
+                __DECLARE_CPP_OVERLOAD_INLINE_FUNC_0_1_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType _DstType, _Dst, _TType1, _TArg1)
+
+            #define __DEFINE_CPP_OVERLOAD_INLINE_NFUNC_0_1_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1, _TArg1) \
+                __DEFINE_CPP_OVERLOAD_INLINE_FUNC_0_1_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1, _TArg1)
+
+            #define __DECLARE_CPP_OVERLOAD_INLINE_NFUNC_0_2_EX(_ReturnType,
_ReturnPolicy, _FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1,
_TArg1, _TType2, _TArg2) \
+                __DECLARE_CPP_OVERLOAD_INLINE_FUNC_0_2_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1, _TArg1, _TType2,
_TArg2)
+
+            #define __DEFINE_CPP_OVERLOAD_INLINE_NFUNC_0_2_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1,
_TArg1, _TType2, _TArg2) \
+                __DEFINE_CPP_OVERLOAD_INLINE_FUNC_0_2_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1,
_TArg1, _TType2, _TArg2)
+
+            #define __DECLARE_CPP_OVERLOAD_INLINE_NFUNC_0_3_EX(_ReturnType,
_ReturnPolicy, _FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1,
_TArg1, _TType2, _TArg2, _TType3, _TArg3) \
+                __DECLARE_CPP_OVERLOAD_INLINE_FUNC_0_3_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1, _TArg1, _TType2,
_TArg2, _TType3, _TArg3)
+
+            #define __DEFINE_CPP_OVERLOAD_INLINE_NFUNC_0_3_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1,
_TArg1, _TType2, _TArg2, _TType3, _TArg3) \
+                __DEFINE_CPP_OVERLOAD_INLINE_FUNC_0_3_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1,
_TArg1, _TType2, _TArg2, _TType3, _TArg3)
+
+        #else // ^^^ _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT ^^^ // vvv
_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT vvv //
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_0_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _SalAttributeDst, _DstType, _Dst) \
+                    _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType
__cdecl _FuncName(_SalAttributeDst _DstType *_Dst);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_0_GETS(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _DstType, _Dst) \
+                    _CRT_INSECURE_DEPRECATE(_FuncName##_s) _DeclSpec _ReturnType __cdecl
_FuncName(_DstType *_Dst);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_1_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst,
_DstType, _Dst, _TType1, _TArg1) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst,
_DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_3_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst,
_DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3
_TArg3);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_4_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _SalAttributeDst, _DstType, _Dst,
_TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3, _TType4, _TArg4) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3,
_TType4 _TArg4);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_1_1_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _HType1, _HArg1, _SalAttributeDst,
_DstType, _Dst, _TType1, _TArg1) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl
_FuncName(_HType1 _HArg1, _SalAttributeDst _DstType *_Dst, _TType1 _TArg1);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_2_0_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _HType1, _HArg1, _HType2, _HArg2,
_SalAttributeDst, _DstType, _Dst) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl
_FuncName(_HType1 _HArg1, _HType2 _HArg2, _SalAttributeDst _DstType *_Dst);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_1_ARGLIST_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _CC, _FuncName, _SecureFuncName,_VFuncName, _SecureVFuncName,
_SalAttributeDst, _DstType, _Dst, _TType1, _TArg1) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType _CC
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, ...); \
+                _CRT_INSECURE_DEPRECATE(_SecureVFuncName) _DeclSpec _ReturnType _CC
_VFuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, va_list _Args);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_ARGLIST(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _VFuncName, _SalAttributeDst, _DstType, _Dst,
_TType1, _TArg1, _TType2, _TArg2) \
+                _CRT_INSECURE_DEPRECATE(_FuncName##_s) _DeclSpec _ReturnType __cdecl
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, ...); \
+                _CRT_INSECURE_DEPRECATE(_VFuncName##_s) _DeclSpec _ReturnType __cdecl
_VFuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, va_list
_Args);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_ARGLIST_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _CC, _FuncName, _VFuncName, _SecureDstType, _SalAttributeDst,
_DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2) \
+                _CRT_INSECURE_DEPRECATE(_FuncName##_s) _DeclSpec _ReturnType _CC
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, ...); \
+                _CRT_INSECURE_DEPRECATE(_VFuncName##_s) _DeclSpec _ReturnType _CC
_VFuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, va_list
_Args);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_SIZE_EX(_DeclSpec,
_FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1,
_TArg1, _TType2, _TArg2) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec size_t __cdecl
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_3_SIZE_EX(_DeclSpec,
_FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1,
_TArg1, _TType2, _TArg2, _TType3, _TArg3) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec size_t __cdecl
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3
_TArg3);
+
+
+            #define __DECLARE_CPP_OVERLOAD_INLINE_NFUNC_0_0_EX(_ReturnType,
_ReturnPolicy, _FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+                __inline \
+                _ReturnType __CRTDECL _FuncName(_DstType *_Dst)
+
+            #define __DEFINE_CPP_OVERLOAD_INLINE_NFUNC_0_0_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst)
+
+            #define __DECLARE_CPP_OVERLOAD_INLINE_NFUNC_0_1_EX(_ReturnType,
_ReturnPolicy, _FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1,
_TArg1) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+                __inline \
+                _ReturnType __CRTDECL _FuncName(_DstType *_Dst, _TType1 _TArg1)
+
+            #define __DEFINE_CPP_OVERLOAD_INLINE_NFUNC_0_1_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1, _TArg1)
+
+            #define __DECLARE_CPP_OVERLOAD_INLINE_NFUNC_0_2_EX(_ReturnType,
_ReturnPolicy, _FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1,
_TArg1, _TType2, _TArg2) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+                __inline \
+                _ReturnType __CRTDECL _FuncName(_DstType *_Dst, _TType1 _TArg1, _TType2
_TArg2)
+
+            #define __DEFINE_CPP_OVERLOAD_INLINE_NFUNC_0_2_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1,
_TArg1, _TType2, _TArg2)
+
+            #define __DECLARE_CPP_OVERLOAD_INLINE_NFUNC_0_3_EX(_ReturnType,
_ReturnPolicy, _FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1,
_TArg1, _TType2, _TArg2, _TType3, _TArg3) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+                __inline \
+                _ReturnType __CRTDECL _FuncName(_DstType *_Dst, _TType1 _TArg1, _TType2
_TArg2, _TType3 _TArg3)
+
+            #define __DEFINE_CPP_OVERLOAD_INLINE_NFUNC_0_3_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1,
_TArg1, _TType2, _TArg2, _TType3, _TArg3)
+
+        #endif // !_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT
+
+    #else  // ^^^ _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES ^^^ // vvv
!_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES vvv //
+
+        #define __RETURN_POLICY_SAME(_FunctionCall)
+        #define __RETURN_POLICY_DST(_FunctionCall)
+        #define __RETURN_POLICY_VOID(_FunctionCall)
+        #define __EMPTY_DECLSPEC
+
+        #if _CRT_FUNCTIONS_REQUIRED
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _SalAttributeDst, _DstType, _Dst) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl
_FuncName(_SalAttributeDst _DstType *_Dst);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0_CGETS(_ReturnType, _DeclSpec,
_FuncName, _SalAttributeDst, _DstType, _Dst) \
+                _CRT_INSECURE_DEPRECATE(_FuncName##_s) _DeclSpec _ReturnType __cdecl
_FuncName(_SalAttributeDst _DstType *_Dst);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst,
_DstType, _Dst, _TType1, _TArg1) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst,
_DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_3_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst,
_DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3
_TArg3);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_4_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _SalAttributeDst, _DstType, _Dst,
_TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3, _TType4, _TArg4) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3,
_TType4 _TArg4);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_1_1_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _HType1, _HArg1, _SalAttributeDst,
_DstType, _Dst, _TType1, _TArg1) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl
_FuncName(_HType1 _HArg1, _SalAttributeDst _DstType *_Dst, _TType1 _TArg1);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_2_0_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _HType1, _HArg1, _HType2, _HArg2,
_SalAttributeDst, _DstType, _Dst) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl
_FuncName(_HType1 _HArg1, _HType2 _HArg2, _SalAttributeDst _DstType *_Dst);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1_ARGLIST_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _CC, _FuncName, _SecureFuncName, _VFuncName, _SecureVFuncName,
_SalAttributeDst, _DstType, _Dst, _TType1, _TArg1) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType _CC
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, ...); \
+                _CRT_INSECURE_DEPRECATE(_SecureVFuncName) _DeclSpec _ReturnType _CC
_VFuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, va_list _Args);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_ARGLIST_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _CC, _FuncName, _VFuncName, _SecureVFuncName, _SecureDstType,
_SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2) \
+                _CRT_INSECURE_DEPRECATE(_FuncName##_s) _DeclSpec _ReturnType _CC
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, ...); \
+                _CRT_INSECURE_DEPRECATE(_SecureVFuncName) _DeclSpec _ReturnType _CC
_VFuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, va_list
_Args);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_SIZE_EX(_DeclSpec, _FuncName,
_SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1,
_TType2, _TArg2) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec size_t __cdecl
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_3_SIZE_EX(_DeclSpec, _FuncName,
_SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1,
_TType2, _TArg2, _TType3, _TArg3) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec size_t __cdecl
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3
_TArg3);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_0_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _SalAttributeDst, _DstType, _Dst) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl
_FuncName(_SalAttributeDst _DstType *_Dst);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_0_GETS(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _DstType, _Dst) \
+                _CRT_INSECURE_DEPRECATE(_FuncName##_s) _DeclSpec _ReturnType __cdecl
_FuncName(_DstType *_Dst);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_1_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst,
_DstType, _Dst, _TType1, _TArg1) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst,
_DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_3_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst,
_DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3
_TArg3);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_4_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _SalAttributeDst, _DstType, _Dst,
_TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3, _TType4, _TArg4) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3,
_TType4 _TArg4);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_1_1_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _HType1, _HArg1, _SalAttributeDst,
_DstType, _Dst, _TType1, _TArg1) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl
_FuncName(_HType1 _HArg1, _SalAttributeDst _DstType *_Dst, _TType1 _TArg1);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_2_0_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _HType1, _HArg1, _HType2, _HArg2,
_SalAttributeDst, _DstType, _Dst) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl
_FuncName(_HType1 _HArg1, _HType2 _HArg2, _SalAttributeDst _DstType *_Dst);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_1_ARGLIST_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _CC, _FuncName, _SecureFuncName, _VFuncName, _SecureVFuncName,
_SalAttributeDst, _DstType, _Dst, _TType1, _TArg1) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType _CC
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, ...); \
+                _CRT_INSECURE_DEPRECATE(_SecureVFuncName) _DeclSpec _ReturnType _CC
_VFuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, va_list _Args);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_ARGLIST(_ReturnType,
_ReturnPolicy, _DeclSpec, _FuncName, _VFuncName, _SalAttributeDst, _DstType, _Dst,
_TType1, _TArg1, _TType2, _TArg2) \
+                _CRT_INSECURE_DEPRECATE(_FuncName##_s) _DeclSpec _ReturnType __cdecl
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, ...); \
+                _CRT_INSECURE_DEPRECATE(_VFuncName##_s) _DeclSpec _ReturnType __cdecl
_VFuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, va_list
_Args);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_ARGLIST_EX(_ReturnType,
_ReturnPolicy, _DeclSpec, _CC, _FuncName, _VFuncName, _SecureDstType, _SalAttributeDst,
_DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2) \
+                _CRT_INSECURE_DEPRECATE(_FuncName##_s) _DeclSpec _ReturnType _CC
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, ...); \
+                _CRT_INSECURE_DEPRECATE(_VFuncName##_s) _DeclSpec _ReturnType _CC
_VFuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, va_list
_Args);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_SIZE_EX(_DeclSpec,
_FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1,
_TArg1, _TType2, _TArg2) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec size_t __cdecl
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2);
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_3_SIZE_EX(_DeclSpec,
_FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1,
_TArg1, _TType2, _TArg2, _TType3, _TArg3) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec size_t __cdecl
_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3
_TArg3);
+
+
+            #define __DECLARE_CPP_OVERLOAD_INLINE_FUNC_0_0_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+                __inline \
+                _ReturnType __CRTDECL _FuncName(_DstType *_Dst)
+
+            #define __DEFINE_CPP_OVERLOAD_INLINE_FUNC_0_0_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst)
+
+            #define __DECLARE_CPP_OVERLOAD_INLINE_FUNC_0_1_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1, _TArg1) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+                __inline \
+                _ReturnType __CRTDECL _FuncName(_DstType *_Dst, _TType1 _TArg1)
+
+            #define __DEFINE_CPP_OVERLOAD_INLINE_FUNC_0_1_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1, _TArg1)
+
+            #define __DECLARE_CPP_OVERLOAD_INLINE_FUNC_0_2_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1, _TArg1, _TType2,
_TArg2) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+                __inline \
+                _ReturnType __CRTDECL _FuncName(_DstType *_Dst, _TType1 _TArg1, _TType2
_TArg2)
+
+            #define __DEFINE_CPP_OVERLOAD_INLINE_FUNC_0_2_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1,
_TArg1, _TType2, _TArg2)
+
+            #define __DECLARE_CPP_OVERLOAD_INLINE_FUNC_0_3_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1, _TArg1, _TType2,
_TArg2, _TType3, _TArg3) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+                __inline \
+                _ReturnType __CRTDECL _FuncName(_DstType *_Dst, _TType1 _TArg1, _TType2
_TArg2, _TType3 _TArg3)
+
+            #define __DEFINE_CPP_OVERLOAD_INLINE_FUNC_0_3_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1,
_TArg1, _TType2, _TArg2, _TType3, _TArg3)
+
+            #define __DECLARE_CPP_OVERLOAD_INLINE_NFUNC_0_0_EX(_ReturnType,
_ReturnPolicy, _FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+                __inline \
+                _ReturnType __CRTDECL _FuncName(_DstType *_Dst)
+
+            #define __DEFINE_CPP_OVERLOAD_INLINE_NFUNC_0_0_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst)
+
+            #define __DECLARE_CPP_OVERLOAD_INLINE_NFUNC_0_1_EX(_ReturnType,
_ReturnPolicy, _FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1,
_TArg1) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+                __inline \
+                _ReturnType __CRTDECL _FuncName(_DstType *_Dst, _TType1 _TArg1)
+
+            #define __DEFINE_CPP_OVERLOAD_INLINE_NFUNC_0_1_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1, _TArg1)
+
+            #define __DECLARE_CPP_OVERLOAD_INLINE_NFUNC_0_2_EX(_ReturnType,
_ReturnPolicy, _FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1,
_TArg1, _TType2, _TArg2) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+                __inline \
+                _ReturnType __CRTDECL _FuncName(_DstType *_Dst, _TType1 _TArg1, _TType2
_TArg2)
+
+            #define __DEFINE_CPP_OVERLOAD_INLINE_NFUNC_0_2_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1,
_TArg1, _TType2, _TArg2)
+
+            #define __DECLARE_CPP_OVERLOAD_INLINE_NFUNC_0_3_EX(_ReturnType,
_ReturnPolicy, _FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1,
_TArg1, _TType2, _TArg2, _TType3, _TArg3) \
+                _CRT_INSECURE_DEPRECATE(_SecureFuncName) \
+                __inline \
+                _ReturnType __CRTDECL _FuncName(_DstType *_Dst, _TType1 _TArg1, _TType2
_TArg2, _TType3 _TArg3)
+
+            #define __DEFINE_CPP_OVERLOAD_INLINE_NFUNC_0_3_EX(_ReturnType, _ReturnPolicy,
_FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1,
_TArg1, _TType2, _TArg2, _TType3, _TArg3)
+
+        #else // ^^^ _CRT_FUNCTIONS_REQUIRED ^^^ // vvv !_CRT_FUNCTIONS_REQUIRED vvv //
+
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0_CGETS(...)
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_3_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_4_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_1_1_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_2_0_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1_ARGLIST_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_ARGLIST_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_SIZE_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_3_SIZE_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_0_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_0_GETS(...)
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_1_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_3_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_4_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_1_1_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_2_0_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_1_ARGLIST_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_ARGLIST(...)
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_ARGLIST_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_SIZE_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_3_SIZE_EX(...)
+            #define __DECLARE_CPP_OVERLOAD_INLINE_FUNC_0_0_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_INLINE_FUNC_0_0_EX(...)
+            #define __DECLARE_CPP_OVERLOAD_INLINE_FUNC_0_1_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_INLINE_FUNC_0_1_EX(...)
+            #define __DECLARE_CPP_OVERLOAD_INLINE_FUNC_0_2_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_INLINE_FUNC_0_2_EX(...)
+            #define __DECLARE_CPP_OVERLOAD_INLINE_FUNC_0_3_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_INLINE_FUNC_0_3_EX(...)
+            #define __DECLARE_CPP_OVERLOAD_INLINE_NFUNC_0_0_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_INLINE_NFUNC_0_0_EX(...)
+            #define __DECLARE_CPP_OVERLOAD_INLINE_NFUNC_0_1_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_INLINE_NFUNC_0_1_EX(...)
+            #define __DECLARE_CPP_OVERLOAD_INLINE_NFUNC_0_2_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_INLINE_NFUNC_0_2_EX(...)
+            #define __DECLARE_CPP_OVERLOAD_INLINE_NFUNC_0_3_EX(...)
+            #define __DEFINE_CPP_OVERLOAD_INLINE_NFUNC_0_3_EX(...)
+
+        #endif // !_CRT_FUNCTIONS_REQUIRED
+    #endif // !_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES
+#endif
+
+_CRT_END_C_HEADER
+
+_UCRT_RESTORE_CLANG_WARNINGS
+#pragma warning(pop) // _UCRT_DISABLED_WARNINGS
diff --git a/sdk/include/ucrt/corecrt_io.h b/sdk/include/ucrt/corecrt_io.h
new file mode 100644
index 00000000000..5beefbc8812
--- /dev/null
+++ b/sdk/include/ucrt/corecrt_io.h
@@ -0,0 +1,572 @@
+//
+// corecrt_io.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// This file declares the low-level I/O and file handling functionality.  These
+// declarations are split out to support the Windows build.
+//
+#pragma once
+
+#include <corecrt_share.h>
+#include <corecrt_wio.h>
+
+#pragma warning(push)
+#pragma warning(disable: _UCRT_DISABLED_WARNINGS)
+_UCRT_DISABLE_CLANG_WARNINGS
+
+_CRT_BEGIN_C_HEADER
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Types
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#ifdef _USE_32BIT_TIME_T
+    #define _finddata_t     _finddata32_t
+    #define _finddatai64_t  _finddata32i64_t
+#else
+    #define _finddata_t     _finddata64i32_t
+    #define _finddatai64_t  __finddata64_t
+#endif
+
+struct _finddata32_t
+{
+    unsigned    attrib;
+    __time32_t  time_create;    // -1 for FAT file systems
+    __time32_t  time_access;    // -1 for FAT file systems
+    __time32_t  time_write;
+    _fsize_t    size;
+    char        name[260];
+};
+
+struct _finddata32i64_t
+{
+    unsigned    attrib;
+    __time32_t  time_create;    // -1 for FAT file systems
+    __time32_t  time_access;    // -1 for FAT file systems
+    __time32_t  time_write;
+    __int64     size;
+    char        name[260];
+};
+
+struct _finddata64i32_t
+{
+    unsigned    attrib;
+    __time64_t  time_create;    // -1 for FAT file systems
+    __time64_t  time_access;    // -1 for FAT file systems
+    __time64_t  time_write;
+    _fsize_t    size;
+    char        name[260];
+};
+
+struct __finddata64_t
+{
+    unsigned    attrib;
+    __time64_t  time_create;    // -1 for FAT file systems
+    __time64_t  time_access;    // -1 for FAT file systems
+    __time64_t  time_write;
+    __int64     size;
+    char        name[260];
+};
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Macros
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// File attribute constants for the _findfirst() family of functions
+#define _A_NORMAL 0x00 // Normal file - No read/write restrictions
+#define _A_RDONLY 0x01 // Read only file
+#define _A_HIDDEN 0x02 // Hidden file
+#define _A_SYSTEM 0x04 // System file
+#define _A_SUBDIR 0x10 // Subdirectory
+#define _A_ARCH   0x20 // Archive file
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Functions
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#ifdef _USE_32BIT_TIME_T
+    #define _findfirst      _findfirst32
+    #define _findnext       _findnext32
+    #define _findfirsti64   _findfirst32i64
+    #define _findnexti64     _findnext32i64
+#else
+    #define _findfirst      _findfirst64i32
+    #define _findnext       _findnext64i32
+    #define _findfirsti64   _findfirst64
+    #define _findnexti64    _findnext64
+#endif
+
+#if _CRT_FUNCTIONS_REQUIRED
+
+    _Check_return_
+    _ACRTIMP int __cdecl _access(
+        _In_z_ char const* _FileName,
+        _In_   int         _AccessMode
+        );
+
+    _Check_return_wat_
+    _ACRTIMP errno_t __cdecl _access_s(
+        _In_z_ char const* _FileName,
+        _In_   int         _AccessMode
+        );
+
+    _Check_return_
+    _ACRTIMP int __cdecl _chmod(
+        _In_z_ char const* _FileName,
+        _In_   int         _Mode
+        );
+
+    _Check_return_
+    _ACRTIMP int __cdecl _chsize(
+        _In_ int  _FileHandle,
+        _In_ long _Size
+        );
+
+    _Check_return_wat_
+    _ACRTIMP errno_t __cdecl _chsize_s(
+        _In_ int     _FileHandle,
+        _In_ __int64 _Size
+        );
+
+    _Check_return_opt_
+    _ACRTIMP int __cdecl _close(
+        _In_ int _FileHandle
+        );
+
+    _Check_return_opt_
+    _ACRTIMP int __cdecl _commit(
+        _In_ int _FileHandle
+        );
+
+    _Check_return_ _CRT_INSECURE_DEPRECATE(_sopen_s)
+    _ACRTIMP int __cdecl _creat(
+        _In_z_ char const* _FileName,
+        _In_   int         _PermissionMode
+        );
+
+    _Check_return_
+    _ACRTIMP int __cdecl _dup(
+        _In_ int _FileHandle
+        );
+
+    _Check_return_
+    _ACRTIMP int __cdecl _dup2(
+        _In_ int _FileHandleSrc,
+        _In_ int _FileHandleDst
+        );
+
+    _Check_return_
+    _ACRTIMP int __cdecl _eof(
+        _In_ int _FileHandle
+        );
+
+    _Check_return_
+    _ACRTIMP long __cdecl _filelength(
+        _In_ int _FileHandle
+        );
+
+    _Success_(return != -1)
+    _Check_return_
+    _ACRTIMP intptr_t __cdecl _findfirst32(
+        _In_z_ char const*           _FileName,
+        _Out_  struct _finddata32_t* _FindData
+        );
+
+    _Success_(return != -1)
+    _Check_return_
+    _ACRTIMP int __cdecl _findnext32(
+        _In_  intptr_t              _FindHandle,
+        _Out_ struct _finddata32_t* _FindData
+        );
+
+    _Check_return_opt_
+    _ACRTIMP int __cdecl _findclose(
+        _In_ intptr_t _FindHandle
+        );
+
+    _ACRTIMP intptr_t __cdecl _get_osfhandle(
+            _In_ int _FileHandle
+            );
+
+    _Check_return_
+    _ACRTIMP int __cdecl _isatty(
+        _In_ int _FileHandle
+        );
+
+    _ACRTIMP int __cdecl _locking(
+            _In_ int  _FileHandle,
+            _In_ int  _LockMode,
+            _In_ long _NumOfBytes
+            );
+
+    _Check_return_opt_
+    _ACRTIMP long __cdecl _lseek(
+        _In_ int  _FileHandle,
+        _In_ long _Offset,
+        _In_ int  _Origin
+        );
+
+    _Success_(return == 0)
+    _Check_return_wat_
+    _ACRTIMP errno_t __cdecl _mktemp_s(
+        _Inout_updates_z_(_Size) char*  _TemplateName,
+        _In_                     size_t _Size
+        );
+
+    __DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_0(
+        errno_t, _mktemp_s,
+        _Prepost_z_ char, _TemplateName
+        )
+
+    _Success_(return != 0)
+    _Check_return_ __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0(
+        char *, __RETURN_POLICY_DST, _ACRTIMP, _mktemp,
+        _Inout_z_, char, _TemplateName
+        )
+
+    _ACRTIMP int __cdecl _open_osfhandle(
+        _In_ intptr_t _OSFileHandle,
+        _In_ int      _Flags
+        );
+
+    #ifdef _CRT_USE_WINAPI_FAMILY_DESKTOP_APP
+        _Success_(return != -1)
+        _Check_return_
+        _DCRTIMP int __cdecl _pipe(
+            _Out_writes_(2)    int*         _PtHandles,
+            _In_               unsigned int _PipeSize,
+            _In_               int          _TextMode
+            );
+    #endif
+
+    _Success_(return != -1)
+    _Check_return_
+    _ACRTIMP int __cdecl _read(
+        _In_                              int          _FileHandle,
+        _Out_writes_bytes_(_MaxCharCount) void*        _DstBuf,
+        _In_                              unsigned int _MaxCharCount
+        );
+
+    _ACRTIMP int __cdecl remove(
+        _In_z_ char const* _FileName
+        );
+
+    _Check_return_
+    _ACRTIMP int __cdecl rename(
+        _In_z_ char const* _OldFilename,
+        _In_z_ char const* _NewFilename
+        );
+
+    _ACRTIMP int __cdecl _unlink(
+        _In_z_ char const* _FileName
+        );
+
+    _Check_return_
+    _ACRTIMP int __cdecl _setmode(
+        _In_ int _FileHandle,
+        _In_ int _Mode
+        );
+
+    _Check_return_
+    _ACRTIMP long __cdecl _tell(
+        _In_ int _FileHandle
+        );
+
+    _CRT_INSECURE_DEPRECATE(_umask_s)
+    _ACRTIMP int __cdecl _umask(
+        _In_ int _Mode
+        );
+
+    _Check_return_wat_
+    _ACRTIMP errno_t __cdecl _umask_s(
+        _In_  int  _NewMode,
+        _Out_ int* _OldMode
+        );
+
+    _ACRTIMP int __cdecl _write(
+        _In_                            int          _FileHandle,
+        _In_reads_bytes_(_MaxCharCount) void const*  _Buf,
+        _In_                            unsigned int _MaxCharCount
+        );
+
+    _Check_return_
+    _ACRTIMP __int64 __cdecl _filelengthi64(
+        _In_ int _FileHandle
+        );
+
+    _Success_(return != -1)
+    _Check_return_
+    _ACRTIMP intptr_t __cdecl _findfirst32i64(
+        _In_z_ char const*              _FileName,
+        _Out_  struct _finddata32i64_t* _FindData
+        );
+
+    _Success_(return != -1)
+    _Check_return_
+    _ACRTIMP intptr_t __cdecl _findfirst64i32(
+        _In_z_ char const*              _FileName,
+        _Out_  struct _finddata64i32_t* _FindData
+        );
+
+    _Success_(return != -1)
+    _Check_return_
+    _ACRTIMP intptr_t __cdecl _findfirst64(
+        _In_z_ char const*            _FileName,
+        _Out_  struct __finddata64_t* _FindData
+        );
+
+    _Success_(return != -1)
+    _Check_return_
+    _ACRTIMP int __cdecl _findnext32i64(
+        _In_  intptr_t                 _FindHandle,
+        _Out_ struct _finddata32i64_t* _FindData
+        );
+
+    _Success_(return != -1)
+    _Check_return_
+    _ACRTIMP int __cdecl _findnext64i32(
+        _In_  intptr_t                 _FindHandle,
+        _Out_ struct _finddata64i32_t* _FindData
+        );
+
+    _Success_(return != -1)
+    _Check_return_
+    _ACRTIMP int __cdecl _findnext64(
+        _In_  intptr_t               _FindHandle,
+        _Out_ struct __finddata64_t* _FindData
+        );
+
+    _Check_return_opt_
+    _ACRTIMP __int64 __cdecl _lseeki64(
+        _In_ int     _FileHandle,
+        _In_ __int64 _Offset,
+        _In_ int     _Origin
+        );
+
+    _Check_return_
+    _ACRTIMP __int64 __cdecl _telli64(
+        _In_ int _FileHandle
+        );
+
+    _Check_return_wat_
+    _ACRTIMP errno_t __cdecl _sopen_s(
+        _Out_  int*        _FileHandle,
+        _In_z_ char const* _FileName,
+        _In_   int         _OpenFlag,
+        _In_   int         _ShareFlag,
+        _In_   int         _PermissionMode
+        );
+
+    _Check_return_
+    _ACRTIMP errno_t __cdecl _sopen_s_nolock(
+        _Out_  int*        _FileHandle,
+        _In_z_ char const* _FileName,
+        _In_   int         _OpenFlag,
+        _In_   int         _ShareFlag,
+        _In_   int         _PermissionMode
+        );
+
+    _ACRTIMP errno_t __cdecl _sopen_dispatch(
+        _In_z_ char const* _FileName,
+        _In_   int         _OFlag,
+        _In_   int         _ShFlag,
+        _In_   int         _PMode,
+        _Out_  int*        _PFileHandle,
+        _In_   int         _BSecure
+        );
+
+
+
+    #ifdef __cplusplus
+
+        // These function do not validate pmode; use _sopen_s instead.
+        extern "C++" _Check_return_ _CRT_INSECURE_DEPRECATE(_sopen_s)
+        inline int __CRTDECL _open(
+            _In_z_ char const* const _FileName,
+            _In_   int         const _OFlag,
+            _In_   int         const _PMode = 0
+            )
+        {
+            int _FileHandle;
+            // Last parameter passed as 0 because we don't want to validate pmode
from _open
+            errno_t const _Result = _sopen_dispatch(_FileName, _OFlag, _SH_DENYNO,
_PMode, &_FileHandle, 0);
+            return _Result ? -1 : _FileHandle;
+        }
+
+        extern "C++" _Check_return_ _CRT_INSECURE_DEPRECATE(_sopen_s)
+        inline int __CRTDECL _sopen(
+            _In_z_ char const* const _FileName,
+            _In_   int         const _OFlag,
+            _In_   int         const _ShFlag,
+            _In_   int         const _PMode = 0
+            )
+        {
+            int _FileHandle;
+            // Last parameter passed as 0 because we don't want to validate pmode
from _sopen
+            errno_t const _Result = _sopen_dispatch(_FileName, _OFlag, _ShFlag, _PMode,
&_FileHandle, 0);
+            return _Result ? -1 : _FileHandle;
+        }
+
+    #else
+
+        _Check_return_ _CRT_INSECURE_DEPRECATE(_sopen_s)
+        _ACRTIMP int __cdecl _open(
+            _In_z_ char const* _FileName,
+            _In_   int         _OpenFlag,
+            ...);
+
+        _Check_return_ _CRT_INSECURE_DEPRECATE(_sopen_s)
+        _ACRTIMP int __cdecl _sopen(
+            _In_z_ char const* _FileName,
+            _In_   int         _OpenFlag,
+            _In_   int         _ShareFlag,
+            ...);
+
+    #endif
+
+
+
+    #if defined(_CRT_INTERNAL_NONSTDC_NAMES) && _CRT_INTERNAL_NONSTDC_NAMES
+        // Suppress warnings about double deprecation
+        #pragma warning(push)
+        #pragma warning(disable: 4141)
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_access)
+        _ACRTIMP int __cdecl access(
+            _In_z_ char const* _FileName,
+            _In_   int         _AccessMode
+            );
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_chmod)
+        _ACRTIMP int __cdecl chmod(
+            _In_z_ char const* _FileName,
+            _In_   int         _AccessMode
+            );
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_chsize)
+        _ACRTIMP int __cdecl chsize(
+            _In_ int  _FileHandle,
+            _In_ long _Size
+            );
+
+        _Check_return_opt_ _CRT_NONSTDC_DEPRECATE(_close)
+        _ACRTIMP int __cdecl close(
+            _In_ int _FileHandle
+        );
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_creat) _CRT_INSECURE_DEPRECATE(_sopen_s)
+        _ACRTIMP int __cdecl creat(
+            _In_z_ char const* _FileName,
+            _In_   int         _PermissionMode
+            );
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_dup)
+        _ACRTIMP int __cdecl dup(
+            _In_ int _FileHandle
+            );
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_dup2)
+        _ACRTIMP int __cdecl dup2(
+            _In_ int _FileHandleSrc,
+            _In_ int _FileHandleDst
+            );
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_eof)
+        _ACRTIMP int __cdecl eof(
+            _In_ int _FileHandle
+            );
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_filelength)
+        _ACRTIMP long __cdecl filelength(
+            _In_ int _FileHandle
+            );
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_isatty)
+        _ACRTIMP int __cdecl isatty(
+            _In_ int _FileHandle
+            );
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_locking)
+        _ACRTIMP int __cdecl locking(
+            _In_ int  _FileHandle,
+            _In_ int  _LockMode,
+            _In_ long _NumOfBytes
+            );
+
+        _Check_return_opt_ _CRT_NONSTDC_DEPRECATE(_lseek)
+        _ACRTIMP long __cdecl lseek(
+            _In_ int  _FileHandle,
+            _In_ long _Offset,
+            _In_ int  _Origin
+            );
+
+        _Success_(return != 0)
+        _CRT_NONSTDC_DEPRECATE(_mktemp) _CRT_INSECURE_DEPRECATE(_mktemp_s)
+        _ACRTIMP char * __cdecl mktemp(
+            _Inout_z_ char* _TemplateName
+            );
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_open) _CRT_INSECURE_DEPRECATE(_sopen_s)
+        _ACRTIMP int __cdecl open(
+            _In_z_ char const* _FileName,
+            _In_   int         _OpenFlag,
+            ...);
+
+        _Success_(return != -1)
+        _CRT_NONSTDC_DEPRECATE(_read)
+        _ACRTIMP int __cdecl read(
+            _In_                              int          _FileHandle,
+            _Out_writes_bytes_(_MaxCharCount) void*        _DstBuf,
+            _In_                              unsigned int _MaxCharCount
+            );
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_setmode)
+        _ACRTIMP int __cdecl setmode(
+            _In_ int _FileHandle,
+            _In_ int _Mode
+            );
+
+        _CRT_NONSTDC_DEPRECATE(_sopen) _CRT_INSECURE_DEPRECATE(_sopen_s)
+        _ACRTIMP int __cdecl sopen(
+            _In_ char const* _FileName,
+            _In_ int         _OpenFlag,
+            _In_ int         _ShareFlag,
+            ...);
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_tell)
+        _ACRTIMP long __cdecl tell(
+            _In_ int _FileHandle
+            );
+
+        _CRT_NONSTDC_DEPRECATE(_umask) _CRT_INSECURE_DEPRECATE(_umask_s)
+        _ACRTIMP int __cdecl umask(
+            _In_ int _Mode
+            );
+
+        _CRT_NONSTDC_DEPRECATE(_unlink)
+        _ACRTIMP int __cdecl unlink(
+            _In_z_ char const* _FileName
+            );
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_write)
+        _ACRTIMP int __cdecl write(
+            _In_                            int          _FileHandle,
+            _In_reads_bytes_(_MaxCharCount) void const*  _Buf,
+            _In_                            unsigned int _MaxCharCount
+            );
+
+        #pragma warning(pop)
+    #endif // _CRT_INTERNAL_NONSTDC_NAMES
+#endif // _CRT_FUNCTIONS_REQUIRED
+
+_CRT_END_C_HEADER
+_UCRT_RESTORE_CLANG_WARNINGS
+#pragma warning(pop) // _UCRT_DISABLED_WARNINGS
diff --git a/sdk/include/ucrt/corecrt_malloc.h b/sdk/include/ucrt/corecrt_malloc.h
new file mode 100644
index 00000000000..b6d90bdf975
--- /dev/null
+++ b/sdk/include/ucrt/corecrt_malloc.h
@@ -0,0 +1,234 @@
+//
+// corecrt_malloc.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The memory allocation library.  These pieces of the allocation library are
+// shared by both <stdlib.h> and <malloc.h>.
+//
+#pragma once
+
+#include <corecrt.h>
+
+#pragma warning(push)
+#pragma warning(disable: _UCRT_DISABLED_WARNINGS)
+_UCRT_DISABLE_CLANG_WARNINGS
+
+_CRT_BEGIN_C_HEADER
+
+
+
+#if defined _DEBUG && defined _CRTDBG_MAP_ALLOC
+    #pragma push_macro("_aligned_free")
+    #pragma push_macro("_aligned_malloc")
+    #pragma push_macro("_aligned_msize")
+    #pragma push_macro("_aligned_offset_malloc")
+    #pragma push_macro("_aligned_offset_realloc")
+    #pragma push_macro("_aligned_offset_recalloc")
+    #pragma push_macro("_aligned_realloc")
+    #pragma push_macro("_aligned_recalloc")
+    #pragma push_macro("_expand")
+    #pragma push_macro("_freea")
+    #pragma push_macro("_msize")
+    #pragma push_macro("_recalloc")
+    #pragma push_macro("calloc")
+    #pragma push_macro("free")
+    #pragma push_macro("malloc")
+    #pragma push_macro("realloc")
+
+    #undef _aligned_free
+    #undef _aligned_malloc
+    #undef _aligned_msize
+    #undef _aligned_offset_malloc
+    #undef _aligned_offset_realloc
+    #undef _aligned_offset_recalloc
+    #undef _aligned_realloc
+    #undef _aligned_recalloc
+    #undef _expand
+    #undef _freea
+    #undef _msize
+    #undef _recalloc
+    #undef calloc
+    #undef free
+    #undef malloc
+    #undef realloc
+#endif
+
+_Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Count * _Size)
+_ACRTIMP _CRTALLOCATOR _CRTRESTRICT
+void* __cdecl _calloc_base(
+    _In_ size_t _Count,
+    _In_ size_t _Size
+    );
+
+_Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Count * _Size)
+_ACRTIMP _CRT_JIT_INTRINSIC _CRTALLOCATOR _CRTRESTRICT _CRT_HYBRIDPATCHABLE
+void* __cdecl calloc(
+    _In_ _CRT_GUARDOVERFLOW size_t _Count,
+    _In_ _CRT_GUARDOVERFLOW size_t _Size
+    );
+
+_Check_return_
+_ACRTIMP int __cdecl _callnewh(
+    _In_ size_t _Size
+    );
+
+_Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Size)
+_ACRTIMP _CRTALLOCATOR _CRT_HYBRIDPATCHABLE
+void* __cdecl _expand(
+    _Pre_notnull_           void*  _Block,
+    _In_ _CRT_GUARDOVERFLOW size_t _Size
+    );
+
+_ACRTIMP
+void __cdecl _free_base(
+    _Pre_maybenull_ _Post_invalid_ void* _Block
+    );
+
+_ACRTIMP _CRT_HYBRIDPATCHABLE
+void __cdecl free(
+    _Pre_maybenull_ _Post_invalid_ void* _Block
+    );
+
+_Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Size)
+_ACRTIMP _CRTALLOCATOR _CRTRESTRICT
+void* __cdecl _malloc_base(
+    _In_ size_t _Size
+    );
+
+_Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Size)
+_ACRTIMP _CRTALLOCATOR _CRT_JIT_INTRINSIC _CRTRESTRICT _CRT_HYBRIDPATCHABLE
+void* __cdecl malloc(
+    _In_ _CRT_GUARDOVERFLOW size_t _Size
+    );
+
+_Check_return_
+_ACRTIMP
+size_t __cdecl _msize_base(
+    _Pre_notnull_ void* _Block
+    ) _CRT_NOEXCEPT;
+
+_Check_return_
+_ACRTIMP _CRT_HYBRIDPATCHABLE
+size_t __cdecl _msize(
+    _Pre_notnull_ void* _Block
+    );
+
+_Success_(return != 0) _Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Size)
+_ACRTIMP _CRTALLOCATOR _CRTRESTRICT
+void* __cdecl _realloc_base(
+    _Pre_maybenull_ _Post_invalid_  void*  _Block,
+    _In_                            size_t _Size
+    );
+
+_Success_(return != 0) _Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Size)
+_ACRTIMP _CRTALLOCATOR _CRTRESTRICT _CRT_HYBRIDPATCHABLE
+void* __cdecl realloc(
+    _Pre_maybenull_ _Post_invalid_ void*  _Block,
+    _In_ _CRT_GUARDOVERFLOW        size_t _Size
+    );
+
+_Success_(return != 0) _Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Count *
_Size)
+_ACRTIMP _CRTALLOCATOR _CRTRESTRICT
+void* __cdecl _recalloc_base(
+    _Pre_maybenull_ _Post_invalid_ void*  _Block,
+    _In_                           size_t _Count,
+    _In_                           size_t _Size
+    );
+
+_Success_(return != 0) _Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Count *
_Size)
+_ACRTIMP _CRTALLOCATOR _CRTRESTRICT
+void* __cdecl _recalloc(
+    _Pre_maybenull_ _Post_invalid_ void*  _Block,
+    _In_ _CRT_GUARDOVERFLOW        size_t _Count,
+    _In_ _CRT_GUARDOVERFLOW        size_t _Size
+    );
+
+_ACRTIMP
+void __cdecl _aligned_free(
+    _Pre_maybenull_ _Post_invalid_ void* _Block
+    );
+
+_Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Size)
+_ACRTIMP _CRTALLOCATOR _CRTRESTRICT
+void* __cdecl _aligned_malloc(
+    _In_ _CRT_GUARDOVERFLOW size_t _Size,
+    _In_                    size_t _Alignment
+    );
+
+_Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Size)
+_ACRTIMP _CRTALLOCATOR _CRTRESTRICT
+void* __cdecl _aligned_offset_malloc(
+    _In_ _CRT_GUARDOVERFLOW size_t _Size,
+    _In_                    size_t _Alignment,
+    _In_                    size_t _Offset
+    );
+
+_Check_return_
+_ACRTIMP
+size_t __cdecl _aligned_msize(
+    _Pre_notnull_ void*  _Block,
+    _In_          size_t _Alignment,
+    _In_          size_t _Offset
+    );
+
+_Success_(return != 0) _Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Size)
+_ACRTIMP _CRTALLOCATOR _CRTRESTRICT
+void* __cdecl _aligned_offset_realloc(
+    _Pre_maybenull_ _Post_invalid_ void*  _Block,
+    _In_ _CRT_GUARDOVERFLOW        size_t _Size,
+    _In_                           size_t _Alignment,
+    _In_                           size_t _Offset
+    );
+
+_Success_(return != 0) _Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Count *
_Size)
+_ACRTIMP _CRTALLOCATOR _CRTRESTRICT
+void* __cdecl _aligned_offset_recalloc(
+    _Pre_maybenull_ _Post_invalid_ void*  _Block,
+    _In_ _CRT_GUARDOVERFLOW        size_t _Count,
+    _In_ _CRT_GUARDOVERFLOW        size_t _Size,
+    _In_                           size_t _Alignment,
+    _In_                           size_t _Offset
+    );
+
+_Success_(return != 0) _Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Size)
+_ACRTIMP _CRTALLOCATOR _CRTRESTRICT
+void* __cdecl _aligned_realloc(
+    _Pre_maybenull_ _Post_invalid_ void*  _Block,
+    _In_ _CRT_GUARDOVERFLOW        size_t _Size,
+    _In_                           size_t _Alignment
+    );
+
+_Success_(return != 0) _Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Count *
_Size)
+_ACRTIMP _CRTALLOCATOR _CRTRESTRICT
+void* __cdecl _aligned_recalloc(
+    _Pre_maybenull_ _Post_invalid_ void*  _Block,
+    _In_ _CRT_GUARDOVERFLOW        size_t _Count,
+    _In_ _CRT_GUARDOVERFLOW        size_t _Size,
+    _In_                           size_t _Alignment
+    );
+
+#if defined _DEBUG && defined _CRTDBG_MAP_ALLOC
+    #pragma pop_macro("realloc")
+    #pragma pop_macro("malloc")
+    #pragma pop_macro("free")
+    #pragma pop_macro("calloc")
+    #pragma pop_macro("_recalloc")
+    #pragma pop_macro("_msize")
+    #pragma pop_macro("_freea")
+    #pragma pop_macro("_expand")
+    #pragma pop_macro("_aligned_recalloc")
+    #pragma pop_macro("_aligned_realloc")
+    #pragma pop_macro("_aligned_offset_recalloc")
+    #pragma pop_macro("_aligned_offset_realloc")
+    #pragma pop_macro("_aligned_offset_malloc")
+    #pragma pop_macro("_aligned_msize")
+    #pragma pop_macro("_aligned_malloc")
+    #pragma pop_macro("_aligned_free")
+#endif
+
+
+
+_CRT_END_C_HEADER
+_UCRT_RESTORE_CLANG_WARNINGS
+#pragma warning(pop) // _UCRT_DISABLED_WARNINGS
diff --git a/sdk/include/ucrt/corecrt_math.h b/sdk/include/ucrt/corecrt_math.h
new file mode 100644
index 00000000000..fdfe1f02e66
--- /dev/null
+++ b/sdk/include/ucrt/corecrt_math.h
@@ -0,0 +1,998 @@
+//
+// corecrt_math.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The majority of the C Standard Library <math.h> functionality.
+//
+#pragma once
+#ifndef _INC_MATH // include guard for 3rd party interop
+#define _INC_MATH
+
+#include <corecrt.h>
+
+#pragma warning(push)
+#pragma warning(disable: _UCRT_DISABLED_WARNINGS)
+_UCRT_DISABLE_CLANG_WARNINGS
+
+_CRT_BEGIN_C_HEADER
+
+#ifndef __assembler
+    // Definition of the _exception struct, which is passed to the matherr function
+    // when a floating point exception is detected:
+    struct _exception
+    {
+        int    type;   // exception type - see below
+        char*  name;   // name of function where error occurred
+        double arg1;   // first argument to function
+        double arg2;   // second argument (if any) to function
+        double retval; // value to be returned by function
+    };
+
+    // Definition of the _complex struct to be used by those who use the complex
+    // functions and want type checking.
+    #ifndef _COMPLEX_DEFINED
+        #define _COMPLEX_DEFINED
+
+        struct _complex
+        {
+            double x, y; // real and imaginary parts
+        };
+
+        #if defined(_CRT_INTERNAL_NONSTDC_NAMES) && _CRT_INTERNAL_NONSTDC_NAMES
&& !defined __cplusplus
+            // Non-ANSI name for compatibility
+            #define complex _complex
+        #endif
+    #endif
+#endif // __assembler
+
+
+
+// On x86, when not using /arch:SSE2 or greater, floating point operations
+// are performed using the x87 instruction set and FLT_EVAL_METHOD is 2.
+// (When /fp:fast is used, floating point operations may be consistent, so
+// we use the default types.)
+#if defined _M_IX86 && _M_IX86_FP < 2 && !defined _M_FP_FAST
+    typedef long double float_t;
+    typedef long double double_t;
+#else
+    typedef float  float_t;
+    typedef double double_t;
+#endif
+
+
+
+// Constant definitions for the exception type passed in the _exception struct
+#define _DOMAIN     1   // argument domain error
+#define _SING       2   // argument singularity
+#define _OVERFLOW   3   // overflow range error
+#define _UNDERFLOW  4   // underflow range error
+#define _TLOSS      5   // total loss of precision
+#define _PLOSS      6   // partial loss of precision
+
+// Definitions of _HUGE and HUGE_VAL - respectively the XENIX and ANSI names
+// for a value returned in case of error by a number of the floating point
+// math routines.
+#ifndef __assembler
+    #ifndef _M_CEE_PURE
+        extern double const _HUGE;
+    #else
+        double const _HUGE = System::Double::PositiveInfinity;
+    #endif
+#endif
+
+#ifndef _HUGE_ENUF
+    #define _HUGE_ENUF  1e+300  // _HUGE_ENUF*_HUGE_ENUF must overflow
+#endif
+
+#define INFINITY   ((float)(_HUGE_ENUF * _HUGE_ENUF))
+#define HUGE_VAL   ((double)INFINITY)
+#define HUGE_VALF  ((float)INFINITY)
+#define HUGE_VALL  ((long double)INFINITY)
+#ifndef _UCRT_NEGATIVE_NAN
+// This operation creates a negative NAN adding a - to make it positive
+#define NAN        (-(float)(INFINITY * 0.0F))
+#else
+// Keep this for backwards compatibility
+#define NAN        ((float)(INFINITY * 0.0F))
+#endif
+
+#define _DENORM    (-2)
+#define _FINITE    (-1)
+#define _INFCODE   1
+#define _NANCODE   2
+
+#define FP_INFINITE  _INFCODE
+#define FP_NAN       _NANCODE
+#define FP_NORMAL    _FINITE
+#define FP_SUBNORMAL _DENORM
+#define FP_ZERO      0
+
+#define _C2          1  // 0 if not 2's complement
+#define FP_ILOGB0   (-0x7fffffff - _C2)
+#define FP_ILOGBNAN 0x7fffffff
+
+#define MATH_ERRNO        1
+#define MATH_ERREXCEPT    2
+#define math_errhandling  (MATH_ERRNO | MATH_ERREXCEPT)
+
+// Values for use as arguments to the _fperrraise function
+#define _FE_DIVBYZERO 0x04
+#define _FE_INEXACT   0x20
+#define _FE_INVALID   0x01
+#define _FE_OVERFLOW  0x08
+#define _FE_UNDERFLOW 0x10
+
+#define _D0_C  3 // little-endian, small long doubles
+#define _D1_C  2
+#define _D2_C  1
+#define _D3_C  0
+
+#define _DBIAS 0x3fe
+#define _DOFF  4
+
+#define _F0_C  1 // little-endian
+#define _F1_C  0
+
+#define _FBIAS 0x7e
+#define _FOFF  7
+#define _FRND  1
+
+#define _L0_C  3 // little-endian, 64-bit long doubles
+#define _L1_C  2
+#define _L2_C  1
+#define _L3_C  0
+
+#define _LBIAS 0x3fe
+#define _LOFF  4
+
+// IEEE 754 double properties
+#define _DFRAC  ((unsigned short)((1 << _DOFF) - 1))
+#define _DMASK  ((unsigned short)(0x7fff & ~_DFRAC))
+#define _DMAX   ((unsigned short)((1 << (15 - _DOFF)) - 1))
+#define _DSIGN  ((unsigned short)0x8000)
+
+// IEEE 754 float properties
+#define _FFRAC  ((unsigned short)((1 << _FOFF) - 1))
+#define _FMASK  ((unsigned short)(0x7fff & ~_FFRAC))
+#define _FMAX   ((unsigned short)((1 << (15 - _FOFF)) - 1))
+#define _FSIGN  ((unsigned short)0x8000)
+
+// IEEE 754 long double properties
+#define _LFRAC  ((unsigned short)(-1))
+#define _LMASK  ((unsigned short)0x7fff)
+#define _LMAX   ((unsigned short)0x7fff)
+#define _LSIGN  ((unsigned short)0x8000)
+
+#define _DHUGE_EXP (int)(_DMAX * 900L / 1000)
+#define _FHUGE_EXP (int)(_FMAX * 900L / 1000)
+#define _LHUGE_EXP (int)(_LMAX * 900L / 1000)
+
+#define _DSIGN_C(_Val)  (((_double_val *)(char*)&(_Val))->_Sh[_D0_C] &
_DSIGN)
+#define _FSIGN_C(_Val)  (((_float_val  *)(char*)&(_Val))->_Sh[_F0_C] &
_FSIGN)
+#define _LSIGN_C(_Val)  (((_ldouble_val*)(char*)&(_Val))->_Sh[_L0_C] &
_LSIGN)
+
+void __cdecl _fperrraise(_In_ int _Except);
+
+_Check_return_ _ACRTIMP short __cdecl _dclass(_In_ double _X);
+_Check_return_ _ACRTIMP short __cdecl _ldclass(_In_ long double _X);
+_Check_return_ _ACRTIMP short __cdecl _fdclass(_In_ float _X);
+
+_Check_return_ _ACRTIMP int __cdecl _dsign(_In_ double _X);
+_Check_return_ _ACRTIMP int __cdecl _ldsign(_In_ long double _X);
+_Check_return_ _ACRTIMP int __cdecl _fdsign(_In_ float _X);
+
+_Check_return_ _ACRTIMP int __cdecl _dpcomp(_In_ double _X, _In_ double _Y);
+_Check_return_ _ACRTIMP int __cdecl _ldpcomp(_In_ long double _X, _In_ long double _Y);
+_Check_return_ _ACRTIMP int __cdecl _fdpcomp(_In_ float _X, _In_ float _Y);
+
+_Check_return_ _ACRTIMP short __cdecl _dtest(_In_ double* _Px);
+_Check_return_ _ACRTIMP short __cdecl _ldtest(_In_ long double* _Px);
+_Check_return_ _ACRTIMP short __cdecl _fdtest(_In_ float* _Px);
+
+_ACRTIMP short __cdecl _d_int(_Inout_ double* _Px, _In_ short _Xexp);
+_ACRTIMP short __cdecl _ld_int(_Inout_ long double* _Px, _In_ short _Xexp);
+_ACRTIMP short __cdecl _fd_int(_Inout_ float* _Px, _In_ short _Xexp);
+
+_ACRTIMP short __cdecl _dscale(_Inout_ double* _Px, _In_ long _Lexp);
+_ACRTIMP short __cdecl _ldscale(_Inout_ long double* _Px, _In_ long _Lexp);
+_ACRTIMP short __cdecl _fdscale(_Inout_ float* _Px, _In_ long _Lexp);
+
+_ACRTIMP short __cdecl _dunscale(_Out_ short* _Pex, _Inout_ double* _Px);
+_ACRTIMP short __cdecl _ldunscale(_Out_ short* _Pex, _Inout_ long double* _Px);
+_ACRTIMP short __cdecl _fdunscale(_Out_ short* _Pex, _Inout_ float* _Px);
+
+_Check_return_ _ACRTIMP short __cdecl _dexp(_Inout_ double* _Px, _In_ double _Y, _In_
long _Eoff);
+_Check_return_ _ACRTIMP short __cdecl _ldexp(_Inout_ long double* _Px, _In_ long double
_Y, _In_ long _Eoff);
+_Check_return_ _ACRTIMP short __cdecl _fdexp(_Inout_ float* _Px, _In_ float _Y, _In_ long
_Eoff);
+
+_Check_return_ _ACRTIMP short __cdecl _dnorm(_Inout_updates_(4) unsigned short* _Ps);
+_Check_return_ _ACRTIMP short __cdecl _fdnorm(_Inout_updates_(2) unsigned short* _Ps);
+
+_Check_return_ _ACRTIMP double __cdecl _dpoly(_In_ double _X, _In_reads_(_N) double
const* _Tab, _In_ int _N);
+_Check_return_ _ACRTIMP long double __cdecl _ldpoly(_In_ long double _X, _In_reads_(_N)
long double const* _Tab, _In_ int _N);
+_Check_return_ _ACRTIMP float __cdecl _fdpoly(_In_ float _X, _In_reads_(_N) float const*
_Tab, _In_ int _N);
+
+_Check_return_ _ACRTIMP double __cdecl _dlog(_In_ double _X, _In_ int _Baseflag);
+_Check_return_ _ACRTIMP long double __cdecl _ldlog(_In_ long double _X, _In_ int
_Baseflag);
+_Check_return_ _ACRTIMP float __cdecl _fdlog(_In_ float _X, _In_ int _Baseflag);
+
+_Check_return_ _ACRTIMP double __cdecl _dsin(_In_ double _X, _In_ unsigned int _Qoff);
+_Check_return_ _ACRTIMP long double __cdecl _ldsin(_In_ long double _X, _In_ unsigned int
_Qoff);
+_Check_return_ _ACRTIMP float __cdecl _fdsin(_In_ float _X, _In_ unsigned int _Qoff);
+
+// double declarations
+typedef union
+{   // pun floating type as integer array
+    unsigned short _Sh[4];
+    double _Val;
+} _double_val;
+
+// float declarations
+typedef union
+{   // pun floating type as integer array
+    unsigned short _Sh[2];
+    float _Val;
+} _float_val;
+
+// long double declarations
+typedef union
+{   // pun floating type as integer array
+    unsigned short _Sh[4];
+    long double _Val;
+} _ldouble_val;
+
+typedef union
+{   // pun float types as integer array
+    unsigned short _Word[4];
+    float _Float;
+    double _Double;
+    long double _Long_double;
+} _float_const;
+
+extern const _float_const _Denorm_C,  _Inf_C,  _Nan_C,  _Snan_C, _Hugeval_C;
+extern const _float_const _FDenorm_C, _FInf_C, _FNan_C, _FSnan_C;
+extern const _float_const _LDenorm_C, _LInf_C, _LNan_C, _LSnan_C;
+
+extern const _float_const _Eps_C,  _Rteps_C;
+extern const _float_const _FEps_C, _FRteps_C;
+extern const _float_const _LEps_C, _LRteps_C;
+
+extern const double      _Zero_C,  _Xbig_C;
+extern const float       _FZero_C, _FXbig_C;
+extern const long double _LZero_C, _LXbig_C;
+
+#define _FP_LT  1
+#define _FP_EQ  2
+#define _FP_GT  4
+
+#ifndef __cplusplus
+
+    #define _CLASS_ARG(_Val)                                 
__pragma(warning(suppress:6334))(sizeof ((_Val) + (float)0) == sizeof (float) ?
'f' : sizeof ((_Val) + (double)0) == sizeof (double) ? 'd' : 'l')
+    #define _CLASSIFY(_Val, _FFunc, _DFunc, _LDFunc)          (_CLASS_ARG(_Val) ==
'f' ? _FFunc((float)(_Val)) : _CLASS_ARG(_Val) == 'd' ?
_DFunc((double)(_Val)) : _LDFunc((long double)(_Val)))
+    #define _CLASSIFY2(_Val1, _Val2, _FFunc, _DFunc, _LDFunc) (_CLASS_ARG((_Val1) +
(_Val2)) == 'f' ? _FFunc((float)(_Val1), (float)(_Val2)) : _CLASS_ARG((_Val1) +
(_Val2)) == 'd' ? _DFunc((double)(_Val1), (double)(_Val2)) : _LDFunc((long
double)(_Val1), (long double)(_Val2)))
+
+    #define fpclassify(_Val)      (_CLASSIFY(_Val, _fdclass, _dclass, _ldclass))
+    #define _FPCOMPARE(_Val1, _Val2) (_CLASSIFY2(_Val1, _Val2, _fdpcomp, _dpcomp,
_ldpcomp))
+
+    #define isfinite(_Val)      (fpclassify(_Val) <= 0)
+    #define isinf(_Val)         (fpclassify(_Val) == FP_INFINITE)
+    #define isnan(_Val)         (fpclassify(_Val) == FP_NAN)
+    #define isnormal(_Val)      (fpclassify(_Val) == FP_NORMAL)
+    #define signbit(_Val)       (_CLASSIFY(_Val, _fdsign, _dsign, _ldsign))
+
+    #define isgreater(x, y)      ((_FPCOMPARE(x, y) & _FP_GT) != 0)
+    #define isgreaterequal(x, y) ((_FPCOMPARE(x, y) & (_FP_EQ | _FP_GT)) != 0)
+    #define isless(x, y)         ((_FPCOMPARE(x, y) & _FP_LT) != 0)
+    #define islessequal(x, y)    ((_FPCOMPARE(x, y) & (_FP_LT | _FP_EQ)) != 0)
+    #define islessgreater(x, y)  ((_FPCOMPARE(x, y) & (_FP_LT | _FP_GT)) != 0)
+    #define isunordered(x, y)    (_FPCOMPARE(x, y) == 0)
+
+#else // __cplusplus
+extern "C++"
+{
+    _Check_return_ inline int fpclassify(_In_ float _X) throw()
+    {
+        return _fdtest(&_X);
+    }
+
+    _Check_return_ inline int fpclassify(_In_ double _X) throw()
+    {
+        return _dtest(&_X);
+    }
+
+    _Check_return_ inline int fpclassify(_In_ long double _X) throw()
+    {
+        return _ldtest(&_X);
+    }
+
+    _Check_return_ inline bool signbit(_In_ float _X) throw()
+    {
+        return _fdsign(_X) != 0;
+    }
+
+    _Check_return_ inline bool signbit(_In_ double _X) throw()
+    {
+        return _dsign(_X) != 0;
+    }
+
+    _Check_return_ inline bool signbit(_In_ long double _X) throw()
+    {
+        return _ldsign(_X) != 0;
+    }
+
+    _Check_return_ inline int _fpcomp(_In_ float _X, _In_ float _Y) throw()
+    {
+        return _fdpcomp(_X, _Y);
+    }
+
+    _Check_return_ inline int _fpcomp(_In_ double _X, _In_ double _Y) throw()
+    {
+        return _dpcomp(_X, _Y);
+    }
+
+    _Check_return_ inline int _fpcomp(_In_ long double _X, _In_ long double _Y) throw()
+    {
+        return _ldpcomp(_X, _Y);
+    }
+
+    template <class _Trc, class _Tre> struct _Combined_type
+    {   // determine combined type
+        typedef float _Type;
+    };
+
+    template <> struct _Combined_type<float, double>
+    {   // determine combined type
+        typedef double _Type;
+    };
+
+    template <> struct _Combined_type<float, long double>
+    {   // determine combined type
+        typedef long double _Type;
+    };
+
+    template <class _Ty, class _T2> struct _Real_widened
+    {   // determine widened real type
+        typedef long double _Type;
+    };
+
+    template <> struct _Real_widened<float, float>
+    {   // determine widened real type
+        typedef float _Type;
+    };
... 114479 lines suppressed ...

    

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

[ros-diffs] [reactos] 02/33: [UCRT] Import Microsoft.Windows.SDK.CRTSource version 10.0.22621.3