diff --git a/.gitattributes b/.gitattributes
index 938b5267f7..e52cc8c23e 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -6,6 +6,7 @@
 
 # Ensure GitHub detects our C++ code as C++ code.
 /stl/inc/** linguist-language=C++
+/stl/modules/** linguist-language=C++
 /stl/src/** linguist-language=C++
 *.h linguist-language=C++
 
diff --git a/stl/CMakeLists.txt b/stl/CMakeLists.txt
index 59998db215..ce5a5d44ce 100644
--- a/stl/CMakeLists.txt
+++ b/stl/CMakeLists.txt
@@ -255,6 +255,16 @@ foreach(header ${HEADERS})
     configure_file("${header}" "${PROJECT_BINARY_DIR}/out/inc/${_header_path}" COPYONLY)
 endforeach()
 
+set(IXX_FILES
+    ${CMAKE_CURRENT_LIST_DIR}/modules/std.ixx
+    ${CMAKE_CURRENT_LIST_DIR}/modules/std.compat.ixx
+)
+
+foreach(ixx_file ${IXX_FILES})
+    file(RELATIVE_PATH _ixx_file_path "${CMAKE_CURRENT_LIST_DIR}/modules" "${ixx_file}")
+    configure_file("${ixx_file}" "${PROJECT_BINARY_DIR}/out/modules/${_ixx_file_path}" COPYONLY)
+endforeach()
+
 # Objs that implement aliases; these are completely independent of the configuration
 set(ALIAS_SOURCES_X86_X64
     ${CMAKE_CURRENT_LIST_DIR}/src/alias_init_once_begin_initialize.asm
diff --git a/stl/inc/__msvc_chrono.hpp b/stl/inc/__msvc_chrono.hpp
index 1f787a25b5..e7051c28d4 100644
--- a/stl/inc/__msvc_chrono.hpp
+++ b/stl/inc/__msvc_chrono.hpp
@@ -28,13 +28,13 @@ _STL_DISABLE_CLANG_WARNINGS
 
 _STD_BEGIN
 namespace chrono {
-    template <class _Rep>
+    _EXPORT_STD template <class _Rep>
     struct treat_as_floating_point : is_floating_point<_Rep> {}; // tests for floating-point type
 
-    template <class _Rep>
+    _EXPORT_STD template <class _Rep>
     _INLINE_VAR constexpr bool treat_as_floating_point_v = treat_as_floating_point<_Rep>::value;
 
-    template <class _Rep>
+    _EXPORT_STD template <class _Rep>
     struct duration_values { // gets arithmetic properties of a type
         _NODISCARD static constexpr _Rep zero() noexcept {
             // get zero value
@@ -62,23 +62,23 @@ namespace chrono {
                                 typename _Clock::time_point, decltype(_Clock::is_steady), decltype(_Clock::now())>> =
             true; // TRANSITION, GH-602
 
-    template <class _Clock>
+    _EXPORT_STD template <class _Clock>
     struct is_clock : bool_constant<_Is_clock_v<_Clock>> {};
-    template <class _Clock>
+    _EXPORT_STD template <class _Clock>
     inline constexpr bool is_clock_v = _Is_clock_v<_Clock>;
 #endif // _HAS_CXX20
 
-    template <class _Rep, class _Period = ratio<1>>
+    _EXPORT_STD template <class _Rep, class _Period = ratio<1>>
     class duration;
 
     template <class _Ty>
     _INLINE_VAR constexpr bool _Is_duration_v = _Is_specialization_v<_Ty, duration>;
 
-    template <class _To, class _Rep, class _Period, enable_if_t<_Is_duration_v<_To>, int> = 0>
+    _EXPORT_STD template <class _To, class _Rep, class _Period, enable_if_t<_Is_duration_v<_To>, int> = 0>
     constexpr _To duration_cast(const duration<_Rep, _Period>&) noexcept(
         is_arithmetic_v<_Rep>&& is_arithmetic_v<typename _To::rep>); // strengthened
 
-    template <class _Rep, class _Period>
+    _EXPORT_STD template <class _Rep, class _Period>
     class duration { // represents a time duration
     public:
         using rep    = _Rep;
@@ -188,7 +188,7 @@ namespace chrono {
         _Rep _MyRep; // the stored rep
     };
 
-    template <class _Clock, class _Duration = typename _Clock::duration>
+    _EXPORT_STD template <class _Clock, class _Duration = typename _Clock::duration>
     class time_point { // represents a point in time
     public:
         using clock    = _Clock;
@@ -277,7 +277,7 @@ struct common_type<_CHRONO time_point<_Clock, _Duration1>,
 };
 
 namespace chrono {
-    template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
     _NODISCARD constexpr common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>
         operator+(const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right) noexcept(
             is_arithmetic_v<_Rep1>&& is_arithmetic_v<_Rep2>) /* strengthened */ {
@@ -285,7 +285,7 @@ namespace chrono {
         return _CD(_CD(_Left).count() + _CD(_Right).count());
     }
 
-    template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
     _NODISCARD constexpr common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>
         operator-(const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right) noexcept(
             is_arithmetic_v<_Rep1>&& is_arithmetic_v<_Rep2>) /* strengthened */ {
@@ -293,7 +293,7 @@ namespace chrono {
         return _CD(_CD(_Left).count() - _CD(_Right).count());
     }
 
-    template <class _Rep1, class _Period1, class _Rep2,
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2,
         enable_if_t<is_convertible_v<const _Rep2&, common_type_t<_Rep1, _Rep2>>, int> = 0>
     _NODISCARD constexpr duration<common_type_t<_Rep1, _Rep2>, _Period1> operator*(
         const duration<_Rep1, _Period1>& _Left,
@@ -303,7 +303,7 @@ namespace chrono {
         return _CD(_CD(_Left).count() * _Right);
     }
 
-    template <class _Rep1, class _Rep2, class _Period2,
+    _EXPORT_STD template <class _Rep1, class _Rep2, class _Period2,
         enable_if_t<is_convertible_v<const _Rep1&, common_type_t<_Rep1, _Rep2>>, int> = 0>
     _NODISCARD constexpr duration<common_type_t<_Rep1, _Rep2>, _Period2>
         operator*(const _Rep1& _Left, const duration<_Rep2, _Period2>& _Right) noexcept(
@@ -327,7 +327,7 @@ namespace chrono {
         // return type for duration / rep and duration % rep
     };
 
-    template <class _Rep1, class _Period1, class _Rep2>
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2>
     _NODISCARD constexpr typename _Duration_div_mod<common_type_t<_Rep1, _Rep2>, _Period1, _Rep2>::type operator/(
         const duration<_Rep1, _Period1>& _Left,
         const _Rep2& _Right) noexcept(is_arithmetic_v<_Rep1>&& is_arithmetic_v<_Rep2>) /* strengthened */ {
@@ -336,7 +336,7 @@ namespace chrono {
         return _CD(_CD(_Left).count() / _Right);
     }
 
-    template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
     _NODISCARD constexpr common_type_t<_Rep1, _Rep2>
         operator/(const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right) noexcept(
             is_arithmetic_v<_Rep1>&& is_arithmetic_v<_Rep2>) /* strengthened */ {
@@ -344,7 +344,7 @@ namespace chrono {
         return _CD(_Left).count() / _CD(_Right).count();
     }
 
-    template <class _Rep1, class _Period1, class _Rep2>
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2>
     _NODISCARD constexpr typename _Duration_div_mod<common_type_t<_Rep1, _Rep2>, _Period1, _Rep2>::type operator%(
         const duration<_Rep1, _Period1>& _Left,
         const _Rep2& _Right) noexcept(is_arithmetic_v<_Rep1>&& is_arithmetic_v<_Rep2>) /* strengthened */ {
@@ -353,7 +353,7 @@ namespace chrono {
         return _CD(_CD(_Left).count() % _Right);
     }
 
-    template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
     _NODISCARD constexpr common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>
         operator%(const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right) noexcept(
             is_arithmetic_v<_Rep1>&& is_arithmetic_v<_Rep2>) /* strengthened */ {
@@ -361,7 +361,7 @@ namespace chrono {
         return _CD(_CD(_Left).count() % _CD(_Right).count());
     }
 
-    template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
     _NODISCARD constexpr bool
         operator==(const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right) noexcept(
             is_arithmetic_v<_Rep1>&& is_arithmetic_v<_Rep2>) /* strengthened */ {
@@ -378,7 +378,7 @@ namespace chrono {
     }
 #endif // !_HAS_CXX20
 
-    template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
     _NODISCARD constexpr bool
         operator<(const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right) noexcept(
             is_arithmetic_v<_Rep1>&& is_arithmetic_v<_Rep2>) /* strengthened */ {
@@ -386,21 +386,21 @@ namespace chrono {
         return _CT(_Left).count() < _CT(_Right).count();
     }
 
-    template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
     _NODISCARD constexpr bool
         operator<=(const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right) noexcept(
             is_arithmetic_v<_Rep1>&& is_arithmetic_v<_Rep2>) /* strengthened */ {
         return !(_Right < _Left);
     }
 
-    template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
     _NODISCARD constexpr bool
         operator>(const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right) noexcept(
             is_arithmetic_v<_Rep1>&& is_arithmetic_v<_Rep2>) /* strengthened */ {
         return _Right < _Left;
     }
 
-    template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
     _NODISCARD constexpr bool
         operator>=(const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right) noexcept(
             is_arithmetic_v<_Rep1>&& is_arithmetic_v<_Rep2>) /* strengthened */ {
@@ -409,7 +409,7 @@ namespace chrono {
 
 #ifdef __cpp_lib_concepts
     // clang-format off
-    template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
         requires three_way_comparable<typename common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>::rep>
     _NODISCARD constexpr auto
         operator<=>(const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right) noexcept(
@@ -420,7 +420,7 @@ namespace chrono {
     }
 #endif // defined(__cpp_lib_concepts)
 
-    template <class _To, class _Rep, class _Period, enable_if_t<_Is_duration_v<_To>, int> _Enabled>
+    _EXPORT_STD template <class _To, class _Rep, class _Period, enable_if_t<_Is_duration_v<_To>, int> _Enabled>
     _NODISCARD constexpr _To duration_cast(const duration<_Rep, _Period>& _Dur) noexcept(
         is_arithmetic_v<_Rep>&& is_arithmetic_v<typename _To::rep>) /* strengthened */ {
         // convert duration to another duration; truncate
@@ -450,7 +450,7 @@ namespace chrono {
         }
     }
 
-    template <class _To, class _Rep, class _Period, enable_if_t<_Is_duration_v<_To>, int> = 0>
+    _EXPORT_STD template <class _To, class _Rep, class _Period, enable_if_t<_Is_duration_v<_To>, int> = 0>
     _NODISCARD constexpr _To floor(const duration<_Rep, _Period>& _Dur) noexcept(
         is_arithmetic_v<_Rep>&& is_arithmetic_v<typename _To::rep>) /* strengthened */ {
         // convert duration to another duration; round towards negative infinity
@@ -463,7 +463,7 @@ namespace chrono {
         return _Casted;
     }
 
-    template <class _To, class _Rep, class _Period, enable_if_t<_Is_duration_v<_To>, int> = 0>
+    _EXPORT_STD template <class _To, class _Rep, class _Period, enable_if_t<_Is_duration_v<_To>, int> = 0>
     _NODISCARD constexpr _To ceil(const duration<_Rep, _Period>& _Dur) noexcept(
         is_arithmetic_v<_Rep>&& is_arithmetic_v<typename _To::rep>) /* strengthened */ {
         // convert duration to another duration; round towards positive infinity
@@ -482,7 +482,7 @@ namespace chrono {
         return _Val % 2 == 0;
     }
 
-    template <class _To, class _Rep, class _Period,
+    _EXPORT_STD template <class _To, class _Rep, class _Period,
         enable_if_t<_Is_duration_v<_To> && !treat_as_floating_point_v<typename _To::rep>, int> = 0>
     _NODISCARD constexpr _To round(const duration<_Rep, _Period>& _Dur) noexcept(
         is_arithmetic_v<_Rep>&& is_arithmetic_v<typename _To::rep>) /* strengthened */ {
@@ -499,7 +499,7 @@ namespace chrono {
         return _Ceiled;
     }
 
-    template <class _Rep, class _Period, enable_if_t<numeric_limits<_Rep>::is_signed, int> = 0>
+    _EXPORT_STD template <class _Rep, class _Period, enable_if_t<numeric_limits<_Rep>::is_signed, int> = 0>
     _NODISCARD constexpr duration<_Rep, _Period> abs(const duration<_Rep, _Period> _Dur) noexcept(
         is_arithmetic_v<_Rep>) /* strengthened */ {
         // create a duration whose count() is the absolute value of _Dur.count()
@@ -510,20 +510,20 @@ namespace chrono {
         }
     }
 
-    using nanoseconds  = duration<long long, nano>;
-    using microseconds = duration<long long, micro>;
-    using milliseconds = duration<long long, milli>;
-    using seconds      = duration<long long>;
-    using minutes      = duration<int, ratio<60>>;
-    using hours        = duration<int, ratio<3600>>;
+    _EXPORT_STD using nanoseconds  = duration<long long, nano>;
+    _EXPORT_STD using microseconds = duration<long long, micro>;
+    _EXPORT_STD using milliseconds = duration<long long, milli>;
+    _EXPORT_STD using seconds      = duration<long long>;
+    _EXPORT_STD using minutes      = duration<int, ratio<60>>;
+    _EXPORT_STD using hours        = duration<int, ratio<3600>>;
 #if _HAS_CXX20
-    using days   = duration<int, ratio_multiply<ratio<24>, hours::period>>;
-    using weeks  = duration<int, ratio_multiply<ratio<7>, days::period>>;
-    using years  = duration<int, ratio_multiply<ratio<146097, 400>, days::period>>;
-    using months = duration<int, ratio_divide<years::period, ratio<12>>>;
+    _EXPORT_STD using days   = duration<int, ratio_multiply<ratio<24>, hours::period>>;
+    _EXPORT_STD using weeks  = duration<int, ratio_multiply<ratio<7>, days::period>>;
+    _EXPORT_STD using years  = duration<int, ratio_multiply<ratio<146097, 400>, days::period>>;
+    _EXPORT_STD using months = duration<int, ratio_divide<years::period, ratio<12>>>;
 #endif // _HAS_CXX20
 
-    template <class _Clock, class _Duration, class _Rep, class _Period>
+    _EXPORT_STD template <class _Clock, class _Duration, class _Rep, class _Period>
     _NODISCARD constexpr time_point<_Clock, common_type_t<_Duration, duration<_Rep, _Period>>>
         operator+(const time_point<_Clock, _Duration>& _Left, const duration<_Rep, _Period>& _Right) noexcept(
             is_arithmetic_v<typename _Duration::rep>&& is_arithmetic_v<_Rep>) /* strengthened */ {
@@ -531,14 +531,14 @@ namespace chrono {
         return _RT(_Left.time_since_epoch() + _Right);
     }
 
-    template <class _Rep, class _Period, class _Clock, class _Duration>
+    _EXPORT_STD template <class _Rep, class _Period, class _Clock, class _Duration>
     _NODISCARD constexpr time_point<_Clock, common_type_t<duration<_Rep, _Period>, _Duration>>
         operator+(const duration<_Rep, _Period>& _Left, const time_point<_Clock, _Duration>& _Right) noexcept(
             is_arithmetic_v<_Rep>&& is_arithmetic_v<typename _Duration::rep>) /* strengthened */ {
         return _Right + _Left;
     }
 
-    template <class _Clock, class _Duration, class _Rep, class _Period>
+    _EXPORT_STD template <class _Clock, class _Duration, class _Rep, class _Period>
     _NODISCARD constexpr time_point<_Clock, common_type_t<_Duration, duration<_Rep, _Period>>>
         operator-(const time_point<_Clock, _Duration>& _Left, const duration<_Rep, _Period>& _Right) noexcept(
             is_arithmetic_v<typename _Duration::rep>&& is_arithmetic_v<_Rep>) /* strengthened */ {
@@ -546,14 +546,14 @@ namespace chrono {
         return _RT(_Left.time_since_epoch() - _Right);
     }
 
-    template <class _Clock, class _Duration1, class _Duration2>
+    _EXPORT_STD template <class _Clock, class _Duration1, class _Duration2>
     _NODISCARD constexpr common_type_t<_Duration1, _Duration2>
         operator-(const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right) noexcept(
             is_arithmetic_v<typename _Duration1::rep>&& is_arithmetic_v<typename _Duration2::rep>) /* strengthened */ {
         return _Left.time_since_epoch() - _Right.time_since_epoch();
     }
 
-    template <class _Clock, class _Duration1, class _Duration2>
+    _EXPORT_STD template <class _Clock, class _Duration1, class _Duration2>
     _NODISCARD constexpr bool
         operator==(const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right) noexcept(
             is_arithmetic_v<typename _Duration1::rep>&& is_arithmetic_v<typename _Duration2::rep>) /* strengthened */ {
@@ -569,28 +569,28 @@ namespace chrono {
     }
 #endif // !_HAS_CXX20
 
-    template <class _Clock, class _Duration1, class _Duration2>
+    _EXPORT_STD template <class _Clock, class _Duration1, class _Duration2>
     _NODISCARD constexpr bool
         operator<(const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right) noexcept(
             is_arithmetic_v<typename _Duration1::rep>&& is_arithmetic_v<typename _Duration2::rep>) /* strengthened */ {
         return _Left.time_since_epoch() < _Right.time_since_epoch();
     }
 
-    template <class _Clock, class _Duration1, class _Duration2>
+    _EXPORT_STD template <class _Clock, class _Duration1, class _Duration2>
     _NODISCARD constexpr bool
         operator<=(const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right) noexcept(
             is_arithmetic_v<typename _Duration1::rep>&& is_arithmetic_v<typename _Duration2::rep>) /* strengthened */ {
         return !(_Right < _Left);
     }
 
-    template <class _Clock, class _Duration1, class _Duration2>
+    _EXPORT_STD template <class _Clock, class _Duration1, class _Duration2>
     _NODISCARD constexpr bool
         operator>(const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right) noexcept(
             is_arithmetic_v<typename _Duration1::rep>&& is_arithmetic_v<typename _Duration2::rep>) /* strengthened */ {
         return _Right < _Left;
     }
 
-    template <class _Clock, class _Duration1, class _Duration2>
+    _EXPORT_STD template <class _Clock, class _Duration1, class _Duration2>
     _NODISCARD constexpr bool
         operator>=(const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right) noexcept(
             is_arithmetic_v<typename _Duration1::rep>&& is_arithmetic_v<typename _Duration2::rep>) /* strengthened */ {
@@ -598,7 +598,7 @@ namespace chrono {
     }
 
 #ifdef __cpp_lib_concepts
-    template <class _Clock, class _Duration1, three_way_comparable_with<_Duration1> _Duration2>
+    _EXPORT_STD template <class _Clock, class _Duration1, three_way_comparable_with<_Duration1> _Duration2>
     _NODISCARD constexpr auto
         operator<=>(const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right) noexcept(
             is_arithmetic_v<typename _Duration1::rep>&& is_arithmetic_v<typename _Duration2::rep>) /* strengthened */ {
@@ -606,28 +606,28 @@ namespace chrono {
     }
 #endif // defined(__cpp_lib_concepts)
 
-    template <class _To, class _Clock, class _Duration, enable_if_t<_Is_duration_v<_To>, int> = 0>
+    _EXPORT_STD template <class _To, class _Clock, class _Duration, enable_if_t<_Is_duration_v<_To>, int> = 0>
     _NODISCARD constexpr time_point<_Clock, _To> time_point_cast(const time_point<_Clock, _Duration>& _Time) noexcept(
         is_arithmetic_v<typename _Duration::rep>&& is_arithmetic_v<typename _To::rep>) /* strengthened */ {
         // change the duration type of a time_point; truncate
         return time_point<_Clock, _To>(_CHRONO duration_cast<_To>(_Time.time_since_epoch()));
     }
 
-    template <class _To, class _Clock, class _Duration, enable_if_t<_Is_duration_v<_To>, int> = 0>
+    _EXPORT_STD template <class _To, class _Clock, class _Duration, enable_if_t<_Is_duration_v<_To>, int> = 0>
     _NODISCARD constexpr time_point<_Clock, _To> floor(const time_point<_Clock, _Duration>& _Time) noexcept(
         is_arithmetic_v<typename _Duration::rep>&& is_arithmetic_v<typename _To::rep>) /* strengthened */ {
         // change the duration type of a time_point; round towards negative infinity
         return time_point<_Clock, _To>(_CHRONO floor<_To>(_Time.time_since_epoch()));
     }
 
-    template <class _To, class _Clock, class _Duration, enable_if_t<_Is_duration_v<_To>, int> = 0>
+    _EXPORT_STD template <class _To, class _Clock, class _Duration, enable_if_t<_Is_duration_v<_To>, int> = 0>
     _NODISCARD constexpr time_point<_Clock, _To> ceil(const time_point<_Clock, _Duration>& _Time) noexcept(
         is_arithmetic_v<typename _Duration::rep>&& is_arithmetic_v<typename _To::rep>) /* strengthened */ {
         // change the duration type of a time_point; round towards positive infinity
         return time_point<_Clock, _To>(_CHRONO ceil<_To>(_Time.time_since_epoch()));
     }
 
-    template <class _To, class _Clock, class _Duration,
+    _EXPORT_STD template <class _To, class _Clock, class _Duration,
         enable_if_t<_Is_duration_v<_To> && !treat_as_floating_point_v<typename _To::rep>, int> = 0>
     _NODISCARD constexpr time_point<_Clock, _To> round(const time_point<_Clock, _Duration>& _Time) noexcept(
         is_arithmetic_v<typename _Duration::rep>&& is_arithmetic_v<typename _To::rep>) /* strengthened */ {
@@ -635,7 +635,7 @@ namespace chrono {
         return time_point<_Clock, _To>(_CHRONO round<_To>(_Time.time_since_epoch()));
     }
 
-    struct system_clock { // wraps GetSystemTimePreciseAsFileTime/GetSystemTimeAsFileTime
+    _EXPORT_STD struct system_clock { // wraps GetSystemTimePreciseAsFileTime/GetSystemTimeAsFileTime
         using rep                       = long long;
         using period                    = ratio<1, 10'000'000>; // 100 nanoseconds
         using duration                  = _CHRONO duration<rep, period>;
@@ -656,13 +656,13 @@ namespace chrono {
     };
 
 #if _HAS_CXX20
-    template <class _Duration>
-    using sys_time    = time_point<system_clock, _Duration>;
-    using sys_seconds = sys_time<seconds>;
-    using sys_days    = sys_time<days>;
+    _EXPORT_STD template <class _Duration>
+    using sys_time                = time_point<system_clock, _Duration>;
+    _EXPORT_STD using sys_seconds = sys_time<seconds>;
+    _EXPORT_STD using sys_days    = sys_time<days>;
 #endif // _HAS_CXX20
 
-    struct steady_clock { // wraps QueryPerformanceCounter
+    _EXPORT_STD struct steady_clock { // wraps QueryPerformanceCounter
         using rep                       = long long;
         using period                    = nano;
         using duration                  = nanoseconds;
@@ -694,7 +694,7 @@ namespace chrono {
         }
     };
 
-    using high_resolution_clock = steady_clock;
+    _EXPORT_STD using high_resolution_clock = steady_clock;
 } // namespace chrono
 
 template <class _Rep, class _Period>
@@ -723,55 +723,62 @@ _NODISCARD bool _To_xtime_10_day_clamped(_CSTD xtime& _Xt, const _CHRONO duratio
 
 inline namespace literals {
     inline namespace chrono_literals {
-        _NODISCARD constexpr _CHRONO hours operator"" h(unsigned long long _Val) noexcept /* strengthened */ {
+        _EXPORT_STD _NODISCARD constexpr _CHRONO hours operator"" h(unsigned long long _Val) noexcept
+        /* strengthened */ {
             return _CHRONO hours(_Val);
         }
 
-        _NODISCARD constexpr _CHRONO duration<double, ratio<3600>> operator"" h(long double _Val) noexcept
+        _EXPORT_STD _NODISCARD constexpr _CHRONO duration<double, ratio<3600>> operator"" h(long double _Val) noexcept
         /* strengthened */ {
             return _CHRONO duration<double, ratio<3600>>(_Val);
         }
 
-        _NODISCARD constexpr _CHRONO minutes(operator"" min)(unsigned long long _Val) noexcept /* strengthened */ {
+        _EXPORT_STD _NODISCARD constexpr _CHRONO minutes(operator"" min)(unsigned long long _Val) noexcept
+        /* strengthened */ {
             return _CHRONO minutes(_Val);
         }
 
-        _NODISCARD constexpr _CHRONO duration<double, ratio<60>>(operator"" min)(long double _Val) noexcept
+        _EXPORT_STD _NODISCARD constexpr _CHRONO duration<double, ratio<60>>(operator"" min)(long double _Val) noexcept
         /* strengthened */ {
             return _CHRONO duration<double, ratio<60>>(_Val);
         }
 
-        _NODISCARD constexpr _CHRONO seconds operator"" s(unsigned long long _Val) noexcept /* strengthened */ {
+        _EXPORT_STD _NODISCARD constexpr _CHRONO seconds operator"" s(unsigned long long _Val) noexcept
+        /* strengthened */ {
             return _CHRONO seconds(_Val);
         }
 
-        _NODISCARD constexpr _CHRONO duration<double> operator"" s(long double _Val) noexcept /* strengthened */ {
+        _EXPORT_STD _NODISCARD constexpr _CHRONO duration<double> operator"" s(long double _Val) noexcept
+        /* strengthened */ {
             return _CHRONO duration<double>(_Val);
         }
 
-        _NODISCARD constexpr _CHRONO milliseconds operator"" ms(unsigned long long _Val) noexcept /* strengthened */ {
+        _EXPORT_STD _NODISCARD constexpr _CHRONO milliseconds operator"" ms(unsigned long long _Val) noexcept
+        /* strengthened */ {
             return _CHRONO milliseconds(_Val);
         }
 
-        _NODISCARD constexpr _CHRONO duration<double, milli> operator"" ms(long double _Val) noexcept
+        _EXPORT_STD _NODISCARD constexpr _CHRONO duration<double, milli> operator"" ms(long double _Val) noexcept
         /* strengthened */ {
             return _CHRONO duration<double, milli>(_Val);
         }
 
-        _NODISCARD constexpr _CHRONO microseconds operator"" us(unsigned long long _Val) noexcept /* strengthened */ {
+        _EXPORT_STD _NODISCARD constexpr _CHRONO microseconds operator"" us(unsigned long long _Val) noexcept
+        /* strengthened */ {
             return _CHRONO microseconds(_Val);
         }
 
-        _NODISCARD constexpr _CHRONO duration<double, micro> operator"" us(long double _Val) noexcept
+        _EXPORT_STD _NODISCARD constexpr _CHRONO duration<double, micro> operator"" us(long double _Val) noexcept
         /* strengthened */ {
             return _CHRONO duration<double, micro>(_Val);
         }
 
-        _NODISCARD constexpr _CHRONO nanoseconds operator"" ns(unsigned long long _Val) noexcept /* strengthened */ {
+        _EXPORT_STD _NODISCARD constexpr _CHRONO nanoseconds operator"" ns(unsigned long long _Val) noexcept
+        /* strengthened */ {
             return _CHRONO nanoseconds(_Val);
         }
 
-        _NODISCARD constexpr _CHRONO duration<double, nano> operator"" ns(long double _Val) noexcept
+        _EXPORT_STD _NODISCARD constexpr _CHRONO duration<double, nano> operator"" ns(long double _Val) noexcept
         /* strengthened */ {
             return _CHRONO duration<double, nano>(_Val);
         }
@@ -779,7 +786,7 @@ inline namespace literals {
 } // namespace literals
 
 namespace chrono {
-    using namespace literals::chrono_literals;
+    _EXPORT_STD using namespace literals::chrono_literals;
 } // namespace chrono
 _STD_END
 
diff --git a/stl/inc/__msvc_iter_core.hpp b/stl/inc/__msvc_iter_core.hpp
index f552728d36..502c024eb8 100644
--- a/stl/inc/__msvc_iter_core.hpp
+++ b/stl/inc/__msvc_iter_core.hpp
@@ -19,18 +19,18 @@ _STL_DISABLE_CLANG_WARNINGS
 
 _STD_BEGIN
 // from <iterator>
-struct input_iterator_tag {};
+_EXPORT_STD struct input_iterator_tag {};
 
-struct output_iterator_tag {};
+_EXPORT_STD struct output_iterator_tag {};
 
-struct forward_iterator_tag : input_iterator_tag {};
+_EXPORT_STD struct forward_iterator_tag : input_iterator_tag {};
 
-struct bidirectional_iterator_tag : forward_iterator_tag {};
+_EXPORT_STD struct bidirectional_iterator_tag : forward_iterator_tag {};
 
-struct random_access_iterator_tag : bidirectional_iterator_tag {};
+_EXPORT_STD struct random_access_iterator_tag : bidirectional_iterator_tag {};
 
 #ifdef __cpp_lib_concepts
-struct contiguous_iterator_tag : random_access_iterator_tag {};
+_EXPORT_STD struct contiguous_iterator_tag : random_access_iterator_tag {};
 
 template <class _Ty>
 concept _Dereferenceable = requires(_Ty& __t) {
@@ -72,7 +72,7 @@ concept _Has_member_reference = requires {
     typename _Ty::reference;
 };
 
-template <class>
+_EXPORT_STD template <class>
 struct incrementable_traits {};
 
 template <class _Ty>
@@ -105,10 +105,10 @@ struct incrementable_traits<_Ty> {
 template <class _Ty>
 concept _Is_from_primary = _Same_impl<typename _Ty::_From_primary, _Ty>;
 
-template <class>
+_EXPORT_STD template <class>
 struct iterator_traits;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 using iter_difference_t = typename conditional_t<_Is_from_primary<iterator_traits<remove_cvref_t<_Ty>>>,
     incrementable_traits<remove_cvref_t<_Ty>>, iterator_traits<remove_cvref_t<_Ty>>>::difference_type;
 
@@ -121,7 +121,7 @@ struct _Cond_value_type<_Ty> {
     using value_type = remove_cv_t<_Ty>;
 };
 
-template <class>
+_EXPORT_STD template <class>
 struct indirectly_readable_traits {};
 
 template <class _Ty>
@@ -153,11 +153,11 @@ template <_Has_member_value_type _Ty>
 struct indirectly_readable_traits<_Ty> : _Cond_value_type<typename _Ty::value_type> {};
 // clang-format on
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 using iter_value_t = typename conditional_t<_Is_from_primary<iterator_traits<remove_cvref_t<_Ty>>>,
     indirectly_readable_traits<remove_cvref_t<_Ty>>, iterator_traits<remove_cvref_t<_Ty>>>::value_type;
 
-template <_Dereferenceable _Ty>
+_EXPORT_STD template <_Dereferenceable _Ty>
 using iter_reference_t = decltype(*_STD declval<_Ty&>());
 
 template <class>
@@ -365,7 +365,7 @@ struct _Iterator_traits_base<_It> {
 };
 // clang-format on
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct iterator_traits : _Iterator_traits_base<_Ty> {
     using _From_primary = iterator_traits;
 };
@@ -394,7 +394,7 @@ template <class _Ty>
 concept _Signed_integer_like = _Integer_like<_Ty> && static_cast<_Ty>(-1) < static_cast<_Ty>(0);
 
 // clang-format off
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 concept weakly_incrementable = movable<_Ty>
     && requires(_Ty __i) {
         typename iter_difference_t<_Ty>;
@@ -407,21 +407,21 @@ concept weakly_incrementable = movable<_Ty>
 #endif // TRANSITION, LLVM-48173
     ;
 
-template <class _It>
+_EXPORT_STD template <class _It>
 concept input_or_output_iterator = requires(_It __i) { { *__i } -> _Can_reference; }
     && weakly_incrementable<_It>;
 
-template <class _Se, class _It>
+_EXPORT_STD template <class _Se, class _It>
 concept sentinel_for = semiregular<_Se>
     && input_or_output_iterator<_It>
     && _Weakly_equality_comparable_with<_Se, _It>;
 // clang-format on
 
-template <class _Se, class _It>
+_EXPORT_STD template <class _Se, class _It>
 inline constexpr bool disable_sized_sentinel_for = false;
 
 // clang-format off
-template <class _Se, class _It>
+_EXPORT_STD template <class _Se, class _It>
 concept sized_sentinel_for = sentinel_for<_Se, _It>
     && !disable_sized_sentinel_for<remove_cv_t<_Se>, remove_cv_t<_It>>
     && requires(const _It& __i, const _Se& __s) {
@@ -432,24 +432,24 @@ concept sized_sentinel_for = sentinel_for<_Se, _It>
 
 namespace ranges {
     // clang-format off
-    enum class subrange_kind : bool { unsized, sized };
+    _EXPORT_STD enum class subrange_kind : bool { unsized, sized };
 
-    template <input_or_output_iterator _It, sentinel_for<_It> _Se = _It,
+    _EXPORT_STD template <input_or_output_iterator _It, sentinel_for<_It> _Se = _It,
         subrange_kind _Ki = sized_sentinel_for<_Se, _It> ? subrange_kind::sized : subrange_kind::unsized>
         requires (_Ki == subrange_kind::sized || !sized_sentinel_for<_Se, _It>)
     class subrange;
 
-    template <size_t _Idx, class _It, class _Se, subrange_kind _Ki>
+    _EXPORT_STD template <size_t _Idx, class _It, class _Se, subrange_kind _Ki>
         requires ((_Idx == 0 && copyable<_It>) || _Idx == 1)
     _NODISCARD constexpr auto get(const subrange<_It, _Se, _Ki>& _Val);
 
-    template <size_t _Idx, class _It, class _Se, subrange_kind _Ki>
+    _EXPORT_STD template <size_t _Idx, class _It, class _Se, subrange_kind _Ki>
         requires (_Idx < 2)
     _NODISCARD constexpr auto get(subrange<_It, _Se, _Ki>&& _Val);
     // clang-format on
 } // namespace ranges
 
-using ranges::get;
+_EXPORT_STD using ranges::get;
 
 template <class _It, class _Se, ranges::subrange_kind _Ki>
 struct tuple_size<ranges::subrange<_It, _Se, _Ki>> : integral_constant<size_t, 2> {};
diff --git a/stl/inc/__msvc_tzdb.hpp b/stl/inc/__msvc_tzdb.hpp
index d252f8a6d5..3948efa3e7 100644
--- a/stl/inc/__msvc_tzdb.hpp
+++ b/stl/inc/__msvc_tzdb.hpp
@@ -20,6 +20,8 @@ _STL_DISABLE_CLANG_WARNINGS
 #pragma push_macro("new")
 #undef new
 
+_EXTERN_C
+
 using __std_tzdb_epoch_milli = double;
 
 struct __std_tzdb_leap_info {
@@ -64,8 +66,6 @@ struct __std_tzdb_sys_info {
     const char* _Abbrev;
 };
 
-_EXTERN_C
-
 _NODISCARD __std_tzdb_time_zones_info* __stdcall __std_tzdb_get_time_zones() noexcept;
 void __stdcall __std_tzdb_delete_time_zones(__std_tzdb_time_zones_info* _Info) noexcept;
 
diff --git a/stl/inc/algorithm b/stl/inc/algorithm
index 7805a59839..1eb4f33e12 100644
--- a/stl/inc/algorithm
+++ b/stl/inc/algorithm
@@ -171,7 +171,7 @@ struct _Optimistic_temporary_buffer { // temporary storage with _alloca-like att
 
 #ifdef __cpp_lib_concepts
 namespace ranges {
-    template <class _In, class _Fun>
+    _EXPORT_STD template <class _In, class _Fun>
     struct in_fun_result {
         /* [[no_unique_address]] */ _In in;
         /* [[no_unique_address]] */ _Fun fun;
@@ -187,7 +187,7 @@ namespace ranges {
         }
     };
 
-    template <class _In1, class _In2, class _Out>
+    _EXPORT_STD template <class _In1, class _In2, class _Out>
     struct in_in_out_result {
         /* [[no_unique_address]] */ _In1 in1;
         /* [[no_unique_address]] */ _In2 in2;
@@ -205,7 +205,7 @@ namespace ranges {
         }
     };
 
-    template <class _In, class _Out1, class _Out2>
+    _EXPORT_STD template <class _In, class _Out1, class _Out2>
     struct in_out_out_result {
         /* [[no_unique_address]] */ _In in;
         /* [[no_unique_address]] */ _Out1 out1;
@@ -223,7 +223,7 @@ namespace ranges {
         }
     };
 
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     struct min_max_result {
         /* [[no_unique_address]] */ _Ty min;
         /* [[no_unique_address]] */ _Ty max;
@@ -239,7 +239,7 @@ namespace ranges {
         }
     };
 
-    template <class _In>
+    _EXPORT_STD template <class _In>
     struct in_found_result {
         /* [[no_unique_address]] */ _In in;
         bool found;
@@ -257,7 +257,7 @@ namespace ranges {
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _InIt, class _Fn>
+_EXPORT_STD template <class _InIt, class _Fn>
 _CONSTEXPR20 _Fn for_each(_InIt _First, _InIt _Last, _Fn _Func) { // perform function for each element [_First, _Last)
     _Adl_verify_range(_First, _Last);
     auto _UFirst      = _Get_unwrapped(_First);
@@ -270,10 +270,10 @@ _CONSTEXPR20 _Fn for_each(_InIt _First, _InIt _Last, _Fn _Func) { // perform fun
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Fn, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Fn, _Enable_if_execution_policy_t<_ExPo> = 0>
 void for_each(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, _Fn _Func) noexcept; // terminates
 
-template <class _InIt, class _Diff, class _Fn>
+_EXPORT_STD template <class _InIt, class _Diff, class _Fn>
 _CONSTEXPR20 _InIt for_each_n(_InIt _First, const _Diff _Count_raw, _Fn _Func) {
     // perform function for each element [_First, _First + _Count)
     _Algorithm_int_t<_Diff> _Count = _Count_raw;
@@ -291,13 +291,13 @@ _CONSTEXPR20 _InIt for_each_n(_InIt _First, const _Diff _Count_raw, _Fn _Func) {
     return _First;
 }
 
-template <class _ExPo, class _FwdIt, class _Diff, class _Fn, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Diff, class _Fn, _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt for_each_n(_ExPo&& _Exec, _FwdIt _First, _Diff _Count_raw, _Fn _Func) noexcept; // terminates
 #endif // _HAS_CXX17
 
 #ifdef __cpp_lib_concepts
 namespace ranges {
-    template <class _In, class _Fun>
+    _EXPORT_STD template <class _In, class _Fun>
     using for_each_result = in_fun_result<_In, _Fun>;
 
     class _For_each_fn : private _Not_quite_object {
@@ -345,9 +345,9 @@ namespace ranges {
         }
     };
 
-    inline constexpr _For_each_fn for_each{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _For_each_fn for_each{_Not_quite_object::_Construct_tag{}};
 
-    template <class _In, class _Fun>
+    _EXPORT_STD template <class _In, class _Fun>
     using for_each_n_result = in_fun_result<_In, _Fun>;
 
     class _For_each_n_fn : private _Not_quite_object {
@@ -372,16 +372,16 @@ namespace ranges {
         }
     };
 
-    inline constexpr _For_each_n_fn for_each_n{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _For_each_n_fn for_each_n{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _FwdIt find_if(_ExPo&& _Exec, _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept; // terminates
 #endif // _HAS_CXX17
 
-template <class _InIt, class _Pr>
+_EXPORT_STD template <class _InIt, class _Pr>
 _NODISCARD _CONSTEXPR20 _InIt find_if_not(_InIt _First, const _InIt _Last, _Pr _Pred) {
     // find first element that satisfies !_Pred
     _Adl_verify_range(_First, _Last);
@@ -398,11 +398,11 @@ _NODISCARD _CONSTEXPR20 _InIt find_if_not(_InIt _First, const _InIt _Last, _Pr _
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _FwdIt find_if_not(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept; // terminates
 #endif // _HAS_CXX17
 
-template <class _FwdIt, class _Pr>
+_EXPORT_STD template <class _FwdIt, class _Pr>
 _NODISCARD _CONSTEXPR20 _FwdIt adjacent_find(const _FwdIt _First, _FwdIt _Last, _Pr _Pred) {
     // find first satisfying _Pred with successor
     _Adl_verify_range(_First, _Last);
@@ -421,16 +421,16 @@ _NODISCARD _CONSTEXPR20 _FwdIt adjacent_find(const _FwdIt _First, _FwdIt _Last,
     return _Last;
 }
 
-template <class _FwdIt>
+_EXPORT_STD template <class _FwdIt>
 _NODISCARD _CONSTEXPR20 _FwdIt adjacent_find(const _FwdIt _First, const _FwdIt _Last) { // find first matching successor
     return _STD adjacent_find(_First, _Last, equal_to<>{});
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _FwdIt adjacent_find(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept; // terminates
 
-template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _FwdIt adjacent_find(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last) noexcept /* terminates */ {
     // find first matching successor
     return _STD adjacent_find(_STD forward<_ExPo>(_Exec), _First, _Last, equal_to{});
@@ -494,11 +494,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Count_fn count{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Count_fn count{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _InIt, class _Pr>
+_EXPORT_STD template <class _InIt, class _Pr>
 _NODISCARD _CONSTEXPR20 _Iter_diff_t<_InIt> count_if(_InIt _First, _InIt _Last, _Pr _Pred) {
     // count elements satisfying _Pred
     _Adl_verify_range(_First, _Last);
@@ -515,7 +515,7 @@ _NODISCARD _CONSTEXPR20 _Iter_diff_t<_InIt> count_if(_InIt _First, _InIt _Last,
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _Iter_diff_t<_FwdIt> count_if(
     _ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept; // terminates
 #endif // _HAS_CXX17
@@ -559,11 +559,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Count_if_fn count_if{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Count_if_fn count_if{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _InIt1, class _InIt2, class _Pr>
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Pr>
 _NODISCARD _CONSTEXPR20 pair<_InIt1, _InIt2> mismatch(_InIt1 _First1, const _InIt1 _Last1, _InIt2 _First2, _Pr _Pred) {
     // return [_First1, _Last1)/[_First2, ...) mismatch
     _Adl_verify_range(_First1, _Last1);
@@ -581,19 +581,19 @@ _NODISCARD _CONSTEXPR20 pair<_InIt1, _InIt2> mismatch(_InIt1 _First1, const _InI
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD pair<_FwdIt1, _FwdIt2> mismatch(
     _ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr _Pred) noexcept; // terminates
 #endif // _HAS_CXX17
 
-template <class _InIt1, class _InIt2>
+_EXPORT_STD template <class _InIt1, class _InIt2>
 _NODISCARD _CONSTEXPR20 pair<_InIt1, _InIt2> mismatch(const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2) {
     // return [_First1, _Last1)/[_First2, ...) mismatch
     return _STD mismatch(_First1, _Last1, _First2, equal_to<>{});
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD pair<_FwdIt1, _FwdIt2> mismatch(
     _ExPo&& _Exec, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2) noexcept /* terminates */ {
     // return [_First1, _Last1)/[_First2, ...) mismatch
@@ -603,7 +603,7 @@ _NODISCARD pair<_FwdIt1, _FwdIt2> mismatch(
 }
 #endif // _HAS_CXX17
 
-template <class _InIt1, class _InIt2, class _Pr>
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Pr>
 _NODISCARD _CONSTEXPR20 pair<_InIt1, _InIt2> mismatch(
     _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred) {
     // return [_First1, _Last1)/[_First2, _Last2) mismatch
@@ -636,19 +636,19 @@ _NODISCARD _CONSTEXPR20 pair<_InIt1, _InIt2> mismatch(
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD pair<_FwdIt1, _FwdIt2> mismatch(
     _ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred) noexcept; // terminates
 #endif // _HAS_CXX17
 
-template <class _InIt1, class _InIt2>
+_EXPORT_STD template <class _InIt1, class _InIt2>
 _NODISCARD _CONSTEXPR20 pair<_InIt1, _InIt2> mismatch(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2) {
     // return [_First1, _Last1)/[_First2, _Last2) mismatch
     return _STD mismatch(_First1, _Last1, _First2, _Last2, equal_to<>{});
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD pair<_FwdIt1, _FwdIt2> mismatch(
     _ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2) noexcept /* terminates */ {
     // return [_First1, _Last1)/[_First2, _Last2) mismatch
@@ -759,11 +759,11 @@ namespace ranges {
         // clang-format on
     };
 
-    inline constexpr _Equal_fn equal{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Equal_fn equal{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _FwdIt1, class _FwdIt2, class _Pr>
+_EXPORT_STD template <class _FwdIt1, class _FwdIt2, class _Pr>
 _NODISCARD _CONSTEXPR20 bool is_permutation(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr _Pred) {
     // test if [_First1, _Last1) == permuted [_First2, ...)
     _Adl_verify_range(_First1, _Last1);
@@ -787,13 +787,13 @@ _NODISCARD _CONSTEXPR20 bool is_permutation(_FwdIt1 _First1, _FwdIt1 _Last1, _Fw
     return _Check_match_counts(_UFirst1, _ULast1, _UFirst2, _STD next(_UFirst2, _Dist2), _Pass_fn(_Pred));
 }
 
-template <class _FwdIt1, class _FwdIt2>
+_EXPORT_STD template <class _FwdIt1, class _FwdIt2>
 _NODISCARD _CONSTEXPR20 bool is_permutation(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2) {
     // test if [_First1, _Last1) == permuted [_First2, ...)
     return _STD is_permutation(_First1, _Last1, _First2, equal_to<>{});
 }
 
-template <class _FwdIt1, class _FwdIt2, class _Pr>
+_EXPORT_STD template <class _FwdIt1, class _FwdIt2, class _Pr>
 _NODISCARD _CONSTEXPR20 bool is_permutation(
     _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred) {
     // test if [_First1, _Last1) == permuted [_First2, _Last2)
@@ -851,7 +851,7 @@ _NODISCARD _CONSTEXPR20 bool is_permutation(
     }
 }
 
-template <class _FwdIt1, class _FwdIt2>
+_EXPORT_STD template <class _FwdIt1, class _FwdIt2>
 _NODISCARD _CONSTEXPR20 bool is_permutation(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2) {
     // test if [_First1, _Last1) == permuted [_First2, _Last2)
     return _STD is_permutation(_First1, _Last1, _First2, _Last2, equal_to<>{});
@@ -1127,11 +1127,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Is_permutation_fn is_permutation{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Is_permutation_fn is_permutation{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _InIt, class _Pr>
+_EXPORT_STD template <class _InIt, class _Pr>
 _NODISCARD _CONSTEXPR20 bool all_of(_InIt _First, _InIt _Last, _Pr _Pred) { // test if all elements satisfy _Pred
     _Adl_verify_range(_First, _Last);
     auto _UFirst      = _Get_unwrapped(_First);
@@ -1146,7 +1146,7 @@ _NODISCARD _CONSTEXPR20 bool all_of(_InIt _First, _InIt _Last, _Pr _Pred) { // t
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD bool all_of(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept; // terminates
 #endif // _HAS_CXX17
 
@@ -1188,11 +1188,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _All_of_fn all_of{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _All_of_fn all_of{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _InIt, class _Pr>
+_EXPORT_STD template <class _InIt, class _Pr>
 _NODISCARD _CONSTEXPR20 bool any_of(const _InIt _First, const _InIt _Last, _Pr _Pred) {
     // test if any element satisfies _Pred
     _Adl_verify_range(_First, _Last);
@@ -1208,7 +1208,7 @@ _NODISCARD _CONSTEXPR20 bool any_of(const _InIt _First, const _InIt _Last, _Pr _
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD bool any_of(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept; // terminates
 #endif // _HAS_CXX17
 
@@ -1250,11 +1250,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Any_of_fn any_of{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Any_of_fn any_of{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _InIt, class _Pr>
+_EXPORT_STD template <class _InIt, class _Pr>
 _NODISCARD _CONSTEXPR20 bool none_of(const _InIt _First, const _InIt _Last, _Pr _Pred) {
     // test if no elements satisfy _Pred
     _Adl_verify_range(_First, _Last);
@@ -1270,7 +1270,7 @@ _NODISCARD _CONSTEXPR20 bool none_of(const _InIt _First, const _InIt _Last, _Pr
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD bool none_of(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept; // terminates
 #endif // _HAS_CXX17
 
@@ -1312,7 +1312,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _None_of_fn none_of{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _None_of_fn none_of{_Not_quite_object::_Construct_tag{}};
 
 #if _HAS_CXX23
     class _Contains_fn : private _Not_quite_object {
@@ -1341,7 +1341,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Contains_fn contains{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Contains_fn contains{_Not_quite_object::_Construct_tag{}};
 
     class _Contains_subrange_fn : private _Not_quite_object {
     public:
@@ -1383,10 +1383,10 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Contains_subrange_fn contains_subrange{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Contains_subrange_fn contains_subrange{_Not_quite_object::_Construct_tag{}};
 #endif // _HAS_CXX23
 
-    template <class _In, class _Out>
+    _EXPORT_STD template <class _In, class _Out>
     using copy_n_result = in_out_result<_In, _Out>;
 
     class _Copy_n_fn : private _Not_quite_object {
@@ -1415,9 +1415,9 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Copy_n_fn copy_n{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Copy_n_fn copy_n{_Not_quite_object::_Construct_tag{}};
 
-    template <class _In, class _Out>
+    _EXPORT_STD template <class _In, class _Out>
     using copy_backward_result = in_out_result<_In, _Out>;
 
     class _Copy_backward_fn : private _Not_quite_object {
@@ -1444,11 +1444,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Copy_backward_fn copy_backward{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Copy_backward_fn copy_backward{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _InIt, class _OutIt, class _Pr>
+_EXPORT_STD template <class _InIt, class _OutIt, class _Pr>
 _CONSTEXPR20 _OutIt copy_if(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred) { // copy each satisfying _Pred
     _Adl_verify_range(_First, _Last);
     auto _UFirst      = _Get_unwrapped(_First);
@@ -1466,7 +1466,7 @@ _CONSTEXPR20 _OutIt copy_if(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt2 copy_if(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _Pr _Pred) noexcept /* terminates */ {
     // copy each satisfying _Pred
     // not parallelized at present, parallelism expected to be feasible in a future release
@@ -1478,7 +1478,7 @@ _FwdIt2 copy_if(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _Pr _Pred
 
 #ifdef __cpp_lib_concepts
 namespace ranges {
-    template <class _In, class _Out>
+    _EXPORT_STD template <class _In, class _Out>
     using copy_if_result = in_out_result<_In, _Out>;
 
     class _Copy_if_fn : private _Not_quite_object {
@@ -1529,9 +1529,9 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Copy_if_fn copy_if{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Copy_if_fn copy_if{_Not_quite_object::_Construct_tag{}};
 
-    template <class _In, class _Out>
+    _EXPORT_STD template <class _In, class _Out>
     using move_result = in_out_result<_In, _Out>;
 
     template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out>
@@ -1579,9 +1579,9 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Move_fn move{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Move_fn move{_Not_quite_object::_Construct_tag{}};
 
-    template <class _In, class _Out>
+    _EXPORT_STD template <class _In, class _Out>
     using move_backward_result = in_out_result<_In, _Out>;
 
     // concept-constrained for strict enforcement as it is used by several algorithms
@@ -1625,11 +1625,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Move_backward_fn move_backward{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Move_backward_fn move_backward{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _InIt, class _OutIt1, class _OutIt2, class _Pr>
+_EXPORT_STD template <class _InIt, class _OutIt1, class _OutIt2, class _Pr>
 _CONSTEXPR20 pair<_OutIt1, _OutIt2> partition_copy(
     _InIt _First, _InIt _Last, _OutIt1 _Dest_true, _OutIt2 _Dest_false, _Pr _Pred) {
     // copy true partition to _Dest_true, false to _Dest_false
@@ -1654,7 +1654,8 @@ _CONSTEXPR20 pair<_OutIt1, _OutIt2> partition_copy(
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
 pair<_FwdIt2, _FwdIt3> partition_copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest_true, _FwdIt3 _Dest_false,
     _Pr _Pred) noexcept /* terminates */ {
     // copy true partition to _Dest_true, false to _Dest_false
@@ -1667,7 +1668,7 @@ pair<_FwdIt2, _FwdIt3> partition_copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _F
 
 #ifdef __cpp_lib_concepts
 namespace ranges {
-    template <class _In, class _Out1, class _Out2>
+    _EXPORT_STD template <class _In, class _Out1, class _Out2>
     using partition_copy_result = in_out_out_result<_In, _Out1, _Out2>;
 
     class _Partition_copy_fn : private _Not_quite_object {
@@ -1729,12 +1730,12 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Partition_copy_fn partition_copy{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Partition_copy_fn partition_copy{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 #endif // _HAS_CXX17
 
-template <class _InIt, class _Pr>
+_EXPORT_STD template <class _InIt, class _Pr>
 _NODISCARD _CONSTEXPR20 bool is_partitioned(const _InIt _First, const _InIt _Last, _Pr _Pred) {
     // test if [_First, _Last) partitioned by _Pred
     _Adl_verify_range(_First, _Last);
@@ -1761,7 +1762,7 @@ _NODISCARD _CONSTEXPR20 bool is_partitioned(const _InIt _First, const _InIt _Las
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD bool is_partitioned(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept; // terminates
 #endif // _HAS_CXX17
 
@@ -1813,11 +1814,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Is_partitioned_fn is_partitioned{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Is_partitioned_fn is_partitioned{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _FwdIt, class _Pr>
+_EXPORT_STD template <class _FwdIt, class _Pr>
 _NODISCARD _CONSTEXPR20 _FwdIt partition_point(_FwdIt _First, _FwdIt _Last, _Pr _Pred) {
     // find beginning of false partition in [_First, _Last)
     _Adl_verify_range(_First, _Last);
@@ -1935,7 +1936,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Partition_point_fn partition_point{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Partition_point_fn partition_point{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
@@ -1960,7 +1961,7 @@ _NODISCARD _CONSTEXPR20 bool _Equal_rev_pred_unchecked(_InIt1 _First1, _InIt2 _F
     return true;
 }
 
-template <class _FwdItHaystack, class _FwdItPat, class _Pr>
+_EXPORT_STD template <class _FwdItHaystack, class _FwdItPat, class _Pr>
 _NODISCARD _CONSTEXPR20 _FwdItHaystack search(_FwdItHaystack _First1, _FwdItHaystack _Last1, const _FwdItPat _First2,
     const _FwdItPat _Last2, _Pr _Pred) { // find first [_First2, _Last2) satisfying _Pred
     _Adl_verify_range(_First1, _Last1);
@@ -2004,12 +2005,13 @@ _NODISCARD _CONSTEXPR20 _FwdItHaystack search(_FwdItHaystack _First1, _FwdItHays
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdItHaystack, class _FwdItPat, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdItHaystack, class _FwdItPat, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _FwdItHaystack search(_ExPo&& _Exec, const _FwdItHaystack _First1, _FwdItHaystack _Last1,
     const _FwdItPat _First2, const _FwdItPat _Last2, _Pr _Pred) noexcept; // terminates
 #endif // _HAS_CXX17
 
-template <class _FwdItHaystack, class _FwdItPat>
+_EXPORT_STD template <class _FwdItHaystack, class _FwdItPat>
 _NODISCARD _CONSTEXPR20 _FwdItHaystack search(
     const _FwdItHaystack _First1, const _FwdItHaystack _Last1, const _FwdItPat _First2, const _FwdItPat _Last2) {
     // find first [_First2, _Last2) match
@@ -2017,7 +2019,7 @@ _NODISCARD _CONSTEXPR20 _FwdItHaystack search(
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdItHaystack, class _FwdItPat, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdItHaystack, class _FwdItPat, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _FwdItHaystack search(_ExPo&& _Exec, const _FwdItHaystack _First1, const _FwdItHaystack _Last1,
     const _FwdItPat _First2, const _FwdItPat _Last2) noexcept /* terminates */ {
     // find first [_First2, _Last2) match
@@ -2025,14 +2027,14 @@ _NODISCARD _FwdItHaystack search(_ExPo&& _Exec, const _FwdItHaystack _First1, co
 }
 #endif // _HAS_CXX17
 
-template <class _FwdItHaystack, class _Searcher>
+_EXPORT_STD template <class _FwdItHaystack, class _Searcher>
 _NODISCARD _CONSTEXPR20 _FwdItHaystack search(
     const _FwdItHaystack _First, const _FwdItHaystack _Last, const _Searcher& _Search) {
     // find _Search's pattern in [_First, _Last)
     return _Search(_First, _Last).first;
 }
 
-template <class _FwdIt, class _Diff, class _Ty, class _Pr>
+_EXPORT_STD template <class _FwdIt, class _Diff, class _Ty, class _Pr>
 _NODISCARD _CONSTEXPR20 _FwdIt search_n(
     const _FwdIt _First, _FwdIt _Last, const _Diff _Count_raw, const _Ty& _Val, _Pr _Pred) {
     // find first _Count * _Val satisfying _Pred
@@ -2105,19 +2107,20 @@ _NODISCARD _CONSTEXPR20 _FwdIt search_n(
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Diff, class _Ty, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Diff, class _Ty, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _FwdIt search_n(_ExPo&& _Exec, const _FwdIt _First, _FwdIt _Last, const _Diff _Count_raw, const _Ty& _Val,
     _Pr _Pred) noexcept; // terminates
 #endif // _HAS_CXX17
 
-template <class _FwdIt, class _Diff, class _Ty>
+_EXPORT_STD template <class _FwdIt, class _Diff, class _Ty>
 _NODISCARD _CONSTEXPR20 _FwdIt search_n(const _FwdIt _First, const _FwdIt _Last, const _Diff _Count, const _Ty& _Val) {
     // find first _Count * _Val match
     return _STD search_n(_First, _Last, _Count, _Val, equal_to<>{});
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Diff, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Diff, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _FwdIt search_n(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, const _Diff _Count,
     const _Ty& _Val) noexcept /* terminates */ { // find first _Count * _Val match
     return _STD search_n(_STD forward<_ExPo>(_Exec), _First, _Last, _Count, _Val, equal_to{});
@@ -2283,7 +2286,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Search_n_fn search_n{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Search_n_fn search_n{_Not_quite_object::_Construct_tag{}};
 
 #if _HAS_CXX23
     class _Starts_with_fn : private _Not_quite_object {
@@ -2348,7 +2351,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Starts_with_fn starts_with{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Starts_with_fn starts_with{_Not_quite_object::_Construct_tag{}};
 
     class _Ends_with_fn : private _Not_quite_object {
     public:
@@ -2576,12 +2579,12 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Ends_with_fn ends_with{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Ends_with_fn ends_with{_Not_quite_object::_Construct_tag{}};
 #endif // _HAS_CXX23
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _FwdIt1, class _FwdIt2, class _Pr>
+_EXPORT_STD template <class _FwdIt1, class _FwdIt2, class _Pr>
 _NODISCARD _CONSTEXPR20 _FwdIt1 find_end(
     _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2, const _FwdIt2 _Last2, _Pr _Pred) {
     // find last [_First2, _Last2) satisfying _Pred
@@ -2662,7 +2665,7 @@ _NODISCARD _CONSTEXPR20 _FwdIt1 find_end(
     }
 }
 
-template <class _FwdIt1, class _FwdIt2>
+_EXPORT_STD template <class _FwdIt1, class _FwdIt2>
 _NODISCARD _CONSTEXPR20 _FwdIt1 find_end(
     _FwdIt1 const _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2, const _FwdIt2 _Last2) {
     // find last [_First2, _Last2) match
@@ -2670,11 +2673,11 @@ _NODISCARD _CONSTEXPR20 _FwdIt1 find_end(
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _FwdIt1 find_end(
     _ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred) noexcept; // terminates
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _FwdIt1 find_end(_ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2) noexcept
 /* terminates */ { // find last [_First2, _Last2) match
     return _STD find_end(_STD forward<_ExPo>(_Exec), _First1, _Last1, _First2, _Last2, equal_to{});
@@ -2842,11 +2845,11 @@ namespace ranges {
         // clang-format on
     };
 
-    inline constexpr _Find_end_fn find_end{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Find_end_fn find_end{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _FwdIt1, class _FwdIt2, class _Pr>
+_EXPORT_STD template <class _FwdIt1, class _FwdIt2, class _Pr>
 _NODISCARD _CONSTEXPR20 _FwdIt1 find_first_of(
     _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2, const _FwdIt2 _Last2, _Pr _Pred) {
     // look for one of [_First2, _Last2) satisfying _Pred with element
@@ -2869,18 +2872,18 @@ _NODISCARD _CONSTEXPR20 _FwdIt1 find_first_of(
     return _First1;
 }
 
-template <class _FwdIt1, class _FwdIt2>
+_EXPORT_STD template <class _FwdIt1, class _FwdIt2>
 _NODISCARD _CONSTEXPR20 _FwdIt1 find_first_of(const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2,
     const _FwdIt2 _Last2) { // look for one of [_First2, _Last2) that matches element
     return _STD find_first_of(_First1, _Last1, _First2, _Last2, equal_to<>{});
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _FwdIt1 find_first_of(_ExPo&& _Exec, const _FwdIt1 _First1, _FwdIt1 _Last1, const _FwdIt2 _First2,
     const _FwdIt2 _Last2, _Pr _Pred) noexcept; // terminates
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _FwdIt1 find_first_of(_ExPo&& _Exec, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2,
     const _FwdIt2 _Last2) noexcept /* terminates */ { // look for one of [_First2, _Last2) that matches element
     return _STD find_first_of(_STD forward<_ExPo>(_Exec), _First1, _Last1, _First2, _Last2, equal_to{});
@@ -2946,9 +2949,9 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Find_first_of_fn find_first_of{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Find_first_of_fn find_first_of{_Not_quite_object::_Construct_tag{}};
 
-    template <class _In1, class _In2>
+    _EXPORT_STD template <class _In1, class _In2>
     using swap_ranges_result = in_in_result<_In1, _In2>;
 
     class _Swap_ranges_fn : private _Not_quite_object {
@@ -3038,11 +3041,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Swap_ranges_fn swap_ranges{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Swap_ranges_fn swap_ranges{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _FwdIt1, class _FwdIt2>
+_EXPORT_STD template <class _FwdIt1, class _FwdIt2>
 _CONSTEXPR20 _FwdIt2 swap_ranges(const _FwdIt1 _First1, const _FwdIt1 _Last1, _FwdIt2 _First2) {
     // swap [_First1, _Last1) with [_First2, ...)
     _Adl_verify_range(_First1, _Last1);
@@ -3055,7 +3058,7 @@ _CONSTEXPR20 _FwdIt2 swap_ranges(const _FwdIt1 _First1, const _FwdIt1 _Last1, _F
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt2 swap_ranges(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _Dest) noexcept /* terminates */ {
     // swap [_First1, _Last1) with [_Dest, ...)
     // not parallelized as benchmarks show it isn't worth it
@@ -3063,7 +3066,7 @@ _FwdIt2 swap_ranges(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _Dest) noe
 }
 #endif // _HAS_CXX17
 
-template <class _InIt, class _OutIt, class _Fn>
+_EXPORT_STD template <class _InIt, class _OutIt, class _Fn>
 _CONSTEXPR20 _OutIt transform(const _InIt _First, const _InIt _Last, _OutIt _Dest, _Fn _Func) {
     // transform [_First, _Last) with _Func
     _Adl_verify_range(_First, _Last);
@@ -3079,12 +3082,12 @@ _CONSTEXPR20 _OutIt transform(const _InIt _First, const _InIt _Last, _OutIt _Des
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Fn, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Fn, _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt2 transform(
     _ExPo&& _Exec, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _Fn _Func) noexcept; // terminates
 #endif // _HAS_CXX17
 
-template <class _InIt1, class _InIt2, class _OutIt, class _Fn>
+_EXPORT_STD template <class _InIt1, class _InIt2, class _OutIt, class _Fn>
 _CONSTEXPR20 _OutIt transform(
     const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, _OutIt _Dest, _Fn _Func) {
     // transform [_First1, _Last1) and [_First2, ...) with _Func
@@ -3103,17 +3106,18 @@ _CONSTEXPR20 _OutIt transform(
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Fn, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Fn,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt3 transform(_ExPo&& _Exec, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2, _FwdIt3 _Dest,
     _Fn _Func) noexcept; // terminates
 #endif // _HAS_CXX17
 
 #ifdef __cpp_lib_concepts
 namespace ranges {
-    template <class _In, class _Out>
+    _EXPORT_STD template <class _In, class _Out>
     using unary_transform_result = in_out_result<_In, _Out>;
 
-    template <class _In1, class _In2, class _Out>
+    _EXPORT_STD template <class _In1, class _In2, class _Out>
     using binary_transform_result = in_in_out_result<_In1, _In2, _Out>;
 
     class _Transform_fn : private _Not_quite_object {
@@ -3213,11 +3217,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Transform_fn transform{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Transform_fn transform{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _FwdIt, class _Ty>
+_EXPORT_STD template <class _FwdIt, class _Ty>
 _CONSTEXPR20 void replace(const _FwdIt _First, const _FwdIt _Last, const _Ty& _Oldval, const _Ty& _Newval) {
     // replace each matching _Oldval with _Newval
     _Adl_verify_range(_First, _Last);
@@ -3231,7 +3235,7 @@ _CONSTEXPR20 void replace(const _FwdIt _First, const _FwdIt _Last, const _Ty& _O
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
 void replace(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, const _Ty& _Oldval,
     const _Ty& _Newval) noexcept; // terminates
 #endif // _HAS_CXX17
@@ -3292,11 +3296,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Replace_fn replace{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Replace_fn replace{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _FwdIt, class _Pr, class _Ty>
+_EXPORT_STD template <class _FwdIt, class _Pr, class _Ty>
 _CONSTEXPR20 void replace_if(const _FwdIt _First, const _FwdIt _Last, _Pr _Pred, const _Ty& _Val) {
     // replace each satisfying _Pred with _Val
     _Adl_verify_range(_First, _Last);
@@ -3310,7 +3314,7 @@ _CONSTEXPR20 void replace_if(const _FwdIt _First, const _FwdIt _Last, _Pr _Pred,
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Pr, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
 void replace_if(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, _Pr _Pred, const _Ty& _Val) noexcept; // terminates
 #endif // _HAS_CXX17
 
@@ -3369,11 +3373,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Replace_if_fn replace_if{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Replace_if_fn replace_if{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _InIt, class _OutIt, class _Ty>
+_EXPORT_STD template <class _InIt, class _OutIt, class _Ty>
 _CONSTEXPR20 _OutIt replace_copy(_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty& _Oldval, const _Ty& _Newval) {
     // copy replacing each matching _Oldval with _Newval
     _Adl_verify_range(_First, _Last);
@@ -3393,7 +3397,7 @@ _CONSTEXPR20 _OutIt replace_copy(_InIt _First, _InIt _Last, _OutIt _Dest, const
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt2 replace_copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, const _Ty& _Oldval,
     const _Ty& _Newval) noexcept /* terminates */ {
     // copy replacing each matching _Oldval with _Newval
@@ -3406,7 +3410,7 @@ _FwdIt2 replace_copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, cons
 
 #ifdef __cpp_lib_concepts
 namespace ranges {
-    template <class _In, class _Out>
+    _EXPORT_STD template <class _In, class _Out>
     using replace_copy_result = in_out_result<_In, _Out>;
 
     class _Replace_copy_fn : private _Not_quite_object {
@@ -3467,11 +3471,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Replace_copy_fn replace_copy{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Replace_copy_fn replace_copy{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _InIt, class _OutIt, class _Pr, class _Ty>
+_EXPORT_STD template <class _InIt, class _OutIt, class _Pr, class _Ty>
 _CONSTEXPR20 _OutIt replace_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred, const _Ty& _Val) {
     // copy replacing each satisfying _Pred with _Val
     _Adl_verify_range(_First, _Last);
@@ -3491,7 +3495,8 @@ _CONSTEXPR20 _OutIt replace_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, class _Ty,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt2 replace_copy_if(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _Pr _Pred, const _Ty& _Val) noexcept
 /* terminates */ {
     // copy replacing each satisfying _Pred with _Val
@@ -3504,7 +3509,7 @@ _FwdIt2 replace_copy_if(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _
 
 #ifdef __cpp_lib_concepts
 namespace ranges {
-    template <class _In, class _Out>
+    _EXPORT_STD template <class _In, class _Out>
     using replace_copy_if_result = in_out_result<_In, _Out>;
 
     class _Replace_copy_if_fn : private _Not_quite_object {
@@ -3560,7 +3565,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Replace_copy_if_fn replace_copy_if{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Replace_copy_if_fn replace_copy_if{_Not_quite_object::_Construct_tag{}};
 
     class _Fill_fn : private _Not_quite_object {
     public:
@@ -3605,7 +3610,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Fill_fn fill{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Fill_fn fill{_Not_quite_object::_Construct_tag{}};
 
     class _Generate_fn : private _Not_quite_object {
     public:
@@ -3646,7 +3651,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Generate_fn generate{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Generate_fn generate{_Not_quite_object::_Construct_tag{}};
 
     class _Generate_n_fn : private _Not_quite_object {
     public:
@@ -3669,11 +3674,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Generate_n_fn generate_n{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Generate_n_fn generate_n{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _FwdIt, class _Fn>
+_EXPORT_STD template <class _FwdIt, class _Fn>
 _CONSTEXPR20 void generate(_FwdIt _First, _FwdIt _Last, _Fn _Func) { // replace [_First, _Last) with _Func()
     _Adl_verify_range(_First, _Last);
     auto _UFirst      = _Get_unwrapped(_First);
@@ -3684,7 +3689,7 @@ _CONSTEXPR20 void generate(_FwdIt _First, _FwdIt _Last, _Fn _Func) { // replace
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Fn, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Fn, _Enable_if_execution_policy_t<_ExPo> = 0>
 void generate(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Fn _Func) noexcept /* terminates */ {
     // replace [_First, _Last) with _Func()
     // not parallelized at present due to unclear parallelism requirements on _Func
@@ -3692,7 +3697,7 @@ void generate(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Fn _Func) noexcept /* termi
 }
 #endif // _HAS_CXX17
 
-template <class _OutIt, class _Diff, class _Fn>
+_EXPORT_STD template <class _OutIt, class _Diff, class _Fn>
 _CONSTEXPR20 _OutIt generate_n(_OutIt _Dest, const _Diff _Count_raw, _Fn _Func) {
     // replace [_Dest, _Dest + _Count) with _Func()
     _Algorithm_int_t<_Diff> _Count = _Count_raw;
@@ -3711,7 +3716,7 @@ _CONSTEXPR20 _OutIt generate_n(_OutIt _Dest, const _Diff _Count_raw, _Fn _Func)
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Diff, class _Fn, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Diff, class _Fn, _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt generate_n(_ExPo&&, const _FwdIt _Dest, const _Diff _Count_raw, _Fn _Func) noexcept /* terminates */ {
     // replace [_Dest, _Dest + _Count) with _Func()
     // not parallelized at present due to unclear parallelism requirements on _Func
@@ -3720,7 +3725,7 @@ _FwdIt generate_n(_ExPo&&, const _FwdIt _Dest, const _Diff _Count_raw, _Fn _Func
 }
 #endif // _HAS_CXX17
 
-template <class _InIt, class _OutIt, class _Ty>
+_EXPORT_STD template <class _InIt, class _OutIt, class _Ty>
 _CONSTEXPR20 _OutIt remove_copy(_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty& _Val) {
     // copy omitting each matching _Val
     _Adl_verify_range(_First, _Last);
@@ -3739,7 +3744,7 @@ _CONSTEXPR20 _OutIt remove_copy(_InIt _First, _InIt _Last, _OutIt _Dest, const _
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt2 remove_copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, const _Ty& _Val) noexcept /* terminates */ {
     // copy omitting each matching _Val
     // not parallelized at present, parallelism expected to be feasible in a future release
@@ -3749,7 +3754,7 @@ _FwdIt2 remove_copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, const
 }
 #endif // _HAS_CXX17
 
-template <class _InIt, class _OutIt, class _Pr>
+_EXPORT_STD template <class _InIt, class _OutIt, class _Pr>
 _CONSTEXPR20 _OutIt remove_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred) {
     // copy omitting each element satisfying _Pred
     _Adl_verify_range(_First, _Last);
@@ -3768,7 +3773,7 @@ _CONSTEXPR20 _OutIt remove_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt2 remove_copy_if(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _Pr _Pred) noexcept /* terminates */ {
     // copy omitting each element satisfying _Pred
     // not parallelized at present, parallelism expected to be feasible in a future release
@@ -3779,11 +3784,11 @@ _FwdIt2 remove_copy_if(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _P
 #endif // _HAS_CXX17
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD_REMOVE_ALG _FwdIt remove(
     _ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, const _Ty& _Val) noexcept; // terminates
 
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD_REMOVE_ALG _FwdIt remove_if(
     _ExPo&& _Exec, _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept; // terminates
 #endif // _HAS_CXX17
@@ -3842,7 +3847,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Remove_fn remove{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Remove_fn remove{_Not_quite_object::_Construct_tag{}};
 
     class _Remove_if_fn : private _Not_quite_object {
     public:
@@ -3896,9 +3901,9 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Remove_if_fn remove_if{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Remove_if_fn remove_if{_Not_quite_object::_Construct_tag{}};
 
-    template <class _In, class _Out>
+    _EXPORT_STD template <class _In, class _Out>
     using remove_copy_result = in_out_result<_In, _Out>;
 
     class _Remove_copy_fn : private _Not_quite_object {
@@ -3960,9 +3965,9 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Remove_copy_fn remove_copy{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Remove_copy_fn remove_copy{_Not_quite_object::_Construct_tag{}};
 
-    template <class _In, class _Out>
+    _EXPORT_STD template <class _In, class _Out>
     using remove_copy_if_result = in_out_result<_In, _Out>;
 
     class _Remove_copy_if_fn : private _Not_quite_object {
@@ -4020,11 +4025,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Remove_copy_if_fn remove_copy_if{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Remove_copy_if_fn remove_copy_if{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _FwdIt, class _Pr>
+_EXPORT_STD template <class _FwdIt, class _Pr>
 _NODISCARD_UNIQUE_ALG _CONSTEXPR20 _FwdIt unique(_FwdIt _First, _FwdIt _Last, _Pr _Pred) {
     // remove each satisfying _Pred with previous
     _Adl_verify_range(_First, _Last);
@@ -4049,20 +4054,20 @@ _NODISCARD_UNIQUE_ALG _CONSTEXPR20 _FwdIt unique(_FwdIt _First, _FwdIt _Last, _P
     return _Last;
 }
 
-template <class _FwdIt>
+_EXPORT_STD template <class _FwdIt>
 _NODISCARD_UNIQUE_ALG _CONSTEXPR20 _FwdIt unique(_FwdIt _First, _FwdIt _Last) { // remove each matching previous
     return _STD unique(_First, _Last, equal_to<>{});
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD_UNIQUE_ALG _FwdIt unique(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
     // remove each satisfying _Pred with previous
     // not parallelized at present, parallelism expected to be feasible in a future release
     return _STD unique(_First, _Last, _Pass_fn(_Pred));
 }
 
-template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD_UNIQUE_ALG _FwdIt unique(_ExPo&&, _FwdIt _First, _FwdIt _Last) noexcept /* terminates */ {
     // remove each matching previous
     // not parallelized at present, parallelism expected to be feasible in a future release
@@ -4134,7 +4139,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Unique_fn unique{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Unique_fn unique{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
@@ -4146,7 +4151,7 @@ _INLINE_VAR constexpr bool
 #endif
     _Can_reread_dest = _Is_cpp17_fwd_iter_v<_OutIt> && is_same_v<_Iter_value_t<_InIt>, _Iter_value_t<_OutIt>>;
 
-template <class _InIt, class _OutIt, class _Pr>
+_EXPORT_STD template <class _InIt, class _OutIt, class _Pr>
 _CONSTEXPR20 _OutIt unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred) {
     // copy compressing pairs that match
     _Adl_verify_range(_First, _Last);
@@ -4202,13 +4207,13 @@ _CONSTEXPR20 _OutIt unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pr
     return _Dest;
 }
 
-template <class _InIt, class _OutIt>
+_EXPORT_STD template <class _InIt, class _OutIt>
 _CONSTEXPR20 _OutIt unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest) { // copy compressing pairs that match
     return _STD unique_copy(_First, _Last, _Dest, equal_to<>{});
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt2 unique_copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _Pr _Pred) noexcept /* terminates */ {
     // copy compressing pairs that match
     // not parallelized at present, parallelism expected to be feasible in a future release
@@ -4217,7 +4222,7 @@ _FwdIt2 unique_copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _Pr _
     return _STD unique_copy(_First, _Last, _Dest, _Pass_fn(_Pred));
 }
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt2 unique_copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest) noexcept /* terminates */ {
     // copy compressing pairs that match
     // not parallelized at present, parallelism expected to be feasible in a future release
@@ -4229,7 +4234,7 @@ _FwdIt2 unique_copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest) noexc
 
 #ifdef __cpp_lib_concepts
 namespace ranges {
-    template <class _In, class _Out>
+    _EXPORT_STD template <class _In, class _Out>
     using unique_copy_result = in_out_result<_In, _Out>;
 
     template <class _It, class _Ty>
@@ -4331,7 +4336,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Unique_copy_fn unique_copy{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Unique_copy_fn unique_copy{_Not_quite_object::_Construct_tag{}};
 
     // concept-constrained for strict enforcement as it is used by several algorithms
     template <bidirectional_iterator _It>
@@ -4393,11 +4398,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Reverse_fn reverse{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Reverse_fn reverse{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _BidIt, class _OutIt>
+_EXPORT_STD template <class _BidIt, class _OutIt>
 _CONSTEXPR20 _OutIt reverse_copy(_BidIt _First, _BidIt _Last, _OutIt _Dest) {
     // copy reversing elements in [_First, _Last)
     _Adl_verify_range(_First, _Last);
@@ -4444,7 +4449,7 @@ _CONSTEXPR20 _OutIt reverse_copy(_BidIt _First, _BidIt _Last, _OutIt _Dest) {
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _BidIt, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _BidIt, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt reverse_copy(_ExPo&&, _BidIt _First, _BidIt _Last, _FwdIt _Dest) noexcept /* terminates */ {
     // copy reversing elements in [_First, _Last)
     // not parallelized as benchmarks show it isn't worth it
@@ -4455,7 +4460,7 @@ _FwdIt reverse_copy(_ExPo&&, _BidIt _First, _BidIt _Last, _FwdIt _Dest) noexcept
 
 #ifdef __cpp_lib_concepts
 namespace ranges {
-    template <class _In, class _Out>
+    _EXPORT_STD template <class _In, class _Out>
     using reverse_copy_result = in_out_result<_In, _Out>;
 
     class _Reverse_copy_fn : private _Not_quite_object {
@@ -4531,7 +4536,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Reverse_copy_fn reverse_copy{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Reverse_copy_fn reverse_copy{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 #endif // _HAS_CXX17
@@ -4641,11 +4646,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Rotate_fn rotate{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Rotate_fn rotate{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _FwdIt, class _OutIt>
+_EXPORT_STD template <class _FwdIt, class _OutIt>
 _CONSTEXPR20 _OutIt rotate_copy(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, _OutIt _Dest) {
     // copy rotating [_First, _Last)
     _Adl_verify_range(_First, _Mid);
@@ -4660,7 +4665,7 @@ _CONSTEXPR20 _OutIt rotate_copy(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, _OutIt
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt2 rotate_copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Mid, _FwdIt1 _Last, _FwdIt2 _Dest) noexcept /* terminates */ {
     // copy rotating [_First, _Last)
     // not parallelized as benchmarks show it isn't worth it
@@ -4671,7 +4676,7 @@ _FwdIt2 rotate_copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Mid, _FwdIt1 _Last, _FwdIt
 
 #ifdef __cpp_lib_concepts
 namespace ranges {
-    template <class _In, class _Out>
+    _EXPORT_STD template <class _In, class _Out>
     using rotate_copy_result = in_out_result<_In, _Out>;
 
     class _Rotate_copy_fn : private _Not_quite_object {
@@ -4718,7 +4723,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Rotate_copy_fn rotate_copy{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Rotate_copy_fn rotate_copy{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
@@ -4766,7 +4771,7 @@ _SampleIt _Sample_selection_unchecked(
     return _Dest;
 }
 
-template <class _PopIt, class _SampleIt, class _Diff, class _Urng>
+_EXPORT_STD template <class _PopIt, class _SampleIt, class _Diff, class _Urng>
 _SampleIt sample(_PopIt _First, _PopIt _Last, _SampleIt _Dest, _Diff _Count, _Urng&& _Func) {
     // randomly select _Count elements from [_First, _Last) into _Dest
     static_assert(_Is_ranges_fwd_iter_v<_PopIt> || _Is_cpp17_random_iter_v<_SampleIt>,
@@ -4802,7 +4807,7 @@ _SampleIt sample(_PopIt _First, _PopIt _Last, _SampleIt _Dest, _Diff _Count, _Ur
 
 #ifdef __cpp_lib_concepts
 // clang-format off
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 concept uniform_random_bit_generator = invocable<_Ty&>
     && unsigned_integral<invoke_result_t<_Ty&>>
     && requires {
@@ -4915,7 +4920,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Sample_fn sample{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Sample_fn sample{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 #endif // _HAS_CXX17
@@ -4942,7 +4947,7 @@ void _Random_shuffle1(_RanIt _First, _RanIt _Last, _RngFn& _RngFunc) {
     }
 }
 
-template <class _RanIt, class _Urng>
+_EXPORT_STD template <class _RanIt, class _Urng>
 void shuffle(_RanIt _First, _RanIt _Last, _Urng&& _Func) { // shuffle [_First, _Last) using URNG _Func
     using _Urng0 = remove_reference_t<_Urng>;
     _Rng_from_urng<_Iter_diff_t<_RanIt>, _Urng0> _RngFunc(_Func);
@@ -5004,12 +5009,12 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Shuffle_fn shuffle{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Shuffle_fn shuffle{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
 #if _HAS_AUTO_PTR_ETC
-template <class _RanIt, class _RngFn>
+_EXPORT_STD template <class _RanIt, class _RngFn>
 void random_shuffle(_RanIt _First, _RanIt _Last, _RngFn&& _RngFunc) {
     // shuffle [_First, _Last) using random function _RngFunc
     _Random_shuffle1(_First, _Last, _RngFunc);
@@ -5031,7 +5036,7 @@ struct _Rand_urng_from_func { // wrap rand() as a URNG
     }
 };
 
-template <class _RanIt>
+_EXPORT_STD template <class _RanIt>
 void random_shuffle(_RanIt _First, _RanIt _Last) { // shuffle [_First, _Last) using rand()
     _Rand_urng_from_func _Func;
     _STD shuffle(_First, _Last, _Func);
@@ -5039,7 +5044,7 @@ void random_shuffle(_RanIt _First, _RanIt _Last) { // shuffle [_First, _Last) us
 #endif // _HAS_AUTO_PTR_ETC
 
 #if _HAS_CXX20
-template <class _FwdIt>
+_EXPORT_STD template <class _FwdIt>
 constexpr _FwdIt shift_left(_FwdIt _First, const _FwdIt _Last, _Iter_diff_t<_FwdIt> _Pos_to_shift) {
     // shift [_First, _Last) left by _Pos_to_shift
     // positions; returns the end of the resulting range
@@ -5073,14 +5078,14 @@ constexpr _FwdIt shift_left(_FwdIt _First, const _FwdIt _Last, _Iter_diff_t<_Fwd
     return _First;
 }
 
-template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt shift_left(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Iter_diff_t<_FwdIt> _Pos_to_shift) noexcept /* terminates */ {
     // shift [_First, _Last) left by _Pos_to_shift positions
     // not parallelized as benchmarks show it isn't worth it
     return _STD shift_left(_First, _Last, _Pos_to_shift);
 }
 
-template <class _FwdIt>
+_EXPORT_STD template <class _FwdIt>
 constexpr _FwdIt shift_right(_FwdIt _First, const _FwdIt _Last, _Iter_diff_t<_FwdIt> _Pos_to_shift) {
     // shift [_First, _Last) right by _Pos_to_shift
     // positions; returns the beginning of the resulting range
@@ -5154,7 +5159,7 @@ constexpr _FwdIt shift_right(_FwdIt _First, const _FwdIt _Last, _Iter_diff_t<_Fw
     }
 }
 
-template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt shift_right(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Iter_diff_t<_FwdIt> _Pos_to_shift) noexcept /* terminates */ {
     // shift [_First, _Last) right by _Pos_to_shift positions
     // not parallelized as benchmarks show it isn't worth it
@@ -5227,7 +5232,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Shift_left_fn shift_left{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Shift_left_fn shift_left{_Not_quite_object::_Construct_tag{}};
 
     class _Shift_right_fn : private _Not_quite_object {
     public:
@@ -5388,11 +5393,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Shift_right_fn shift_right{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Shift_right_fn shift_right{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // _HAS_CXX23 && defined(__cpp_lib_concepts)
 
-template <class _FwdIt, class _Pr>
+_EXPORT_STD template <class _FwdIt, class _Pr>
 _CONSTEXPR20 _FwdIt partition(_FwdIt _First, const _FwdIt _Last, _Pr _Pred) {
     // move elements satisfying _Pred to beginning of sequence
     _Adl_verify_range(_First, _Last);
@@ -5451,7 +5456,7 @@ _CONSTEXPR20 _FwdIt partition(_FwdIt _First, const _FwdIt _Last, _Pr _Pred) {
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt partition(_ExPo&& _Exec, _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept; // terminates
 
 #ifdef __cpp_lib_concepts
@@ -5532,7 +5537,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Partition_fn partition{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Partition_fn partition{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 #endif // _HAS_CXX17
@@ -5689,7 +5694,7 @@ _BidIt _Stable_partition_unchecked(_BidIt _First, _BidIt _Last, _Pr _Pred) {
     return _Stable_partition_unchecked1(_First, _Last, _Pred, _Total_count, _Temp_buf._Data, _Temp_buf._Capacity).first;
 }
 
-template <class _BidIt, class _Pr>
+_EXPORT_STD template <class _BidIt, class _Pr>
 _BidIt stable_partition(_BidIt _First, _BidIt _Last, _Pr _Pred) {
     // partition preserving order of equivalents
     _Adl_verify_range(_First, _Last);
@@ -5698,7 +5703,7 @@ _BidIt stable_partition(_BidIt _First, _BidIt _Last, _Pr _Pred) {
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _BidIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _BidIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _BidIt stable_partition(_ExPo&&, _BidIt _First, _BidIt _Last, _Pr _Pred) noexcept /* terminates */ {
     // partition preserving order of equivalents
     // not parallelized at present, parallelism expected to be feasible in a future release
@@ -5905,7 +5910,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Stable_partition_fn stable_partition{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Stable_partition_fn stable_partition{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
@@ -5925,7 +5930,7 @@ _CONSTEXPR20 void _Push_heap_by_index(
     *(_First + _Hole) = _STD forward<_Ty>(_Val); // drop _Val into final hole
 }
 
-template <class _RanIt, class _Pr>
+_EXPORT_STD template <class _RanIt, class _Pr>
 _CONSTEXPR20 void push_heap(_RanIt _First, _RanIt _Last, _Pr _Pred) {
     // push *(_Last - 1) onto heap at [_First, _Last - 1)
     _Adl_verify_range(_First, _Last);
@@ -5939,7 +5944,7 @@ _CONSTEXPR20 void push_heap(_RanIt _First, _RanIt _Last, _Pr _Pred) {
     }
 }
 
-template <class _RanIt>
+_EXPORT_STD template <class _RanIt>
 _CONSTEXPR20 void push_heap(_RanIt _First, _RanIt _Last) {
     // push *(_Last - 1) onto heap at [_First, _Last - 1)
     _STD push_heap(_First, _Last, less<>{});
@@ -6015,7 +6020,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Push_heap_fn push_heap{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Push_heap_fn push_heap{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
@@ -6070,14 +6075,14 @@ _CONSTEXPR20 void _Pop_heap_unchecked(_RanIt _First, _RanIt _Last, _Pr _Pred) {
     }
 }
 
-template <class _RanIt, class _Pr>
+_EXPORT_STD template <class _RanIt, class _Pr>
 _CONSTEXPR20 void pop_heap(_RanIt _First, _RanIt _Last, _Pr _Pred) {
     // pop *_First to *(_Last - 1) and reheap
     _Adl_verify_range(_First, _Last);
     _Pop_heap_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Pass_fn(_Pred));
 }
 
-template <class _RanIt>
+_EXPORT_STD template <class _RanIt>
 _CONSTEXPR20 void pop_heap(_RanIt _First, _RanIt _Last) {
     // pop *_First to *(_Last - 1) and reheap
     _STD pop_heap(_First, _Last, less<>{});
@@ -6181,7 +6186,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Pop_heap_fn pop_heap{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Pop_heap_fn pop_heap{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
@@ -6198,13 +6203,13 @@ _CONSTEXPR20 void _Make_heap_unchecked(_RanIt _First, _RanIt _Last, _Pr _Pred) {
     }
 }
 
-template <class _RanIt, class _Pr>
+_EXPORT_STD template <class _RanIt, class _Pr>
 _CONSTEXPR20 void make_heap(_RanIt _First, _RanIt _Last, _Pr _Pred) { // make [_First, _Last) into a heap
     _Adl_verify_range(_First, _Last);
     _Make_heap_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Pass_fn(_Pred));
 }
 
-template <class _RanIt>
+_EXPORT_STD template <class _RanIt>
 _CONSTEXPR20 void make_heap(_RanIt _First, _RanIt _Last) { // make [_First, _Last) into a heap
     _STD make_heap(_First, _Last, less<>{});
 }
@@ -6255,7 +6260,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Make_heap_fn make_heap{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Make_heap_fn make_heap{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
@@ -6273,7 +6278,7 @@ _CONSTEXPR20 _RanIt _Is_heap_until_unchecked(_RanIt _First, _RanIt _Last, _Pr _P
     return _Last;
 }
 
-template <class _RanIt, class _Pr>
+_EXPORT_STD template <class _RanIt, class _Pr>
 _NODISCARD _CONSTEXPR20 _RanIt is_heap_until(_RanIt _First, _RanIt _Last, _Pr _Pred) {
     // find extent of range that is a heap
     _Adl_verify_range(_First, _Last);
@@ -6281,7 +6286,7 @@ _NODISCARD _CONSTEXPR20 _RanIt is_heap_until(_RanIt _First, _RanIt _Last, _Pr _P
     return _First;
 }
 
-template <class _RanIt, class _Pr>
+_EXPORT_STD template <class _RanIt, class _Pr>
 _NODISCARD _CONSTEXPR20 bool is_heap(_RanIt _First, _RanIt _Last, _Pr _Pred) {
     // test if range is a heap
     _Adl_verify_range(_First, _Last);
@@ -6290,34 +6295,34 @@ _NODISCARD _CONSTEXPR20 bool is_heap(_RanIt _First, _RanIt _Last, _Pr _Pred) {
     return _Is_heap_until_unchecked(_UFirst, _ULast, _Pass_fn(_Pred)) == _ULast;
 }
 
-template <class _RanIt>
+_EXPORT_STD template <class _RanIt>
 _NODISCARD _CONSTEXPR20 _RanIt is_heap_until(_RanIt _First, _RanIt _Last) {
     // find extent of range that is a heap ordered by operator<
     return _STD is_heap_until(_First, _Last, less<>{});
 }
 
-template <class _RanIt>
+_EXPORT_STD template <class _RanIt>
 _NODISCARD _CONSTEXPR20 bool is_heap(_RanIt _First, _RanIt _Last) { // test if range is a heap ordered by operator<
     return _STD is_heap(_First, _Last, less<>{});
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _RanIt is_heap_until(_ExPo&& _Exec, _RanIt _First, _RanIt _Last, _Pr _Pred) noexcept; // terminates
 
-template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD bool is_heap(_ExPo&& _Exec, _RanIt _First, _RanIt _Last, _Pr _Pred) noexcept /* terminates */ {
     // test if range is a heap
     return _STD is_heap_until(_STD forward<_ExPo>(_Exec), _First, _Last, _Pass_fn(_Pred)) == _Last;
 }
 
-template <class _ExPo, class _RanIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _RanIt, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _RanIt is_heap_until(_ExPo&& _Exec, _RanIt _First, _RanIt _Last) noexcept /* terminates */ {
     // find extent of range that is a heap ordered by operator<
     return _STD is_heap_until(_STD forward<_ExPo>(_Exec), _First, _Last, less{});
 }
 
-template <class _ExPo, class _RanIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _RanIt, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD bool is_heap(_ExPo&& _Exec, _RanIt _First, _RanIt _Last) noexcept /* terminates */ {
     // test if range is a heap ordered by operator<
     return _STD is_heap(_STD forward<_ExPo>(_Exec), _First, _Last, less{});
@@ -6375,7 +6380,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Is_heap_fn is_heap{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Is_heap_fn is_heap{_Not_quite_object::_Construct_tag{}};
 
     class _Is_heap_until_fn : private _Not_quite_object {
     public:
@@ -6402,7 +6407,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Is_heap_until_fn is_heap_until{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Is_heap_until_fn is_heap_until{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 #endif // _HAS_CXX17
@@ -6415,7 +6420,7 @@ _CONSTEXPR20 void _Sort_heap_unchecked(_RanIt _First, _RanIt _Last, _Pr _Pred) {
     }
 }
 
-template <class _RanIt, class _Pr>
+_EXPORT_STD template <class _RanIt, class _Pr>
 _CONSTEXPR20 void sort_heap(_RanIt _First, _RanIt _Last, _Pr _Pred) { // order heap by repeatedly popping
     _Adl_verify_range(_First, _Last);
     const auto _UFirst = _Get_unwrapped(_First);
@@ -6429,7 +6434,7 @@ _CONSTEXPR20 void sort_heap(_RanIt _First, _RanIt _Last, _Pr _Pred) { // order h
     _Sort_heap_unchecked(_UFirst, _ULast, _Pass_fn(_Pred));
 }
 
-template <class _RanIt>
+_EXPORT_STD template <class _RanIt>
 _CONSTEXPR20 void sort_heap(_RanIt _First, _RanIt _Last) { // order heap by repeatedly popping
     _STD sort_heap(_First, _Last, less<>{});
 }
@@ -6474,7 +6479,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Sort_heap_fn sort_heap{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Sort_heap_fn sort_heap{_Not_quite_object::_Construct_tag{}};
 
     template <class _It, class _Ty, class _Pr, class _Pj>
     _NODISCARD constexpr _It _Lower_bound_unchecked(
@@ -6529,7 +6534,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Lower_bound_fn lower_bound{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Lower_bound_fn lower_bound{_Not_quite_object::_Construct_tag{}};
 
     template <class _It, class _Ty, class _Pr, class _Pj>
     _NODISCARD constexpr _It _Upper_bound_unchecked(
@@ -6582,11 +6587,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Upper_bound_fn upper_bound{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Upper_bound_fn upper_bound{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _FwdIt, class _Ty, class _Pr>
+_EXPORT_STD template <class _FwdIt, class _Ty, class _Pr>
 _NODISCARD _CONSTEXPR20 pair<_FwdIt, _FwdIt> equal_range(_FwdIt _First, _FwdIt _Last, const _Ty& _Val, _Pr _Pred) {
     // find range equivalent to _Val
     _Adl_verify_range(_First, _Last);
@@ -6623,7 +6628,7 @@ _NODISCARD _CONSTEXPR20 pair<_FwdIt, _FwdIt> equal_range(_FwdIt _First, _FwdIt _
     return {_First, _Last};
 }
 
-template <class _FwdIt, class _Ty>
+_EXPORT_STD template <class _FwdIt, class _Ty>
 _NODISCARD _CONSTEXPR20 pair<_FwdIt, _FwdIt> equal_range(_FwdIt _First, _FwdIt _Last, const _Ty& _Val) {
     // find range equivalent to _Val
     return _STD equal_range(_First, _Last, _Val, less<>{});
@@ -6688,11 +6693,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Equal_range_fn equal_range{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Equal_range_fn equal_range{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _FwdIt, class _Ty, class _Pr>
+_EXPORT_STD template <class _FwdIt, class _Ty, class _Pr>
 _NODISCARD _CONSTEXPR20 bool binary_search(_FwdIt _First, _FwdIt _Last, const _Ty& _Val, _Pr _Pred) {
     // test if _Val equivalent to some element
     _Adl_verify_range(_First, _Last);
@@ -6702,7 +6707,7 @@ _NODISCARD _CONSTEXPR20 bool binary_search(_FwdIt _First, _FwdIt _Last, const _T
     return _UFirst != _ULast && !_Pred(_Val, *_UFirst);
 }
 
-template <class _FwdIt, class _Ty>
+_EXPORT_STD template <class _FwdIt, class _Ty>
 _NODISCARD _CONSTEXPR20 bool binary_search(_FwdIt _First, _FwdIt _Last, const _Ty& _Val) {
     // test if _Val equivalent to some element
     return _STD binary_search(_First, _Last, _Val, less<>{});
@@ -6737,7 +6742,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Binary_search_fn binary_search{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Binary_search_fn binary_search{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
@@ -6760,7 +6765,7 @@ _NODISCARD constexpr auto _Idl_dist_add(_Diff1 _Lhs, _Diff2 _Rhs) {
     return _Lhs + _Rhs;
 }
 
-template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
+_EXPORT_STD template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
 _CONSTEXPR20 _OutIt merge(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred) {
     // copy merging ranges
     _Adl_verify_range(_First1, _Last1);
@@ -6801,14 +6806,15 @@ _CONSTEXPR20 _OutIt merge(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2
     return _Dest;
 }
 
-template <class _InIt1, class _InIt2, class _OutIt>
+_EXPORT_STD template <class _InIt1, class _InIt2, class _OutIt>
 _CONSTEXPR20 _OutIt merge(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest) {
     // copy merging ranges
     return _STD merge(_First1, _Last1, _First2, _Last2, _Dest, less<>{});
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt3 merge(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _FwdIt3 _Dest,
     _Pr _Pred) noexcept /* terminates */ {
     // copy merging ranges
@@ -6819,7 +6825,8 @@ _FwdIt3 merge(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2
     return _STD merge(_First1, _Last1, _First2, _Last2, _Dest, _Pass_fn(_Pred));
 }
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt3 merge(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _FwdIt3 _Dest) noexcept
 /* terminates */ {
     // copy merging ranges
@@ -6832,7 +6839,7 @@ _FwdIt3 merge(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2
 
 #ifdef __cpp_lib_concepts
 namespace ranges {
-    template <class _In1, class _In2, class _Out>
+    _EXPORT_STD template <class _In1, class _In2, class _Out>
     using merge_result = in_in_out_result<_In1, _In2, _Out>;
 
     class _Merge_fn : private _Not_quite_object {
@@ -6905,7 +6912,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Merge_fn merge{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Merge_fn merge{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 #endif // _HAS_CXX17
@@ -7100,7 +7107,7 @@ void _Buffered_inplace_merge_unchecked(_BidIt _First, _BidIt _Mid, _BidIt _Last,
     _Buffered_inplace_merge_unchecked_impl(_First, _Mid, _Last, _Count1, _Count2, _Temp_ptr, _Capacity, _Pred);
 }
 
-template <class _BidIt, class _Pr>
+_EXPORT_STD template <class _BidIt, class _Pr>
 void inplace_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Pr _Pred) {
     // merge [_First, _Mid) with [_Mid, _Last)
     _Adl_verify_range(_First, _Mid);
@@ -7151,21 +7158,21 @@ void inplace_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Pr _Pred) {
         _UFirst, _UMid, _ULast, _Count1, _Count2, _Temp_buf._Data, _Temp_buf._Capacity, _Pass_fn(_Pred));
 }
 
-template <class _BidIt>
+_EXPORT_STD template <class _BidIt>
 void inplace_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last) {
     // merge [_First, _Mid) with [_Mid, _Last)
     _STD inplace_merge(_First, _Mid, _Last, less<>{});
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _BidIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _BidIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 void inplace_merge(_ExPo&&, _BidIt _First, _BidIt _Mid, _BidIt _Last, _Pr _Pred) noexcept /* terminates */ {
     // merge [_First, _Mid) with [_Mid, _Last)
     // not parallelized at present, parallelism expected to be feasible in a future release
     _STD inplace_merge(_First, _Mid, _Last, _Pass_fn(_Pred));
 }
 
-template <class _ExPo, class _BidIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _BidIt, _Enable_if_execution_policy_t<_ExPo> = 0>
 void inplace_merge(_ExPo&&, _BidIt _First, _BidIt _Mid, _BidIt _Last) noexcept /* terminates */ {
     // merge [_First, _Mid) with [_Mid, _Last)
     // not parallelized at present, parallelism expected to be feasible in a future release
@@ -7497,7 +7504,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Inplace_merge_fn inplace_merge{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Inplace_merge_fn inplace_merge{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
@@ -7658,7 +7665,7 @@ _CONSTEXPR20 void _Sort_unchecked(_RanIt _First, _RanIt _Last, _Iter_diff_t<_Ran
     }
 }
 
-template <class _RanIt, class _Pr>
+_EXPORT_STD template <class _RanIt, class _Pr>
 _CONSTEXPR20 void sort(const _RanIt _First, const _RanIt _Last, _Pr _Pred) { // order [_First, _Last)
     _Adl_verify_range(_First, _Last);
     const auto _UFirst = _Get_unwrapped(_First);
@@ -7666,16 +7673,16 @@ _CONSTEXPR20 void sort(const _RanIt _First, const _RanIt _Last, _Pr _Pred) { //
     _Sort_unchecked(_UFirst, _ULast, _ULast - _UFirst, _Pass_fn(_Pred));
 }
 
-template <class _RanIt>
+_EXPORT_STD template <class _RanIt>
 _CONSTEXPR20 void sort(const _RanIt _First, const _RanIt _Last) { // order [_First, _Last)
     _STD sort(_First, _Last, less<>{});
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 void sort(_ExPo&& _Exec, _RanIt _First, _RanIt _Last, _Pr _Pred) noexcept; // terminates
 
-template <class _ExPo, class _RanIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _RanIt, _Enable_if_execution_policy_t<_ExPo> = 0>
 void sort(_ExPo&& _Exec, const _RanIt _First, const _RanIt _Last) noexcept /* terminates */ {
     // order [_First, _Last)
     _STD sort(_STD forward<_ExPo>(_Exec), _First, _Last, less{});
@@ -7897,7 +7904,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Sort_fn sort{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Sort_fn sort{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
@@ -8060,7 +8067,7 @@ void _Stable_sort_unchecked(const _BidIt _First, const _BidIt _Last, const _Iter
     }
 }
 
-template <class _BidIt, class _Pr>
+_EXPORT_STD template <class _BidIt, class _Pr>
 void stable_sort(const _BidIt _First, const _BidIt _Last, _Pr _Pred) {
     // sort preserving order of equivalents
     _Adl_verify_range(_First, _Last);
@@ -8077,17 +8084,17 @@ void stable_sort(const _BidIt _First, const _BidIt _Last, _Pr _Pred) {
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _BidIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _BidIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 void stable_sort(_ExPo&& _Exec, const _BidIt _First, const _BidIt _Last, _Pr _Pred) noexcept; // terminates
 #endif // _HAS_CXX17
 
-template <class _BidIt>
+_EXPORT_STD template <class _BidIt>
 void stable_sort(const _BidIt _First, const _BidIt _Last) { // sort preserving order of equivalents
     _STD stable_sort(_First, _Last, less<>{});
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _BidIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _BidIt, _Enable_if_execution_policy_t<_ExPo> = 0>
 void stable_sort(_ExPo&& _Exec, _BidIt _First, _BidIt _Last) noexcept /* terminates */ {
     // sort preserving order of equivalents
     _STD stable_sort(_STD forward<_ExPo>(_Exec), _First, _Last, less{});
@@ -8347,11 +8354,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Stable_sort_fn stable_sort{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Stable_sort_fn stable_sort{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _RanIt, class _Pr>
+_EXPORT_STD template <class _RanIt, class _Pr>
 _CONSTEXPR20 void partial_sort(_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred) {
     // order [_First, _Last) up to _Mid
     _Adl_verify_range(_First, _Mid);
@@ -8375,21 +8382,21 @@ _CONSTEXPR20 void partial_sort(_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pr
     _Sort_heap_unchecked(_UFirst, _UMid, _Pass_fn(_Pred));
 }
 
-template <class _RanIt>
+_EXPORT_STD template <class _RanIt>
 _CONSTEXPR20 void partial_sort(_RanIt _First, _RanIt _Mid, _RanIt _Last) {
     // order [_First, _Last) up to _Mid
     _STD partial_sort(_First, _Mid, _Last, less<>{});
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 void partial_sort(_ExPo&&, _RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred) noexcept /* terminates */ {
     // order [_First, _Last) up to _Mid
     // parallelism suspected to be infeasible
     return _STD partial_sort(_First, _Mid, _Last, _Pass_fn(_Pred));
 }
 
-template <class _ExPo, class _RanIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _RanIt, _Enable_if_execution_policy_t<_ExPo> = 0>
 void partial_sort(_ExPo&&, _RanIt _First, _RanIt _Mid, _RanIt _Last) noexcept /* terminates */ {
     // order [_First, _Last) up to _Mid
     // parallelism suspected to be infeasible
@@ -8466,12 +8473,12 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Partial_sort_fn partial_sort{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Partial_sort_fn partial_sort{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 #endif // _HAS_CXX17
 
-template <class _InIt, class _RanIt, class _Pr>
+_EXPORT_STD template <class _InIt, class _RanIt, class _Pr>
 _CONSTEXPR20 _RanIt partial_sort_copy(_InIt _First1, _InIt _Last1, _RanIt _First2, _RanIt _Last2, _Pr _Pred) {
     // copy [_First1, _Last1) into [_First2, _Last2)
     _Adl_verify_range(_First1, _Last1);
@@ -8503,14 +8510,14 @@ _CONSTEXPR20 _RanIt partial_sort_copy(_InIt _First1, _InIt _Last1, _RanIt _First
     return _First2;
 }
 
-template <class _InIt, class _RanIt>
+_EXPORT_STD template <class _InIt, class _RanIt>
 _CONSTEXPR20 _RanIt partial_sort_copy(_InIt _First1, _InIt _Last1, _RanIt _First2, _RanIt _Last2) {
     // copy [_First1, _Last1) into [_First2, _Last2)
     return _STD partial_sort_copy(_First1, _Last1, _First2, _Last2, less<>{});
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _RanIt partial_sort_copy(_ExPo&&, _FwdIt _First1, _FwdIt _Last1, _RanIt _First2, _RanIt _Last2, _Pr _Pred) noexcept
 /* terminates */ {
     // copy [_First1, _Last1) into [_First2, _Last2)
@@ -8520,7 +8527,7 @@ _RanIt partial_sort_copy(_ExPo&&, _FwdIt _First1, _FwdIt _Last1, _RanIt _First2,
     return _STD partial_sort_copy(_First1, _Last1, _First2, _Last2, _Pass_fn(_Pred));
 }
 
-template <class _ExPo, class _FwdIt, class _RanIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _RanIt, _Enable_if_execution_policy_t<_ExPo> = 0>
 _RanIt partial_sort_copy(_ExPo&&, _FwdIt _First1, _FwdIt _Last1, _RanIt _First2, _RanIt _Last2) noexcept
 /* terminates */ {
     // copy [_First1, _Last1) into [_First2, _Last2)
@@ -8532,7 +8539,7 @@ _RanIt partial_sort_copy(_ExPo&&, _FwdIt _First1, _FwdIt _Last1, _RanIt _First2,
 
 #ifdef __cpp_lib_concepts
 namespace ranges {
-    template <class _In, class _Out>
+    _EXPORT_STD template <class _In, class _Out>
     using partial_sort_copy_result = in_out_result<_In, _Out>;
 
     class _Partial_sort_copy_fn : private _Not_quite_object {
@@ -8620,12 +8627,12 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Partial_sort_copy_fn partial_sort_copy{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Partial_sort_copy_fn partial_sort_copy{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 #endif // _HAS_CXX17
 
-template <class _RanIt, class _Pr>
+_EXPORT_STD template <class _RanIt, class _Pr>
 _CONSTEXPR20 void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr _Pred) {
     // order Nth element
     _Adl_verify_range(_First, _Nth);
@@ -8652,20 +8659,20 @@ _CONSTEXPR20 void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr _Pre
     _Insertion_sort_unchecked(_UFirst, _ULast, _Pass_fn(_Pred)); // sort any remainder
 }
 
-template <class _RanIt>
+_EXPORT_STD template <class _RanIt>
 _CONSTEXPR20 void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last) { // order Nth element
     _STD nth_element(_First, _Nth, _Last, less<>{});
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 void nth_element(_ExPo&&, _RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr _Pred) noexcept /* terminates */ {
     // order Nth element
     // not parallelized at present, parallelism expected to be feasible in a future release
     _STD nth_element(_First, _Nth, _Last, _Pass_fn(_Pred));
 }
 
-template <class _ExPo, class _RanIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _RanIt, _Enable_if_execution_policy_t<_ExPo> = 0>
 void nth_element(_ExPo&&, _RanIt _First, _RanIt _Nth, _RanIt _Last) noexcept /* terminates */ {
     // order Nth element
     // not parallelized at present, parallelism expected to be feasible in a future release
@@ -8742,12 +8749,12 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Nth_element_fn nth_element{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Nth_element_fn nth_element{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 #endif // _HAS_CXX17
 
-template <class _InIt1, class _InIt2, class _Pr>
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Pr>
 _NODISCARD _CONSTEXPR20 bool includes(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred) {
     // test if every element in sorted [_First2, _Last2) is in sorted [_First1, _Last1)
     _Adl_verify_range(_First1, _Last1);
@@ -8771,14 +8778,14 @@ _NODISCARD _CONSTEXPR20 bool includes(_InIt1 _First1, _InIt1 _Last1, _InIt2 _Fir
     return _UFirst2 == _ULast2;
 }
 
-template <class _InIt1, class _InIt2>
+_EXPORT_STD template <class _InIt1, class _InIt2>
 _NODISCARD _CONSTEXPR20 bool includes(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2) {
     // test if every element in sorted [_First2, _Last2) is in sorted [_First1, _Last1)
     return _STD includes(_First1, _Last1, _First2, _Last2, less<>{});
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD bool includes(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred) noexcept
 /* terminates */ {
     // test if every element in sorted [_First2, _Last2) is in sorted [_First1, _Last1)
@@ -8788,7 +8795,7 @@ _NODISCARD bool includes(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _Firs
     return _STD includes(_First1, _Last1, _First2, _Last2, _Pass_fn(_Pred));
 }
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD bool includes(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2) noexcept
 /* terminates */ {
     // test if every element in sorted [_First2, _Last2) is in sorted [_First1, _Last1)
@@ -8866,12 +8873,12 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Includes_fn includes{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Includes_fn includes{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 #endif // _HAS_CXX17
 
-template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
+_EXPORT_STD template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
 _CONSTEXPR20 _OutIt set_union(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred) {
     // OR sets [_First1, _Last1) and [_First2, _Last2)
     _Adl_verify_range(_First1, _Last1);
@@ -8902,14 +8909,15 @@ _CONSTEXPR20 _OutIt set_union(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _In
     return _Dest;
 }
 
-template <class _InIt1, class _InIt2, class _OutIt>
+_EXPORT_STD template <class _InIt1, class _InIt2, class _OutIt>
 _CONSTEXPR20 _OutIt set_union(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest) {
     // OR sets [_First1, _Last1) and [_First2, _Last2)
     return _STD set_union(_First1, _Last1, _First2, _Last2, _Dest, less<>{});
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt3 set_union(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _FwdIt3 _Dest,
     _Pr _Pred) noexcept /* terminates */ {
     // OR sets [_First1, _Last1) and [_First2, _Last2)
@@ -8920,7 +8928,8 @@ _FwdIt3 set_union(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Fw
     return _STD set_union(_First1, _Last1, _First2, _Last2, _Dest, _Pass_fn(_Pred));
 }
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt3 set_union(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _FwdIt3 _Dest) noexcept
 /* terminates */ {
     // OR sets [_First1, _Last1) and [_First2, _Last2)
@@ -8933,7 +8942,7 @@ _FwdIt3 set_union(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Fw
 
 #ifdef __cpp_lib_concepts
 namespace ranges {
-    template <class _In1, class _In2, class _Out>
+    _EXPORT_STD template <class _In1, class _In2, class _Out>
     using set_union_result = in_in_out_result<_In1, _In2, _Out>;
 
     class _Set_union_fn : private _Not_quite_object {
@@ -9003,12 +9012,12 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Set_union_fn set_union{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Set_union_fn set_union{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 #endif // _HAS_CXX17
 
-template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
+_EXPORT_STD template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
 _CONSTEXPR20 _OutIt set_intersection(
     _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred) {
     // AND sets [_First1, _Last1) and [_First2, _Last2)
@@ -9038,18 +9047,20 @@ _CONSTEXPR20 _OutIt set_intersection(
     return _Dest;
 }
 
-template <class _InIt1, class _InIt2, class _OutIt>
+_EXPORT_STD template <class _InIt1, class _InIt2, class _OutIt>
 _CONSTEXPR20 _OutIt set_intersection(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest) {
     // AND sets [_First1, _Last1) and [_First2, _Last2)
     return _STD set_intersection(_First1, _Last1, _First2, _Last2, _Dest, less<>{});
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt3 set_intersection(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _FwdIt3 _Dest,
     _Pr _Pred) noexcept; // terminates
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt3 set_intersection(_ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2,
     _FwdIt3 _Dest) noexcept /* terminates */ {
     // AND sets [_First1, _Last1) and [_First2, _Last2)
@@ -9058,7 +9069,7 @@ _FwdIt3 set_intersection(_ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2
 
 #ifdef __cpp_lib_concepts
 namespace ranges {
-    template <class _In1, class _In2, class _Out>
+    _EXPORT_STD template <class _In1, class _In2, class _Out>
     using set_intersection_result = in_in_out_result<_In1, _In2, _Out>;
 
     class _Set_intersection_fn : private _Not_quite_object {
@@ -9134,12 +9145,12 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Set_intersection_fn set_intersection{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Set_intersection_fn set_intersection{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 #endif // _HAS_CXX17
 
-template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
+_EXPORT_STD template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
 _CONSTEXPR20 _OutIt set_difference(
     _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred) {
     // take set [_First2, _Last2) from [_First1, _Last1)
@@ -9170,18 +9181,20 @@ _CONSTEXPR20 _OutIt set_difference(
     return _Dest;
 }
 
-template <class _InIt1, class _InIt2, class _OutIt>
+_EXPORT_STD template <class _InIt1, class _InIt2, class _OutIt>
 _CONSTEXPR20 _OutIt set_difference(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest) {
     // take set [_First2, _Last2) from [_First1, _Last1)
     return _STD set_difference(_First1, _Last1, _First2, _Last2, _Dest, less<>{});
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt3 set_difference(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _FwdIt3 _Dest,
     _Pr _Pred) noexcept; // terminates
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt3 set_difference(_ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2,
     _FwdIt3 _Dest) noexcept /* terminates */ {
     // take set [_First2, _Last2) from [_First1, _Last1)
@@ -9190,7 +9203,7 @@ _FwdIt3 set_difference(_ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _
 
 #ifdef __cpp_lib_concepts
 namespace ranges {
-    template <class _In, class _Out>
+    _EXPORT_STD template <class _In, class _Out>
     using set_difference_result = in_out_result<_In, _Out>;
 
     class _Set_difference_fn : private _Not_quite_object {
@@ -9262,12 +9275,12 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Set_difference_fn set_difference{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Set_difference_fn set_difference{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 #endif // _HAS_CXX17
 
-template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
+_EXPORT_STD template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
 _CONSTEXPR20 _OutIt set_symmetric_difference(
     _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred) {
     // XOR sets [_First1, _Last1) and [_First2, _Last2)
@@ -9300,7 +9313,7 @@ _CONSTEXPR20 _OutIt set_symmetric_difference(
     return _Dest;
 }
 
-template <class _InIt1, class _InIt2, class _OutIt>
+_EXPORT_STD template <class _InIt1, class _InIt2, class _OutIt>
 _CONSTEXPR20 _OutIt set_symmetric_difference(
     _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest) {
     // XOR sets [_First1, _Last1) and [_First2, _Last2)
@@ -9308,7 +9321,8 @@ _CONSTEXPR20 _OutIt set_symmetric_difference(
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt3 set_symmetric_difference(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2,
     _FwdIt3 _Dest, _Pr _Pred) noexcept /* terminates */ {
     // XOR sets [_First1, _Last1) and [_First2, _Last2)
@@ -9319,7 +9333,8 @@ _FwdIt3 set_symmetric_difference(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdI
     return _STD set_symmetric_difference(_First1, _Last1, _First2, _Last2, _Dest, _Pass_fn(_Pred));
 }
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt3 set_symmetric_difference(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2,
     _FwdIt3 _Dest) noexcept /* terminates */ {
     // XOR sets [_First1, _Last1) and [_First2, _Last2)
@@ -9332,7 +9347,7 @@ _FwdIt3 set_symmetric_difference(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdI
 
 #ifdef __cpp_lib_concepts
 namespace ranges {
-    template <class _In1, class _In2, class _Out>
+    _EXPORT_STD template <class _In1, class _In2, class _Out>
     using set_symmetric_difference_result = in_in_out_result<_In1, _In2, _Out>;
 
     class _Set_symmetric_difference_fn : private _Not_quite_object {
@@ -9412,7 +9427,8 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Set_symmetric_difference_fn set_symmetric_difference{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Set_symmetric_difference_fn set_symmetric_difference{
+        _Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 #endif // _HAS_CXX17
@@ -9456,27 +9472,27 @@ constexpr _FwdIt _Max_element_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred)
     return _Found;
 }
 
-template <class _FwdIt, class _Pr>
+_EXPORT_STD template <class _FwdIt, class _Pr>
 _NODISCARD constexpr _FwdIt max_element(_FwdIt _First, _FwdIt _Last, _Pr _Pred) { // find largest element
     _Adl_verify_range(_First, _Last);
     _Seek_wrapped(_First, _Max_element_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Pass_fn(_Pred)));
     return _First;
 }
 
-template <class _FwdIt>
+_EXPORT_STD template <class _FwdIt>
 _NODISCARD constexpr _FwdIt max_element(_FwdIt _First, _FwdIt _Last) { // find largest element
     return _STD max_element(_First, _Last, less<>{});
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _FwdIt max_element(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
     // find largest element
     // not parallelized at present, parallelism expected to be feasible in a future release
     return _STD max_element(_First, _Last, _Pass_fn(_Pred));
 }
 
-template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _FwdIt max_element(_ExPo&&, _FwdIt _First, _FwdIt _Last) noexcept /* terminates */ {
     // find largest element
     // not parallelized at present, parallelism expected to be feasible in a future release
@@ -9544,7 +9560,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Max_element_fn max_element{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Max_element_fn max_element{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 #endif // _HAS_CXX17
@@ -9577,27 +9593,27 @@ constexpr _FwdIt _Min_element_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred)
     return _Found;
 }
 
-template <class _FwdIt, class _Pr>
+_EXPORT_STD template <class _FwdIt, class _Pr>
 _NODISCARD constexpr _FwdIt min_element(_FwdIt _First, _FwdIt _Last, _Pr _Pred) { // find smallest element
     _Adl_verify_range(_First, _Last);
     _Seek_wrapped(_First, _Min_element_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Pass_fn(_Pred)));
     return _First;
 }
 
-template <class _FwdIt>
+_EXPORT_STD template <class _FwdIt>
 _NODISCARD constexpr _FwdIt min_element(_FwdIt _First, _FwdIt _Last) { // find smallest element
     return _STD min_element(_First, _Last, less<>{});
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _FwdIt min_element(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
     // find smallest element
     // not parallelized at present, parallelism expected to be feasible in a future release
     return _STD min_element(_First, _Last, _Pass_fn(_Pred));
 }
 
-template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _FwdIt min_element(_ExPo&&, _FwdIt _First, _FwdIt _Last) noexcept /* terminates */ {
     // find smallest element
     // not parallelized at present, parallelism expected to be feasible in a future release
@@ -9665,7 +9681,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Min_element_fn min_element{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Min_element_fn min_element{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 #endif // _HAS_CXX17
@@ -9724,7 +9740,7 @@ constexpr pair<_FwdIt, _FwdIt> _Minmax_element_unchecked(_FwdIt _First, _FwdIt _
     return _Found;
 }
 
-template <class _FwdIt, class _Pr>
+_EXPORT_STD template <class _FwdIt, class _Pr>
 _NODISCARD constexpr pair<_FwdIt, _FwdIt> minmax_element(_FwdIt _First, _FwdIt _Last, _Pr _Pred) {
     // find smallest and largest elements
     _Adl_verify_range(_First, _Last);
@@ -9734,14 +9750,14 @@ _NODISCARD constexpr pair<_FwdIt, _FwdIt> minmax_element(_FwdIt _First, _FwdIt _
     return {_First, _Last};
 }
 
-template <class _FwdIt>
+_EXPORT_STD template <class _FwdIt>
 _NODISCARD constexpr pair<_FwdIt, _FwdIt> minmax_element(_FwdIt _First, _FwdIt _Last) {
     // find smallest and largest elements
     return _STD minmax_element(_First, _Last, less<>{});
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD pair<_FwdIt, _FwdIt> minmax_element(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept
 /* terminates */ {
     // find smallest and largest elements
@@ -9749,7 +9765,7 @@ _NODISCARD pair<_FwdIt, _FwdIt> minmax_element(_ExPo&&, _FwdIt _First, _FwdIt _L
     return _STD minmax_element(_First, _Last, _Pass_fn(_Pred));
 }
 
-template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD pair<_FwdIt, _FwdIt> minmax_element(_ExPo&&, _FwdIt _First, _FwdIt _Last) noexcept /* terminates */ {
     // find smallest and largest elements
     // not parallelized at present, parallelism expected to be feasible in a future release
@@ -9758,7 +9774,7 @@ _NODISCARD pair<_FwdIt, _FwdIt> minmax_element(_ExPo&&, _FwdIt _First, _FwdIt _L
 
 #ifdef __cpp_lib_concepts
 namespace ranges {
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     using minmax_element_result = min_max_result<_Ty>;
 
     template <class _It, class _Se, class _Pr, class _Pj>
@@ -9856,19 +9872,19 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Minmax_element_fn minmax_element{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Minmax_element_fn minmax_element{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 #endif // _HAS_CXX17
 
-template <class _Ty, class _Pr>
+_EXPORT_STD template <class _Ty, class _Pr>
 _NODISCARD constexpr _Ty(max)(initializer_list<_Ty> _Ilist, _Pr _Pred) {
     // return leftmost/largest
     const _Ty* _Res = _Max_element_unchecked(_Ilist.begin(), _Ilist.end(), _Pass_fn(_Pred));
     return *_Res;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD constexpr _Ty(max)(initializer_list<_Ty> _Ilist) {
     // return leftmost/largest
     return (_STD max)(_Ilist, less<>{});
@@ -9933,18 +9949,18 @@ namespace ranges {
         // clang-format on
     };
 
-    inline constexpr _Max_fn max{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Max_fn max{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _Ty, class _Pr>
+_EXPORT_STD template <class _Ty, class _Pr>
 _NODISCARD constexpr _Ty(min)(initializer_list<_Ty> _Ilist, _Pr _Pred) {
     // return leftmost/smallest
     const _Ty* _Res = _Min_element_unchecked(_Ilist.begin(), _Ilist.end(), _Pass_fn(_Pred));
     return *_Res;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD constexpr _Ty(min)(initializer_list<_Ty> _Ilist) {
     // return leftmost/smallest
     return (_STD min)(_Ilist, less<>{});
@@ -10003,11 +10019,11 @@ namespace ranges {
         // clang-format on
     };
 
-    inline constexpr _Min_fn min{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Min_fn min{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _Ty, class _Pr>
+_EXPORT_STD template <class _Ty, class _Pr>
 _NODISCARD constexpr pair<const _Ty&, const _Ty&> minmax(const _Ty& _Left, const _Ty& _Right, _Pr _Pred) noexcept(
     noexcept(_DEBUG_LT_PRED(_Pred, _Right, _Left))) /* strengthened */ {
     // return pair(leftmost/smaller, rightmost/larger) of _Left and _Right
@@ -10018,14 +10034,14 @@ _NODISCARD constexpr pair<const _Ty&, const _Ty&> minmax(const _Ty& _Left, const
     return {_Left, _Right};
 }
 
-template <class _Ty, class _Pr>
+_EXPORT_STD template <class _Ty, class _Pr>
 _NODISCARD constexpr pair<_Ty, _Ty> minmax(initializer_list<_Ty> _Ilist, _Pr _Pred) {
     // return {leftmost/smallest, rightmost/largest}
     pair<const _Ty*, const _Ty*> _Res = _Minmax_element_unchecked(_Ilist.begin(), _Ilist.end(), _Pass_fn(_Pred));
     return pair<_Ty, _Ty>(*_Res.first, *_Res.second);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD constexpr pair<const _Ty&, const _Ty&> minmax(const _Ty& _Left, const _Ty& _Right) noexcept(
     noexcept(_Right < _Left)) /* strengthened */ {
     // return pair(leftmost/smaller, rightmost/larger) of _Left and _Right
@@ -10037,7 +10053,7 @@ _NODISCARD constexpr pair<const _Ty&, const _Ty&> minmax(const _Ty& _Left, const
     return {_Left, _Right};
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD constexpr pair<_Ty, _Ty> minmax(initializer_list<_Ty> _Ilist) {
     // return {leftmost/smallest, rightmost/largest}
     return _STD minmax(_Ilist, less<>{});
@@ -10045,7 +10061,7 @@ _NODISCARD constexpr pair<_Ty, _Ty> minmax(initializer_list<_Ty> _Ilist) {
 
 #ifdef __cpp_lib_concepts
 namespace ranges {
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     using minmax_result = min_max_result<_Ty>;
 
     class _Minmax_fn : private _Not_quite_object {
@@ -10135,11 +10151,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Minmax_fn minmax{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Minmax_fn minmax{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _BidIt, class _Pr>
+_EXPORT_STD template <class _BidIt, class _Pr>
 _CONSTEXPR20 bool next_permutation(_BidIt _First, _BidIt _Last, _Pr _Pred) {
     // permute and test for pure ascending
     _Adl_verify_range(_First, _Last);
@@ -10170,7 +10186,7 @@ _CONSTEXPR20 bool next_permutation(_BidIt _First, _BidIt _Last, _Pr _Pred) {
     }
 }
 
-template <class _BidIt>
+_EXPORT_STD template <class _BidIt>
 _CONSTEXPR20 bool next_permutation(_BidIt _First, _BidIt _Last) {
     // permute and test for pure ascending
     return _STD next_permutation(_First, _Last, less<>{});
@@ -10178,7 +10194,7 @@ _CONSTEXPR20 bool next_permutation(_BidIt _First, _BidIt _Last) {
 
 #ifdef __cpp_lib_concepts
 namespace ranges {
-    template <class _In>
+    _EXPORT_STD template <class _In>
     using next_permutation_result = in_found_result<_In>;
 
     class _Next_permutation_fn : private _Not_quite_object {
@@ -10239,11 +10255,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Next_permutation_fn next_permutation{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Next_permutation_fn next_permutation{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _BidIt, class _Pr>
+_EXPORT_STD template <class _BidIt, class _Pr>
 _CONSTEXPR20 bool prev_permutation(_BidIt _First, _BidIt _Last, _Pr _Pred) {
     // reverse permute and test for pure descending
     _Adl_verify_range(_First, _Last);
@@ -10274,7 +10290,7 @@ _CONSTEXPR20 bool prev_permutation(_BidIt _First, _BidIt _Last, _Pr _Pred) {
     }
 }
 
-template <class _BidIt>
+_EXPORT_STD template <class _BidIt>
 _CONSTEXPR20 bool prev_permutation(_BidIt _First, _BidIt _Last) {
     // reverse permute and test for pure descending
     return _STD prev_permutation(_First, _Last, less<>{});
@@ -10282,7 +10298,7 @@ _CONSTEXPR20 bool prev_permutation(_BidIt _First, _BidIt _Last) {
 
 #ifdef __cpp_lib_concepts
 namespace ranges {
-    template <class _In>
+    _EXPORT_STD template <class _In>
     using prev_permutation_result = in_found_result<_In>;
 
     class _Prev_permutation_fn : private _Not_quite_object {
@@ -10343,11 +10359,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Prev_permutation_fn prev_permutation{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Prev_permutation_fn prev_permutation{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _FwdIt, class _Pr>
+_EXPORT_STD template <class _FwdIt, class _Pr>
 _NODISCARD _CONSTEXPR20 _FwdIt is_sorted_until(const _FwdIt _First, _FwdIt _Last, _Pr _Pred) {
     // find extent of range that is ordered by predicate
     _Adl_verify_range(_First, _Last);
@@ -10366,7 +10382,7 @@ _NODISCARD _CONSTEXPR20 _FwdIt is_sorted_until(const _FwdIt _First, _FwdIt _Last
     return _Last;
 }
 
-template <class _FwdIt, class _Pr>
+_EXPORT_STD template <class _FwdIt, class _Pr>
 _NODISCARD _CONSTEXPR20 bool is_sorted(_FwdIt _First, _FwdIt _Last, _Pr _Pred) {
     // test if range is ordered by predicate
     _Adl_verify_range(_First, _Last);
@@ -10375,34 +10391,34 @@ _NODISCARD _CONSTEXPR20 bool is_sorted(_FwdIt _First, _FwdIt _Last, _Pr _Pred) {
     return _STD is_sorted_until(_UFirst, _ULast, _Pass_fn(_Pred)) == _ULast;
 }
 
-template <class _FwdIt>
+_EXPORT_STD template <class _FwdIt>
 _NODISCARD _CONSTEXPR20 _FwdIt is_sorted_until(_FwdIt _First, _FwdIt _Last) {
     // find extent of range that is ordered by operator<
     return _STD is_sorted_until(_First, _Last, less<>{});
 }
 
-template <class _FwdIt>
+_EXPORT_STD template <class _FwdIt>
 _NODISCARD _CONSTEXPR20 bool is_sorted(_FwdIt _First, _FwdIt _Last) { // test if range is ordered by operator<
     return _STD is_sorted(_First, _Last, less<>{});
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _FwdIt is_sorted_until(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept; // terminates
 
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD bool is_sorted(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
     // test if range is ordered by predicate
     return _STD is_sorted_until(_STD forward<_ExPo>(_Exec), _First, _Last, _Pass_fn(_Pred)) == _Last;
 }
 
-template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _FwdIt is_sorted_until(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last) noexcept /* terminates */ {
     // find extent of range that is ordered by operator<
     return _STD is_sorted_until(_STD forward<_ExPo>(_Exec), _First, _Last, less{});
 }
 
-template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD bool is_sorted(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last) noexcept /* terminates */ {
     // test if range is ordered by operator<
     return _STD is_sorted(_STD forward<_ExPo>(_Exec), _First, _Last, less{});
@@ -10433,7 +10449,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Is_sorted_fn is_sorted{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Is_sorted_fn is_sorted{_Not_quite_object::_Construct_tag{}};
 
     class _Is_sorted_until_fn : private _Not_quite_object {
     public:
@@ -10460,11 +10476,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Is_sorted_until_fn is_sorted_until{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Is_sorted_until_fn is_sorted_until{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _Ty, class _Pr>
+_EXPORT_STD template <class _Ty, class _Pr>
 _NODISCARD constexpr const _Ty& clamp(const _Ty& _Val, const _Ty& _Min_val, const _Ty& _Max_val, _Pr _Pred) {
     // returns _Val constrained to [_Min_val, _Max_val]
 #if _ITERATOR_DEBUG_LEVEL == 2
@@ -10492,7 +10508,7 @@ _NODISCARD constexpr const _Ty& clamp(const _Ty& _Val, const _Ty& _Min_val, cons
     }
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD constexpr const _Ty& clamp(const _Ty& _Val, const _Ty& _Min_val, const _Ty& _Max_val) {
     // returns _Val constrained to [_Min_val, _Max_val]
     return _STD clamp(_Val, _Min_val, _Max_val, less{});
@@ -10526,7 +10542,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Clamp_fn clamp{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Clamp_fn clamp{_Not_quite_object::_Construct_tag{}};
 
     class _Lexicographical_compare_fn : private _Not_quite_object {
     public:
@@ -10604,7 +10620,8 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Lexicographical_compare_fn lexicographical_compare{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Lexicographical_compare_fn lexicographical_compare{
+        _Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 #endif // _HAS_CXX17
diff --git a/stl/inc/any b/stl/inc/any
index 76f3746bbb..7bcf69f935 100644
--- a/stl/inc/any
+++ b/stl/inc/any
@@ -31,7 +31,7 @@ _STL_DISABLE_CLANG_WARNINGS
 
 _STD_BEGIN
 
-class bad_any_cast : public bad_cast { // thrown by failed any_cast
+_EXPORT_STD class bad_any_cast : public bad_cast { // thrown by failed any_cast
 public:
     _NODISCARD const char* __CLR_OR_THIS_CALL what() const noexcept override {
         return "Bad any_cast";
@@ -107,7 +107,7 @@ template <class _Ty>
 inline constexpr _Any_small_RTTI _Any_small_RTTI_obj = {
     &_Any_small_RTTI::_Destroy_impl<_Ty>, &_Any_small_RTTI::_Copy_impl<_Ty>, &_Any_small_RTTI::_Move_impl<_Ty>};
 
-class any { // storage for any (CopyConstructible) type
+_EXPORT_STD class any { // storage for any (CopyConstructible) type
 public:
     // Construction and destruction [any.cons]
     constexpr any() noexcept {}
@@ -353,23 +353,23 @@ private:
 };
 
 // Non-member functions [any.nonmembers]
-inline void swap(any& _Left, any& _Right) noexcept {
+_EXPORT_STD inline void swap(any& _Left, any& _Right) noexcept {
     _Left.swap(_Right);
 }
 
-template <class _ValueType, class... _Types,
+_EXPORT_STD template <class _ValueType, class... _Types,
     enable_if_t<is_constructible_v<any, in_place_type_t<_ValueType>, _Types...>, int> = 0>
 _NODISCARD any make_any(_Types&&... _Args) { // construct an any containing a _ValueType initialized with _Args...
     return any{in_place_type<_ValueType>, _STD forward<_Types>(_Args)...};
 }
-template <class _ValueType, class _Elem, class... _Types,
+_EXPORT_STD template <class _ValueType, class _Elem, class... _Types,
     enable_if_t<is_constructible_v<any, in_place_type_t<_ValueType>, initializer_list<_Elem>&, _Types...>, int> = 0>
 _NODISCARD any make_any(initializer_list<_Elem> _Ilist, _Types&&... _Args) {
     // construct an any containing a _ValueType initialized with _Ilist and _Args...
     return any{in_place_type<_ValueType>, _Ilist, _STD forward<_Types>(_Args)...};
 }
 
-template <class _ValueType>
+_EXPORT_STD template <class _ValueType>
 _NODISCARD const _ValueType* any_cast(const any* const _Any) noexcept {
     // retrieve a pointer to the _ValueType contained in _Any, or null
     static_assert(!is_void_v<_ValueType>, "std::any cannot contain void.");
@@ -384,7 +384,7 @@ _NODISCARD const _ValueType* any_cast(const any* const _Any) noexcept {
         return _Any->_Cast<_Remove_cvref_t<_ValueType>>();
     }
 }
-template <class _ValueType>
+_EXPORT_STD template <class _ValueType>
 _NODISCARD _ValueType* any_cast(any* const _Any) noexcept {
     // retrieve a pointer to the _ValueType contained in _Any, or null
     static_assert(!is_void_v<_ValueType>, "std::any cannot contain void.");
@@ -400,7 +400,7 @@ _NODISCARD _ValueType* any_cast(any* const _Any) noexcept {
     }
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD remove_cv_t<_Ty> any_cast(const any& _Any) {
     static_assert(is_constructible_v<remove_cv_t<_Ty>, const _Remove_cvref_t<_Ty>&>,
         "any_cast<T>(const any&) requires remove_cv_t<T> to be constructible from "
@@ -413,7 +413,7 @@ _NODISCARD remove_cv_t<_Ty> any_cast(const any& _Any) {
 
     return static_cast<remove_cv_t<_Ty>>(*_Ptr);
 }
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD remove_cv_t<_Ty> any_cast(any& _Any) {
     static_assert(is_constructible_v<remove_cv_t<_Ty>, _Remove_cvref_t<_Ty>&>,
         "any_cast<T>(any&) requires remove_cv_t<T> to be constructible from remove_cv_t<remove_reference_t<T>>&");
@@ -425,7 +425,7 @@ _NODISCARD remove_cv_t<_Ty> any_cast(any& _Any) {
 
     return static_cast<remove_cv_t<_Ty>>(*_Ptr);
 }
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD remove_cv_t<_Ty> any_cast(any&& _Any) {
     static_assert(is_constructible_v<remove_cv_t<_Ty>, _Remove_cvref_t<_Ty>>,
         "any_cast<T>(any&&) requires remove_cv_t<T> to be constructible from remove_cv_t<remove_reference_t<T>>");
diff --git a/stl/inc/array b/stl/inc/array
index 2f46406147..4c384d1efc 100644
--- a/stl/inc/array
+++ b/stl/inc/array
@@ -403,7 +403,7 @@ struct pointer_traits<_Array_iterator<_Ty, _Size>> {
 };
 #endif // _HAS_CXX20
 
-template <class _Ty, size_t _Size>
+_EXPORT_STD template <class _Ty, size_t _Size>
 class array { // fixed size array of values
 public:
     using value_type      = _Ty;
@@ -762,12 +762,12 @@ public:
         _Elems[1];
 };
 
-template <class _Ty, size_t _Size, enable_if_t<_Size == 0 || _Is_swappable<_Ty>::value, int> = 0>
+_EXPORT_STD template <class _Ty, size_t _Size, enable_if_t<_Size == 0 || _Is_swappable<_Ty>::value, int> = 0>
 _CONSTEXPR20 void swap(array<_Ty, _Size>& _Left, array<_Ty, _Size>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
     _Left.swap(_Right);
 }
 
-template <class _Ty, size_t _Size>
+_EXPORT_STD template <class _Ty, size_t _Size>
 _NODISCARD _CONSTEXPR20 bool operator==(const array<_Ty, _Size>& _Left, const array<_Ty, _Size>& _Right) {
 #ifdef __EDG__ // TRANSITION, VSO-1161663
     return _STD equal(_Left.begin(), _Left.end(), _Right.begin());
@@ -784,7 +784,7 @@ _NODISCARD bool operator!=(const array<_Ty, _Size>& _Left, const array<_Ty, _Siz
 #endif // !_HAS_CXX20
 
 #ifdef __cpp_lib_concepts
-template <class _Ty, size_t _Size>
+_EXPORT_STD template <class _Ty, size_t _Size>
 _NODISCARD constexpr _Synth_three_way_result<_Ty> operator<=>(
     const array<_Ty, _Size>& _Left, const array<_Ty, _Size>& _Right) {
 #ifdef __EDG__ // TRANSITION, VSO-1161663
@@ -835,7 +835,7 @@ _NODISCARD constexpr array<remove_cv_t<_Ty>, _Size> _To_array_rvalue_impl(
     return {{_STD move(_Array[_Idx])...}};
 }
 
-template <class _Ty, size_t _Size>
+_EXPORT_STD template <class _Ty, size_t _Size>
 _NODISCARD constexpr array<remove_cv_t<_Ty>, _Size> to_array(_Ty (&_Array)[_Size]) {
     static_assert(!is_array_v<_Ty>, "N4830 [array.creation]/1: "
                                     "to_array does not accept multidimensional arrays.");
@@ -844,7 +844,7 @@ _NODISCARD constexpr array<remove_cv_t<_Ty>, _Size> to_array(_Ty (&_Array)[_Size
     return _To_array_lvalue_impl(_Array, make_index_sequence<_Size>{});
 }
 
-template <class _Ty, size_t _Size>
+_EXPORT_STD template <class _Ty, size_t _Size>
 _NODISCARD constexpr array<remove_cv_t<_Ty>, _Size> to_array(_Ty (&&_Array)[_Size]) {
     static_assert(!is_array_v<_Ty>, "N4830 [array.creation]/4: "
                                     "to_array does not accept multidimensional arrays.");
@@ -854,25 +854,25 @@ _NODISCARD constexpr array<remove_cv_t<_Ty>, _Size> to_array(_Ty (&&_Array)[_Siz
 }
 #endif // _HAS_CXX20
 
-template <size_t _Idx, class _Ty, size_t _Size>
+_EXPORT_STD template <size_t _Idx, class _Ty, size_t _Size>
 _NODISCARD constexpr _Ty& get(array<_Ty, _Size>& _Arr) noexcept {
     static_assert(_Idx < _Size, "array index out of bounds");
     return _Arr._Elems[_Idx];
 }
 
-template <size_t _Idx, class _Ty, size_t _Size>
+_EXPORT_STD template <size_t _Idx, class _Ty, size_t _Size>
 _NODISCARD constexpr const _Ty& get(const array<_Ty, _Size>& _Arr) noexcept {
     static_assert(_Idx < _Size, "array index out of bounds");
     return _Arr._Elems[_Idx];
 }
 
-template <size_t _Idx, class _Ty, size_t _Size>
+_EXPORT_STD template <size_t _Idx, class _Ty, size_t _Size>
 _NODISCARD constexpr _Ty&& get(array<_Ty, _Size>&& _Arr) noexcept {
     static_assert(_Idx < _Size, "array index out of bounds");
     return _STD move(_Arr._Elems[_Idx]);
 }
 
-template <size_t _Idx, class _Ty, size_t _Size>
+_EXPORT_STD template <size_t _Idx, class _Ty, size_t _Size>
 _NODISCARD constexpr const _Ty&& get(const array<_Ty, _Size>&& _Arr) noexcept {
     static_assert(_Idx < _Size, "array index out of bounds");
     return _STD move(_Arr._Elems[_Idx]);
diff --git a/stl/inc/atomic b/stl/inc/atomic
index 15b040d415..b58fe10ae1 100644
--- a/stl/inc/atomic
+++ b/stl/inc/atomic
@@ -274,17 +274,17 @@ inline constexpr bool _Might_have_non_value_bits =
     !has_unique_object_representations_v<_Ty> && !is_floating_point_v<_Ty>;
 #endif // _CMPXCHG_MASK_OUT_PADDING_BITS
 
-extern "C" inline void atomic_thread_fence(const memory_order _Order) noexcept {
+_EXPORT_STD extern "C" inline void atomic_thread_fence(const memory_order _Order) noexcept {
     ::_Atomic_thread_fence(static_cast<unsigned int>(_Order));
 }
 
-extern "C" inline void atomic_signal_fence(const memory_order _Order) noexcept {
+_EXPORT_STD extern "C" inline void atomic_signal_fence(const memory_order _Order) noexcept {
     if (_Order != memory_order_relaxed) {
         _Compiler_barrier();
     }
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty kill_dependency(_Ty _Arg) noexcept { // "magic" template that kills dependency ordering when called
     return _Arg;
 }
@@ -2084,7 +2084,7 @@ template <class _TVal, class _Ty = _TVal>
 using _Choose_atomic_base_t = _Choose_atomic_base2_t<_TVal, _Ty>;
 #endif // _HAS_CXX20
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct atomic : _Choose_atomic_base_t<_Ty> { // atomic value
 private:
     using _Base = _Choose_atomic_base_t<_Ty>;
@@ -2263,7 +2263,7 @@ atomic(_Ty) -> atomic<_Ty>;
 #endif // _HAS_CXX17
 
 #if _HAS_CXX20
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct atomic_ref : _Choose_atomic_base_t<_Ty, _Ty&> { // atomic reference
 private:
     using _Base = _Choose_atomic_base_t<_Ty, _Ty&>;
@@ -2372,382 +2372,382 @@ private:
 };
 #endif // _HAS_CXX20
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD bool atomic_is_lock_free(const volatile atomic<_Ty>* _Mem) noexcept {
     return _Mem->is_lock_free();
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD bool atomic_is_lock_free(const atomic<_Ty>* _Mem) noexcept {
     return _Mem->is_lock_free();
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 void atomic_store(volatile atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value) noexcept {
     static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
     _Mem->store(_Value);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 void atomic_store(atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value) noexcept {
     _Mem->store(_Value);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 void atomic_store_explicit(
     volatile atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value, const memory_order _Order) noexcept {
     static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
     _Mem->store(_Value, _Order);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 void atomic_store_explicit(atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value, const memory_order _Order) noexcept {
     _Mem->store(_Value, _Order);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _CXX20_DEPRECATE_ATOMIC_INIT void atomic_init(
     volatile atomic<_Ty>* const _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
     static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
     _STD atomic_store_explicit(_Mem, _Value, memory_order_relaxed);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _CXX20_DEPRECATE_ATOMIC_INIT void atomic_init(
     atomic<_Ty>* const _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
     _STD atomic_store_explicit(_Mem, _Value, memory_order_relaxed);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Ty atomic_load(const volatile atomic<_Ty>* const _Mem) noexcept {
     static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
     return _Mem->load();
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Ty atomic_load(const atomic<_Ty>* const _Mem) noexcept {
     return _Mem->load();
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Ty atomic_load_explicit(const volatile atomic<_Ty>* const _Mem, const memory_order _Order) noexcept {
     static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
     return _Mem->load(_Order);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Ty atomic_load_explicit(const atomic<_Ty>* const _Mem, const memory_order _Order) noexcept {
     return _Mem->load(_Order);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty atomic_exchange(volatile atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value) noexcept {
     static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
     return _Mem->exchange(_Value);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty atomic_exchange(atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value) noexcept {
     return _Mem->exchange(_Value);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty atomic_exchange_explicit(
     volatile atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value, const memory_order _Order) noexcept {
     static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
     return _Mem->exchange(_Value, _Order);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty atomic_exchange_explicit(
     atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value, const memory_order _Order) noexcept {
     return _Mem->exchange(_Value, _Order);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 bool atomic_compare_exchange_strong(
     volatile atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected, const _Identity_t<_Ty> _Desired) noexcept {
     static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
     return _Mem->compare_exchange_strong(*_Expected, _Desired);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 bool atomic_compare_exchange_strong(
     atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected, const _Identity_t<_Ty> _Desired) noexcept {
     return _Mem->compare_exchange_strong(*_Expected, _Desired);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 bool atomic_compare_exchange_strong_explicit(volatile atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected,
     const _Identity_t<_Ty> _Desired, const memory_order _Success, const memory_order _Failure) noexcept {
     static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
     return _Mem->compare_exchange_strong(*_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 bool atomic_compare_exchange_strong_explicit(atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected,
     const _Identity_t<_Ty> _Desired, const memory_order _Success, const memory_order _Failure) noexcept {
     return _Mem->compare_exchange_strong(*_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 bool atomic_compare_exchange_weak(
     volatile atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected, const _Identity_t<_Ty> _Desired) noexcept {
     static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
     return _Mem->compare_exchange_strong(*_Expected, _Desired);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 bool atomic_compare_exchange_weak(
     atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected, const _Identity_t<_Ty> _Desired) noexcept {
     return _Mem->compare_exchange_strong(*_Expected, _Desired);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 bool atomic_compare_exchange_weak_explicit(volatile atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected,
     const _Identity_t<_Ty> _Desired, const memory_order _Success, const memory_order _Failure) noexcept {
     static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
     return _Mem->compare_exchange_strong(*_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 bool atomic_compare_exchange_weak_explicit(atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected,
     const _Identity_t<_Ty> _Desired, const memory_order _Success, const memory_order _Failure) noexcept {
     return _Mem->compare_exchange_strong(*_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty atomic_fetch_add(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value) noexcept {
     static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
     return _Mem->fetch_add(_Value);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty atomic_fetch_add(atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value) noexcept {
     return _Mem->fetch_add(_Value);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty atomic_fetch_add_explicit(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value,
     const memory_order _Order) noexcept {
     static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
     return _Mem->fetch_add(_Value, _Order);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty atomic_fetch_add_explicit(
     atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value, const memory_order _Order) noexcept {
     return _Mem->fetch_add(_Value, _Order);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty atomic_fetch_sub(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value) noexcept {
     static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
     return _Mem->fetch_sub(_Value);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty atomic_fetch_sub(atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value) noexcept {
     return _Mem->fetch_sub(_Value);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty atomic_fetch_sub_explicit(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value,
     const memory_order _Order) noexcept {
     static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
     return _Mem->fetch_sub(_Value, _Order);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty atomic_fetch_sub_explicit(
     atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value, const memory_order _Order) noexcept {
     return _Mem->fetch_sub(_Value, _Order);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty atomic_fetch_and(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
     static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
     return _Mem->fetch_and(_Value);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty atomic_fetch_and(atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
     return _Mem->fetch_and(_Value);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty atomic_fetch_and_explicit(
     volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value, const memory_order _Order) noexcept {
     static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
     return _Mem->fetch_and(_Value, _Order);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty atomic_fetch_and_explicit(
     atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value, const memory_order _Order) noexcept {
     return _Mem->fetch_and(_Value, _Order);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty atomic_fetch_or(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
     static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
     return _Mem->fetch_or(_Value);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty atomic_fetch_or(atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
     return _Mem->fetch_or(_Value);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty atomic_fetch_or_explicit(
     volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value, const memory_order _Order) noexcept {
     static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
     return _Mem->fetch_or(_Value, _Order);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty atomic_fetch_or_explicit(
     atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value, const memory_order _Order) noexcept {
     return _Mem->fetch_or(_Value, _Order);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty atomic_fetch_xor(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
     static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
     return _Mem->fetch_xor(_Value);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty atomic_fetch_xor(atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
     return _Mem->fetch_xor(_Value);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty atomic_fetch_xor_explicit(
     volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value, const memory_order _Order) noexcept {
     static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
     return _Mem->fetch_xor(_Value, _Order);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty atomic_fetch_xor_explicit(
     atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value, const memory_order _Order) noexcept {
     return _Mem->fetch_xor(_Value, _Order);
 }
 
 #if _HAS_CXX20
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 void atomic_wait(const volatile atomic<_Ty>* const _Mem, const typename atomic<_Ty>::value_type _Expected) noexcept
 /* strengthened */ {
     _Mem->wait(_Expected);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 void atomic_wait(const atomic<_Ty>* const _Mem, const typename atomic<_Ty>::value_type _Expected) noexcept
 /* strengthened */ {
     _Mem->wait(_Expected);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 void atomic_wait_explicit(const volatile atomic<_Ty>* const _Mem, const typename atomic<_Ty>::value_type _Expected,
     const memory_order _Order) noexcept /* strengthened */ {
     _Mem->wait(_Expected, _Order);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 void atomic_wait_explicit(const atomic<_Ty>* const _Mem, const typename atomic<_Ty>::value_type _Expected,
     const memory_order _Order) noexcept /* strengthened */ {
     _Mem->wait(_Expected, _Order);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 void atomic_notify_one(volatile atomic<_Ty>* const _Mem) noexcept /* strengthened */ {
     _Mem->notify_one();
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 void atomic_notify_one(atomic<_Ty>* const _Mem) noexcept /* strengthened */ {
     _Mem->notify_one();
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 void atomic_notify_all(volatile atomic<_Ty>* const _Mem) noexcept /* strengthened */ {
     _Mem->notify_all();
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 void atomic_notify_all(atomic<_Ty>* const _Mem) noexcept /* strengthened */ {
     _Mem->notify_all();
 }
 #endif // _HAS_CXX20
 
-using atomic_bool = atomic<bool>;
+_EXPORT_STD using atomic_bool = atomic<bool>;
 
-using atomic_char   = atomic<char>;
-using atomic_schar  = atomic<signed char>;
-using atomic_uchar  = atomic<unsigned char>;
-using atomic_short  = atomic<short>;
-using atomic_ushort = atomic<unsigned short>;
-using atomic_int    = atomic<int>;
-using atomic_uint   = atomic<unsigned int>;
-using atomic_long   = atomic<long>;
-using atomic_ulong  = atomic<unsigned long>;
-using atomic_llong  = atomic<long long>;
-using atomic_ullong = atomic<unsigned long long>;
+_EXPORT_STD using atomic_char   = atomic<char>;
+_EXPORT_STD using atomic_schar  = atomic<signed char>;
+_EXPORT_STD using atomic_uchar  = atomic<unsigned char>;
+_EXPORT_STD using atomic_short  = atomic<short>;
+_EXPORT_STD using atomic_ushort = atomic<unsigned short>;
+_EXPORT_STD using atomic_int    = atomic<int>;
+_EXPORT_STD using atomic_uint   = atomic<unsigned int>;
+_EXPORT_STD using atomic_long   = atomic<long>;
+_EXPORT_STD using atomic_ulong  = atomic<unsigned long>;
+_EXPORT_STD using atomic_llong  = atomic<long long>;
+_EXPORT_STD using atomic_ullong = atomic<unsigned long long>;
 
 #ifdef __cpp_lib_char8_t
-using atomic_char8_t = atomic<char8_t>;
+_EXPORT_STD using atomic_char8_t = atomic<char8_t>;
 #endif // __cpp_lib_char8_t
-using atomic_char16_t = atomic<char16_t>;
-using atomic_char32_t = atomic<char32_t>;
-using atomic_wchar_t  = atomic<wchar_t>;
-
-using atomic_int8_t   = atomic<int8_t>;
-using atomic_uint8_t  = atomic<uint8_t>;
-using atomic_int16_t  = atomic<int16_t>;
-using atomic_uint16_t = atomic<uint16_t>;
-using atomic_int32_t  = atomic<int32_t>;
-using atomic_uint32_t = atomic<uint32_t>;
-using atomic_int64_t  = atomic<int64_t>;
-using atomic_uint64_t = atomic<uint64_t>;
-
-using atomic_int_least8_t   = atomic<int_least8_t>;
-using atomic_uint_least8_t  = atomic<uint_least8_t>;
-using atomic_int_least16_t  = atomic<int_least16_t>;
-using atomic_uint_least16_t = atomic<uint_least16_t>;
-using atomic_int_least32_t  = atomic<int_least32_t>;
-using atomic_uint_least32_t = atomic<uint_least32_t>;
-using atomic_int_least64_t  = atomic<int_least64_t>;
-using atomic_uint_least64_t = atomic<uint_least64_t>;
-
-using atomic_int_fast8_t   = atomic<int_fast8_t>;
-using atomic_uint_fast8_t  = atomic<uint_fast8_t>;
-using atomic_int_fast16_t  = atomic<int_fast16_t>;
-using atomic_uint_fast16_t = atomic<uint_fast16_t>;
-using atomic_int_fast32_t  = atomic<int_fast32_t>;
-using atomic_uint_fast32_t = atomic<uint_fast32_t>;
-using atomic_int_fast64_t  = atomic<int_fast64_t>;
-using atomic_uint_fast64_t = atomic<uint_fast64_t>;
-
-using atomic_intptr_t  = atomic<intptr_t>;
-using atomic_uintptr_t = atomic<uintptr_t>;
-using atomic_size_t    = atomic<size_t>;
-using atomic_ptrdiff_t = atomic<ptrdiff_t>;
-using atomic_intmax_t  = atomic<intmax_t>;
-using atomic_uintmax_t = atomic<uintmax_t>;
+_EXPORT_STD using atomic_char16_t = atomic<char16_t>;
+_EXPORT_STD using atomic_char32_t = atomic<char32_t>;
+_EXPORT_STD using atomic_wchar_t  = atomic<wchar_t>;
+
+_EXPORT_STD using atomic_int8_t   = atomic<int8_t>;
+_EXPORT_STD using atomic_uint8_t  = atomic<uint8_t>;
+_EXPORT_STD using atomic_int16_t  = atomic<int16_t>;
+_EXPORT_STD using atomic_uint16_t = atomic<uint16_t>;
+_EXPORT_STD using atomic_int32_t  = atomic<int32_t>;
+_EXPORT_STD using atomic_uint32_t = atomic<uint32_t>;
+_EXPORT_STD using atomic_int64_t  = atomic<int64_t>;
+_EXPORT_STD using atomic_uint64_t = atomic<uint64_t>;
+
+_EXPORT_STD using atomic_int_least8_t   = atomic<int_least8_t>;
+_EXPORT_STD using atomic_uint_least8_t  = atomic<uint_least8_t>;
+_EXPORT_STD using atomic_int_least16_t  = atomic<int_least16_t>;
+_EXPORT_STD using atomic_uint_least16_t = atomic<uint_least16_t>;
+_EXPORT_STD using atomic_int_least32_t  = atomic<int_least32_t>;
+_EXPORT_STD using atomic_uint_least32_t = atomic<uint_least32_t>;
+_EXPORT_STD using atomic_int_least64_t  = atomic<int_least64_t>;
+_EXPORT_STD using atomic_uint_least64_t = atomic<uint_least64_t>;
+
+_EXPORT_STD using atomic_int_fast8_t   = atomic<int_fast8_t>;
+_EXPORT_STD using atomic_uint_fast8_t  = atomic<uint_fast8_t>;
+_EXPORT_STD using atomic_int_fast16_t  = atomic<int_fast16_t>;
+_EXPORT_STD using atomic_uint_fast16_t = atomic<uint_fast16_t>;
+_EXPORT_STD using atomic_int_fast32_t  = atomic<int_fast32_t>;
+_EXPORT_STD using atomic_uint_fast32_t = atomic<uint_fast32_t>;
+_EXPORT_STD using atomic_int_fast64_t  = atomic<int_fast64_t>;
+_EXPORT_STD using atomic_uint_fast64_t = atomic<uint_fast64_t>;
+
+_EXPORT_STD using atomic_intptr_t  = atomic<intptr_t>;
+_EXPORT_STD using atomic_uintptr_t = atomic<uintptr_t>;
+_EXPORT_STD using atomic_size_t    = atomic<size_t>;
+_EXPORT_STD using atomic_ptrdiff_t = atomic<ptrdiff_t>;
+_EXPORT_STD using atomic_intmax_t  = atomic<intmax_t>;
+_EXPORT_STD using atomic_uintmax_t = atomic<uintmax_t>;
 
 #if _HAS_CXX20
 // Though there are CMPXCHG8B and CMPXCHG16B,
 // the largest atomics with a full set of efficient operations are pointer-sized.
-using atomic_signed_lock_free   = atomic_intptr_t;
-using atomic_unsigned_lock_free = atomic_uintptr_t;
+_EXPORT_STD using atomic_signed_lock_free   = atomic_intptr_t;
+_EXPORT_STD using atomic_unsigned_lock_free = atomic_uintptr_t;
 #endif // _HAS_CXX20
 
 #define ATOMIC_FLAG_INIT \
     {}
 
-struct atomic_flag { // flag with test-and-set semantics
+_EXPORT_STD struct atomic_flag { // flag with test-and-set semantics
 #if _HAS_CXX20
     _NODISCARD bool test(const memory_order _Order = memory_order_seq_cst) const noexcept {
         return _Storage.load(_Order) != 0;
@@ -2811,88 +2811,92 @@ struct atomic_flag { // flag with test-and-set semantics
 
 
 #if _HAS_CXX20
-_NODISCARD inline bool atomic_flag_test(const volatile atomic_flag* const _Flag) noexcept {
+_EXPORT_STD _NODISCARD inline bool atomic_flag_test(const volatile atomic_flag* const _Flag) noexcept {
     return _Flag->test();
 }
 
-_NODISCARD inline bool atomic_flag_test(const atomic_flag* const _Flag) noexcept {
+_EXPORT_STD _NODISCARD inline bool atomic_flag_test(const atomic_flag* const _Flag) noexcept {
     return _Flag->test();
 }
 
-_NODISCARD inline bool atomic_flag_test_explicit(
+_EXPORT_STD _NODISCARD inline bool atomic_flag_test_explicit(
     const volatile atomic_flag* const _Flag, const memory_order _Order) noexcept {
     return _Flag->test(_Order);
 }
 
-_NODISCARD inline bool atomic_flag_test_explicit(const atomic_flag* const _Flag, const memory_order _Order) noexcept {
+_EXPORT_STD _NODISCARD inline bool atomic_flag_test_explicit(
+    const atomic_flag* const _Flag, const memory_order _Order) noexcept {
     return _Flag->test(_Order);
 }
 #endif // _HAS_CXX20
 
-inline bool atomic_flag_test_and_set(atomic_flag* const _Flag) noexcept {
+_EXPORT_STD inline bool atomic_flag_test_and_set(atomic_flag* const _Flag) noexcept {
     return _Flag->test_and_set();
 }
 
-inline bool atomic_flag_test_and_set(volatile atomic_flag* const _Flag) noexcept {
+_EXPORT_STD inline bool atomic_flag_test_and_set(volatile atomic_flag* const _Flag) noexcept {
     return _Flag->test_and_set();
 }
 
-inline bool atomic_flag_test_and_set_explicit(atomic_flag* const _Flag, const memory_order _Order) noexcept {
+_EXPORT_STD inline bool atomic_flag_test_and_set_explicit(
+    atomic_flag* const _Flag, const memory_order _Order) noexcept {
     return _Flag->test_and_set(_Order);
 }
 
-inline bool atomic_flag_test_and_set_explicit(volatile atomic_flag* const _Flag, const memory_order _Order) noexcept {
+_EXPORT_STD inline bool atomic_flag_test_and_set_explicit(
+    volatile atomic_flag* const _Flag, const memory_order _Order) noexcept {
     return _Flag->test_and_set(_Order);
 }
 
-inline void atomic_flag_clear(atomic_flag* const _Flag) noexcept {
+_EXPORT_STD inline void atomic_flag_clear(atomic_flag* const _Flag) noexcept {
     _Flag->clear();
 }
 
-inline void atomic_flag_clear(volatile atomic_flag* const _Flag) noexcept {
+_EXPORT_STD inline void atomic_flag_clear(volatile atomic_flag* const _Flag) noexcept {
     _Flag->clear();
 }
 
-inline void atomic_flag_clear_explicit(atomic_flag* const _Flag, const memory_order _Order) noexcept {
+_EXPORT_STD inline void atomic_flag_clear_explicit(atomic_flag* const _Flag, const memory_order _Order) noexcept {
     _Flag->clear(_Order);
 }
 
-inline void atomic_flag_clear_explicit(volatile atomic_flag* const _Flag, const memory_order _Order) noexcept {
+_EXPORT_STD inline void atomic_flag_clear_explicit(
+    volatile atomic_flag* const _Flag, const memory_order _Order) noexcept {
     _Flag->clear(_Order);
 }
 
 #if _HAS_CXX20
-inline void atomic_flag_wait(const volatile atomic_flag* const _Flag, const bool _Expected) noexcept {
+_EXPORT_STD inline void atomic_flag_wait(const volatile atomic_flag* const _Flag, const bool _Expected) noexcept {
     return _Flag->wait(_Expected);
 }
 
-inline void atomic_flag_wait(const atomic_flag* const _Flag, const bool _Expected) noexcept {
+_EXPORT_STD inline void atomic_flag_wait(const atomic_flag* const _Flag, const bool _Expected) noexcept {
     return _Flag->wait(_Expected);
 }
 
-inline void atomic_flag_wait_explicit(
+_EXPORT_STD inline void atomic_flag_wait_explicit(
     const volatile atomic_flag* const _Flag, const bool _Expected, const memory_order _Order) noexcept {
     return _Flag->wait(_Expected, _Order);
 }
 
-inline void atomic_flag_wait_explicit(
+_EXPORT_STD inline void atomic_flag_wait_explicit(
     const atomic_flag* const _Flag, const bool _Expected, const memory_order _Order) noexcept {
     return _Flag->wait(_Expected, _Order);
 }
 
-inline void atomic_flag_notify_one(volatile atomic_flag* const _Flag) noexcept {
+_EXPORT_STD inline void atomic_flag_notify_one(volatile atomic_flag* const _Flag) noexcept {
     return _Flag->notify_one();
 }
 
-inline void atomic_flag_notify_one(atomic_flag* const _Flag) noexcept {
+_EXPORT_STD inline void atomic_flag_notify_one(atomic_flag* const _Flag) noexcept {
     return _Flag->notify_one();
 }
 
-inline void atomic_flag_notify_all(volatile atomic_flag* const _Flag) noexcept {
+_EXPORT_STD inline void atomic_flag_notify_all(volatile atomic_flag* const _Flag) noexcept {
     return _Flag->notify_all();
 }
 
-inline void atomic_flag_notify_all(atomic_flag* const _Flag) noexcept {
+_EXPORT_STD inline void atomic_flag_notify_all(atomic_flag* const _Flag) noexcept {
     return _Flag->notify_all();
 }
 
diff --git a/stl/inc/barrier b/stl/inc/barrier
index c7332d508c..850c90f4fc 100644
--- a/stl/inc/barrier
+++ b/stl/inc/barrier
@@ -35,7 +35,7 @@ struct _No_completion_function {
     void operator()() noexcept {}
 };
 
-template <class _Completion_function = _No_completion_function>
+_EXPORT_STD template <class _Completion_function = _No_completion_function>
 class barrier;
 
 inline constexpr ptrdiff_t _Barrier_arrival_token_mask = 1;
@@ -66,7 +66,7 @@ private:
     ptrdiff_t _Value;
 };
 
-template <class _Completion_function>
+_EXPORT_STD template <class _Completion_function>
 class barrier {
 public:
     static_assert(
diff --git a/stl/inc/bit b/stl/inc/bit
index 391c0cdcdf..06af8550f3 100644
--- a/stl/inc/bit
+++ b/stl/inc/bit
@@ -26,7 +26,7 @@ _STL_DISABLE_CLANG_WARNINGS
 
 _STD_BEGIN
 
-template <class _To, class _From,
+_EXPORT_STD template <class _To, class _From,
     enable_if_t<conjunction_v<bool_constant<sizeof(_To) == sizeof(_From)>, is_trivially_copyable<_To>,
                     is_trivially_copyable<_From>>,
         int> = 0>
@@ -34,17 +34,17 @@ _NODISCARD constexpr _To bit_cast(const _From& _Val) noexcept {
     return __builtin_bit_cast(_To, _Val);
 }
 
-template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
+_EXPORT_STD template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
 _NODISCARD constexpr int countl_zero(_Ty _Val) noexcept;
 
-template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
+_EXPORT_STD template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
 _NODISCARD constexpr bool has_single_bit(const _Ty _Val) noexcept {
     return _Val != 0 && (_Val & (_Val - 1)) == 0;
 }
 
 inline void _Precondition_violation_in_bit_ceil() noexcept {}
 
-template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
+_EXPORT_STD template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
 _NODISCARD constexpr _Ty bit_ceil(const _Ty _Val) noexcept /* strengthened */ {
     if (_Val <= 1u) {
         return _Ty{1};
@@ -72,7 +72,7 @@ _NODISCARD constexpr _Ty bit_ceil(const _Ty _Val) noexcept /* strengthened */ {
     return static_cast<_Ty>(_Ty{1} << _Num);
 }
 
-template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
+_EXPORT_STD template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
 _NODISCARD constexpr _Ty bit_floor(const _Ty _Val) noexcept {
     if (_Val == 0) {
         return 0;
@@ -81,15 +81,15 @@ _NODISCARD constexpr _Ty bit_floor(const _Ty _Val) noexcept {
     return static_cast<_Ty>(_Ty{1} << (numeric_limits<_Ty>::digits - 1 - _STD countl_zero(_Val)));
 }
 
-template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
+_EXPORT_STD template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
 _NODISCARD constexpr int bit_width(const _Ty _Val) noexcept {
     return numeric_limits<_Ty>::digits - _STD countl_zero(_Val);
 }
 
-template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
+_EXPORT_STD template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
 _NODISCARD constexpr _Ty rotr(_Ty _Val, int _Rotation) noexcept;
 
-template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
+_EXPORT_STD template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
 _NODISCARD constexpr _Ty rotl(const _Ty _Val, const int _Rotation) noexcept {
     constexpr auto _Digits = numeric_limits<_Ty>::digits;
 
@@ -117,7 +117,7 @@ _NODISCARD constexpr _Ty rotl(const _Ty _Val, const int _Rotation) noexcept {
     }
 }
 
-template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> _Enabled>
+_EXPORT_STD template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> _Enabled>
 _NODISCARD constexpr _Ty rotr(const _Ty _Val, const int _Rotation) noexcept {
     constexpr auto _Digits = numeric_limits<_Ty>::digits;
 
@@ -289,7 +289,7 @@ _NODISCARD constexpr unsigned long long _Byteswap_uint64(const unsigned long lon
 }
 #endif // _HAS_CXX23
 
-template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> _Enabled>
+_EXPORT_STD template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> _Enabled>
 _NODISCARD constexpr int countl_zero(const _Ty _Val) noexcept {
 #if defined(_M_IX86) || (defined(_M_X64) && !defined(_M_ARM64EC))
     if (!_STD is_constant_evaluated()) {
@@ -304,28 +304,28 @@ _NODISCARD constexpr int countl_zero(const _Ty _Val) noexcept {
     return _Countl_zero_fallback(_Val);
 }
 
-template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
+_EXPORT_STD template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
 _NODISCARD constexpr int countl_one(const _Ty _Val) noexcept {
     return _STD countl_zero(static_cast<_Ty>(~_Val));
 }
 
-template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
+_EXPORT_STD template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
 _NODISCARD constexpr int countr_zero(const _Ty _Val) noexcept {
     return _Countr_zero(_Val);
 }
 
-template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> _Enabled = 0>
+_EXPORT_STD template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> _Enabled = 0>
 _NODISCARD constexpr int countr_one(const _Ty _Val) noexcept {
     return _Countr_zero(static_cast<_Ty>(~_Val));
 }
 
-template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
+_EXPORT_STD template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
 _NODISCARD constexpr int popcount(const _Ty _Val) noexcept {
     return _Popcount(_Val);
 }
 
 #if _HAS_CXX23
-template <class _Ty, enable_if_t<is_integral_v<_Ty>, int> = 0>
+_EXPORT_STD template <class _Ty, enable_if_t<is_integral_v<_Ty>, int> = 0>
 _NODISCARD constexpr _Ty byteswap(const _Ty _Val) noexcept {
     if constexpr (sizeof(_Ty) == 1) {
         return _Val;
@@ -341,7 +341,7 @@ _NODISCARD constexpr _Ty byteswap(const _Ty _Val) noexcept {
 }
 #endif // _HAS_CXX23
 
-enum class endian { little = 0, big = 1, native = little };
+_EXPORT_STD enum class endian { little = 0, big = 1, native = little };
 
 _STD_END
 #pragma pop_macro("new")
diff --git a/stl/inc/bitset b/stl/inc/bitset
index 041d17b923..de019cf1aa 100644
--- a/stl/inc/bitset
+++ b/stl/inc/bitset
@@ -20,7 +20,7 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-template <size_t _Bits>
+_EXPORT_STD template <size_t _Bits>
 class bitset { // store fixed-length sequence of Boolean elements
 public:
 #pragma warning(push)
@@ -492,28 +492,28 @@ private:
     _Ty _Array[_Words + 1];
 };
 
-template <size_t _Bits>
+_EXPORT_STD template <size_t _Bits>
 _NODISCARD _CONSTEXPR23 bitset<_Bits> operator&(const bitset<_Bits>& _Left, const bitset<_Bits>& _Right) noexcept {
     bitset<_Bits> _Ans = _Left;
     _Ans &= _Right;
     return _Ans;
 }
 
-template <size_t _Bits>
+_EXPORT_STD template <size_t _Bits>
 _NODISCARD _CONSTEXPR23 bitset<_Bits> operator|(const bitset<_Bits>& _Left, const bitset<_Bits>& _Right) noexcept {
     bitset<_Bits> _Ans = _Left;
     _Ans |= _Right;
     return _Ans;
 }
 
-template <size_t _Bits>
+_EXPORT_STD template <size_t _Bits>
 _NODISCARD _CONSTEXPR23 bitset<_Bits> operator^(const bitset<_Bits>& _Left, const bitset<_Bits>& _Right) noexcept {
     bitset<_Bits> _Ans = _Left;
     _Ans ^= _Right;
     return _Ans;
 }
 
-template <class _Elem, class _Tr, size_t _Bits>
+_EXPORT_STD template <class _Elem, class _Tr, size_t _Bits>
 basic_ostream<_Elem, _Tr>& operator<<(basic_ostream<_Elem, _Tr>& _Ostr, const bitset<_Bits>& _Right) {
     using _Ctype             = typename basic_ostream<_Elem, _Tr>::_Ctype;
     const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Ostr.getloc());
@@ -523,7 +523,7 @@ basic_ostream<_Elem, _Tr>& operator<<(basic_ostream<_Elem, _Tr>& _Ostr, const bi
     return _Ostr << _Right.template to_string<_Elem, _Tr, allocator<_Elem>>(_Elem0, _Elem1);
 }
 
-template <class _Elem, class _Tr, size_t _Bits>
+_EXPORT_STD template <class _Elem, class _Tr, size_t _Bits>
 basic_istream<_Elem, _Tr>& operator>>(basic_istream<_Elem, _Tr>& _Istr, bitset<_Bits>& _Right) {
     using _Istr_t                    = basic_istream<_Elem, _Tr>;
     using _Ctype                     = typename _Istr_t::_Ctype;
diff --git a/stl/inc/cctype b/stl/inc/cctype
index 597de07b05..de39757181 100644
--- a/stl/inc/cctype
+++ b/stl/inc/cctype
@@ -19,21 +19,21 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-using _CSTD isalnum;
-using _CSTD isalpha;
-using _CSTD iscntrl;
-using _CSTD isdigit;
-using _CSTD isgraph;
-using _CSTD islower;
-using _CSTD isprint;
-using _CSTD ispunct;
-using _CSTD isspace;
-using _CSTD isupper;
-using _CSTD isxdigit;
-using _CSTD tolower;
-using _CSTD toupper;
-
-using _CSTD isblank;
+_EXPORT_STD using _CSTD isalnum;
+_EXPORT_STD using _CSTD isalpha;
+_EXPORT_STD using _CSTD iscntrl;
+_EXPORT_STD using _CSTD isdigit;
+_EXPORT_STD using _CSTD isgraph;
+_EXPORT_STD using _CSTD islower;
+_EXPORT_STD using _CSTD isprint;
+_EXPORT_STD using _CSTD ispunct;
+_EXPORT_STD using _CSTD isspace;
+_EXPORT_STD using _CSTD isupper;
+_EXPORT_STD using _CSTD isxdigit;
+_EXPORT_STD using _CSTD tolower;
+_EXPORT_STD using _CSTD toupper;
+
+_EXPORT_STD using _CSTD isblank;
 _STD_END
 
 #pragma pop_macro("new")
diff --git a/stl/inc/cfenv b/stl/inc/cfenv
index c78b983724..bad2bf0264 100644
--- a/stl/inc/cfenv
+++ b/stl/inc/cfenv
@@ -19,24 +19,24 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-using _CSTD fegetround;
-using _CSTD fesetround;
+_EXPORT_STD using _CSTD fegetround;
+_EXPORT_STD using _CSTD fesetround;
 
 #if !defined(_M_CEE) || defined(_CRTBLD)
-using _CSTD feclearexcept;
-using _CSTD fegetenv;
-using _CSTD fegetexceptflag;
-using _CSTD feholdexcept;
-using _CSTD fenv_t;
-using _CSTD fesetenv;
-using _CSTD fesetexceptflag;
-using _CSTD fetestexcept;
-using _CSTD fexcept_t;
+_EXPORT_STD using _CSTD feclearexcept;
+_EXPORT_STD using _CSTD fegetenv;
+_EXPORT_STD using _CSTD fegetexceptflag;
+_EXPORT_STD using _CSTD feholdexcept;
+_EXPORT_STD using _CSTD fenv_t;
+_EXPORT_STD using _CSTD fesetenv;
+_EXPORT_STD using _CSTD fesetexceptflag;
+_EXPORT_STD using _CSTD fetestexcept;
+_EXPORT_STD using _CSTD fexcept_t;
 #endif // !defined(_M_CEE) || defined(_CRTBLD)
 
 #if !defined(_M_CEE) && !defined(_CRTBLD)
-using _CSTD feraiseexcept;
-using _CSTD feupdateenv;
+_EXPORT_STD using _CSTD feraiseexcept;
+_EXPORT_STD using _CSTD feupdateenv;
 #endif // !defined(_M_CEE) && !defined(_CRTBLD)
 _STD_END
 
diff --git a/stl/inc/charconv b/stl/inc/charconv
index 85a83419be..b65b9eb911 100644
--- a/stl/inc/charconv
+++ b/stl/inc/charconv
@@ -157,55 +157,55 @@ _NODISCARD _CONSTEXPR23 to_chars_result _Integer_to_chars(
     return {_First + _Digits_written, errc{}};
 }
 
-_CONSTEXPR23 to_chars_result to_chars(
+_EXPORT_STD _CONSTEXPR23 to_chars_result to_chars(
     char* const _First, char* const _Last, const char _Value, const int _Base = 10) noexcept /* strengthened */ {
     return _Integer_to_chars(_First, _Last, _Value, _Base);
 }
-_CONSTEXPR23 to_chars_result to_chars(
+_EXPORT_STD _CONSTEXPR23 to_chars_result to_chars(
     char* const _First, char* const _Last, const signed char _Value, const int _Base = 10) noexcept /* strengthened */ {
     return _Integer_to_chars(_First, _Last, _Value, _Base);
 }
-_CONSTEXPR23 to_chars_result to_chars(char* const _First, char* const _Last, const unsigned char _Value,
+_EXPORT_STD _CONSTEXPR23 to_chars_result to_chars(char* const _First, char* const _Last, const unsigned char _Value,
     const int _Base = 10) noexcept /* strengthened */ {
     return _Integer_to_chars(_First, _Last, _Value, _Base);
 }
-_CONSTEXPR23 to_chars_result to_chars(
+_EXPORT_STD _CONSTEXPR23 to_chars_result to_chars(
     char* const _First, char* const _Last, const short _Value, const int _Base = 10) noexcept /* strengthened */ {
     return _Integer_to_chars(_First, _Last, _Value, _Base);
 }
-_CONSTEXPR23 to_chars_result to_chars(char* const _First, char* const _Last, const unsigned short _Value,
+_EXPORT_STD _CONSTEXPR23 to_chars_result to_chars(char* const _First, char* const _Last, const unsigned short _Value,
     const int _Base = 10) noexcept /* strengthened */ {
     return _Integer_to_chars(_First, _Last, _Value, _Base);
 }
-_CONSTEXPR23 to_chars_result to_chars(
+_EXPORT_STD _CONSTEXPR23 to_chars_result to_chars(
     char* const _First, char* const _Last, const int _Value, const int _Base = 10) noexcept /* strengthened */ {
     return _Integer_to_chars(_First, _Last, _Value, _Base);
 }
-_CONSTEXPR23 to_chars_result to_chars(char* const _First, char* const _Last, const unsigned int _Value,
+_EXPORT_STD _CONSTEXPR23 to_chars_result to_chars(char* const _First, char* const _Last, const unsigned int _Value,
     const int _Base = 10) noexcept /* strengthened */ {
     return _Integer_to_chars(_First, _Last, _Value, _Base);
 }
-_CONSTEXPR23 to_chars_result to_chars(
+_EXPORT_STD _CONSTEXPR23 to_chars_result to_chars(
     char* const _First, char* const _Last, const long _Value, const int _Base = 10) noexcept /* strengthened */ {
     return _Integer_to_chars(_First, _Last, _Value, _Base);
 }
-_CONSTEXPR23 to_chars_result to_chars(char* const _First, char* const _Last, const unsigned long _Value,
+_EXPORT_STD _CONSTEXPR23 to_chars_result to_chars(char* const _First, char* const _Last, const unsigned long _Value,
     const int _Base = 10) noexcept /* strengthened */ {
     return _Integer_to_chars(_First, _Last, _Value, _Base);
 }
-_CONSTEXPR23 to_chars_result to_chars(
+_EXPORT_STD _CONSTEXPR23 to_chars_result to_chars(
     char* const _First, char* const _Last, const long long _Value, const int _Base = 10) noexcept /* strengthened */ {
     return _Integer_to_chars(_First, _Last, _Value, _Base);
 }
-_CONSTEXPR23 to_chars_result to_chars(char* const _First, char* const _Last, const unsigned long long _Value,
-    const int _Base = 10) noexcept /* strengthened */ {
+_EXPORT_STD _CONSTEXPR23 to_chars_result to_chars(char* const _First, char* const _Last,
+    const unsigned long long _Value, const int _Base = 10) noexcept /* strengthened */ {
     return _Integer_to_chars(_First, _Last, _Value, _Base);
 }
 
-to_chars_result to_chars(char* _First, char* _Last, bool _Value, int _Base = 10) = delete;
+_EXPORT_STD to_chars_result to_chars(char* _First, char* _Last, bool _Value, int _Base = 10) = delete;
 
 
-struct from_chars_result {
+_EXPORT_STD struct from_chars_result {
     const char* ptr;
     errc ec;
 #if _HAS_CXX20
@@ -309,48 +309,48 @@ _NODISCARD _CONSTEXPR23 from_chars_result _Integer_from_chars(
     return {_Next, errc{}};
 }
 
-_CONSTEXPR23 from_chars_result from_chars(
+_EXPORT_STD _CONSTEXPR23 from_chars_result from_chars(
     const char* const _First, const char* const _Last, char& _Value, const int _Base = 10) noexcept /* strengthened */ {
     return _Integer_from_chars(_First, _Last, _Value, _Base);
 }
-_CONSTEXPR23 from_chars_result from_chars(const char* const _First, const char* const _Last, signed char& _Value,
-    const int _Base = 10) noexcept /* strengthened */ {
+_EXPORT_STD _CONSTEXPR23 from_chars_result from_chars(const char* const _First, const char* const _Last,
+    signed char& _Value, const int _Base = 10) noexcept /* strengthened */ {
     return _Integer_from_chars(_First, _Last, _Value, _Base);
 }
-_CONSTEXPR23 from_chars_result from_chars(const char* const _First, const char* const _Last, unsigned char& _Value,
-    const int _Base = 10) noexcept /* strengthened */ {
+_EXPORT_STD _CONSTEXPR23 from_chars_result from_chars(const char* const _First, const char* const _Last,
+    unsigned char& _Value, const int _Base = 10) noexcept /* strengthened */ {
     return _Integer_from_chars(_First, _Last, _Value, _Base);
 }
-_CONSTEXPR23 from_chars_result from_chars(const char* const _First, const char* const _Last, short& _Value,
+_EXPORT_STD _CONSTEXPR23 from_chars_result from_chars(const char* const _First, const char* const _Last, short& _Value,
     const int _Base = 10) noexcept /* strengthened */ {
     return _Integer_from_chars(_First, _Last, _Value, _Base);
 }
-_CONSTEXPR23 from_chars_result from_chars(const char* const _First, const char* const _Last, unsigned short& _Value,
-    const int _Base = 10) noexcept /* strengthened */ {
+_EXPORT_STD _CONSTEXPR23 from_chars_result from_chars(const char* const _First, const char* const _Last,
+    unsigned short& _Value, const int _Base = 10) noexcept /* strengthened */ {
     return _Integer_from_chars(_First, _Last, _Value, _Base);
 }
-_CONSTEXPR23 from_chars_result from_chars(
+_EXPORT_STD _CONSTEXPR23 from_chars_result from_chars(
     const char* const _First, const char* const _Last, int& _Value, const int _Base = 10) noexcept /* strengthened */ {
     return _Integer_from_chars(_First, _Last, _Value, _Base);
 }
-_CONSTEXPR23 from_chars_result from_chars(const char* const _First, const char* const _Last, unsigned int& _Value,
-    const int _Base = 10) noexcept /* strengthened */ {
+_EXPORT_STD _CONSTEXPR23 from_chars_result from_chars(const char* const _First, const char* const _Last,
+    unsigned int& _Value, const int _Base = 10) noexcept /* strengthened */ {
     return _Integer_from_chars(_First, _Last, _Value, _Base);
 }
-_CONSTEXPR23 from_chars_result from_chars(
+_EXPORT_STD _CONSTEXPR23 from_chars_result from_chars(
     const char* const _First, const char* const _Last, long& _Value, const int _Base = 10) noexcept /* strengthened */ {
     return _Integer_from_chars(_First, _Last, _Value, _Base);
 }
-_CONSTEXPR23 from_chars_result from_chars(const char* const _First, const char* const _Last, unsigned long& _Value,
-    const int _Base = 10) noexcept /* strengthened */ {
+_EXPORT_STD _CONSTEXPR23 from_chars_result from_chars(const char* const _First, const char* const _Last,
+    unsigned long& _Value, const int _Base = 10) noexcept /* strengthened */ {
     return _Integer_from_chars(_First, _Last, _Value, _Base);
 }
-_CONSTEXPR23 from_chars_result from_chars(const char* const _First, const char* const _Last, long long& _Value,
-    const int _Base = 10) noexcept /* strengthened */ {
+_EXPORT_STD _CONSTEXPR23 from_chars_result from_chars(const char* const _First, const char* const _Last,
+    long long& _Value, const int _Base = 10) noexcept /* strengthened */ {
     return _Integer_from_chars(_First, _Last, _Value, _Base);
 }
-_CONSTEXPR23 from_chars_result from_chars(const char* const _First, const char* const _Last, unsigned long long& _Value,
-    const int _Base = 10) noexcept /* strengthened */ {
+_EXPORT_STD _CONSTEXPR23 from_chars_result from_chars(const char* const _First, const char* const _Last,
+    unsigned long long& _Value, const int _Base = 10) noexcept /* strengthened */ {
     return _Integer_from_chars(_First, _Last, _Value, _Base);
 }
 
@@ -1901,15 +1901,15 @@ _NODISCARD from_chars_result _Floating_from_chars(
     }
 }
 
-inline from_chars_result from_chars(const char* const _First, const char* const _Last, float& _Value,
+_EXPORT_STD inline from_chars_result from_chars(const char* const _First, const char* const _Last, float& _Value,
     const chars_format _Fmt = chars_format::general) noexcept /* strengthened */ {
     return _Floating_from_chars(_First, _Last, _Value, _Fmt);
 }
-inline from_chars_result from_chars(const char* const _First, const char* const _Last, double& _Value,
+_EXPORT_STD inline from_chars_result from_chars(const char* const _First, const char* const _Last, double& _Value,
     const chars_format _Fmt = chars_format::general) noexcept /* strengthened */ {
     return _Floating_from_chars(_First, _Last, _Value, _Fmt);
 }
-inline from_chars_result from_chars(const char* const _First, const char* const _Last, long double& _Value,
+_EXPORT_STD inline from_chars_result from_chars(const char* const _First, const char* const _Last, long double& _Value,
     const chars_format _Fmt = chars_format::general) noexcept /* strengthened */ {
     double _Dbl; // intentionally default-init
     const from_chars_result _Result = _Floating_from_chars(_First, _Last, _Dbl, _Fmt);
@@ -2517,40 +2517,41 @@ _NODISCARD to_chars_result _Floating_to_chars(
     }
 }
 
-inline to_chars_result to_chars(char* const _First, char* const _Last, const float _Value) noexcept /* strengthened */ {
+_EXPORT_STD inline to_chars_result to_chars(char* const _First, char* const _Last, const float _Value) noexcept
+/* strengthened */ {
     return _Floating_to_chars<_Floating_to_chars_overload::_Plain>(_First, _Last, _Value, chars_format{}, 0);
 }
-inline to_chars_result to_chars(char* const _First, char* const _Last, const double _Value) noexcept
+_EXPORT_STD inline to_chars_result to_chars(char* const _First, char* const _Last, const double _Value) noexcept
 /* strengthened */ {
     return _Floating_to_chars<_Floating_to_chars_overload::_Plain>(_First, _Last, _Value, chars_format{}, 0);
 }
-inline to_chars_result to_chars(char* const _First, char* const _Last, const long double _Value) noexcept
+_EXPORT_STD inline to_chars_result to_chars(char* const _First, char* const _Last, const long double _Value) noexcept
 /* strengthened */ {
     return _Floating_to_chars<_Floating_to_chars_overload::_Plain>(
         _First, _Last, static_cast<double>(_Value), chars_format{}, 0);
 }
-inline to_chars_result to_chars(
+_EXPORT_STD inline to_chars_result to_chars(
     char* const _First, char* const _Last, const float _Value, const chars_format _Fmt) noexcept /* strengthened */ {
     return _Floating_to_chars<_Floating_to_chars_overload::_Format_only>(_First, _Last, _Value, _Fmt, 0);
 }
-inline to_chars_result to_chars(
+_EXPORT_STD inline to_chars_result to_chars(
     char* const _First, char* const _Last, const double _Value, const chars_format _Fmt) noexcept /* strengthened */ {
     return _Floating_to_chars<_Floating_to_chars_overload::_Format_only>(_First, _Last, _Value, _Fmt, 0);
 }
-inline to_chars_result to_chars(char* const _First, char* const _Last, const long double _Value,
+_EXPORT_STD inline to_chars_result to_chars(char* const _First, char* const _Last, const long double _Value,
     const chars_format _Fmt) noexcept /* strengthened */ {
     return _Floating_to_chars<_Floating_to_chars_overload::_Format_only>(
         _First, _Last, static_cast<double>(_Value), _Fmt, 0);
 }
-inline to_chars_result to_chars(char* const _First, char* const _Last, const float _Value, const chars_format _Fmt,
-    const int _Precision) noexcept /* strengthened */ {
+_EXPORT_STD inline to_chars_result to_chars(char* const _First, char* const _Last, const float _Value,
+    const chars_format _Fmt, const int _Precision) noexcept /* strengthened */ {
     return _Floating_to_chars<_Floating_to_chars_overload::_Format_precision>(_First, _Last, _Value, _Fmt, _Precision);
 }
-inline to_chars_result to_chars(char* const _First, char* const _Last, const double _Value, const chars_format _Fmt,
-    const int _Precision) noexcept /* strengthened */ {
+_EXPORT_STD inline to_chars_result to_chars(char* const _First, char* const _Last, const double _Value,
+    const chars_format _Fmt, const int _Precision) noexcept /* strengthened */ {
     return _Floating_to_chars<_Floating_to_chars_overload::_Format_precision>(_First, _Last, _Value, _Fmt, _Precision);
 }
-inline to_chars_result to_chars(char* const _First, char* const _Last, const long double _Value,
+_EXPORT_STD inline to_chars_result to_chars(char* const _First, char* const _Last, const long double _Value,
     const chars_format _Fmt, const int _Precision) noexcept /* strengthened */ {
     return _Floating_to_chars<_Floating_to_chars_overload::_Format_precision>(
         _First, _Last, static_cast<double>(_Value), _Fmt, _Precision);
diff --git a/stl/inc/chrono b/stl/inc/chrono
index 8607c41f40..cfe8898968 100644
--- a/stl/inc/chrono
+++ b/stl/inc/chrono
@@ -170,7 +170,7 @@ namespace chrono {
         }
     }
 
-    template <class _CharT, class _Traits, class _Rep, class _Period>
+    _EXPORT_STD template <class _CharT, class _Traits, class _Rep, class _Period>
     basic_ostream<_CharT, _Traits>& operator<<(
         basic_ostream<_CharT, _Traits>& _Os, const duration<_Rep, _Period>& _Dur) {
         basic_ostringstream<_CharT, _Traits> _Sstr;
@@ -183,19 +183,17 @@ namespace chrono {
         return _Os << _Sstr.str();
     }
 
-    struct local_t {};
+    _EXPORT_STD struct local_t {};
 
-    template <class _Duration>
-    using local_time    = time_point<local_t, _Duration>;
-    using local_seconds = local_time<seconds>;
-    using local_days    = local_time<days>;
+    _EXPORT_STD template <class _Duration>
+    using local_time                = time_point<local_t, _Duration>;
+    _EXPORT_STD using local_seconds = local_time<seconds>;
+    _EXPORT_STD using local_days    = local_time<days>;
 
-    struct last_spec {
-        explicit last_spec() = default;
-    };
-    inline constexpr last_spec last{};
+    _EXPORT_STD struct last_spec { explicit last_spec() = default; };
+    _EXPORT_STD inline constexpr last_spec last{};
 
-    class day {
+    _EXPORT_STD class day {
     public:
         day() = default;
         constexpr explicit day(unsigned int _Val) noexcept : _Day{static_cast<unsigned char>(_Val)} {}
@@ -235,28 +233,28 @@ namespace chrono {
         unsigned char _Day;
     };
 
-    _NODISCARD constexpr bool operator==(const day& _Left, const day& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr bool operator==(const day& _Left, const day& _Right) noexcept {
         return static_cast<unsigned int>(_Left) == static_cast<unsigned int>(_Right);
     }
-    _NODISCARD constexpr strong_ordering operator<=>(const day& _Left, const day& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr strong_ordering operator<=>(const day& _Left, const day& _Right) noexcept {
         return static_cast<unsigned int>(_Left) <=> static_cast<unsigned int>(_Right);
     }
 
-    _NODISCARD constexpr day operator+(const day& _Left, const days& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr day operator+(const day& _Left, const days& _Right) noexcept {
         return day{static_cast<unsigned int>(_Left) + _Right.count()};
     }
-    _NODISCARD constexpr day operator+(const days& _Left, const day& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr day operator+(const days& _Left, const day& _Right) noexcept {
         return _Right + _Left;
     }
-    _NODISCARD constexpr day operator-(const day& _Left, const days& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr day operator-(const day& _Left, const days& _Right) noexcept {
         return day{static_cast<unsigned int>(_Left) - _Right.count()};
     }
-    _NODISCARD constexpr days operator-(const day& _Left, const day& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr days operator-(const day& _Left, const day& _Right) noexcept {
         return days{
             static_cast<int>(static_cast<unsigned int>(_Left)) - static_cast<int>(static_cast<unsigned int>(_Right))};
     }
 
-    class month {
+    _EXPORT_STD class month {
     public:
         month() = default;
         constexpr explicit month(unsigned int _Val) noexcept : _Month{static_cast<unsigned char>(_Val)} {}
@@ -294,25 +292,25 @@ namespace chrono {
         unsigned char _Month;
     };
 
-    _NODISCARD constexpr bool operator==(const month& _Left, const month& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr bool operator==(const month& _Left, const month& _Right) noexcept {
         return static_cast<unsigned int>(_Left) == static_cast<unsigned int>(_Right);
     }
-    _NODISCARD constexpr strong_ordering operator<=>(const month& _Left, const month& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr strong_ordering operator<=>(const month& _Left, const month& _Right) noexcept {
         return static_cast<unsigned int>(_Left) <=> static_cast<unsigned int>(_Right);
     }
 
-    _NODISCARD constexpr month operator+(const month& _Left, const months& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr month operator+(const month& _Left, const months& _Right) noexcept {
         const auto _Mo  = static_cast<long long>(static_cast<unsigned int>(_Left)) + (_Right.count() - 1);
         const auto _Div = (_Mo >= 0 ? _Mo : _Mo - 11) / 12;
         return month{static_cast<unsigned int>(_Mo - _Div * 12 + 1)};
     }
-    _NODISCARD constexpr month operator+(const months& _Left, const month& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr month operator+(const months& _Left, const month& _Right) noexcept {
         return _Right + _Left;
     }
-    _NODISCARD constexpr month operator-(const month& _Left, const months& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr month operator-(const month& _Left, const months& _Right) noexcept {
         return _Left + -_Right;
     }
-    _NODISCARD constexpr months operator-(const month& _Left, const month& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr months operator-(const month& _Left, const month& _Right) noexcept {
         const auto _Mo = static_cast<unsigned int>(_Left) - static_cast<unsigned int>(_Right);
         return months{_Mo <= 11 ? _Mo : _Mo + 12};
     }
@@ -326,7 +324,7 @@ namespace chrono {
         return *this;
     }
 
-    class year {
+    _EXPORT_STD class year {
     public:
         year() = default;
         constexpr explicit year(int _Val) noexcept : _Year{static_cast<short>(_Val)} {}
@@ -395,30 +393,30 @@ namespace chrono {
         static constexpr int _Year_max = 32767;
     };
 
-    _NODISCARD constexpr bool operator==(const year& _Left, const year& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr bool operator==(const year& _Left, const year& _Right) noexcept {
         return static_cast<int>(_Left) == static_cast<int>(_Right);
     }
-    _NODISCARD constexpr strong_ordering operator<=>(const year& _Left, const year& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr strong_ordering operator<=>(const year& _Left, const year& _Right) noexcept {
         return static_cast<int>(_Left) <=> static_cast<int>(_Right);
     }
 
-    _NODISCARD constexpr year operator+(const year& _Left, const years& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year operator+(const year& _Left, const years& _Right) noexcept {
         return year{static_cast<int>(_Left) + _Right.count()};
     }
-    _NODISCARD constexpr year operator+(const years& _Left, const year& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year operator+(const years& _Left, const year& _Right) noexcept {
         return _Right + _Left;
     }
-    _NODISCARD constexpr year operator-(const year& _Left, const years& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year operator-(const year& _Left, const years& _Right) noexcept {
         return _Left + -_Right;
     }
-    _NODISCARD constexpr years operator-(const year& _Left, const year& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr years operator-(const year& _Left, const year& _Right) noexcept {
         return years{static_cast<int>(_Left) - static_cast<int>(_Right)};
     }
 
-    class weekday_indexed;
-    class weekday_last;
+    _EXPORT_STD class weekday_indexed;
+    _EXPORT_STD class weekday_last;
 
-    class weekday {
+    _EXPORT_STD class weekday {
     public:
         weekday() = default;
         constexpr explicit weekday(unsigned int _Val) noexcept
@@ -471,22 +469,22 @@ namespace chrono {
         }
     };
 
-    _NODISCARD constexpr bool operator==(const weekday& _Left, const weekday& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr bool operator==(const weekday& _Left, const weekday& _Right) noexcept {
         return _Left.c_encoding() == _Right.c_encoding();
     }
 
-    _NODISCARD constexpr weekday operator+(const weekday& _Left, const days& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr weekday operator+(const weekday& _Left, const days& _Right) noexcept {
         const auto _Wd  = static_cast<long long>(_Left.c_encoding()) + _Right.count();
         const auto _Div = (_Wd >= 0 ? _Wd : _Wd - 6) / 7;
         return weekday{static_cast<unsigned int>(_Wd - _Div * 7)};
     }
-    _NODISCARD constexpr weekday operator+(const days& _Left, const weekday& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr weekday operator+(const days& _Left, const weekday& _Right) noexcept {
         return _Right + _Left;
     }
-    _NODISCARD constexpr weekday operator-(const weekday& _Left, const days& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr weekday operator-(const weekday& _Left, const days& _Right) noexcept {
         return _Left + -_Right;
     }
-    _NODISCARD constexpr days operator-(const weekday& _Left, const weekday& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr days operator-(const weekday& _Left, const weekday& _Right) noexcept {
         const auto _Wd = _Left.c_encoding() - _Right.c_encoding();
         const auto _Wk = _Wd <= 6 ? _Wd : _Wd + 7;
         return days{_Wk};
@@ -501,7 +499,7 @@ namespace chrono {
         return *this;
     }
 
-    class weekday_indexed {
+    _EXPORT_STD class weekday_indexed {
     public:
         weekday_indexed() = default;
         constexpr weekday_indexed(const weekday& _Wd, unsigned int _Idx) noexcept
@@ -522,11 +520,12 @@ namespace chrono {
         unsigned char _Index;
     };
 
-    _NODISCARD constexpr bool operator==(const weekday_indexed& _Left, const weekday_indexed& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr bool operator==(
+        const weekday_indexed& _Left, const weekday_indexed& _Right) noexcept {
         return _Left.weekday() == _Right.weekday() && _Left.index() == _Right.index();
     }
 
-    class weekday_last {
+    _EXPORT_STD class weekday_last {
     public:
         constexpr explicit weekday_last(const weekday& _Wd) noexcept : _Weekday{_Wd} {}
 
@@ -541,7 +540,7 @@ namespace chrono {
         _CHRONO weekday _Weekday;
     };
 
-    _NODISCARD constexpr bool operator==(const weekday_last& _Left, const weekday_last& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr bool operator==(const weekday_last& _Left, const weekday_last& _Right) noexcept {
         return _Left.weekday() == _Right.weekday();
     }
 
@@ -552,7 +551,7 @@ namespace chrono {
         return weekday_last{*this};
     }
 
-    class month_day {
+    _EXPORT_STD class month_day {
     public:
         month_day() = default;
         constexpr month_day(const month& _Month_, const day& _Day_) noexcept : _Month{_Month_}, _Day{_Day_} {}
@@ -585,10 +584,11 @@ namespace chrono {
         _CHRONO day _Day;
     };
 
-    _NODISCARD constexpr bool operator==(const month_day& _Left, const month_day& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr bool operator==(const month_day& _Left, const month_day& _Right) noexcept {
         return _Left.month() == _Right.month() && _Left.day() == _Right.day();
     }
-    _NODISCARD constexpr strong_ordering operator<=>(const month_day& _Left, const month_day& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr strong_ordering operator<=>(
+        const month_day& _Left, const month_day& _Right) noexcept {
         const auto _Comp = _Left.month() <=> _Right.month();
         if (_Comp != 0) {
             return _Comp;
@@ -597,7 +597,7 @@ namespace chrono {
         return _Left.day() <=> _Right.day();
     }
 
-    class month_day_last {
+    _EXPORT_STD class month_day_last {
     public:
         constexpr explicit month_day_last(const month& _Month_) noexcept : _Month{_Month_} {}
 
@@ -612,15 +612,16 @@ namespace chrono {
         _CHRONO month _Month;
     };
 
-    _NODISCARD constexpr bool operator==(const month_day_last& _Left, const month_day_last& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr bool operator==(
+        const month_day_last& _Left, const month_day_last& _Right) noexcept {
         return _Left.month() == _Right.month();
     }
-    _NODISCARD constexpr strong_ordering operator<=>(
+    _EXPORT_STD _NODISCARD constexpr strong_ordering operator<=>(
         const month_day_last& _Left, const month_day_last& _Right) noexcept {
         return _Left.month() <=> _Right.month();
     }
 
-    class month_weekday {
+    _EXPORT_STD class month_weekday {
     public:
         constexpr month_weekday(const month& _Month_, const weekday_indexed& _Wdi) noexcept
             : _Month{_Month_}, _Weekday_index{_Wdi} {}
@@ -641,11 +642,11 @@ namespace chrono {
         _CHRONO weekday_indexed _Weekday_index;
     };
 
-    _NODISCARD constexpr bool operator==(const month_weekday& _Left, const month_weekday& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr bool operator==(const month_weekday& _Left, const month_weekday& _Right) noexcept {
         return _Left.month() == _Right.month() && _Left.weekday_indexed() == _Right.weekday_indexed();
     }
 
-    class month_weekday_last {
+    _EXPORT_STD class month_weekday_last {
     public:
         constexpr month_weekday_last(const month& _Month_, const weekday_last& _Wdl) noexcept
             : _Month{_Month_}, _Weekday_last{_Wdl} {}
@@ -665,11 +666,12 @@ namespace chrono {
         _CHRONO weekday_last _Weekday_last;
     };
 
-    _NODISCARD constexpr bool operator==(const month_weekday_last& _Left, const month_weekday_last& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr bool operator==(
+        const month_weekday_last& _Left, const month_weekday_last& _Right) noexcept {
         return _Left.month() == _Right.month() && _Left.weekday_last() == _Right.weekday_last();
     }
 
-    class year_month {
+    _EXPORT_STD class year_month {
     public:
         year_month() = default;
         constexpr year_month(const year& _Year_, const month& _Month_) noexcept : _Year{_Year_}, _Month{_Month_} {}
@@ -697,10 +699,11 @@ namespace chrono {
         _CHRONO month _Month;
     };
 
-    _NODISCARD constexpr bool operator==(const year_month& _Left, const year_month& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr bool operator==(const year_month& _Left, const year_month& _Right) noexcept {
         return _Left.year() == _Right.year() && _Left.month() == _Right.month();
     }
-    _NODISCARD constexpr strong_ordering operator<=>(const year_month& _Left, const year_month& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr strong_ordering operator<=>(
+        const year_month& _Left, const year_month& _Right) noexcept {
         const auto _Comp = _Left.year() <=> _Right.year();
         if (_Comp != 0) {
             return _Comp;
@@ -709,37 +712,37 @@ namespace chrono {
         return _Left.month() <=> _Right.month();
     }
 
-    template <int = 0>
+    _EXPORT_STD template <int = 0>
     _NODISCARD constexpr year_month operator+(const year_month& _Left, const months& _Right) noexcept {
         const auto _Mo  = static_cast<long long>(static_cast<unsigned int>(_Left.month())) + (_Right.count() - 1);
         const auto _Div = (_Mo >= 0 ? _Mo : _Mo - 11) / 12;
         return year_month{_Left.year() + years{_Div}, month{static_cast<unsigned int>(_Mo - _Div * 12 + 1)}};
     }
-    template <int = 0>
+    _EXPORT_STD template <int = 0>
     _NODISCARD constexpr year_month operator+(const months& _Left, const year_month& _Right) noexcept {
         return _Right + _Left;
     }
 
-    template <int = 0>
+    _EXPORT_STD template <int = 0>
     _NODISCARD constexpr year_month operator-(const year_month& _Left, const months& _Right) noexcept {
         return _Left + -_Right;
     }
 
-    _NODISCARD constexpr months operator-(const year_month& _Left, const year_month& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr months operator-(const year_month& _Left, const year_month& _Right) noexcept {
         return _Left.year() - _Right.year()
              + months{static_cast<int>(static_cast<unsigned int>(_Left.month()))
                       - static_cast<int>(static_cast<unsigned int>(_Right.month()))};
     }
 
-    _NODISCARD constexpr year_month operator+(const year_month& _Left, const years& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month operator+(const year_month& _Left, const years& _Right) noexcept {
         return {year{_Left.year() + _Right}, _Left.month()};
     }
 
-    _NODISCARD constexpr year_month operator+(const years& _Left, const year_month& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month operator+(const years& _Left, const year_month& _Right) noexcept {
         return _Right + _Left;
     }
 
-    _NODISCARD constexpr year_month operator-(const year_month& _Left, const years& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month operator-(const year_month& _Left, const years& _Right) noexcept {
         return _Left + -_Right;
     }
 
@@ -774,9 +777,9 @@ namespace chrono {
         return _Last_day_table[(static_cast<unsigned int>(_Month) - 1) & 0xF];
     }
 
-    class year_month_day_last;
+    _EXPORT_STD class year_month_day_last;
 
-    class year_month_day {
+    _EXPORT_STD class year_month_day {
     public:
         year_month_day() = default;
         constexpr year_month_day(const year& _Year_, const month& _Month_, const day& _Day_) noexcept
@@ -988,10 +991,11 @@ namespace chrono {
         }
     };
 
-    _NODISCARD constexpr bool operator==(const year_month_day& _Left, const year_month_day& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr bool operator==(
+        const year_month_day& _Left, const year_month_day& _Right) noexcept {
         return _Left.year() == _Right.year() && _Left.month() == _Right.month() && _Left.day() == _Right.day();
     }
-    _NODISCARD constexpr strong_ordering operator<=>(
+    _EXPORT_STD _NODISCARD constexpr strong_ordering operator<=>(
         const year_month_day& _Left, const year_month_day& _Right) noexcept {
         auto _Comp = _Left.year() <=> _Right.year();
         if (_Comp != 0) {
@@ -1006,31 +1010,34 @@ namespace chrono {
         return _Left.day() <=> _Right.day();
     }
 
-    template <int = 0>
+    _EXPORT_STD template <int = 0>
     _NODISCARD constexpr year_month_day operator+(const year_month_day& _Left, const months& _Right) noexcept {
         const auto _Ym = year_month{_Left.year(), _Left.month()} + _Right;
         return {_Ym.year(), _Ym.month(), _Left.day()};
     }
 
-    template <int = 0>
+    _EXPORT_STD template <int = 0>
     _NODISCARD constexpr year_month_day operator+(const months& _Left, const year_month_day& _Right) noexcept {
         return _Right + _Left;
     }
 
-    template <int = 0>
+    _EXPORT_STD template <int = 0>
     _NODISCARD constexpr year_month_day operator-(const year_month_day& _Left, const months& _Right) noexcept {
         return _Left + -_Right;
     }
 
-    _NODISCARD constexpr year_month_day operator+(const year_month_day& _Left, const years& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_day operator+(
+        const year_month_day& _Left, const years& _Right) noexcept {
         return {_Left.year() + _Right, _Left.month(), _Left.day()};
     }
 
-    _NODISCARD constexpr year_month_day operator+(const years& _Left, const year_month_day& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_day operator+(
+        const years& _Left, const year_month_day& _Right) noexcept {
         return _Right + _Left;
     }
 
-    _NODISCARD constexpr year_month_day operator-(const year_month_day& _Left, const years& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_day operator-(
+        const year_month_day& _Left, const years& _Right) noexcept {
         return _Left + -_Right;
     }
 
@@ -1053,7 +1060,7 @@ namespace chrono {
         return *this;
     }
 
-    class year_month_day_last {
+    _EXPORT_STD class year_month_day_last {
     public:
         constexpr year_month_day_last(const year& _Year_, const month_day_last& _Mdl) noexcept
             : _Year{_Year_}, _Month_day_last{_Mdl} {}
@@ -1093,10 +1100,11 @@ namespace chrono {
         _CHRONO month_day_last _Month_day_last;
     };
 
-    _NODISCARD constexpr bool operator==(const year_month_day_last& _Left, const year_month_day_last& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr bool operator==(
+        const year_month_day_last& _Left, const year_month_day_last& _Right) noexcept {
         return _Left.year() == _Right.year() && _Left.month_day_last() == _Right.month_day_last();
     }
-    _NODISCARD constexpr strong_ordering operator<=>(
+    _EXPORT_STD _NODISCARD constexpr strong_ordering operator<=>(
         const year_month_day_last& _Left, const year_month_day_last& _Right) noexcept {
         const auto _Comp = _Left.year() <=> _Right.year();
         if (_Comp != 0) {
@@ -1106,31 +1114,34 @@ namespace chrono {
         return _Left.month_day_last() <=> _Right.month_day_last();
     }
 
-    template <int = 0>
+    _EXPORT_STD template <int = 0>
     _NODISCARD constexpr year_month_day_last operator+(
         const year_month_day_last& _Left, const months& _Right) noexcept {
         const auto _Ym = year_month{_Left.year(), _Left.month()} + _Right;
         return {_Ym.year(), month_day_last{_Ym.month()}};
     }
-    template <int = 0>
+    _EXPORT_STD template <int = 0>
     _NODISCARD constexpr year_month_day_last operator+(
         const months& _Left, const year_month_day_last& _Right) noexcept {
         return _Right + _Left;
     }
 
-    template <int = 0>
+    _EXPORT_STD template <int = 0>
     _NODISCARD constexpr year_month_day_last operator-(
         const year_month_day_last& _Left, const months& _Right) noexcept {
         return _Left + -_Right;
     }
 
-    _NODISCARD constexpr year_month_day_last operator+(const year_month_day_last& _Left, const years& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_day_last operator+(
+        const year_month_day_last& _Left, const years& _Right) noexcept {
         return {_Left.year() + _Right, _Left.month_day_last()};
     }
-    _NODISCARD constexpr year_month_day_last operator+(const years& _Left, const year_month_day_last& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_day_last operator+(
+        const years& _Left, const year_month_day_last& _Right) noexcept {
         return _Right + _Left;
     }
-    _NODISCARD constexpr year_month_day_last operator-(const year_month_day_last& _Left, const years& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_day_last operator-(
+        const year_month_day_last& _Left, const years& _Right) noexcept {
         return _Left + -_Right;
     }
 
@@ -1156,7 +1167,7 @@ namespace chrono {
     constexpr year_month_day::year_month_day(const year_month_day_last& _Ymdl) noexcept
         : _Year{_Ymdl.year()}, _Month{_Ymdl.month()}, _Day{_Ymdl.day()} {}
 
-    class year_month_weekday {
+    _EXPORT_STD class year_month_weekday {
     public:
         year_month_weekday() = default;
         constexpr year_month_weekday(const year& _Year_, const month& _Month_, const weekday_indexed& _Wdi) noexcept
@@ -1228,34 +1239,38 @@ namespace chrono {
         }
     };
 
-    _NODISCARD constexpr bool operator==(const year_month_weekday& _Left, const year_month_weekday& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr bool operator==(
+        const year_month_weekday& _Left, const year_month_weekday& _Right) noexcept {
         return _Left.year() == _Right.year() && _Left.month() == _Right.month()
             && _Left.weekday_indexed() == _Right.weekday_indexed();
     }
 
-    template <int = 0>
+    _EXPORT_STD template <int = 0>
     _NODISCARD constexpr year_month_weekday operator+(const year_month_weekday& _Left, const months& _Right) noexcept {
         const auto _Ym = year_month{_Left.year(), _Left.month()} + _Right;
         return {_Ym.year(), _Ym.month(), _Left.weekday_indexed()};
     }
-    template <int = 0>
+    _EXPORT_STD template <int = 0>
     _NODISCARD constexpr year_month_weekday operator+(const months& _Left, const year_month_weekday& _Right) noexcept {
         return _Right + _Left;
     }
 
-    template <int = 0>
+    _EXPORT_STD template <int = 0>
     _NODISCARD constexpr year_month_weekday operator-(const year_month_weekday& _Left, const months& _Right) noexcept {
         return _Left + -_Right;
     }
 
-    _NODISCARD constexpr year_month_weekday operator+(const year_month_weekday& _Left, const years& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday operator+(
+        const year_month_weekday& _Left, const years& _Right) noexcept {
         return year_month_weekday{_Left.year() + _Right, _Left.month(), _Left.weekday_indexed()};
     }
-    _NODISCARD constexpr year_month_weekday operator+(const years& _Left, const year_month_weekday& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday operator+(
+        const years& _Left, const year_month_weekday& _Right) noexcept {
         return _Right + _Left;
     }
 
-    _NODISCARD constexpr year_month_weekday operator-(const year_month_weekday& _Left, const years& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday operator-(
+        const year_month_weekday& _Left, const years& _Right) noexcept {
         return _Left + -_Right;
     }
 
@@ -1278,7 +1293,7 @@ namespace chrono {
         return *this;
     }
 
-    class year_month_weekday_last {
+    _EXPORT_STD class year_month_weekday_last {
     public:
         constexpr year_month_weekday_last(const year& _Year_, const month& _Month_, const weekday_last& _Wdl) noexcept
             : _Year{_Year_}, _Month{_Month_}, _Weekday_last{_Wdl} {}
@@ -1322,40 +1337,40 @@ namespace chrono {
         _CHRONO weekday_last _Weekday_last;
     };
 
-    _NODISCARD constexpr bool operator==(
+    _EXPORT_STD _NODISCARD constexpr bool operator==(
         const year_month_weekday_last& _Left, const year_month_weekday_last& _Right) noexcept {
         return _Left.year() == _Right.year() && _Left.month() == _Right.month()
             && _Left.weekday_last() == _Right.weekday_last();
     }
 
-    template <int = 0>
+    _EXPORT_STD template <int = 0>
     _NODISCARD constexpr year_month_weekday_last operator+(
         const year_month_weekday_last& _Left, const months& _Right) noexcept {
         const auto _Ym = year_month{_Left.year(), _Left.month()} + _Right;
         return {_Ym.year(), _Ym.month(), _Left.weekday_last()};
     }
-    template <int = 0>
+    _EXPORT_STD template <int = 0>
     _NODISCARD constexpr year_month_weekday_last operator+(
         const months& _Left, const year_month_weekday_last& _Right) noexcept {
         return _Right + _Left;
     }
 
-    template <int = 0>
+    _EXPORT_STD template <int = 0>
     _NODISCARD constexpr year_month_weekday_last operator-(
         const year_month_weekday_last& _Left, const months& _Right) noexcept {
         return _Left + -_Right;
     }
 
-    _NODISCARD constexpr year_month_weekday_last operator+(
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday_last operator+(
         const year_month_weekday_last& _Left, const years& _Right) noexcept {
         return {_Left.year() + _Right, _Left.month(), _Left.weekday_last()};
     }
-    _NODISCARD constexpr year_month_weekday_last operator+(
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday_last operator+(
         const years& _Left, const year_month_weekday_last& _Right) noexcept {
         return _Right + _Left;
     }
 
-    _NODISCARD constexpr year_month_weekday_last operator-(
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday_last operator-(
         const year_month_weekday_last& _Left, const years& _Right) noexcept {
         return _Left + -_Right;
     }
@@ -1380,150 +1395,162 @@ namespace chrono {
     }
 
     // Civil calendar conventional syntax operators
-    _NODISCARD constexpr year_month operator/(const year& _Year, const month& _Month) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month operator/(const year& _Year, const month& _Month) noexcept {
         return {_Year, _Month};
     }
-    _NODISCARD constexpr year_month operator/(const year& _Year, int _Month) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month operator/(const year& _Year, int _Month) noexcept {
         return _Year / month{static_cast<unsigned int>(_Month)};
     }
-    _NODISCARD constexpr month_day operator/(const month& _Month, const day& _Day) noexcept {
+    _EXPORT_STD _NODISCARD constexpr month_day operator/(const month& _Month, const day& _Day) noexcept {
         return {_Month, _Day};
     }
-    _NODISCARD constexpr month_day operator/(const month& _Month, int _Day) noexcept {
+    _EXPORT_STD _NODISCARD constexpr month_day operator/(const month& _Month, int _Day) noexcept {
         return _Month / day{static_cast<unsigned int>(_Day)};
     }
-    _NODISCARD constexpr month_day operator/(int _Month, const day& _Day) noexcept {
+    _EXPORT_STD _NODISCARD constexpr month_day operator/(int _Month, const day& _Day) noexcept {
         return month{static_cast<unsigned int>(_Month)} / _Day;
     }
-    _NODISCARD constexpr month_day operator/(const day& _Day, const month& _Month) noexcept {
+    _EXPORT_STD _NODISCARD constexpr month_day operator/(const day& _Day, const month& _Month) noexcept {
         return _Month / _Day;
     }
-    _NODISCARD constexpr month_day operator/(const day& _Day, int _Month) noexcept {
+    _EXPORT_STD _NODISCARD constexpr month_day operator/(const day& _Day, int _Month) noexcept {
         return month{static_cast<unsigned int>(_Month)} / _Day;
     }
-    _NODISCARD constexpr month_day_last operator/(const month& _Month, last_spec) noexcept {
+    _EXPORT_STD _NODISCARD constexpr month_day_last operator/(const month& _Month, last_spec) noexcept {
         return month_day_last{_Month};
     }
-    _NODISCARD constexpr month_day_last operator/(int _Month, last_spec) noexcept {
+    _EXPORT_STD _NODISCARD constexpr month_day_last operator/(int _Month, last_spec) noexcept {
         return month{static_cast<unsigned int>(_Month)} / last;
     }
-    _NODISCARD constexpr month_day_last operator/(last_spec, const month& _Month) noexcept {
+    _EXPORT_STD _NODISCARD constexpr month_day_last operator/(last_spec, const month& _Month) noexcept {
         return _Month / last;
     }
-    _NODISCARD constexpr month_day_last operator/(last_spec, int _Month) noexcept {
+    _EXPORT_STD _NODISCARD constexpr month_day_last operator/(last_spec, int _Month) noexcept {
         return month{static_cast<unsigned int>(_Month)} / last;
     }
-    _NODISCARD constexpr month_weekday operator/(const month& _Month, const weekday_indexed& _Wdi) noexcept {
+    _EXPORT_STD _NODISCARD constexpr month_weekday operator/(
+        const month& _Month, const weekday_indexed& _Wdi) noexcept {
         return {_Month, _Wdi};
     }
-    _NODISCARD constexpr month_weekday operator/(int _Month, const weekday_indexed& _Wdi) noexcept {
+    _EXPORT_STD _NODISCARD constexpr month_weekday operator/(int _Month, const weekday_indexed& _Wdi) noexcept {
         return month{static_cast<unsigned int>(_Month)} / _Wdi;
     }
-    _NODISCARD constexpr month_weekday operator/(const weekday_indexed& _Wdi, const month& _Month) noexcept {
+    _EXPORT_STD _NODISCARD constexpr month_weekday operator/(
+        const weekday_indexed& _Wdi, const month& _Month) noexcept {
         return _Month / _Wdi;
     }
-    _NODISCARD constexpr month_weekday operator/(const weekday_indexed& _Wdi, int _Month) noexcept {
+    _EXPORT_STD _NODISCARD constexpr month_weekday operator/(const weekday_indexed& _Wdi, int _Month) noexcept {
         return month{static_cast<unsigned int>(_Month)} / _Wdi;
     }
-    _NODISCARD constexpr month_weekday_last operator/(const month& _Month, const weekday_last& _Wdl) noexcept {
+    _EXPORT_STD _NODISCARD constexpr month_weekday_last operator/(
+        const month& _Month, const weekday_last& _Wdl) noexcept {
         return {_Month, _Wdl};
     }
-    _NODISCARD constexpr month_weekday_last operator/(int _Month, const weekday_last& _Wdl) noexcept {
+    _EXPORT_STD _NODISCARD constexpr month_weekday_last operator/(int _Month, const weekday_last& _Wdl) noexcept {
         return month{static_cast<unsigned int>(_Month)} / _Wdl;
     }
-    _NODISCARD constexpr month_weekday_last operator/(const weekday_last& _Wdl, const month& _Month) noexcept {
+    _EXPORT_STD _NODISCARD constexpr month_weekday_last operator/(
+        const weekday_last& _Wdl, const month& _Month) noexcept {
         return _Month / _Wdl;
     }
-    _NODISCARD constexpr month_weekday_last operator/(const weekday_last& _Wdl, int _Month) noexcept {
+    _EXPORT_STD _NODISCARD constexpr month_weekday_last operator/(const weekday_last& _Wdl, int _Month) noexcept {
         return month{static_cast<unsigned int>(_Month)} / _Wdl;
     }
-    _NODISCARD constexpr year_month_day operator/(const year_month& _Ym, const day& _Day) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_day operator/(const year_month& _Ym, const day& _Day) noexcept {
         return {_Ym.year(), _Ym.month(), _Day};
     }
-    _NODISCARD constexpr year_month_day operator/(const year_month& _Ym, int _Day) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_day operator/(const year_month& _Ym, int _Day) noexcept {
         return _Ym / day{static_cast<unsigned int>(_Day)};
     }
-    _NODISCARD constexpr year_month_day operator/(const year& _Year, const month_day& _Md) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_day operator/(const year& _Year, const month_day& _Md) noexcept {
         return _Year / _Md.month() / _Md.day();
     }
-    _NODISCARD constexpr year_month_day operator/(int _Year, const month_day& _Md) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_day operator/(int _Year, const month_day& _Md) noexcept {
         return year{_Year} / _Md.month() / _Md.day();
     }
-    _NODISCARD constexpr year_month_day operator/(const month_day& _Md, const year& _Year) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_day operator/(const month_day& _Md, const year& _Year) noexcept {
         return _Year / _Md.month() / _Md.day();
     }
-    _NODISCARD constexpr year_month_day operator/(const month_day& _Md, int _Year) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_day operator/(const month_day& _Md, int _Year) noexcept {
         return year{_Year} / _Md.month() / _Md.day();
     }
-    _NODISCARD constexpr year_month_day_last operator/(const year_month& _Ym, last_spec) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_day_last operator/(const year_month& _Ym, last_spec) noexcept {
         return {_Ym.year(), month_day_last{_Ym.month()}};
     }
-    _NODISCARD constexpr year_month_day_last operator/(const year& _Year, const month_day_last& _Mdl) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_day_last operator/(
+        const year& _Year, const month_day_last& _Mdl) noexcept {
         return {_Year, _Mdl};
     }
-    _NODISCARD constexpr year_month_day_last operator/(int _Year, const month_day_last& _Mdl) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_day_last operator/(int _Year, const month_day_last& _Mdl) noexcept {
         return year{_Year} / _Mdl;
     }
-    _NODISCARD constexpr year_month_day_last operator/(const month_day_last& _Mdl, const year& _Year) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_day_last operator/(
+        const month_day_last& _Mdl, const year& _Year) noexcept {
         return _Year / _Mdl;
     }
-    _NODISCARD constexpr year_month_day_last operator/(const month_day_last& _Mdl, int _Year) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_day_last operator/(const month_day_last& _Mdl, int _Year) noexcept {
         return year{_Year} / _Mdl;
     }
-    _NODISCARD constexpr year_month_weekday operator/(const year_month& _Ym, const weekday_indexed& _Wdi) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday operator/(
+        const year_month& _Ym, const weekday_indexed& _Wdi) noexcept {
         return year_month_weekday{_Ym.year(), _Ym.month(), _Wdi};
     }
-    _NODISCARD constexpr year_month_weekday operator/(const year& _Year, const month_weekday& _Mwd) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday operator/(
+        const year& _Year, const month_weekday& _Mwd) noexcept {
         return year_month_weekday{_Year, _Mwd.month(), _Mwd.weekday_indexed()};
     }
-    _NODISCARD constexpr year_month_weekday operator/(int _Year, const month_weekday& _Mwd) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday operator/(int _Year, const month_weekday& _Mwd) noexcept {
         return year{_Year} / _Mwd;
     }
-    _NODISCARD constexpr year_month_weekday operator/(const month_weekday& _Mwd, const year& _Year) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday operator/(
+        const month_weekday& _Mwd, const year& _Year) noexcept {
         return _Year / _Mwd;
     }
-    _NODISCARD constexpr year_month_weekday operator/(const month_weekday& _Mwd, int _Year) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday operator/(const month_weekday& _Mwd, int _Year) noexcept {
         return year{_Year} / _Mwd;
     }
-    _NODISCARD constexpr year_month_weekday_last operator/(const year_month& _Ym, const weekday_last& _Wdl) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday_last operator/(
+        const year_month& _Ym, const weekday_last& _Wdl) noexcept {
         return {_Ym.year(), _Ym.month(), _Wdl};
     }
-    _NODISCARD constexpr year_month_weekday_last operator/(
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday_last operator/(
         const year& _Year, const month_weekday_last& _Mwdl) noexcept {
         return {_Year, _Mwdl.month(), _Mwdl.weekday_last()};
     }
-    _NODISCARD constexpr year_month_weekday_last operator/(int _Year, const month_weekday_last& _Mwdl) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday_last operator/(
+        int _Year, const month_weekday_last& _Mwdl) noexcept {
         return year{_Year} / _Mwdl;
     }
-    _NODISCARD constexpr year_month_weekday_last operator/(
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday_last operator/(
         const month_weekday_last& _Mwdl, const year& _Year) noexcept {
         return _Year / _Mwdl;
     }
-    _NODISCARD constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, int _Year) noexcept {
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday_last operator/(
+        const month_weekday_last& _Mwdl, int _Year) noexcept {
         return year{_Year} / _Mwdl;
     }
 
     // Calendrical constants
-    inline constexpr weekday Sunday{0};
-    inline constexpr weekday Monday{1};
-    inline constexpr weekday Tuesday{2};
-    inline constexpr weekday Wednesday{3};
-    inline constexpr weekday Thursday{4};
-    inline constexpr weekday Friday{5};
-    inline constexpr weekday Saturday{6};
-
-    inline constexpr month January{1};
-    inline constexpr month February{2};
-    inline constexpr month March{3};
-    inline constexpr month April{4};
-    inline constexpr month May{5};
-    inline constexpr month June{6};
-    inline constexpr month July{7};
-    inline constexpr month August{8};
-    inline constexpr month September{9};
-    inline constexpr month October{10};
-    inline constexpr month November{11};
-    inline constexpr month December{12};
+    _EXPORT_STD inline constexpr weekday Sunday{0};
+    _EXPORT_STD inline constexpr weekday Monday{1};
+    _EXPORT_STD inline constexpr weekday Tuesday{2};
+    _EXPORT_STD inline constexpr weekday Wednesday{3};
+    _EXPORT_STD inline constexpr weekday Thursday{4};
+    _EXPORT_STD inline constexpr weekday Friday{5};
+    _EXPORT_STD inline constexpr weekday Saturday{6};
+
+    _EXPORT_STD inline constexpr month January{1};
+    _EXPORT_STD inline constexpr month February{2};
+    _EXPORT_STD inline constexpr month March{3};
+    _EXPORT_STD inline constexpr month April{4};
+    _EXPORT_STD inline constexpr month May{5};
+    _EXPORT_STD inline constexpr month June{6};
+    _EXPORT_STD inline constexpr month July{7};
+    _EXPORT_STD inline constexpr month August{8};
+    _EXPORT_STD inline constexpr month September{9};
+    _EXPORT_STD inline constexpr month October{10};
+    _EXPORT_STD inline constexpr month November{11};
+    _EXPORT_STD inline constexpr month December{12};
 
     _NODISCARD constexpr intmax_t _Pow10(const unsigned int _Exp) {
         intmax_t _Result = 1;
@@ -1558,7 +1585,7 @@ namespace chrono {
         }
     }
 
-    template <class _Duration>
+    _EXPORT_STD template <class _Duration>
     class hh_mm_ss {
     public:
         static_assert(_Is_duration_v<_Duration>,
@@ -1627,14 +1654,14 @@ namespace chrono {
         precision _Sub_secs;
     };
 
-    _NODISCARD constexpr bool is_am(const hours& _Hours) noexcept {
+    _EXPORT_STD _NODISCARD constexpr bool is_am(const hours& _Hours) noexcept {
         return _Hours >= hours{0} && _Hours <= hours{11};
     }
-    _NODISCARD constexpr bool is_pm(const hours& _Hours) noexcept {
+    _EXPORT_STD _NODISCARD constexpr bool is_pm(const hours& _Hours) noexcept {
         return _Hours >= hours{12} && _Hours <= hours{23};
     }
 
-    _NODISCARD constexpr hours make12(const hours& _Hours) noexcept {
+    _EXPORT_STD _NODISCARD constexpr hours make12(const hours& _Hours) noexcept {
         const auto _H_count{_Hours.count()};
         auto _Ret{_H_count == 0 ? 12 : _H_count};
         if (_Ret > 12) {
@@ -1643,7 +1670,7 @@ namespace chrono {
 
         return hours{_Ret};
     }
-    _NODISCARD constexpr hours make24(const hours& _Hours, bool _Is_pm) noexcept {
+    _EXPORT_STD _NODISCARD constexpr hours make24(const hours& _Hours, bool _Is_pm) noexcept {
         const auto _H_count{_Hours.count()};
         auto _Ret{_H_count == 12 ? 0 : _H_count};
         if (_Is_pm) {
@@ -1655,7 +1682,7 @@ namespace chrono {
 
     // [time.zone.info]
 
-    struct sys_info {
+    _EXPORT_STD struct sys_info {
         sys_seconds begin;
         sys_seconds end;
         seconds offset;
@@ -1663,7 +1690,7 @@ namespace chrono {
         string abbrev;
     };
 
-    struct local_info {
+    _EXPORT_STD struct local_info {
         static constexpr int unique      = 0;
         static constexpr int nonexistent = 1;
         static constexpr int ambiguous   = 2;
@@ -1673,7 +1700,7 @@ namespace chrono {
         sys_info second;
     };
 
-    class nonexistent_local_time : public runtime_error {
+    _EXPORT_STD class nonexistent_local_time : public runtime_error {
     public:
         template <class _Duration>
         nonexistent_local_time(const local_time<_Duration>& _Tp, const local_info& _Info)
@@ -1696,7 +1723,7 @@ namespace chrono {
         _THROW((nonexistent_local_time{_Tp, _Info}));
     }
 
-    class ambiguous_local_time : public runtime_error {
+    _EXPORT_STD class ambiguous_local_time : public runtime_error {
     public:
         template <class _Duration>
         ambiguous_local_time(const local_time<_Duration>& _Tp, const local_info& _Info)
@@ -1721,9 +1748,9 @@ namespace chrono {
 
     // [time.zone.timezone]
 
-    enum class choose { earliest, latest };
+    _EXPORT_STD enum class choose { earliest, latest };
 
-    class time_zone {
+    _EXPORT_STD class time_zone {
     public:
         explicit time_zone(string_view _Name_) : _Name(_Name_) {}
 
@@ -1874,19 +1901,20 @@ namespace chrono {
         string _Name;
     };
 
-    _NODISCARD inline bool operator==(const time_zone& _Left, const time_zone& _Right) noexcept {
+    _EXPORT_STD _NODISCARD inline bool operator==(const time_zone& _Left, const time_zone& _Right) noexcept {
         return _Left.name() == _Right.name();
     }
 
 #ifdef __cpp_lib_concepts
-    _NODISCARD inline strong_ordering operator<=>(const time_zone& _Left, const time_zone& _Right) noexcept {
+    _EXPORT_STD _NODISCARD inline strong_ordering operator<=>(
+        const time_zone& _Left, const time_zone& _Right) noexcept {
         return _Left.name() <=> _Right.name();
     }
 #endif // __cpp_lib_concepts
 
     // [time.zone.leap]
 
-    class leap_second {
+    _EXPORT_STD class leap_second {
     public:
         leap_second(const leap_second&)            = default;
         leap_second& operator=(const leap_second&) = default;
@@ -1919,67 +1947,68 @@ namespace chrono {
         seconds _Elapsed_offset;
     };
 
-    _NODISCARD constexpr bool operator==(const leap_second& _Left, const leap_second& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr bool operator==(const leap_second& _Left, const leap_second& _Right) noexcept {
         return _Left.date() == _Right.date();
     }
-    template <class _Duration>
+    _EXPORT_STD template <class _Duration>
     _NODISCARD constexpr bool operator==(const leap_second& _Left, const sys_time<_Duration>& _Right) noexcept {
         return _Left.date() == _Right;
     }
 
-    template <class _Duration>
+    _EXPORT_STD template <class _Duration>
     _NODISCARD constexpr bool operator<(const leap_second& _Left, const sys_time<_Duration>& _Right) noexcept {
         return _Left.date() < _Right;
     }
-    template <class _Duration>
+    _EXPORT_STD template <class _Duration>
     _NODISCARD constexpr bool operator<(const sys_time<_Duration>& _Left, const leap_second& _Right) noexcept {
         return _Left < _Right.date();
     }
 
-    template <class _Duration>
+    _EXPORT_STD template <class _Duration>
     _NODISCARD constexpr bool operator>(const leap_second& _Left, const sys_time<_Duration>& _Right) noexcept {
         return _Right < _Left.date();
     }
-    template <class _Duration>
+    _EXPORT_STD template <class _Duration>
     _NODISCARD constexpr bool operator>(const sys_time<_Duration>& _Left, const leap_second& _Right) noexcept {
         return _Right.date() < _Left;
     }
 
-    template <class _Duration>
+    _EXPORT_STD template <class _Duration>
     _NODISCARD constexpr bool operator<=(const leap_second& _Left, const sys_time<_Duration>& _Right) noexcept {
         return !(_Right < _Left.date());
     }
-    template <class _Duration>
+    _EXPORT_STD template <class _Duration>
     _NODISCARD constexpr bool operator<=(const sys_time<_Duration>& _Left, const leap_second& _Right) noexcept {
         return !(_Right.date() < _Left);
     }
 
-    template <class _Duration>
+    _EXPORT_STD template <class _Duration>
     _NODISCARD constexpr bool operator>=(const leap_second& _Left, const sys_time<_Duration>& _Right) noexcept {
         return !(_Left.date() < _Right);
     }
-    template <class _Duration>
+    _EXPORT_STD template <class _Duration>
     _NODISCARD constexpr bool operator>=(const sys_time<_Duration>& _Left, const leap_second& _Right) noexcept {
         return !(_Left < _Right.date());
     }
 
 #ifdef __cpp_lib_concepts
     // clang-format off
-    template <class _Duration>
+    _EXPORT_STD template <class _Duration>
         requires three_way_comparable_with<sys_seconds, sys_time<_Duration>>
     _NODISCARD constexpr auto operator<=>(
         const leap_second& _Left, const sys_time<_Duration>& _Right) noexcept {
         // clang-format on
         return _Left.date() <=> _Right;
     }
-    _NODISCARD constexpr strong_ordering operator<=>(const leap_second& _Left, const leap_second& _Right) noexcept {
+    _EXPORT_STD _NODISCARD constexpr strong_ordering operator<=>(
+        const leap_second& _Left, const leap_second& _Right) noexcept {
         return _Left.date() <=> _Right.date();
     }
 #endif // __cpp_lib_concepts
 
     // [time.zone.link]
 
-    class time_zone_link {
+    _EXPORT_STD class time_zone_link {
     public:
         explicit time_zone_link(string_view _Name_, string_view _Target_) : _Name(_Name_), _Target(_Target_) {}
 
@@ -1999,12 +2028,13 @@ namespace chrono {
         string _Target;
     };
 
-    _NODISCARD inline bool operator==(const time_zone_link& _Left, const time_zone_link& _Right) noexcept {
+    _EXPORT_STD _NODISCARD inline bool operator==(const time_zone_link& _Left, const time_zone_link& _Right) noexcept {
         return _Left.name() == _Right.name();
     }
 
 #ifdef __cpp_lib_concepts
-    _NODISCARD inline strong_ordering operator<=>(const time_zone_link& _Left, const time_zone_link& _Right) noexcept {
+    _EXPORT_STD _NODISCARD inline strong_ordering operator<=>(
+        const time_zone_link& _Left, const time_zone_link& _Right) noexcept {
         return _Left.name() <=> _Right.name();
     }
 #endif // __cpp_lib_concepts
@@ -2031,7 +2061,7 @@ namespace chrono {
         return _Result == _Vec.end() ? nullptr : &*_Result;
     }
 
-    struct tzdb {
+    _EXPORT_STD struct tzdb {
         string version;
         vector<time_zone> zones;
         vector<time_zone_link> links;
@@ -2164,7 +2194,7 @@ namespace chrono {
         return _STD move(_Icu_version) + "." + _STD to_string(_Num_leap_seconds);
     }
 
-    class tzdb_list {
+    _EXPORT_STD class tzdb_list {
     private:
         using _ListType = forward_list<tzdb, _Crt_allocator<tzdb>>;
 
@@ -2273,7 +2303,7 @@ namespace chrono {
 
     inline atomic<tzdb_list*> _Global_tzdb_list;
 
-    _NODISCARD inline tzdb_list& get_tzdb_list() {
+    _EXPORT_STD _NODISCARD inline tzdb_list& get_tzdb_list() {
         auto _Tzdb_ptr = _Global_tzdb_list.load();
         if (_Tzdb_ptr != nullptr) {
             return *_Tzdb_ptr;
@@ -2306,19 +2336,19 @@ namespace chrono {
         return *_Tzdb_ptr;
     }
 
-    _NODISCARD inline const tzdb& get_tzdb() {
+    _EXPORT_STD _NODISCARD inline const tzdb& get_tzdb() {
         return _CHRONO get_tzdb_list().front();
     }
 
-    _NODISCARD inline const time_zone* locate_zone(string_view _Tz_name) {
+    _EXPORT_STD _NODISCARD inline const time_zone* locate_zone(string_view _Tz_name) {
         return _CHRONO get_tzdb().locate_zone(_Tz_name);
     }
 
-    _NODISCARD inline const time_zone* current_zone() {
+    _EXPORT_STD _NODISCARD inline const time_zone* current_zone() {
         return _CHRONO get_tzdb().current_zone();
     }
 
-    inline const tzdb& reload_tzdb() {
+    _EXPORT_STD inline const tzdb& reload_tzdb() {
         _TRY_BEGIN
         return _CHRONO get_tzdb_list()._Reload();
         _CATCH(const runtime_error&)
@@ -2330,7 +2360,7 @@ namespace chrono {
         _CATCH_END
     }
 
-    _NODISCARD inline string remote_version() {
+    _EXPORT_STD _NODISCARD inline string remote_version() {
         const auto& _Tzdb                = _CHRONO get_tzdb();
         const auto& _Version             = _Tzdb.version;
         const auto [_Leap_sec, _Ignored] = _Tzdb_generate_leap_seconds(_Tzdb.leap_seconds.size());
@@ -2339,7 +2369,7 @@ namespace chrono {
 
     // [time.zone.zonedtraits]
 
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     struct zoned_traits {};
 
     template <>
@@ -2355,7 +2385,7 @@ namespace chrono {
 
     // [time.zone.zonedtime]
 
-    template <class _Duration, class _TimeZonePtr = const time_zone*>
+    _EXPORT_STD template <class _Duration, class _TimeZonePtr = const time_zone*>
     class zoned_time {
     private:
         static_assert(_Is_duration_v<_Duration>,
@@ -2522,9 +2552,9 @@ namespace chrono {
     zoned_time(_TimeZonePtrOrName&&, zoned_time<_Duration, _TimeZonePtr2>, choose = choose::earliest)
         -> zoned_time<common_type_t<_Duration, seconds>, _Time_zone_representation<_TimeZonePtrOrName>>;
 
-    using zoned_seconds = zoned_time<seconds>;
+    _EXPORT_STD using zoned_seconds = zoned_time<seconds>;
 
-    template <class _Duration1, class _Duration2, class _TimeZonePtr>
+    _EXPORT_STD template <class _Duration1, class _Duration2, class _TimeZonePtr>
     _NODISCARD bool operator==(
         const zoned_time<_Duration1, _TimeZonePtr>& _Left, const zoned_time<_Duration2, _TimeZonePtr>& _Right) {
         return _Left.get_time_zone() == _Right.get_time_zone() && _Left.get_sys_time() == _Right.get_sys_time();
@@ -2532,17 +2562,17 @@ namespace chrono {
 
     // [time.clock.utc]
 
-    class utc_clock;
-    template <class _Duration>
-    using utc_time    = time_point<utc_clock, _Duration>;
-    using utc_seconds = utc_time<seconds>;
+    _EXPORT_STD class utc_clock;
+    _EXPORT_STD template <class _Duration>
+    using utc_time                = time_point<utc_clock, _Duration>;
+    _EXPORT_STD using utc_seconds = utc_time<seconds>;
 
-    struct leap_second_info {
+    _EXPORT_STD struct leap_second_info {
         bool is_leap_second;
         seconds elapsed;
     };
 
-    template <class _Duration>
+    _EXPORT_STD template <class _Duration>
     _NODISCARD leap_second_info get_leap_second_info(const utc_time<_Duration>& _Time) {
         const utc_seconds _Time_floor = _CHRONO floor<seconds>(_Time);
         const auto& _Tzdb             = _CHRONO get_tzdb();
@@ -2615,7 +2645,7 @@ namespace chrono {
         }
     }
 
-    class utc_clock {
+    _EXPORT_STD class utc_clock {
     public:
         using rep                       = system_clock::rep;
         using period                    = system_clock::period;
@@ -2659,13 +2689,13 @@ namespace chrono {
 
     // [time.clock.tai]
 
-    class tai_clock;
+    _EXPORT_STD class tai_clock;
 
-    template <class _Duration>
-    using tai_time    = time_point<tai_clock, _Duration>;
-    using tai_seconds = tai_time<seconds>;
+    _EXPORT_STD template <class _Duration>
+    using tai_time                = time_point<tai_clock, _Duration>;
+    _EXPORT_STD using tai_seconds = tai_time<seconds>;
 
-    class tai_clock {
+    _EXPORT_STD class tai_clock {
     public:
         using rep                       = system_clock::rep;
         using period                    = system_clock::period;
@@ -2694,13 +2724,13 @@ namespace chrono {
 
     // [time.clock.gps]
 
-    class gps_clock;
+    _EXPORT_STD class gps_clock;
 
-    template <class _Duration>
-    using gps_time    = time_point<gps_clock, _Duration>;
-    using gps_seconds = gps_time<seconds>;
+    _EXPORT_STD template <class _Duration>
+    using gps_time                = time_point<gps_clock, _Duration>;
+    _EXPORT_STD using gps_seconds = gps_time<seconds>;
 
-    class gps_clock {
+    _EXPORT_STD class gps_clock {
     public:
         using rep                       = system_clock::rep;
         using period                    = system_clock::period;
@@ -2733,9 +2763,9 @@ namespace filesystem {
 } // namespace filesystem
 
 namespace chrono {
-    using file_clock = filesystem::_File_time_clock;
+    _EXPORT_STD using file_clock = filesystem::_File_time_clock;
 
-    template <class _Duration>
+    _EXPORT_STD template <class _Duration>
     using file_time = time_point<file_clock, _Duration>;
 } // namespace chrono
 #endif // ^^^ _HAS_CXX20
@@ -2801,7 +2831,7 @@ namespace filesystem {
 namespace chrono {
     // [time.clock.conv]
 
-    template <class _DestClock, class _SourceClock>
+    _EXPORT_STD template <class _DestClock, class _SourceClock>
     struct clock_time_conversion {};
 
     // [time.clock.cast.id]
@@ -2988,7 +3018,7 @@ namespace chrono {
     template <class _DestClock, class _SourceClock, class _Duration>
     inline constexpr auto _Clock_cast_choice = _Choose_clock_cast<_DestClock, _SourceClock, _Duration>();
 
-    template <class _DestClock, class _SourceClock, class _Duration,
+    _EXPORT_STD template <class _DestClock, class _SourceClock, class _Duration,
         enable_if_t<_Clock_cast_choice<_DestClock, _SourceClock, _Duration> != _Clock_cast_strategy::_None, int> = 0>
     _NODISCARD auto clock_cast(const time_point<_SourceClock, _Duration>& _Time) {
         constexpr auto _Strat = _Clock_cast_choice<_DestClock, _SourceClock, _Duration>;
@@ -4378,7 +4408,7 @@ namespace chrono {
         }
     };
 
-    template <class _CharT, class _Traits, class _Rep, class _Period, class _Alloc = allocator<_CharT>>
+    _EXPORT_STD template <class _CharT, class _Traits, class _Rep, class _Period, class _Alloc = allocator<_CharT>>
     basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
         duration<_Rep, _Period>& _Duration, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr,
         minutes* _Offset = nullptr) {
@@ -4389,7 +4419,7 @@ namespace chrono {
         return _Istr;
     }
 
-    template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
     basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt, weekday& _Wd,
         basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr, minutes* _Offset = nullptr) {
         _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset};
@@ -4399,7 +4429,7 @@ namespace chrono {
         return _Istr;
     }
 
-    template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
     basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt, day& _Day,
         basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr, minutes* _Offset = nullptr) {
         _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset};
@@ -4409,7 +4439,7 @@ namespace chrono {
         return _Istr;
     }
 
-    template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
     basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
         month& _Month, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr, minutes* _Offset = nullptr) {
         _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset};
@@ -4419,7 +4449,7 @@ namespace chrono {
         return _Istr;
     }
 
-    template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
     basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
         month_day& _Md, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr, minutes* _Offset = nullptr) {
         _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset};
@@ -4429,7 +4459,7 @@ namespace chrono {
         return _Istr;
     }
 
-    template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
     basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt, year& _Year,
         basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr, minutes* _Offset = nullptr) {
         _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset};
@@ -4439,7 +4469,7 @@ namespace chrono {
         return _Istr;
     }
 
-    template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
     basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
         year_month& _Ym, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr, minutes* _Offset = nullptr) {
         _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset};
@@ -4449,7 +4479,7 @@ namespace chrono {
         return _Istr;
     }
 
-    template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
     basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
         year_month_day& _Ymd, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr, minutes* _Offset = nullptr) {
         _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset};
@@ -4459,7 +4489,7 @@ namespace chrono {
         return _Istr;
     }
 
-    template <class _CharT, class _Traits, class _Duration, class _Alloc = allocator<_CharT>>
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration, class _Alloc = allocator<_CharT>>
     basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
         utc_time<_Duration>& _Tp, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr,
         minutes* _Offset = nullptr) {
@@ -4474,7 +4504,7 @@ namespace chrono {
         return _Istr;
     }
 
-    template <class _CharT, class _Traits, class _Duration, class _Alloc = allocator<_CharT>>
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration, class _Alloc = allocator<_CharT>>
     basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
         sys_time<_Duration>& _Tp, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr,
         minutes* _Offset = nullptr) {
@@ -4489,7 +4519,7 @@ namespace chrono {
         return _Istr;
     }
 
-    template <class _CharT, class _Traits, class _Duration, class _Alloc = allocator<_CharT>>
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration, class _Alloc = allocator<_CharT>>
     basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
         tai_time<_Duration>& _Tp, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr,
         minutes* _Offset = nullptr) {
@@ -4504,7 +4534,7 @@ namespace chrono {
         return _Istr;
     }
 
-    template <class _CharT, class _Traits, class _Duration, class _Alloc = allocator<_CharT>>
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration, class _Alloc = allocator<_CharT>>
     basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
         gps_time<_Duration>& _Tp, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr,
         chrono::minutes* _Offset = nullptr) {
@@ -4519,7 +4549,7 @@ namespace chrono {
         return _Istr;
     }
 
-    template <class _CharT, class _Traits, class _Duration, class _Alloc = allocator<_CharT>>
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration, class _Alloc = allocator<_CharT>>
     basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
         file_time<_Duration>& _Tp, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr,
         chrono::minutes* _Offset = nullptr) {
@@ -4536,7 +4566,7 @@ namespace chrono {
         return _Istr;
     }
 
-    template <class _CharT, class _Traits, class _Duration, class _Alloc = allocator<_CharT>>
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration, class _Alloc = allocator<_CharT>>
     basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
         local_time<_Duration>& _Tp, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr,
         minutes* _Offset = nullptr) {
@@ -4599,50 +4629,50 @@ namespace chrono {
                      _STD declval<const _CharT*>(), _STD declval<_Parsable&>(), _STD declval<_Rest>()...)),
             0); // intentional ADL
 
-    template <class _CharT, class _Parsable, _Has_from_stream<_CharT, char_traits<_CharT>, _Parsable> = 0>
+    _EXPORT_STD template <class _CharT, class _Parsable, _Has_from_stream<_CharT, char_traits<_CharT>, _Parsable> = 0>
     _NODISCARD auto parse(const _CharT* _Fmt, _Parsable& _Tp) {
         return _Time_parse_iomanip_c_str<_CharT, char_traits<_CharT>, allocator<_CharT>, _Parsable>{_Fmt, _Tp};
     }
 
-    template <class _CharT, class _Traits, class _Alloc, class _Parsable,
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc, class _Parsable,
         _Has_from_stream<_CharT, _Traits, _Parsable> = 0>
     _NODISCARD auto parse(const basic_string<_CharT, _Traits, _Alloc>& _Fmt, _Parsable& _Tp) {
         return _Time_parse_iomanip{_Fmt, _Tp};
     }
 
-    template <class _CharT, class _Traits, class _Alloc, class _Parsable,
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc, class _Parsable,
         _Has_from_stream<_CharT, _Traits, _Parsable, basic_string<_CharT, _Traits, _Alloc>*> = 0>
     _NODISCARD auto parse(const _CharT* _Fmt, _Parsable& _Tp, basic_string<_CharT, _Traits, _Alloc>& _Abbrev) {
         return _Time_parse_iomanip_c_str{_Fmt, _Tp, _STD addressof(_Abbrev)};
     }
 
-    template <class _CharT, class _Traits, class _Alloc, class _Parsable,
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc, class _Parsable,
         _Has_from_stream<_CharT, _Traits, _Parsable, basic_string<_CharT, _Traits, _Alloc>*> = 0>
     _NODISCARD auto parse(const basic_string<_CharT, _Traits, _Alloc>& _Fmt, _Parsable& _Tp,
         basic_string<_CharT, _Traits, _Alloc>& _Abbrev) {
         return _Time_parse_iomanip{_Fmt, _Tp, _STD addressof(_Abbrev)};
     }
 
-    template <class _CharT, class _Parsable,
+    _EXPORT_STD template <class _CharT, class _Parsable,
         _Has_from_stream<_CharT, char_traits<_CharT>, _Parsable, basic_string<_CharT>*, minutes*> = 0>
     _NODISCARD auto parse(const _CharT* _Fmt, _Parsable& _Tp, minutes& _Offset) {
         return _Time_parse_iomanip_c_str{_Fmt, _Tp, static_cast<basic_string<_CharT>*>(nullptr), &_Offset};
     }
 
-    template <class _CharT, class _Traits, class _Alloc, class _Parsable,
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc, class _Parsable,
         _Has_from_stream<_CharT, _Traits, _Parsable, basic_string<_CharT, _Traits, _Alloc>*, minutes*> = 0>
     _NODISCARD auto parse(const basic_string<_CharT, _Traits, _Alloc>& _Fmt, _Parsable& _Tp, minutes& _Offset) {
         return _Time_parse_iomanip{_Fmt, _Tp, static_cast<basic_string<_CharT, _Traits, _Alloc>*>(nullptr), &_Offset};
     }
 
-    template <class _CharT, class _Traits, class _Alloc, class _Parsable,
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc, class _Parsable,
         _Has_from_stream<_CharT, _Traits, _Parsable, basic_string<_CharT, _Traits, _Alloc>*, minutes*> = 0>
     _NODISCARD auto parse(
         const _CharT* _Fmt, _Parsable& _Tp, basic_string<_CharT, _Traits, _Alloc>& _Abbrev, minutes& _Offset) {
         return _Time_parse_iomanip_c_str{_Fmt, _Tp, _STD addressof(_Abbrev), &_Offset};
     }
 
-    template <class _CharT, class _Traits, class _Alloc, class _Parsable,
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc, class _Parsable,
         _Has_from_stream<_CharT, _Traits, _Parsable, basic_string<_CharT, _Traits, _Alloc>*, minutes*> = 0>
     _NODISCARD auto parse(const basic_string<_CharT, _Traits, _Alloc>& _Fmt, _Parsable& _Tp,
         basic_string<_CharT, _Traits, _Alloc>& _Abbrev, minutes& _Offset) {
@@ -4901,7 +4931,7 @@ namespace chrono {
         }
     };
 
-    template <class _Duration>
+    _EXPORT_STD template <class _Duration>
     _NODISCARD _Local_time_format_t<_Duration> local_time_format(const local_time<_Duration> _Time,
         const string* const _Abbrev = nullptr, const seconds* const _Offset_sec = nullptr) {
         return {_Time, _Abbrev, _Offset_sec};
@@ -4967,7 +4997,7 @@ namespace chrono {
         _Write_seconds(_Os, _Hh_mm_ss_part_underflow_to_zero(_Val));
     }
 
-    template <class _Ty>
+    _EXPORT_STD /* TRANSITION, VSO-1582358 */ template <class _Ty>
     _NODISCARD tm _Fill_tm(const _Ty& _Val) {
         unsigned int _Day   = 0;
         unsigned int _Month = 0;
@@ -5058,33 +5088,33 @@ namespace chrono {
         return _Time;
     }
 
-    template <class _CharT, class _Traits>
+    _EXPORT_STD template <class _CharT, class _Traits>
     basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const day& _Val) {
         return _Os << (_Val.ok() ? _STD format(_STATICALLY_WIDEN(_CharT, "{:%d}"), _Val)
                                  : _STD format(_STATICALLY_WIDEN(_CharT, "{:%d} is not a valid day"), _Val));
     }
 
-    template <class _CharT, class _Traits>
+    _EXPORT_STD template <class _CharT, class _Traits>
     basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const month& _Val) {
         return _Os << (_Val.ok() ? _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L%b}"), _Val)
                                  : _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{} is not a valid month"),
                                      static_cast<unsigned int>(_Val)));
     }
 
-    template <class _CharT, class _Traits>
+    _EXPORT_STD template <class _CharT, class _Traits>
     basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const year& _Val) {
         return _Os << (_Val.ok() ? _STD format(_STATICALLY_WIDEN(_CharT, "{:%Y}"), _Val)
                                  : _STD format(_STATICALLY_WIDEN(_CharT, "{:%Y} is not a valid year"), _Val));
     }
 
-    template <class _CharT, class _Traits>
+    _EXPORT_STD template <class _CharT, class _Traits>
     basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const weekday& _Val) {
         return _Os << (_Val.ok() ? _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L%a}"), _Val)
                                  : _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{} is not a valid weekday"),
                                      _Val.c_encoding()));
     }
 
-    template <class _CharT, class _Traits>
+    _EXPORT_STD template <class _CharT, class _Traits>
     basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const weekday_indexed& _Val) {
         const auto _Idx = _Val.index();
         return _Os << (_Idx >= 1 && _Idx <= 5
@@ -5093,64 +5123,64 @@ namespace chrono {
                                _Val.weekday(), _Idx));
     }
 
-    template <class _CharT, class _Traits>
+    _EXPORT_STD template <class _CharT, class _Traits>
     basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const weekday_last& _Val) {
         return _Os << _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L}[last]"), _Val.weekday());
     }
 
-    template <class _CharT, class _Traits>
+    _EXPORT_STD template <class _CharT, class _Traits>
     basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const month_day& _Val) {
         return _Os << _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L}/{}"), _Val.month(), _Val.day());
     }
 
-    template <class _CharT, class _Traits>
+    _EXPORT_STD template <class _CharT, class _Traits>
     basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const month_day_last& _Val) {
         return _Os << _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L}/last"), _Val.month());
     }
 
-    template <class _CharT, class _Traits>
+    _EXPORT_STD template <class _CharT, class _Traits>
     basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const month_weekday& _Val) {
         return _Os << _STD format(
                    _Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L}/{:L}"), _Val.month(), _Val.weekday_indexed());
     }
 
-    template <class _CharT, class _Traits>
+    _EXPORT_STD template <class _CharT, class _Traits>
     basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const month_weekday_last& _Val) {
         return _Os << _STD format(
                    _Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L}/{:L}"), _Val.month(), _Val.weekday_last());
     }
 
-    template <class _CharT, class _Traits>
+    _EXPORT_STD template <class _CharT, class _Traits>
     basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const year_month& _Val) {
         return _Os << _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{}/{:L}"), _Val.year(), _Val.month());
     }
 
-    template <class _CharT, class _Traits>
+    _EXPORT_STD template <class _CharT, class _Traits>
     basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const year_month_day& _Val) {
         return _Os << (_Val.ok() ? _STD format(_STATICALLY_WIDEN(_CharT, "{:%F}"), _Val)
                                  : _STD format(_STATICALLY_WIDEN(_CharT, "{:%F} is not a valid date"), _Val));
     }
 
-    template <class _CharT, class _Traits>
+    _EXPORT_STD template <class _CharT, class _Traits>
     basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const year_month_day_last& _Val) {
         return _Os << _STD format(
                    _Os.getloc(), _STATICALLY_WIDEN(_CharT, "{}/{:L}"), _Val.year(), _Val.month_day_last());
     }
 
-    template <class _CharT, class _Traits>
+    _EXPORT_STD template <class _CharT, class _Traits>
     basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const year_month_weekday& _Val) {
         return _Os << _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{}/{:L}/{:L}"), _Val.year(), _Val.month(),
                    _Val.weekday_indexed());
     }
 
-    template <class _CharT, class _Traits>
+    _EXPORT_STD template <class _CharT, class _Traits>
     basic_ostream<_CharT, _Traits>& operator<<(
         basic_ostream<_CharT, _Traits>& _Os, const year_month_weekday_last& _Val) {
         return _Os << _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{}/{:L}/{:L}"), _Val.year(), _Val.month(),
                    _Val.weekday_last());
     }
 
-    template <class _CharT, class _Traits, class _Duration>
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration>
     basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const hh_mm_ss<_Duration>& _Val) {
         return _Os << _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L%T}"), _Val);
     }
@@ -5167,14 +5197,14 @@ namespace chrono {
     }
 #pragma warning(pop)
 
-    template <class _CharT, class _Traits>
+    _EXPORT_STD template <class _CharT, class _Traits>
     basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const sys_info& _Val) {
         return _Os << _STD format(_Os.getloc(),
                    _STATICALLY_WIDEN(_CharT, "begin: {}, end: {}, offset: {}, save: {}, abbrev: {}"), //
                    _Val.begin, _Val.end, _Val.offset, _Val.save, _Widen_string<_CharT>(_Val.abbrev));
     }
 
-    template <class _CharT, class _Traits>
+    _EXPORT_STD template <class _CharT, class _Traits>
     basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const local_info& _Val) {
         switch (_Val.result) {
         case local_info::unique:
@@ -5196,7 +5226,7 @@ namespace chrono {
         }
     }
 
-    template <class _CharT, class _Traits, class _Duration>
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration>
         // clang-format off
         requires (!treat_as_floating_point_v<typename _Duration::rep> && _Duration{1} < days{1})
     basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const sys_time<_Duration>& _Val) {
@@ -5204,37 +5234,37 @@ namespace chrono {
         return _Os << _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L%F %T}"), _Val);
     }
 
-    template <class _CharT, class _Traits>
+    _EXPORT_STD template <class _CharT, class _Traits>
     basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const sys_days& _Val) {
         return _Os << year_month_day{_Val};
     }
 
-    template <class _CharT, class _Traits, class _Duration>
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration>
     basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const utc_time<_Duration>& _Val) {
         return _Os << _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L%F %T}"), _Val);
     }
 
-    template <class _CharT, class _Traits, class _Duration>
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration>
     basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const tai_time<_Duration>& _Val) {
         return _Os << _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L%F %T}"), _Val);
     }
 
-    template <class _CharT, class _Traits, class _Duration>
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration>
     basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const gps_time<_Duration>& _Val) {
         return _Os << _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L%F %T}"), _Val);
     }
 
-    template <class _CharT, class _Traits, class _Duration>
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration>
     basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const file_time<_Duration>& _Val) {
         return _Os << _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L%F %T}"), _Val);
     }
 
-    template <class _CharT, class _Traits, class _Duration>
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration>
     basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const local_time<_Duration>& _Val) {
         return _Os << sys_time<_Duration>{_Val.time_since_epoch()};
     }
 
-    template <class _CharT, class _Traits, class _Duration, class _TimeZonePtr>
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration, class _TimeZonePtr>
     basic_ostream<_CharT, _Traits>& operator<<(
         basic_ostream<_CharT, _Traits>& _Os, const zoned_time<_Duration, _TimeZonePtr>& _Val) {
         const auto _Info = _Val.get_info();
@@ -5985,10 +6015,10 @@ namespace chrono {
 
 inline namespace literals {
     inline namespace chrono_literals {
-        _NODISCARD constexpr _CHRONO day operator"" d(unsigned long long _Day) noexcept {
+        _EXPORT_STD _NODISCARD constexpr _CHRONO day operator"" d(unsigned long long _Day) noexcept {
             return _CHRONO day{static_cast<unsigned int>(_Day)};
         }
-        _NODISCARD constexpr _CHRONO year operator"" y(unsigned long long _Year) noexcept {
+        _EXPORT_STD _NODISCARD constexpr _CHRONO year operator"" y(unsigned long long _Year) noexcept {
             return _CHRONO year{static_cast<int>(_Year)};
         }
     } // namespace chrono_literals
diff --git a/stl/inc/cinttypes b/stl/inc/cinttypes
index d1f07e10a5..62a4a3084e 100644
--- a/stl/inc/cinttypes
+++ b/stl/inc/cinttypes
@@ -20,14 +20,14 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-using _CSTD imaxdiv_t; // from <inttypes.h>
-
-using _CSTD imaxabs;
-using _CSTD imaxdiv;
-using _CSTD strtoimax;
-using _CSTD strtoumax;
-using _CSTD wcstoimax;
-using _CSTD wcstoumax;
+_EXPORT_STD using _CSTD imaxdiv_t; // from <inttypes.h>
+
+_EXPORT_STD using _CSTD imaxabs;
+_EXPORT_STD using _CSTD imaxdiv;
+_EXPORT_STD using _CSTD strtoimax;
+_EXPORT_STD using _CSTD strtoumax;
+_EXPORT_STD using _CSTD wcstoimax;
+_EXPORT_STD using _CSTD wcstoumax;
 _STD_END
 
 #pragma pop_macro("new")
diff --git a/stl/inc/clocale b/stl/inc/clocale
index bfc5a0aacf..09844d7ddb 100644
--- a/stl/inc/clocale
+++ b/stl/inc/clocale
@@ -19,9 +19,9 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-using _CSTD lconv;
-using _CSTD localeconv;
-using _CSTD setlocale;
+_EXPORT_STD using _CSTD lconv;
+_EXPORT_STD using _CSTD localeconv;
+_EXPORT_STD using _CSTD setlocale;
 _STD_END
 
 #pragma pop_macro("new")
diff --git a/stl/inc/cmath b/stl/inc/cmath
index 21d8fe1d99..38b6bff4ad 100644
--- a/stl/inc/cmath
+++ b/stl/inc/cmath
@@ -708,199 +708,203 @@ _GENERIC_MATH2(fmin)
 
 
 _STD_BEGIN
-using _CSTD abs;
-using _CSTD acos;
-using _CSTD asin;
-using _CSTD atan;
-using _CSTD atan2;
-using _CSTD ceil;
-using _CSTD cos;
-using _CSTD cosh;
-using _CSTD exp;
-using _CSTD fabs;
-using _CSTD floor;
-using _CSTD fmod;
-using _CSTD frexp;
-using _CSTD ldexp;
-using _CSTD log;
-using _CSTD log10;
-using _CSTD modf;
-using _CSTD pow;
-using _CSTD sin;
-using _CSTD sinh;
-using _CSTD sqrt;
-using _CSTD tan;
-using _CSTD tanh;
-
-using _CSTD acosf;
-using _CSTD asinf;
-using _CSTD atanf;
-using _CSTD atan2f;
-using _CSTD ceilf;
-using _CSTD cosf;
-using _CSTD coshf;
-using _CSTD expf;
-using _CSTD fabsf;
-using _CSTD floorf;
-using _CSTD fmodf;
-using _CSTD frexpf;
-using _CSTD ldexpf;
-using _CSTD logf;
-using _CSTD log10f;
-using _CSTD modff;
-using _CSTD powf;
-using _CSTD sinf;
-using _CSTD sinhf;
-using _CSTD sqrtf;
-using _CSTD tanf;
-using _CSTD tanhf;
-
-using _CSTD acosl;
-using _CSTD asinl;
-using _CSTD atanl;
-using _CSTD atan2l;
-using _CSTD ceill;
-using _CSTD cosl;
-using _CSTD coshl;
-using _CSTD expl;
-using _CSTD fabsl;
-using _CSTD floorl;
-using _CSTD fmodl;
-using _CSTD frexpl;
-using _CSTD ldexpl;
-using _CSTD logl;
-using _CSTD log10l;
-using _CSTD modfl;
-using _CSTD powl;
-using _CSTD sinl;
-using _CSTD sinhl;
-using _CSTD sqrtl;
-using _CSTD tanl;
-using _CSTD tanhl;
-
-using _CSTD float_t;
-using _CSTD double_t;
-
-using _CSTD acosh;
-using _CSTD asinh;
-using _CSTD atanh;
-using _CSTD cbrt;
-using _CSTD erf;
-using _CSTD erfc;
-using _CSTD expm1;
-using _CSTD exp2;
-using _CSTD hypot;
-using _CSTD ilogb;
-using _CSTD lgamma;
-using _CSTD log1p;
-using _CSTD log2;
-using _CSTD logb;
-using _CSTD llrint;
-using _CSTD lrint;
-using _CSTD nearbyint;
-using _CSTD rint;
-using _CSTD llround;
-using _CSTD lround;
-using _CSTD fdim;
-using _CSTD fma;
-using _CSTD fmax;
-using _CSTD fmin;
-using _CSTD round;
-using _CSTD trunc;
-using _CSTD remainder;
-using _CSTD remquo;
-using _CSTD copysign;
-using _CSTD nan;
-using _CSTD nextafter;
-using _CSTD scalbn;
-using _CSTD scalbln;
-using _CSTD nexttoward;
-using _CSTD tgamma;
-
-using _CSTD acoshf;
-using _CSTD asinhf;
-using _CSTD atanhf;
-using _CSTD cbrtf;
-using _CSTD erff;
-using _CSTD erfcf;
-using _CSTD expm1f;
-using _CSTD exp2f;
-using _CSTD hypotf;
-using _CSTD ilogbf;
-using _CSTD lgammaf;
-using _CSTD log1pf;
-using _CSTD log2f;
-using _CSTD logbf;
-using _CSTD llrintf;
-using _CSTD lrintf;
-using _CSTD nearbyintf;
-using _CSTD rintf;
-using _CSTD llroundf;
-using _CSTD lroundf;
-using _CSTD fdimf;
-using _CSTD fmaf;
-using _CSTD fmaxf;
-using _CSTD fminf;
-using _CSTD roundf;
-using _CSTD truncf;
-using _CSTD remainderf;
-using _CSTD remquof;
-using _CSTD copysignf;
-using _CSTD nanf;
-using _CSTD nextafterf;
-using _CSTD scalbnf;
-using _CSTD scalblnf;
-using _CSTD nexttowardf;
-using _CSTD tgammaf;
-
-using _CSTD acoshl;
-using _CSTD asinhl;
-using _CSTD atanhl;
-using _CSTD cbrtl;
-using _CSTD erfl;
-using _CSTD erfcl;
-using _CSTD expm1l;
-using _CSTD exp2l;
-using _CSTD hypotl;
-using _CSTD ilogbl;
-using _CSTD lgammal;
-using _CSTD log1pl;
-using _CSTD log2l;
-using _CSTD logbl;
-using _CSTD llrintl;
-using _CSTD lrintl;
-using _CSTD nearbyintl;
-using _CSTD rintl;
-using _CSTD llroundl;
-using _CSTD lroundl;
-using _CSTD fdiml;
-using _CSTD fmal;
-using _CSTD fmaxl;
-using _CSTD fminl;
-using _CSTD roundl;
-using _CSTD truncl;
-using _CSTD remainderl;
-using _CSTD remquol;
-using _CSTD copysignl;
-using _CSTD nanl;
-using _CSTD nextafterl;
-using _CSTD scalbnl;
-using _CSTD scalblnl;
-using _CSTD nexttowardl;
-using _CSTD tgammal;
-
-using _CSTD fpclassify;
-using _CSTD signbit;
-using _CSTD isfinite;
-using _CSTD isinf;
-using _CSTD isnan;
-using _CSTD isnormal;
-using _CSTD isgreater;
-using _CSTD isgreaterequal;
-using _CSTD isless;
-using _CSTD islessequal;
-using _CSTD islessgreater;
-using _CSTD isunordered;
+_EXPORT_STD using _CSTD abs;
+_EXPORT_STD using _CSTD acos;
+_EXPORT_STD using _CSTD asin;
+_EXPORT_STD using _CSTD atan;
+_EXPORT_STD using _CSTD atan2;
+_EXPORT_STD using _CSTD ceil;
+_EXPORT_STD using _CSTD cos;
+_EXPORT_STD using _CSTD cosh;
+_EXPORT_STD using _CSTD exp;
+_EXPORT_STD using _CSTD fabs;
+_EXPORT_STD using _CSTD floor;
+_EXPORT_STD using _CSTD fmod;
+_EXPORT_STD using _CSTD frexp;
+_EXPORT_STD using _CSTD ldexp;
+_EXPORT_STD using _CSTD log;
+_EXPORT_STD using _CSTD log10;
+_EXPORT_STD using _CSTD modf;
+_EXPORT_STD using _CSTD pow;
+_EXPORT_STD using _CSTD sin;
+_EXPORT_STD using _CSTD sinh;
+_EXPORT_STD using _CSTD sqrt;
+_EXPORT_STD using _CSTD tan;
+_EXPORT_STD using _CSTD tanh;
+
+_EXPORT_STD using _CSTD acosf;
+_EXPORT_STD using _CSTD asinf;
+_EXPORT_STD using _CSTD atanf;
+_EXPORT_STD using _CSTD atan2f;
+_EXPORT_STD using _CSTD ceilf;
+_EXPORT_STD using _CSTD cosf;
+_EXPORT_STD using _CSTD coshf;
+_EXPORT_STD using _CSTD expf;
+_EXPORT_STD using _CSTD fabsf;
+_EXPORT_STD using _CSTD floorf;
+_EXPORT_STD using _CSTD fmodf;
+_EXPORT_STD using _CSTD frexpf;
+_EXPORT_STD using _CSTD ldexpf;
+_EXPORT_STD using _CSTD logf;
+_EXPORT_STD using _CSTD log10f;
+_EXPORT_STD using _CSTD modff;
+_EXPORT_STD using _CSTD powf;
+_EXPORT_STD using _CSTD sinf;
+_EXPORT_STD using _CSTD sinhf;
+_EXPORT_STD using _CSTD sqrtf;
+_EXPORT_STD using _CSTD tanf;
+_EXPORT_STD using _CSTD tanhf;
+
+_EXPORT_STD using _CSTD acosl;
+_EXPORT_STD using _CSTD asinl;
+_EXPORT_STD using _CSTD atanl;
+_EXPORT_STD using _CSTD atan2l;
+_EXPORT_STD using _CSTD ceill;
+_EXPORT_STD using _CSTD cosl;
+_EXPORT_STD using _CSTD coshl;
+_EXPORT_STD using _CSTD expl;
+_EXPORT_STD using _CSTD fabsl;
+_EXPORT_STD using _CSTD floorl;
+_EXPORT_STD using _CSTD fmodl;
+_EXPORT_STD using _CSTD frexpl;
+_EXPORT_STD using _CSTD ldexpl;
+_EXPORT_STD using _CSTD logl;
+_EXPORT_STD using _CSTD log10l;
+_EXPORT_STD using _CSTD modfl;
+_EXPORT_STD using _CSTD powl;
+_EXPORT_STD using _CSTD sinl;
+_EXPORT_STD using _CSTD sinhl;
+_EXPORT_STD using _CSTD sqrtl;
+_EXPORT_STD using _CSTD tanl;
+_EXPORT_STD using _CSTD tanhl;
+
+_EXPORT_STD using _CSTD float_t;
+_EXPORT_STD using _CSTD double_t;
+
+_EXPORT_STD using _CSTD acosh;
+_EXPORT_STD using _CSTD asinh;
+_EXPORT_STD using _CSTD atanh;
+_EXPORT_STD using _CSTD cbrt;
+_EXPORT_STD using _CSTD erf;
+_EXPORT_STD using _CSTD erfc;
+_EXPORT_STD using _CSTD expm1;
+_EXPORT_STD using _CSTD exp2;
+
+inline namespace _Binary_hypot {
+    _EXPORT_STD using _CSTD hypot;
+} // namespace _Binary_hypot
+
+_EXPORT_STD using _CSTD ilogb;
+_EXPORT_STD using _CSTD lgamma;
+_EXPORT_STD using _CSTD log1p;
+_EXPORT_STD using _CSTD log2;
+_EXPORT_STD using _CSTD logb;
+_EXPORT_STD using _CSTD llrint;
+_EXPORT_STD using _CSTD lrint;
+_EXPORT_STD using _CSTD nearbyint;
+_EXPORT_STD using _CSTD rint;
+_EXPORT_STD using _CSTD llround;
+_EXPORT_STD using _CSTD lround;
+_EXPORT_STD using _CSTD fdim;
+_EXPORT_STD using _CSTD fma;
+_EXPORT_STD using _CSTD fmax;
+_EXPORT_STD using _CSTD fmin;
+_EXPORT_STD using _CSTD round;
+_EXPORT_STD using _CSTD trunc;
+_EXPORT_STD using _CSTD remainder;
+_EXPORT_STD using _CSTD remquo;
+_EXPORT_STD using _CSTD copysign;
+_EXPORT_STD using _CSTD nan;
+_EXPORT_STD using _CSTD nextafter;
+_EXPORT_STD using _CSTD scalbn;
+_EXPORT_STD using _CSTD scalbln;
+_EXPORT_STD using _CSTD nexttoward;
+_EXPORT_STD using _CSTD tgamma;
+
+_EXPORT_STD using _CSTD acoshf;
+_EXPORT_STD using _CSTD asinhf;
+_EXPORT_STD using _CSTD atanhf;
+_EXPORT_STD using _CSTD cbrtf;
+_EXPORT_STD using _CSTD erff;
+_EXPORT_STD using _CSTD erfcf;
+_EXPORT_STD using _CSTD expm1f;
+_EXPORT_STD using _CSTD exp2f;
+_EXPORT_STD using _CSTD hypotf;
+_EXPORT_STD using _CSTD ilogbf;
+_EXPORT_STD using _CSTD lgammaf;
+_EXPORT_STD using _CSTD log1pf;
+_EXPORT_STD using _CSTD log2f;
+_EXPORT_STD using _CSTD logbf;
+_EXPORT_STD using _CSTD llrintf;
+_EXPORT_STD using _CSTD lrintf;
+_EXPORT_STD using _CSTD nearbyintf;
+_EXPORT_STD using _CSTD rintf;
+_EXPORT_STD using _CSTD llroundf;
+_EXPORT_STD using _CSTD lroundf;
+_EXPORT_STD using _CSTD fdimf;
+_EXPORT_STD using _CSTD fmaf;
+_EXPORT_STD using _CSTD fmaxf;
+_EXPORT_STD using _CSTD fminf;
+_EXPORT_STD using _CSTD roundf;
+_EXPORT_STD using _CSTD truncf;
+_EXPORT_STD using _CSTD remainderf;
+_EXPORT_STD using _CSTD remquof;
+_EXPORT_STD using _CSTD copysignf;
+_EXPORT_STD using _CSTD nanf;
+_EXPORT_STD using _CSTD nextafterf;
+_EXPORT_STD using _CSTD scalbnf;
+_EXPORT_STD using _CSTD scalblnf;
+_EXPORT_STD using _CSTD nexttowardf;
+_EXPORT_STD using _CSTD tgammaf;
+
+_EXPORT_STD using _CSTD acoshl;
+_EXPORT_STD using _CSTD asinhl;
+_EXPORT_STD using _CSTD atanhl;
+_EXPORT_STD using _CSTD cbrtl;
+_EXPORT_STD using _CSTD erfl;
+_EXPORT_STD using _CSTD erfcl;
+_EXPORT_STD using _CSTD expm1l;
+_EXPORT_STD using _CSTD exp2l;
+_EXPORT_STD using _CSTD hypotl;
+_EXPORT_STD using _CSTD ilogbl;
+_EXPORT_STD using _CSTD lgammal;
+_EXPORT_STD using _CSTD log1pl;
+_EXPORT_STD using _CSTD log2l;
+_EXPORT_STD using _CSTD logbl;
+_EXPORT_STD using _CSTD llrintl;
+_EXPORT_STD using _CSTD lrintl;
+_EXPORT_STD using _CSTD nearbyintl;
+_EXPORT_STD using _CSTD rintl;
+_EXPORT_STD using _CSTD llroundl;
+_EXPORT_STD using _CSTD lroundl;
+_EXPORT_STD using _CSTD fdiml;
+_EXPORT_STD using _CSTD fmal;
+_EXPORT_STD using _CSTD fmaxl;
+_EXPORT_STD using _CSTD fminl;
+_EXPORT_STD using _CSTD roundl;
+_EXPORT_STD using _CSTD truncl;
+_EXPORT_STD using _CSTD remainderl;
+_EXPORT_STD using _CSTD remquol;
+_EXPORT_STD using _CSTD copysignl;
+_EXPORT_STD using _CSTD nanl;
+_EXPORT_STD using _CSTD nextafterl;
+_EXPORT_STD using _CSTD scalbnl;
+_EXPORT_STD using _CSTD scalblnl;
+_EXPORT_STD using _CSTD nexttowardl;
+_EXPORT_STD using _CSTD tgammal;
+
+_EXPORT_STD using _CSTD fpclassify;
+_EXPORT_STD using _CSTD signbit;
+_EXPORT_STD using _CSTD isfinite;
+_EXPORT_STD using _CSTD isinf;
+_EXPORT_STD using _CSTD isnan;
+_EXPORT_STD using _CSTD isnormal;
+_EXPORT_STD using _CSTD isgreater;
+_EXPORT_STD using _CSTD isgreaterequal;
+_EXPORT_STD using _CSTD isless;
+_EXPORT_STD using _CSTD islessequal;
+_EXPORT_STD using _CSTD islessgreater;
+_EXPORT_STD using _CSTD isunordered;
 _STD_END
 
 #if _HAS_CXX17
@@ -952,280 +956,293 @@ _NODISCARD _CRT_SATELLITE_2 float __stdcall __std_smf_hypot3f(float, float, floa
 _END_EXTERN_C
 
 _STD_BEGIN
-_NODISCARD inline double assoc_laguerre(
+_EXPORT_STD _NODISCARD inline double assoc_laguerre(
     const unsigned int _Degree, const unsigned int _Order, const double _Value) noexcept /* strengthened */ {
     return __std_smf_assoc_laguerre(_Degree, _Order, _Value);
 }
 
-_NODISCARD inline float assoc_laguerref(
+_EXPORT_STD _NODISCARD inline float assoc_laguerref(
     const unsigned int _Degree, const unsigned int _Order, const float _Value) noexcept /* strengthened */ {
     return __std_smf_assoc_laguerref(_Degree, _Order, _Value);
 }
 
-_NODISCARD inline long double assoc_laguerrel(
+_EXPORT_STD _NODISCARD inline long double assoc_laguerrel(
     const unsigned int _Degree, const unsigned int _Order, const long double _Value) noexcept /* strengthened */ {
     return __std_smf_assoc_laguerre(_Degree, _Order, static_cast<double>(_Value));
 }
 
-_NODISCARD inline double assoc_legendre(
+_EXPORT_STD _NODISCARD inline double assoc_legendre(
     const unsigned int _Degree, const unsigned int _Order, const double _Value) noexcept /* strengthened */ {
     return __std_smf_assoc_legendre(_Degree, _Order, _Value);
 }
 
-_NODISCARD inline float assoc_legendref(
+_EXPORT_STD _NODISCARD inline float assoc_legendref(
     const unsigned int _Degree, const unsigned int _Order, const float _Value) noexcept /* strengthened */ {
     return __std_smf_assoc_legendref(_Degree, _Order, _Value);
 }
 
-_NODISCARD inline long double assoc_legendrel(
+_EXPORT_STD _NODISCARD inline long double assoc_legendrel(
     const unsigned int _Degree, const unsigned int _Order, const long double _Value) noexcept /* strengthened */ {
     return __std_smf_assoc_legendre(_Degree, _Order, static_cast<double>(_Value));
 }
 
-_NODISCARD inline double beta(const double _Arg1, const double _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline double beta(const double _Arg1, const double _Arg2) noexcept /* strengthened */ {
     return __std_smf_beta(_Arg1, _Arg2);
 }
 
-_NODISCARD inline float betaf(const float _Arg1, const float _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline float betaf(const float _Arg1, const float _Arg2) noexcept /* strengthened */ {
     return __std_smf_betaf(_Arg1, _Arg2);
 }
 
-_NODISCARD inline long double betal(const long double _Arg1, const long double _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline long double betal(const long double _Arg1, const long double _Arg2) noexcept
+/* strengthened */ {
     return __std_smf_beta(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
 }
 
-_NODISCARD inline double comp_ellint_1(const double _Arg) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline double comp_ellint_1(const double _Arg) noexcept /* strengthened */ {
     return __std_smf_comp_ellint_1(_Arg);
 }
 
-_NODISCARD inline float comp_ellint_1f(const float _Arg) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline float comp_ellint_1f(const float _Arg) noexcept /* strengthened */ {
     return __std_smf_comp_ellint_1f(_Arg);
 }
 
-_NODISCARD inline long double comp_ellint_1l(const long double _Arg) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline long double comp_ellint_1l(const long double _Arg) noexcept /* strengthened */ {
     return __std_smf_comp_ellint_1(static_cast<double>(_Arg));
 }
 
-_NODISCARD inline double comp_ellint_2(const double _Arg) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline double comp_ellint_2(const double _Arg) noexcept /* strengthened */ {
     return __std_smf_comp_ellint_2(_Arg);
 }
 
-_NODISCARD inline float comp_ellint_2f(const float _Arg) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline float comp_ellint_2f(const float _Arg) noexcept /* strengthened */ {
     return __std_smf_comp_ellint_2f(_Arg);
 }
 
-_NODISCARD inline long double comp_ellint_2l(const long double _Arg) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline long double comp_ellint_2l(const long double _Arg) noexcept /* strengthened */ {
     return __std_smf_comp_ellint_2(static_cast<double>(_Arg));
 }
 
-_NODISCARD inline double comp_ellint_3(const double _Arg1, const double _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline double comp_ellint_3(const double _Arg1, const double _Arg2) noexcept /* strengthened */ {
     return __std_smf_comp_ellint_3(_Arg1, _Arg2);
 }
 
-_NODISCARD inline float comp_ellint_3f(const float _Arg1, const float _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline float comp_ellint_3f(const float _Arg1, const float _Arg2) noexcept /* strengthened */ {
     return __std_smf_comp_ellint_3f(_Arg1, _Arg2);
 }
 
-_NODISCARD inline long double comp_ellint_3l(const long double _Arg1, const long double _Arg2) noexcept
+_EXPORT_STD _NODISCARD inline long double comp_ellint_3l(const long double _Arg1, const long double _Arg2) noexcept
 /* strengthened */ {
     return __std_smf_comp_ellint_3(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
 }
 
-_NODISCARD inline double cyl_bessel_i(const double _Arg1, const double _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline double cyl_bessel_i(const double _Arg1, const double _Arg2) noexcept /* strengthened */ {
     return __std_smf_cyl_bessel_i(_Arg1, _Arg2);
 }
 
-_NODISCARD inline float cyl_bessel_if(const float _Arg1, const float _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline float cyl_bessel_if(const float _Arg1, const float _Arg2) noexcept /* strengthened */ {
     return __std_smf_cyl_bessel_if(_Arg1, _Arg2);
 }
 
-_NODISCARD inline long double cyl_bessel_il(const long double _Arg1, const long double _Arg2) noexcept
+_EXPORT_STD _NODISCARD inline long double cyl_bessel_il(const long double _Arg1, const long double _Arg2) noexcept
 /* strengthened */ {
     return __std_smf_cyl_bessel_i(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
 }
 
-_NODISCARD inline double cyl_bessel_j(const double _Arg1, const double _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline double cyl_bessel_j(const double _Arg1, const double _Arg2) noexcept /* strengthened */ {
     return __std_smf_cyl_bessel_j(_Arg1, _Arg2);
 }
 
-_NODISCARD inline float cyl_bessel_jf(const float _Arg1, const float _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline float cyl_bessel_jf(const float _Arg1, const float _Arg2) noexcept /* strengthened */ {
     return __std_smf_cyl_bessel_jf(_Arg1, _Arg2);
 }
 
-_NODISCARD inline long double cyl_bessel_jl(const long double _Arg1, const long double _Arg2) noexcept
+_EXPORT_STD _NODISCARD inline long double cyl_bessel_jl(const long double _Arg1, const long double _Arg2) noexcept
 /* strengthened */ {
     return __std_smf_cyl_bessel_j(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
 }
 
-_NODISCARD inline double cyl_bessel_k(const double _Arg1, const double _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline double cyl_bessel_k(const double _Arg1, const double _Arg2) noexcept /* strengthened */ {
     return __std_smf_cyl_bessel_k(_Arg1, _Arg2);
 }
 
-_NODISCARD inline float cyl_bessel_kf(const float _Arg1, const float _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline float cyl_bessel_kf(const float _Arg1, const float _Arg2) noexcept /* strengthened */ {
     return __std_smf_cyl_bessel_kf(_Arg1, _Arg2);
 }
 
-_NODISCARD inline long double cyl_bessel_kl(const long double _Arg1, const long double _Arg2) noexcept
+_EXPORT_STD _NODISCARD inline long double cyl_bessel_kl(const long double _Arg1, const long double _Arg2) noexcept
 /* strengthened */ {
     return __std_smf_cyl_bessel_k(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
 }
 
-_NODISCARD inline double cyl_neumann(const double _Arg1, const double _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline double cyl_neumann(const double _Arg1, const double _Arg2) noexcept /* strengthened */ {
     return __std_smf_cyl_neumann(_Arg1, _Arg2);
 }
 
-_NODISCARD inline float cyl_neumannf(const float _Arg1, const float _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline float cyl_neumannf(const float _Arg1, const float _Arg2) noexcept /* strengthened */ {
     return __std_smf_cyl_neumannf(_Arg1, _Arg2);
 }
 
-_NODISCARD inline long double cyl_neumannl(const long double _Arg1, const long double _Arg2) noexcept
+_EXPORT_STD _NODISCARD inline long double cyl_neumannl(const long double _Arg1, const long double _Arg2) noexcept
 /* strengthened */ {
     return __std_smf_cyl_neumann(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
 }
 
-_NODISCARD inline double ellint_1(const double _Arg1, const double _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline double ellint_1(const double _Arg1, const double _Arg2) noexcept /* strengthened */ {
     return __std_smf_ellint_1(_Arg1, _Arg2);
 }
 
-_NODISCARD inline float ellint_1f(const float _Arg1, const float _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline float ellint_1f(const float _Arg1, const float _Arg2) noexcept /* strengthened */ {
     return __std_smf_ellint_1f(_Arg1, _Arg2);
 }
 
-_NODISCARD inline long double ellint_1l(const long double _Arg1, const long double _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline long double ellint_1l(const long double _Arg1, const long double _Arg2) noexcept
+/* strengthened */ {
     return __std_smf_ellint_1(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
 }
 
-_NODISCARD inline double ellint_2(const double _Arg1, const double _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline double ellint_2(const double _Arg1, const double _Arg2) noexcept /* strengthened */ {
     return __std_smf_ellint_2(_Arg1, _Arg2);
 }
 
-_NODISCARD inline float ellint_2f(const float _Arg1, const float _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline float ellint_2f(const float _Arg1, const float _Arg2) noexcept /* strengthened */ {
     return __std_smf_ellint_2f(_Arg1, _Arg2);
 }
 
-_NODISCARD inline long double ellint_2l(const long double _Arg1, const long double _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline long double ellint_2l(const long double _Arg1, const long double _Arg2) noexcept
+/* strengthened */ {
     return __std_smf_ellint_2(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
 }
 
-_NODISCARD inline double ellint_3(const double _Arg1, const double _Arg2, const double _Arg3) noexcept
+_EXPORT_STD _NODISCARD inline double ellint_3(const double _Arg1, const double _Arg2, const double _Arg3) noexcept
 /* strengthened */ {
     return __std_smf_ellint_3(_Arg1, _Arg2, _Arg3);
 }
 
-_NODISCARD inline float ellint_3f(const float _Arg1, const float _Arg2, const float _Arg3) noexcept
+_EXPORT_STD _NODISCARD inline float ellint_3f(const float _Arg1, const float _Arg2, const float _Arg3) noexcept
 /* strengthened */ {
     return __std_smf_ellint_3f(_Arg1, _Arg2, _Arg3);
 }
 
-_NODISCARD inline long double ellint_3l(
+_EXPORT_STD _NODISCARD inline long double ellint_3l(
     const long double _Arg1, const long double _Arg2, const long double _Arg3) noexcept /* strengthened */ {
     return __std_smf_ellint_3(static_cast<double>(_Arg1), static_cast<double>(_Arg2), static_cast<double>(_Arg3));
 }
 
-_NODISCARD inline double expint(const double _Arg) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline double expint(const double _Arg) noexcept /* strengthened */ {
     return __std_smf_expint(_Arg);
 }
 
-_NODISCARD inline float expintf(const float _Arg) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline float expintf(const float _Arg) noexcept /* strengthened */ {
     return __std_smf_expintf(_Arg);
 }
 
-_NODISCARD inline long double expintl(const long double _Arg) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline long double expintl(const long double _Arg) noexcept /* strengthened */ {
     return __std_smf_expint(static_cast<double>(_Arg));
 }
 
-_NODISCARD inline double hermite(const unsigned int _Arg1, const double _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline double hermite(const unsigned int _Arg1, const double _Arg2) noexcept /* strengthened */ {
     return __std_smf_hermite(_Arg1, _Arg2);
 }
 
-_NODISCARD inline float hermitef(const unsigned int _Arg1, const float _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline float hermitef(const unsigned int _Arg1, const float _Arg2) noexcept /* strengthened */ {
     return __std_smf_hermitef(_Arg1, _Arg2);
 }
 
-_NODISCARD inline long double hermitel(const unsigned int _Arg1, const long double _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline long double hermitel(const unsigned int _Arg1, const long double _Arg2) noexcept
+/* strengthened */ {
     return __std_smf_hermite(_Arg1, static_cast<double>(_Arg2));
 }
 
-_NODISCARD inline double laguerre(const unsigned int _Arg1, const double _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline double laguerre(const unsigned int _Arg1, const double _Arg2) noexcept
+/* strengthened */ {
     return __std_smf_laguerre(_Arg1, _Arg2);
 }
 
-_NODISCARD inline float laguerref(const unsigned int _Arg1, const float _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline float laguerref(const unsigned int _Arg1, const float _Arg2) noexcept /* strengthened */ {
     return __std_smf_laguerref(_Arg1, _Arg2);
 }
 
-_NODISCARD inline long double laguerrel(const unsigned int _Arg1, const long double _Arg2) noexcept
+_EXPORT_STD _NODISCARD inline long double laguerrel(const unsigned int _Arg1, const long double _Arg2) noexcept
 /* strengthened */ {
     return __std_smf_laguerre(_Arg1, static_cast<double>(_Arg2));
 }
 
-_NODISCARD inline double legendre(const unsigned int _Degree, const double _Value) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline double legendre(const unsigned int _Degree, const double _Value) noexcept
+/* strengthened */ {
     return __std_smf_legendre(_Degree, _Value);
 }
 
-_NODISCARD inline float legendref(const unsigned int _Degree, const float _Value) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline float legendref(const unsigned int _Degree, const float _Value) noexcept
+/* strengthened */ {
     return __std_smf_legendref(_Degree, _Value);
 }
 
-_NODISCARD inline long double legendrel(const unsigned int _Degree, const long double _Value) noexcept
+_EXPORT_STD _NODISCARD inline long double legendrel(const unsigned int _Degree, const long double _Value) noexcept
 /* strengthened */ {
     return __std_smf_legendre(_Degree, static_cast<double>(_Value));
 }
 
-_NODISCARD inline double riemann_zeta(const double _Arg) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline double riemann_zeta(const double _Arg) noexcept /* strengthened */ {
     return __std_smf_riemann_zeta(_Arg);
 }
-_NODISCARD inline float riemann_zetaf(const float _Arg) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline float riemann_zetaf(const float _Arg) noexcept /* strengthened */ {
     return __std_smf_riemann_zetaf(_Arg);
 }
 
-_NODISCARD inline long double riemann_zetal(const long double _Arg) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline long double riemann_zetal(const long double _Arg) noexcept /* strengthened */ {
     return __std_smf_riemann_zeta(static_cast<double>(_Arg));
 }
 
-_NODISCARD inline double sph_bessel(const unsigned int _Arg1, const double _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline double sph_bessel(const unsigned int _Arg1, const double _Arg2) noexcept
+/* strengthened */ {
     return __std_smf_sph_bessel(_Arg1, _Arg2);
 }
 
-_NODISCARD inline float sph_besself(const unsigned int _Arg1, const float _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline float sph_besself(const unsigned int _Arg1, const float _Arg2) noexcept
+/* strengthened */ {
     return __std_smf_sph_besself(_Arg1, _Arg2);
 }
 
-_NODISCARD inline long double sph_bessell(const unsigned int _Arg1, const long double _Arg2) noexcept
+_EXPORT_STD _NODISCARD inline long double sph_bessell(const unsigned int _Arg1, const long double _Arg2) noexcept
 /* strengthened */ {
     return __std_smf_sph_bessel(_Arg1, static_cast<double>(_Arg2));
 }
 
-_NODISCARD inline double sph_legendre(const unsigned int _Arg1, const unsigned int _Arg2, const double _Theta) noexcept
+_EXPORT_STD _NODISCARD inline double sph_legendre(
+    const unsigned int _Arg1, const unsigned int _Arg2, const double _Theta) noexcept
 /* strengthened */ {
     return __std_smf_sph_legendre(_Arg1, _Arg2, _Theta);
 }
 
-_NODISCARD inline float sph_legendref(const unsigned int _Arg1, const unsigned int _Arg2, const float _Theta) noexcept
+_EXPORT_STD _NODISCARD inline float sph_legendref(
+    const unsigned int _Arg1, const unsigned int _Arg2, const float _Theta) noexcept
 /* strengthened */ {
     return __std_smf_sph_legendref(_Arg1, _Arg2, _Theta);
 }
 
-_NODISCARD inline long double sph_legendrel(
+_EXPORT_STD _NODISCARD inline long double sph_legendrel(
     const unsigned int _Arg1, const unsigned int _Arg2, const long double _Theta) noexcept /* strengthened */ {
     return __std_smf_sph_legendre(_Arg1, _Arg2, static_cast<double>(_Theta));
 }
 
-_NODISCARD inline double sph_neumann(const unsigned int _Arg1, const double _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline double sph_neumann(const unsigned int _Arg1, const double _Arg2) noexcept
+/* strengthened */ {
     return __std_smf_sph_neumann(_Arg1, _Arg2);
 }
 
-_NODISCARD inline float sph_neumannf(const unsigned int _Arg1, const float _Arg2) noexcept /* strengthened */ {
+_EXPORT_STD _NODISCARD inline float sph_neumannf(const unsigned int _Arg1, const float _Arg2) noexcept
+/* strengthened */ {
     return __std_smf_sph_neumannf(_Arg1, _Arg2);
 }
 
-_NODISCARD inline long double sph_neumannl(const unsigned int _Arg1, const long double _Arg2) noexcept
+_EXPORT_STD _NODISCARD inline long double sph_neumannl(const unsigned int _Arg1, const long double _Arg2) noexcept
 /* strengthened */ {
     return __std_smf_sph_neumann(_Arg1, static_cast<double>(_Arg2));
 }
 
 #define _GENERIC_MATH_SPECIAL1(NAME)                                                  \
-    template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>                  \
+    _EXPORT_STD template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>      \
     _NODISCARD auto NAME(const _Ty _Arg) noexcept /* strengthened */ {                \
         using _Common = conditional_t<is_integral_v<_Ty>, double, _Ty>;               \
         if constexpr (is_same_v<_Common, float>) {                                    \
@@ -1236,7 +1253,8 @@ _NODISCARD inline long double sph_neumannl(const unsigned int _Arg1, const long
     }
 
 #define _GENERIC_MATH_SPECIAL2(NAME)                                                                               \
-    template <class _Ty1, class _Ty2, enable_if_t<is_arithmetic_v<_Ty1> && is_arithmetic_v<_Ty2>, int> = 0>        \
+    _EXPORT_STD template <class _Ty1, class _Ty2,                                                                  \
+        enable_if_t<is_arithmetic_v<_Ty1> && is_arithmetic_v<_Ty2>, int> = 0>                                      \
     _NODISCARD auto NAME(const _Ty1 _Arg1, const _Ty2 _Arg2) noexcept /* strengthened */ {                         \
         using _Common = _Common_float_type_t<_Ty1, _Ty2>;                                                          \
         if constexpr (is_same_v<_Common, float>) {                                                                 \
@@ -1247,7 +1265,7 @@ _NODISCARD inline long double sph_neumannl(const unsigned int _Arg1, const long
     }
 
 #define _GENERIC_MATH_SPECIAL3(NAME)                                                                                   \
-    template <class _Ty1, class _Ty2, class _Ty3,                                                                      \
+    _EXPORT_STD template <class _Ty1, class _Ty2, class _Ty3,                                                          \
         enable_if_t<is_arithmetic_v<_Ty1> && is_arithmetic_v<_Ty2> && is_arithmetic_v<_Ty3>, int> = 0>                 \
     _NODISCARD auto NAME(const _Ty1 _Arg1, const _Ty2 _Arg2, const _Ty3 _Arg3) noexcept /* strengthened */ {           \
         using _Common = _Common_float_type_t<_Ty1, _Common_float_type_t<_Ty2, _Ty3>>;                                  \
@@ -1260,7 +1278,7 @@ _NODISCARD inline long double sph_neumannl(const unsigned int _Arg1, const long
     }
 
 #define _GENERIC_MATH_SPECIAL_UINT1(NAME)                                                         \
-    template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>                              \
+    _EXPORT_STD template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>                  \
     _NODISCARD auto NAME(const unsigned int _Arg1, const _Ty _Arg2) noexcept /* strengthened */ { \
         using _Common = conditional_t<is_integral_v<_Ty>, double, _Ty>;                           \
         if constexpr (is_same_v<_Common, float>) {                                                \
@@ -1271,7 +1289,7 @@ _NODISCARD inline long double sph_neumannl(const unsigned int _Arg1, const long
     }
 
 #define _GENERIC_MATH_SPECIAL_UINT2(NAME)                                                                  \
-    template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>                                       \
+    _EXPORT_STD template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>                           \
     _NODISCARD auto NAME(                                                                                  \
         const unsigned int _Arg1, const unsigned int _Arg2, const _Ty _Arg3) noexcept /* strengthened */ { \
         using _Common = conditional_t<is_integral_v<_Ty>, double, _Ty>;                                    \
@@ -1311,19 +1329,19 @@ _GENERIC_MATH_SPECIAL_UINT1(sph_neumann)
 #undef _GENERIC_MATH_SPECIAL_UINT1
 #undef _GENERIC_MATH_SPECIAL_UINT2
 
-_NODISCARD inline double hypot(const double _Dx, const double _Dy, const double _Dz) {
+_EXPORT_STD _NODISCARD inline double hypot(const double _Dx, const double _Dy, const double _Dz) {
     return __std_smf_hypot3(_Dx, _Dy, _Dz);
 }
 
-_NODISCARD inline float hypot(const float _Dx, const float _Dy, const float _Dz) {
+_EXPORT_STD _NODISCARD inline float hypot(const float _Dx, const float _Dy, const float _Dz) {
     return __std_smf_hypot3f(_Dx, _Dy, _Dz);
 }
 
-_NODISCARD inline long double hypot(const long double _Dx, const long double _Dy, const long double _Dz) {
+_EXPORT_STD _NODISCARD inline long double hypot(const long double _Dx, const long double _Dy, const long double _Dz) {
     return __std_smf_hypot3(static_cast<double>(_Dx), static_cast<double>(_Dy), static_cast<double>(_Dz));
 }
 
-template <class _Ty1, class _Ty2, class _Ty3,
+_EXPORT_STD template <class _Ty1, class _Ty2, class _Ty3,
     enable_if_t<is_arithmetic_v<_Ty1> && is_arithmetic_v<_Ty2> && is_arithmetic_v<_Ty3>, int> = 0>
 _NODISCARD auto hypot(const _Ty1 _Dx, const _Ty2 _Dy, const _Ty3 _Dz) {
     // N4910 [cmath.syn]/2 "Sufficient additional overloads"
@@ -1436,20 +1454,21 @@ _NODISCARD constexpr _Ty _Common_lerp(const _Ty _ArgA, const _Ty _ArgB, const _T
     }
 }
 
-_NODISCARD constexpr inline float lerp(const float _ArgA, const float _ArgB, const float _ArgT) noexcept {
+_EXPORT_STD _NODISCARD constexpr inline float lerp(const float _ArgA, const float _ArgB, const float _ArgT) noexcept {
     return _Common_lerp(_ArgA, _ArgB, _ArgT);
 }
 
-_NODISCARD constexpr inline double lerp(const double _ArgA, const double _ArgB, const double _ArgT) noexcept {
+_EXPORT_STD _NODISCARD constexpr inline double lerp(
+    const double _ArgA, const double _ArgB, const double _ArgT) noexcept {
     return _Common_lerp(_ArgA, _ArgB, _ArgT);
 }
 
-_NODISCARD constexpr inline long double lerp(
+_EXPORT_STD _NODISCARD constexpr inline long double lerp(
     const long double _ArgA, const long double _ArgB, const long double _ArgT) noexcept {
     return _Common_lerp(_ArgA, _ArgB, _ArgT);
 }
 
-template <class _Ty1, class _Ty2, class _Ty3,
+_EXPORT_STD template <class _Ty1, class _Ty2, class _Ty3,
     enable_if_t<is_arithmetic_v<_Ty1> && is_arithmetic_v<_Ty2> && is_arithmetic_v<_Ty3>, int> = 0>
 _NODISCARD constexpr auto lerp(const _Ty1 _ArgA, const _Ty2 _ArgB, const _Ty3 _ArgT) noexcept {
     using _Tgt = conditional_t<_Is_any_of_v<long double, _Ty1, _Ty2, _Ty3>, long double, double>;
diff --git a/stl/inc/codecvt b/stl/inc/codecvt
index 8534566026..b62004e707 100644
--- a/stl/inc/codecvt
+++ b/stl/inc/codecvt
@@ -22,12 +22,16 @@ _STD_BEGIN
 _INLINE_VAR constexpr int _Little_first = 1;
 _INLINE_VAR constexpr int _Big_first    = 2;
 
-enum _CXX17_DEPRECATE_CODECVT_HEADER codecvt_mode { consume_header = 4, generate_header = 2, little_endian = 1 };
+_EXPORT_STD enum _CXX17_DEPRECATE_CODECVT_HEADER codecvt_mode {
+    consume_header  = 4,
+    generate_header = 2,
+    little_endian   = 1
+};
 
 using _Statype = _CSTD mbstate_t;
 
 _STL_DISABLE_DEPRECATED_WARNING
-template <class _Elem, unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = codecvt_mode{}>
+_EXPORT_STD template <class _Elem, unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = codecvt_mode{}>
 class _CXX17_DEPRECATE_CODECVT_HEADER codecvt_utf8 : public codecvt<_Elem, char, _Statype> {
     // facet for converting between _Elem and UTF-8 byte sequences
 public:
@@ -218,7 +222,7 @@ protected:
     }
 };
 
-template <class _Elem, unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = codecvt_mode{}>
+_EXPORT_STD template <class _Elem, unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = codecvt_mode{}>
 class _CXX17_DEPRECATE_CODECVT_HEADER codecvt_utf16 : public codecvt<_Elem, char, _Statype> {
     // facet for converting between _Elem and UTF-16 multibyte sequences
 private:
@@ -435,7 +439,7 @@ protected:
     }
 };
 
-template <class _Elem, unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = codecvt_mode{}>
+_EXPORT_STD template <class _Elem, unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = codecvt_mode{}>
 class _CXX17_DEPRECATE_CODECVT_HEADER codecvt_utf8_utf16
     : public codecvt<_Elem, char, _Statype> { // facet for converting between UTF-16 _Elem and UTF-8 byte sequences
 public:
diff --git a/stl/inc/compare b/stl/inc/compare
index 96aa6d382b..feb5aafe97 100644
--- a/stl/inc/compare
+++ b/stl/inc/compare
@@ -35,7 +35,7 @@ enum class _Compare_eq : _Compare_t { equal = 0, equivalent = equal };
 enum class _Compare_ord : _Compare_t { less = -1, greater = 1 };
 enum class _Compare_ncmp : _Compare_t { unordered = -128 };
 
-struct partial_ordering {
+_EXPORT_STD struct partial_ordering {
     static const partial_ordering less;
     static const partial_ordering equivalent;
     static const partial_ordering greater;
@@ -101,7 +101,7 @@ inline constexpr partial_ordering partial_ordering::equivalent{static_cast<_Comp
 inline constexpr partial_ordering partial_ordering::greater{static_cast<_Compare_t>(_Compare_ord::greater)};
 inline constexpr partial_ordering partial_ordering::unordered{static_cast<_Compare_t>(_Compare_ncmp::unordered)};
 
-struct weak_ordering {
+_EXPORT_STD struct weak_ordering {
     static const weak_ordering less;
     static const weak_ordering equivalent;
     static const weak_ordering greater;
@@ -163,7 +163,7 @@ inline constexpr weak_ordering weak_ordering::less{static_cast<_Compare_t>(_Comp
 inline constexpr weak_ordering weak_ordering::equivalent{static_cast<_Compare_t>(_Compare_eq::equivalent)};
 inline constexpr weak_ordering weak_ordering::greater{static_cast<_Compare_t>(_Compare_ord::greater)};
 
-struct strong_ordering {
+_EXPORT_STD struct strong_ordering {
     static const strong_ordering less;
     static const strong_ordering equal;
     static const strong_ordering equivalent;
@@ -231,27 +231,27 @@ inline constexpr strong_ordering strong_ordering::equal{static_cast<_Compare_t>(
 inline constexpr strong_ordering strong_ordering::equivalent{static_cast<_Compare_t>(_Compare_eq::equivalent)};
 inline constexpr strong_ordering strong_ordering::greater{static_cast<_Compare_t>(_Compare_ord::greater)};
 
-_NODISCARD constexpr bool is_eq(const partial_ordering _Comp) noexcept {
+_EXPORT_STD _NODISCARD constexpr bool is_eq(const partial_ordering _Comp) noexcept {
     return _Comp == 0;
 }
 
-_NODISCARD constexpr bool is_neq(const partial_ordering _Comp) noexcept {
+_EXPORT_STD _NODISCARD constexpr bool is_neq(const partial_ordering _Comp) noexcept {
     return _Comp != 0;
 }
 
-_NODISCARD constexpr bool is_lt(const partial_ordering _Comp) noexcept {
+_EXPORT_STD _NODISCARD constexpr bool is_lt(const partial_ordering _Comp) noexcept {
     return _Comp < 0;
 }
 
-_NODISCARD constexpr bool is_lteq(const partial_ordering _Comp) noexcept {
+_EXPORT_STD _NODISCARD constexpr bool is_lteq(const partial_ordering _Comp) noexcept {
     return _Comp <= 0;
 }
 
-_NODISCARD constexpr bool is_gt(const partial_ordering _Comp) noexcept {
+_EXPORT_STD _NODISCARD constexpr bool is_gt(const partial_ordering _Comp) noexcept {
     return _Comp > 0;
 }
 
-_NODISCARD constexpr bool is_gteq(const partial_ordering _Comp) noexcept {
+_EXPORT_STD _NODISCARD constexpr bool is_gteq(const partial_ordering _Comp) noexcept {
     return _Comp >= 0;
 }
 
@@ -274,14 +274,14 @@ inline constexpr unsigned char _Classify_category<weak_ordering> = _Comparison_c
 template <>
 inline constexpr unsigned char _Classify_category<strong_ordering> = _Comparison_category_strong;
 
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
 using common_comparison_category_t =
     conditional_t<(_Classify_category<_Types...> & _Comparison_category_none) != 0, void,
         conditional_t<(_Classify_category<_Types...> & _Comparison_category_partial) != 0, partial_ordering,
             conditional_t<(_Classify_category<_Types...> & _Comparison_category_weak) != 0, weak_ordering,
                 strong_ordering>>>;
 
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
 struct common_comparison_category {
     using type = common_comparison_category_t<_Types...>;
 };
@@ -291,13 +291,13 @@ struct common_comparison_category {
 template <class _Ty, class _Cat>
 concept _Compares_as = same_as<common_comparison_category_t<_Ty, _Cat>, _Cat>;
 
-template <class _Ty, class _Cat = partial_ordering>
+_EXPORT_STD template <class _Ty, class _Cat = partial_ordering>
 concept three_way_comparable = _Half_equality_comparable<_Ty, _Ty> && _Half_ordered<_Ty, _Ty>
     && requires(const remove_reference_t<_Ty>& __a, const remove_reference_t<_Ty>& __b) {
         { __a <=> __b } -> _Compares_as<_Cat>;
     };
 
-template <class _Ty1, class _Ty2, class _Cat = partial_ordering>
+_EXPORT_STD template <class _Ty1, class _Ty2, class _Cat = partial_ordering>
 concept three_way_comparable_with = three_way_comparable<_Ty1, _Cat> && three_way_comparable<_Ty2, _Cat>
     && common_reference_with<const remove_reference_t<_Ty1>&, const remove_reference_t<_Ty2>&>
     && three_way_comparable<common_reference_t<const remove_reference_t<_Ty1>&, const remove_reference_t<_Ty2>&>, _Cat>
@@ -307,11 +307,11 @@ concept three_way_comparable_with = three_way_comparable<_Ty1, _Cat> && three_wa
         { __u <=> __t } -> _Compares_as<_Cat>;
     };
 
-template <class _Ty1, class _Ty2 = _Ty1>
+_EXPORT_STD template <class _Ty1, class _Ty2 = _Ty1>
 using compare_three_way_result_t =
     decltype(_STD declval<const remove_reference_t<_Ty1>&>() <=> _STD declval<const remove_reference_t<_Ty2>&>());
 
-template <class _Ty1, class _Ty2 = _Ty1>
+_EXPORT_STD template <class _Ty1, class _Ty2 = _Ty1>
 struct compare_three_way_result {};
 
 template <class _Ty1, class _Ty2>
@@ -320,7 +320,7 @@ struct compare_three_way_result<_Ty1, _Ty2> {
     using type = compare_three_way_result_t<_Ty1, _Ty2>;
 };
 
-struct compare_three_way {
+_EXPORT_STD struct compare_three_way {
     template <class _Ty1, class _Ty2>
         requires three_way_comparable_with<_Ty1, _Ty2>
     _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
@@ -453,7 +453,7 @@ namespace _Strong_order {
 } // namespace _Strong_order
 
 inline namespace _Cpos {
-    inline constexpr _Strong_order::_Cpo strong_order;
+    _EXPORT_STD inline constexpr _Strong_order::_Cpo strong_order;
 }
 
 namespace _Weak_order {
@@ -573,7 +573,7 @@ namespace _Weak_order {
 } // namespace _Weak_order
 
 inline namespace _Cpos {
-    inline constexpr _Weak_order::_Cpo weak_order;
+    _EXPORT_STD inline constexpr _Weak_order::_Cpo weak_order;
 }
 
 namespace _Partial_order {
@@ -650,7 +650,7 @@ namespace _Partial_order {
 } // namespace _Partial_order
 
 inline namespace _Cpos {
-    inline constexpr _Partial_order::_Cpo partial_order;
+    _EXPORT_STD inline constexpr _Partial_order::_Cpo partial_order;
 }
 
 template <class _Ty1, class _Ty2>
@@ -710,7 +710,7 @@ namespace _Compare_strong_order_fallback {
 } // namespace _Compare_strong_order_fallback
 
 inline namespace _Cpos {
-    inline constexpr _Compare_strong_order_fallback::_Cpo compare_strong_order_fallback;
+    _EXPORT_STD inline constexpr _Compare_strong_order_fallback::_Cpo compare_strong_order_fallback;
 }
 
 template <class _Ty1, class _Ty2>
@@ -764,7 +764,7 @@ namespace _Compare_weak_order_fallback {
 } // namespace _Compare_weak_order_fallback
 
 inline namespace _Cpos {
-    inline constexpr _Compare_weak_order_fallback::_Cpo compare_weak_order_fallback;
+    _EXPORT_STD inline constexpr _Compare_weak_order_fallback::_Cpo compare_weak_order_fallback;
 }
 
 template <class _Ty1, class _Ty2>
@@ -827,7 +827,7 @@ namespace _Compare_partial_order_fallback {
 } // namespace _Compare_partial_order_fallback
 
 inline namespace _Cpos {
-    inline constexpr _Compare_partial_order_fallback::_Cpo compare_partial_order_fallback;
+    _EXPORT_STD inline constexpr _Compare_partial_order_fallback::_Cpo compare_partial_order_fallback;
 }
 
 #endif // __cpp_lib_concepts
diff --git a/stl/inc/complex b/stl/inc/complex
index d104cac919..42b2e32354 100644
--- a/stl/inc/complex
+++ b/stl/inc/complex
@@ -348,7 +348,7 @@ using _Dcomplex_value = _CSTD _C_double_complex;
 using _Fcomplex_value = _CSTD _C_float_complex;
 using _Lcomplex_value = _CSTD _C_ldouble_complex;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class complex;
 template <>
 class complex<float>;
@@ -1294,7 +1294,7 @@ constexpr complex<long double>::complex(const complex<float>& _Right)
 constexpr complex<long double>::complex(const complex<double>& _Right)
     : _Complex_base<long double, _Lcomplex_value>(_Right.real(), _Right.imag()) {}
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class complex : public _Complex_base<_Ty, _Complex_value<_Ty>> {
 public:
     using _Mybase = _Complex_base<_Ty, _Complex_value<_Ty>>;
@@ -1386,106 +1386,106 @@ public:
     }
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _CONSTEXPR20 complex<_Ty> operator+(const complex<_Ty>& _Left, const complex<_Ty>& _Right) {
     complex<_Ty> _Tmp(_Left);
     _Tmp += _Right;
     return _Tmp;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _CONSTEXPR20 complex<_Ty> operator+(const complex<_Ty>& _Left, const _Ty& _Right) {
     complex<_Ty> _Tmp(_Left);
     _Tmp += _Right;
     return _Tmp;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _CONSTEXPR20 complex<_Ty> operator+(const _Ty& _Left, const complex<_Ty>& _Right) {
     complex<_Ty> _Tmp(_Right);
     _Tmp += _Left;
     return _Tmp;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _CONSTEXPR20 complex<_Ty> operator-(const complex<_Ty>& _Left, const complex<_Ty>& _Right) {
     complex<_Ty> _Tmp(_Left);
     _Tmp -= _Right;
     return _Tmp;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _CONSTEXPR20 complex<_Ty> operator-(const complex<_Ty>& _Left, const _Ty& _Right) {
     complex<_Ty> _Tmp(_Left);
     _Tmp -= _Right;
     return _Tmp;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _CONSTEXPR20 complex<_Ty> operator-(const _Ty& _Left, const complex<_Ty>& _Right) {
     complex<_Ty> _Tmp(_Left);
     _Tmp -= _Right;
     return _Tmp;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _CONSTEXPR20 complex<_Ty> operator*(const complex<_Ty>& _Left, const complex<_Ty>& _Right) {
     complex<_Ty> _Tmp(_Left);
     _Tmp *= _Right;
     return _Tmp;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _CONSTEXPR20 complex<_Ty> operator*(const complex<_Ty>& _Left, const _Ty& _Right) {
     complex<_Ty> _Tmp(_Left);
     _Tmp *= _Right;
     return _Tmp;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _CONSTEXPR20 complex<_Ty> operator*(const _Ty& _Left, const complex<_Ty>& _Right) {
     complex<_Ty> _Tmp(_Right);
     _Tmp *= _Left;
     return _Tmp;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _CONSTEXPR20 complex<_Ty> operator/(const complex<_Ty>& _Left, const complex<_Ty>& _Right) {
     complex<_Ty> _Tmp(_Left);
     _Tmp /= _Right;
     return _Tmp;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _CONSTEXPR20 complex<_Ty> operator/(const complex<_Ty>& _Left, const _Ty& _Right) {
     complex<_Ty> _Tmp(_Left);
     _Tmp /= _Right;
     return _Tmp;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _CONSTEXPR20 complex<_Ty> operator/(const _Ty& _Left, const complex<_Ty>& _Right) {
     complex<_Ty> _Tmp(_Left);
     _Tmp /= _Right;
     return _Tmp;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _CONSTEXPR20 complex<_Ty> operator+(const complex<_Ty>& _Left) {
     return _Left;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _CONSTEXPR20 complex<_Ty> operator-(const complex<_Ty>& _Left) {
     return complex<_Ty>(-_Left.real(), -_Left.imag());
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD constexpr bool operator==(const complex<_Ty>& _Left, const complex<_Ty>& _Right) {
     return _Left.real() == _Right.real() && _Left.imag() == _Right.imag();
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD constexpr bool operator==(const complex<_Ty>& _Left, const _Ty& _Right) {
     return _Left.real() == _Right && _Left.imag() == 0;
 }
@@ -1512,25 +1512,25 @@ _NODISCARD constexpr bool operator!=(const _Ty& _Left, const complex<_Ty>& _Righ
 }
 #endif // !_HAS_CXX20
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD constexpr _Ty imag(const complex<_Ty>& _Left) {
     return _Left.imag();
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD constexpr _Ty real(const complex<_Ty>& _Left) {
     return _Left.real();
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD complex<_Ty> sqrt(const complex<_Ty>& _Left);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Ty abs(const complex<_Ty>& _Left) {
     return _Ctraits<_Ty>::hypot(_Left.real(), _Left.imag());
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD complex<_Ty> acos(const complex<_Ty>& _Left) {
     const _Ty _Arcbig = static_cast<_Ty>(0.25) * _Ctraits<_Ty>::sqrt(_Ctraits<_Ty>::_Flt_max());
     constexpr _Ty _Pi = static_cast<_Ty>(3.1415926535897932384626433832795029L);
@@ -1597,7 +1597,7 @@ _NODISCARD complex<_Ty> acos(const complex<_Ty>& _Left) {
     return complex<_Ty>(_Ux, _Vx);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD complex<_Ty> acosh(const complex<_Ty>& _Left) {
     const _Ty _Arcbig = static_cast<_Ty>(0.25) * _Ctraits<_Ty>::sqrt(_Ctraits<_Ty>::_Flt_max());
     constexpr _Ty _Pi = static_cast<_Ty>(3.1415926535897932384626433832795029L);
@@ -1667,7 +1667,7 @@ _NODISCARD complex<_Ty> acosh(const complex<_Ty>& _Left) {
     return complex<_Ty>(_Ux, _Vx);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD complex<_Ty> asinh(const complex<_Ty>& _Left) {
     const _Ty _Arcbig = static_cast<_Ty>(0.25) * _Ctraits<_Ty>::sqrt(_Ctraits<_Ty>::_Flt_max());
     constexpr _Ty _Pi = static_cast<_Ty>(3.1415926535897932384626433832795029L);
@@ -1732,14 +1732,14 @@ _NODISCARD complex<_Ty> asinh(const complex<_Ty>& _Left) {
     return complex<_Ty>(_Ux, _Vx);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD complex<_Ty> asin(const complex<_Ty>& _Left) {
     complex<_Ty> _Asinh = _STD asinh(complex<_Ty>(-imag(_Left), real(_Left)));
 
     return complex<_Ty>(imag(_Asinh), -real(_Asinh));
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD complex<_Ty> atanh(const complex<_Ty>& _Left) {
     const _Ty _Arcbig    = static_cast<_Ty>(0.25) * _Ctraits<_Ty>::sqrt(_Ctraits<_Ty>::_Flt_max());
     constexpr _Ty _Piby2 = static_cast<_Ty>(1.5707963267948966192313216916397514L);
@@ -1791,14 +1791,14 @@ _NODISCARD complex<_Ty> atanh(const complex<_Ty>& _Left) {
     return complex<_Ty>(_Ux, _Vx);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD complex<_Ty> atan(const complex<_Ty>& _Left) {
     complex<_Ty> _Atanh = _STD atanh(complex<_Ty>(-imag(_Left), real(_Left)));
 
     return complex<_Ty>(imag(_Atanh), -real(_Atanh));
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD complex<_Ty> cosh(const complex<_Ty>& _Left) {
     return complex<_Ty>(_Ctraits<_Ty>::_Cosh(real(_Left), _Ctraits<_Ty>::cos(imag(_Left))),
         _Ctraits<_Ty>::_Sinh(real(_Left), _Ctraits<_Ty>::sin(imag(_Left))));
@@ -1820,7 +1820,7 @@ _NODISCARD complex<_Ty> _Polar_positive_nan_inf_zero_rho(const _Ty& _Rho, const
     }
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD complex<_Ty> exp(const complex<_Ty>& _Left) {
     const _Ty _Log_rho = _STD real(_Left);
     const _Ty _Theta   = _STD imag(_Left);
@@ -1921,7 +1921,7 @@ _NODISCARD inline float _Log_abs(const complex<float>& _Left) noexcept {
     return _Math_algorithms::_Log_hypot(_STD real(_Left), _STD imag(_Left));
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD complex<_Ty> log(const complex<_Ty>& _Left) {
     const _Ty _Log_abs_v = _Log_abs(_Left); // get logarithm of magnitude
     const _Ty _Theta     = _Ctraits<_Ty>::atan2(_STD imag(_Left), _STD real(_Left)); // get phase
@@ -1937,7 +1937,7 @@ complex<_Ty> _Pow(const _Ty& _Left, const _Ty& _Right) {
     }
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD complex<_Ty> pow(const complex<_Ty>& _Left, const _Ty& _Right) {
     if (imag(_Left) == 0) {
         if (_Ctraits<_Ty>::_Signbit(imag(_Left))) {
@@ -1950,7 +1950,7 @@ _NODISCARD complex<_Ty> pow(const complex<_Ty>& _Left, const _Ty& _Right) {
     }
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD complex<_Ty> pow(const _Ty& _Left, const complex<_Ty>& _Right) {
     if (imag(_Right) == 0) {
         return _Pow(_Left, real(_Right));
@@ -1961,7 +1961,7 @@ _NODISCARD complex<_Ty> pow(const _Ty& _Left, const complex<_Ty>& _Right) {
     }
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD complex<_Ty> pow(const complex<_Ty>& _Left, const complex<_Ty>& _Right) {
     if (imag(_Right) == 0) {
         return pow(_Left, real(_Right));
@@ -1972,13 +1972,13 @@ _NODISCARD complex<_Ty> pow(const complex<_Ty>& _Left, const complex<_Ty>& _Righ
     }
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD complex<_Ty> sinh(const complex<_Ty>& _Left) {
     return complex<_Ty>(_Ctraits<_Ty>::_Sinh(real(_Left), _Ctraits<_Ty>::cos(imag(_Left))),
         _Ctraits<_Ty>::_Cosh(real(_Left), _Ctraits<_Ty>::sin(imag(_Left))));
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD complex<_Ty> sqrt(const complex<_Ty>& _Left) {
     int _Leftexp;
     _Ty _Rho = _Fabs(_Left, &_Leftexp); // get magnitude and scale factor
@@ -2022,7 +2022,7 @@ _NODISCARD complex<_Ty> sqrt(const complex<_Ty>& _Left) {
     }
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD complex<_Ty> tanh(const complex<_Ty>& _Left) {
     _Ty _Tv = _Ctraits<_Ty>::tan(imag(_Left));
     _Ty _Sv = _Ctraits<_Ty>::_Sinh(real(_Left), _Ty{1});
@@ -2044,17 +2044,17 @@ _NODISCARD complex<_Ty> tanh(const complex<_Ty>& _Left) {
     return complex<_Ty>((_Ctraits<_Ty>::sqrt(_Ty{1} + _Sv * _Sv)) * _Bv / _Dv, _Tv / _Dv);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Ty arg(const complex<_Ty>& _Left) { // return phase angle of complex as real
     return _Ctraits<_Ty>::atan2(imag(_Left), real(_Left));
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _CONSTEXPR20 complex<_Ty> conj(const complex<_Ty>& _Left) { // return complex conjugate
     return complex<_Ty>(real(_Left), -imag(_Left));
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD complex<_Ty> proj(const complex<_Ty>& _Left) { // return complex projection
     if (_Ctraits<_Ty>::_Isinf(real(_Left)) || _Ctraits<_Ty>::_Isinf(imag(_Left))) {
         const _Ty _Imag = _Ctraits<_Ty>::_Copysign(_Ty{0}, imag(_Left));
@@ -2064,23 +2064,23 @@ _NODISCARD complex<_Ty> proj(const complex<_Ty>& _Left) { // return complex proj
     return _Left;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD complex<_Ty> cos(const complex<_Ty>& _Left) {
     return complex<_Ty>(_Ctraits<_Ty>::_Cosh(imag(_Left), _Ctraits<_Ty>::cos(real(_Left))),
         -_Ctraits<_Ty>::_Sinh(imag(_Left), _Ctraits<_Ty>::sin(real(_Left))));
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD complex<_Ty> log10(const complex<_Ty>& _Left) {
     return log(_Left) * static_cast<_Ty>(0.43429448190325182765112891891660508L);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _CONSTEXPR20 _Ty norm(const complex<_Ty>& _Left) { // return squared magnitude
     return real(_Left) * real(_Left) + imag(_Left) * imag(_Left);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD complex<_Ty> polar(const _Ty& _Rho, const _Ty& _Theta) { // return _Rho * exp(i * _Theta) as complex
     if (!_Ctraits<_Ty>::_Isnan(_Rho) && !_Ctraits<_Ty>::_Isinf(_Rho) && _Rho != _Ty{0}) { // _Rho is finite non-zero
         return complex<_Ty>(_Rho * _Ctraits<_Ty>::cos(_Theta), _Rho * _Ctraits<_Ty>::sin(_Theta));
@@ -2094,18 +2094,18 @@ _NODISCARD complex<_Ty> polar(const _Ty& _Rho, const _Ty& _Theta) { // return _R
     }
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD complex<_Ty> polar(const _Ty& _Rho) { // return _Rho * exp(i * 0) as complex
     return complex<_Ty>(_Rho, _Ty{0});
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD complex<_Ty> sin(const complex<_Ty>& _Left) {
     return complex<_Ty>(_Ctraits<_Ty>::_Cosh(imag(_Left), _Ctraits<_Ty>::sin(real(_Left))),
         _Ctraits<_Ty>::_Sinh(imag(_Left), _Ctraits<_Ty>::cos(real(_Left))));
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD complex<_Ty> tan(const complex<_Ty>& _Left) {
     complex<_Ty> _Zv(tanh(complex<_Ty>(-imag(_Left), real(_Left))));
     return complex<_Ty>(imag(_Zv), -real(_Zv));
@@ -2114,7 +2114,7 @@ _NODISCARD complex<_Ty> tan(const complex<_Ty>& _Left) {
 template <class _Ty>
 using _Upgrade_to_double = conditional_t<is_integral_v<_Ty>, double, _Ty>;
 
-template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>
+_EXPORT_STD template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>
 _NODISCARD _Upgrade_to_double<_Ty> arg(_Ty _Left) {
     using _Upgraded = _Upgrade_to_double<_Ty>;
     const auto _Val = static_cast<_Upgraded>(_Left);
@@ -2122,12 +2122,12 @@ _NODISCARD _Upgrade_to_double<_Ty> arg(_Ty _Left) {
     return _Ctraits<_Upgraded>::atan2(0, _Val);
 }
 
-template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>
+_EXPORT_STD template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>
 _NODISCARD _CONSTEXPR20 _Upgrade_to_double<_Ty> imag(_Ty) {
     return 0;
 }
 
-template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>
+_EXPORT_STD template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>
 _NODISCARD _CONSTEXPR20 _Upgrade_to_double<_Ty> real(_Ty _Left) {
     using _Upgraded = _Upgrade_to_double<_Ty>;
     const auto _Val = static_cast<_Upgraded>(_Left);
@@ -2135,7 +2135,7 @@ _NODISCARD _CONSTEXPR20 _Upgrade_to_double<_Ty> real(_Ty _Left) {
     return _Val;
 }
 
-template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>
+_EXPORT_STD template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>
 _NODISCARD _CONSTEXPR20 _Upgrade_to_double<_Ty> norm(_Ty _Left) {
     using _Upgraded = _Upgrade_to_double<_Ty>;
     const auto _Val = static_cast<_Upgraded>(_Left);
@@ -2143,7 +2143,7 @@ _NODISCARD _CONSTEXPR20 _Upgrade_to_double<_Ty> norm(_Ty _Left) {
     return _Val * _Val;
 }
 
-template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>
+_EXPORT_STD template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>
 _NODISCARD _CONSTEXPR20 complex<_Upgrade_to_double<_Ty>> conj(_Ty _Left) {
     using _Upgraded = _Upgrade_to_double<_Ty>;
     const auto _Val = static_cast<_Upgraded>(_Left);
@@ -2151,7 +2151,7 @@ _NODISCARD _CONSTEXPR20 complex<_Upgrade_to_double<_Ty>> conj(_Ty _Left) {
     return complex<_Upgraded>(_Val, -_Upgraded{0});
 }
 
-template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>
+_EXPORT_STD template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>
 _NODISCARD complex<_Upgrade_to_double<_Ty>> proj(_Ty _Left) {
     using _Upgraded = _Upgrade_to_double<_Ty>;
     const auto _Val = static_cast<_Upgraded>(_Left);
@@ -2165,27 +2165,27 @@ _NODISCARD complex<_Upgrade_to_double<_Ty>> proj(_Ty _Left) {
     return complex<_Upgraded>(_Val, 0);
 }
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD complex<_Common_float_type_t<_Ty1, _Ty2>> pow(const complex<_Ty1>& _Left, const complex<_Ty2>& _Right) {
     using _Type = complex<_Common_float_type_t<_Ty1, _Ty2>>;
     return _STD pow(_Type(_Left), _Type(_Right));
 }
 
-template <class _Ty1, class _Ty2, enable_if_t<is_arithmetic_v<_Ty2>, int> = 0>
+_EXPORT_STD template <class _Ty1, class _Ty2, enable_if_t<is_arithmetic_v<_Ty2>, int> = 0>
 _NODISCARD complex<_Common_float_type_t<_Ty1, _Ty2>> pow(const complex<_Ty1>& _Left, const _Ty2& _Right) {
     using _Promoted = _Common_float_type_t<_Ty1, _Ty2>;
     using _Type     = complex<_Promoted>;
     return _STD pow(_Type(_Left), _Type(static_cast<_Promoted>(_Right)));
 }
 
-template <class _Ty1, class _Ty2, enable_if_t<is_arithmetic_v<_Ty1>, int> = 0>
+_EXPORT_STD template <class _Ty1, class _Ty2, enable_if_t<is_arithmetic_v<_Ty1>, int> = 0>
 _NODISCARD complex<_Common_float_type_t<_Ty1, _Ty2>> pow(const _Ty1& _Left, const complex<_Ty2>& _Right) {
     using _Promoted = _Common_float_type_t<_Ty1, _Ty2>;
     using _Type     = complex<_Promoted>;
     return _STD pow(_Type(static_cast<_Promoted>(_Left)), _Type(_Right));
 }
 
-template <class _Ty, class _Elem, class _Tr>
+_EXPORT_STD template <class _Ty, class _Elem, class _Tr>
 basic_istream<_Elem, _Tr>& operator>>(basic_istream<_Elem, _Tr>& _Istr, complex<_Ty>& _Right) {
     const ctype<_Elem>& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Istr.getloc());
     _Elem _Ch                      = 0;
@@ -2215,7 +2215,7 @@ basic_istream<_Elem, _Tr>& operator>>(basic_istream<_Elem, _Tr>& _Istr, complex<
     return _Istr;
 }
 
-template <class _Ty, class _Elem, class _Tr>
+_EXPORT_STD template <class _Ty, class _Elem, class _Tr>
 basic_ostream<_Elem, _Tr>& operator<<(basic_ostream<_Elem, _Tr>& _Ostr, const complex<_Ty>& _Right) {
     const ctype<_Elem>& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Ostr.getloc());
     basic_ostringstream<_Elem, _Tr, allocator<_Elem>> _Sstr;
@@ -2230,27 +2230,27 @@ basic_ostream<_Elem, _Tr>& operator<<(basic_ostream<_Elem, _Tr>& _Ostr, const co
 
 inline namespace literals {
     inline namespace complex_literals {
-        _NODISCARD constexpr complex<long double> operator""il(long double _Val) {
+        _EXPORT_STD _NODISCARD constexpr complex<long double> operator""il(long double _Val) {
             return complex<long double>(0.0L, static_cast<long double>(_Val));
         }
 
-        _NODISCARD constexpr complex<long double> operator""il(unsigned long long _Val) {
+        _EXPORT_STD _NODISCARD constexpr complex<long double> operator""il(unsigned long long _Val) {
             return complex<long double>(0.0L, static_cast<long double>(_Val));
         }
 
-        _NODISCARD constexpr complex<double> operator""i(long double _Val) {
+        _EXPORT_STD _NODISCARD constexpr complex<double> operator""i(long double _Val) {
             return complex<double>(0.0, static_cast<double>(_Val));
         }
 
-        _NODISCARD constexpr complex<double> operator""i(unsigned long long _Val) {
+        _EXPORT_STD _NODISCARD constexpr complex<double> operator""i(unsigned long long _Val) {
             return complex<double>(0.0, static_cast<double>(_Val));
         }
 
-        _NODISCARD constexpr complex<float> operator""if(long double _Val) {
+        _EXPORT_STD _NODISCARD constexpr complex<float> operator""if(long double _Val) {
             return complex<float>(0.0f, static_cast<float>(_Val));
         }
 
-        _NODISCARD constexpr complex<float> operator""if(unsigned long long _Val) {
+        _EXPORT_STD _NODISCARD constexpr complex<float> operator""if(unsigned long long _Val) {
             return complex<float>(0.0f, static_cast<float>(_Val));
         }
     } // namespace complex_literals
diff --git a/stl/inc/concepts b/stl/inc/concepts
index 0604da2002..49585e00ea 100644
--- a/stl/inc/concepts
+++ b/stl/inc/concepts
@@ -32,14 +32,14 @@ concept _Same_impl = // Must be a distinct concept to provide symmetric subsumpt
     is_same_v<_Ty1, _Ty2>;
 #endif // __clang__
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 concept same_as = _Same_impl<_Ty1, _Ty2> && _Same_impl<_Ty2, _Ty1>;
 
-template <class _Derived, class _Base>
+_EXPORT_STD template <class _Derived, class _Base>
 concept derived_from = __is_base_of(_Base, _Derived)
     && __is_convertible_to(const volatile _Derived*, const volatile _Base*);
 
-template <class _From, class _To>
+_EXPORT_STD template <class _From, class _To>
 #if !defined(__EDG__) && !defined(__clang__) // TRANSITION, DevCom-1627396
 concept convertible_to = is_convertible_v<_From, _To>
 #else // ^^^ workaround / no workaround vvv
@@ -52,7 +52,7 @@ concept convertible_to = __is_convertible_to(_From, _To)
 template <class _From, class _To>
 concept _Implicitly_convertible_to = is_convertible_v<_From, _To>;
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 concept common_reference_with =
     requires {
         typename common_reference_t<_Ty1, _Ty2>;
@@ -62,7 +62,7 @@ concept common_reference_with =
     && convertible_to<_Ty1, common_reference_t<_Ty1, _Ty2>>
     && convertible_to<_Ty2, common_reference_t<_Ty1, _Ty2>>;
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 concept common_with =
     requires {
         typename common_type_t<_Ty1, _Ty2>;
@@ -77,19 +77,19 @@ concept common_with =
     && common_reference_with<add_lvalue_reference_t<common_type_t<_Ty1, _Ty2>>,
         common_reference_t<add_lvalue_reference_t<const _Ty1>, add_lvalue_reference_t<const _Ty2>>>;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 concept integral = is_integral_v<_Ty>;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 concept signed_integral = integral<_Ty> && static_cast<_Ty>(-1) < static_cast<_Ty>(0);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 concept unsigned_integral = integral<_Ty> && !signed_integral<_Ty>;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 concept floating_point = is_floating_point_v<_Ty>;
 
-template <class _LTy, class _RTy>
+_EXPORT_STD template <class _LTy, class _RTy>
 concept assignable_from = is_lvalue_reference_v<_LTy>
     && common_reference_with<const remove_reference_t<_LTy>&, const remove_reference_t<_RTy>&>
     && requires(_LTy _Left, _RTy&& _Right) {
@@ -98,21 +98,21 @@ concept assignable_from = is_lvalue_reference_v<_LTy>
 
 // swappable and swappable_with are defined below, since they depend on move_constructible.
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 concept destructible = __is_nothrow_destructible(_Ty);
 
-template <class _Ty, class... _ArgTys>
+_EXPORT_STD template <class _Ty, class... _ArgTys>
 concept constructible_from = destructible<_Ty>
     && __is_constructible(_Ty, _ArgTys...);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 concept default_initializable = constructible_from<_Ty>
     && requires {
         _Ty{};
         ::new (static_cast<void*>(nullptr)) _Ty; // is-default-initializable<_Ty>
     };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 concept move_constructible = constructible_from<_Ty, _Ty> && convertible_to<_Ty, _Ty>;
 
 template <class _Ty>
@@ -159,16 +159,16 @@ namespace ranges {
     } // namespace _Swap
 
     inline namespace _Cpos {
-        inline constexpr _Swap::_Cpo swap;
+        _EXPORT_STD inline constexpr _Swap::_Cpo swap;
     }
 } // namespace ranges
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 concept swappable = requires(_Ty& __x, _Ty& __y) {
     _RANGES swap(__x, __y);
 };
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 concept swappable_with = common_reference_with<_Ty1, _Ty2>
     && requires(_Ty1&& __t, _Ty2&& __u) {
         _RANGES swap(static_cast<_Ty1&&>(__t), static_cast<_Ty1&&>(__t));
@@ -177,7 +177,7 @@ concept swappable_with = common_reference_with<_Ty1, _Ty2>
         _RANGES swap(static_cast<_Ty2&&>(__u), static_cast<_Ty1&&>(__t));
     };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 concept copy_constructible = move_constructible<_Ty>
     && constructible_from<_Ty, _Ty&> && convertible_to<_Ty&, _Ty>
     && constructible_from<_Ty, const _Ty&> && convertible_to<const _Ty&, _Ty>
@@ -203,10 +203,10 @@ template <class _Ty1, class _Ty2>
 concept _Weakly_equality_comparable_with =
     _Half_equality_comparable<_Ty1, _Ty2> && _Half_equality_comparable<_Ty2, _Ty1>;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 concept equality_comparable = _Half_equality_comparable<_Ty, _Ty>;
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 concept equality_comparable_with = equality_comparable<_Ty1> && equality_comparable<_Ty2>
     && common_reference_with<const remove_reference_t<_Ty1>&, const remove_reference_t<_Ty2>&>
     && equality_comparable<common_reference_t<const remove_reference_t<_Ty1>&, const remove_reference_t<_Ty2>&>>
@@ -223,57 +223,57 @@ concept _Half_ordered = requires(const remove_reference_t<_Ty1>& __t, const remo
 template <class _Ty1, class _Ty2>
 concept _Partially_ordered_with = _Half_ordered<_Ty1, _Ty2> && _Half_ordered<_Ty2, _Ty1>;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 concept totally_ordered = equality_comparable<_Ty> && _Half_ordered<_Ty, _Ty>;
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 concept totally_ordered_with = totally_ordered<_Ty1> && totally_ordered<_Ty2>
     && equality_comparable_with<_Ty1, _Ty2>
     && totally_ordered<common_reference_t<const remove_reference_t<_Ty1>&, const remove_reference_t<_Ty2>&>>
     && _Partially_ordered_with<_Ty1, _Ty2>;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 concept movable = is_object_v<_Ty>
     && move_constructible<_Ty>
     && assignable_from<_Ty&, _Ty>
     && swappable<_Ty>;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 concept copyable = copy_constructible<_Ty>
     && movable<_Ty>
     && assignable_from<_Ty&, _Ty&>
     && assignable_from<_Ty&, const _Ty&>
     && assignable_from<_Ty&, const _Ty>;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 concept semiregular = copyable<_Ty> && default_initializable<_Ty>;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 concept regular = semiregular<_Ty> && equality_comparable<_Ty>;
 
-template <class _FTy, class... _ArgTys>
+_EXPORT_STD template <class _FTy, class... _ArgTys>
 concept invocable = requires(_FTy&& _Fn, _ArgTys&&... _Args) {
     _STD invoke(static_cast<_FTy&&>(_Fn), static_cast<_ArgTys&&>(_Args)...);
 };
 
-template <class _FTy, class... _ArgTys>
+_EXPORT_STD template <class _FTy, class... _ArgTys>
 concept regular_invocable = invocable<_FTy, _ArgTys...>;
 
-template <class _FTy, class... _ArgTys>
+_EXPORT_STD template <class _FTy, class... _ArgTys>
 concept predicate = regular_invocable<_FTy, _ArgTys...>
     && _Boolean_testable<invoke_result_t<_FTy, _ArgTys...>>;
 
-template <class _FTy, class _Ty1, class _Ty2>
+_EXPORT_STD template <class _FTy, class _Ty1, class _Ty2>
 concept relation =
        predicate<_FTy, _Ty1, _Ty1>
     && predicate<_FTy, _Ty2, _Ty2>
     && predicate<_FTy, _Ty1, _Ty2>
     && predicate<_FTy, _Ty2, _Ty1>;
 
-template <class _FTy, class _Ty1, class _Ty2>
+_EXPORT_STD template <class _FTy, class _Ty1, class _Ty2>
 concept equivalence_relation = relation<_FTy, _Ty1, _Ty2>;
 
-template <class _FTy, class _Ty1, class _Ty2>
+_EXPORT_STD template <class _FTy, class _Ty1, class _Ty2>
 concept strict_weak_order = relation<_FTy, _Ty1, _Ty2>;
 
 // clang-format on
diff --git a/stl/inc/condition_variable b/stl/inc/condition_variable
index 5d0641c718..fc11f39d58 100644
--- a/stl/inc/condition_variable
+++ b/stl/inc/condition_variable
@@ -49,7 +49,7 @@ private:
     _Lock& _Mtx;
 };
 
-class condition_variable_any { // class for waiting for conditions with any kind of mutex
+_EXPORT_STD class condition_variable_any { // class for waiting for conditions with any kind of mutex
 public:
     condition_variable_any() : _Myptr{_STD make_shared<mutex>()} {
         _Cnd_init_in_situ(_Mycnd());
@@ -273,7 +273,7 @@ private:
     }
 };
 
-inline void notify_all_at_thread_exit(condition_variable& _Cnd, unique_lock<mutex> _Lck) {
+_EXPORT_STD inline void notify_all_at_thread_exit(condition_variable& _Cnd, unique_lock<mutex> _Lck) {
     // register _Cnd for release at thread exit
     _Cnd._Register(_Lck, nullptr);
 }
diff --git a/stl/inc/coroutine b/stl/inc/coroutine
index d884eba9c9..3f9b6de971 100644
--- a/stl/inc/coroutine
+++ b/stl/inc/coroutine
@@ -43,10 +43,10 @@ struct _Coroutine_traits<_Ret, void_t<typename _Ret::promise_type>> {
     using promise_type = typename _Ret::promise_type;
 };
 
-template <class _Ret, class...>
+_EXPORT_STD template <class _Ret, class...>
 struct coroutine_traits : _Coroutine_traits<_Ret> {};
 
-template <class = void>
+_EXPORT_STD template <class = void>
 struct coroutine_handle;
 
 template <>
@@ -93,7 +93,7 @@ private:
     void* _Ptr = nullptr;
 };
 
-template <class _Promise>
+_EXPORT_STD template <class _Promise>
 struct coroutine_handle {
     constexpr coroutine_handle() noexcept = default;
     constexpr coroutine_handle(nullptr_t) noexcept {}
@@ -153,12 +153,13 @@ private:
     void* _Ptr = nullptr;
 };
 
-_NODISCARD constexpr bool operator==(const coroutine_handle<> _Left, const coroutine_handle<> _Right) noexcept {
+_EXPORT_STD _NODISCARD constexpr bool operator==(
+    const coroutine_handle<> _Left, const coroutine_handle<> _Right) noexcept {
     return _Left.address() == _Right.address();
 }
 
 #if _HAS_CXX20
-_NODISCARD constexpr strong_ordering operator<=>(
+_EXPORT_STD _NODISCARD constexpr strong_ordering operator<=>(
     const coroutine_handle<> _Left, const coroutine_handle<> _Right) noexcept {
 #ifdef __cpp_lib_concepts
     return compare_three_way{}(_Left.address(), _Right.address());
@@ -195,7 +196,7 @@ struct hash<coroutine_handle<_Promise>> {
     }
 };
 
-struct noop_coroutine_promise {};
+_EXPORT_STD struct noop_coroutine_promise {};
 
 template <>
 struct coroutine_handle<noop_coroutine_promise> {
@@ -231,14 +232,14 @@ private:
     void* _Ptr = __builtin_coro_noop();
 };
 
-using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>;
+_EXPORT_STD using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>;
 
-_NODISCARD inline noop_coroutine_handle noop_coroutine() noexcept {
+_EXPORT_STD _NODISCARD inline noop_coroutine_handle noop_coroutine() noexcept {
     // Returns a handle to a coroutine that has no observable effects when resumed or destroyed.
     return noop_coroutine_handle{};
 }
 
-struct suspend_never {
+_EXPORT_STD struct suspend_never {
     _NODISCARD constexpr bool await_ready() const noexcept {
         return true;
     }
@@ -247,7 +248,7 @@ struct suspend_never {
     constexpr void await_resume() const noexcept {}
 };
 
-struct suspend_always {
+_EXPORT_STD struct suspend_always {
     _NODISCARD constexpr bool await_ready() const noexcept {
         return false;
     }
diff --git a/stl/inc/csetjmp b/stl/inc/csetjmp
index 802ff156e6..c22d99775a 100644
--- a/stl/inc/csetjmp
+++ b/stl/inc/csetjmp
@@ -19,8 +19,8 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-using ::jmp_buf;
-using ::longjmp;
+_EXPORT_STD using ::jmp_buf;
+_EXPORT_STD using ::longjmp;
 using ::setjmp;
 _STD_END
 
diff --git a/stl/inc/csignal b/stl/inc/csignal
index 720c6d1150..5eba45955a 100644
--- a/stl/inc/csignal
+++ b/stl/inc/csignal
@@ -19,10 +19,10 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-using _CSTD sig_atomic_t;
-using _CSTD raise;
+_EXPORT_STD using _CSTD sig_atomic_t;
+_EXPORT_STD using _CSTD raise;
 #ifndef _M_CEE_PURE
-using _CSTD signal;
+_EXPORT_STD using _CSTD signal;
 #endif // _M_CEE_PURE
 _STD_END
 
diff --git a/stl/inc/cstdarg b/stl/inc/cstdarg
index f9897bcb17..e1f2c08e5a 100644
--- a/stl/inc/cstdarg
+++ b/stl/inc/cstdarg
@@ -19,7 +19,7 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-using ::va_list;
+_EXPORT_STD using ::va_list;
 _STD_END
 
 #pragma pop_macro("new")
diff --git a/stl/inc/cstddef b/stl/inc/cstddef
index b810544336..91aa280202 100644
--- a/stl/inc/cstddef
+++ b/stl/inc/cstddef
@@ -20,71 +20,72 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-using _CSTD ptrdiff_t;
-using _CSTD size_t;
-using max_align_t = double; // most aligned type
+_EXPORT_STD using _CSTD ptrdiff_t;
+_EXPORT_STD using _CSTD size_t;
+_EXPORT_STD using max_align_t = double; // most aligned type
+_EXPORT_STD using nullptr_t   = decltype(nullptr);
 
 #ifdef __cpp_lib_byte
-enum class byte : unsigned char {};
+_EXPORT_STD enum class byte : unsigned char {};
 
-template <class _IntType, enable_if_t<is_integral_v<_IntType>, int> = 0>
+_EXPORT_STD template <class _IntType, enable_if_t<is_integral_v<_IntType>, int> = 0>
 _NODISCARD constexpr byte operator<<(const byte _Arg, const _IntType _Shift) noexcept {
     // every static_cast is intentional
     return static_cast<byte>(static_cast<unsigned char>(static_cast<unsigned int>(_Arg) << _Shift));
 }
 
-template <class _IntType, enable_if_t<is_integral_v<_IntType>, int> = 0>
+_EXPORT_STD template <class _IntType, enable_if_t<is_integral_v<_IntType>, int> = 0>
 _NODISCARD constexpr byte operator>>(const byte _Arg, const _IntType _Shift) noexcept {
     // every static_cast is intentional
     return static_cast<byte>(static_cast<unsigned char>(static_cast<unsigned int>(_Arg) >> _Shift));
 }
 
-_NODISCARD constexpr byte operator|(const byte _Left, const byte _Right) noexcept {
+_EXPORT_STD _NODISCARD constexpr byte operator|(const byte _Left, const byte _Right) noexcept {
     // every static_cast is intentional
     return static_cast<byte>(
         static_cast<unsigned char>(static_cast<unsigned int>(_Left) | static_cast<unsigned int>(_Right)));
 }
 
-_NODISCARD constexpr byte operator&(const byte _Left, const byte _Right) noexcept {
+_EXPORT_STD _NODISCARD constexpr byte operator&(const byte _Left, const byte _Right) noexcept {
     // every static_cast is intentional
     return static_cast<byte>(
         static_cast<unsigned char>(static_cast<unsigned int>(_Left) & static_cast<unsigned int>(_Right)));
 }
 
-_NODISCARD constexpr byte operator^(const byte _Left, const byte _Right) noexcept {
+_EXPORT_STD _NODISCARD constexpr byte operator^(const byte _Left, const byte _Right) noexcept {
     // every static_cast is intentional
     return static_cast<byte>(
         static_cast<unsigned char>(static_cast<unsigned int>(_Left) ^ static_cast<unsigned int>(_Right)));
 }
 
-_NODISCARD constexpr byte operator~(const byte _Arg) noexcept {
+_EXPORT_STD _NODISCARD constexpr byte operator~(const byte _Arg) noexcept {
     // every static_cast is intentional
     return static_cast<byte>(static_cast<unsigned char>(~static_cast<unsigned int>(_Arg)));
 }
 
-template <class _IntType, enable_if_t<is_integral_v<_IntType>, int> = 0>
+_EXPORT_STD template <class _IntType, enable_if_t<is_integral_v<_IntType>, int> = 0>
 constexpr byte& operator<<=(byte& _Arg, const _IntType _Shift) noexcept {
     return _Arg = _Arg << _Shift;
 }
 
-template <class _IntType, enable_if_t<is_integral_v<_IntType>, int> = 0>
+_EXPORT_STD template <class _IntType, enable_if_t<is_integral_v<_IntType>, int> = 0>
 constexpr byte& operator>>=(byte& _Arg, const _IntType _Shift) noexcept {
     return _Arg = _Arg >> _Shift;
 }
 
-constexpr byte& operator|=(byte& _Left, const byte _Right) noexcept {
+_EXPORT_STD constexpr byte& operator|=(byte& _Left, const byte _Right) noexcept {
     return _Left = _Left | _Right;
 }
 
-constexpr byte& operator&=(byte& _Left, const byte _Right) noexcept {
+_EXPORT_STD constexpr byte& operator&=(byte& _Left, const byte _Right) noexcept {
     return _Left = _Left & _Right;
 }
 
-constexpr byte& operator^=(byte& _Left, const byte _Right) noexcept {
+_EXPORT_STD constexpr byte& operator^=(byte& _Left, const byte _Right) noexcept {
     return _Left = _Left ^ _Right;
 }
 
-template <class _IntType, enable_if_t<is_integral_v<_IntType>, int> = 0>
+_EXPORT_STD template <class _IntType, enable_if_t<is_integral_v<_IntType>, int> = 0>
 _NODISCARD constexpr _IntType to_integer(const byte _Arg) noexcept {
     return static_cast<_IntType>(_Arg);
 }
diff --git a/stl/inc/cstdint b/stl/inc/cstdint
index c61aed7d7b..e581d104da 100644
--- a/stl/inc/cstdint
+++ b/stl/inc/cstdint
@@ -19,37 +19,37 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-using _CSTD int8_t;
-using _CSTD int16_t;
-using _CSTD int32_t;
-using _CSTD int64_t;
-using _CSTD uint8_t;
-using _CSTD uint16_t;
-using _CSTD uint32_t;
-using _CSTD uint64_t;
+_EXPORT_STD using _CSTD int8_t;
+_EXPORT_STD using _CSTD int16_t;
+_EXPORT_STD using _CSTD int32_t;
+_EXPORT_STD using _CSTD int64_t;
+_EXPORT_STD using _CSTD uint8_t;
+_EXPORT_STD using _CSTD uint16_t;
+_EXPORT_STD using _CSTD uint32_t;
+_EXPORT_STD using _CSTD uint64_t;
 
-using _CSTD int_least8_t;
-using _CSTD int_least16_t;
-using _CSTD int_least32_t;
-using _CSTD int_least64_t;
-using _CSTD uint_least8_t;
-using _CSTD uint_least16_t;
-using _CSTD uint_least32_t;
-using _CSTD uint_least64_t;
+_EXPORT_STD using _CSTD int_least8_t;
+_EXPORT_STD using _CSTD int_least16_t;
+_EXPORT_STD using _CSTD int_least32_t;
+_EXPORT_STD using _CSTD int_least64_t;
+_EXPORT_STD using _CSTD uint_least8_t;
+_EXPORT_STD using _CSTD uint_least16_t;
+_EXPORT_STD using _CSTD uint_least32_t;
+_EXPORT_STD using _CSTD uint_least64_t;
 
-using _CSTD int_fast8_t;
-using _CSTD int_fast16_t;
-using _CSTD int_fast32_t;
-using _CSTD int_fast64_t;
-using _CSTD uint_fast8_t;
-using _CSTD uint_fast16_t;
-using _CSTD uint_fast32_t;
-using _CSTD uint_fast64_t;
+_EXPORT_STD using _CSTD int_fast8_t;
+_EXPORT_STD using _CSTD int_fast16_t;
+_EXPORT_STD using _CSTD int_fast32_t;
+_EXPORT_STD using _CSTD int_fast64_t;
+_EXPORT_STD using _CSTD uint_fast8_t;
+_EXPORT_STD using _CSTD uint_fast16_t;
+_EXPORT_STD using _CSTD uint_fast32_t;
+_EXPORT_STD using _CSTD uint_fast64_t;
 
-using _CSTD intmax_t;
-using _CSTD intptr_t;
-using _CSTD uintmax_t;
-using _CSTD uintptr_t;
+_EXPORT_STD using _CSTD intmax_t;
+_EXPORT_STD using _CSTD intptr_t;
+_EXPORT_STD using _CSTD uintmax_t;
+_EXPORT_STD using _CSTD uintptr_t;
 
 #if _HAS_TR1_NAMESPACE
 namespace _DEPRECATE_TR1_NAMESPACE tr1 {
diff --git a/stl/inc/cstdio b/stl/inc/cstdio
index 78aa8aac77..5aaa8b5a8f 100644
--- a/stl/inc/cstdio
+++ b/stl/inc/cstdio
@@ -36,55 +36,55 @@ _STD_BEGIN
 
 using _CSTD _Mbstatet;
 
-using _CSTD size_t;
-using _CSTD fpos_t;
-using _CSTD FILE;
-using _CSTD clearerr;
-using _CSTD fclose;
-using _CSTD feof;
-using _CSTD ferror;
-using _CSTD fflush;
-using _CSTD fgetc;
-using _CSTD fgetpos;
-using _CSTD fgets;
-using _CSTD fopen;
-using _CSTD fprintf;
-using _CSTD fputc;
-using _CSTD fputs;
-using _CSTD fread;
-using _CSTD freopen;
-using _CSTD fscanf;
-using _CSTD fseek;
-using _CSTD fsetpos;
-using _CSTD ftell;
-using _CSTD fwrite;
-using _CSTD getc;
-using _CSTD getchar;
-using _CSTD perror;
-using _CSTD putc;
-using _CSTD putchar;
-using _CSTD printf;
-using _CSTD puts;
-using _CSTD remove;
-using _CSTD rename;
-using _CSTD rewind;
-using _CSTD scanf;
-using _CSTD setbuf;
-using _CSTD setvbuf;
-using _CSTD sprintf;
-using _CSTD sscanf;
-using _CSTD tmpfile;
-using _CSTD tmpnam;
-using _CSTD ungetc;
-using _CSTD vfprintf;
-using _CSTD vprintf;
-using _CSTD vsprintf;
+_EXPORT_STD using _CSTD size_t;
+_EXPORT_STD using _CSTD fpos_t;
+_EXPORT_STD using _CSTD FILE;
+_EXPORT_STD using _CSTD clearerr;
+_EXPORT_STD using _CSTD fclose;
+_EXPORT_STD using _CSTD feof;
+_EXPORT_STD using _CSTD ferror;
+_EXPORT_STD using _CSTD fflush;
+_EXPORT_STD using _CSTD fgetc;
+_EXPORT_STD using _CSTD fgetpos;
+_EXPORT_STD using _CSTD fgets;
+_EXPORT_STD using _CSTD fopen;
+_EXPORT_STD using _CSTD fprintf;
+_EXPORT_STD using _CSTD fputc;
+_EXPORT_STD using _CSTD fputs;
+_EXPORT_STD using _CSTD fread;
+_EXPORT_STD using _CSTD freopen;
+_EXPORT_STD using _CSTD fscanf;
+_EXPORT_STD using _CSTD fseek;
+_EXPORT_STD using _CSTD fsetpos;
+_EXPORT_STD using _CSTD ftell;
+_EXPORT_STD using _CSTD fwrite;
+_EXPORT_STD using _CSTD getc;
+_EXPORT_STD using _CSTD getchar;
+_EXPORT_STD using _CSTD perror;
+_EXPORT_STD using _CSTD putc;
+_EXPORT_STD using _CSTD putchar;
+_EXPORT_STD using _CSTD printf;
+_EXPORT_STD using _CSTD puts;
+_EXPORT_STD using _CSTD remove;
+_EXPORT_STD using _CSTD rename;
+_EXPORT_STD using _CSTD rewind;
+_EXPORT_STD using _CSTD scanf;
+_EXPORT_STD using _CSTD setbuf;
+_EXPORT_STD using _CSTD setvbuf;
+_EXPORT_STD using _CSTD sprintf;
+_EXPORT_STD using _CSTD sscanf;
+_EXPORT_STD using _CSTD tmpfile;
+_EXPORT_STD using _CSTD tmpnam;
+_EXPORT_STD using _CSTD ungetc;
+_EXPORT_STD using _CSTD vfprintf;
+_EXPORT_STD using _CSTD vprintf;
+_EXPORT_STD using _CSTD vsprintf;
 
-using _CSTD snprintf;
-using _CSTD vsnprintf;
-using _CSTD vfscanf;
-using _CSTD vscanf;
-using _CSTD vsscanf;
+_EXPORT_STD using _CSTD snprintf;
+_EXPORT_STD using _CSTD vsnprintf;
+_EXPORT_STD using _CSTD vfscanf;
+_EXPORT_STD using _CSTD vscanf;
+_EXPORT_STD using _CSTD vsscanf;
 
 #pragma warning(pop)
 _STD_END
diff --git a/stl/inc/cstdlib b/stl/inc/cstdlib
index 6507887012..91941aa282 100644
--- a/stl/inc/cstdlib
+++ b/stl/inc/cstdlib
@@ -33,52 +33,52 @@ _NODISCARD _Check_return_ inline long double abs(_In_ long double _Xx) noexcept
 }
 
 _STD_BEGIN
-using _CSTD size_t;
-using _CSTD div_t;
-using _CSTD ldiv_t;
-using _CSTD abort;
-using _CSTD abs;
-using _CSTD atexit;
-using _CSTD atof;
-using _CSTD atoi;
-using _CSTD atol;
-using _CSTD bsearch;
-using _CSTD calloc;
-using _CSTD div;
-using _CSTD exit;
-using _CSTD free;
-using _CSTD labs;
-using _CSTD ldiv;
-using _CSTD malloc;
-using _CSTD mblen;
-using _CSTD mbstowcs;
-using _CSTD mbtowc;
-using _CSTD qsort;
-using _CSTD rand;
-using _CSTD realloc;
-using _CSTD srand;
-using _CSTD strtod;
-using _CSTD strtol;
-using _CSTD strtoul;
-using _CSTD wcstombs;
-using _CSTD wctomb;
+_EXPORT_STD using _CSTD size_t;
+_EXPORT_STD using _CSTD div_t;
+_EXPORT_STD using _CSTD ldiv_t;
+_EXPORT_STD using _CSTD abort;
+_EXPORT_STD using _CSTD abs;
+_EXPORT_STD using _CSTD atexit;
+_EXPORT_STD using _CSTD atof;
+_EXPORT_STD using _CSTD atoi;
+_EXPORT_STD using _CSTD atol;
+_EXPORT_STD using _CSTD bsearch;
+_EXPORT_STD using _CSTD calloc;
+_EXPORT_STD using _CSTD div;
+_EXPORT_STD using _CSTD exit;
+_EXPORT_STD using _CSTD free;
+_EXPORT_STD using _CSTD labs;
+_EXPORT_STD using _CSTD ldiv;
+_EXPORT_STD using _CSTD malloc;
+_EXPORT_STD using _CSTD mblen;
+_EXPORT_STD using _CSTD mbstowcs;
+_EXPORT_STD using _CSTD mbtowc;
+_EXPORT_STD using _CSTD qsort;
+_EXPORT_STD using _CSTD rand;
+_EXPORT_STD using _CSTD realloc;
+_EXPORT_STD using _CSTD srand;
+_EXPORT_STD using _CSTD strtod;
+_EXPORT_STD using _CSTD strtol;
+_EXPORT_STD using _CSTD strtoul;
+_EXPORT_STD using _CSTD wcstombs;
+_EXPORT_STD using _CSTD wctomb;
 
-using _CSTD lldiv_t;
+_EXPORT_STD using _CSTD lldiv_t;
 
-using _CSTD getenv;
-using _CSTD system;
+_EXPORT_STD using _CSTD getenv;
+_EXPORT_STD using _CSTD system;
 
-using _CSTD atoll;
-using _CSTD llabs;
-using _CSTD lldiv;
-using _CSTD strtof;
-using _CSTD strtold;
-using _CSTD strtoll;
-using _CSTD strtoull;
+_EXPORT_STD using _CSTD atoll;
+_EXPORT_STD using _CSTD llabs;
+_EXPORT_STD using _CSTD lldiv;
+_EXPORT_STD using _CSTD strtof;
+_EXPORT_STD using _CSTD strtold;
+_EXPORT_STD using _CSTD strtoll;
+_EXPORT_STD using _CSTD strtoull;
 
-using _CSTD _Exit;
-using _CSTD at_quick_exit;
-using _CSTD quick_exit;
+_EXPORT_STD using _CSTD _Exit;
+_EXPORT_STD using _CSTD at_quick_exit;
+_EXPORT_STD using _CSTD quick_exit;
 _STD_END
 
 #pragma pop_macro("new")
diff --git a/stl/inc/cstring b/stl/inc/cstring
index a0140aa307..c82b78638d 100644
--- a/stl/inc/cstring
+++ b/stl/inc/cstring
@@ -22,29 +22,29 @@ _STD_BEGIN
 #pragma warning(push)
 #pragma warning(disable : 4995) // name was marked as #pragma deprecated
 
-using _CSTD size_t;
-using _CSTD memchr;
-using _CSTD memcmp;
-using _CSTD memcpy;
-using _CSTD memmove;
-using _CSTD memset;
-using _CSTD strcat;
-using _CSTD strchr;
-using _CSTD strcmp;
-using _CSTD strcoll;
-using _CSTD strcpy;
-using _CSTD strcspn;
-using _CSTD strerror;
-using _CSTD strlen;
-using _CSTD strncat;
-using _CSTD strncmp;
-using _CSTD strncpy;
-using _CSTD strpbrk;
-using _CSTD strrchr;
-using _CSTD strspn;
-using _CSTD strstr;
-using _CSTD strtok;
-using _CSTD strxfrm;
+_EXPORT_STD using _CSTD size_t;
+_EXPORT_STD using _CSTD memchr;
+_EXPORT_STD using _CSTD memcmp;
+_EXPORT_STD using _CSTD memcpy;
+_EXPORT_STD using _CSTD memmove;
+_EXPORT_STD using _CSTD memset;
+_EXPORT_STD using _CSTD strcat;
+_EXPORT_STD using _CSTD strchr;
+_EXPORT_STD using _CSTD strcmp;
+_EXPORT_STD using _CSTD strcoll;
+_EXPORT_STD using _CSTD strcpy;
+_EXPORT_STD using _CSTD strcspn;
+_EXPORT_STD using _CSTD strerror;
+_EXPORT_STD using _CSTD strlen;
+_EXPORT_STD using _CSTD strncat;
+_EXPORT_STD using _CSTD strncmp;
+_EXPORT_STD using _CSTD strncpy;
+_EXPORT_STD using _CSTD strpbrk;
+_EXPORT_STD using _CSTD strrchr;
+_EXPORT_STD using _CSTD strspn;
+_EXPORT_STD using _CSTD strstr;
+_EXPORT_STD using _CSTD strtok;
+_EXPORT_STD using _CSTD strxfrm;
 
 #pragma warning(pop)
 _STD_END
diff --git a/stl/inc/ctime b/stl/inc/ctime
index 94ed91c49c..a0bd471efe 100644
--- a/stl/inc/ctime
+++ b/stl/inc/ctime
@@ -19,23 +19,75 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-using _CSTD clock_t;
-using _CSTD size_t;
-using _CSTD time_t;
-using _CSTD tm;
-using _CSTD asctime;
-using _CSTD clock;
-using _CSTD ctime;
-using _CSTD difftime;
-using _CSTD gmtime;
-using _CSTD localtime;
-using _CSTD mktime;
-using _CSTD strftime;
-using _CSTD time;
+_EXPORT_STD using _CSTD clock_t;
+_EXPORT_STD using _CSTD size_t;
+_EXPORT_STD using _CSTD time_t;
+_EXPORT_STD using _CSTD tm;
+_EXPORT_STD using _CSTD asctime;
+_EXPORT_STD using _CSTD clock;
+_EXPORT_STD using _CSTD strftime;
 #if _HAS_CXX17
-using _CSTD timespec;
-using _CSTD timespec_get;
+_EXPORT_STD using _CSTD timespec;
 #endif // _HAS_CXX17
+
+#if _HAS_CXX23 && defined(_BUILD_STD_MODULE) // TRANSITION, DevCom-1126857
+_STL_DISABLE_DEPRECATED_WARNING
+
+// These workaround functions intentionally aren't inline.
+_EXPORT_STD
+_Check_return_ _CRT_INSECURE_DEPRECATE(ctime_s)
+char* __CRTDECL ctime(_In_ const time_t* const _Time) noexcept /* strengthened */ {
+    return _CSTD _ctime64(_Time);
+}
+
+_EXPORT_STD
+_Check_return_ double __CRTDECL difftime(_In_ const time_t _Time1, _In_ const time_t _Time2) noexcept
+/* strengthened */ {
+    return _CSTD _difftime64(_Time1, _Time2);
+}
+
+_EXPORT_STD
+_Check_return_ _CRT_INSECURE_DEPRECATE(gmtime_s)
+tm* __CRTDECL gmtime(_In_ const time_t* const _Time) noexcept /* strengthened */ {
+    return _CSTD _gmtime64(_Time);
+}
+
+_EXPORT_STD
+_CRT_INSECURE_DEPRECATE(localtime_s)
+tm* __CRTDECL localtime(_In_ const time_t* const _Time) noexcept /* strengthened */ {
+    return _CSTD _localtime64(_Time);
+}
+
+_EXPORT_STD
+_Check_return_opt_ time_t __CRTDECL mktime(_Inout_ tm* const _Tm) noexcept /* strengthened */ {
+    return _CSTD _mktime64(_Tm);
+}
+
+_EXPORT_STD
+time_t __CRTDECL time(_Out_opt_ time_t* const _Time) noexcept /* strengthened */ {
+    return _CSTD _time64(_Time);
+}
+
+_EXPORT_STD
+_Check_return_ int __CRTDECL timespec_get(_Out_ timespec* const _Ts, _In_ const int _Base) noexcept /* strengthened */ {
+    return _CSTD _timespec64_get(reinterpret_cast<_timespec64*>(_Ts), _Base);
+}
+
+_STL_RESTORE_DEPRECATED_WARNING
+#else // ^^^ workaround / no workaround vvv
+
+// _EXPORT_STD has no effect while the workaround is present.
+_EXPORT_STD using _CSTD ctime;
+_EXPORT_STD using _CSTD difftime;
+_EXPORT_STD using _CSTD gmtime;
+_EXPORT_STD using _CSTD localtime;
+_EXPORT_STD using _CSTD mktime;
+_EXPORT_STD using _CSTD time;
+#if _HAS_CXX17
+_EXPORT_STD using _CSTD timespec_get;
+#endif // _HAS_CXX17
+
+#endif // ^^^ no workaround ^^^
 _STD_END
 
 #pragma pop_macro("new")
diff --git a/stl/inc/cuchar b/stl/inc/cuchar
index fc8feb0be8..e43d714dbc 100644
--- a/stl/inc/cuchar
+++ b/stl/inc/cuchar
@@ -19,12 +19,12 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-using _CSTD mbstate_t;
-using _CSTD size_t;
-using _CSTD mbrtoc16;
-using _CSTD c16rtomb;
-using _CSTD mbrtoc32;
-using _CSTD c32rtomb;
+_EXPORT_STD using _CSTD mbstate_t;
+_EXPORT_STD using _CSTD size_t;
+_EXPORT_STD using _CSTD mbrtoc16;
+_EXPORT_STD using _CSTD c16rtomb;
+_EXPORT_STD using _CSTD mbrtoc32;
+_EXPORT_STD using _CSTD c32rtomb;
 _STD_END
 
 #pragma pop_macro("new")
diff --git a/stl/inc/cwchar b/stl/inc/cwchar
index 7f48789ab9..8bccfb4f19 100644
--- a/stl/inc/cwchar
+++ b/stl/inc/cwchar
@@ -27,71 +27,71 @@ _STD_BEGIN
 
 using _CSTD _Mbstatet;
 
-using _CSTD mbstate_t;
-using _CSTD size_t;
-using _CSTD tm;
-using _CSTD wint_t;
+_EXPORT_STD using _CSTD mbstate_t;
+_EXPORT_STD using _CSTD size_t;
+_EXPORT_STD using _CSTD tm;
+_EXPORT_STD using _CSTD wint_t;
 
-using _CSTD btowc;
-using _CSTD fgetwc;
-using _CSTD fgetws;
-using _CSTD fputwc;
-using _CSTD fputws;
-using _CSTD fwide;
-using _CSTD fwprintf;
-using _CSTD fwscanf;
-using _CSTD getwc;
-using _CSTD getwchar;
-using _CSTD mbrlen;
-using _CSTD mbrtowc;
-using _CSTD mbsrtowcs;
-using _CSTD mbsinit;
-using _CSTD putwc;
-using _CSTD putwchar;
-using _CSTD swprintf;
-using _CSTD swscanf;
-using _CSTD ungetwc;
-using _CSTD vfwprintf;
-using _CSTD vswprintf;
-using _CSTD vwprintf;
-using _CSTD wcrtomb;
-using _CSTD wprintf;
-using _CSTD wscanf;
-using _CSTD wcsrtombs;
-using _CSTD wcstol;
-using _CSTD wcscat;
-using _CSTD wcschr;
-using _CSTD wcscmp;
-using _CSTD wcscoll;
-using _CSTD wcscpy;
-using _CSTD wcscspn;
-using _CSTD wcslen;
-using _CSTD wcsncat;
-using _CSTD wcsncmp;
-using _CSTD wcsncpy;
-using _CSTD wcspbrk;
-using _CSTD wcsrchr;
-using _CSTD wcsspn;
-using _CSTD wcstod;
-using _CSTD wcstoul;
-using _CSTD wcsstr;
-using _CSTD wcstok;
-using _CSTD wcsxfrm;
-using _CSTD wctob;
-using _CSTD wmemchr;
-using _CSTD wmemcmp;
-using _CSTD wmemcpy;
-using _CSTD wmemmove;
-using _CSTD wmemset;
-using _CSTD wcsftime;
+_EXPORT_STD using _CSTD btowc;
+_EXPORT_STD using _CSTD fgetwc;
+_EXPORT_STD using _CSTD fgetws;
+_EXPORT_STD using _CSTD fputwc;
+_EXPORT_STD using _CSTD fputws;
+_EXPORT_STD using _CSTD fwide;
+_EXPORT_STD using _CSTD fwprintf;
+_EXPORT_STD using _CSTD fwscanf;
+_EXPORT_STD using _CSTD getwc;
+_EXPORT_STD using _CSTD getwchar;
+_EXPORT_STD using _CSTD mbrlen;
+_EXPORT_STD using _CSTD mbrtowc;
+_EXPORT_STD using _CSTD mbsrtowcs;
+_EXPORT_STD using _CSTD mbsinit;
+_EXPORT_STD using _CSTD putwc;
+_EXPORT_STD using _CSTD putwchar;
+_EXPORT_STD using _CSTD swprintf;
+_EXPORT_STD using _CSTD swscanf;
+_EXPORT_STD using _CSTD ungetwc;
+_EXPORT_STD using _CSTD vfwprintf;
+_EXPORT_STD using _CSTD vswprintf;
+_EXPORT_STD using _CSTD vwprintf;
+_EXPORT_STD using _CSTD wcrtomb;
+_EXPORT_STD using _CSTD wprintf;
+_EXPORT_STD using _CSTD wscanf;
+_EXPORT_STD using _CSTD wcsrtombs;
+_EXPORT_STD using _CSTD wcstol;
+_EXPORT_STD using _CSTD wcscat;
+_EXPORT_STD using _CSTD wcschr;
+_EXPORT_STD using _CSTD wcscmp;
+_EXPORT_STD using _CSTD wcscoll;
+_EXPORT_STD using _CSTD wcscpy;
+_EXPORT_STD using _CSTD wcscspn;
+_EXPORT_STD using _CSTD wcslen;
+_EXPORT_STD using _CSTD wcsncat;
+_EXPORT_STD using _CSTD wcsncmp;
+_EXPORT_STD using _CSTD wcsncpy;
+_EXPORT_STD using _CSTD wcspbrk;
+_EXPORT_STD using _CSTD wcsrchr;
+_EXPORT_STD using _CSTD wcsspn;
+_EXPORT_STD using _CSTD wcstod;
+_EXPORT_STD using _CSTD wcstoul;
+_EXPORT_STD using _CSTD wcsstr;
+_EXPORT_STD using _CSTD wcstok;
+_EXPORT_STD using _CSTD wcsxfrm;
+_EXPORT_STD using _CSTD wctob;
+_EXPORT_STD using _CSTD wmemchr;
+_EXPORT_STD using _CSTD wmemcmp;
+_EXPORT_STD using _CSTD wmemcpy;
+_EXPORT_STD using _CSTD wmemmove;
+_EXPORT_STD using _CSTD wmemset;
+_EXPORT_STD using _CSTD wcsftime;
 
-using _CSTD vfwscanf;
-using _CSTD vswscanf;
-using _CSTD vwscanf;
-using _CSTD wcstof;
-using _CSTD wcstold;
-using _CSTD wcstoll;
-using _CSTD wcstoull;
+_EXPORT_STD using _CSTD vfwscanf;
+_EXPORT_STD using _CSTD vswscanf;
+_EXPORT_STD using _CSTD vwscanf;
+_EXPORT_STD using _CSTD wcstof;
+_EXPORT_STD using _CSTD wcstold;
+_EXPORT_STD using _CSTD wcstoll;
+_EXPORT_STD using _CSTD wcstoull;
 
 #pragma warning(pop)
 _STD_END
diff --git a/stl/inc/cwctype b/stl/inc/cwctype
index 310125edc9..6c48792d14 100644
--- a/stl/inc/cwctype
+++ b/stl/inc/cwctype
@@ -39,29 +39,29 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef wctype
 
 _STD_BEGIN
-using _CSTD wint_t;
-using _CSTD wctrans_t;
-using _CSTD wctype_t;
+_EXPORT_STD using _CSTD wint_t;
+_EXPORT_STD using _CSTD wctrans_t;
+_EXPORT_STD using _CSTD wctype_t;
 
-using _CSTD iswalnum;
-using _CSTD iswalpha;
-using _CSTD iswcntrl;
-using _CSTD iswctype;
-using _CSTD iswdigit;
-using _CSTD iswgraph;
-using _CSTD iswlower;
-using _CSTD iswprint;
-using _CSTD iswpunct;
-using _CSTD iswspace;
-using _CSTD iswupper;
-using _CSTD iswxdigit;
-using _CSTD towctrans;
-using _CSTD towlower;
-using _CSTD towupper;
-using _CSTD wctrans;
-using _CSTD wctype;
+_EXPORT_STD using _CSTD iswalnum;
+_EXPORT_STD using _CSTD iswalpha;
+_EXPORT_STD using _CSTD iswcntrl;
+_EXPORT_STD using _CSTD iswctype;
+_EXPORT_STD using _CSTD iswdigit;
+_EXPORT_STD using _CSTD iswgraph;
+_EXPORT_STD using _CSTD iswlower;
+_EXPORT_STD using _CSTD iswprint;
+_EXPORT_STD using _CSTD iswpunct;
+_EXPORT_STD using _CSTD iswspace;
+_EXPORT_STD using _CSTD iswupper;
+_EXPORT_STD using _CSTD iswxdigit;
+_EXPORT_STD using _CSTD towctrans;
+_EXPORT_STD using _CSTD towlower;
+_EXPORT_STD using _CSTD towupper;
+_EXPORT_STD using _CSTD wctrans;
+_EXPORT_STD using _CSTD wctype;
 
-using _CSTD iswblank;
+_EXPORT_STD using _CSTD iswblank;
 _STD_END
 
 #pragma pop_macro("new")
diff --git a/stl/inc/deque b/stl/inc/deque
index 04d535fc47..c2802fde09 100644
--- a/stl/inc/deque
+++ b/stl/inc/deque
@@ -570,7 +570,7 @@ public:
     size_type _Mysize; // current length of sequence
 };
 
-template <class _Ty, class _Alloc = allocator<_Ty>>
+_EXPORT_STD template <class _Ty, class _Alloc = allocator<_Ty>>
 class deque {
 private:
     friend _Tidy_guard<deque>;
@@ -1696,12 +1696,12 @@ template <_RANGES input_range _Rng, class _Alloc = allocator<_RANGES range_value
 deque(from_range_t, _Rng&&, _Alloc = _Alloc()) -> deque<_RANGES range_value_t<_Rng>, _Alloc>;
 #endif // _HAS_CXX23 && defined(__cpp_lib_concepts)
 
-template <class _Ty, class _Alloc>
+_EXPORT_STD template <class _Ty, class _Alloc>
 void swap(deque<_Ty, _Alloc>& _Left, deque<_Ty, _Alloc>& _Right) noexcept /* strengthened */ {
     _Left.swap(_Right);
 }
 
-template <class _Ty, class _Alloc>
+_EXPORT_STD template <class _Ty, class _Alloc>
 _NODISCARD bool operator==(const deque<_Ty, _Alloc>& _Left, const deque<_Ty, _Alloc>& _Right) {
     return _Left.size() == _Right.size()
         && _STD equal(_Left._Unchecked_begin(), _Left._Unchecked_end(), _Right._Unchecked_begin());
@@ -1715,7 +1715,7 @@ _NODISCARD bool operator!=(const deque<_Ty, _Alloc>& _Left, const deque<_Ty, _Al
 #endif // !_HAS_CXX20
 
 #ifdef __cpp_lib_concepts
-template <class _Ty, class _Alloc>
+_EXPORT_STD template <class _Ty, class _Alloc>
 _NODISCARD _Synth_three_way_result<_Ty> operator<=>(const deque<_Ty, _Alloc>& _Left, const deque<_Ty, _Alloc>& _Right) {
     return _STD lexicographical_compare_three_way(_Left._Unchecked_begin(), _Left._Unchecked_end(),
         _Right._Unchecked_begin(), _Right._Unchecked_end(), _Synth_three_way{});
@@ -1744,12 +1744,12 @@ _NODISCARD bool operator>=(const deque<_Ty, _Alloc>& _Left, const deque<_Ty, _Al
 #endif // ^^^ !defined(__cpp_lib_concepts) ^^^
 
 #if _HAS_CXX20
-template <class _Ty, class _Alloc, class _Uty>
+_EXPORT_STD template <class _Ty, class _Alloc, class _Uty>
 typename deque<_Ty, _Alloc>::size_type erase(deque<_Ty, _Alloc>& _Cont, const _Uty& _Val) {
     return _Erase_remove(_Cont, _Val);
 }
 
-template <class _Ty, class _Alloc, class _Pr>
+_EXPORT_STD template <class _Ty, class _Alloc, class _Pr>
 typename deque<_Ty, _Alloc>::size_type erase_if(deque<_Ty, _Alloc>& _Cont, _Pr _Pred) {
     return _Erase_remove_if(_Cont, _Pass_fn(_Pred));
 }
@@ -1757,7 +1757,7 @@ typename deque<_Ty, _Alloc>::size_type erase_if(deque<_Ty, _Alloc>& _Cont, _Pr _
 
 #if _HAS_CXX17
 namespace pmr {
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     using deque = _STD deque<_Ty, polymorphic_allocator<_Ty>>;
 } // namespace pmr
 #endif // _HAS_CXX17
diff --git a/stl/inc/exception b/stl/inc/exception
index 3d7088805c..1aec7bec2e 100644
--- a/stl/inc/exception
+++ b/stl/inc/exception
@@ -21,9 +21,10 @@ _STL_DISABLE_CLANG_WARNINGS
 _STD_BEGIN
 
 #if _HAS_DEPRECATED_UNCAUGHT_EXCEPTION
-_CXX17_DEPRECATE_UNCAUGHT_EXCEPTION _CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL uncaught_exception() noexcept;
+_EXPORT_STD extern "C++" _CXX17_DEPRECATE_UNCAUGHT_EXCEPTION _CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL
+    uncaught_exception() noexcept;
 #endif // _HAS_DEPRECATED_UNCAUGHT_EXCEPTION
-_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL uncaught_exceptions() noexcept;
+_EXPORT_STD extern "C++" _CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL uncaught_exceptions() noexcept;
 
 _STD_END
 
@@ -34,13 +35,16 @@ _STD_END
 
 _STD_BEGIN
 
-using ::terminate;
+_EXPORT_STD class exception;
+_EXPORT_STD class bad_exception;
+
+_EXPORT_STD using ::terminate;
 
 #ifndef _M_CEE_PURE
-using ::set_terminate;
-using ::terminate_handler;
+_EXPORT_STD using ::set_terminate;
+_EXPORT_STD using ::terminate_handler;
 
-_NODISCARD inline terminate_handler __CRTDECL get_terminate() noexcept {
+_EXPORT_STD _NODISCARD inline terminate_handler __CRTDECL get_terminate() noexcept {
     // get current terminate handler
     return _get_terminate();
 }
@@ -70,7 +74,7 @@ _STDEXT_END
 
 _STD_BEGIN
 
-using _STDEXT exception;
+_EXPORT_STD using _STDEXT exception;
 
 using _Prhand = void(__cdecl*)(const exception&);
 
@@ -158,19 +162,19 @@ public:
 _STDEXT_END
 
 _STD_BEGIN
-using terminate_handler = void(__cdecl*)();
+_EXPORT_STD using terminate_handler = void(__cdecl*)();
 
-inline terminate_handler __CRTDECL set_terminate(terminate_handler) noexcept {
+_EXPORT_STD inline terminate_handler __CRTDECL set_terminate(terminate_handler) noexcept {
     // register a terminate handler
     return nullptr;
 }
 
-[[noreturn]] inline void __CRTDECL terminate() noexcept {
+_EXPORT_STD [[noreturn]] inline void __CRTDECL terminate() noexcept {
     // handle exception termination
     _CSTD abort();
 }
 
-_NODISCARD inline terminate_handler __CRTDECL get_terminate() noexcept {
+_EXPORT_STD _NODISCARD inline terminate_handler __CRTDECL get_terminate() noexcept {
     // get current terminate handler
     return nullptr;
 }
@@ -191,29 +195,30 @@ _NODISCARD inline unexpected_handler __CRTDECL get_unexpected() noexcept {
 }
 #endif // _HAS_UNEXPECTED
 
-using _STDEXT bad_alloc;
-using _STDEXT bad_array_new_length;
-using _STDEXT bad_exception;
+_EXPORT_STD using _STDEXT bad_alloc;
+_EXPORT_STD using _STDEXT bad_array_new_length;
+_EXPORT_STD using _STDEXT bad_exception;
 
 _STD_END
 
 #endif // _HAS_EXCEPTIONS
 
-_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCreate(_Out_ void*) noexcept;
-_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrDestroy(_Inout_ void*) noexcept;
-_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCopy(_Out_ void*, _In_ const void*) noexcept;
-_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrAssign(_Inout_ void*, _In_ const void*) noexcept;
-_CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL __ExceptionPtrCompare(_In_ const void*, _In_ const void*) noexcept;
-_CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL __ExceptionPtrToBool(_In_ const void*) noexcept;
-_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrSwap(_Inout_ void*, _Inout_ void*) noexcept;
-_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCurrentException(void*) noexcept;
-[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrRethrow(_In_ const void*);
-_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCopyException(
+extern "C++" _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCreate(_Out_ void*) noexcept;
+extern "C++" _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrDestroy(_Inout_ void*) noexcept;
+extern "C++" _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCopy(_Out_ void*, _In_ const void*) noexcept;
+extern "C++" _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrAssign(_Inout_ void*, _In_ const void*) noexcept;
+extern "C++" _CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL __ExceptionPtrCompare(
+    _In_ const void*, _In_ const void*) noexcept;
+extern "C++" _CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL __ExceptionPtrToBool(_In_ const void*) noexcept;
+extern "C++" _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrSwap(_Inout_ void*, _Inout_ void*) noexcept;
+extern "C++" _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCurrentException(void*) noexcept;
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrRethrow(_In_ const void*);
+extern "C++" _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCopyException(
     _Inout_ void*, _In_ const void*, _In_ const void*) noexcept;
 
 _STD_BEGIN
 
-class exception_ptr {
+_EXPORT_STD class exception_ptr {
 public:
     exception_ptr() noexcept {
         __ExceptionPtrCreate(this);
@@ -304,18 +309,18 @@ private:
 #endif // __clang__
 };
 
-_NODISCARD inline exception_ptr current_exception() noexcept {
+_EXPORT_STD _NODISCARD inline exception_ptr current_exception() noexcept {
     return exception_ptr::_Current_exception();
 }
 
-[[noreturn]] inline void rethrow_exception(_In_ exception_ptr _Ptr) {
+_EXPORT_STD [[noreturn]] inline void rethrow_exception(_In_ exception_ptr _Ptr) {
     __ExceptionPtrRethrow(&_Ptr);
 }
 
 template <class _Ex>
 void* __GetExceptionInfo(_Ex);
 
-template <class _Ex>
+_EXPORT_STD template <class _Ex>
 _NODISCARD_SMART_PTR_ALLOC exception_ptr make_exception_ptr(_Ex _Except) noexcept {
     return exception_ptr::_Copy_exception(_STD addressof(_Except), __GetExceptionInfo(_Except));
 }
@@ -324,7 +329,7 @@ _NODISCARD_SMART_PTR_ALLOC exception_ptr make_exception_ptr(_Ex _Except) noexcep
     _THROW(bad_array_new_length{});
 }
 
-class nested_exception { // wrap an exception_ptr
+_EXPORT_STD class nested_exception { // wrap an exception_ptr
 public:
     nested_exception() noexcept : _Exc(_STD current_exception()) {}
 
@@ -354,7 +359,7 @@ struct _With_nested : _Uty, nested_exception { // glue user exception to nested_
         : _Uty(_STD forward<_Ty>(_Arg)), nested_exception() {} // store user exception and current_exception()
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 [[noreturn]] void throw_with_nested(_Ty&& _Arg) {
     // throw user exception, glued to nested_exception if possible
     using _Uty = decay_t<_Ty>;
@@ -370,7 +375,7 @@ template <class _Ty>
 }
 
 #ifdef _CPPRTTI
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 void rethrow_if_nested(const _Ty& _Arg) {
     // detect nested_exception inheritance
     constexpr bool _Can_use_dynamic_cast =
@@ -385,11 +390,11 @@ void rethrow_if_nested(const _Ty& _Arg) {
     }
 }
 #else // _CPPRTTI
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 void rethrow_if_nested(const _Ty&) = delete; // requires /GR option
 #endif // _CPPRTTI
 
-class bad_variant_access
+_EXPORT_STD class bad_variant_access
     : public exception { // exception for visit of a valueless variant or get<I> on a variant with index() != I
 public:
     bad_variant_access() noexcept = default;
diff --git a/stl/inc/execution b/stl/inc/execution
index 0953ef28cc..e465e848f4 100644
--- a/stl/inc/execution
+++ b/stl/inc/execution
@@ -71,7 +71,7 @@ inline constexpr size_t _Oversubmission_multiplier   = 4;
 inline constexpr size_t _Still_active                = static_cast<size_t>(-1);
 
 namespace execution {
-    class sequenced_policy {
+    _EXPORT_STD class sequenced_policy {
         // indicates support for only sequential execution, and requests termination on exceptions
     public:
         using _Standard_execution_policy   = int;
@@ -79,9 +79,9 @@ namespace execution {
         static constexpr bool _Ivdep       = false;
     };
 
-    inline constexpr sequenced_policy seq{/* unspecified */};
+    _EXPORT_STD inline constexpr sequenced_policy seq{/* unspecified */};
 
-    class parallel_policy {
+    _EXPORT_STD class parallel_policy {
         // indicates support by element access functions for parallel execution with parallel forward progress
         // guarantees, and requests termination on exceptions
     public:
@@ -90,9 +90,9 @@ namespace execution {
         static constexpr bool _Ivdep       = true;
     };
 
-    inline constexpr parallel_policy par{/* unspecified */};
+    _EXPORT_STD inline constexpr parallel_policy par{/* unspecified */};
 
-    class parallel_unsequenced_policy {
+    _EXPORT_STD class parallel_unsequenced_policy {
         // indicates support by element access functions for parallel execution with weakly parallel forward progress
         // guarantees, and requests termination on exceptions
         //
@@ -103,10 +103,10 @@ namespace execution {
         static constexpr bool _Ivdep       = true;
     };
 
-    inline constexpr parallel_unsequenced_policy par_unseq{/* unspecified */};
+    _EXPORT_STD inline constexpr parallel_unsequenced_policy par_unseq{/* unspecified */};
 
 #if _HAS_CXX20
-    class unsequenced_policy {
+    _EXPORT_STD class unsequenced_policy {
         // indicates support by element access functions for weakly parallel forward progress guarantees, and for
         // executing interleaved on the same thread, and requests termination on exceptions
         //
@@ -117,7 +117,7 @@ namespace execution {
         static constexpr bool _Ivdep       = true;
     };
 
-    inline constexpr unsequenced_policy unseq{/* unspecified */};
+    _EXPORT_STD inline constexpr unsequenced_policy unseq{/* unspecified */};
 #endif // _HAS_CXX20
 
 } // namespace execution
@@ -472,7 +472,7 @@ struct _Parallel_choose_max_chunk {
     }
 };
 
-template <class _Ty>
+_EXPORT_STD /* TRANSITION, VSO-1592329 */ template <class _Ty>
 struct alignas(_Ty) alignas(size_t) alignas(_Atomic_counter_t) _Circular_buffer { // work stealing deque extent type
     static_assert(is_trivial_v<_Ty>, "Work stealing deques work only with trivial operations");
 
@@ -1109,7 +1109,7 @@ bool _All_of_family_parallel(_FwdIt _First, const _FwdIt _Last, _Pr _Pred) {
     return true;
 }
 
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _NODISCARD bool all_of(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
     // test if all elements in [_First, _Last) satisfy _Pred with the indicated execution policy
     _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
@@ -1123,7 +1123,7 @@ _NODISCARD bool all_of(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept
     }
 }
 
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _NODISCARD bool any_of(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
     // test if any element in [_First, _Last) satisfies _Pred with the indicated execution policy
     _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
@@ -1137,7 +1137,7 @@ _NODISCARD bool any_of(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _Pr _Pr
     }
 }
 
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _NODISCARD bool none_of(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
     // test if no element in [_First, _Last) satisfies _Pred with the indicated execution policy
     _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
@@ -1186,7 +1186,7 @@ struct _Static_partitioned_for_each2 { // for_each task scheduled on the system
     }
 };
 
-template <class _ExPo, class _FwdIt, class _Fn, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Fn, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 void for_each(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Fn _Func) noexcept /* terminates */ {
     // perform function for each element [_First, _Last) with the indicated execution policy
     _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
@@ -1232,7 +1232,7 @@ _FwdIt _For_each_n_ivdep(_FwdIt _First, _Diff _Count, _Fn _Func) {
     return _First;
 }
 
-template <class _ExPo, class _FwdIt, class _Diff, class _Fn, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Diff, class _Fn, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _FwdIt for_each_n(_ExPo&&, _FwdIt _First, const _Diff _Count_raw, _Fn _Func) noexcept /* terminates */ {
     // perform function for each element [_First, _First + _Count)
     _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
@@ -1334,7 +1334,7 @@ _FwdIt _Find_parallel_unchecked(_ExPo&&, const _FwdIt _First, const _FwdIt _Last
     return _Fx(_First, _Last);
 }
 
-template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _NODISCARD _FwdIt find(_ExPo&& _Exec, _FwdIt _First, const _FwdIt _Last, const _Ty& _Val) noexcept /* terminates */ {
     // find first matching _Val
     _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
@@ -1346,7 +1346,7 @@ _NODISCARD _FwdIt find(_ExPo&& _Exec, _FwdIt _First, const _FwdIt _Last, const _
     return _First;
 }
 
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _NODISCARD _FwdIt find_if(_ExPo&& _Exec, _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
     // find first satisfying _Pred
     _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
@@ -1359,7 +1359,7 @@ _NODISCARD _FwdIt find_if(_ExPo&& _Exec, _FwdIt _First, const _FwdIt _Last, _Pr
     return _First;
 }
 
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _NODISCARD _FwdIt find_if_not(_ExPo&& _Exec, _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
     // find first satisfying !_Pred
     _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
@@ -1516,7 +1516,8 @@ struct _Static_partitioned_find_end_backward3 {
     }
 };
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _NODISCARD _FwdIt1 find_end(_ExPo&&, _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2, const _FwdIt2 _Last2,
     _Pr _Pred) noexcept /* terminates */ {
     // find last [_First2, _Last2) satisfying _Pred
@@ -1574,7 +1575,8 @@ _NODISCARD _FwdIt1 find_end(_ExPo&&, _FwdIt1 _First1, const _FwdIt1 _Last1, cons
     return _First1;
 }
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _NODISCARD _FwdIt1 find_first_of(_ExPo&& _Exec, const _FwdIt1 _First1, _FwdIt1 _Last1, const _FwdIt2 _First2,
     const _FwdIt2 _Last2, _Pr _Pred) noexcept /* terminates */ {
     // look for one of [_First2, _Last2) that matches element
@@ -1641,7 +1643,7 @@ struct _Static_partitioned_adjacent_find3 {
     }
 };
 
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _NODISCARD _FwdIt adjacent_find(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
     // find first satisfying _Pred with successor
     _Adl_verify_range(_First, _Last);
@@ -1699,7 +1701,7 @@ struct _Static_partitioned_count_if2 {
     }
 };
 
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _NODISCARD _Iter_diff_t<_FwdIt> count_if(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept
 /* terminates */ {
     // count elements satisfying _Pred
@@ -1734,7 +1736,7 @@ _NODISCARD _Iter_diff_t<_FwdIt> count_if(_ExPo&&, const _FwdIt _First, const _Fw
     return _STD count_if(_UFirst, _ULast, _Pass_fn(_Pred));
 }
 
-template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _NODISCARD _Iter_diff_t<_FwdIt> count(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, const _Ty& _Val) noexcept
 /* terminates */ {
     // count elements that match _Val
@@ -1861,7 +1863,8 @@ struct _Static_partitioned_mismatch3 {
 #pragma warning(push)
 #pragma warning(disable : 4868) // compiler may not enforce left-to-right evaluation order
                                 // in braced initializer list (/Wall)
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _NODISCARD pair<_FwdIt1, _FwdIt2> mismatch(
     _ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr _Pred) noexcept /* terminates */ {
     // return [_First1, _Last1)/[_First2, ...) mismatch
@@ -1903,7 +1906,8 @@ _NODISCARD pair<_FwdIt1, _FwdIt2> mismatch(
 }
 #pragma warning(pop)
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _NODISCARD pair<_FwdIt1, _FwdIt2> mismatch(
     _ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred) noexcept /* terminates */ {
     // return [_First1, _Last1)/[_First2, _Last2) mismatch
@@ -1980,7 +1984,8 @@ struct _Static_partitioned_equal2 {
     }
 };
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _NODISCARD bool equal(_ExPo&&, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2, _Pr _Pred) noexcept
 /* terminates */ {
     // compare [_First1, _Last1) to [_First2, ...)
@@ -2013,7 +2018,8 @@ _NODISCARD bool equal(_ExPo&&, const _FwdIt1 _First1, const _FwdIt1 _Last1, cons
     return _STD equal(_UFirst1, _ULast1, _First2, _Pass_fn(_Pred));
 }
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _NODISCARD bool equal(_ExPo&&, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2, const _FwdIt2 _Last2,
     _Pr _Pred) noexcept /* terminates */ {
     // compare [_First1, _Last1) to [_First2, _Last2)
@@ -2099,7 +2105,8 @@ struct _Static_partitioned_search3 {
     }
 };
 
-template <class _ExPo, class _FwdItHaystack, class _FwdItPat, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdItHaystack, class _FwdItPat, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _NODISCARD _FwdItHaystack search(_ExPo&&, const _FwdItHaystack _First1, _FwdItHaystack _Last1, const _FwdItPat _First2,
     const _FwdItPat _Last2, _Pr _Pred) noexcept /* terminates */ {
     // find first [_First2, _Last2) match
@@ -2228,7 +2235,8 @@ struct _Static_partitioned_search_n3 {
     }
 };
 
-template <class _ExPo, class _FwdIt, class _Diff, class _Ty, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Diff, class _Ty, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _NODISCARD _FwdIt search_n(_ExPo&&, const _FwdIt _First, _FwdIt _Last, const _Diff _Count_raw, const _Ty& _Val,
     _Pr _Pred) noexcept /* terminates */ {
     // find first _Count * _Val satisfying _Pred
@@ -2304,7 +2312,8 @@ struct _Static_partitioned_unary_transform2 {
     }
 };
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Fn, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Fn,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _FwdIt2 transform(_ExPo&&, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _Fn _Func) noexcept
 /* terminates */ {
     // transform [_First, _Last) with _Func
@@ -2382,7 +2391,7 @@ struct _Static_partitioned_binary_transform2 {
 #pragma warning(push)
 #pragma warning(disable : 4868) // compiler may not enforce left-to-right evaluation order
                                 // in braced initializer list (/Wall)
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Fn,
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Fn,
     _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _FwdIt3 transform(_ExPo&&, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2, _FwdIt3 _Dest,
     _Fn _Func) noexcept /* terminates */ {
@@ -2428,7 +2437,7 @@ _FwdIt3 transform(_ExPo&&, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _F
 }
 #pragma warning(pop)
 
-template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 void replace(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, const _Ty& _Oldval, const _Ty& _Newval) noexcept
 /* terminates */ {
     // replace each matching _Oldval with _Newval
@@ -2440,7 +2449,7 @@ void replace(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, const _Ty&
     });
 }
 
-template <class _ExPo, class _FwdIt, class _Pr, class _Ty, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, class _Ty, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 void replace_if(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, _Pr _Pred, const _Ty& _Val) noexcept
 /* terminates */ {
     // replace each satisfying _Pred with _Val
@@ -2564,7 +2573,7 @@ struct _Static_partitioned_remove_if2 {
     }
 };
 
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _NODISCARD_REMOVE_ALG _FwdIt remove_if(_ExPo&&, _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept
 /* terminates */ {
     // remove each satisfying _Pred
@@ -2592,7 +2601,7 @@ _NODISCARD_REMOVE_ALG _FwdIt remove_if(_ExPo&&, _FwdIt _First, const _FwdIt _Las
     return _First;
 }
 
-template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _NODISCARD_REMOVE_ALG _FwdIt remove(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, const _Ty& _Val) noexcept
 /* terminates */ {
     // remove each matching _Val
@@ -2703,7 +2712,7 @@ struct _Sort_operation { // context for background threads
     }
 };
 
-template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 void sort(_ExPo&&, const _RanIt _First, const _RanIt _Last, _Pr _Pred) noexcept /* terminates */ {
     // order [_First, _Last)
     _Adl_verify_range(_First, _Last);
@@ -2960,7 +2969,7 @@ struct _Static_partitioned_stable_sort3 {
     }
 };
 
-template <class _ExPo, class _BidIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _BidIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 void stable_sort(_ExPo&&, const _BidIt _First, const _BidIt _Last, _Pr _Pred) noexcept /* terminates */ {
     // sort preserving order of equivalents
     _Adl_verify_range(_First, _Last);
@@ -3047,7 +3056,7 @@ struct _Static_partitioned_is_sorted_until2 {
     }
 };
 
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _NODISCARD _FwdIt is_sorted_until(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
     // find extent of range that is ordered by predicate
     _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
@@ -3201,7 +3210,7 @@ struct _Static_partitioned_is_partitioned {
     }
 };
 
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _NODISCARD bool is_partitioned(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
     // test if [_First, _Last) is partitioned by _Pred
     _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
@@ -3273,7 +3282,7 @@ struct _Static_partitioned_is_heap_until2 {
     }
 };
 
-template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _NODISCARD _RanIt is_heap_until(_ExPo&&, _RanIt _First, _RanIt _Last, _Pr _Pred) noexcept /* terminates */ {
     // find extent of range that is a heap
     _REQUIRE_PARALLEL_ITERATOR(_RanIt);
@@ -3522,7 +3531,7 @@ struct _Static_partitioned_partition2 {
     }
 };
 
-template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _FwdIt partition(_ExPo&&, _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
     // move elements satisfying _Pred to beginning of sequence
     _Adl_verify_range(_First, _Last);
@@ -3851,7 +3860,7 @@ struct _Set_intersection_per_chunk {
     }
 };
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr,
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr,
     _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _FwdIt3 set_intersection(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _FwdIt3 _Dest,
     _Pr _Pred) noexcept /* terminates */ {
@@ -3943,7 +3952,7 @@ struct _Set_difference_per_chunk {
     }
 };
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr,
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr,
     _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _FwdIt3 set_difference(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _FwdIt3 _Dest,
     _Pr _Pred) noexcept /* terminates */ {
@@ -4048,7 +4057,8 @@ struct _Static_partitioned_reduce2 {
     }
 };
 
-template <class _ExPo, class _FwdIt, class _Ty, class _BinOp, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, class _BinOp,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _NODISCARD _Ty reduce(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _Ty _Val, _BinOp _Reduce_op) noexcept
 /* terminates */ {
     // return commutative and associative reduction of _Val and [_First, _Last), using _Reduce_op
@@ -4147,7 +4157,7 @@ struct _Static_partitioned_transform_reduce_binary2 { // transform-reduction tas
 #pragma warning(push)
 #pragma warning(disable : 4868) // compiler may not enforce left-to-right evaluation order
                                 // in braced initializer list (/Wall)
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp1, class _BinOp2,
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp1, class _BinOp2,
     _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _NODISCARD _Ty transform_reduce(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Ty _Val, _BinOp1 _Reduce_op,
     _BinOp2 _Transform_op) noexcept /* terminates */ {
@@ -4243,7 +4253,7 @@ struct _Static_partitioned_transform_reduce2 { // transformed reduction task sch
     }
 };
 
-template <class _ExPo, class _FwdIt, class _Ty, class _BinOp, class _UnaryOp,
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, class _BinOp, class _UnaryOp,
     _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _NODISCARD _Ty transform_reduce(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _Ty _Val, _BinOp _Reduce_op,
     _UnaryOp _Transform_op) noexcept /* terminates */ {
@@ -4393,7 +4403,7 @@ struct _Static_partitioned_exclusive_scan2 {
     }
 };
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp,
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp,
     _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _FwdIt2 exclusive_scan(_ExPo&&, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _Ty _Val,
     _BinOp _Reduce_op) noexcept /* terminates */ {
@@ -4522,7 +4532,7 @@ struct _Static_partitioned_inclusive_scan2 {
     }
 };
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, class _Ty,
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, class _Ty,
     _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _FwdIt2 inclusive_scan(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op, _Ty _Val) noexcept
 /* terminates */ {
@@ -4566,7 +4576,8 @@ _FwdIt2 inclusive_scan(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _B
     return _Dest;
 }
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _FwdIt2 inclusive_scan(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op) noexcept
 /* terminates */ {
     // compute partial noncommutative and associative reductions into _Dest, using _Reduce_op
@@ -4709,7 +4720,7 @@ struct _Static_partitioned_transform_exclusive_scan2 {
     }
 };
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp, class _UnaryOp,
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp, class _UnaryOp,
     _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _FwdIt2 transform_exclusive_scan(_ExPo&&, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _Ty _Val,
     _BinOp _Reduce_op, _UnaryOp _Transform_op) noexcept /* terminates */ {
@@ -4840,7 +4851,7 @@ struct _Static_partitioned_transform_inclusive_scan2 {
     }
 };
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp, class _UnaryOp,
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp, class _UnaryOp,
     _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _FwdIt2 transform_inclusive_scan(_ExPo&&, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op,
     _UnaryOp _Transform_op, _Ty _Val) noexcept /* terminates */ {
@@ -4886,7 +4897,7 @@ _FwdIt2 transform_inclusive_scan(_ExPo&&, const _FwdIt1 _First, const _FwdIt1 _L
     return _Dest;
 }
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, class _UnaryOp,
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, class _UnaryOp,
     _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _FwdIt2 transform_inclusive_scan(_ExPo&&, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op,
     _UnaryOp _Transform_op) noexcept /* terminates */ {
@@ -4988,7 +4999,8 @@ _FwdIt2 _Adjacent_difference_seq(_FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _D
     return _Dest;
 }
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
 _FwdIt2 adjacent_difference(_ExPo&&, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Diff_op) noexcept
 /* terminates */ {
     // compute adjacent differences into _Dest
diff --git a/stl/inc/expected b/stl/inc/expected
index 20894ab5a3..3f25d69314 100644
--- a/stl/inc/expected
+++ b/stl/inc/expected
@@ -25,7 +25,7 @@ _STL_DISABLE_CLANG_WARNINGS
 
 _STD_BEGIN
 
-template <class _Err>
+_EXPORT_STD template <class _Err>
 class unexpected;
 
 template <class _Err>
@@ -39,7 +39,7 @@ struct _Check_unexpected_argument : true_type {
 };
 
 // [expected.un.general]
-template <class _Err>
+_EXPORT_STD template <class _Err>
 class unexpected {
     static_assert(_Check_unexpected_argument<_Err>::value);
 
@@ -110,7 +110,7 @@ private:
 template <class _Err>
 unexpected(_Err) -> unexpected<_Err>;
 
-template <class _Err>
+_EXPORT_STD template <class _Err>
 class bad_expected_access;
 
 template <>
@@ -134,7 +134,7 @@ protected:
 #endif // !_HAS_EXCEPTIONS
 };
 
-template <class _Err>
+_EXPORT_STD template <class _Err>
 class bad_expected_access : public bad_expected_access<void> {
 public:
     explicit bad_expected_access(_Err _Unex) noexcept(is_nothrow_move_constructible_v<_Err>) // strengthened
@@ -157,13 +157,11 @@ private:
     _Err _Unexpected;
 };
 
-struct unexpect_t {
-    explicit unexpect_t() = default;
-};
+_EXPORT_STD struct unexpect_t { explicit unexpect_t() = default; };
 
-inline constexpr unexpect_t unexpect{};
+_EXPORT_STD inline constexpr unexpect_t unexpect{};
 
-template <class _Ty, class _Err>
+_EXPORT_STD template <class _Ty, class _Err>
 class expected {
     static_assert(!is_reference_v<_Ty>, "T must not be a reference type. (N4910 [expected.object.general]/2)");
     static_assert(!is_function_v<_Ty>, "T must not be a function type. (N4910 [expected.object.general]/2)");
diff --git a/stl/inc/experimental/filesystem b/stl/inc/experimental/filesystem
index ea4eb2cd5c..d4d5bab72f 100644
--- a/stl/inc/experimental/filesystem
+++ b/stl/inc/experimental/filesystem
@@ -89,7 +89,7 @@ enum class copy_options { // names for copy options
     _Unspecified_recursion_prevention_tag = 512
 };
 
-_BITMASK_OPS(copy_options)
+_BITMASK_OPS(_EMPTY_ARGUMENT, copy_options)
 
 enum class directory_options { // names for directory options
     none = 0,
@@ -121,7 +121,7 @@ enum class perms { // names for permissions
     resolve_symlinks = 0x40000
 };
 
-_BITMASK_OPS(perms)
+_BITMASK_OPS(_EMPTY_ARGUMENT, perms)
 
 class file_status { // stores file status
 public:
diff --git a/stl/inc/filesystem b/stl/inc/filesystem
index df4e0f811b..e71ac1512a 100644
--- a/stl/inc/filesystem
+++ b/stl/inc/filesystem
@@ -173,7 +173,7 @@ namespace filesystem {
     template <class _Ty>
     inline constexpr bool _Is_Source = _Is_Source_impl<decay_t<_Ty>>;
 
-    class path;
+    _EXPORT_STD class path;
 
     template <>
     inline constexpr bool _Is_Source<path> = false; // to avoid constraint recursion via the converting constructor and
@@ -613,7 +613,7 @@ namespace filesystem {
     template <class _Base_iter>
     class _Path_iterator;
 
-    class path {
+    _EXPORT_STD class path {
         template <class _Base_iter>
         friend class _Path_iterator;
         friend inline __std_win_error _Absolute(path& _Result, const wstring& _Text);
@@ -1372,12 +1372,12 @@ namespace filesystem {
         string_type _Text;
     };
 
-    template <class _Src, enable_if_t<_Is_Source<_Src>, int> = 0>
+    _EXPORT_STD template <class _Src, enable_if_t<_Is_Source<_Src>, int> = 0>
     _CXX20_DEPRECATE_U8PATH _NODISCARD path u8path(const _Src& _Source) { // construct a path from UTF-8 _Source
         return path(_Convert_Source_to_wide(_Source, _Utf8_conversion{}));
     }
 
-    template <class _InIt>
+    _EXPORT_STD template <class _InIt>
     _CXX20_DEPRECATE_U8PATH _NODISCARD path u8path(_InIt _First, _InIt _Last) {
         // construct a path from UTF-8 [_First, _Last)
         static_assert(_Is_EcharT<_Iter_value_t<_InIt>>, "invalid value_type, see N4810 29.11.4 [fs.req]/3");
@@ -1584,11 +1584,11 @@ namespace filesystem {
         const path* _Mypath{};
     };
 
-    inline void swap(path& _Left, path& _Right) noexcept {
+    _EXPORT_STD inline void swap(path& _Left, path& _Right) noexcept {
         _Left.swap(_Right);
     }
 
-    _NODISCARD inline size_t hash_value(const path& _Path) noexcept {
+    _EXPORT_STD _NODISCARD inline size_t hash_value(const path& _Path) noexcept {
         // calculate a hash value for _Path
         // See path::compare; we effectively decompose the path with special handling for root_name, root_directory.
         // Examples:
@@ -1748,7 +1748,7 @@ namespace filesystem {
         return iterator(_Text.cend(), this);
     }
 
-    class filesystem_error : public system_error { // base of all filesystem-error exceptions
+    _EXPORT_STD class filesystem_error : public system_error { // base of all filesystem-error exceptions
     public:
         filesystem_error(const string& _Message, const error_code _Errcode)
             : system_error(_Errcode, _Message), _What(runtime_error::what()) {}
@@ -1829,7 +1829,7 @@ namespace filesystem {
         _THROW(filesystem_error(_Op, _Path1, _Path2, _Error));
     }
 
-    enum class file_type {
+    _EXPORT_STD enum class file_type {
         none,
         not_found,
         regular,
@@ -1848,7 +1848,7 @@ namespace filesystem {
         junction // implementation-defined value indicating an NT junction
     };
 
-    enum class perms {
+    _EXPORT_STD enum class perms {
         none = 0,
 
         owner_read  = 0400,
@@ -1877,9 +1877,9 @@ namespace filesystem {
         _File_attribute_readonly = all & ~_All_write // returned for files with FILE_ATTRIBUTE_READONLY
     };
 
-    _BITMASK_OPS(perms)
+    _BITMASK_OPS(_EXPORT_STD, perms)
 
-    enum class copy_options {
+    _EXPORT_STD enum class copy_options {
         none = static_cast<int>(__std_fs_copy_options::_None),
 
         _Existing_mask     = static_cast<int>(__std_fs_copy_options::_Existing_mask),
@@ -1901,9 +1901,9 @@ namespace filesystem {
         _Unspecified_copy_prevention_tag = 0x10000 // to be removed by LWG-3057
     };
 
-    _BITMASK_OPS(copy_options)
+    _BITMASK_OPS(_EXPORT_STD, copy_options)
 
-    class file_status {
+    _EXPORT_STD class file_status {
     public:
         // [fs.file_status.cons], constructors and destructor
         file_status() noexcept = default;
@@ -1982,7 +1982,7 @@ namespace filesystem {
         perms _Myperms     = perms::unknown;
     };
 
-    _NODISCARD inline bool exists(const file_status _Status) noexcept {
+    _EXPORT_STD _NODISCARD inline bool exists(const file_status _Status) noexcept {
         // tests whether _Status indicates an existing file
         switch (_Status.type()) {
         case file_type::none:
@@ -2002,27 +2002,27 @@ namespace filesystem {
         }
     }
 
-    _NODISCARD inline bool is_block_file(const file_status _Status) noexcept {
+    _EXPORT_STD _NODISCARD inline bool is_block_file(const file_status _Status) noexcept {
         // tests whether _Status indicates a block file
         return _Status.type() == file_type::block;
     }
 
-    _NODISCARD inline bool is_character_file(const file_status _Status) noexcept {
+    _EXPORT_STD _NODISCARD inline bool is_character_file(const file_status _Status) noexcept {
         // tests whether _Status indicates a character file
         return _Status.type() == file_type::character;
     }
 
-    _NODISCARD inline bool is_directory(const file_status _Status) noexcept {
+    _EXPORT_STD _NODISCARD inline bool is_directory(const file_status _Status) noexcept {
         // tests whether _Status indicates a directory
         return _Status.type() == file_type::directory;
     }
 
-    _NODISCARD inline bool is_fifo(const file_status _Status) noexcept {
+    _EXPORT_STD _NODISCARD inline bool is_fifo(const file_status _Status) noexcept {
         // tests whether _Status indicates a fifo
         return _Status.type() == file_type::fifo;
     }
 
-    _NODISCARD inline bool is_other(const file_status _Status) noexcept {
+    _EXPORT_STD _NODISCARD inline bool is_other(const file_status _Status) noexcept {
         // tests whether _Status indicates other file types
         switch (_Status.type()) {
         case file_type::none:
@@ -2042,17 +2042,17 @@ namespace filesystem {
         }
     }
 
-    _NODISCARD inline bool is_regular_file(const file_status _Status) noexcept {
+    _EXPORT_STD _NODISCARD inline bool is_regular_file(const file_status _Status) noexcept {
         // tests whether _Status indicates a regular file
         return _Status.type() == file_type::regular;
     }
 
-    _NODISCARD inline bool is_socket(const file_status _Status) noexcept {
+    _EXPORT_STD _NODISCARD inline bool is_socket(const file_status _Status) noexcept {
         // tests whether _Status indicates a socket
         return _Status.type() == file_type::socket;
     }
 
-    _NODISCARD inline bool is_symlink(const file_status _Status) noexcept {
+    _EXPORT_STD _NODISCARD inline bool is_symlink(const file_status _Status) noexcept {
         // tests whether _Status indicates a symlink
         return _Status.type() == file_type::symlink;
     }
@@ -2076,12 +2076,12 @@ namespace filesystem {
         __std_fs_stats_flags::_Attributes | __std_fs_stats_flags::_Reparse_tag;
 
 #if _HAS_CXX20
-    using file_time_type = _CHRONO time_point<_CHRONO file_clock>;
+    _EXPORT_STD using file_time_type = _CHRONO time_point<_CHRONO file_clock>;
 #else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
     using file_time_type = _CHRONO time_point<filesystem::_File_time_clock>;
 #endif // ^^^ !_HAS_CXX20
 
-    class directory_entry {
+    _EXPORT_STD class directory_entry {
     public:
         // [fs.dir.entry.cons], constructors and destructor
         directory_entry() noexcept : _Cached_data{}, _Path() {}
@@ -2482,8 +2482,8 @@ namespace filesystem {
         filesystem::path _Path;
     };
 
-    enum class directory_options { none = 0, follow_directory_symlink = 1, skip_permission_denied = 2 };
-    _BITMASK_OPS(directory_options)
+    _EXPORT_STD enum class directory_options { none = 0, follow_directory_symlink = 1, skip_permission_denied = 2 };
+    _BITMASK_OPS(_EXPORT_STD, directory_options)
 
     struct _Dir_enum_impl {
         _NODISCARD static __std_win_error _Advance_and_reset_if_no_more_files(shared_ptr<_Dir_enum_impl>& _Ptr) {
@@ -2587,8 +2587,8 @@ namespace filesystem {
         _Find_file_handle _Dir;
     };
 
-    class directory_iterator;
-    class recursive_directory_iterator;
+    _EXPORT_STD class directory_iterator;
+    _EXPORT_STD class recursive_directory_iterator;
 
     struct _Directory_entry_proxy {
         _NODISCARD directory_entry operator*() && noexcept {
@@ -2604,7 +2604,7 @@ namespace filesystem {
         directory_entry _Entry;
     };
 
-    class directory_iterator {
+    _EXPORT_STD class directory_iterator {
     public:
         using iterator_category = input_iterator_tag;
         using value_type        = directory_entry;
@@ -2696,11 +2696,11 @@ namespace filesystem {
         shared_ptr<_Dir_enum_impl> _Impl;
     };
 
-    _NODISCARD inline directory_iterator begin(directory_iterator _Iter) noexcept {
+    _EXPORT_STD _NODISCARD inline directory_iterator begin(directory_iterator _Iter) noexcept {
         return _Iter;
     }
 
-    _NODISCARD inline directory_iterator end(directory_iterator) noexcept {
+    _EXPORT_STD _NODISCARD inline directory_iterator end(directory_iterator) noexcept {
         return {};
     }
 
@@ -2828,7 +2828,7 @@ namespace filesystem {
             : _Dir_enum_impl(_STD move(_Create_data)), _Options(_Options_arg) {}
     };
 
-    class recursive_directory_iterator {
+    _EXPORT_STD class recursive_directory_iterator {
     public:
         using iterator_category = input_iterator_tag;
         using value_type        = directory_entry;
@@ -2948,11 +2948,11 @@ namespace filesystem {
         shared_ptr<_Recursive_dir_enum_impl> _Impl;
     };
 
-    _NODISCARD inline recursive_directory_iterator begin(recursive_directory_iterator _Iter) noexcept {
+    _EXPORT_STD _NODISCARD inline recursive_directory_iterator begin(recursive_directory_iterator _Iter) noexcept {
         return _Iter;
     }
 
-    _NODISCARD inline recursive_directory_iterator end(recursive_directory_iterator) noexcept {
+    _EXPORT_STD _NODISCARD inline recursive_directory_iterator end(recursive_directory_iterator) noexcept {
         return {};
     }
 
@@ -2977,7 +2977,7 @@ namespace filesystem {
         return _Err;
     }
 
-    _NODISCARD inline path absolute(const path& _Input) {
+    _EXPORT_STD _NODISCARD inline path absolute(const path& _Input) {
         // normalize path according to system semantics, without touching the disk
         // calls GetFullPathNameW
         path _Result;
@@ -2989,7 +2989,7 @@ namespace filesystem {
         return _Result;
     }
 
-    _NODISCARD inline path absolute(const path& _Input, error_code& _Ec) {
+    _EXPORT_STD _NODISCARD inline path absolute(const path& _Input, error_code& _Ec) {
         // normalize path according to system semantics, without touching the disk
         // calls GetFullPathNameW
         _Ec.clear(); // for exception safety
@@ -3051,7 +3051,7 @@ namespace filesystem {
         return __std_win_error::_Success;
     }
 
-    _NODISCARD inline path canonical(const path& _Input) {
+    _EXPORT_STD _NODISCARD inline path canonical(const path& _Input) {
         // resolve the final path according to system semantics, by opening the file
         // calls GetFinalPathNameByHandleW
         path _Result;
@@ -3063,7 +3063,7 @@ namespace filesystem {
         return _Result;
     }
 
-    _NODISCARD inline path canonical(const path& _Input, error_code& _Ec) {
+    _EXPORT_STD _NODISCARD inline path canonical(const path& _Input, error_code& _Ec) {
         // resolve the final path according to system semantics, by opening the file
         // calls GetFinalPathNameByHandleW
         _Ec.clear(); // for exception safety
@@ -3109,7 +3109,7 @@ namespace filesystem {
         return _Cleaned_link;
     }
 
-    inline void create_directory_symlink(const path& _To, const path& _New_symlink) {
+    _EXPORT_STD inline void create_directory_symlink(const path& _To, const path& _New_symlink) {
         // create a symlink for a directory, _New_symlink -> _To
         const auto _Cleaned = _Get_cleaned_symlink_target(_To);
         if (!_Cleaned) {
@@ -3123,7 +3123,8 @@ namespace filesystem {
         }
     }
 
-    inline void create_directory_symlink(const path& _To, const path& _New_symlink, error_code& _Ec) noexcept {
+    _EXPORT_STD inline void create_directory_symlink(
+        const path& _To, const path& _New_symlink, error_code& _Ec) noexcept {
         // create a symlink for a directory, _New_symlink -> _To
         const auto _Cleaned = _Get_cleaned_symlink_target(_To);
         if (_Cleaned) {
@@ -3134,7 +3135,7 @@ namespace filesystem {
         }
     }
 
-    inline void create_hard_link(const path& _To, const path& _New_hard_link) {
+    _EXPORT_STD inline void create_hard_link(const path& _To, const path& _New_hard_link) {
         // create a hard link for a file, _New_hard_link -> _To
         // note reversed parameter order:
         const auto _Err = __std_fs_create_hard_link(_New_hard_link.c_str(), _To.c_str());
@@ -3143,13 +3144,13 @@ namespace filesystem {
         }
     }
 
-    inline void create_hard_link(const path& _To, const path& _New_hard_link, error_code& _Ec) noexcept {
+    _EXPORT_STD inline void create_hard_link(const path& _To, const path& _New_hard_link, error_code& _Ec) noexcept {
         // create a hard link for a file, _New_hard_link -> _To
         // note reversed parameter order:
         _Ec = _Make_ec(__std_fs_create_hard_link(_New_hard_link.c_str(), _To.c_str()));
     }
 
-    inline void create_symlink(const path& _To, const path& _New_symlink) {
+    _EXPORT_STD inline void create_symlink(const path& _To, const path& _New_symlink) {
         // create a symlink for a file, _New_symlink -> _To
         const auto _Cleaned = _Get_cleaned_symlink_target(_To);
         if (!_Cleaned) {
@@ -3163,7 +3164,7 @@ namespace filesystem {
         }
     }
 
-    inline void create_symlink(const path& _To, const path& _New_symlink, error_code& _Ec) noexcept {
+    _EXPORT_STD inline void create_symlink(const path& _To, const path& _New_symlink, error_code& _Ec) noexcept {
         // create a symlink for a file, _New_symlink -> _To
         const auto _Cleaned = _Get_cleaned_symlink_target(_To);
         if (_Cleaned) {
@@ -3222,14 +3223,14 @@ namespace filesystem {
         return __std_win_error::_Success;
     }
 
-    _NODISCARD inline path read_symlink(const path& _Symlink_path, error_code& _Ec) {
+    _EXPORT_STD _NODISCARD inline path read_symlink(const path& _Symlink_path, error_code& _Ec) {
         _Ec.clear();
         path _Result;
         _Ec = _Make_ec(_Read_symlink(_Symlink_path, _Result));
         return _Result;
     }
 
-    _NODISCARD inline path read_symlink(const path& _Symlink_path) {
+    _EXPORT_STD _NODISCARD inline path read_symlink(const path& _Symlink_path) {
         path _Result;
         const auto _Err = _Read_symlink(_Symlink_path, _Result);
         if (_Err != __std_win_error::_Success) {
@@ -3340,18 +3341,19 @@ namespace filesystem {
         return _Err;
     }
 
-    inline void copy_symlink(const path& _Symlink, const path& _New_symlink, error_code& _Ec) {
+    _EXPORT_STD inline void copy_symlink(const path& _Symlink, const path& _New_symlink, error_code& _Ec) {
         _Ec = _Make_ec(_Copy_symlink(_Symlink, _New_symlink));
     }
 
-    inline void copy_symlink(const path& _Symlink, const path& _New_symlink) {
+    _EXPORT_STD inline void copy_symlink(const path& _Symlink, const path& _New_symlink) {
         const auto _Err = _Copy_symlink(_Symlink, _New_symlink);
         if (_Err != __std_win_error::_Success) {
             _Throw_fs_error("copy_symlink", _Err, _Symlink, _New_symlink);
         }
     }
 
-    inline bool copy_file(const path& _From, const path& _To, const copy_options _Options, error_code& _Ec) noexcept
+    _EXPORT_STD inline bool copy_file(
+        const path& _From, const path& _To, const copy_options _Options, error_code& _Ec) noexcept
     /* strengthened */ {
         // copy a file _From -> _To according to _Options
         const auto _Result =
@@ -3360,7 +3362,7 @@ namespace filesystem {
         return _Result._Copied;
     }
 
-    inline bool copy_file(const path& _From, const path& _To, const copy_options _Options) {
+    _EXPORT_STD inline bool copy_file(const path& _From, const path& _To, const copy_options _Options) {
         // copy a file _From -> _To according to _Options
         const auto _Result =
             __std_fs_copy_file(_From.c_str(), _To.c_str(), static_cast<__std_fs_copy_options>(_Options));
@@ -3371,12 +3373,12 @@ namespace filesystem {
         return _Result._Copied;
     }
 
-    inline bool copy_file(const path& _From, const path& _To, error_code& _Ec) noexcept /* strengthened */ {
+    _EXPORT_STD inline bool copy_file(const path& _From, const path& _To, error_code& _Ec) noexcept /* strengthened */ {
         // copy a file _From -> _To, failing if the destination exists
         return _STD filesystem::copy_file(_From, _To, copy_options::none, _Ec);
     }
 
-    inline bool copy_file(const path& _From, const path& _To) {
+    _EXPORT_STD inline bool copy_file(const path& _From, const path& _To) {
         // copy a file _From -> _To, failing if the destination exists
         return _STD filesystem::copy_file(_From, _To, copy_options::none);
     }
@@ -3398,7 +3400,7 @@ namespace filesystem {
         return {__std_win_error::_Success, _CSTD memcmp(&_Left_id, &_Right_id, sizeof(__std_fs_file_id)) == 0};
     }
 
-    _NODISCARD inline bool equivalent(const path& _Lhs, const path& _Rhs) {
+    _EXPORT_STD _NODISCARD inline bool equivalent(const path& _Lhs, const path& _Rhs) {
         // test if the paths _Lhs and _Rhs refer to the same file
         const auto _Result = _Equivalent(_Lhs.c_str(), _Rhs.c_str());
         if (_Result.first != __std_win_error::_Success) {
@@ -3408,19 +3410,19 @@ namespace filesystem {
         return _Result.second;
     }
 
-    _NODISCARD inline bool equivalent(const path& _Lhs, const path& _Rhs, error_code& _Ec) noexcept {
+    _EXPORT_STD _NODISCARD inline bool equivalent(const path& _Lhs, const path& _Rhs, error_code& _Ec) noexcept {
         // test if the paths _Lhs and _Rhs refer to the same file
         const auto _Result = _Equivalent(_Lhs.c_str(), _Rhs.c_str());
         _Ec                = _Make_ec(_Result.first);
         return _Result.second;
     }
 
-    _NODISCARD inline file_status status(const path& _Path);
-    _NODISCARD inline file_status status(const path& _Path, error_code& _Ec) noexcept;
-    _NODISCARD inline file_status symlink_status(const path& _Path);
-    _NODISCARD inline file_status symlink_status(const path& _Path, error_code& _Ec) noexcept;
+    _EXPORT_STD _NODISCARD inline file_status status(const path& _Path);
+    _EXPORT_STD _NODISCARD inline file_status status(const path& _Path, error_code& _Ec) noexcept;
+    _EXPORT_STD _NODISCARD inline file_status symlink_status(const path& _Path);
+    _EXPORT_STD _NODISCARD inline file_status symlink_status(const path& _Path, error_code& _Ec) noexcept;
 
-    _NODISCARD inline bool exists(const path& _Target, error_code& _Ec) noexcept {
+    _EXPORT_STD _NODISCARD inline bool exists(const path& _Target, error_code& _Ec) noexcept {
         const auto _Type = _STD filesystem::status(_Target, _Ec).type();
         if (_Type != file_type::none) {
             _Ec.clear();
@@ -3430,7 +3432,7 @@ namespace filesystem {
         return false;
     }
 
-    _NODISCARD inline bool exists(const path& _Target) {
+    _EXPORT_STD _NODISCARD inline bool exists(const path& _Target) {
         error_code _Ec;
         const bool _Result = _STD filesystem::exists(_Target, _Ec);
         if (_Ec) {
@@ -3453,7 +3455,7 @@ namespace filesystem {
         return _Error;
     }
 
-    _NODISCARD inline uintmax_t file_size(const path& _Path) {
+    _EXPORT_STD _NODISCARD inline uintmax_t file_size(const path& _Path) {
         uintmax_t _Result;
         const auto _Error = _File_size(_Path, _Result);
         if (_Error != __std_win_error::_Success) {
@@ -3463,7 +3465,7 @@ namespace filesystem {
         return _Result;
     }
 
-    _NODISCARD inline uintmax_t file_size(const path& _Path, error_code& _Ec) noexcept {
+    _EXPORT_STD _NODISCARD inline uintmax_t file_size(const path& _Path, error_code& _Ec) noexcept {
         uintmax_t _Result;
         _Ec = _Make_ec(_File_size(_Path, _Result));
         return _Result;
@@ -3482,7 +3484,7 @@ namespace filesystem {
         return _Error;
     }
 
-    _NODISCARD inline uintmax_t hard_link_count(const path& _Target) {
+    _EXPORT_STD _NODISCARD inline uintmax_t hard_link_count(const path& _Target) {
         // get the number of hard links to _Target
         uintmax_t _Result;
         const auto _Err = _Hard_link_count(_Target.c_str(), _Result);
@@ -3493,46 +3495,46 @@ namespace filesystem {
         return _Result;
     }
 
-    _NODISCARD inline uintmax_t hard_link_count(const path& _Target, error_code& _Ec) noexcept {
+    _EXPORT_STD _NODISCARD inline uintmax_t hard_link_count(const path& _Target, error_code& _Ec) noexcept {
         // get the number of hard links to _Target
         uintmax_t _Result;
         _Ec = _Make_ec(_Hard_link_count(_Target.c_str(), _Result));
         return _Result;
     }
 
-    _NODISCARD inline bool is_block_file(const path&) noexcept /* strengthened */ {
+    _EXPORT_STD _NODISCARD inline bool is_block_file(const path&) noexcept /* strengthened */ {
         // tests whether the input path is a block special file (never on Windows)
         return false;
     }
 
-    _NODISCARD inline bool is_block_file(const path& _Path, error_code& _Ec) noexcept {
+    _EXPORT_STD _NODISCARD inline bool is_block_file(const path& _Path, error_code& _Ec) noexcept {
         // tests whether the input path is a block special file (never on Windows)
         (void) _STD filesystem::status(_Path, _Ec);
         return false; // note status sets _Ec to an error on nonexistent input
     }
 
-    _NODISCARD inline bool is_character_file(const path&) noexcept /* strengthened */ {
+    _EXPORT_STD _NODISCARD inline bool is_character_file(const path&) noexcept /* strengthened */ {
         // tests whether the input path is a character special file (never on Windows)
         return false;
     }
 
-    _NODISCARD inline bool is_character_file(const path& _Path, error_code& _Ec) noexcept {
+    _EXPORT_STD _NODISCARD inline bool is_character_file(const path& _Path, error_code& _Ec) noexcept {
         // tests whether the input path is a character special file (never on Windows)
         (void) _STD filesystem::status(_Path, _Ec);
         return false; // note status sets _Ec to an error on nonexistent input
     }
 
-    _NODISCARD inline bool is_directory(const path& _Path) {
+    _EXPORT_STD _NODISCARD inline bool is_directory(const path& _Path) {
         // tests whether _Path is a directory
         return _STD filesystem::is_directory(_STD filesystem::status(_Path));
     }
 
-    _NODISCARD inline bool is_directory(const path& _Path, error_code& _Ec) noexcept {
+    _EXPORT_STD _NODISCARD inline bool is_directory(const path& _Path, error_code& _Ec) noexcept {
         // tests whether _Path is a directory
         return _STD filesystem::is_directory(_STD filesystem::status(_Path, _Ec));
     }
 
-    _NODISCARD inline bool is_empty(const path& _Path, error_code& _Ec) {
+    _EXPORT_STD _NODISCARD inline bool is_empty(const path& _Path, error_code& _Ec) {
         // test whether _Path refers to a zero sized file or empty directory
         constexpr auto _Flags = __std_fs_stats_flags::_Attributes | __std_fs_stats_flags::_File_size
                               | __std_fs_stats_flags::_Follow_symlinks;
@@ -3551,7 +3553,7 @@ namespace filesystem {
         }
     }
 
-    _NODISCARD inline bool is_empty(const path& _Path) {
+    _EXPORT_STD _NODISCARD inline bool is_empty(const path& _Path) {
         // test whether _Path refers to a zero sized file or empty directory
         error_code _Ec;
         const bool _Result = is_empty(_Path, _Ec);
@@ -3562,59 +3564,59 @@ namespace filesystem {
         return _Result;
     }
 
-    _NODISCARD inline bool is_fifo(const path&) noexcept /* strengthened */ {
+    _EXPORT_STD _NODISCARD inline bool is_fifo(const path&) noexcept /* strengthened */ {
         // tests whether the input path is a fifo (never on Windows)
         return false;
     }
 
-    _NODISCARD inline bool is_fifo(const path& _Path, error_code& _Ec) noexcept {
+    _EXPORT_STD _NODISCARD inline bool is_fifo(const path& _Path, error_code& _Ec) noexcept {
         // tests whether the input path is a fifo (never on Windows)
         (void) _STD filesystem::status(_Path, _Ec);
         return false; // note status sets _Ec to an error on nonexistent input
     }
 
-    _NODISCARD inline bool is_other(const path& _Path) {
+    _EXPORT_STD _NODISCARD inline bool is_other(const path& _Path) {
         // tests whether _Path is an "other" file (such as a junction)
         return _STD filesystem::is_other(_STD filesystem::status(_Path));
     }
 
-    _NODISCARD inline bool is_other(const path& _Path, error_code& _Ec) noexcept {
+    _EXPORT_STD _NODISCARD inline bool is_other(const path& _Path, error_code& _Ec) noexcept {
         // tests whether _Path is an "other" file (such as a junction)
         return _STD filesystem::is_other(_STD filesystem::status(_Path, _Ec));
     }
 
-    _NODISCARD inline bool is_regular_file(const path& _Path) {
+    _EXPORT_STD _NODISCARD inline bool is_regular_file(const path& _Path) {
         // tests whether _Path is a regular file
         return _STD filesystem::is_regular_file(_STD filesystem::status(_Path));
     }
 
-    _NODISCARD inline bool is_regular_file(const path& _Path, error_code& _Ec) noexcept {
+    _EXPORT_STD _NODISCARD inline bool is_regular_file(const path& _Path, error_code& _Ec) noexcept {
         // tests whether _Path is a regular file
         return _STD filesystem::is_regular_file(_STD filesystem::status(_Path, _Ec));
     }
 
-    _NODISCARD inline bool is_socket(const path&) noexcept /* strengthened */ {
+    _EXPORT_STD _NODISCARD inline bool is_socket(const path&) noexcept /* strengthened */ {
         // tests whether the input path is a socket (never on Windows)
         return false;
     }
 
-    _NODISCARD inline bool is_socket(const path& _Path, error_code& _Ec) noexcept {
+    _EXPORT_STD _NODISCARD inline bool is_socket(const path& _Path, error_code& _Ec) noexcept {
         // tests whether the input path is a socket (never on Windows)
         (void) _STD filesystem::status(_Path, _Ec);
         return false; // note status sets _Ec to an error on nonexistent input
     }
 
-    _NODISCARD inline bool is_symlink(const path& _Path) {
+    _EXPORT_STD _NODISCARD inline bool is_symlink(const path& _Path) {
         // tests whether _Path is a symlink
         return _STD filesystem::is_symlink(_STD filesystem::symlink_status(_Path));
     }
 
-    _NODISCARD inline bool is_symlink(const path& _Path, error_code& _Ec) noexcept {
+    _EXPORT_STD _NODISCARD inline bool is_symlink(const path& _Path, error_code& _Ec) noexcept {
         // tests whether _Path is a symlink
         return _STD filesystem::is_symlink(_STD filesystem::symlink_status(_Path, _Ec));
     }
 
-    inline bool remove(const path& _Target) {
+    _EXPORT_STD inline bool remove(const path& _Target) {
         // remove file _Target (even if it is a directory); returns whether the file was removed
         // note !exists(_Target) is not an error, and merely returns false
         const auto _Result = __std_fs_remove(_Target.c_str());
@@ -3625,7 +3627,7 @@ namespace filesystem {
         return _Result._Removed;
     }
 
-    inline bool remove(const path& _Target, error_code& _Ec) noexcept {
+    _EXPORT_STD inline bool remove(const path& _Target, error_code& _Ec) noexcept {
         // remove file _Target (even if it is a directory); returns whether the file was removed
         // note !exists(_Target) is not an error, and merely returns false
         const auto _Result = __std_fs_remove(_Target.c_str());
@@ -3633,7 +3635,7 @@ namespace filesystem {
         return _Result._Removed;
     }
 
-    inline void rename(const path& _Old_p, const path& _New_p) {
+    _EXPORT_STD inline void rename(const path& _Old_p, const path& _New_p) {
         // rename _Old_p to _New_p, overwriting _New_p if it is an existing non-directory file
         // the standard explicitly allows an implementation to not replace _New_p if it is a directory,
         // and we take advantage of that here to be able to use MoveFileEx(... MOVEFILE_REPLACE_EXISTING)
@@ -3643,14 +3645,14 @@ namespace filesystem {
         }
     }
 
-    inline void rename(const path& _Old_p, const path& _New_p, error_code& _Ec) noexcept {
+    _EXPORT_STD inline void rename(const path& _Old_p, const path& _New_p, error_code& _Ec) noexcept {
         // rename _Old_p to _New_p, overwriting _New_p if it is an existing non-directory file
         // the standard explicitly allows an implementation to not replace _New_p if it is a directory,
         // and we take advantage of that here to be able to use MoveFileEx(... MOVEFILE_REPLACE_EXISTING)
         _Ec = _Make_ec(__std_fs_rename(_Old_p.c_str(), _New_p.c_str()));
     }
 
-    inline void resize_file(const path& _Target, const uintmax_t _New_size) {
+    _EXPORT_STD inline void resize_file(const path& _Target, const uintmax_t _New_size) {
         // set the size of _Target to _New_size
         const auto _Err = __std_fs_resize_file(_Target.c_str(), _New_size);
         if (_Err != __std_win_error::_Success) {
@@ -3658,12 +3660,12 @@ namespace filesystem {
         }
     }
 
-    inline void resize_file(const path& _Target, const uintmax_t _New_size, error_code& _Ec) noexcept {
+    _EXPORT_STD inline void resize_file(const path& _Target, const uintmax_t _New_size, error_code& _Ec) noexcept {
         // set the size of _Target to _New_size
         _Ec = _Make_ec(__std_fs_resize_file(_Target.c_str(), _New_size));
     }
 
-    struct space_info {
+    _EXPORT_STD struct space_info {
         uintmax_t capacity;
         uintmax_t free;
         uintmax_t available;
@@ -3673,7 +3675,7 @@ namespace filesystem {
 #endif // _HAS_CXX20
     };
 
-    _NODISCARD inline space_info space(const path& _Target) {
+    _EXPORT_STD _NODISCARD inline space_info space(const path& _Target) {
         // get capacity information for the volume on which the file _Target resides
         space_info _Result;
         const auto _Last_error = __std_fs_space(_Target.c_str(), &_Result.available, &_Result.capacity, &_Result.free);
@@ -3684,14 +3686,14 @@ namespace filesystem {
         return _Result;
     }
 
-    _NODISCARD inline space_info space(const path& _Target, error_code& _Ec) noexcept {
+    _EXPORT_STD _NODISCARD inline space_info space(const path& _Target, error_code& _Ec) noexcept {
         // get capacity information for the volume on which the file _Target resides
         space_info _Result;
         _Ec = _Make_ec(__std_fs_space(_Target.c_str(), &_Result.available, &_Result.capacity, &_Result.free));
         return _Result;
     }
 
-    _NODISCARD inline bool status_known(const file_status _Status) noexcept {
+    _EXPORT_STD _NODISCARD inline bool status_known(const file_status _Status) noexcept {
         return _Status.type() != file_type::none;
     }
 
@@ -3707,13 +3709,13 @@ namespace filesystem {
         return _Result;
     }
 
-    _NODISCARD inline file_status status(const path& _Path, error_code& _Ec) noexcept {
+    _EXPORT_STD _NODISCARD inline file_status status(const path& _Path, error_code& _Ec) noexcept {
         const auto _Result = _Get_any_status(_Path, _Status_stats_flags);
         _Ec                = _Make_ec(_Result._Error);
         return _Result._Status;
     }
 
-    _NODISCARD inline file_status status(const path& _Path) {
+    _EXPORT_STD _NODISCARD inline file_status status(const path& _Path) {
         const auto _Result = _Get_any_status(_Path, _Status_stats_flags);
         if (_Result._Not_good()) {
             _Throw_fs_error("status", _Result._Error, _Path);
@@ -3721,13 +3723,13 @@ namespace filesystem {
         return _Result._Status;
     }
 
-    _NODISCARD inline file_status symlink_status(const path& _Path, error_code& _Ec) noexcept {
+    _EXPORT_STD _NODISCARD inline file_status symlink_status(const path& _Path, error_code& _Ec) noexcept {
         const auto _Result = _Get_any_status(_Path, _Symlink_status_stats_flags);
         _Ec                = _Make_ec(_Result._Error);
         return _Result._Status;
     }
 
-    _NODISCARD inline file_status symlink_status(const path& _Path) {
+    _EXPORT_STD _NODISCARD inline file_status symlink_status(const path& _Path) {
         const auto _Result = _Get_any_status(_Path, _Symlink_status_stats_flags);
         if (_Result._Not_good()) {
             _Throw_fs_error("symlink_status", _Result._Error, _Path);
@@ -3736,7 +3738,7 @@ namespace filesystem {
         return _Result._Status;
     }
 
-    inline bool create_directory(const path& _Path) {
+    _EXPORT_STD inline bool create_directory(const path& _Path) {
         const auto _Result = __std_fs_create_directory(_Path.c_str());
         if (_Result._Error != __std_win_error::_Success) {
             _Throw_fs_error("create_directory", _Result._Error, _Path);
@@ -3745,13 +3747,13 @@ namespace filesystem {
         return _Result._Created;
     }
 
-    inline bool create_directory(const path& _Path, error_code& _Ec) noexcept {
+    _EXPORT_STD inline bool create_directory(const path& _Path, error_code& _Ec) noexcept {
         const auto _Result = __std_fs_create_directory(_Path.c_str());
         _Ec                = _Make_ec(_Result._Error);
         return _Result._Created;
     }
 
-    inline bool create_directory(const path& _Path, const path& _Existing_p) {
+    _EXPORT_STD inline bool create_directory(const path& _Path, const path& _Existing_p) {
         const auto _Result = __std_fs_create_directory(_Path.c_str());
         if (_Result._Error != __std_win_error::_Success) {
             _Throw_fs_error("create_directory", _Result._Error, _Path, _Existing_p);
@@ -3760,13 +3762,13 @@ namespace filesystem {
         return _Result._Created;
     }
 
-    inline bool create_directory(const path& _Path, const path&, error_code& _Ec) noexcept {
+    _EXPORT_STD inline bool create_directory(const path& _Path, const path&, error_code& _Ec) noexcept {
         const auto _Result = __std_fs_create_directory(_Path.c_str());
         _Ec                = _Make_ec(_Result._Error);
         return _Result._Created;
     }
 
-    inline bool create_directories(const path& _Path, error_code& _Ec) {
+    _EXPORT_STD inline bool create_directories(const path& _Path, error_code& _Ec) {
         if (_Path.empty()) {
             _Ec = _Make_ec(__std_win_error::_Path_not_found);
             return false;
@@ -3825,7 +3827,7 @@ namespace filesystem {
         return _Created_last;
     }
 
-    inline bool create_directories(const path& _Path) {
+    _EXPORT_STD inline bool create_directories(const path& _Path) {
         error_code _Ec;
         const bool _Result = _STD filesystem::create_directories(_Path, _Ec);
         if (_Ec) {
@@ -3885,7 +3887,7 @@ namespace filesystem {
         }
     }
 
-    inline uintmax_t remove_all(const path& _Path, error_code& _Ec) {
+    _EXPORT_STD inline uintmax_t remove_all(const path& _Path, error_code& _Ec) {
         // remove _Path, including any contents
         _Ec.clear(); // for exception safety
         const auto _First_remove_result = __std_fs_remove(_Path.c_str());
@@ -3902,7 +3904,7 @@ namespace filesystem {
         return _Removed_count;
     }
 
-    inline uintmax_t remove_all(const path& _Path) {
+    _EXPORT_STD inline uintmax_t remove_all(const path& _Path) {
         error_code _Ec;
         const auto _Removed_count = _STD filesystem::remove_all(_Path, _Ec);
         if (_Ec) {
@@ -3925,7 +3927,7 @@ namespace filesystem {
         return _Error;
     }
 
-    _NODISCARD inline file_time_type last_write_time(const path& _Path) {
+    _EXPORT_STD _NODISCARD inline file_time_type last_write_time(const path& _Path) {
         file_time_type _Result;
         const auto _Error = _Last_write_time(_Path, _Result);
         if (_Error != __std_win_error::_Success) {
@@ -3935,13 +3937,13 @@ namespace filesystem {
         return _Result;
     }
 
-    _NODISCARD inline file_time_type last_write_time(const path& _Path, error_code& _Ec) noexcept {
+    _EXPORT_STD _NODISCARD inline file_time_type last_write_time(const path& _Path, error_code& _Ec) noexcept {
         file_time_type _Result;
         _Ec = _Make_ec(_Last_write_time(_Path, _Result));
         return _Result;
     }
 
-    inline void last_write_time(const path& _Target, const file_time_type _New_time) {
+    _EXPORT_STD inline void last_write_time(const path& _Target, const file_time_type _New_time) {
         // set the last write time of _Target to _New_time
         const auto _Err = __std_fs_set_last_write_time(_New_time.time_since_epoch().count(), _Target.c_str());
         if (_Err != __std_win_error::_Success) {
@@ -3949,14 +3951,15 @@ namespace filesystem {
         }
     }
 
-    inline void last_write_time(const path& _Target, const file_time_type _New_time, error_code& _Ec) noexcept {
+    _EXPORT_STD inline void last_write_time(
+        const path& _Target, const file_time_type _New_time, error_code& _Ec) noexcept {
         // set the last write time of _Target to _New_time
         _Ec = _Make_ec(__std_fs_set_last_write_time(_New_time.time_since_epoch().count(), _Target.c_str()));
     }
 
-    enum class perm_options { replace = 0x1, add = 0x2, remove = 0x4, nofollow = 0x8 };
+    _EXPORT_STD enum class perm_options { replace = 0x1, add = 0x2, remove = 0x4, nofollow = 0x8 };
 
-    _BITMASK_OPS(perm_options)
+    _BITMASK_OPS(_EXPORT_STD, perm_options)
 
     _NODISCARD inline __std_win_error _Permissions(
         const path& _Target, const perms _Perms, perm_options _Options) noexcept {
@@ -3995,7 +3998,7 @@ namespace filesystem {
         return __std_fs_change_permissions(_Target.c_str(), _Follow_symlinks, _Readonly);
     }
 
-    inline void permissions(
+    _EXPORT_STD inline void permissions(
         const path& _Target, const perms _Perms, const perm_options _Options = perm_options::replace) {
         const auto _Err = _Permissions(_Target, _Perms, _Options);
         if (_Err != __std_win_error::_Success) {
@@ -4003,16 +4006,16 @@ namespace filesystem {
         }
     }
 
-    inline void permissions(
+    _EXPORT_STD inline void permissions(
         const path& _Target, const perms _Perms, const perm_options _Options, error_code& _Ec) noexcept {
         _Ec = _Make_ec(_Permissions(_Target, _Perms, _Options));
     }
 
-    inline void permissions(const path& _Target, const perms _Perms, error_code& _Ec) noexcept {
+    _EXPORT_STD inline void permissions(const path& _Target, const perms _Perms, error_code& _Ec) noexcept {
         _STD filesystem::permissions(_Target, _Perms, perm_options::replace, _Ec);
     }
 
-    _NODISCARD inline path temp_directory_path(error_code& _Ec) {
+    _EXPORT_STD _NODISCARD inline path temp_directory_path(error_code& _Ec) {
         // get a location suitable for temporary storage, and verify that it is a directory
         _Ec.clear(); // for exception safety
         path _Result;
@@ -4028,7 +4031,7 @@ namespace filesystem {
         return _Result;
     }
 
-    _NODISCARD inline path temp_directory_path() {
+    _EXPORT_STD _NODISCARD inline path temp_directory_path() {
         // get a location suitable for temporary storage, and verify that it is a directory
         error_code _Ec; // unusual arrangement to allow thrown error_code to have generic_category()
         path _Result(_STD filesystem::temp_directory_path(_Ec));
@@ -4050,14 +4053,14 @@ namespace filesystem {
         }
     }
 
-    _NODISCARD inline path current_path(error_code& _Ec) {
+    _EXPORT_STD _NODISCARD inline path current_path(error_code& _Ec) {
         _Ec.clear();
         path _Result;
         _Ec = _Make_ec(_Current_path(_Result));
         return _Result;
     }
 
-    _NODISCARD inline path current_path() {
+    _EXPORT_STD _NODISCARD inline path current_path() {
         path _Result;
         const auto _Err = _Current_path(_Result);
         if (_Err != __std_win_error::_Success) {
@@ -4066,18 +4069,18 @@ namespace filesystem {
         return _Result;
     }
 
-    inline void current_path(const path& _To, error_code& _Ec) noexcept { // set the current path
+    _EXPORT_STD inline void current_path(const path& _To, error_code& _Ec) noexcept { // set the current path
         _Ec = _Make_ec(__std_fs_set_current_path(_To._Text.data()));
     }
 
-    inline void current_path(const path& _To) { // set the current path
+    _EXPORT_STD inline void current_path(const path& _To) { // set the current path
         const auto _Err = __std_fs_set_current_path(_To._Text.data());
         if (_Err != __std_win_error::_Success) {
             _Throw_fs_error("current_path(const path&)", _Err, _To);
         }
     }
 
-    _NODISCARD inline path weakly_canonical(const path& _Input, error_code& _Ec) {
+    _EXPORT_STD _NODISCARD inline path weakly_canonical(const path& _Input, error_code& _Ec) {
         // eventually calls GetFinalPathNameByHandleW
         _Ec.clear(); // for exception safety
 
@@ -4126,7 +4129,7 @@ namespace filesystem {
         return _Result;
     }
 
-    _NODISCARD inline path weakly_canonical(const path& _Input) {
+    _EXPORT_STD _NODISCARD inline path weakly_canonical(const path& _Input) {
         // eventually calls GetFinalPathNameByHandleW
         error_code _Ec;
 
@@ -4139,14 +4142,15 @@ namespace filesystem {
         return _Result;
     }
 
-    _NODISCARD inline path proximate(const path& _Path, const path& _Base = _STD filesystem::current_path()) {
+    _EXPORT_STD _NODISCARD inline path proximate(
+        const path& _Path, const path& _Base = _STD filesystem::current_path()) {
         // eventually calls GetFinalPathNameByHandleW
         const path _Weakly_canonical_path = _STD filesystem::weakly_canonical(_Path);
         const path _Weakly_canonical_base = _STD filesystem::weakly_canonical(_Base);
         return _Weakly_canonical_path.lexically_proximate(_Weakly_canonical_base);
     }
 
-    _NODISCARD inline path proximate(const path& _Path, const path& _Base, error_code& _Ec) {
+    _EXPORT_STD _NODISCARD inline path proximate(const path& _Path, const path& _Base, error_code& _Ec) {
         // eventually calls GetFinalPathNameByHandleW
         const path _Weakly_canonical_path = _STD filesystem::weakly_canonical(_Path, _Ec);
 
@@ -4163,7 +4167,7 @@ namespace filesystem {
         return _Weakly_canonical_path.lexically_proximate(_Weakly_canonical_base);
     }
 
-    _NODISCARD inline path proximate(const path& _Path, error_code& _Ec) {
+    _EXPORT_STD _NODISCARD inline path proximate(const path& _Path, error_code& _Ec) {
         // eventually calls GetFinalPathNameByHandleW
         const path _Base = _STD filesystem::current_path(_Ec);
         // N4810 29.11.14.27 [fs.op.proximate]/1 incorrectly calls current_path()
@@ -4174,14 +4178,15 @@ namespace filesystem {
         return _STD filesystem::proximate(_Path, _Base, _Ec);
     }
 
-    _NODISCARD inline path relative(const path& _Path, const path& _Base = _STD filesystem::current_path()) {
+    _EXPORT_STD _NODISCARD inline path relative(
+        const path& _Path, const path& _Base = _STD filesystem::current_path()) {
         // eventually calls GetFinalPathNameByHandleW
         const path _Weakly_canonical_path = _STD filesystem::weakly_canonical(_Path);
         const path _Weakly_canonical_base = _STD filesystem::weakly_canonical(_Base);
         return _Weakly_canonical_path.lexically_relative(_Weakly_canonical_base);
     }
 
-    _NODISCARD inline path relative(const path& _Path, const path& _Base, error_code& _Ec) {
+    _EXPORT_STD _NODISCARD inline path relative(const path& _Path, const path& _Base, error_code& _Ec) {
         // eventually calls GetFinalPathNameByHandleW
         const path _Weakly_canonical_path = _STD filesystem::weakly_canonical(_Path, _Ec);
 
@@ -4198,7 +4203,7 @@ namespace filesystem {
         return _Weakly_canonical_path.lexically_relative(_Weakly_canonical_base);
     }
 
-    _NODISCARD inline path relative(const path& _Path, error_code& _Ec) {
+    _EXPORT_STD _NODISCARD inline path relative(const path& _Path, error_code& _Ec) {
         // eventually calls GetFinalPathNameByHandleW
         const path _Base = _STD filesystem::current_path(_Ec);
         // N4810 29.11.14.29 [fs.op.relative]/1 incorrectly calls current_path()
@@ -4366,7 +4371,7 @@ namespace filesystem {
         // Otherwise, no effects.
     }
 
-    inline void copy(const path& _From, const path& _To, const copy_options _Options, error_code& _Ec) {
+    _EXPORT_STD inline void copy(const path& _From, const path& _To, const copy_options _Options, error_code& _Ec) {
         const directory_entry _From_dir(_From, _Ec);
         if (_Ec) { // report an error if exists(f) is false
             return;
@@ -4375,7 +4380,7 @@ namespace filesystem {
         _Copy_impl(_From_dir, _To, _Options, _Ec);
     }
 
-    inline void copy(const path& _From, const path& _To, const copy_options _Options) {
+    _EXPORT_STD inline void copy(const path& _From, const path& _To, const copy_options _Options) {
         error_code _Ec;
         _STD filesystem::copy(_From, _To, _Options, _Ec);
         if (_Ec) {
@@ -4383,11 +4388,11 @@ namespace filesystem {
         }
     }
 
-    inline void copy(const path& _From, const path& _To, error_code& _Ec) {
+    _EXPORT_STD inline void copy(const path& _From, const path& _To, error_code& _Ec) {
         return _STD filesystem::copy(_From, _To, copy_options::none, _Ec);
     }
 
-    inline void copy(const path& _From, const path& _To) {
+    _EXPORT_STD inline void copy(const path& _From, const path& _To) {
         return _STD filesystem::copy(_From, _To, copy_options::none);
     }
 } // namespace filesystem
diff --git a/stl/inc/format b/stl/inc/format
index 25d61dddb0..4675dd3593 100644
--- a/stl/inc/format
+++ b/stl/inc/format
@@ -70,12 +70,10 @@ extern "C" _NODISCARD __std_win_error __stdcall __std_get_cvt(__std_code_page _C
 
 _STD_BEGIN
 
-template <class, class>
+_EXPORT_STD template <class, class>
 class vector;
 
-class format_error : public runtime_error {
-    using runtime_error::runtime_error;
-};
+_EXPORT_STD class format_error : public runtime_error { using runtime_error::runtime_error; };
 
 [[noreturn]] inline void _Throw_format_error(const char* const _Message) {
     _THROW(format_error{_Message});
@@ -544,12 +542,12 @@ concept _Has_formatter = requires(_Ty& _Val, _Context& _Ctx) {
 template <class _Ty, class _Context>
 concept _Has_const_formatter = _Has_formatter<const remove_reference_t<_Ty>, _Context>;
 
-template <class _Ty, class _CharT = char>
+_EXPORT_STD template <class _Ty, class _CharT = char>
 struct formatter;
 
 inline void _You_see_this_error_because_arg_id_is_out_of_range() noexcept {}
 
-template <class _CharT>
+_EXPORT_STD template <class _CharT>
 class basic_format_parse_context {
 public:
     using char_type      = _CharT;
@@ -624,10 +622,10 @@ private:
     ptrdiff_t _Next_arg_id = 0;
 };
 
-using format_parse_context  = basic_format_parse_context<char>;
-using wformat_parse_context = basic_format_parse_context<wchar_t>;
+_EXPORT_STD using format_parse_context  = basic_format_parse_context<char>;
+_EXPORT_STD using wformat_parse_context = basic_format_parse_context<wchar_t>;
 
-template <class _Context>
+_EXPORT_STD template <class _Context>
 class basic_format_arg {
 public:
     using _CharType = typename _Context::char_type;
@@ -716,7 +714,7 @@ public:
     };
 };
 
-template <class _Visitor, class _Context>
+_EXPORT_STD template <class _Visitor, class _Context>
 decltype(auto) visit_format_arg(_Visitor&& _Vis, basic_format_arg<_Context> _Arg) {
     switch (_Arg._Active_state) {
     case _Basic_format_arg_type::_None:
@@ -1809,7 +1807,7 @@ struct _Format_arg_index {
     size_t _Type_ : 4;
 };
 
-template <class _Context>
+_EXPORT_STD template <class _Context>
 class basic_format_args;
 
 template <class _Context, class... _Args>
@@ -1896,7 +1894,7 @@ public:
 template <class _Context>
 class _Format_arg_store<_Context> {};
 
-template <class _Context>
+_EXPORT_STD template <class _Context>
 class basic_format_args {
 public:
     basic_format_args() noexcept = default;
@@ -2007,7 +2005,7 @@ public:
     }
 };
 
-template <class _Out, class _CharT>
+_EXPORT_STD template <class _Out, class _CharT>
     requires output_iterator<_Out, const _CharT&>
 class basic_format_context {
 private:
@@ -2251,8 +2249,8 @@ public:
 using _Fmt_it  = back_insert_iterator<_Fmt_buffer<char>>;
 using _Fmt_wit = back_insert_iterator<_Fmt_buffer<wchar_t>>;
 
-using format_context  = basic_format_context<_Fmt_it, char>;
-using wformat_context = basic_format_context<_Fmt_wit, wchar_t>;
+_EXPORT_STD using format_context  = basic_format_context<_Fmt_it, char>;
+_EXPORT_STD using wformat_context = basic_format_context<_Fmt_wit, wchar_t>;
 
 template <class _CharT, class _OutputIt>
 _NODISCARD _OutputIt _Fmt_write(_OutputIt _Out, monostate) {
@@ -3279,7 +3277,7 @@ struct _Format_handler {
 
 // Generic formatter definition, the deleted default constructor
 // makes it "disabled" as per N4885 [format.formatter.spec]/5
-template <class _Ty, class _CharT>
+_EXPORT_STD template <class _Ty, class _CharT>
 struct formatter {
     formatter()                           = delete;
     formatter(const formatter&)           = delete;
@@ -3375,7 +3373,7 @@ template <_Format_supported_charT _CharT, class _Traits>
 struct formatter<basic_string_view<_CharT, _Traits>, _CharT>
     : _Formatter_base<basic_string_view<_CharT, _Traits>, _CharT, _Basic_format_arg_type::_String_type> {};
 
-template <class _CharT, class... _Args>
+_EXPORT_STD template <class _CharT, class... _Args>
 struct basic_format_string {
 public:
     template <class _Ty>
@@ -3394,26 +3392,26 @@ private:
     basic_string_view<_CharT> _Str;
 };
 
-template <class... _Args>
+_EXPORT_STD template <class... _Args>
 using format_string = basic_format_string<char, type_identity_t<_Args>...>;
 
-template <class... _Args>
+_EXPORT_STD template <class... _Args>
 using wformat_string = basic_format_string<wchar_t, type_identity_t<_Args>...>;
 
-using format_args  = basic_format_args<format_context>;
-using wformat_args = basic_format_args<wformat_context>;
+_EXPORT_STD using format_args  = basic_format_args<format_context>;
+_EXPORT_STD using wformat_args = basic_format_args<wformat_context>;
 
-template <class _Context = format_context, class... _Args>
+_EXPORT_STD template <class _Context = format_context, class... _Args>
 _NODISCARD auto make_format_args(_Args&&... _Vals) {
     return _Format_arg_store<_Context, _Args...>{_Vals...};
 }
 
-template <class... _Args>
+_EXPORT_STD template <class... _Args>
 _NODISCARD auto make_wformat_args(_Args&&... _Vals) {
     return _Format_arg_store<wformat_context, _Args...>{_Vals...};
 }
 
-template <output_iterator<const char&> _OutputIt>
+_EXPORT_STD template <output_iterator<const char&> _OutputIt>
 _OutputIt vformat_to(_OutputIt _Out, const string_view _Fmt, const format_args _Args) {
     if constexpr (is_same_v<_OutputIt, _Fmt_it>) {
         _Format_handler<char> _Handler(_Out, _Fmt, _Args);
@@ -3427,7 +3425,7 @@ _OutputIt vformat_to(_OutputIt _Out, const string_view _Fmt, const format_args _
     }
 }
 
-template <output_iterator<const wchar_t&> _OutputIt>
+_EXPORT_STD template <output_iterator<const wchar_t&> _OutputIt>
 _OutputIt vformat_to(_OutputIt _Out, const wstring_view _Fmt, const wformat_args _Args) {
     if constexpr (is_same_v<_OutputIt, _Fmt_wit>) {
         _Format_handler<wchar_t> _Handler(_Out, _Fmt, _Args);
@@ -3441,7 +3439,7 @@ _OutputIt vformat_to(_OutputIt _Out, const wstring_view _Fmt, const wformat_args
     }
 }
 
-template <output_iterator<const char&> _OutputIt>
+_EXPORT_STD template <output_iterator<const char&> _OutputIt>
 _OutputIt vformat_to(_OutputIt _Out, const locale& _Loc, const string_view _Fmt, const format_args _Args) {
     if constexpr (is_same_v<_OutputIt, _Fmt_it>) {
         _Format_handler<char> _Handler(_Out, _Fmt, _Args, _Lazy_locale{_Loc});
@@ -3455,7 +3453,7 @@ _OutputIt vformat_to(_OutputIt _Out, const locale& _Loc, const string_view _Fmt,
     }
 }
 
-template <output_iterator<const wchar_t&> _OutputIt>
+_EXPORT_STD template <output_iterator<const wchar_t&> _OutputIt>
 _OutputIt vformat_to(_OutputIt _Out, const locale& _Loc, const wstring_view _Fmt, const wformat_args _Args) {
     if constexpr (is_same_v<_OutputIt, _Fmt_wit>) {
         _Format_handler<wchar_t> _Handler(_Out, _Fmt, _Args, _Lazy_locale{_Loc});
@@ -3469,27 +3467,27 @@ _OutputIt vformat_to(_OutputIt _Out, const locale& _Loc, const wstring_view _Fmt
     }
 }
 
-template <output_iterator<const char&> _OutputIt, class... _Types>
+_EXPORT_STD template <output_iterator<const char&> _OutputIt, class... _Types>
 _OutputIt format_to(_OutputIt _Out, const format_string<_Types...> _Fmt, _Types&&... _Args) {
     return _STD vformat_to(_STD move(_Out), _Fmt.get(), _STD make_format_args(_Args...));
 }
 
-template <output_iterator<const wchar_t&> _OutputIt, class... _Types>
+_EXPORT_STD template <output_iterator<const wchar_t&> _OutputIt, class... _Types>
 _OutputIt format_to(_OutputIt _Out, const wformat_string<_Types...> _Fmt, _Types&&... _Args) {
     return _STD vformat_to(_STD move(_Out), _Fmt.get(), _STD make_wformat_args(_Args...));
 }
 
-template <output_iterator<const char&> _OutputIt, class... _Types>
+_EXPORT_STD template <output_iterator<const char&> _OutputIt, class... _Types>
 _OutputIt format_to(_OutputIt _Out, const locale& _Loc, const format_string<_Types...> _Fmt, _Types&&... _Args) {
     return _STD vformat_to(_STD move(_Out), _Loc, _Fmt.get(), _STD make_format_args(_Args...));
 }
 
-template <output_iterator<const wchar_t&> _OutputIt, class... _Types>
+_EXPORT_STD template <output_iterator<const wchar_t&> _OutputIt, class... _Types>
 _OutputIt format_to(_OutputIt _Out, const locale& _Loc, const wformat_string<_Types...> _Fmt, _Types&&... _Args) {
     return _STD vformat_to(_STD move(_Out), _Loc, _Fmt.get(), _STD make_wformat_args(_Args...));
 }
 
-template <int = 0> // improves throughput, see GH-2329
+_EXPORT_STD template <int = 0> // improves throughput, see GH-2329
 _NODISCARD string vformat(const string_view _Fmt, const format_args _Args) {
     string _Str;
     _Str.reserve(_Fmt.size() + _Args._Estimate_required_capacity());
@@ -3497,7 +3495,7 @@ _NODISCARD string vformat(const string_view _Fmt, const format_args _Args) {
     return _Str;
 }
 
-template <int = 0> // improves throughput, see GH-2329
+_EXPORT_STD template <int = 0> // improves throughput, see GH-2329
 _NODISCARD wstring vformat(const wstring_view _Fmt, const wformat_args _Args) {
     wstring _Str;
     _Str.reserve(_Fmt.size() + _Args._Estimate_required_capacity());
@@ -3505,7 +3503,7 @@ _NODISCARD wstring vformat(const wstring_view _Fmt, const wformat_args _Args) {
     return _Str;
 }
 
-template <int = 0> // improves throughput, see GH-2329
+_EXPORT_STD template <int = 0> // improves throughput, see GH-2329
 _NODISCARD string vformat(const locale& _Loc, const string_view _Fmt, const format_args _Args) {
     string _Str;
     _Str.reserve(_Fmt.size() + _Args._Estimate_required_capacity());
@@ -3513,7 +3511,7 @@ _NODISCARD string vformat(const locale& _Loc, const string_view _Fmt, const form
     return _Str;
 }
 
-template <int = 0> // improves throughput, see GH-2329
+_EXPORT_STD template <int = 0> // improves throughput, see GH-2329
 _NODISCARD wstring vformat(const locale& _Loc, const wstring_view _Fmt, const wformat_args _Args) {
     wstring _Str;
     _Str.reserve(_Fmt.size() + _Args._Estimate_required_capacity());
@@ -3521,33 +3519,33 @@ _NODISCARD wstring vformat(const locale& _Loc, const wstring_view _Fmt, const wf
     return _Str;
 }
 
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
 _NODISCARD string format(const format_string<_Types...> _Fmt, _Types&&... _Args) {
     return _STD vformat(_Fmt.get(), _STD make_format_args(_Args...));
 }
 
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
 _NODISCARD wstring format(const wformat_string<_Types...> _Fmt, _Types&&... _Args) {
     return _STD vformat(_Fmt.get(), _STD make_wformat_args(_Args...));
 }
 
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
 _NODISCARD string format(const locale& _Loc, const format_string<_Types...> _Fmt, _Types&&... _Args) {
     return _STD vformat(_Loc, _Fmt.get(), _STD make_format_args(_Args...));
 }
 
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
 _NODISCARD wstring format(const locale& _Loc, const wformat_string<_Types...> _Fmt, _Types&&... _Args) {
     return _STD vformat(_Loc, _Fmt.get(), _STD make_wformat_args(_Args...));
 }
 
-template <class _OutputIt>
+_EXPORT_STD template <class _OutputIt>
 struct format_to_n_result {
     _OutputIt out;
     iter_difference_t<_OutputIt> size;
 };
 
-template <output_iterator<const char&> _OutputIt, class... _Types>
+_EXPORT_STD template <output_iterator<const char&> _OutputIt, class... _Types>
 format_to_n_result<_OutputIt> format_to_n(
     _OutputIt _Out, const iter_difference_t<_OutputIt> _Max, const format_string<_Types...> _Fmt, _Types&&... _Args) {
     _Fmt_iterator_buffer<_OutputIt, char, _Fmt_fixed_buffer_traits> _Buf(_STD move(_Out), _Max);
@@ -3555,7 +3553,7 @@ format_to_n_result<_OutputIt> format_to_n(
     return {.out = _Buf._Out(), .size = _Buf._Count()};
 }
 
-template <output_iterator<const wchar_t&> _OutputIt, class... _Types>
+_EXPORT_STD template <output_iterator<const wchar_t&> _OutputIt, class... _Types>
 format_to_n_result<_OutputIt> format_to_n(
     _OutputIt _Out, const iter_difference_t<_OutputIt> _Max, const wformat_string<_Types...> _Fmt, _Types&&... _Args) {
     _Fmt_iterator_buffer<_OutputIt, wchar_t, _Fmt_fixed_buffer_traits> _Buf(_STD move(_Out), _Max);
@@ -3563,7 +3561,7 @@ format_to_n_result<_OutputIt> format_to_n(
     return {.out = _Buf._Out(), .size = _Buf._Count()};
 }
 
-template <output_iterator<const char&> _OutputIt, class... _Types>
+_EXPORT_STD template <output_iterator<const char&> _OutputIt, class... _Types>
 format_to_n_result<_OutputIt> format_to_n(_OutputIt _Out, const iter_difference_t<_OutputIt> _Max, const locale& _Loc,
     const format_string<_Types...> _Fmt, _Types&&... _Args) {
     _Fmt_iterator_buffer<_OutputIt, char, _Fmt_fixed_buffer_traits> _Buf(_STD move(_Out), _Max);
@@ -3571,7 +3569,7 @@ format_to_n_result<_OutputIt> format_to_n(_OutputIt _Out, const iter_difference_
     return {.out = _Buf._Out(), .size = _Buf._Count()};
 }
 
-template <output_iterator<const wchar_t&> _OutputIt, class... _Types>
+_EXPORT_STD template <output_iterator<const wchar_t&> _OutputIt, class... _Types>
 format_to_n_result<_OutputIt> format_to_n(_OutputIt _Out, const iter_difference_t<_OutputIt> _Max, const locale& _Loc,
     const wformat_string<_Types...> _Fmt, _Types&&... _Args) {
     _Fmt_iterator_buffer<_OutputIt, wchar_t, _Fmt_fixed_buffer_traits> _Buf(_STD move(_Out), _Max);
@@ -3579,28 +3577,28 @@ format_to_n_result<_OutputIt> format_to_n(_OutputIt _Out, const iter_difference_
     return {.out = _Buf._Out(), .size = _Buf._Count()};
 }
 
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
 _NODISCARD size_t formatted_size(const format_string<_Types...> _Fmt, _Types&&... _Args) {
     _Fmt_counting_buffer<char> _Buf;
     _STD vformat_to(_Fmt_it{_Buf}, _Fmt.get(), _STD make_format_args(_Args...));
     return _Buf._Count();
 }
 
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
 _NODISCARD size_t formatted_size(const wformat_string<_Types...> _Fmt, _Types&&... _Args) {
     _Fmt_counting_buffer<wchar_t> _Buf;
     _STD vformat_to(_Fmt_wit{_Buf}, _Fmt.get(), _STD make_wformat_args(_Args...));
     return _Buf._Count();
 }
 
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
 _NODISCARD size_t formatted_size(const locale& _Loc, const format_string<_Types...> _Fmt, _Types&&... _Args) {
     _Fmt_counting_buffer<char> _Buf;
     _STD vformat_to(_Fmt_it{_Buf}, _Loc, _Fmt.get(), _STD make_format_args(_Args...));
     return _Buf._Count();
 }
 
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
 _NODISCARD size_t formatted_size(const locale& _Loc, const wformat_string<_Types...> _Fmt, _Types&&... _Args) {
     _Fmt_counting_buffer<wchar_t> _Buf;
     _STD vformat_to(_Fmt_wit{_Buf}, _Loc, _Fmt.get(), _STD make_wformat_args(_Args...));
diff --git a/stl/inc/forward_list b/stl/inc/forward_list
index 3def6d663b..6c9417f393 100644
--- a/stl/inc/forward_list
+++ b/stl/inc/forward_list
@@ -507,7 +507,7 @@ private:
     pointer _Head; // Points at the first constructed node.
 };
 
-template <class _Ty, class _Alloc = allocator<_Ty>>
+_EXPORT_STD template <class _Ty, class _Alloc = allocator<_Ty>>
 class forward_list { // singly linked list
 private:
     using _Alty          = _Rebind_alloc_t<_Alloc, _Ty>;
@@ -1561,12 +1561,12 @@ template <_RANGES input_range _Rng, class _Alloc = allocator<_RANGES range_value
 forward_list(from_range_t, _Rng&&, _Alloc = _Alloc()) -> forward_list<_RANGES range_value_t<_Rng>, _Alloc>;
 #endif // _HAS_CXX23 && defined(__cpp_lib_concepts)
 
-template <class _Ty, class _Alloc>
+_EXPORT_STD template <class _Ty, class _Alloc>
 void swap(forward_list<_Ty, _Alloc>& _Left, forward_list<_Ty, _Alloc>& _Right) noexcept /* strengthened */ {
     _Left.swap(_Right);
 }
 
-template <class _Ty, class _Alloc>
+_EXPORT_STD template <class _Ty, class _Alloc>
 _NODISCARD bool operator==(const forward_list<_Ty, _Alloc>& _Left, const forward_list<_Ty, _Alloc>& _Right) {
     return _STD equal(
         _Left._Unchecked_begin(), _Left._Unchecked_end_iter(), _Right._Unchecked_begin(), _Right._Unchecked_end_iter());
@@ -1580,7 +1580,7 @@ _NODISCARD bool operator!=(const forward_list<_Ty, _Alloc>& _Left, const forward
 #endif // !_HAS_CXX20
 
 #ifdef __cpp_lib_concepts
-template <class _Ty, class _Alloc>
+_EXPORT_STD template <class _Ty, class _Alloc>
 _NODISCARD _Synth_three_way_result<_Ty> operator<=>(
     const forward_list<_Ty, _Alloc>& _Left, const forward_list<_Ty, _Alloc>& _Right) {
     return _STD lexicographical_compare_three_way(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(),
@@ -1610,12 +1610,12 @@ _NODISCARD bool operator>=(const forward_list<_Ty, _Alloc>& _Left, const forward
 #endif // ^^^ !defined(__cpp_lib_concepts) ^^^
 
 #if _HAS_CXX20
-template <class _Ty, class _Alloc, class _Uty>
+_EXPORT_STD template <class _Ty, class _Alloc, class _Uty>
 typename forward_list<_Ty, _Alloc>::size_type erase(forward_list<_Ty, _Alloc>& _Cont, const _Uty& _Val) {
     return _Cont.remove_if([&](_Ty& _Elem) { return _Elem == _Val; });
 }
 
-template <class _Ty, class _Alloc, class _Pr>
+_EXPORT_STD template <class _Ty, class _Alloc, class _Pr>
 typename forward_list<_Ty, _Alloc>::size_type erase_if(forward_list<_Ty, _Alloc>& _Cont, _Pr _Pred) {
     return _Cont.remove_if(_Pass_fn(_Pred));
 }
@@ -1623,7 +1623,7 @@ typename forward_list<_Ty, _Alloc>::size_type erase_if(forward_list<_Ty, _Alloc>
 
 #if _HAS_CXX17
 namespace pmr {
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     using forward_list = _STD forward_list<_Ty, polymorphic_allocator<_Ty>>;
 } // namespace pmr
 #endif // _HAS_CXX17
diff --git a/stl/inc/fstream b/stl/inc/fstream
index e4fc17705e..07b85a4a23 100644
--- a/stl/inc/fstream
+++ b/stl/inc/fstream
@@ -26,7 +26,7 @@ _STL_DISABLE_CLANG_WARNINGS
 _STD_BEGIN
 #if _HAS_CXX17
 namespace filesystem {
-    class path;
+    _EXPORT_STD class path;
 }
 #endif // _HAS_CXX17
 
@@ -60,11 +60,11 @@ _INLINE_VAR constexpr bool _Is_any_path = _Is_any_of_v<_Ty
     >;
 // clang-format on
 
-_CRTIMP2_PURE FILE* __CLRCALL_PURE_OR_CDECL _Fiopen(const char*, ios_base::openmode, int);
-_CRTIMP2_PURE FILE* __CLRCALL_PURE_OR_CDECL _Fiopen(const wchar_t*, ios_base::openmode, int);
+extern "C++" _CRTIMP2_PURE FILE* __CLRCALL_PURE_OR_CDECL _Fiopen(const char*, ios_base::openmode, int);
+extern "C++" _CRTIMP2_PURE FILE* __CLRCALL_PURE_OR_CDECL _Fiopen(const wchar_t*, ios_base::openmode, int);
 
 #ifdef _CRTBLD
-_CRTIMP2_PURE FILE* __CLRCALL_PURE_OR_CDECL _Fiopen(const unsigned short*, ios_base::openmode, int);
+extern "C++" _CRTIMP2_PURE FILE* __CLRCALL_PURE_OR_CDECL _Fiopen(const unsigned short*, ios_base::openmode, int);
 #endif // _CRTBLD
 
 template <class _Elem>
@@ -161,7 +161,7 @@ inline bool _Ungetc(const unsigned short& _Wchar, FILE* _File) { // put back an
 }
 #endif // _CRTBLD
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 class basic_filebuf : public basic_streambuf<_Elem, _Traits> { // stream buffer associated with a C stream
 public:
     using _Mysb = basic_streambuf<_Elem, _Traits>;
@@ -797,12 +797,12 @@ private:
     _Elem* _Set_egptr; // saves egptr()
 };
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 void swap(basic_filebuf<_Elem, _Traits>& _Left, basic_filebuf<_Elem, _Traits>& _Right) {
     _Left.swap(_Right);
 }
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 class basic_ifstream : public basic_istream<_Elem, _Traits> { // input stream associated with a C stream
 public:
     using _Mybase = basic_istream<_Elem, _Traits>;
@@ -981,12 +981,12 @@ private:
     _Myfb _Filebuffer;
 };
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 void swap(basic_ifstream<_Elem, _Traits>& _Left, basic_ifstream<_Elem, _Traits>& _Right) {
     _Left.swap(_Right);
 }
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 class basic_ofstream : public basic_ostream<_Elem, _Traits> { // output stream associated with a C stream
 public:
     using _Mybase = basic_ostream<_Elem, _Traits>;
@@ -1164,12 +1164,12 @@ private:
     _Myfb _Filebuffer;
 };
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 void swap(basic_ofstream<_Elem, _Traits>& _Left, basic_ofstream<_Elem, _Traits>& _Right) {
     _Left.swap(_Right);
 }
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 class basic_fstream : public basic_iostream<_Elem, _Traits> { // input/output stream associated with a C stream
 public:
     using _Mybase     = basic_iostream<_Elem, _Traits>;
@@ -1354,7 +1354,7 @@ private:
     _Myfb _Filebuffer;
 };
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 void swap(basic_fstream<_Elem, _Traits>& _Left, basic_fstream<_Elem, _Traits>& _Right) {
     _Left.swap(_Right);
 }
diff --git a/stl/inc/functional b/stl/inc/functional
index 1ecd7fdb48..780d324a99 100644
--- a/stl/inc/functional
+++ b/stl/inc/functional
@@ -32,7 +32,7 @@ _STL_DISABLE_CLANG_WARNINGS
 
 _STD_BEGIN
 #if _HAS_CXX23
-template <class _Result_type, class _Callable, class... _Types,
+_EXPORT_STD template <class _Result_type, class _Callable, class... _Types,
     enable_if_t<is_invocable_r_v<_Result_type, _Callable, _Types...>, int> = 0>
 _NODISCARD constexpr _Result_type invoke_r(_Callable&& _Obj, _Types&&... _Args) noexcept(
     is_nothrow_invocable_r_v<_Result_type, _Callable, _Types...>) {
@@ -46,7 +46,7 @@ _NODISCARD constexpr _Result_type invoke_r(_Callable&& _Obj, _Types&&... _Args)
 
 // plus, minus, and multiplies are defined in <xstddef>
 
-template <class _Ty = void>
+_EXPORT_STD template <class _Ty = void>
 struct divides {
     using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
     using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
@@ -57,7 +57,7 @@ struct divides {
     }
 };
 
-template <class _Ty = void>
+_EXPORT_STD template <class _Ty = void>
 struct modulus {
     using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
     using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
@@ -68,7 +68,7 @@ struct modulus {
     }
 };
 
-template <class _Ty = void>
+_EXPORT_STD template <class _Ty = void>
 struct negate {
     using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
     using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = _Ty;
@@ -80,7 +80,7 @@ struct negate {
 
 // equal_to, not_equal_to, greater, less, greater_equal, and less_equal are defined in <xstddef>
 
-template <class _Ty = void>
+_EXPORT_STD template <class _Ty = void>
 struct logical_and {
     using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
     using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
@@ -91,7 +91,7 @@ struct logical_and {
     }
 };
 
-template <class _Ty = void>
+_EXPORT_STD template <class _Ty = void>
 struct logical_or {
     using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
     using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
@@ -102,7 +102,7 @@ struct logical_or {
     }
 };
 
-template <class _Ty = void>
+_EXPORT_STD template <class _Ty = void>
 struct logical_not {
     using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
     using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = bool;
@@ -112,7 +112,7 @@ struct logical_not {
     }
 };
 
-template <class _Ty = void>
+_EXPORT_STD template <class _Ty = void>
 struct bit_and {
     using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
     using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
@@ -123,7 +123,7 @@ struct bit_and {
     }
 };
 
-template <class _Ty = void>
+_EXPORT_STD template <class _Ty = void>
 struct bit_or {
     using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
     using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
@@ -134,7 +134,7 @@ struct bit_or {
     }
 };
 
-template <class _Ty = void>
+_EXPORT_STD template <class _Ty = void>
 struct bit_xor {
     using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
     using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
@@ -145,7 +145,7 @@ struct bit_xor {
     }
 };
 
-template <class _Ty = void>
+_EXPORT_STD template <class _Ty = void>
 struct bit_not {
     using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
     using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = _Ty;
@@ -268,7 +268,7 @@ struct bit_not<void> {
 
 #if _HAS_DEPRECATED_NEGATORS
 _STL_DISABLE_DEPRECATED_WARNING
-template <class _Fn>
+_EXPORT_STD template <class _Fn>
 class _CXX17_DEPRECATE_NEGATORS unary_negate {
 public:
     using argument_type = typename _Fn::argument_type;
@@ -284,12 +284,12 @@ private:
     _Fn _Functor;
 };
 
-template <class _Fn>
+_EXPORT_STD template <class _Fn>
 _CXX17_DEPRECATE_NEGATORS _NODISCARD constexpr unary_negate<_Fn> not1(const _Fn& _Func) {
     return unary_negate<_Fn>(_Func);
 }
 
-template <class _Fn>
+_EXPORT_STD template <class _Fn>
 class _CXX17_DEPRECATE_NEGATORS binary_negate {
 public:
     using first_argument_type  = typename _Fn::first_argument_type;
@@ -306,7 +306,7 @@ private:
     _Fn _Functor;
 };
 
-template <class _Fn>
+_EXPORT_STD template <class _Fn>
 _CXX17_DEPRECATE_NEGATORS _NODISCARD constexpr binary_negate<_Fn> not2(const _Fn& _Func) {
     return binary_negate<_Fn>(_Func);
 }
@@ -315,7 +315,7 @@ _STL_RESTORE_DEPRECATED_WARNING
 
 #if _HAS_AUTO_PTR_ETC
 _STL_DISABLE_DEPRECATED_WARNING
-template <class _Fn>
+_EXPORT_STD template <class _Fn>
 class binder1st : public unary_function<typename _Fn::second_argument_type,
                       typename _Fn::result_type> { // functor adapter _Func(stored, right)
 public:
@@ -338,13 +338,13 @@ protected:
     typename _Fn::first_argument_type value; // the left operand
 };
 
-template <class _Fn, class _Ty>
+_EXPORT_STD template <class _Fn, class _Ty>
 _NODISCARD binder1st<_Fn> bind1st(const _Fn& _Func, const _Ty& _Left) {
     typename _Fn::first_argument_type _Val(_Left);
     return binder1st<_Fn>(_Func, _Val);
 }
 
-template <class _Fn>
+_EXPORT_STD template <class _Fn>
 class binder2nd : public unary_function<typename _Fn::first_argument_type,
                       typename _Fn::result_type> { // functor adapter _Func(left, stored)
 public:
@@ -367,14 +367,14 @@ protected:
     typename _Fn::second_argument_type value; // the right operand
 };
 
-template <class _Fn, class _Ty>
+_EXPORT_STD template <class _Fn, class _Ty>
 _NODISCARD binder2nd<_Fn> bind2nd(const _Fn& _Func, const _Ty& _Right) {
     typename _Fn::second_argument_type _Val(_Right);
     return binder2nd<_Fn>(_Func, _Val);
 }
 _STL_RESTORE_DEPRECATED_WARNING
 
-template <class _Arg, class _Result, class _Fn = _Result (*)(_Arg)>
+_EXPORT_STD template <class _Arg, class _Result, class _Fn = _Result(*)(_Arg)>
 class pointer_to_unary_function : public unary_function<_Arg, _Result> { // functor adapter (*pfunc)(left)
 public:
     explicit pointer_to_unary_function(_Fn _Left) : _Pfun(_Left) {}
@@ -387,7 +387,7 @@ protected:
     _Fn _Pfun; // the function pointer
 };
 
-template <class _Arg1, class _Arg2, class _Result, class _Fn = _Result (*)(_Arg1, _Arg2)>
+_EXPORT_STD template <class _Arg1, class _Arg2, class _Result, class _Fn = _Result(*)(_Arg1, _Arg2)>
 class pointer_to_binary_function
     : public binary_function<_Arg1, _Arg2, _Result> { // functor adapter (*pfunc)(left, right)
 public:
@@ -402,12 +402,12 @@ protected:
 };
 
 #define _PTR_FUN(CALL_OPT, X1, X2, X3)                                                                      \
-    template <class _Arg, class _Result>                                                                    \
+    _EXPORT_STD template <class _Arg, class _Result>                                                        \
     _NODISCARD pointer_to_unary_function<_Arg, _Result, _Result(CALL_OPT*)(_Arg)> ptr_fun(                  \
         _Result(CALL_OPT* _Left)(_Arg)) {                                                                   \
         return pointer_to_unary_function<_Arg, _Result, _Result(CALL_OPT*)(_Arg)>(_Left);                   \
     }                                                                                                       \
-    template <class _Arg1, class _Arg2, class _Result>                                                      \
+    _EXPORT_STD template <class _Arg1, class _Arg2, class _Result>                                          \
     _NODISCARD pointer_to_binary_function<_Arg1, _Arg2, _Result, _Result(CALL_OPT*)(_Arg1, _Arg2)> ptr_fun( \
         _Result(CALL_OPT* _Left)(_Arg1, _Arg2)) {                                                           \
         return pointer_to_binary_function<_Arg1, _Arg2, _Result, _Result(CALL_OPT*)(_Arg1, _Arg2)>(_Left);  \
@@ -416,7 +416,7 @@ protected:
 _NON_MEMBER_CALL(_PTR_FUN, X1, X2, X3)
 #undef _PTR_FUN
 
-template <class _Result, class _Ty>
+_EXPORT_STD template <class _Result, class _Ty>
 class mem_fun_t : public unary_function<_Ty*, _Result> { // functor adapter (*p->*pfunc)(), non-const *pfunc
 public:
     explicit mem_fun_t(_Result (_Ty::*_Pm)()) : _Pmemfun(_Pm) {}
@@ -429,7 +429,7 @@ private:
     _Result (_Ty::*_Pmemfun)(); // the member function pointer
 };
 
-template <class _Result, class _Ty, class _Arg>
+_EXPORT_STD template <class _Result, class _Ty, class _Arg>
 class mem_fun1_t : public binary_function<_Ty*, _Arg, _Result> { // functor adapter (*p->*pfunc)(val), non-const *pfunc
 public:
     explicit mem_fun1_t(_Result (_Ty::*_Pm)(_Arg)) : _Pmemfun(_Pm) {}
@@ -442,7 +442,7 @@ private:
     _Result (_Ty::*_Pmemfun)(_Arg); // the member function pointer
 };
 
-template <class _Result, class _Ty>
+_EXPORT_STD template <class _Result, class _Ty>
 class const_mem_fun_t : public unary_function<const _Ty*, _Result> { // functor adapter (*p->*pfunc)(), const *pfunc
 public:
     explicit const_mem_fun_t(_Result (_Ty::*_Pm)() const) : _Pmemfun(_Pm) {}
@@ -455,7 +455,7 @@ private:
     _Result (_Ty::*_Pmemfun)() const; // the member function pointer
 };
 
-template <class _Result, class _Ty, class _Arg>
+_EXPORT_STD template <class _Result, class _Ty, class _Arg>
 class const_mem_fun1_t
     : public binary_function<const _Ty*, _Arg, _Result> { // functor adapter (*p->*pfunc)(val), const *pfunc
 public:
@@ -469,27 +469,27 @@ private:
     _Result (_Ty::*_Pmemfun)(_Arg) const; // the member function pointer
 };
 
-template <class _Result, class _Ty>
+_EXPORT_STD template <class _Result, class _Ty>
 _NODISCARD mem_fun_t<_Result, _Ty> mem_fun(_Result (_Ty::*_Pm)()) {
     return mem_fun_t<_Result, _Ty>(_Pm);
 }
 
-template <class _Result, class _Ty, class _Arg>
+_EXPORT_STD template <class _Result, class _Ty, class _Arg>
 _NODISCARD mem_fun1_t<_Result, _Ty, _Arg> mem_fun(_Result (_Ty::*_Pm)(_Arg)) {
     return mem_fun1_t<_Result, _Ty, _Arg>(_Pm);
 }
 
-template <class _Result, class _Ty>
+_EXPORT_STD template <class _Result, class _Ty>
 _NODISCARD const_mem_fun_t<_Result, _Ty> mem_fun(_Result (_Ty::*_Pm)() const) {
     return const_mem_fun_t<_Result, _Ty>(_Pm);
 }
 
-template <class _Result, class _Ty, class _Arg>
+_EXPORT_STD template <class _Result, class _Ty, class _Arg>
 _NODISCARD const_mem_fun1_t<_Result, _Ty, _Arg> mem_fun(_Result (_Ty::*_Pm)(_Arg) const) {
     return const_mem_fun1_t<_Result, _Ty, _Arg>(_Pm);
 }
 
-template <class _Result, class _Ty>
+_EXPORT_STD template <class _Result, class _Ty>
 class mem_fun_ref_t : public unary_function<_Ty, _Result> { // functor adapter (*left.*pfunc)(), non-const *pfunc
 public:
     explicit mem_fun_ref_t(_Result (_Ty::*_Pm)()) : _Pmemfun(_Pm) {}
@@ -502,7 +502,7 @@ private:
     _Result (_Ty::*_Pmemfun)(); // the member function pointer
 };
 
-template <class _Result, class _Ty, class _Arg>
+_EXPORT_STD template <class _Result, class _Ty, class _Arg>
 class mem_fun1_ref_t
     : public binary_function<_Ty, _Arg, _Result> { // functor adapter (*left.*pfunc)(val), non-const *pfunc
 public:
@@ -516,7 +516,7 @@ private:
     _Result (_Ty::*_Pmemfun)(_Arg); // the member function pointer
 };
 
-template <class _Result, class _Ty>
+_EXPORT_STD template <class _Result, class _Ty>
 class const_mem_fun_ref_t : public unary_function<_Ty, _Result> { // functor adapter (*left.*pfunc)(), const *pfunc
 public:
     explicit const_mem_fun_ref_t(_Result (_Ty::*_Pm)() const) : _Pmemfun(_Pm) {}
@@ -529,7 +529,7 @@ private:
     _Result (_Ty::*_Pmemfun)() const; // the member function pointer
 };
 
-template <class _Result, class _Ty, class _Arg>
+_EXPORT_STD template <class _Result, class _Ty, class _Arg>
 class const_mem_fun1_ref_t
     : public binary_function<_Ty, _Arg, _Result> { // functor adapter (*left.*pfunc)(val), const *pfunc
 public:
@@ -543,22 +543,22 @@ private:
     _Result (_Ty::*_Pmemfun)(_Arg) const; // the member function pointer
 };
 
-template <class _Result, class _Ty>
+_EXPORT_STD template <class _Result, class _Ty>
 _NODISCARD mem_fun_ref_t<_Result, _Ty> mem_fun_ref(_Result (_Ty::*_Pm)()) {
     return mem_fun_ref_t<_Result, _Ty>(_Pm);
 }
 
-template <class _Result, class _Ty, class _Arg>
+_EXPORT_STD template <class _Result, class _Ty, class _Arg>
 _NODISCARD mem_fun1_ref_t<_Result, _Ty, _Arg> mem_fun_ref(_Result (_Ty::*_Pm)(_Arg)) {
     return mem_fun1_ref_t<_Result, _Ty, _Arg>(_Pm);
 }
 
-template <class _Result, class _Ty>
+_EXPORT_STD template <class _Result, class _Ty>
 _NODISCARD const_mem_fun_ref_t<_Result, _Ty> mem_fun_ref(_Result (_Ty::*_Pm)() const) {
     return const_mem_fun_ref_t<_Result, _Ty>(_Pm);
 }
 
-template <class _Result, class _Ty, class _Arg>
+_EXPORT_STD template <class _Result, class _Ty, class _Arg>
 _NODISCARD const_mem_fun1_ref_t<_Result, _Ty, _Arg> mem_fun_ref(_Result (_Ty::*_Pm)(_Arg) const) {
     return const_mem_fun1_ref_t<_Result, _Ty, _Arg>(_Pm);
 }
@@ -580,7 +580,7 @@ public:
     }
 };
 
-template <class _Rx, class _Ty>
+_EXPORT_STD template <class _Rx, class _Ty>
 _NODISCARD _CONSTEXPR20 _Mem_fn<_Rx _Ty::*> mem_fn(_Rx _Ty::*_Pm) noexcept {
     return _Mem_fn<_Rx _Ty::*>(_Pm);
 }
@@ -633,7 +633,7 @@ public:
     }
 };
 
-template <class _Callable>
+_EXPORT_STD template <class _Callable>
 _NODISCARD _CONSTEXPR20 _Not_fn<decay_t<_Callable>> not_fn(_Callable&& _Obj) noexcept(
     is_nothrow_constructible_v<decay_t<_Callable>, _Callable>) /* strengthened */ {
     // wrap a callable object to be negated
@@ -641,7 +641,7 @@ _NODISCARD _CONSTEXPR20 _Not_fn<decay_t<_Callable>> not_fn(_Callable&& _Obj) noe
 }
 #endif // _HAS_CXX17
 
-class bad_function_call : public exception { // exception thrown when an empty std::function is called
+_EXPORT_STD class bad_function_call : public exception { // exception thrown when an empty std::function is called
 public:
     bad_function_call() noexcept {}
 
@@ -651,7 +651,7 @@ public:
     }
 };
 
-[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xbad_function_call();
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xbad_function_call();
 
 struct _Unforced { // tag to distinguish bind() from bind<R>()
     explicit _Unforced() = default;
@@ -684,7 +684,7 @@ struct _Invoker_ret<_Unforced> { // selected for _Rx being _Unforced
     }
 };
 
-template <class _Fty>
+_EXPORT_STD template <class _Fty>
 class function;
 
 template <class _Ty>
@@ -1024,7 +1024,7 @@ _NON_MEMBER_CALL(_GET_FUNCTION_IMPL_NOEXCEPT, X1, X2, X3)
 #undef _GET_FUNCTION_IMPL_NOEXCEPT
 #endif // __cpp_noexcept_function_type
 
-template <class _Fty>
+_EXPORT_STD template <class _Fty>
 class function : public _Get_function_impl<_Fty>::type { // wrapper for callable objects
 private:
     using _Mybase = typename _Get_function_impl<_Fty>::type;
@@ -1162,12 +1162,12 @@ template <class _Fx>
 function(_Fx) -> function<typename _Deduce_signature<_Fx>::type>;
 #endif // _HAS_CXX17
 
-template <class _Fty>
+_EXPORT_STD template <class _Fty>
 void swap(function<_Fty>& _Left, function<_Fty>& _Right) noexcept {
     _Left.swap(_Right);
 }
 
-template <class _Fty>
+_EXPORT_STD template <class _Fty>
 _NODISCARD bool operator==(const function<_Fty>& _Other, nullptr_t) noexcept {
     return !_Other;
 }
@@ -1747,7 +1747,7 @@ public:
 };
 #endif // __cpp_noexcept_function_type
 
-template <class... _Signature>
+_EXPORT_STD template <class... _Signature>
 class move_only_function : private _Move_only_function_call<_Signature...> {
 private:
     using _Call = _Move_only_function_call<_Signature...>;
@@ -1868,7 +1868,7 @@ struct _Ph { // placeholder
     static_assert(_Nx > 0, "invalid placeholder index");
 };
 
-template <class _Tx>
+_EXPORT_STD template <class _Tx>
 struct is_placeholder : integral_constant<int, 0> {}; // _Tx is not a placeholder
 
 template <int _Nx>
@@ -1883,13 +1883,13 @@ struct is_placeholder<volatile _Tx> : is_placeholder<_Tx>::type {}; // ignore cv
 template <class _Tx>
 struct is_placeholder<const volatile _Tx> : is_placeholder<_Tx>::type {}; // ignore cv-qualifiers
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr int is_placeholder_v = is_placeholder<_Ty>::value;
 
 template <class _Ret, class _Fx, class... _Types>
 class _Binder;
 
-template <class _Tx>
+_EXPORT_STD template <class _Tx>
 struct is_bind_expression : false_type {}; // _Tx is not a bind expression
 
 template <class _Ret, class _Fx, class... _Types>
@@ -1904,7 +1904,7 @@ struct is_bind_expression<volatile _Tx> : is_bind_expression<_Tx>::type {}; // i
 template <class _Tx>
 struct is_bind_expression<const volatile _Tx> : is_bind_expression<_Tx>::type {}; // ignore cv-qualifiers
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_bind_expression_v = is_bind_expression<_Ty>::value;
 
 template <class _Cv_TiD, bool = _Is_specialization_v<remove_cv_t<_Cv_TiD>, reference_wrapper>,
@@ -2020,37 +2020,37 @@ public:
 #undef _CALL_BINDER
 };
 
-template <class _Fx, class... _Types>
+_EXPORT_STD template <class _Fx, class... _Types>
 _NODISCARD _CONSTEXPR20 _Binder<_Unforced, _Fx, _Types...> bind(_Fx&& _Func, _Types&&... _Args) {
     return _Binder<_Unforced, _Fx, _Types...>(_STD forward<_Fx>(_Func), _STD forward<_Types>(_Args)...);
 }
 
-template <class _Ret, class _Fx, class... _Types>
+_EXPORT_STD template <class _Ret, class _Fx, class... _Types>
 _NODISCARD _CONSTEXPR20 _Binder<_Ret, _Fx, _Types...> bind(_Fx&& _Func, _Types&&... _Args) {
     return _Binder<_Ret, _Fx, _Types...>(_STD forward<_Fx>(_Func), _STD forward<_Types>(_Args)...);
 }
 
 namespace placeholders {
-    _INLINE_VAR constexpr _Ph<1> _1{};
-    _INLINE_VAR constexpr _Ph<2> _2{};
-    _INLINE_VAR constexpr _Ph<3> _3{};
-    _INLINE_VAR constexpr _Ph<4> _4{};
-    _INLINE_VAR constexpr _Ph<5> _5{};
-    _INLINE_VAR constexpr _Ph<6> _6{};
-    _INLINE_VAR constexpr _Ph<7> _7{};
-    _INLINE_VAR constexpr _Ph<8> _8{};
-    _INLINE_VAR constexpr _Ph<9> _9{};
-    _INLINE_VAR constexpr _Ph<10> _10{};
-    _INLINE_VAR constexpr _Ph<11> _11{};
-    _INLINE_VAR constexpr _Ph<12> _12{};
-    _INLINE_VAR constexpr _Ph<13> _13{};
-    _INLINE_VAR constexpr _Ph<14> _14{};
-    _INLINE_VAR constexpr _Ph<15> _15{};
-    _INLINE_VAR constexpr _Ph<16> _16{};
-    _INLINE_VAR constexpr _Ph<17> _17{};
-    _INLINE_VAR constexpr _Ph<18> _18{};
-    _INLINE_VAR constexpr _Ph<19> _19{};
-    _INLINE_VAR constexpr _Ph<20> _20{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<1> _1{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<2> _2{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<3> _3{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<4> _4{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<5> _5{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<6> _6{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<7> _7{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<8> _8{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<9> _9{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<10> _10{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<11> _11{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<12> _12{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<13> _13{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<14> _14{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<15> _15{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<16> _16{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<17> _17{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<18> _18{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<19> _19{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<20> _20{};
 } // namespace placeholders
 
 #if _HAS_CXX20
@@ -2115,7 +2115,7 @@ public:
     }
 };
 
-template <class _Fx, class... _Types>
+_EXPORT_STD template <class _Fx, class... _Types>
 _NODISCARD constexpr auto bind_front(_Fx&& _Func, _Types&&... _Args) {
     static_assert(is_constructible_v<decay_t<_Fx>, _Fx>,
         "std::bind_front requires the decayed callable to be constructible from an undecayed callable");
@@ -2192,7 +2192,7 @@ public:
     }
 };
 
-template <class _Fx, class... _Types>
+_EXPORT_STD template <class _Fx, class... _Types>
 _NODISCARD constexpr auto bind_back(_Fx&& _Func, _Types&&... _Args) {
     static_assert(is_constructible_v<decay_t<_Fx>, _Fx>,
         "std::bind_back requires the decayed callable to be constructible from an undecayed callable");
@@ -2298,7 +2298,7 @@ _CONSTEXPR20 pair<_FwdItHaystack, _FwdItHaystack> _Search_pair_unchecked(
     }
 }
 
-template <class _FwdItPat, class _Pred_eq = equal_to<>>
+_EXPORT_STD template <class _FwdItPat, class _Pred_eq = equal_to<>>
 class default_searcher { // functor to search haystacks for needles
 public:
     _CONSTEXPR20 default_searcher(_FwdItPat _First, _FwdItPat _Last, _Pred_eq _Eq = _Pred_eq())
@@ -2781,7 +2781,7 @@ using _Boyer_moore_traits =
         _Boyer_moore_traits_general_mode<_RanItPat, _Hash_ty, _Pred_eq>>;
 
 
-template <class _RanItPat, class _Hash_ty = hash<_Iter_value_t<_RanItPat>>, class _Pred_eq = equal_to<>>
+_EXPORT_STD template <class _RanItPat, class _Hash_ty = hash<_Iter_value_t<_RanItPat>>, class _Pred_eq = equal_to<>>
 class boyer_moore_searcher {
 public:
     boyer_moore_searcher(
@@ -2820,7 +2820,7 @@ private:
 };
 
 
-template <class _RanItPat, class _Hash_ty = hash<_Iter_value_t<_RanItPat>>, class _Pred_eq = equal_to<>>
+_EXPORT_STD template <class _RanItPat, class _Hash_ty = hash<_Iter_value_t<_RanItPat>>, class _Pred_eq = equal_to<>>
 class boyer_moore_horspool_searcher { // equivalent to Boyer-Moore without the second table
 public:
     boyer_moore_horspool_searcher(
@@ -2861,7 +2861,7 @@ private:
 
 #ifdef __cpp_lib_concepts
 namespace ranges {
-    struct not_equal_to {
+    _EXPORT_STD struct not_equal_to {
         // clang-format off
         template <class _Ty1, class _Ty2>
             requires equality_comparable_with<_Ty1, _Ty2>
@@ -2874,7 +2874,7 @@ namespace ranges {
         using is_transparent = int;
     };
 
-    struct greater_equal {
+    _EXPORT_STD struct greater_equal {
         // clang-format off
         template <class _Ty1, class _Ty2>
             requires totally_ordered_with<_Ty1, _Ty2>
@@ -2887,7 +2887,7 @@ namespace ranges {
         using is_transparent = int;
     };
 
-    struct less_equal {
+    _EXPORT_STD struct less_equal {
         // clang-format off
         template <class _Ty1, class _Ty2>
             requires totally_ordered_with<_Ty1, _Ty2>
diff --git a/stl/inc/future b/stl/inc/future
index 8e3f4be8da..031384331a 100644
--- a/stl/inc/future
+++ b/stl/inc/future
@@ -60,21 +60,21 @@ _NODISCARD _Unique_ptr_alloc<_Alloc> _Make_unique_alloc(_Alloc& _Al, _Args&&...
 
 struct _Nil {}; // empty struct, for unused argument types
 
-enum class future_errc { // names for futures errors
+_EXPORT_STD enum class future_errc { // names for futures errors
     broken_promise = 1,
     future_already_retrieved,
     promise_already_satisfied,
     no_state
 };
 
-enum class launch { // names for launch options passed to async
+_EXPORT_STD enum class launch { // names for launch options passed to async
     async    = 0x1,
     deferred = 0x2
 };
 
-_BITMASK_OPS(launch)
+_BITMASK_OPS(_EXPORT_STD, launch)
 
-enum class future_status { // names for timed wait function returns
+_EXPORT_STD enum class future_status { // names for timed wait function returns
     ready,
     timeout,
     deferred
@@ -83,13 +83,13 @@ enum class future_status { // names for timed wait function returns
 template <>
 struct is_error_code_enum<future_errc> : true_type {};
 
-_NODISCARD const error_category& future_category() noexcept;
+_EXPORT_STD _NODISCARD const error_category& future_category() noexcept;
 
-_NODISCARD inline error_code make_error_code(future_errc _Ec) noexcept {
+_EXPORT_STD _NODISCARD inline error_code make_error_code(future_errc _Ec) noexcept {
     return error_code(static_cast<int>(_Ec), _STD future_category());
 }
 
-_NODISCARD inline error_condition make_error_condition(future_errc _Ec) noexcept {
+_EXPORT_STD _NODISCARD inline error_condition make_error_condition(future_errc _Ec) noexcept {
     return error_condition(static_cast<int>(_Ec), _STD future_category());
 }
 
@@ -112,7 +112,7 @@ _NODISCARD inline const char* _Future_error_map(int _Errcode) noexcept { // conv
     }
 }
 
-class future_error : public logic_error { // future exception
+_EXPORT_STD class future_error : public logic_error { // future exception
 public:
     explicit future_error(error_code _Errcode) // internal, TRANSITION, will be removed
         : logic_error(""), _Mycode(_Errcode) {}
@@ -161,7 +161,7 @@ public:
     }
 };
 
-_NODISCARD inline const error_category& future_category() noexcept {
+_EXPORT_STD _NODISCARD inline const error_category& future_category() noexcept {
     return _Immortalize_memcpy_image<_Future_error_category2>();
 }
 
@@ -880,10 +880,10 @@ private:
     bool _Get_only_once;
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class shared_future;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class future : public _State_manager<_Ty> {
     // class that defines a non-copyable asynchronous return object that holds a value
 private:
@@ -986,7 +986,7 @@ public:
     future& operator=(const future&) = delete;
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class shared_future : public _State_manager<_Ty> {
     // class that defines a copyable asynchronous return object that holds a value
 private:
@@ -1159,7 +1159,7 @@ private:
     bool _Future_retrieved;
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class promise { // class that defines an asynchronous provider that holds a value
 public:
     static_assert(!is_array_v<_Ty> && is_object_v<_Ty> && is_destructible_v<_Ty>,
@@ -1335,7 +1335,7 @@ private:
 template <class _Ty, class _Alloc>
 struct uses_allocator<promise<_Ty>, _Alloc> : true_type {};
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 void swap(promise<_Ty>& _Left, promise<_Ty>& _Right) noexcept {
     _Left.swap(_Right);
 }
@@ -1355,7 +1355,7 @@ struct _P_arg_type<void> { // type for functions returning void
     using type = int;
 };
 
-template <class>
+_EXPORT_STD template <class>
 class packaged_task; // not defined
 
 template <class _Ret, class... _ArgTypes>
@@ -1458,7 +1458,7 @@ template <class _Ty, class _Alloc>
 struct uses_allocator<packaged_task<_Ty>, _Alloc> : true_type {};
 #endif // _HAS_FUNCTION_ALLOCATOR_SUPPORT
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 void swap(packaged_task<_Ty>& _Left, packaged_task<_Ty>& _Right) noexcept {
     _Left.swap(_Right);
 }
@@ -1518,7 +1518,7 @@ _Associated_state<typename _P_arg_type<_Ret>::type>* _Get_associated_state(launc
     }
 }
 
-template <class _Fty, class... _ArgTypes>
+_EXPORT_STD template <class _Fty, class... _ArgTypes>
 _NODISCARD_ASYNC future<_Invoke_result_t<decay_t<_Fty>, decay_t<_ArgTypes>...>> async(
     launch _Policy, _Fty&& _Fnarg, _ArgTypes&&... _Args) {
     // manages a callable object launched with supplied policy
@@ -1531,7 +1531,7 @@ _NODISCARD_ASYNC future<_Invoke_result_t<decay_t<_Fty>, decay_t<_ArgTypes>...>>
     return future<_Ret>(_Pr._Get_state_for_future(), _Nil{});
 }
 
-template <class _Fty, class... _ArgTypes>
+_EXPORT_STD template <class _Fty, class... _ArgTypes>
 _NODISCARD_ASYNC future<_Invoke_result_t<decay_t<_Fty>, decay_t<_ArgTypes>...>> async(
     _Fty&& _Fnarg, _ArgTypes&&... _Args) {
     // manages a callable object launched with default policy
diff --git a/stl/inc/initializer_list b/stl/inc/initializer_list
index 2714f3d378..8fe7b121e5 100644
--- a/stl/inc/initializer_list
+++ b/stl/inc/initializer_list
@@ -18,7 +18,7 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 class initializer_list {
 public:
     using value_type      = _Elem;
@@ -51,12 +51,12 @@ private:
     const _Elem* _Last;
 };
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 _NODISCARD constexpr const _Elem* begin(initializer_list<_Elem> _Ilist) noexcept {
     return _Ilist.begin();
 }
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 _NODISCARD constexpr const _Elem* end(initializer_list<_Elem> _Ilist) noexcept {
     return _Ilist.end();
 }
diff --git a/stl/inc/iomanip b/stl/inc/iomanip
index 711b792bd7..60a049221a 100644
--- a/stl/inc/iomanip
+++ b/stl/inc/iomanip
@@ -46,7 +46,7 @@ struct _Fillobj { // store fill character
     _Elem _Fill; // the fill character
 };
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 _NODISCARD _Fillobj<_Elem> setfill(_Elem _Ch) {
     return _Fillobj<_Elem>(_Ch);
 }
@@ -103,12 +103,12 @@ struct _Monobj { // store reference to monetary amount
     bool _Intl; // international flag
 };
 
-template <class _Money>
+_EXPORT_STD template <class _Money>
 _NODISCARD _Monobj<_Money> get_money(_Money& _Val_arg, bool _Intl_arg = false) {
     return _Monobj<_Money>(_Val_arg, _Intl_arg);
 }
 
-template <class _Money>
+_EXPORT_STD template <class _Money>
 _NODISCARD _Monobj<const _Money> put_money(const _Money& _Val_arg, bool _Intl_arg = false) {
     return _Monobj<const _Money>(_Val_arg, _Intl_arg);
 }
@@ -174,12 +174,12 @@ struct _Timeobj { // store reference to tm object and format
     const _Elem* _Fmtlast; // format string end
 };
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 _NODISCARD _Timeobj<_Elem, tm*> get_time(tm* _Tptr_arg, const _Elem* _Fmt_arg) {
     return _Timeobj<_Elem, tm*>(_Tptr_arg, _Fmt_arg);
 }
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 _NODISCARD _Timeobj<_Elem, const tm*> put_time(const tm* _Tptr_arg, const _Elem* _Fmt_arg) {
     return _Timeobj<_Elem, const tm*>(_Tptr_arg, _Fmt_arg);
 }
@@ -352,28 +352,28 @@ struct _Quote_in { // store reference to string
     _Elem _Escape; // escape element
 };
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 _NODISCARD _Quote_out<_Elem, void, size_t> quoted(
     const _Elem* _Ptr, _Elem _Delim = _Elem('"'), _Elem _Escape = _Elem('\\')) {
     const size_t _Size = char_traits<_Elem>::length(_Ptr);
     return {_Ptr, _Size, _Delim, _Escape};
 }
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 _NODISCARD _Quote_out<_Elem, _Traits, typename basic_string<_Elem, _Traits, _Alloc>::size_type> quoted(
     const basic_string<_Elem, _Traits, _Alloc>& _Str, _Elem _Delim = _Elem('"'), _Elem _Escape = _Elem('\\')) {
     return {_Str.c_str(), _Str.size(), _Delim, _Escape};
 }
 
 #if _HAS_CXX17
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 _NODISCARD _Quote_out<_Elem, _Traits, size_t> quoted(
     const basic_string_view<_Elem, _Traits> _Str, _Elem _Delim = _Elem('"'), _Elem _Escape = _Elem('\\')) {
     return {_Str.data(), _Str.size(), _Delim, _Escape};
 }
 #endif // _HAS_CXX17
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 _NODISCARD _Quote_in<_Elem, _Traits, _Alloc> quoted(
     basic_string<_Elem, _Traits, _Alloc>& _Str, _Elem _Delim = _Elem('"'), _Elem _Escape = _Elem('\\')) {
     return {_Str, _Delim, _Escape};
@@ -401,11 +401,11 @@ struct _Smanip { // store function pointer and argument value
     _Arg _Manarg; // the argument value
 };
 
-_NODISCARD _MRTIMP2 _Smanip<ios_base::fmtflags> __cdecl resetiosflags(ios_base::fmtflags);
-_NODISCARD _MRTIMP2 _Smanip<ios_base::fmtflags> __cdecl setiosflags(ios_base::fmtflags);
-_NODISCARD _MRTIMP2 _Smanip<int> __cdecl setbase(int);
-_NODISCARD _MRTIMP2 _Smanip<streamsize> __cdecl setprecision(streamsize);
-_NODISCARD _MRTIMP2 _Smanip<streamsize> __cdecl setw(streamsize);
+_EXPORT_STD extern "C++" _NODISCARD _MRTIMP2 _Smanip<ios_base::fmtflags> __cdecl resetiosflags(ios_base::fmtflags);
+_EXPORT_STD extern "C++" _NODISCARD _MRTIMP2 _Smanip<ios_base::fmtflags> __cdecl setiosflags(ios_base::fmtflags);
+_EXPORT_STD extern "C++" _NODISCARD _MRTIMP2 _Smanip<int> __cdecl setbase(int);
+_EXPORT_STD extern "C++" _NODISCARD _MRTIMP2 _Smanip<streamsize> __cdecl setprecision(streamsize);
+_EXPORT_STD extern "C++" _NODISCARD _MRTIMP2 _Smanip<streamsize> __cdecl setw(streamsize);
 _STD_END
 #pragma pop_macro("new")
 _STL_RESTORE_CLANG_WARNINGS
diff --git a/stl/inc/ios b/stl/inc/ios
index 3fdfc02c1f..319a26c3d9 100644
--- a/stl/inc/ios
+++ b/stl/inc/ios
@@ -18,7 +18,7 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-template <class _Elem, class _Traits>
+_EXPORT_STD extern "C++" template <class _Elem, class _Traits>
 class basic_ios : public ios_base { // base class for basic_istream/basic_ostream
 public:
     using _Myos       = basic_ostream<_Elem, _Traits>;
@@ -181,122 +181,122 @@ template class _CRTIMP2_PURE_IMPORT basic_ios<unsigned short, char_traits<unsign
 #endif // __FORCE_INSTANCE
 #endif // defined(_DLL_CPPLIB)
 
-inline ios_base& __CLRCALL_OR_CDECL boolalpha(ios_base& _Iosbase) { // set boolalpha
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL boolalpha(ios_base& _Iosbase) { // set boolalpha
     _Iosbase.setf(ios_base::boolalpha);
     return _Iosbase;
 }
 
-inline ios_base& __CLRCALL_OR_CDECL dec(ios_base& _Iosbase) { // set basefield to dec
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL dec(ios_base& _Iosbase) { // set basefield to dec
     _Iosbase.setf(ios_base::dec, ios_base::basefield);
     return _Iosbase;
 }
 
-inline ios_base& __CLRCALL_OR_CDECL defaultfloat(ios_base& _Iosbase) { // clear floatfield
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL defaultfloat(ios_base& _Iosbase) { // clear floatfield
     _Iosbase.unsetf(ios_base::floatfield);
     return _Iosbase;
 }
 
-inline ios_base& __CLRCALL_OR_CDECL fixed(ios_base& _Iosbase) { // set floatfield to fixed
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL fixed(ios_base& _Iosbase) { // set floatfield to fixed
     _Iosbase.setf(ios_base::fixed, ios_base::floatfield);
     return _Iosbase;
 }
 
-inline ios_base& __CLRCALL_OR_CDECL hex(ios_base& _Iosbase) { // set basefield to hex
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL hex(ios_base& _Iosbase) { // set basefield to hex
     _Iosbase.setf(ios_base::hex, ios_base::basefield);
     return _Iosbase;
 }
 
-inline ios_base& __CLRCALL_OR_CDECL hexfloat(ios_base& _Iosbase) { // set floatfield to hexfloat
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL hexfloat(ios_base& _Iosbase) { // set floatfield to hexfloat
     _Iosbase.setf(ios_base::hexfloat, ios_base::floatfield);
     return _Iosbase;
 }
 
-inline ios_base& __CLRCALL_OR_CDECL internal(ios_base& _Iosbase) { // set adjustfield to internal
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL internal(ios_base& _Iosbase) { // set adjustfield to internal
     _Iosbase.setf(ios_base::internal, ios_base::adjustfield);
     return _Iosbase;
 }
 
-inline ios_base& __CLRCALL_OR_CDECL left(ios_base& _Iosbase) { // set adjustfield to left
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL left(ios_base& _Iosbase) { // set adjustfield to left
     _Iosbase.setf(ios_base::left, ios_base::adjustfield);
     return _Iosbase;
 }
 
-inline ios_base& __CLRCALL_OR_CDECL noboolalpha(ios_base& _Iosbase) { // clear boolalpha
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL noboolalpha(ios_base& _Iosbase) { // clear boolalpha
     _Iosbase.unsetf(ios_base::boolalpha);
     return _Iosbase;
 }
 
-inline ios_base& __CLRCALL_OR_CDECL noshowbase(ios_base& _Iosbase) { // clear showbase
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL noshowbase(ios_base& _Iosbase) { // clear showbase
     _Iosbase.unsetf(ios_base::showbase);
     return _Iosbase;
 }
 
-inline ios_base& __CLRCALL_OR_CDECL noshowpoint(ios_base& _Iosbase) { // clear showpoint
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL noshowpoint(ios_base& _Iosbase) { // clear showpoint
     _Iosbase.unsetf(ios_base::showpoint);
     return _Iosbase;
 }
 
-inline ios_base& __CLRCALL_OR_CDECL noshowpos(ios_base& _Iosbase) { // clear showpos
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL noshowpos(ios_base& _Iosbase) { // clear showpos
     _Iosbase.unsetf(ios_base::showpos);
     return _Iosbase;
 }
 
-inline ios_base& __CLRCALL_OR_CDECL noskipws(ios_base& _Iosbase) { // clear skipws
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL noskipws(ios_base& _Iosbase) { // clear skipws
     _Iosbase.unsetf(ios_base::skipws);
     return _Iosbase;
 }
 
-inline ios_base& __CLRCALL_OR_CDECL nounitbuf(ios_base& _Iosbase) { // clear unitbuf
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL nounitbuf(ios_base& _Iosbase) { // clear unitbuf
     _Iosbase.unsetf(ios_base::unitbuf);
     return _Iosbase;
 }
 
-inline ios_base& __CLRCALL_OR_CDECL nouppercase(ios_base& _Iosbase) { // clear uppercase
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL nouppercase(ios_base& _Iosbase) { // clear uppercase
     _Iosbase.unsetf(ios_base::uppercase);
     return _Iosbase;
 }
 
-inline ios_base& __CLRCALL_OR_CDECL oct(ios_base& _Iosbase) { // set oct in basefield
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL oct(ios_base& _Iosbase) { // set oct in basefield
     _Iosbase.setf(ios_base::oct, ios_base::basefield);
     return _Iosbase;
 }
 
-inline ios_base& __CLRCALL_OR_CDECL right(ios_base& _Iosbase) { // set right in adjustfield
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL right(ios_base& _Iosbase) { // set right in adjustfield
     _Iosbase.setf(ios_base::right, ios_base::adjustfield);
     return _Iosbase;
 }
 
-inline ios_base& __CLRCALL_OR_CDECL scientific(ios_base& _Iosbase) { // set scientific in floatfield
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL scientific(ios_base& _Iosbase) { // set scientific in floatfield
     _Iosbase.setf(ios_base::scientific, ios_base::floatfield);
     return _Iosbase;
 }
 
-inline ios_base& __CLRCALL_OR_CDECL showbase(ios_base& _Iosbase) { // set showbase
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL showbase(ios_base& _Iosbase) { // set showbase
     _Iosbase.setf(ios_base::showbase);
     return _Iosbase;
 }
 
-inline ios_base& __CLRCALL_OR_CDECL showpoint(ios_base& _Iosbase) { // set showpoint
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL showpoint(ios_base& _Iosbase) { // set showpoint
     _Iosbase.setf(ios_base::showpoint);
     return _Iosbase;
 }
 
-inline ios_base& __CLRCALL_OR_CDECL showpos(ios_base& _Iosbase) { // set showpos
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL showpos(ios_base& _Iosbase) { // set showpos
     _Iosbase.setf(ios_base::showpos);
     return _Iosbase;
 }
 
-inline ios_base& __CLRCALL_OR_CDECL skipws(ios_base& _Iosbase) { // set skipws
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL skipws(ios_base& _Iosbase) { // set skipws
     _Iosbase.setf(ios_base::skipws);
     return _Iosbase;
 }
 
-inline ios_base& __CLRCALL_OR_CDECL unitbuf(ios_base& _Iosbase) { // set unitbuf
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL unitbuf(ios_base& _Iosbase) { // set unitbuf
     _Iosbase.setf(ios_base::unitbuf);
     return _Iosbase;
 }
 
-inline ios_base& __CLRCALL_OR_CDECL uppercase(ios_base& _Iosbase) { // set uppercase
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL uppercase(ios_base& _Iosbase) { // set uppercase
     _Iosbase.setf(ios_base::uppercase);
     return _Iosbase;
 }
diff --git a/stl/inc/iosfwd b/stl/inc/iosfwd
index 2462b10426..81b6d61bd2 100644
--- a/stl/inc/iosfwd
+++ b/stl/inc/iosfwd
@@ -44,10 +44,10 @@ _STD_BEGIN
 #endif // _HAS_EXCEPTIONS
 
 // from <streambuf>
-using streamoff  = long long;
-using streamsize = long long;
+_EXPORT_STD using streamoff  = long long;
+_EXPORT_STD using streamsize = long long;
 
-template <class _Statetype>
+_EXPORT_STD template <class _Statetype>
 class fpos { // store arbitrary file position
 public:
     /* implicit */ fpos(streamoff _Off = 0) : _Myoff(_Off), _Fpos(0), _Mystate() {}
@@ -134,19 +134,19 @@ private:
     _Statetype _Mystate; // current conversion state
 };
 
-using streampos  = fpos<_Mbstatet>;
-using wstreampos = streampos;
+_EXPORT_STD using streampos  = fpos<_Mbstatet>;
+_EXPORT_STD using wstreampos = streampos;
 #ifdef __cpp_lib_char8_t
-using u8streampos = streampos;
+_EXPORT_STD using u8streampos = streampos;
 #endif // __cpp_lib_char8_t
-using u16streampos = streampos;
-using u32streampos = streampos;
+_EXPORT_STD using u16streampos = streampos;
+_EXPORT_STD using u32streampos = streampos;
 
-class locale;
-template <class _Facet>
+_EXPORT_STD extern "C++" class locale;
+_EXPORT_STD template <class _Facet>
 const _Facet& __CRTDECL use_facet(const locale&);
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 struct char_traits;
 template <>
 struct char_traits<char>;
@@ -165,117 +165,117 @@ template <>
 struct char_traits<unsigned short>;
 #endif // _CRTBLD
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class allocator;
-class ios_base;
-template <class _Elem, class _Traits = char_traits<_Elem>>
+_EXPORT_STD extern "C++" class ios_base;
+_EXPORT_STD extern "C++" template <class _Elem, class _Traits = char_traits<_Elem>>
 class basic_ios;
-template <class _Elem, class _Traits = char_traits<_Elem>>
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>>
 class istreambuf_iterator;
-template <class _Elem, class _Traits = char_traits<_Elem>>
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>>
 class ostreambuf_iterator;
-template <class _Elem, class _Traits = char_traits<_Elem>>
+_EXPORT_STD extern "C++" template <class _Elem, class _Traits = char_traits<_Elem>>
 class basic_streambuf;
 
 #pragma vtordisp(push, 2) // compiler bug workaround
-template <class _Elem, class _Traits = char_traits<_Elem>>
+_EXPORT_STD extern "C++" template <class _Elem, class _Traits = char_traits<_Elem>>
 class basic_istream;
-template <class _Elem, class _Traits = char_traits<_Elem>>
+_EXPORT_STD extern "C++" template <class _Elem, class _Traits = char_traits<_Elem>>
 class basic_ostream;
 #pragma vtordisp(pop) // compiler bug workaround
 
-template <class _Elem, class _Traits = char_traits<_Elem>>
+_EXPORT_STD extern "C++" template <class _Elem, class _Traits = char_traits<_Elem>>
 class basic_iostream;
-template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
 class basic_stringbuf;
-template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
 class basic_istringstream;
-template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
 class basic_ostringstream;
-template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
 class basic_stringstream;
 #if _HAS_CXX23
-template <class _Elem, class _Traits = char_traits<_Elem>>
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>>
 class basic_spanbuf;
-template <class _Elem, class _Traits = char_traits<_Elem>>
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>>
 class basic_ispanstream;
-template <class _Elem, class _Traits = char_traits<_Elem>>
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>>
 class basic_ospanstream;
-template <class _Elem, class _Traits = char_traits<_Elem>>
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>>
 class basic_spanstream;
 #endif // _HAS_CXX23
-template <class _Elem, class _Traits = char_traits<_Elem>>
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>>
 class basic_filebuf;
-template <class _Elem, class _Traits = char_traits<_Elem>>
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>>
 class basic_ifstream;
-template <class _Elem, class _Traits = char_traits<_Elem>>
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>>
 class basic_ofstream;
-template <class _Elem, class _Traits = char_traits<_Elem>>
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>>
 class basic_fstream;
 #if _HAS_CXX20
 template <class _Elem, class _Traits = char_traits<_Elem>>
 class _Basic_syncbuf_impl;
-template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
 class basic_syncbuf;
-template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
 class basic_osyncstream;
 #endif // _HAS_CXX20
 
 #if defined(_DLL_CPPLIB)
-template <class _Elem, class _InIt>
+_EXPORT_STD extern "C++" template <class _Elem, class _InIt>
 class num_get;
-template <class _Elem, class _OutIt>
+_EXPORT_STD extern "C++" template <class _Elem, class _OutIt>
 class num_put;
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 class collate;
 #endif // defined(_DLL_CPPLIB)
 
-using ios           = basic_ios<char, char_traits<char>>;
-using streambuf     = basic_streambuf<char, char_traits<char>>;
-using istream       = basic_istream<char, char_traits<char>>;
-using ostream       = basic_ostream<char, char_traits<char>>;
-using iostream      = basic_iostream<char, char_traits<char>>;
-using stringbuf     = basic_stringbuf<char, char_traits<char>, allocator<char>>;
-using istringstream = basic_istringstream<char, char_traits<char>, allocator<char>>;
-using ostringstream = basic_ostringstream<char, char_traits<char>, allocator<char>>;
-using stringstream  = basic_stringstream<char, char_traits<char>, allocator<char>>;
-using filebuf       = basic_filebuf<char, char_traits<char>>;
-using ifstream      = basic_ifstream<char, char_traits<char>>;
-using ofstream      = basic_ofstream<char, char_traits<char>>;
-using fstream       = basic_fstream<char, char_traits<char>>;
+_EXPORT_STD using ios           = basic_ios<char, char_traits<char>>;
+_EXPORT_STD using streambuf     = basic_streambuf<char, char_traits<char>>;
+_EXPORT_STD using istream       = basic_istream<char, char_traits<char>>;
+_EXPORT_STD using ostream       = basic_ostream<char, char_traits<char>>;
+_EXPORT_STD using iostream      = basic_iostream<char, char_traits<char>>;
+_EXPORT_STD using stringbuf     = basic_stringbuf<char, char_traits<char>, allocator<char>>;
+_EXPORT_STD using istringstream = basic_istringstream<char, char_traits<char>, allocator<char>>;
+_EXPORT_STD using ostringstream = basic_ostringstream<char, char_traits<char>, allocator<char>>;
+_EXPORT_STD using stringstream  = basic_stringstream<char, char_traits<char>, allocator<char>>;
+_EXPORT_STD using filebuf       = basic_filebuf<char, char_traits<char>>;
+_EXPORT_STD using ifstream      = basic_ifstream<char, char_traits<char>>;
+_EXPORT_STD using ofstream      = basic_ofstream<char, char_traits<char>>;
+_EXPORT_STD using fstream       = basic_fstream<char, char_traits<char>>;
 #if _HAS_CXX20
-using syncbuf     = basic_syncbuf<char>;
-using osyncstream = basic_osyncstream<char>;
+_EXPORT_STD using syncbuf     = basic_syncbuf<char>;
+_EXPORT_STD using osyncstream = basic_osyncstream<char>;
 #endif // _HAS_CXX20
 #if _HAS_CXX23
-using spanbuf     = basic_spanbuf<char>;
-using ispanstream = basic_ispanstream<char>;
-using ospanstream = basic_ospanstream<char>;
-using spanstream  = basic_spanstream<char>;
+_EXPORT_STD using spanbuf     = basic_spanbuf<char>;
+_EXPORT_STD using ispanstream = basic_ispanstream<char>;
+_EXPORT_STD using ospanstream = basic_ospanstream<char>;
+_EXPORT_STD using spanstream  = basic_spanstream<char>;
 #endif // _HAS_CXX23
 
-using wios           = basic_ios<wchar_t, char_traits<wchar_t>>;
-using wstreambuf     = basic_streambuf<wchar_t, char_traits<wchar_t>>;
-using wistream       = basic_istream<wchar_t, char_traits<wchar_t>>;
-using wostream       = basic_ostream<wchar_t, char_traits<wchar_t>>;
-using wiostream      = basic_iostream<wchar_t, char_traits<wchar_t>>;
-using wstringbuf     = basic_stringbuf<wchar_t, char_traits<wchar_t>, allocator<wchar_t>>;
-using wistringstream = basic_istringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t>>;
-using wostringstream = basic_ostringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t>>;
-using wstringstream  = basic_stringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t>>;
-using wfilebuf       = basic_filebuf<wchar_t, char_traits<wchar_t>>;
-using wifstream      = basic_ifstream<wchar_t, char_traits<wchar_t>>;
-using wofstream      = basic_ofstream<wchar_t, char_traits<wchar_t>>;
-using wfstream       = basic_fstream<wchar_t, char_traits<wchar_t>>;
+_EXPORT_STD using wios           = basic_ios<wchar_t, char_traits<wchar_t>>;
+_EXPORT_STD using wstreambuf     = basic_streambuf<wchar_t, char_traits<wchar_t>>;
+_EXPORT_STD using wistream       = basic_istream<wchar_t, char_traits<wchar_t>>;
+_EXPORT_STD using wostream       = basic_ostream<wchar_t, char_traits<wchar_t>>;
+_EXPORT_STD using wiostream      = basic_iostream<wchar_t, char_traits<wchar_t>>;
+_EXPORT_STD using wstringbuf     = basic_stringbuf<wchar_t, char_traits<wchar_t>, allocator<wchar_t>>;
+_EXPORT_STD using wistringstream = basic_istringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t>>;
+_EXPORT_STD using wostringstream = basic_ostringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t>>;
+_EXPORT_STD using wstringstream  = basic_stringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t>>;
+_EXPORT_STD using wfilebuf       = basic_filebuf<wchar_t, char_traits<wchar_t>>;
+_EXPORT_STD using wifstream      = basic_ifstream<wchar_t, char_traits<wchar_t>>;
+_EXPORT_STD using wofstream      = basic_ofstream<wchar_t, char_traits<wchar_t>>;
+_EXPORT_STD using wfstream       = basic_fstream<wchar_t, char_traits<wchar_t>>;
 #if _HAS_CXX20
-using wsyncbuf     = basic_syncbuf<wchar_t>;
-using wosyncstream = basic_osyncstream<wchar_t>;
+_EXPORT_STD using wsyncbuf     = basic_syncbuf<wchar_t>;
+_EXPORT_STD using wosyncstream = basic_osyncstream<wchar_t>;
 #endif // _HAS_CXX20
 #if _HAS_CXX23
-using wspanbuf     = basic_spanbuf<wchar_t>;
-using wispanstream = basic_ispanstream<wchar_t>;
-using wospanstream = basic_ospanstream<wchar_t>;
-using wspanstream  = basic_spanstream<wchar_t>;
+_EXPORT_STD using wspanbuf     = basic_spanbuf<wchar_t>;
+_EXPORT_STD using wispanstream = basic_ispanstream<wchar_t>;
+_EXPORT_STD using wospanstream = basic_ospanstream<wchar_t>;
+_EXPORT_STD using wspanstream  = basic_spanstream<wchar_t>;
 #endif // _HAS_CXX23
 
 _STD_END
diff --git a/stl/inc/iostream b/stl/inc/iostream
index 04da464dd0..efa221eb4f 100644
--- a/stl/inc/iostream
+++ b/stl/inc/iostream
@@ -36,23 +36,23 @@ __PURE_APPDOMAIN_GLOBAL extern wostream* _Ptr_wcout;
 __PURE_APPDOMAIN_GLOBAL extern wostream* _Ptr_wcerr;
 __PURE_APPDOMAIN_GLOBAL extern wostream* _Ptr_wclog;
 #else // _M_CEE_PURE
-__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT istream cin;
-__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT ostream cout;
-__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT ostream cerr;
-__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT ostream clog;
-__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT istream* _Ptr_cin;
-__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT ostream* _Ptr_cout;
-__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT ostream* _Ptr_cerr;
-__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT ostream* _Ptr_clog;
+_EXPORT_STD extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT istream cin;
+_EXPORT_STD extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT ostream cout;
+_EXPORT_STD extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT ostream cerr;
+_EXPORT_STD extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT ostream clog;
+extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT istream* _Ptr_cin;
+extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT ostream* _Ptr_cout;
+extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT ostream* _Ptr_cerr;
+extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT ostream* _Ptr_clog;
 
-__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT wistream wcin;
-__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT wostream wcout;
-__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT wostream wcerr;
-__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT wostream wclog;
-__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT wistream* _Ptr_wcin;
-__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT wostream* _Ptr_wcout;
-__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT wostream* _Ptr_wcerr;
-__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT wostream* _Ptr_wclog;
+_EXPORT_STD extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT wistream wcin;
+_EXPORT_STD extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT wostream wcout;
+_EXPORT_STD extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT wostream wcerr;
+_EXPORT_STD extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT wostream wclog;
+extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT wistream* _Ptr_wcin;
+extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT wostream* _Ptr_wcout;
+extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT wostream* _Ptr_wcerr;
+extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT wostream* _Ptr_wclog;
 
 #ifdef _CRTBLD // TRANSITION, ABI: _Winit appears to be unused
 class _CRTIMP2_PURE_IMPORT _Winit {
diff --git a/stl/inc/istream b/stl/inc/istream
index fd7f0caaab..c976a77089 100644
--- a/stl/inc/istream
+++ b/stl/inc/istream
@@ -20,7 +20,7 @@ _STL_DISABLE_CLANG_WARNINGS
 _STD_BEGIN
 #pragma vtordisp(push, 2) // compiler bug workaround
 
-template <class _Elem, class _Traits>
+_EXPORT_STD extern "C++" template <class _Elem, class _Traits>
 class basic_istream : virtual public basic_ios<_Elem, _Traits> { // control extractions from a stream buffer
 public:
     using _Myios = basic_ios<_Elem, _Traits>;
@@ -721,7 +721,7 @@ template class _CRTIMP2_PURE_IMPORT basic_istream<unsigned short, char_traits<un
 #endif // __FORCE_INSTANCE
 #endif // defined(_DLL_CPPLIB)
 
-template <class _Elem, class _Traits>
+_EXPORT_STD extern "C++" template <class _Elem, class _Traits>
 class basic_iostream : public basic_istream<_Elem, _Traits>,
                        public basic_ostream<_Elem, _Traits> { // control insertions and extractions from a stream buffer
 public:
@@ -820,19 +820,19 @@ basic_istream<_Elem, _Traits>& _Istream_extract_into_buffer(
 #if _HAS_CXX20 // P0487R1 Fixing operator>>(basic_istream&, CharT*)
 #pragma warning(push)
 #pragma warning(disable : 6001) // Using uninitialized memory '_Str'.
-template <class _Elem, class _Traits, size_t _Size>
+_EXPORT_STD template <class _Elem, class _Traits, size_t _Size>
 basic_istream<_Elem, _Traits>& operator>>(
     basic_istream<_Elem, _Traits>& _Istr, _Out_writes_z_(_Size) _Elem (&_Str)[_Size]) {
     return _Istream_extract_into_buffer(_Istr, _Size, _Str);
 }
 
-template <class _Traits, size_t _Size>
+_EXPORT_STD template <class _Traits, size_t _Size>
 basic_istream<char, _Traits>& operator>>(
     basic_istream<char, _Traits>& _Istr, _Out_writes_z_(_Size) signed char (&_Str)[_Size]) {
     return _Istream_extract_into_buffer(_Istr, _Size, reinterpret_cast<char*>(_Str));
 }
 
-template <class _Traits, size_t _Size>
+_EXPORT_STD template <class _Traits, size_t _Size>
 basic_istream<char, _Traits>& operator>>(
     basic_istream<char, _Traits>& _Istr, _Out_writes_z_(_Size) unsigned char (&_Str)[_Size]) {
     return _Istream_extract_into_buffer(_Istr, _Size, reinterpret_cast<char*>(_Str));
@@ -855,7 +855,7 @@ basic_istream<char, _Traits>& operator>>(basic_istream<char, _Traits>& _Istr, un
 }
 #endif // _HAS_CXX20
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, _Elem& _Ch) { // extract a character
     using _Myis = basic_istream<_Elem, _Traits>;
 
@@ -878,13 +878,13 @@ basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
     return _Istr;
 }
 
-template <class _Traits>
+_EXPORT_STD template <class _Traits>
 basic_istream<char, _Traits>& operator>>(basic_istream<char, _Traits>& _Istr, signed char& _Ch) {
     // extract a signed char
     return _Istr >> reinterpret_cast<char&>(_Ch);
 }
 
-template <class _Traits>
+_EXPORT_STD template <class _Traits>
 basic_istream<char, _Traits>& operator>>(basic_istream<char, _Traits>& _Istr, unsigned char& _Ch) {
     // extract an unsigned char
     return _Istr >> reinterpret_cast<char&>(_Ch);
@@ -896,14 +896,14 @@ struct _Can_stream_in : false_type {};
 template <class _Istr, class _Ty>
 struct _Can_stream_in<_Istr, _Ty, void_t<decltype(_STD declval<_Istr&>() >> _STD declval<_Ty>())>> : true_type {};
 
-template <class _Istr, class _Ty,
+_EXPORT_STD template <class _Istr, class _Ty,
     enable_if_t<conjunction_v<is_convertible<_Istr*, ios_base*>, _Can_stream_in<_Istr, _Ty>>, int> = 0>
 _Istr&& operator>>(_Istr&& _Is, _Ty&& _Val) { // extract from rvalue stream
     _Is >> _STD forward<_Ty>(_Val);
     return _STD move(_Is);
 }
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 basic_istream<_Elem, _Traits>& __CLRCALL_OR_CDECL ws(basic_istream<_Elem, _Traits>& _Istr) { // consume whitespace
     const typename basic_istream<_Elem, _Traits>::sentry _Ok(_Istr, true);
 
diff --git a/stl/inc/iterator b/stl/inc/iterator
index 1da5cfd10e..5b2e5ec211 100644
--- a/stl/inc/iterator
+++ b/stl/inc/iterator
@@ -19,7 +19,7 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-template <class _Container>
+_EXPORT_STD template <class _Container>
 class back_insert_iterator { // wrap pushes to back of container as output iterator
 public:
     using iterator_category = output_iterator_tag;
@@ -64,13 +64,13 @@ protected:
     _Container* container;
 };
 
-template <class _Container>
+_EXPORT_STD template <class _Container>
 _NODISCARD _CONSTEXPR20 back_insert_iterator<_Container> back_inserter(_Container& _Cont) noexcept /* strengthened */ {
     // return a back_insert_iterator
     return back_insert_iterator<_Container>(_Cont);
 }
 
-template <class _Container>
+_EXPORT_STD template <class _Container>
 class front_insert_iterator { // wrap pushes to front of container as output iterator
 public:
     using iterator_category = output_iterator_tag;
@@ -115,12 +115,12 @@ protected:
     _Container* container;
 };
 
-template <class _Container>
+_EXPORT_STD template <class _Container>
 _NODISCARD _CONSTEXPR20 front_insert_iterator<_Container> front_inserter(_Container& _Cont) {
     return front_insert_iterator<_Container>(_Cont);
 }
 
-template <class _Container>
+_EXPORT_STD template <class _Container>
 class insert_iterator { // wrap inserts into container as output iterator
 public:
     using iterator_category = output_iterator_tag;
@@ -176,12 +176,12 @@ _NODISCARD _CONSTEXPR20 insert_iterator<_Container> inserter(_Container& _Cont,
     return insert_iterator<_Container>(_Cont, _Where);
 }
 #else // ^^^ No Ranges / Ranges vvv
-template <class _Container>
+_EXPORT_STD template <class _Container>
 _NODISCARD constexpr insert_iterator<_Container> inserter(_Container& _Cont, _RANGES iterator_t<_Container> _Where) {
     return insert_iterator<_Container>(_Cont, _Where);
 }
 
-template <semiregular _Se>
+_EXPORT_STD template <semiregular _Se>
 class move_sentinel {
 public:
     constexpr move_sentinel() = default;
@@ -235,7 +235,7 @@ private:
 };
 #endif // __cpp_lib_concepts
 
-template <class _Ty, class _Elem = char, class _Traits = char_traits<_Elem>, class _Diff = ptrdiff_t>
+_EXPORT_STD template <class _Ty, class _Elem = char, class _Traits = char_traits<_Elem>, class _Diff = ptrdiff_t>
 class istream_iterator {
 public:
     using iterator_category = input_iterator_tag;
@@ -305,7 +305,7 @@ private:
     _Ty _Myval{}; // lookahead value (valid if _Myistr is not null)
 };
 
-template <class _Ty, class _Elem, class _Traits, class _Diff>
+_EXPORT_STD template <class _Ty, class _Elem, class _Traits, class _Diff>
 _NODISCARD bool operator==(const istream_iterator<_Ty, _Elem, _Traits, _Diff>& _Left,
     const istream_iterator<_Ty, _Elem, _Traits, _Diff>& _Right) noexcept /* strengthened */ {
     return _Left._Equal(_Right);
@@ -319,7 +319,7 @@ _NODISCARD bool operator!=(const istream_iterator<_Ty, _Elem, _Traits, _Diff>& _
 }
 #endif // !_HAS_CXX20
 
-template <class _Ty, class _Elem = char, class _Traits = char_traits<_Elem>>
+_EXPORT_STD template <class _Ty, class _Elem = char, class _Traits = char_traits<_Elem>>
 class ostream_iterator {
 public:
     using iterator_category = output_iterator_tag;
@@ -364,7 +364,7 @@ private:
     ostream_type* _Myostr; // pointer to output stream
 };
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 class istreambuf_iterator {
 public:
     using iterator_category = input_iterator_tag;
@@ -487,7 +487,7 @@ private:
     mutable _Elem _Val; // next element to deliver
 };
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 _NODISCARD bool operator==(
     const istreambuf_iterator<_Elem, _Traits>& _Left, const istreambuf_iterator<_Elem, _Traits>& _Right) {
     return _Left.equal(_Right);
@@ -501,7 +501,7 @@ _NODISCARD bool operator!=(
 }
 #endif // !_HAS_CXX20
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 class ostreambuf_iterator {
 public:
     using iterator_category = output_iterator_tag;
@@ -848,7 +848,7 @@ concept _Use_postfix_proxy = !requires(_Iter& __it) { { *__it++ } -> _Can_refere
     && constructible_from<iter_value_t<_Iter>, iter_reference_t<_Iter>>
     && move_constructible<iter_value_t<_Iter>>;
 
-template <input_or_output_iterator _Iter, sentinel_for<_Iter> _Se>
+_EXPORT_STD template <input_or_output_iterator _Iter, sentinel_for<_Iter> _Se>
     requires (!same_as<_Iter, _Se> && copyable<_Iter>)
 class common_iterator {
     // clang-format on
@@ -1128,7 +1128,7 @@ struct _Counted_iterator_concept_base<_Iter> : _Counted_iterator_category_base<_
     using iterator_concept = typename _Iter::iterator_concept;
 };
 
-template <input_or_output_iterator _Iter>
+_EXPORT_STD template <input_or_output_iterator _Iter>
 class counted_iterator : public _Counted_iterator_concept_base<_Iter> {
 public:
     using iterator_type   = _Iter;
diff --git a/stl/inc/latch b/stl/inc/latch
index 7ca2d02cf9..e18586f415 100644
--- a/stl/inc/latch
+++ b/stl/inc/latch
@@ -29,7 +29,7 @@ _STL_DISABLE_CLANG_WARNINGS
 
 _STD_BEGIN
 
-class latch {
+_EXPORT_STD class latch {
 public:
     _NODISCARD static constexpr ptrdiff_t(max)() noexcept {
         return (1ULL << (sizeof(ptrdiff_t) * CHAR_BIT - 1)) - 1;
diff --git a/stl/inc/limits b/stl/inc/limits
index 9fa62e60dd..f255b2c214 100644
--- a/stl/inc/limits
+++ b/stl/inc/limits
@@ -35,13 +35,13 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-enum float_denorm_style { // constants for different IEEE float denormalization styles
+_EXPORT_STD enum float_denorm_style { // constants for different IEEE float denormalization styles
     denorm_indeterminate = -1,
     denorm_absent        = 0,
     denorm_present       = 1
 };
 
-enum float_round_style { // constants for different IEEE rounding styles
+_EXPORT_STD enum float_round_style { // constants for different IEEE rounding styles
     round_indeterminate       = -1,
     round_toward_zero         = 0,
     round_to_nearest          = 1,
@@ -75,7 +75,7 @@ struct _Num_base { // base for all types, with common defaults
     static constexpr int radix                     = 0;
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class numeric_limits : public _Num_base { // numeric limits for arbitrary type _Ty (say little or nothing)
 public:
     _NODISCARD static constexpr _Ty(min)() noexcept {
diff --git a/stl/inc/list b/stl/inc/list
index 7d248f34de..509e2299d6 100644
--- a/stl/inc/list
+++ b/stl/inc/list
@@ -752,7 +752,7 @@ private:
 template <class _Traits>
 class _Hash;
 
-template <class _Ty, class _Alloc = allocator<_Ty>>
+_EXPORT_STD template <class _Ty, class _Alloc = allocator<_Ty>>
 class list { // bidirectional linked list
 private:
     template <class>
@@ -1864,12 +1864,12 @@ template <_RANGES input_range _Rng, class _Alloc = allocator<_RANGES range_value
 list(from_range_t, _Rng&&, _Alloc = _Alloc()) -> list<_RANGES range_value_t<_Rng>, _Alloc>;
 #endif // _HAS_CXX23 && defined(__cpp_lib_concepts)
 
-template <class _Ty, class _Alloc>
+_EXPORT_STD template <class _Ty, class _Alloc>
 void swap(list<_Ty, _Alloc>& _Left, list<_Ty, _Alloc>& _Right) noexcept /* strengthened */ {
     _Left.swap(_Right);
 }
 
-template <class _Ty, class _Alloc>
+_EXPORT_STD template <class _Ty, class _Alloc>
 _NODISCARD bool operator==(const list<_Ty, _Alloc>& _Left, const list<_Ty, _Alloc>& _Right) {
     return _Left.size() == _Right.size()
         && _STD equal(_Left._Unchecked_begin(), _Left._Unchecked_end(), _Right._Unchecked_begin());
@@ -1883,7 +1883,7 @@ _NODISCARD bool operator!=(const list<_Ty, _Alloc>& _Left, const list<_Ty, _Allo
 #endif // !_HAS_CXX20
 
 #ifdef __cpp_lib_concepts
-template <class _Ty, class _Alloc>
+_EXPORT_STD template <class _Ty, class _Alloc>
 _NODISCARD _Synth_three_way_result<_Ty> operator<=>(const list<_Ty, _Alloc>& _Left, const list<_Ty, _Alloc>& _Right) {
     return _STD lexicographical_compare_three_way(_Left._Unchecked_begin(), _Left._Unchecked_end(),
         _Right._Unchecked_begin(), _Right._Unchecked_end(), _Synth_three_way{});
@@ -1912,12 +1912,12 @@ _NODISCARD bool operator>=(const list<_Ty, _Alloc>& _Left, const list<_Ty, _Allo
 #endif // ^^^ !defined(__cpp_lib_concepts) ^^^
 
 #if _HAS_CXX20
-template <class _Ty, class _Alloc, class _Uty>
+_EXPORT_STD template <class _Ty, class _Alloc, class _Uty>
 typename list<_Ty, _Alloc>::size_type erase(list<_Ty, _Alloc>& _Cont, const _Uty& _Val) {
     return _Cont.remove_if([&](_Ty& _Elem) { return _Elem == _Val; });
 }
 
-template <class _Ty, class _Alloc, class _Pr>
+_EXPORT_STD template <class _Ty, class _Alloc, class _Pr>
 typename list<_Ty, _Alloc>::size_type erase_if(list<_Ty, _Alloc>& _Cont, _Pr _Pred) {
     return _Cont.remove_if(_Pass_fn(_Pred));
 }
@@ -1925,7 +1925,7 @@ typename list<_Ty, _Alloc>::size_type erase_if(list<_Ty, _Alloc>& _Cont, _Pr _Pr
 
 #if _HAS_CXX17
 namespace pmr {
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     using list = _STD list<_Ty, polymorphic_allocator<_Ty>>;
 } // namespace pmr
 #endif // _HAS_CXX17
diff --git a/stl/inc/locale b/stl/inc/locale
index d958a79794..bb80b9ed53 100644
--- a/stl/inc/locale
+++ b/stl/inc/locale
@@ -23,7 +23,7 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 class collate : public locale::facet { // facet for ordering sequences of elements
 public:
     static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
@@ -140,7 +140,7 @@ template __PURE_APPDOMAIN_GLOBAL locale::id collate<unsigned short>::id;
 #pragma clang diagnostic pop
 #endif // __clang__
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 class collate_byname : public collate<_Elem> { // collate for named locale
 public:
     static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
@@ -155,7 +155,7 @@ protected:
     __CLR_OR_THIS_CALL ~collate_byname() noexcept override {}
 };
 
-template <class _Facet>
+_EXPORT_STD template <class _Facet>
 _NODISCARD bool has_facet(const locale& _Loc) noexcept {
     _BEGIN_LOCK(_LOCK_LOCALE) // the thread lock, make get atomic
     size_t _Id = _Facet::id;
@@ -163,72 +163,72 @@ _NODISCARD bool has_facet(const locale& _Loc) noexcept {
     _END_LOCK()
 }
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 _NODISCARD bool isalnum(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::alnum, _Ch);
 }
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 _NODISCARD bool isalpha(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::alpha, _Ch);
 }
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 _NODISCARD bool isblank(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::blank, _Ch);
 }
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 _NODISCARD bool iscntrl(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::cntrl, _Ch);
 }
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 _NODISCARD bool isdigit(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::digit, _Ch);
 }
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 _NODISCARD bool isgraph(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::graph, _Ch);
 }
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 _NODISCARD bool islower(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::lower, _Ch);
 }
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 _NODISCARD bool isprint(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::print, _Ch);
 }
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 _NODISCARD bool ispunct(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::punct, _Ch);
 }
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 _NODISCARD bool isspace(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::space, _Ch);
 }
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 _NODISCARD bool isupper(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::upper, _Ch);
 }
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 _NODISCARD bool isxdigit(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::xdigit, _Ch);
 }
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 _NODISCARD _Elem tolower(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).tolower(_Ch);
 }
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 _NODISCARD _Elem toupper(_Elem _Ch, const locale& _Loc) {
     return _STD use_facet<ctype<_Elem>>(_Loc).toupper(_Ch);
 }
diff --git a/stl/inc/map b/stl/inc/map
index e2cbb000d5..63bbefdb82 100644
--- a/stl/inc/map
+++ b/stl/inc/map
@@ -69,7 +69,7 @@ public:
     }
 };
 
-template <class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty>>>
+_EXPORT_STD template <class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty>>>
 class map : public _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, false>> {
     // ordered red-black tree of {key, mapped} values, unique keys
 public:
@@ -395,7 +395,7 @@ map(from_range_t, _Rng&&, _Alloc)
 #endif // _HAS_CXX23 && defined(__cpp_lib_concepts)
 #endif // _HAS_CXX17
 
-template <class _Kty, class _Ty, class _Pr, class _Alloc>
+_EXPORT_STD template <class _Kty, class _Ty, class _Pr, class _Alloc>
 _NODISCARD bool operator==(const map<_Kty, _Ty, _Pr, _Alloc>& _Left, const map<_Kty, _Ty, _Pr, _Alloc>& _Right) {
     return _Left.size() == _Right.size()
         && _STD equal(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(), _Right._Unchecked_begin());
@@ -409,7 +409,7 @@ _NODISCARD bool operator!=(const map<_Kty, _Ty, _Pr, _Alloc>& _Left, const map<_
 #endif // !_HAS_CXX20
 
 #ifdef __cpp_lib_concepts
-template <class _Kty, class _Ty, class _Pr, class _Alloc>
+_EXPORT_STD template <class _Kty, class _Ty, class _Pr, class _Alloc>
 _NODISCARD _Synth_three_way_result<pair<const _Kty, _Ty>> operator<=>(
     const map<_Kty, _Ty, _Pr, _Alloc>& _Left, const map<_Kty, _Ty, _Pr, _Alloc>& _Right) {
     return _STD lexicographical_compare_three_way(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(),
@@ -438,20 +438,20 @@ _NODISCARD bool operator>=(const map<_Kty, _Ty, _Pr, _Alloc>& _Left, const map<_
 }
 #endif // ^^^ !defined(__cpp_lib_concepts) ^^^
 
-template <class _Kty, class _Ty, class _Pr, class _Alloc>
+_EXPORT_STD template <class _Kty, class _Ty, class _Pr, class _Alloc>
 void swap(map<_Kty, _Ty, _Pr, _Alloc>& _Left, map<_Kty, _Ty, _Pr, _Alloc>& _Right) noexcept(
     noexcept(_Left.swap(_Right))) {
     _Left.swap(_Right);
 }
 
 #if _HAS_CXX20
-template <class _Kty, class _Ty, class _Keylt, class _Alloc, class _Pr>
+_EXPORT_STD template <class _Kty, class _Ty, class _Keylt, class _Alloc, class _Pr>
 typename map<_Kty, _Ty, _Keylt, _Alloc>::size_type erase_if(map<_Kty, _Ty, _Keylt, _Alloc>& _Cont, _Pr _Pred) {
     return _Erase_nodes_if(_Cont, _Pass_fn(_Pred));
 }
 #endif // _HAS_CXX20
 
-template <class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty>>>
+_EXPORT_STD template <class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty>>>
 class multimap : public _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, true>> {
     // ordered red-black tree of {key, mapped} values, non-unique keys
 public:
@@ -626,7 +626,7 @@ multimap(from_range_t, _Rng&&, _Alloc)
 #endif // _HAS_CXX23 && defined(__cpp_lib_concepts)
 #endif // _HAS_CXX17
 
-template <class _Kty, class _Ty, class _Pr, class _Alloc>
+_EXPORT_STD template <class _Kty, class _Ty, class _Pr, class _Alloc>
 _NODISCARD bool operator==(
     const multimap<_Kty, _Ty, _Pr, _Alloc>& _Left, const multimap<_Kty, _Ty, _Pr, _Alloc>& _Right) {
     return _Left.size() == _Right.size()
@@ -642,7 +642,7 @@ _NODISCARD bool operator!=(
 #endif // !_HAS_CXX20
 
 #ifdef __cpp_lib_concepts
-template <class _Kty, class _Ty, class _Pr, class _Alloc>
+_EXPORT_STD template <class _Kty, class _Ty, class _Pr, class _Alloc>
 _NODISCARD _Synth_three_way_result<pair<const _Kty, _Ty>> operator<=>(
     const multimap<_Kty, _Ty, _Pr, _Alloc>& _Left, const multimap<_Kty, _Ty, _Pr, _Alloc>& _Right) {
     return _STD lexicographical_compare_three_way(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(),
@@ -675,14 +675,14 @@ _NODISCARD bool operator>=(
 }
 #endif // ^^^ !defined(__cpp_lib_concepts) ^^^
 
-template <class _Kty, class _Ty, class _Pr, class _Alloc>
+_EXPORT_STD template <class _Kty, class _Ty, class _Pr, class _Alloc>
 void swap(multimap<_Kty, _Ty, _Pr, _Alloc>& _Left, multimap<_Kty, _Ty, _Pr, _Alloc>& _Right) noexcept(
     noexcept(_Left.swap(_Right))) {
     _Left.swap(_Right);
 }
 
 #if _HAS_CXX20
-template <class _Kty, class _Ty, class _Keylt, class _Alloc, class _Pr>
+_EXPORT_STD template <class _Kty, class _Ty, class _Keylt, class _Alloc, class _Pr>
 typename multimap<_Kty, _Ty, _Keylt, _Alloc>::size_type erase_if(
     multimap<_Kty, _Ty, _Keylt, _Alloc>& _Cont, _Pr _Pred) {
     return _Erase_nodes_if(_Cont, _Pass_fn(_Pred));
@@ -691,10 +691,10 @@ typename multimap<_Kty, _Ty, _Keylt, _Alloc>::size_type erase_if(
 
 #if _HAS_CXX17
 namespace pmr {
-    template <class _Kty, class _Ty, class _Pr = less<_Kty>>
+    _EXPORT_STD template <class _Kty, class _Ty, class _Pr = less<_Kty>>
     using map = _STD map<_Kty, _Ty, _Pr, polymorphic_allocator<pair<const _Kty, _Ty>>>;
 
-    template <class _Kty, class _Ty, class _Pr = less<_Kty>>
+    _EXPORT_STD template <class _Kty, class _Ty, class _Pr = less<_Kty>>
     using multimap = _STD multimap<_Kty, _Ty, _Pr, polymorphic_allocator<pair<const _Kty, _Ty>>>;
 } // namespace pmr
 #endif // _HAS_CXX17
diff --git a/stl/inc/memory b/stl/inc/memory
index 787d0b6786..94ac50ab41 100644
--- a/stl/inc/memory
+++ b/stl/inc/memory
@@ -28,7 +28,7 @@ _STL_DISABLE_CLANG_WARNINGS
 _STD_BEGIN
 #ifdef __cpp_lib_concepts
 namespace ranges {
-    template <class _In, class _Out>
+    _EXPORT_STD template <class _In, class _Out>
     using uninitialized_copy_result = in_out_result<_In, _Out>;
 
     class _Uninitialized_copy_fn : private _Not_quite_object {
@@ -103,11 +103,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Uninitialized_copy_fn uninitialized_copy{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Uninitialized_copy_fn uninitialized_copy{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _InIt, class _Diff, class _NoThrowFwdIt>
+_EXPORT_STD template <class _InIt, class _Diff, class _NoThrowFwdIt>
 _NoThrowFwdIt uninitialized_copy_n(const _InIt _First, const _Diff _Count_raw, _NoThrowFwdIt _Dest) {
     // copy [_First, _First + _Count) to [_Dest, ...)
     _Algorithm_int_t<_Diff> _Count = _Count_raw;
@@ -135,7 +135,7 @@ _NoThrowFwdIt uninitialized_copy_n(const _InIt _First, const _Diff _Count_raw, _
 
 #ifdef __cpp_lib_concepts
 namespace ranges {
-    template <class _In, class _Out>
+    _EXPORT_STD template <class _In, class _Out>
     using uninitialized_copy_n_result = in_out_result<_In, _Out>;
 
     class _Uninitialized_copy_n_fn : private _Not_quite_object {
@@ -184,12 +184,12 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Uninitialized_copy_n_fn uninitialized_copy_n{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Uninitialized_copy_n_fn uninitialized_copy_n{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
 #if _HAS_CXX17
-template <class _InIt, class _NoThrowFwdIt>
+_EXPORT_STD template <class _InIt, class _NoThrowFwdIt>
 _NoThrowFwdIt uninitialized_move(const _InIt _First, const _InIt _Last, _NoThrowFwdIt _Dest) {
     // move [_First, _Last) to raw [_Dest, ...)
     _Adl_verify_range(_First, _Last);
@@ -238,11 +238,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Uninitialized_move_fn uninitialized_move{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Uninitialized_move_fn uninitialized_move{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _InIt, class _Diff, class _NoThrowFwdIt>
+_EXPORT_STD template <class _InIt, class _Diff, class _NoThrowFwdIt>
 pair<_InIt, _NoThrowFwdIt> uninitialized_move_n(_InIt _First, const _Diff _Count_raw, _NoThrowFwdIt _Dest) {
     // move [_First, _First + _Count) to [_Dest, ...)
     _Algorithm_int_t<_Diff> _Count = _Count_raw;
@@ -274,7 +274,7 @@ pair<_InIt, _NoThrowFwdIt> uninitialized_move_n(_InIt _First, const _Diff _Count
 
 #ifdef __cpp_lib_concepts
 namespace ranges {
-    template <class _In, class _Out>
+    _EXPORT_STD template <class _In, class _Out>
     using uninitialized_move_n_result = in_out_result<_In, _Out>;
 
     class _Uninitialized_move_n_fn : private _Not_quite_object {
@@ -323,7 +323,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Uninitialized_move_n_fn uninitialized_move_n{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Uninitialized_move_n_fn uninitialized_move_n{_Not_quite_object::_Construct_tag{}};
 
     class _Uninitialized_fill_fn : private _Not_quite_object {
     public:
@@ -381,11 +381,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Uninitialized_fill_fn uninitialized_fill{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Uninitialized_fill_fn uninitialized_fill{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _NoThrowFwdIt, class _Diff, class _Tval>
+_EXPORT_STD template <class _NoThrowFwdIt, class _Diff, class _Tval>
 _NoThrowFwdIt uninitialized_fill_n(_NoThrowFwdIt _First, const _Diff _Count_raw, const _Tval& _Val) {
     // copy _Count copies of _Val to raw _First
     _Algorithm_int_t<_Diff> _Count = _Count_raw;
@@ -459,7 +459,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Uninitialized_fill_n_fn uninitialized_fill_n{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Uninitialized_fill_n_fn uninitialized_fill_n{_Not_quite_object::_Construct_tag{}};
 
     class _Construct_at_fn : private _Not_quite_object {
     public:
@@ -479,7 +479,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Construct_at_fn construct_at{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Construct_at_fn construct_at{_Not_quite_object::_Construct_tag{}};
 
     // clang-format off
     template <_No_throw_input_iterator _It, _No_throw_sentinel_for<_It> _Se>
@@ -501,12 +501,12 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Destroy_at_fn destroy_at{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Destroy_at_fn destroy_at{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
 #if _HAS_CXX17
-template <class _NoThrowFwdIt>
+_EXPORT_STD template <class _NoThrowFwdIt>
 _CONSTEXPR20 void destroy(const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last) {
     // destroy all elements in [_First, _Last)
     _Adl_verify_range(_First, _Last);
@@ -558,11 +558,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Destroy_fn destroy{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Destroy_fn destroy{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _NoThrowFwdIt, class _Diff>
+_EXPORT_STD template <class _NoThrowFwdIt, class _Diff>
 _CONSTEXPR20 _NoThrowFwdIt destroy_n(_NoThrowFwdIt _First, const _Diff _Count_raw) {
     // destroy all elements in [_First, _First + _Count)
     _Algorithm_int_t<_Diff> _Count = _Count_raw;
@@ -615,11 +615,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Destroy_n_fn destroy_n{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Destroy_n_fn destroy_n{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _NoThrowFwdIt>
+_EXPORT_STD template <class _NoThrowFwdIt>
 void uninitialized_default_construct(const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last) {
     // default-initialize all elements in [_First, _Last)
     using _Ty = remove_reference_t<_Iter_ref_t<_NoThrowFwdIt>>;
@@ -687,12 +687,12 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Uninitialized_default_construct_fn uninitialized_default_construct{
+    _EXPORT_STD inline constexpr _Uninitialized_default_construct_fn uninitialized_default_construct{
         _Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _NoThrowFwdIt, class _Diff>
+_EXPORT_STD template <class _NoThrowFwdIt, class _Diff>
 _NoThrowFwdIt uninitialized_default_construct_n(_NoThrowFwdIt _First, const _Diff _Count_raw) {
     // default-initialize all elements in [_First, _First + _Count_raw)
     using _Ty                      = _Iter_value_t<_NoThrowFwdIt>;
@@ -746,12 +746,12 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Uninitialized_default_construct_n_fn uninitialized_default_construct_n{
+    _EXPORT_STD inline constexpr _Uninitialized_default_construct_n_fn uninitialized_default_construct_n{
         _Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _NoThrowFwdIt>
+_EXPORT_STD template <class _NoThrowFwdIt>
 void uninitialized_value_construct(const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last) {
     // value-initialize all elements in [_First, _Last)
     _Adl_verify_range(_First, _Last);
@@ -820,12 +820,12 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Uninitialized_value_construct_fn uninitialized_value_construct{
+    _EXPORT_STD inline constexpr _Uninitialized_value_construct_fn uninitialized_value_construct{
         _Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _NoThrowFwdIt, class _Diff>
+_EXPORT_STD template <class _NoThrowFwdIt, class _Diff>
 _NoThrowFwdIt uninitialized_value_construct_n(_NoThrowFwdIt _First, const _Diff _Count_raw) {
     // value-initialize all elements in [_First, _First + _Count_raw)
     _Algorithm_int_t<_Diff> _Count = _Count_raw;
@@ -868,7 +868,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Uninitialized_value_construct_n_fn uninitialized_value_construct_n{
+    _EXPORT_STD inline constexpr _Uninitialized_value_construct_n_fn uninitialized_value_construct_n{
         _Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
@@ -876,7 +876,7 @@ namespace ranges {
 
 
 #if _HAS_DEPRECATED_RAW_STORAGE_ITERATOR
-template <class _OutIt, class _Ty>
+_EXPORT_STD template <class _OutIt, class _Ty>
 class _CXX17_DEPRECATE_RAW_STORAGE_ITERATOR raw_storage_iterator { // wrap stores to raw buffer as output iterator
 public:
     using iterator_category = output_iterator_tag;
@@ -927,17 +927,17 @@ private:
 
 
 #if _HAS_AUTO_PTR_ETC
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class auto_ptr;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct auto_ptr_ref { // proxy reference for auto_ptr copying
     explicit auto_ptr_ref(_Ty* _Right) : _Ref(_Right) {}
 
     _Ty* _Ref; // generic pointer to auto_ptr ptr
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class auto_ptr { // wrap an object pointer to ensure destruction
 public:
     using element_type = _Ty;
@@ -1036,7 +1036,7 @@ public:
 #endif // _HAS_AUTO_PTR_ETC
 
 
-class bad_weak_ptr : public exception { // exception type for invalid use of expired weak_ptr object
+_EXPORT_STD class bad_weak_ptr : public exception { // exception type for invalid use of expired weak_ptr object
 public:
     bad_weak_ptr() noexcept {}
 
@@ -1222,16 +1222,16 @@ private:
     _Compressed_pair<_Dx, _Compressed_pair<_Myalty, _Resource>> _Mypair;
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct default_delete;
 
-template <class _Ty, class _Dx = default_delete<_Ty>>
+_EXPORT_STD template <class _Ty, class _Dx = default_delete<_Ty>>
 class unique_ptr;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class shared_ptr;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class weak_ptr;
 
 template <class _Yty, class = void>
@@ -1490,7 +1490,7 @@ struct _Temporary_owner_del {
     }
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class shared_ptr : public _Ptr_base<_Ty> { // class for reference counted resource management
 private:
     using _Mybase = _Ptr_base<_Ty>;
@@ -1807,13 +1807,13 @@ template <class _Ty, class _Dx>
 shared_ptr(unique_ptr<_Ty, _Dx>) -> shared_ptr<_Ty>;
 #endif // _HAS_CXX17
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD bool operator==(const shared_ptr<_Ty1>& _Left, const shared_ptr<_Ty2>& _Right) noexcept {
     return _Left.get() == _Right.get();
 }
 
 #if _HAS_CXX20
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD strong_ordering operator<=>(const shared_ptr<_Ty1>& _Left, const shared_ptr<_Ty2>& _Right) noexcept {
     return _Left.get() <=> _Right.get();
 }
@@ -1844,13 +1844,13 @@ _NODISCARD bool operator<=(const shared_ptr<_Ty1>& _Left, const shared_ptr<_Ty2>
 }
 #endif // ^^^ !_HAS_CXX20 ^^^
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD bool operator==(const shared_ptr<_Ty>& _Left, nullptr_t) noexcept {
     return _Left.get() == nullptr;
 }
 
 #if _HAS_CXX20
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD strong_ordering operator<=>(const shared_ptr<_Ty>& _Left, nullptr_t) noexcept {
     return _Left.get() <=> static_cast<typename shared_ptr<_Ty>::element_type*>(nullptr);
 }
@@ -1911,53 +1911,53 @@ _NODISCARD bool operator<=(nullptr_t, const shared_ptr<_Ty>& _Right) noexcept {
 }
 #endif // ^^^ !_HAS_CXX20 ^^^
 
-template <class _Elem, class _Traits, class _Ty>
+_EXPORT_STD template <class _Elem, class _Traits, class _Ty>
 basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Out, const shared_ptr<_Ty>& _Px) {
     // write contained pointer to stream
     return _Out << _Px.get();
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 void swap(shared_ptr<_Ty>& _Left, shared_ptr<_Ty>& _Right) noexcept {
     _Left.swap(_Right);
 }
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD shared_ptr<_Ty1> static_pointer_cast(const shared_ptr<_Ty2>& _Other) noexcept {
     // static_cast for shared_ptr that properly respects the reference count control block
     const auto _Ptr = static_cast<typename shared_ptr<_Ty1>::element_type*>(_Other.get());
     return shared_ptr<_Ty1>(_Other, _Ptr);
 }
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD shared_ptr<_Ty1> static_pointer_cast(shared_ptr<_Ty2>&& _Other) noexcept {
     // static_cast for shared_ptr that properly respects the reference count control block
     const auto _Ptr = static_cast<typename shared_ptr<_Ty1>::element_type*>(_Other.get());
     return shared_ptr<_Ty1>(_STD move(_Other), _Ptr);
 }
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD shared_ptr<_Ty1> const_pointer_cast(const shared_ptr<_Ty2>& _Other) noexcept {
     // const_cast for shared_ptr that properly respects the reference count control block
     const auto _Ptr = const_cast<typename shared_ptr<_Ty1>::element_type*>(_Other.get());
     return shared_ptr<_Ty1>(_Other, _Ptr);
 }
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD shared_ptr<_Ty1> const_pointer_cast(shared_ptr<_Ty2>&& _Other) noexcept {
     // const_cast for shared_ptr that properly respects the reference count control block
     const auto _Ptr = const_cast<typename shared_ptr<_Ty1>::element_type*>(_Other.get());
     return shared_ptr<_Ty1>(_STD move(_Other), _Ptr);
 }
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD shared_ptr<_Ty1> reinterpret_pointer_cast(const shared_ptr<_Ty2>& _Other) noexcept {
     // reinterpret_cast for shared_ptr that properly respects the reference count control block
     const auto _Ptr = reinterpret_cast<typename shared_ptr<_Ty1>::element_type*>(_Other.get());
     return shared_ptr<_Ty1>(_Other, _Ptr);
 }
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD shared_ptr<_Ty1> reinterpret_pointer_cast(shared_ptr<_Ty2>&& _Other) noexcept {
     // reinterpret_cast for shared_ptr that properly respects the reference count control block
     const auto _Ptr = reinterpret_cast<typename shared_ptr<_Ty1>::element_type*>(_Other.get());
@@ -1965,7 +1965,7 @@ _NODISCARD shared_ptr<_Ty1> reinterpret_pointer_cast(shared_ptr<_Ty2>&& _Other)
 }
 
 #ifdef _CPPRTTI
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD shared_ptr<_Ty1> dynamic_pointer_cast(const shared_ptr<_Ty2>& _Other) noexcept {
     // dynamic_cast for shared_ptr that properly respects the reference count control block
     const auto _Ptr = dynamic_cast<typename shared_ptr<_Ty1>::element_type*>(_Other.get());
@@ -1977,7 +1977,7 @@ _NODISCARD shared_ptr<_Ty1> dynamic_pointer_cast(const shared_ptr<_Ty2>& _Other)
     return {};
 }
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD shared_ptr<_Ty1> dynamic_pointer_cast(shared_ptr<_Ty2>&& _Other) noexcept {
     // dynamic_cast for shared_ptr that properly respects the reference count control block
     const auto _Ptr = dynamic_cast<typename shared_ptr<_Ty1>::element_type*>(_Other.get());
@@ -1989,14 +1989,14 @@ _NODISCARD shared_ptr<_Ty1> dynamic_pointer_cast(shared_ptr<_Ty2>&& _Other) noex
     return {};
 }
 #else // _CPPRTTI
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 shared_ptr<_Ty1> dynamic_pointer_cast(const shared_ptr<_Ty2>&) noexcept = delete; // requires /GR option
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 shared_ptr<_Ty1> dynamic_pointer_cast(shared_ptr<_Ty2>&&) noexcept = delete; // requires /GR option
 #endif // _CPPRTTI
 
 #if _HAS_STATIC_RTTI
-template <class _Dx, class _Ty>
+_EXPORT_STD template <class _Dx, class _Ty>
 _NODISCARD _Dx* get_deleter(const shared_ptr<_Ty>& _Sx) noexcept {
     // return pointer to shared_ptr's deleter object if its type is _Dx
     if (_Sx._Rep) {
@@ -2006,7 +2006,7 @@ _NODISCARD _Dx* get_deleter(const shared_ptr<_Ty>& _Sx) noexcept {
     return nullptr;
 }
 #else // _HAS_STATIC_RTTI
-template <class _Dx, class _Ty>
+_EXPORT_STD template <class _Dx, class _Ty>
 _Dx* get_deleter(const shared_ptr<_Ty>&) noexcept = delete; // requires static RTTI
 #endif // _HAS_STATIC_RTTI
 
@@ -2693,7 +2693,7 @@ private:
 };
 #endif // _HAS_CXX20
 
-template <class _Ty, class... _Types>
+_EXPORT_STD template <class _Ty, class... _Types>
 _NODISCARD_SMART_PTR_ALLOC
 #if _HAS_CXX20
     enable_if_t<!is_array_v<_Ty>, shared_ptr<_Ty>>
@@ -2722,7 +2722,7 @@ struct _NODISCARD _Global_delete_guard {
     }
 };
 
-template <class _Ty, class... _ArgTypes>
+_EXPORT_STD /* TRANSITION, VSO-1538698 */ template <class _Ty, class... _ArgTypes>
 _NODISCARD shared_ptr<_Ty> _Make_shared_unbounded_array(const size_t _Count, const _ArgTypes&... _Args) {
     // make a shared_ptr to an unbounded array
     static_assert(is_unbounded_array_v<_Ty>);
@@ -2736,18 +2736,18 @@ _NODISCARD shared_ptr<_Ty> _Make_shared_unbounded_array(const size_t _Count, con
     return _Ret;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD_SMART_PTR_ALLOC enable_if_t<is_unbounded_array_v<_Ty>, shared_ptr<_Ty>> make_shared(const size_t _Count) {
     return _Make_shared_unbounded_array<_Ty>(_Count);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD_SMART_PTR_ALLOC enable_if_t<is_unbounded_array_v<_Ty>, shared_ptr<_Ty>> make_shared(
     const size_t _Count, const remove_extent_t<_Ty>& _Val) {
     return _Make_shared_unbounded_array<_Ty>(_Count, _Val);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD_SMART_PTR_ALLOC enable_if_t<is_bounded_array_v<_Ty>, shared_ptr<_Ty>> make_shared() {
     // make a shared_ptr to a bounded array
     const auto _Rx = new _Ref_count_bounded_array<_Ty>();
@@ -2756,7 +2756,7 @@ _NODISCARD_SMART_PTR_ALLOC enable_if_t<is_bounded_array_v<_Ty>, shared_ptr<_Ty>>
     return _Ret;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD_SMART_PTR_ALLOC enable_if_t<is_bounded_array_v<_Ty>, shared_ptr<_Ty>> make_shared(
     const remove_extent_t<_Ty>& _Val) {
     // make a shared_ptr to a bounded array
@@ -2766,7 +2766,7 @@ _NODISCARD_SMART_PTR_ALLOC enable_if_t<is_bounded_array_v<_Ty>, shared_ptr<_Ty>>
     return _Ret;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD_SMART_PTR_ALLOC enable_if_t<!is_unbounded_array_v<_Ty>, shared_ptr<_Ty>> make_shared_for_overwrite() {
     shared_ptr<_Ty> _Ret;
     if constexpr (is_array_v<_Ty>) {
@@ -2781,14 +2781,14 @@ _NODISCARD_SMART_PTR_ALLOC enable_if_t<!is_unbounded_array_v<_Ty>, shared_ptr<_T
     return _Ret;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD_SMART_PTR_ALLOC enable_if_t<is_unbounded_array_v<_Ty>, shared_ptr<_Ty>> make_shared_for_overwrite(
     const size_t _Count) {
     return _Make_shared_unbounded_array<_Ty>(_Count, _For_overwrite_tag{});
 }
 #endif // _HAS_CXX20
 
-template <class _Ty, class _Alloc, class... _Types>
+_EXPORT_STD template <class _Ty, class _Alloc, class... _Types>
 _NODISCARD_SMART_PTR_ALLOC
 #if _HAS_CXX20
     enable_if_t<!is_array_v<_Ty>, shared_ptr<_Ty>>
@@ -2829,7 +2829,7 @@ struct _Allocate_n_ptr {
     _Allocate_n_ptr& operator=(const _Allocate_n_ptr&) = delete;
 };
 
-template <class _Ty, class _Alloc, class... _ArgTypes>
+_EXPORT_STD /* TRANSITION, VSO-1538698 */ template <class _Ty, class _Alloc, class... _ArgTypes>
 _NODISCARD shared_ptr<_Ty> _Allocate_shared_unbounded_array(
     const _Alloc& _Al, const size_t _Count, const _ArgTypes&... _Args) {
     // make a shared_ptr to an unbounded array
@@ -2849,19 +2849,19 @@ _NODISCARD shared_ptr<_Ty> _Allocate_shared_unbounded_array(
     return _Ret;
 }
 
-template <class _Ty, class _Alloc>
+_EXPORT_STD template <class _Ty, class _Alloc>
 _NODISCARD_SMART_PTR_ALLOC enable_if_t<is_unbounded_array_v<_Ty>, shared_ptr<_Ty>> allocate_shared(
     const _Alloc& _Al, const size_t _Count) {
     return _Allocate_shared_unbounded_array<_Ty>(_Al, _Count);
 }
 
-template <class _Ty, class _Alloc>
+_EXPORT_STD template <class _Ty, class _Alloc>
 _NODISCARD_SMART_PTR_ALLOC enable_if_t<is_unbounded_array_v<_Ty>, shared_ptr<_Ty>> allocate_shared(
     const _Alloc& _Al, const size_t _Count, const remove_extent_t<_Ty>& _Val) {
     return _Allocate_shared_unbounded_array<_Ty>(_Al, _Count, _Val);
 }
 
-template <class _Ty, class _Alloc>
+_EXPORT_STD template <class _Ty, class _Alloc>
 _NODISCARD_SMART_PTR_ALLOC enable_if_t<is_bounded_array_v<_Ty>, shared_ptr<_Ty>> allocate_shared(const _Alloc& _Al) {
     // make a shared_ptr to a bounded array
     using _Refc    = _Ref_count_bounded_array_alloc<remove_cv_t<_Ty>, _Alloc>;
@@ -2876,7 +2876,7 @@ _NODISCARD_SMART_PTR_ALLOC enable_if_t<is_bounded_array_v<_Ty>, shared_ptr<_Ty>>
     return _Ret;
 }
 
-template <class _Ty, class _Alloc>
+_EXPORT_STD template <class _Ty, class _Alloc>
 _NODISCARD_SMART_PTR_ALLOC enable_if_t<is_bounded_array_v<_Ty>, shared_ptr<_Ty>> allocate_shared(
     const _Alloc& _Al, const remove_extent_t<_Ty>& _Val) {
     // make a shared_ptr to a bounded array
@@ -2892,7 +2892,7 @@ _NODISCARD_SMART_PTR_ALLOC enable_if_t<is_bounded_array_v<_Ty>, shared_ptr<_Ty>>
     return _Ret;
 }
 
-template <class _Ty, class _Alloc>
+_EXPORT_STD template <class _Ty, class _Alloc>
 _NODISCARD_SMART_PTR_ALLOC enable_if_t<!is_unbounded_array_v<_Ty>, shared_ptr<_Ty>> allocate_shared_for_overwrite(
     const _Alloc& _Al) {
     shared_ptr<_Ty> _Ret;
@@ -2921,14 +2921,14 @@ _NODISCARD_SMART_PTR_ALLOC enable_if_t<!is_unbounded_array_v<_Ty>, shared_ptr<_T
     return _Ret;
 }
 
-template <class _Ty, class _Alloc>
+_EXPORT_STD template <class _Ty, class _Alloc>
 _NODISCARD_SMART_PTR_ALLOC enable_if_t<is_unbounded_array_v<_Ty>, shared_ptr<_Ty>> allocate_shared_for_overwrite(
     const _Alloc& _Al, const size_t _Count) {
     return _Allocate_shared_unbounded_array<_Ty>(_Al, _Count, _For_overwrite_tag{});
 }
 #endif // _HAS_CXX20
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class weak_ptr : public _Ptr_base<_Ty> { // class for pointer to reference counted resource
 public:
 #ifndef _M_CEE_PURE
@@ -3047,12 +3047,12 @@ template <class _Ty>
 weak_ptr(shared_ptr<_Ty>) -> weak_ptr<_Ty>;
 #endif // _HAS_CXX17
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 void swap(weak_ptr<_Ty>& _Left, weak_ptr<_Ty>& _Right) noexcept {
     _Left.swap(_Right);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class enable_shared_from_this { // provide member functions that create shared_ptr to this
 public:
     using _Esft_type = enable_shared_from_this;
@@ -3094,7 +3094,7 @@ private:
 };
 
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct default_delete { // default deleter for unique_ptr
     constexpr default_delete() noexcept = default;
 
@@ -3135,7 +3135,7 @@ template <class _Dx2>
 using _Unique_ptr_enable_default_t =
     enable_if_t<conjunction_v<negation<is_pointer<_Dx2>>, is_default_constructible<_Dx2>>, int>;
 
-template <class _Ty, class _Dx /* = default_delete<_Ty> */>
+_EXPORT_STD template <class _Ty, class _Dx /* = default_delete<_Ty> */>
 class unique_ptr { // non-copyable pointer to an object
 public:
     using pointer      = typename _Get_deleter_pointer_type<_Ty, remove_reference_t<_Dx>>::type;
@@ -3428,44 +3428,44 @@ private:
 };
 
 
-template <class _Ty, class... _Types, enable_if_t<!is_array_v<_Ty>, int> = 0>
+_EXPORT_STD template <class _Ty, class... _Types, enable_if_t<!is_array_v<_Ty>, int> = 0>
 _NODISCARD_SMART_PTR_ALLOC _CONSTEXPR23 unique_ptr<_Ty> make_unique(_Types&&... _Args) { // make a unique_ptr
     return unique_ptr<_Ty>(new _Ty(_STD forward<_Types>(_Args)...));
 }
 
-template <class _Ty, enable_if_t<is_array_v<_Ty> && extent_v<_Ty> == 0, int> = 0>
+_EXPORT_STD template <class _Ty, enable_if_t<is_array_v<_Ty> && extent_v<_Ty> == 0, int> = 0>
 _NODISCARD_SMART_PTR_ALLOC _CONSTEXPR23 unique_ptr<_Ty> make_unique(const size_t _Size) { // make a unique_ptr
     using _Elem = remove_extent_t<_Ty>;
     return unique_ptr<_Ty>(new _Elem[_Size]());
 }
 
-template <class _Ty, class... _Types, enable_if_t<extent_v<_Ty> != 0, int> = 0>
+_EXPORT_STD template <class _Ty, class... _Types, enable_if_t<extent_v<_Ty> != 0, int> = 0>
 void make_unique(_Types&&...) = delete;
 
 #if _HAS_CXX20
-template <class _Ty, enable_if_t<!is_array_v<_Ty>, int> = 0>
+_EXPORT_STD template <class _Ty, enable_if_t<!is_array_v<_Ty>, int> = 0>
 _NODISCARD_SMART_PTR_ALLOC _CONSTEXPR23 unique_ptr<_Ty> make_unique_for_overwrite() {
     // make a unique_ptr with default initialization
     return unique_ptr<_Ty>(new _Ty);
 }
 
-template <class _Ty, enable_if_t<is_unbounded_array_v<_Ty>, int> = 0>
+_EXPORT_STD template <class _Ty, enable_if_t<is_unbounded_array_v<_Ty>, int> = 0>
 _NODISCARD_SMART_PTR_ALLOC _CONSTEXPR23 unique_ptr<_Ty> make_unique_for_overwrite(const size_t _Size) {
     // make a unique_ptr with default initialization
     using _Elem = remove_extent_t<_Ty>;
     return unique_ptr<_Ty>(new _Elem[_Size]);
 }
 
-template <class _Ty, class... _Types, enable_if_t<is_bounded_array_v<_Ty>, int> = 0>
+_EXPORT_STD template <class _Ty, class... _Types, enable_if_t<is_bounded_array_v<_Ty>, int> = 0>
 void make_unique_for_overwrite(_Types&&...) = delete;
 #endif // _HAS_CXX20
 
-template <class _Ty, class _Dx, enable_if_t<_Is_swappable<_Dx>::value, int> = 0>
+_EXPORT_STD template <class _Ty, class _Dx, enable_if_t<_Is_swappable<_Dx>::value, int> = 0>
 _CONSTEXPR23 void swap(unique_ptr<_Ty, _Dx>& _Left, unique_ptr<_Ty, _Dx>& _Right) noexcept {
     _Left.swap(_Right);
 }
 
-template <class _Ty1, class _Dx1, class _Ty2, class _Dx2>
+_EXPORT_STD template <class _Ty1, class _Dx1, class _Ty2, class _Dx2>
 _NODISCARD _CONSTEXPR23 bool operator==(const unique_ptr<_Ty1, _Dx1>& _Left, const unique_ptr<_Ty2, _Dx2>& _Right) {
     return _Left.get() == _Right.get();
 }
@@ -3477,7 +3477,7 @@ _NODISCARD bool operator!=(const unique_ptr<_Ty1, _Dx1>& _Left, const unique_ptr
 }
 #endif // !_HAS_CXX20
 
-template <class _Ty1, class _Dx1, class _Ty2, class _Dx2>
+_EXPORT_STD template <class _Ty1, class _Dx1, class _Ty2, class _Dx2>
 _NODISCARD bool operator<(const unique_ptr<_Ty1, _Dx1>& _Left, const unique_ptr<_Ty2, _Dx2>& _Right) {
     using _Ptr1   = typename unique_ptr<_Ty1, _Dx1>::pointer;
     using _Ptr2   = typename unique_ptr<_Ty2, _Dx2>::pointer;
@@ -3485,24 +3485,24 @@ _NODISCARD bool operator<(const unique_ptr<_Ty1, _Dx1>& _Left, const unique_ptr<
     return less<_Common>{}(_Left.get(), _Right.get());
 }
 
-template <class _Ty1, class _Dx1, class _Ty2, class _Dx2>
+_EXPORT_STD template <class _Ty1, class _Dx1, class _Ty2, class _Dx2>
 _NODISCARD bool operator>=(const unique_ptr<_Ty1, _Dx1>& _Left, const unique_ptr<_Ty2, _Dx2>& _Right) {
     return !(_Left < _Right);
 }
 
-template <class _Ty1, class _Dx1, class _Ty2, class _Dx2>
+_EXPORT_STD template <class _Ty1, class _Dx1, class _Ty2, class _Dx2>
 _NODISCARD bool operator>(const unique_ptr<_Ty1, _Dx1>& _Left, const unique_ptr<_Ty2, _Dx2>& _Right) {
     return _Right < _Left;
 }
 
-template <class _Ty1, class _Dx1, class _Ty2, class _Dx2>
+_EXPORT_STD template <class _Ty1, class _Dx1, class _Ty2, class _Dx2>
 _NODISCARD bool operator<=(const unique_ptr<_Ty1, _Dx1>& _Left, const unique_ptr<_Ty2, _Dx2>& _Right) {
     return !(_Right < _Left);
 }
 
 #ifdef __cpp_lib_concepts
 // clang-format off
-template <class _Ty1, class _Dx1, class _Ty2, class _Dx2>
+_EXPORT_STD template <class _Ty1, class _Dx1, class _Ty2, class _Dx2>
     requires three_way_comparable_with<typename unique_ptr<_Ty1, _Dx1>::pointer,
         typename unique_ptr<_Ty2, _Dx2>::pointer>
 _NODISCARD compare_three_way_result_t<typename unique_ptr<_Ty1, _Dx1>::pointer,
@@ -3513,7 +3513,7 @@ _NODISCARD compare_three_way_result_t<typename unique_ptr<_Ty1, _Dx1>::pointer,
 }
 #endif // __cpp_lib_concepts
 
-template <class _Ty, class _Dx>
+_EXPORT_STD template <class _Ty, class _Dx>
 _NODISCARD _CONSTEXPR23 bool operator==(const unique_ptr<_Ty, _Dx>& _Left, nullptr_t) noexcept {
     return !_Left;
 }
@@ -3535,51 +3535,51 @@ _NODISCARD bool operator!=(nullptr_t _Left, const unique_ptr<_Ty, _Dx>& _Right)
 }
 #endif // !_HAS_CXX20
 
-template <class _Ty, class _Dx>
+_EXPORT_STD template <class _Ty, class _Dx>
 _NODISCARD _CONSTEXPR23 bool operator<(const unique_ptr<_Ty, _Dx>& _Left, nullptr_t _Right) {
     using _Ptr = typename unique_ptr<_Ty, _Dx>::pointer;
     return less<_Ptr>{}(_Left.get(), _Right);
 }
 
-template <class _Ty, class _Dx>
+_EXPORT_STD template <class _Ty, class _Dx>
 _NODISCARD _CONSTEXPR23 bool operator<(nullptr_t _Left, const unique_ptr<_Ty, _Dx>& _Right) {
     using _Ptr = typename unique_ptr<_Ty, _Dx>::pointer;
     return less<_Ptr>{}(_Left, _Right.get());
 }
 
-template <class _Ty, class _Dx>
+_EXPORT_STD template <class _Ty, class _Dx>
 _NODISCARD _CONSTEXPR23 bool operator>=(const unique_ptr<_Ty, _Dx>& _Left, nullptr_t _Right) {
     return !(_Left < _Right);
 }
 
-template <class _Ty, class _Dx>
+_EXPORT_STD template <class _Ty, class _Dx>
 _NODISCARD _CONSTEXPR23 bool operator>=(nullptr_t _Left, const unique_ptr<_Ty, _Dx>& _Right) {
     return !(_Left < _Right);
 }
 
-template <class _Ty, class _Dx>
+_EXPORT_STD template <class _Ty, class _Dx>
 _NODISCARD _CONSTEXPR23 bool operator>(const unique_ptr<_Ty, _Dx>& _Left, nullptr_t _Right) {
     return _Right < _Left;
 }
 
-template <class _Ty, class _Dx>
+_EXPORT_STD template <class _Ty, class _Dx>
 _NODISCARD _CONSTEXPR23 bool operator>(nullptr_t _Left, const unique_ptr<_Ty, _Dx>& _Right) {
     return _Right < _Left;
 }
 
-template <class _Ty, class _Dx>
+_EXPORT_STD template <class _Ty, class _Dx>
 _NODISCARD _CONSTEXPR23 bool operator<=(const unique_ptr<_Ty, _Dx>& _Left, nullptr_t _Right) {
     return !(_Right < _Left);
 }
 
-template <class _Ty, class _Dx>
+_EXPORT_STD template <class _Ty, class _Dx>
 _NODISCARD _CONSTEXPR23 bool operator<=(nullptr_t _Left, const unique_ptr<_Ty, _Dx>& _Right) {
     return !(_Right < _Left);
 }
 
 #ifdef __cpp_lib_concepts
 // clang-format off
-template <class _Ty, class _Dx>
+_EXPORT_STD template <class _Ty, class _Dx>
     requires three_way_comparable<typename unique_ptr<_Ty, _Dx>::pointer>
 _NODISCARD _CONSTEXPR23 compare_three_way_result_t<typename unique_ptr<_Ty, _Dx>::pointer> operator<=>(
     const unique_ptr<_Ty, _Dx>& _Left, nullptr_t) {
@@ -3594,7 +3594,7 @@ template <class _OutTy, class _PxTy>
 struct _Can_stream_unique_ptr<_OutTy, _PxTy, void_t<decltype(_STD declval<_OutTy>() << _STD declval<_PxTy>().get())>>
     : true_type {};
 
-template <class _Elem, class _Traits, class _Yty, class _Dx,
+_EXPORT_STD template <class _Elem, class _Traits, class _Yty, class _Dx,
     enable_if_t<_Can_stream_unique_ptr<basic_ostream<_Elem, _Traits>&, const unique_ptr<_Yty, _Dx>&>::value, int> = 0>
 basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Out, const unique_ptr<_Yty, _Dx>& _Px) {
     // write contained pointer to stream
@@ -3603,25 +3603,25 @@ basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Out, c
 }
 
 #if _HAS_GARBAGE_COLLECTION_SUPPORT_DELETED_IN_CXX23
-enum class pointer_safety { relaxed, preferred, strict };
+_EXPORT_STD enum class pointer_safety { relaxed, preferred, strict };
 
-inline void declare_reachable(void*) {}
+_EXPORT_STD inline void declare_reachable(void*) {}
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _Ty* undeclare_reachable(_Ty* _Ptr) {
     return _Ptr;
 }
 
-inline void declare_no_pointers(char*, size_t) {}
+_EXPORT_STD inline void declare_no_pointers(char*, size_t) {}
 
-inline void undeclare_no_pointers(char*, size_t) {}
+_EXPORT_STD inline void undeclare_no_pointers(char*, size_t) {}
 
-inline pointer_safety get_pointer_safety() noexcept {
+_EXPORT_STD inline pointer_safety get_pointer_safety() noexcept {
     return pointer_safety::relaxed;
 }
 #endif // _HAS_GARBAGE_COLLECTION_SUPPORT_DELETED_IN_CXX23
 
-template <class _Ty = void>
+_EXPORT_STD template <class _Ty = void>
 struct owner_less; // not defined
 
 template <class _Ty>
@@ -3707,7 +3707,7 @@ struct hash<shared_ptr<_Ty>> {
 };
 
 #if _HAS_CXX20
-template <size_t _Nx, class _Ty>
+_EXPORT_STD template <size_t _Nx, class _Ty>
 _NODISCARD_ASSUME_ALIGNED constexpr _Ty* assume_aligned(_Ty* const _Ptr) noexcept /* strengthened */ {
     if (_STD is_constant_evaluated()) {
         return _Ptr;
@@ -3733,13 +3733,13 @@ struct _Shared_ptr_spin_lock { // class to manage a spin lock for shared_ptr ato
     }
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT _NODISCARD bool atomic_is_lock_free(const shared_ptr<_Ty>*) {
     // return true if atomic operations on shared_ptr<_Ty> are lock-free
     return false;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT _NODISCARD shared_ptr<_Ty> atomic_load_explicit(
     const shared_ptr<_Ty>* _Ptr, memory_order) {
     // load *_Ptr atomically
@@ -3748,13 +3748,13 @@ _CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT _NODISCARD shared_ptr<_Ty> atomic
     return _Result;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT _NODISCARD shared_ptr<_Ty> atomic_load(
     const shared_ptr<_Ty>* _Ptr) { // load *_Ptr atomically
     return _STD atomic_load_explicit(_Ptr, memory_order_seq_cst);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT void atomic_store_explicit(
     shared_ptr<_Ty>* _Ptr, shared_ptr<_Ty> _Other, memory_order) {
     // store _Other to *_Ptr atomically
@@ -3762,13 +3762,13 @@ _CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT void atomic_store_explicit(
     _Ptr->swap(_Other);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT void atomic_store(
     shared_ptr<_Ty>* _Ptr, shared_ptr<_Ty> _Other) { // store _Other to *_Ptr atomically
     _STD atomic_store_explicit(_Ptr, _STD move(_Other), memory_order_seq_cst);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT shared_ptr<_Ty> atomic_exchange_explicit(
     shared_ptr<_Ty>* _Ptr, shared_ptr<_Ty> _Other, memory_order) {
     // copy _Other to *_Ptr and return previous value of *_Ptr atomically
@@ -3777,14 +3777,14 @@ _CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT shared_ptr<_Ty> atomic_exchange_e
     return _Other;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT shared_ptr<_Ty> atomic_exchange(
     shared_ptr<_Ty>* _Ptr, shared_ptr<_Ty> _Other) {
     // copy _Other to *_Ptr and return previous value of *_Ptr atomically
     return _STD atomic_exchange_explicit(_Ptr, _STD move(_Other), memory_order_seq_cst);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT bool atomic_compare_exchange_weak_explicit(shared_ptr<_Ty>* _Ptr,
     shared_ptr<_Ty>* _Exp, shared_ptr<_Ty> _Value, memory_order, memory_order) { // atomically compare and exchange
     shared_ptr<_Ty> _Old_exp; // destroyed outside spin lock
@@ -3799,7 +3799,7 @@ _CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT bool atomic_compare_exchange_weak
     return _Success;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT bool atomic_compare_exchange_weak(
     shared_ptr<_Ty>* _Ptr, shared_ptr<_Ty>* _Exp, shared_ptr<_Ty> _Value) {
     // atomically compare and exchange
@@ -3807,14 +3807,14 @@ _CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT bool atomic_compare_exchange_weak
         _Ptr, _Exp, _STD move(_Value), memory_order_seq_cst, memory_order_seq_cst);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT bool atomic_compare_exchange_strong_explicit(shared_ptr<_Ty>* _Ptr,
     shared_ptr<_Ty>* _Exp, shared_ptr<_Ty> _Value, memory_order, memory_order) { // atomically compare and exchange
     return _STD atomic_compare_exchange_weak_explicit(
         _Ptr, _Exp, _STD move(_Value), memory_order_seq_cst, memory_order_seq_cst);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT bool atomic_compare_exchange_strong(
     shared_ptr<_Ty>* _Ptr, shared_ptr<_Ty>* _Exp, shared_ptr<_Ty> _Value) {
     // atomically compare and exchange
@@ -4142,7 +4142,7 @@ concept _Resettable_pointer = requires(_SmartPtr& _Smart_ptr, _Pointer _Ptr, _Ar
     _Smart_ptr.reset(static_cast<_Sp>(_Ptr), _STD forward<_ArgsT>(_Args)...);
 };
 
-template <class _SmartPtr, class _Pointer, class... _ArgsT>
+_EXPORT_STD template <class _SmartPtr, class _Pointer, class... _ArgsT>
 class out_ptr_t {
     static_assert(!_Is_specialization_v<_SmartPtr, shared_ptr> || sizeof...(_ArgsT) != 0,
         "out_ptr_t with shared_ptr requires a deleter (N4892 [out.ptr.t]/3)");
@@ -4198,7 +4198,7 @@ private:
     _Compressed_pair<tuple<_ArgsT...>, _Pointer> _Mypair;
 };
 
-template <class _Pointer = void, class _SmartPtr, class... _ArgsT>
+_EXPORT_STD template <class _Pointer = void, class _SmartPtr, class... _ArgsT>
 _NODISCARD auto out_ptr(_SmartPtr& _Smart_ptr, _ArgsT&&... _Args) {
     if constexpr (is_void_v<_Pointer>) {
         return out_ptr_t<_SmartPtr, _Pointer_of<_SmartPtr>, _ArgsT&&...>(_Smart_ptr, _STD forward<_ArgsT>(_Args)...);
@@ -4207,7 +4207,7 @@ _NODISCARD auto out_ptr(_SmartPtr& _Smart_ptr, _ArgsT&&... _Args) {
     }
 }
 
-template <class _SmartPtr, class _Pointer, class... _ArgsT>
+_EXPORT_STD template <class _SmartPtr, class _Pointer, class... _ArgsT>
 class inout_ptr_t {
     static_assert(!_Is_specialization_v<_SmartPtr, shared_ptr>,
         "inout_ptr_t doesn't work with shared_ptr (N4892 [inout.ptr.t]/3)");
@@ -4278,7 +4278,7 @@ private:
     _Compressed_pair<tuple<_ArgsT...>, _Pointer> _Mypair;
 };
 
-template <class _Pointer = void, class _SmartPtr, class... _ArgsT>
+_EXPORT_STD template <class _Pointer = void, class _SmartPtr, class... _ArgsT>
 _NODISCARD auto inout_ptr(_SmartPtr& _Smart_ptr, _ArgsT&&... _Args) {
     if constexpr (is_void_v<_Pointer>) {
         return inout_ptr_t<_SmartPtr, _Pointer_of<_SmartPtr>, _ArgsT&&...>(_Smart_ptr, _STD forward<_ArgsT>(_Args)...);
diff --git a/stl/inc/memory_resource b/stl/inc/memory_resource
index 743809c9bd..90a6214ada 100644
--- a/stl/inc/memory_resource
+++ b/stl/inc/memory_resource
@@ -35,7 +35,7 @@ namespace pmr {
     extern "C" _CRT_SATELLITE_1 memory_resource* __cdecl _Aligned_set_default_resource(memory_resource*) noexcept;
     extern "C" _CRT_SATELLITE_1 memory_resource* __cdecl _Unaligned_set_default_resource(memory_resource*) noexcept;
 
-    inline memory_resource* set_default_resource(memory_resource* const _Resource) noexcept {
+    _EXPORT_STD inline memory_resource* set_default_resource(memory_resource* const _Resource) noexcept {
 #ifdef __cpp_aligned_new
         return _Aligned_set_default_resource(_Resource);
 #else // ^^^ __cpp_aligned_new / !__cpp_aligned_new vvv
@@ -43,7 +43,7 @@ namespace pmr {
 #endif // __cpp_aligned_new
     }
 
-    extern "C" _NODISCARD _CRT_SATELLITE_1 memory_resource* __cdecl null_memory_resource() noexcept;
+    _EXPORT_STD extern "C" _NODISCARD _CRT_SATELLITE_1 memory_resource* __cdecl null_memory_resource() noexcept;
 
     class _Identity_equal_resource : public memory_resource {
     protected:
@@ -92,13 +92,13 @@ namespace pmr {
 
     extern "C" _CRT_SATELLITE_1 _Aligned_new_delete_resource_impl* __cdecl _Aligned_new_delete_resource() noexcept;
 
-    _NODISCARD inline memory_resource* new_delete_resource() noexcept {
+    _EXPORT_STD _NODISCARD inline memory_resource* new_delete_resource() noexcept {
         return _Aligned_new_delete_resource();
     }
 
 #else // ^^^ __cpp_aligned_new / !__cpp_aligned_new vvv
 
-    _NODISCARD inline memory_resource* new_delete_resource() noexcept {
+    _EXPORT_STD _NODISCARD inline memory_resource* new_delete_resource() noexcept {
         return _Unaligned_new_delete_resource();
     }
 #endif // __cpp_aligned_new
@@ -215,7 +215,7 @@ namespace pmr {
         _Link_type* _Head = nullptr;
     };
 
-    struct pool_options {
+    _EXPORT_STD struct pool_options {
         size_t max_blocks_per_chunk        = 0;
         size_t largest_required_pool_block = 0;
     };
@@ -227,7 +227,7 @@ namespace pmr {
         (void) _Align;
     }
 
-    struct unsynchronized_pool_resource : _Identity_equal_resource {
+    _EXPORT_STD struct unsynchronized_pool_resource : _Identity_equal_resource {
         unsynchronized_pool_resource() noexcept { // initialize pool with default options and default upstream
             _Setup_options();
         }
@@ -566,7 +566,7 @@ namespace pmr {
     };
 
 #ifndef _M_CEE
-    class synchronized_pool_resource : public unsynchronized_pool_resource {
+    _EXPORT_STD class synchronized_pool_resource : public unsynchronized_pool_resource {
     public:
         using unsynchronized_pool_resource::unsynchronized_pool_resource;
 
@@ -591,7 +591,7 @@ namespace pmr {
     };
 #endif // _M_CEE
 
-    class monotonic_buffer_resource : public _Identity_equal_resource {
+    _EXPORT_STD class monotonic_buffer_resource : public _Identity_equal_resource {
     public:
         explicit monotonic_buffer_resource(memory_resource* const _Upstream) noexcept // strengthened
             : _Resource{_Upstream} {} // initialize this resource with upstream
diff --git a/stl/inc/mutex b/stl/inc/mutex
index 2dcf035208..de0537c068 100644
--- a/stl/inc/mutex
+++ b/stl/inc/mutex
@@ -30,8 +30,8 @@ _STL_DISABLE_CLANG_WARNINGS
 _STD_BEGIN
 // mutex and recursive_mutex are not supported under /clr
 #ifndef _M_CEE
-class condition_variable;
-class condition_variable_any;
+_EXPORT_STD class condition_variable;
+_EXPORT_STD class condition_variable_any;
 
 class _Mutex_base { // base class for all mutex types
 public:
@@ -83,7 +83,7 @@ private:
     }
 };
 
-class mutex : public _Mutex_base { // class for mutual exclusion
+_EXPORT_STD class mutex : public _Mutex_base { // class for mutual exclusion
 public:
     /* constexpr */ mutex() noexcept // TRANSITION, ABI
         : _Mutex_base() {}
@@ -92,7 +92,7 @@ public:
     mutex& operator=(const mutex&) = delete;
 };
 
-class recursive_mutex : public _Mutex_base { // class for recursive mutual exclusion
+_EXPORT_STD class recursive_mutex : public _Mutex_base { // class for recursive mutual exclusion
 public:
     recursive_mutex() : _Mutex_base(_Mtx_recursive) {}
 
@@ -105,23 +105,23 @@ public:
 };
 #endif // _M_CEE
 
-struct adopt_lock_t { // indicates adopt lock
+_EXPORT_STD struct adopt_lock_t { // indicates adopt lock
     explicit adopt_lock_t() = default;
 };
 
-struct defer_lock_t { // indicates defer lock
+_EXPORT_STD struct defer_lock_t { // indicates defer lock
     explicit defer_lock_t() = default;
 };
 
-struct try_to_lock_t { // indicates try to lock
+_EXPORT_STD struct try_to_lock_t { // indicates try to lock
     explicit try_to_lock_t() = default;
 };
 
-_INLINE_VAR constexpr adopt_lock_t adopt_lock{};
-_INLINE_VAR constexpr defer_lock_t defer_lock{};
-_INLINE_VAR constexpr try_to_lock_t try_to_lock{};
+_EXPORT_STD _INLINE_VAR constexpr adopt_lock_t adopt_lock{};
+_EXPORT_STD _INLINE_VAR constexpr defer_lock_t defer_lock{};
+_EXPORT_STD _INLINE_VAR constexpr try_to_lock_t try_to_lock{};
 
-template <class _Mutex>
+_EXPORT_STD template <class _Mutex>
 class unique_lock { // whizzy class with destructor that unlocks mutex
 public:
     using mutex_type = _Mutex;
@@ -272,7 +272,7 @@ private:
     }
 };
 
-template <class _Mutex>
+_EXPORT_STD template <class _Mutex>
 void swap(unique_lock<_Mutex>& _Left, unique_lock<_Mutex>& _Right) noexcept {
     _Left.swap(_Right);
 }
@@ -346,7 +346,7 @@ int _Try_lock1(_Lock0& _Lk0, _Lock1& _Lk1) {
     return -1;
 }
 
-template <class _Lock0, class _Lock1, class... _LockN>
+_EXPORT_STD template <class _Lock0, class _Lock1, class... _LockN>
 _NODISCARD_TRY_CHANGE_STATE int try_lock(_Lock0& _Lk0, _Lock1& _Lk1, _LockN&... _LkN) { // try to lock multiple locks
     return _Try_lock1(_Lk0, _Lk1, _LkN...);
 }
@@ -413,12 +413,12 @@ void _Lock_nonmember1(_Lock0& _Lk0, _Lock1& _Lk1) {
     }
 }
 
-template <class _Lock0, class _Lock1, class... _LockN>
+_EXPORT_STD template <class _Lock0, class _Lock1, class... _LockN>
 void lock(_Lock0& _Lk0, _Lock1& _Lk1, _LockN&... _LkN) { // lock multiple locks, without deadlock
     _Lock_nonmember1(_Lk0, _Lk1, _LkN...);
 }
 
-template <class _Mutex>
+_EXPORT_STD template <class _Mutex>
 class _NODISCARD_LOCK lock_guard { // class with destructor that unlocks a mutex
 public:
     using mutex_type = _Mutex;
@@ -441,7 +441,7 @@ private:
 };
 
 #if _HAS_CXX17
-template <class... _Mutexes>
+_EXPORT_STD template <class... _Mutexes>
 class _NODISCARD_LOCK scoped_lock { // class with destructor that unlocks mutexes
 public:
     explicit scoped_lock(_Mutexes&... _Mtxes) : _MyMutexes(_Mtxes...) { // construct and lock
@@ -543,7 +543,7 @@ struct _Init_once_completer {
     }
 };
 
-template <class _Fn, class... _Args>
+_EXPORT_STD template <class _Fn, class... _Args>
 void(call_once)(once_flag& _Once, _Fn&& _Fx, _Args&&... _Ax) noexcept(
     noexcept(_STD invoke(_STD forward<_Fn>(_Fx), _STD forward<_Args>(_Ax)...))) /* strengthened */ {
     // call _Fx(_Ax...) once
@@ -565,12 +565,12 @@ void(call_once)(once_flag& _Once, _Fn&& _Fx, _Args&&... _Ax) noexcept(
 
 // condition_variable, timed_mutex, and recursive_timed_mutex are not supported under /clr
 #ifndef _M_CEE
-enum class cv_status { // names for wait returns
+_EXPORT_STD enum class cv_status { // names for wait returns
     no_timeout,
     timeout
 };
 
-class condition_variable { // class for waiting for conditions
+_EXPORT_STD class condition_variable { // class for waiting for conditions
 public:
     using native_handle_type = _Cnd_t;
 
@@ -744,7 +744,7 @@ struct _UInt_is_zero {
     }
 };
 
-class timed_mutex { // class for timed mutual exclusion
+_EXPORT_STD class timed_mutex { // class for timed mutual exclusion
 public:
     timed_mutex() noexcept : _My_locked(0) {}
 
@@ -815,7 +815,7 @@ private:
     unsigned int _My_locked;
 };
 
-class recursive_timed_mutex { // class for recursive timed mutual exclusion
+_EXPORT_STD class recursive_timed_mutex { // class for recursive timed mutual exclusion
 public:
     recursive_timed_mutex() noexcept : _My_locked(0) {}
 
diff --git a/stl/inc/new b/stl/inc/new
index da0f276cfd..d697a4e9f1 100644
--- a/stl/inc/new
+++ b/stl/inc/new
@@ -18,16 +18,78 @@ _STL_DISABLE_CLANG_WARNINGS
 #pragma push_macro("new")
 #undef new
 
+#ifdef _BUILD_STD_MODULE
+#pragma warning(push)
+#pragma warning(disable : 28251) // Inconsistent annotation for 'new': this instance has no annotations.
+
+// Mirroring <vcruntime_new.h> declarations:
+
+_STD_BEGIN
+_EXPORT_STD extern "C++" struct nothrow_t;
+_EXPORT_STD extern "C++" const nothrow_t nothrow;
+_STD_END
+
+_EXPORT_STD extern "C++" _NODISCARD _VCRT_ALLOCATOR void* __CRTDECL operator new(size_t);
+_EXPORT_STD extern "C++" _NODISCARD _VCRT_ALLOCATOR void* __CRTDECL operator new(
+    size_t, const _STD nothrow_t&) noexcept;
+_EXPORT_STD extern "C++" _NODISCARD _VCRT_ALLOCATOR void* __CRTDECL operator new[](size_t);
+_EXPORT_STD extern "C++" _NODISCARD _VCRT_ALLOCATOR void* __CRTDECL operator new[](
+    size_t, const _STD nothrow_t&) noexcept;
+_EXPORT_STD extern "C++" void __CRTDECL operator delete(void*) noexcept;
+_EXPORT_STD extern "C++" void __CRTDECL operator delete(void*, size_t) noexcept;
+_EXPORT_STD extern "C++" void __CRTDECL operator delete(void*, const _STD nothrow_t&) noexcept;
+_EXPORT_STD extern "C++" void __CRTDECL operator delete[](void*) noexcept;
+_EXPORT_STD extern "C++" void __CRTDECL operator delete[](void*, size_t) noexcept;
+_EXPORT_STD extern "C++" void __CRTDECL operator delete[](void*, const _STD nothrow_t&) noexcept;
+
+#ifdef __cpp_aligned_new
 _STD_BEGIN
+#ifdef __EDG__ // TRANSITION, VSO-1618988
+extern "C++" {
+_EXPORT_STD enum class align_val_t : size_t;
+}
+#else // ^^^ workaround / no workaround vvv
+_EXPORT_STD extern "C++" enum class align_val_t : size_t;
+#endif // ^^^ no workaround ^^^
+_STD_END
+
+_EXPORT_STD extern "C++" _NODISCARD _VCRT_ALLOCATOR void* __CRTDECL operator new(size_t, _STD align_val_t);
+_EXPORT_STD extern "C++" _NODISCARD _VCRT_ALLOCATOR void* __CRTDECL operator new(
+    size_t, _STD align_val_t, const _STD nothrow_t&) noexcept;
+_EXPORT_STD extern "C++" _NODISCARD _VCRT_ALLOCATOR void* __CRTDECL operator new[](size_t, _STD align_val_t);
+_EXPORT_STD extern "C++" _NODISCARD _VCRT_ALLOCATOR void* __CRTDECL operator new[](
+    size_t, _STD align_val_t, const _STD nothrow_t&) noexcept;
+_EXPORT_STD extern "C++" void __CRTDECL operator delete(void*, _STD align_val_t) noexcept;
+_EXPORT_STD extern "C++" void __CRTDECL operator delete(void*, size_t, _STD align_val_t) noexcept;
+_EXPORT_STD extern "C++" void __CRTDECL operator delete(void*, _STD align_val_t, const _STD nothrow_t&) noexcept;
+_EXPORT_STD extern "C++" void __CRTDECL operator delete[](void*, _STD align_val_t) noexcept;
+_EXPORT_STD extern "C++" void __CRTDECL operator delete[](void*, size_t, _STD align_val_t) noexcept;
+_EXPORT_STD extern "C++" void __CRTDECL operator delete[](void*, _STD align_val_t, const _STD nothrow_t&) noexcept;
+#endif // __cpp_aligned_new
+
+_EXPORT_STD extern "C++" _NODISCARD void* __CRTDECL operator new(size_t, void*) noexcept;
+_EXPORT_STD extern "C++" _NODISCARD void* __CRTDECL operator new[](size_t, void*) noexcept;
+_EXPORT_STD extern "C++" void __CRTDECL operator delete(void*, void*) noexcept;
+_EXPORT_STD extern "C++" void __CRTDECL operator delete[](void*, void*) noexcept;
+
+#pragma warning(pop)
+#endif // _BUILD_STD_MODULE
+
+_STD_BEGIN
+#if _HAS_EXCEPTIONS
+_EXPORT_STD class bad_alloc;
+_EXPORT_STD class bad_array_new_length;
+#else // ^^^ _HAS_EXCEPTIONS / !_HAS_EXCEPTIONS vvv
+// <exception> exports bad_alloc and bad_array_new_length.
+#endif // ^^^ !_HAS_EXCEPTIONS ^^^
+
 #if _HAS_CXX20
-struct destroying_delete_t {
-    explicit destroying_delete_t() = default;
-};
-inline constexpr destroying_delete_t destroying_delete{};
+_EXPORT_STD struct destroying_delete_t { explicit destroying_delete_t() = default; };
+_EXPORT_STD inline constexpr destroying_delete_t destroying_delete{};
 #endif // _HAS_CXX20
 
 #if _HAS_CXX17
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD_LAUNDER constexpr _Ty* launder(_Ty* _Ptr) noexcept {
     static_assert(!is_function_v<_Ty> && !is_void_v<_Ty>,
         "N4727 21.6.4 [ptr.launder]/3: The program is ill-formed if T is a function type or cv void.");
@@ -35,18 +97,18 @@ _NODISCARD_LAUNDER constexpr _Ty* launder(_Ty* _Ptr) noexcept {
 }
 
 #if defined(_M_IX86) || defined(_M_X64) || defined(_M_ARM) || defined(_M_ARM64)
-inline constexpr size_t hardware_constructive_interference_size = 64;
-inline constexpr size_t hardware_destructive_interference_size  = 64;
+_EXPORT_STD inline constexpr size_t hardware_constructive_interference_size = 64;
+_EXPORT_STD inline constexpr size_t hardware_destructive_interference_size  = 64;
 #else // ^^^ supported hardware ^^^ // vvv unsupported hardware vvv
 #error Unsupported architecture
 #endif // hardware
 
 #endif // _HAS_CXX17
 
-using new_handler = void(__CLRCALL_PURE_OR_CDECL*)();
+_EXPORT_STD using new_handler = void(__CLRCALL_PURE_OR_CDECL*)();
 
-_CRTIMP2 new_handler __cdecl set_new_handler(_In_opt_ new_handler) noexcept;
-_NODISCARD _CRTIMP2 new_handler __cdecl get_new_handler() noexcept;
+_EXPORT_STD extern "C++" _CRTIMP2 new_handler __cdecl set_new_handler(_In_opt_ new_handler) noexcept;
+_EXPORT_STD extern "C++" _NODISCARD _CRTIMP2 new_handler __cdecl get_new_handler() noexcept;
 _STD_END
 
 #pragma pop_macro("new")
diff --git a/stl/inc/numbers b/stl/inc/numbers
index 884c349a45..af5d9e4cec 100644
--- a/stl/inc/numbers
+++ b/stl/inc/numbers
@@ -32,31 +32,31 @@ namespace numbers {
                                           "variable template is ill-formed. (N4835 [math.constants]/3)");
     };
 
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     inline constexpr _Ty e_v = _Invalid<_Ty>{};
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     inline constexpr _Ty log2e_v = _Invalid<_Ty>{};
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     inline constexpr _Ty log10e_v = _Invalid<_Ty>{};
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     inline constexpr _Ty pi_v = _Invalid<_Ty>{};
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     inline constexpr _Ty inv_pi_v = _Invalid<_Ty>{};
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     inline constexpr _Ty inv_sqrtpi_v = _Invalid<_Ty>{};
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     inline constexpr _Ty ln2_v = _Invalid<_Ty>{};
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     inline constexpr _Ty ln10_v = _Invalid<_Ty>{};
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     inline constexpr _Ty sqrt2_v = _Invalid<_Ty>{};
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     inline constexpr _Ty sqrt3_v = _Invalid<_Ty>{};
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     inline constexpr _Ty inv_sqrt3_v = _Invalid<_Ty>{};
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     inline constexpr _Ty egamma_v = _Invalid<_Ty>{};
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     inline constexpr _Ty phi_v = _Invalid<_Ty>{};
 
 #ifdef __cpp_lib_concepts
@@ -169,19 +169,19 @@ namespace numbers {
     inline constexpr long double phi_v<long double> = phi_v<double>;
 #endif // ^^^ !defined(__cpp_lib_concepts) ^^^
 
-    inline constexpr double e          = e_v<double>;
-    inline constexpr double log2e      = log2e_v<double>;
-    inline constexpr double log10e     = log10e_v<double>;
-    inline constexpr double pi         = pi_v<double>;
-    inline constexpr double inv_pi     = inv_pi_v<double>;
-    inline constexpr double inv_sqrtpi = inv_sqrtpi_v<double>;
-    inline constexpr double ln2        = ln2_v<double>;
-    inline constexpr double ln10       = ln10_v<double>;
-    inline constexpr double sqrt2      = sqrt2_v<double>;
-    inline constexpr double sqrt3      = sqrt3_v<double>;
-    inline constexpr double inv_sqrt3  = inv_sqrt3_v<double>;
-    inline constexpr double egamma     = egamma_v<double>;
-    inline constexpr double phi        = phi_v<double>;
+    _EXPORT_STD inline constexpr double e          = e_v<double>;
+    _EXPORT_STD inline constexpr double log2e      = log2e_v<double>;
+    _EXPORT_STD inline constexpr double log10e     = log10e_v<double>;
+    _EXPORT_STD inline constexpr double pi         = pi_v<double>;
+    _EXPORT_STD inline constexpr double inv_pi     = inv_pi_v<double>;
+    _EXPORT_STD inline constexpr double inv_sqrtpi = inv_sqrtpi_v<double>;
+    _EXPORT_STD inline constexpr double ln2        = ln2_v<double>;
+    _EXPORT_STD inline constexpr double ln10       = ln10_v<double>;
+    _EXPORT_STD inline constexpr double sqrt2      = sqrt2_v<double>;
+    _EXPORT_STD inline constexpr double sqrt3      = sqrt3_v<double>;
+    _EXPORT_STD inline constexpr double inv_sqrt3  = inv_sqrt3_v<double>;
+    _EXPORT_STD inline constexpr double egamma     = egamma_v<double>;
+    _EXPORT_STD inline constexpr double phi        = phi_v<double>;
 } // namespace numbers
 _STD_END
 
diff --git a/stl/inc/numeric b/stl/inc/numeric
index 1f2c2d65e6..3b8b9495e9 100644
--- a/stl/inc/numeric
+++ b/stl/inc/numeric
@@ -21,7 +21,7 @@ _STL_DISABLE_CLANG_WARNINGS
 #pragma push_macro("new")
 #undef new
 _STD_BEGIN
-template <class _InIt, class _Ty, class _Fn>
+_EXPORT_STD template <class _InIt, class _Ty, class _Fn>
 _NODISCARD _CONSTEXPR20 _Ty accumulate(const _InIt _First, const _InIt _Last, _Ty _Val, _Fn _Reduce_op) {
     // return noncommutative and nonassociative reduction of _Val and all in [_First, _Last), using _Reduce_op
     _Adl_verify_range(_First, _Last);
@@ -37,7 +37,7 @@ _NODISCARD _CONSTEXPR20 _Ty accumulate(const _InIt _First, const _InIt _Last, _T
     return _Val;
 }
 
-template <class _InIt, class _Ty>
+_EXPORT_STD template <class _InIt, class _Ty>
 _NODISCARD _CONSTEXPR20 _Ty accumulate(const _InIt _First, const _InIt _Last, _Ty _Val) {
     // return noncommutative and nonassociative reduction of _Val and all in [_First, _Last)
     return _STD accumulate(_First, _Last, _Val, plus<>{});
@@ -67,7 +67,7 @@ template <class _InIt, class _Ty, class _BinOp>
 inline constexpr bool _Plus_on_arithmetic_ranges_reduction_v = false;
 #endif // _STD_VECTORIZE_WITH_FLOAT_CONTROL
 
-template <class _InIt, class _Ty, class _BinOp>
+_EXPORT_STD template <class _InIt, class _Ty, class _BinOp>
 _NODISCARD _CONSTEXPR20 _Ty reduce(const _InIt _First, const _InIt _Last, _Ty _Val, _BinOp _Reduce_op) {
     // return commutative and associative reduction of _Val and [_First, _Last), using _Reduce_op
     _Adl_verify_range(_First, _Last);
@@ -89,30 +89,30 @@ _NODISCARD _CONSTEXPR20 _Ty reduce(const _InIt _First, const _InIt _Last, _Ty _V
     return _Val;
 }
 
-template <class _InIt, class _Ty>
+_EXPORT_STD template <class _InIt, class _Ty>
 _NODISCARD _CONSTEXPR20 _Ty reduce(const _InIt _First, const _InIt _Last, _Ty _Val) {
     // return commutative and associative reduction of _Val and [_First, _Last)
     return _STD reduce(_First, _Last, _STD move(_Val), plus{});
 }
 
-template <class _InIt>
+_EXPORT_STD template <class _InIt>
 _NODISCARD _CONSTEXPR20 _Iter_value_t<_InIt> reduce(const _InIt _First, const _InIt _Last) {
     // return commutative and associative reduction of
     // iterator_traits<_InIt>::value_type{} and [_First, _Last)
     return _STD reduce(_First, _Last, _Iter_value_t<_InIt>{}, plus{});
 }
 
-template <class _ExPo, class _FwdIt, class _Ty, class _BinOp, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, class _BinOp, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _Ty reduce(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, _Ty _Val, _BinOp _Reduce_op) noexcept; // terminates
 
-template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _Ty reduce(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, _Ty _Val) noexcept /* terminates */ {
     // return commutative and associative reduction of _Val and [_First, _Last)
     _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
     return _STD reduce(_STD forward<_ExPo>(_Exec), _First, _Last, _STD move(_Val), plus{});
 }
 
-template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _Iter_value_t<_FwdIt> reduce(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last) noexcept
 /* terminates */ {
     // return commutative and associative reduction of
@@ -122,7 +122,7 @@ _NODISCARD _Iter_value_t<_FwdIt> reduce(_ExPo&& _Exec, const _FwdIt _First, cons
 }
 #endif // _HAS_CXX17
 
-template <class _InIt1, class _InIt2, class _Ty, class _BinOp1, class _BinOp2>
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Ty, class _BinOp1, class _BinOp2>
 _NODISCARD _CONSTEXPR20 _Ty inner_product(
     _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val, _BinOp1 _Reduce_op, _BinOp2 _Transform_op) {
     // return noncommutative and nonassociative transform-reduction of sequences, using
@@ -142,7 +142,7 @@ _NODISCARD _CONSTEXPR20 _Ty inner_product(
     return _Val;
 }
 
-template <class _InIt1, class _InIt2, class _Ty>
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Ty>
 _NODISCARD _CONSTEXPR20 _Ty inner_product(const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, _Ty _Val) {
     // return noncommutative and nonassociative transform-reduction of sequences
     return _STD inner_product(_First1, _Last1, _First2, _STD move(_Val), plus<>{}, multiplies<>{});
@@ -172,7 +172,7 @@ template <class _InIt1, class _InIt2, class _Ty, class _BinOp1, class _BinOp2>
 inline constexpr bool _Default_ops_transform_reduce_v = false;
 #endif // _STD_VECTORIZE_WITH_FLOAT_CONTROL
 
-template <class _InIt1, class _InIt2, class _Ty, class _BinOp1, class _BinOp2>
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Ty, class _BinOp1, class _BinOp2>
 _NODISCARD _CONSTEXPR20 _Ty transform_reduce(
     _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val, _BinOp1 _Reduce_op, _BinOp2 _Transform_op) {
     // return commutative and associative transform-reduction of sequences, using
@@ -198,13 +198,13 @@ _NODISCARD _CONSTEXPR20 _Ty transform_reduce(
     return _Val;
 }
 
-template <class _InIt1, class _InIt2, class _Ty>
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Ty>
 _NODISCARD _CONSTEXPR20 _Ty transform_reduce(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val) {
     // return commutative and associative transform-reduction of sequences
     return _STD transform_reduce(_First1, _Last1, _First2, _STD move(_Val), plus{}, multiplies{});
 }
 
-template <class _InIt, class _Ty, class _BinOp, class _UnaryOp>
+_EXPORT_STD template <class _InIt, class _Ty, class _BinOp, class _UnaryOp>
 _NODISCARD _CONSTEXPR20 _Ty transform_reduce(
     const _InIt _First, const _InIt _Last, _Ty _Val, _BinOp _Reduce_op, _UnaryOp _Transform_op) {
     // return commutative and associative reduction of transformed sequence, using
@@ -219,12 +219,12 @@ _NODISCARD _CONSTEXPR20 _Ty transform_reduce(
     return _Val;
 }
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp1, class _BinOp2,
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp1, class _BinOp2,
     _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _Ty transform_reduce(_ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Ty _Val,
     _BinOp1 _Reduce_op, _BinOp2 _Transform_op) noexcept; // terminates
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _Ty transform_reduce(_ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Ty _Val) noexcept
 /* terminates */ {
     // return commutative and associative transform-reduction of sequences
@@ -234,12 +234,13 @@ _NODISCARD _Ty transform_reduce(_ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1,
         _STD forward<_ExPo>(_Exec), _First1, _Last1, _First2, _STD move(_Val), plus{}, multiplies{});
 }
 
-template <class _ExPo, class _FwdIt, class _Ty, class _BinOp, class _UnaryOp, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, class _BinOp, class _UnaryOp,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _Ty transform_reduce(_ExPo&& _Exec, const _FwdIt _First1, const _FwdIt _Last1, _Ty _Val, _BinOp _Reduce_op,
     _UnaryOp _Transform_op) noexcept; // terminates
 #endif // _HAS_CXX17
 
-template <class _InIt, class _OutIt, class _BinOp>
+_EXPORT_STD template <class _InIt, class _OutIt, class _BinOp>
 _CONSTEXPR20 _OutIt partial_sum(const _InIt _First, const _InIt _Last, _OutIt _Dest, _BinOp _Reduce_op) {
     // compute partial noncommutative and nonassociative reductions into _Dest, using _Reduce_op
     _Adl_verify_range(_First, _Last);
@@ -268,14 +269,14 @@ _CONSTEXPR20 _OutIt partial_sum(const _InIt _First, const _InIt _Last, _OutIt _D
     return _Dest;
 }
 
-template <class _InIt, class _OutIt>
+_EXPORT_STD template <class _InIt, class _OutIt>
 _CONSTEXPR20 _OutIt partial_sum(_InIt _First, _InIt _Last, _OutIt _Dest) {
     // compute partial noncommutative and nonassociative reductions into _Dest
     return _STD partial_sum(_First, _Last, _Dest, plus<>{});
 }
 
 #if _HAS_CXX17
-template <class _InIt, class _OutIt, class _Ty, class _BinOp>
+_EXPORT_STD template <class _InIt, class _OutIt, class _Ty, class _BinOp>
 _CONSTEXPR20 _OutIt exclusive_scan(const _InIt _First, const _InIt _Last, _OutIt _Dest, _Ty _Val, _BinOp _Reduce_op) {
     // set each value in [_Dest, _Dest + (_Last - _First)) to the associative reduction of predecessors and _Val
     _Adl_verify_range(_First, _Last);
@@ -300,24 +301,25 @@ _CONSTEXPR20 _OutIt exclusive_scan(const _InIt _First, const _InIt _Last, _OutIt
     return _Dest;
 }
 
-template <class _InIt, class _OutIt, class _Ty>
+_EXPORT_STD template <class _InIt, class _OutIt, class _Ty>
 _CONSTEXPR20 _OutIt exclusive_scan(const _InIt _First, const _InIt _Last, const _OutIt _Dest, _Ty _Val) {
     // set each value in [_Dest, _Dest + (_Last - _First)) to the associative reduction of predecessors and _Val
     return _STD exclusive_scan(_First, _Last, _Dest, _STD move(_Val), plus{});
 }
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt2 exclusive_scan(_ExPo&& _Exec, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _Ty _Val,
     _BinOp _Reduce_op) noexcept; // terminates
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt2 exclusive_scan(_ExPo&& _Exec, const _FwdIt1 _First, const _FwdIt1 _Last, const _FwdIt2 _Dest, _Ty _Val) noexcept
 /* terminates */ {
     // set each value in [_Dest, _Dest + (_Last - _First)) to the associative reduction of predecessors and _Val
     return _STD exclusive_scan(_STD forward<_ExPo>(_Exec), _First, _Last, _Dest, _STD move(_Val), plus{});
 }
 
-template <class _InIt, class _OutIt, class _Ty, class _BinOp>
+_EXPORT_STD template <class _InIt, class _OutIt, class _Ty, class _BinOp>
 _CONSTEXPR20 _OutIt inclusive_scan(const _InIt _First, const _InIt _Last, _OutIt _Dest, _BinOp _Reduce_op, _Ty _Val) {
     // compute partial noncommutative and associative reductions including _Val into _Dest, using _Reduce_op
     _Adl_verify_range(_First, _Last);
@@ -334,7 +336,7 @@ _CONSTEXPR20 _OutIt inclusive_scan(const _InIt _First, const _InIt _Last, _OutIt
     return _Dest;
 }
 
-template <class _InIt, class _OutIt, class _BinOp>
+_EXPORT_STD template <class _InIt, class _OutIt, class _BinOp>
 _CONSTEXPR20 _OutIt inclusive_scan(const _InIt _First, const _InIt _Last, _OutIt _Dest, _BinOp _Reduce_op) {
     // compute partial noncommutative and associative reductions into _Dest, using _Reduce_op
     _Adl_verify_range(_First, _Last);
@@ -359,28 +361,29 @@ _CONSTEXPR20 _OutIt inclusive_scan(const _InIt _First, const _InIt _Last, _OutIt
     return _Dest;
 }
 
-template <class _InIt, class _OutIt>
+_EXPORT_STD template <class _InIt, class _OutIt>
 _CONSTEXPR20 _OutIt inclusive_scan(const _InIt _First, const _InIt _Last, const _OutIt _Dest) {
     // compute partial noncommutative and associative reductions into _Dest
     return _STD inclusive_scan(_First, _Last, _Dest, plus{});
 }
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, class _Ty,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt2 inclusive_scan(
     _ExPo&& _Exec, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op, _Ty _Val) noexcept; // terminates
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt2 inclusive_scan(
     _ExPo&& _Exec, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op) noexcept; // terminates
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt2 inclusive_scan(_ExPo&& _Exec, const _FwdIt1 _First, const _FwdIt1 _Last, const _FwdIt2 _Dest) noexcept
 /* terminates */ {
     // compute partial noncommutative and associative reductions into _Dest
     return _STD inclusive_scan(_STD forward<_ExPo>(_Exec), _First, _Last, _Dest, plus{});
 }
 
-template <class _InIt, class _OutIt, class _Ty, class _BinOp, class _UnaryOp>
+_EXPORT_STD template <class _InIt, class _OutIt, class _Ty, class _BinOp, class _UnaryOp>
 _CONSTEXPR20 _OutIt transform_exclusive_scan(
     const _InIt _First, const _InIt _Last, _OutIt _Dest, _Ty _Val, _BinOp _Reduce_op, _UnaryOp _Transform_op) {
     // set each value in [_Dest, _Dest + (_Last - _First)) to the associative reduction of transformed predecessors
@@ -406,12 +409,12 @@ _CONSTEXPR20 _OutIt transform_exclusive_scan(
     return _Dest;
 }
 
-template <class _ExPo, class _FwdIt1, class _OutIt, class _Ty, class _BinOp, class _UnaryOp,
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _OutIt, class _Ty, class _BinOp, class _UnaryOp,
     _Enable_if_execution_policy_t<_ExPo> = 0>
 _OutIt transform_exclusive_scan(_ExPo&& _Exec, const _FwdIt1 _First, const _FwdIt1 _Last, _OutIt _Dest, _Ty _Val,
     _BinOp _Reduce_op, _UnaryOp _Transform_op) noexcept; // terminates
 
-template <class _InIt, class _OutIt, class _Ty, class _BinOp, class _UnaryOp>
+_EXPORT_STD template <class _InIt, class _OutIt, class _Ty, class _BinOp, class _UnaryOp>
 _CONSTEXPR20 _OutIt transform_inclusive_scan(
     const _InIt _First, const _InIt _Last, _OutIt _Dest, _BinOp _Reduce_op, _UnaryOp _Transform_op, _Ty _Val) {
     // compute partial noncommutative and associative transformed reductions including _Val into _Dest
@@ -429,7 +432,7 @@ _CONSTEXPR20 _OutIt transform_inclusive_scan(
     return _Dest;
 }
 
-template <class _InIt, class _OutIt, class _BinOp, class _UnaryOp>
+_EXPORT_STD template <class _InIt, class _OutIt, class _BinOp, class _UnaryOp>
 _CONSTEXPR20 _OutIt transform_inclusive_scan(
     const _InIt _First, const _InIt _Last, _OutIt _Dest, _BinOp _Reduce_op, _UnaryOp _Transform_op) {
     // compute partial noncommutative and associative transformed reductions into _Dest
@@ -455,18 +458,18 @@ _CONSTEXPR20 _OutIt transform_inclusive_scan(
     return _Dest;
 }
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp, class _UnaryOp,
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp, class _UnaryOp,
     _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt2 transform_inclusive_scan(_ExPo&& _Exec, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest,
     _BinOp _Reduce_op, _UnaryOp _Transform_op, _Ty _Val) noexcept; // terminates
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, class _UnaryOp,
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, class _UnaryOp,
     _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt2 transform_inclusive_scan(_ExPo&& _Exec, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest,
     _BinOp _Reduce_op, _UnaryOp _Transform_op) noexcept; // terminates
 #endif // _HAS_CXX17
 
-template <class _InIt, class _OutIt, class _BinOp>
+_EXPORT_STD template <class _InIt, class _OutIt, class _BinOp>
 _CONSTEXPR20 _OutIt adjacent_difference(const _InIt _First, const _InIt _Last, _OutIt _Dest, _BinOp _Func) {
     // compute adjacent differences into _Dest
     _Adl_verify_range(_First, _Last);
@@ -493,18 +496,18 @@ _CONSTEXPR20 _OutIt adjacent_difference(const _InIt _First, const _InIt _Last, _
     return _Dest;
 }
 
-template <class _InIt, class _OutIt>
+_EXPORT_STD template <class _InIt, class _OutIt>
 _CONSTEXPR20 _OutIt adjacent_difference(const _InIt _First, const _InIt _Last, const _OutIt _Dest) {
     // compute adjacent differences into _Dest
     return _STD adjacent_difference(_First, _Last, _Dest, minus<>{});
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt2 adjacent_difference(
     _ExPo&& _Exec, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Diff_op) noexcept; // terminates
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt2 adjacent_difference(_ExPo&& _Exec, const _FwdIt1 _First, const _FwdIt1 _Last, const _FwdIt2 _Dest) noexcept
 /* terminates */ {
     // compute adjacent differences into _Dest
@@ -512,7 +515,7 @@ _FwdIt2 adjacent_difference(_ExPo&& _Exec, const _FwdIt1 _First, const _FwdIt1 _
 }
 #endif // _HAS_CXX17
 
-template <class _FwdIt, class _Ty>
+_EXPORT_STD template <class _FwdIt, class _Ty>
 _CONSTEXPR20 void iota(_FwdIt _First, _FwdIt _Last, _Ty _Val) {
     // compute increasing sequence into [_First, _Last)
     _Adl_verify_range(_First, _Last);
@@ -525,7 +528,7 @@ _CONSTEXPR20 void iota(_FwdIt _First, _FwdIt _Last, _Ty _Val) {
 
 #if _HAS_CXX23 && defined(__cpp_lib_concepts) // TRANSITION, GH-395
 namespace ranges {
-    template <class _Out, class _Ty>
+    _EXPORT_STD template <class _Out, class _Ty>
     using iota_result = out_value_result<_Out, _Ty>;
 
     class _Iota_fn : private _Not_quite_object {
@@ -563,7 +566,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Iota_fn iota{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Iota_fn iota{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // _HAS_CXX23 && defined(__cpp_lib_concepts)
 
@@ -587,7 +590,7 @@ _NODISCARD constexpr auto _Abs_u(const _Integral _Val) noexcept {
     }
 }
 
-template <class _Mt, class _Nt>
+_EXPORT_STD template <class _Mt, class _Nt>
 _NODISCARD constexpr common_type_t<_Mt, _Nt> gcd(const _Mt _Mx, const _Nt _Nx) noexcept /* strengthened */ {
     // calculate greatest common divisor
     static_assert(_Is_nonbool_integral<_Mt> && _Is_nonbool_integral<_Nt>, "GCD requires nonbool integral types");
@@ -625,7 +628,7 @@ _NODISCARD constexpr common_type_t<_Mt, _Nt> gcd(const _Mt _Mx, const _Nt _Nx) n
     });
 }
 
-template <class _Mt, class _Nt>
+_EXPORT_STD template <class _Mt, class _Nt>
 _NODISCARD constexpr common_type_t<_Mt, _Nt> lcm(const _Mt _Mx, const _Nt _Nx) noexcept /* strengthened */ {
     // calculate least common multiple
     static_assert(_Is_nonbool_integral<_Mt> && _Is_nonbool_integral<_Nt>, "LCM requires nonbool integral types");
@@ -642,7 +645,7 @@ _NODISCARD constexpr common_type_t<_Mt, _Nt> lcm(const _Mt _Mx, const _Nt _Nx) n
 #endif // _HAS_CXX17
 
 #if _HAS_CXX20
-template <class _Ty, enable_if_t<is_arithmetic_v<_Ty> && !is_same_v<remove_cv_t<_Ty>, bool>, int> = 0>
+_EXPORT_STD template <class _Ty, enable_if_t<is_arithmetic_v<_Ty> && !is_same_v<remove_cv_t<_Ty>, bool>, int> = 0>
 _NODISCARD constexpr _Ty midpoint(const _Ty _Val1, const _Ty _Val2) noexcept {
     if constexpr (is_floating_point_v<_Ty>) {
         if (_STD is_constant_evaluated()) {
@@ -707,7 +710,7 @@ _NODISCARD constexpr _Ty midpoint(const _Ty _Val1, const _Ty _Val2) noexcept {
     }
 }
 
-template <class _Ty, enable_if_t<is_object_v<_Ty>, int> = 0>
+_EXPORT_STD template <class _Ty, enable_if_t<is_object_v<_Ty>, int> = 0>
 _NODISCARD constexpr _Ty* midpoint(_Ty* const _Val1, _Ty* const _Val2) noexcept /* strengthened */ {
     if (_Val1 > _Val2) {
         return _Val1 - ((_Val1 - _Val2) >> 1); // shift for codegen
diff --git a/stl/inc/optional b/stl/inc/optional
index 9f5c788406..49173c22cd 100644
--- a/stl/inc/optional
+++ b/stl/inc/optional
@@ -30,13 +30,13 @@ _STL_DISABLE_CLANG_WARNINGS
 
 _STD_BEGIN
 
-struct nullopt_t { // no-value state indicator
+_EXPORT_STD struct nullopt_t { // no-value state indicator
     struct _Tag {};
     constexpr explicit nullopt_t(_Tag) {}
 };
-inline constexpr nullopt_t nullopt{nullopt_t::_Tag{}};
+_EXPORT_STD inline constexpr nullopt_t nullopt{nullopt_t::_Tag{}};
 
-class bad_optional_access : public exception {
+_EXPORT_STD class bad_optional_access : public exception {
 public:
     _NODISCARD const char* __CLR_OR_THIS_CALL what() const noexcept override {
         return "Bad optional access";
@@ -210,7 +210,7 @@ struct _Optional_construct_base : _Optional_destruct_base<_Ty> {
     }
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class optional : private _SMF_control<_Optional_construct_base<_Ty>, _Ty> {
 private:
     using _Mybase = _SMF_control<_Optional_construct_base<_Ty>, _Ty>;
@@ -615,7 +615,7 @@ public:
 template <class _Ty>
 optional(_Ty) -> optional<_Ty>;
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD constexpr bool operator==(const optional<_Ty1>& _Left, const optional<_Ty2>& _Right) noexcept(
     noexcept(_Fake_copy_init<bool>(*_Left == *_Right))) /* strengthened */
 #ifdef __cpp_lib_concepts
@@ -632,7 +632,7 @@ _NODISCARD constexpr bool operator==(const optional<_Ty1>& _Left, const optional
     return _Left_has_value == _Right_has_value;
 }
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD constexpr bool operator!=(const optional<_Ty1>& _Left, const optional<_Ty2>& _Right) noexcept(
     noexcept(_Fake_copy_init<bool>(*_Left != *_Right))) /* strengthened */
 #ifdef __cpp_lib_concepts
@@ -649,7 +649,7 @@ _NODISCARD constexpr bool operator!=(const optional<_Ty1>& _Left, const optional
     return _Left_has_value != _Right_has_value;
 }
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD constexpr bool operator<(const optional<_Ty1>& _Left, const optional<_Ty2>& _Right) noexcept(
     noexcept(_Fake_copy_init<bool>(*_Left < *_Right))) /* strengthened */
 #ifdef __cpp_lib_concepts
@@ -666,7 +666,7 @@ _NODISCARD constexpr bool operator<(const optional<_Ty1>& _Left, const optional<
     return _Left_has_value < _Right_has_value;
 }
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD constexpr bool operator>(const optional<_Ty1>& _Left, const optional<_Ty2>& _Right) noexcept(
     noexcept(_Fake_copy_init<bool>(*_Left > *_Right))) /* strengthened */
 #ifdef __cpp_lib_concepts
@@ -683,7 +683,7 @@ _NODISCARD constexpr bool operator>(const optional<_Ty1>& _Left, const optional<
     return _Left_has_value > _Right_has_value;
 }
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD constexpr bool operator<=(const optional<_Ty1>& _Left, const optional<_Ty2>& _Right) noexcept(
     noexcept(_Fake_copy_init<bool>(*_Left <= *_Right))) /* strengthened */
 #ifdef __cpp_lib_concepts
@@ -700,7 +700,7 @@ _NODISCARD constexpr bool operator<=(const optional<_Ty1>& _Left, const optional
     return _Left_has_value <= _Right_has_value;
 }
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD constexpr bool operator>=(const optional<_Ty1>& _Left, const optional<_Ty2>& _Right) noexcept(
     noexcept(_Fake_copy_init<bool>(*_Left >= *_Right))) /* strengthened */
 #ifdef __cpp_lib_concepts
@@ -718,7 +718,7 @@ _NODISCARD constexpr bool operator>=(const optional<_Ty1>& _Left, const optional
 }
 
 #ifdef __cpp_lib_concepts
-template <class _Ty1, three_way_comparable_with<_Ty1> _Ty2>
+_EXPORT_STD template <class _Ty1, three_way_comparable_with<_Ty1> _Ty2>
 _NODISCARD constexpr compare_three_way_result_t<_Ty1, _Ty2> operator<=>(const optional<_Ty1>& _Left,
     const optional<_Ty2>& _Right) noexcept(noexcept(*_Left <=> *_Right)) /* strengthened */ {
     const bool _Left_has_value  = _Left.has_value();
@@ -731,13 +731,13 @@ _NODISCARD constexpr compare_three_way_result_t<_Ty1, _Ty2> operator<=>(const op
 }
 #endif // __cpp_lib_concepts
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD constexpr bool operator==(const optional<_Ty>& _Left, nullopt_t) noexcept {
     return !_Left.has_value();
 }
 
 #if _HAS_CXX20
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD constexpr strong_ordering operator<=>(const optional<_Ty>& _Left, nullopt_t) noexcept {
     return _Left.has_value() <=> false;
 }
@@ -820,7 +820,7 @@ template <class _Lhs, class _Rhs>
 using _Enable_if_comparable_with_greater_equal =
     _Enable_if_bool_convertible<decltype(_STD declval<const _Lhs&>() >= _STD declval<const _Rhs&>())>;
 
-template <class _Ty1, class _Ty2, _Enable_if_comparable_with_equal<_Ty1, _Ty2> = 0>
+_EXPORT_STD template <class _Ty1, class _Ty2, _Enable_if_comparable_with_equal<_Ty1, _Ty2> = 0>
 _NODISCARD constexpr bool operator==(const optional<_Ty1>& _Left, const _Ty2& _Right) noexcept(
     noexcept(_Fake_copy_init<bool>(*_Left == _Right))) /* strengthened */ {
     if (_Left) {
@@ -829,7 +829,7 @@ _NODISCARD constexpr bool operator==(const optional<_Ty1>& _Left, const _Ty2& _R
     return false;
 }
 
-template <class _Ty1, class _Ty2, _Enable_if_comparable_with_equal<_Ty1, _Ty2> = 0>
+_EXPORT_STD template <class _Ty1, class _Ty2, _Enable_if_comparable_with_equal<_Ty1, _Ty2> = 0>
 _NODISCARD constexpr bool operator==(const _Ty1& _Left, const optional<_Ty2>& _Right) noexcept(
     noexcept(_Fake_copy_init<bool>(_Left == *_Right))) /* strengthened */ {
     if (_Right) {
@@ -838,7 +838,7 @@ _NODISCARD constexpr bool operator==(const _Ty1& _Left, const optional<_Ty2>& _R
     return false;
 }
 
-template <class _Ty1, class _Ty2, _Enable_if_comparable_with_not_equal<_Ty1, _Ty2> = 0>
+_EXPORT_STD template <class _Ty1, class _Ty2, _Enable_if_comparable_with_not_equal<_Ty1, _Ty2> = 0>
 _NODISCARD constexpr bool operator!=(const optional<_Ty1>& _Left, const _Ty2& _Right) noexcept(
     noexcept(_Fake_copy_init<bool>(*_Left != _Right))) /* strengthened */ {
     if (_Left) {
@@ -846,7 +846,7 @@ _NODISCARD constexpr bool operator!=(const optional<_Ty1>& _Left, const _Ty2& _R
     }
     return true;
 }
-template <class _Ty1, class _Ty2, _Enable_if_comparable_with_not_equal<_Ty1, _Ty2> = 0>
+_EXPORT_STD template <class _Ty1, class _Ty2, _Enable_if_comparable_with_not_equal<_Ty1, _Ty2> = 0>
 _NODISCARD constexpr bool operator!=(const _Ty1& _Left, const optional<_Ty2>& _Right) noexcept(
     noexcept(_Fake_copy_init<bool>(_Left != *_Right))) /* strengthened */ {
     if (_Right) {
@@ -855,7 +855,7 @@ _NODISCARD constexpr bool operator!=(const _Ty1& _Left, const optional<_Ty2>& _R
     return true;
 }
 
-template <class _Ty1, class _Ty2, _Enable_if_comparable_with_less<_Ty1, _Ty2> = 0>
+_EXPORT_STD template <class _Ty1, class _Ty2, _Enable_if_comparable_with_less<_Ty1, _Ty2> = 0>
 _NODISCARD constexpr bool operator<(const optional<_Ty1>& _Left, const _Ty2& _Right) noexcept(
     noexcept(_Fake_copy_init<bool>(*_Left < _Right))) /* strengthened */ {
     if (_Left) {
@@ -863,7 +863,7 @@ _NODISCARD constexpr bool operator<(const optional<_Ty1>& _Left, const _Ty2& _Ri
     }
     return true;
 }
-template <class _Ty1, class _Ty2, _Enable_if_comparable_with_less<_Ty1, _Ty2> = 0>
+_EXPORT_STD template <class _Ty1, class _Ty2, _Enable_if_comparable_with_less<_Ty1, _Ty2> = 0>
 _NODISCARD constexpr bool operator<(const _Ty1& _Left, const optional<_Ty2>& _Right) noexcept(
     noexcept(_Fake_copy_init<bool>(_Left < *_Right))) /* strengthened */ {
     if (_Right) {
@@ -872,7 +872,7 @@ _NODISCARD constexpr bool operator<(const _Ty1& _Left, const optional<_Ty2>& _Ri
     return false;
 }
 
-template <class _Ty1, class _Ty2, _Enable_if_comparable_with_greater<_Ty1, _Ty2> = 0>
+_EXPORT_STD template <class _Ty1, class _Ty2, _Enable_if_comparable_with_greater<_Ty1, _Ty2> = 0>
 _NODISCARD constexpr bool operator>(const optional<_Ty1>& _Left, const _Ty2& _Right) noexcept(
     noexcept(_Fake_copy_init<bool>(*_Left > _Right))) /* strengthened */ {
     if (_Left) {
@@ -880,7 +880,7 @@ _NODISCARD constexpr bool operator>(const optional<_Ty1>& _Left, const _Ty2& _Ri
     }
     return false;
 }
-template <class _Ty1, class _Ty2, _Enable_if_comparable_with_greater<_Ty1, _Ty2> = 0>
+_EXPORT_STD template <class _Ty1, class _Ty2, _Enable_if_comparable_with_greater<_Ty1, _Ty2> = 0>
 _NODISCARD constexpr bool operator>(const _Ty1& _Left, const optional<_Ty2>& _Right) noexcept(
     noexcept(_Fake_copy_init<bool>(_Left > *_Right))) /* strengthened */ {
     if (_Right) {
@@ -889,7 +889,7 @@ _NODISCARD constexpr bool operator>(const _Ty1& _Left, const optional<_Ty2>& _Ri
     return true;
 }
 
-template <class _Ty1, class _Ty2, _Enable_if_comparable_with_less_equal<_Ty1, _Ty2> = 0>
+_EXPORT_STD template <class _Ty1, class _Ty2, _Enable_if_comparable_with_less_equal<_Ty1, _Ty2> = 0>
 _NODISCARD constexpr bool operator<=(const optional<_Ty1>& _Left, const _Ty2& _Right) noexcept(
     noexcept(_Fake_copy_init<bool>(*_Left <= _Right))) /* strengthened */ {
     if (_Left) {
@@ -897,7 +897,7 @@ _NODISCARD constexpr bool operator<=(const optional<_Ty1>& _Left, const _Ty2& _R
     }
     return true;
 }
-template <class _Ty1, class _Ty2, _Enable_if_comparable_with_less_equal<_Ty1, _Ty2> = 0>
+_EXPORT_STD template <class _Ty1, class _Ty2, _Enable_if_comparable_with_less_equal<_Ty1, _Ty2> = 0>
 _NODISCARD constexpr bool operator<=(const _Ty1& _Left, const optional<_Ty2>& _Right) noexcept(
     noexcept(_Fake_copy_init<bool>(_Left <= *_Right))) /* strengthened */ {
     if (_Right) {
@@ -906,7 +906,7 @@ _NODISCARD constexpr bool operator<=(const _Ty1& _Left, const optional<_Ty2>& _R
     return false;
 }
 
-template <class _Ty1, class _Ty2, _Enable_if_comparable_with_greater_equal<_Ty1, _Ty2> = 0>
+_EXPORT_STD template <class _Ty1, class _Ty2, _Enable_if_comparable_with_greater_equal<_Ty1, _Ty2> = 0>
 _NODISCARD constexpr bool operator>=(const optional<_Ty1>& _Left, const _Ty2& _Right) noexcept(
     noexcept(_Fake_copy_init<bool>(*_Left >= _Right))) /* strengthened */ {
     if (_Left) {
@@ -914,7 +914,7 @@ _NODISCARD constexpr bool operator>=(const optional<_Ty1>& _Left, const _Ty2& _R
     }
     return false;
 }
-template <class _Ty1, class _Ty2, _Enable_if_comparable_with_greater_equal<_Ty1, _Ty2> = 0>
+_EXPORT_STD template <class _Ty1, class _Ty2, _Enable_if_comparable_with_greater_equal<_Ty1, _Ty2> = 0>
 _NODISCARD constexpr bool operator>=(const _Ty1& _Left, const optional<_Ty2>& _Right) noexcept(
     noexcept(_Fake_copy_init<bool>(_Left >= *_Right))) /* strengthened */ {
     if (_Right) {
@@ -925,7 +925,7 @@ _NODISCARD constexpr bool operator>=(const _Ty1& _Left, const optional<_Ty2>& _R
 
 #ifdef __cpp_lib_concepts
 // clang-format off
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
     requires (!_Is_specialization_v<_Ty2, optional>)
         && three_way_comparable_with<_Ty1, _Ty2>
 _NODISCARD constexpr compare_three_way_result_t<_Ty1, _Ty2>
@@ -940,22 +940,22 @@ _NODISCARD constexpr compare_three_way_result_t<_Ty1, _Ty2>
 }
 #endif // __cpp_lib_concepts
 
-template <class _Ty, enable_if_t<is_move_constructible_v<_Ty> && is_swappable_v<_Ty>, int> = 0>
+_EXPORT_STD template <class _Ty, enable_if_t<is_move_constructible_v<_Ty> && is_swappable_v<_Ty>, int> = 0>
 _CONSTEXPR20 void swap(optional<_Ty>& _Left, optional<_Ty>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
     _Left.swap(_Right);
 }
 
-template <class _Ty, enable_if_t<is_constructible_v<decay_t<_Ty>, _Ty>, int> = 0> // LWG-3627
+_EXPORT_STD template <class _Ty, enable_if_t<is_constructible_v<decay_t<_Ty>, _Ty>, int> = 0> // LWG-3627
 _NODISCARD constexpr optional<decay_t<_Ty>> make_optional(_Ty&& _Value) noexcept(
     noexcept(optional<decay_t<_Ty>>{_STD forward<_Ty>(_Value)})) /* strengthened */ {
     return optional<decay_t<_Ty>>{_STD forward<_Ty>(_Value)};
 }
-template <class _Ty, class... _Types, enable_if_t<is_constructible_v<_Ty, _Types...>, int> = 0>
+_EXPORT_STD template <class _Ty, class... _Types, enable_if_t<is_constructible_v<_Ty, _Types...>, int> = 0>
 _NODISCARD constexpr optional<_Ty> make_optional(_Types&&... _Args) noexcept(
     noexcept(optional<_Ty>{in_place, _STD forward<_Types>(_Args)...})) /* strengthened */ {
     return optional<_Ty>{in_place, _STD forward<_Types>(_Args)...};
 }
-template <class _Ty, class _Elem, class... _Types,
+_EXPORT_STD template <class _Ty, class _Elem, class... _Types,
     enable_if_t<is_constructible_v<_Ty, initializer_list<_Elem>&, _Types...>, int> = 0>
 _NODISCARD constexpr optional<_Ty> make_optional(initializer_list<_Elem> _Ilist, _Types&&... _Args) noexcept(
     noexcept(optional<_Ty>{in_place, _Ilist, _STD forward<_Types>(_Args)...})) /* strengthened */ {
diff --git a/stl/inc/ostream b/stl/inc/ostream
index fd86ddd822..86fe111745 100644
--- a/stl/inc/ostream
+++ b/stl/inc/ostream
@@ -20,7 +20,7 @@ _STL_DISABLE_CLANG_WARNINGS
 _STD_BEGIN
 #pragma vtordisp(push, 2) // compiler bug workaround
 
-template <class _Elem, class _Traits>
+_EXPORT_STD extern "C++" template <class _Elem, class _Traits>
 class basic_ostream : virtual public basic_ios<_Elem, _Traits> { // control insertions into a stream buffer
 public:
     using _Myios = basic_ios<_Elem, _Traits>;
@@ -677,7 +677,7 @@ template class _CRTIMP2_PURE_IMPORT basic_ostream<unsigned short, char_traits<un
 #endif // __FORCE_INSTANCE
 #endif // defined(_DLL_CPPLIB)
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, const char* _Val) { // insert NTBS
     ios_base::iostate _State = ios_base::goodbit;
     streamsize _Count        = static_cast<streamsize>(_CSTD strlen(_Val));
@@ -721,7 +721,7 @@ basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
     return _Ostr;
 }
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, char _Ch) { // insert a character
     ios_base::iostate _State = ios_base::goodbit;
     const typename basic_ostream<_Elem, _Traits>::sentry _Ok(_Ostr);
@@ -757,7 +757,7 @@ basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
     return _Ostr;
 }
 
-template <class _Traits>
+_EXPORT_STD template <class _Traits>
 basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& _Ostr, const char* _Val) {
     // insert NTBS into char stream
     using _Elem = char;
@@ -802,7 +802,7 @@ basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& _Ostr, co
     return _Ostr;
 }
 
-template <class _Traits>
+_EXPORT_STD template <class _Traits>
 basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& _Ostr, char _Ch) {
     // insert a char into char stream
     using _Elem = char;
@@ -840,7 +840,7 @@ basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& _Ostr, ch
     return _Ostr;
 }
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, const _Elem* _Val) { // insert NTCS
     using _Myos = basic_ostream<_Elem, _Traits>;
 
@@ -883,7 +883,7 @@ basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
     return _Ostr;
 }
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, _Elem _Ch) { // insert a character
     using _Myos = basic_ostream<_Elem, _Traits>;
 
@@ -919,24 +919,24 @@ basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
     return _Ostr;
 }
 
-template <class _Traits>
+_EXPORT_STD template <class _Traits>
 basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& _Ostr, const signed char* _Val) {
     // insert a signed char NTBS
     return _Ostr << reinterpret_cast<const char*>(_Val);
 }
 
-template <class _Traits>
+_EXPORT_STD template <class _Traits>
 basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& _Ostr, signed char _Ch) { // insert a signed char
     return _Ostr << static_cast<char>(_Ch);
 }
 
-template <class _Traits>
+_EXPORT_STD template <class _Traits>
 basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& _Ostr, const unsigned char* _Val) {
     // insert an unsigned char NTBS
     return _Ostr << reinterpret_cast<const char*>(_Val);
 }
 
-template <class _Traits>
+_EXPORT_STD template <class _Traits>
 basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& _Ostr, unsigned char _Ch) {
     // insert an unsigned char
     return _Ostr << static_cast<char>(_Ch);
@@ -944,45 +944,45 @@ basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& _Ostr, un
 
 #ifdef __cpp_char8_t // These deleted overloads are specified in P1423.
 // don't insert a UTF-8 NTBS
-template <class _Traits>
+_EXPORT_STD template <class _Traits>
 basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char8_t*) = delete;
-template <class _Traits>
+_EXPORT_STD template <class _Traits>
 basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char8_t*) = delete;
 
 // don't insert a UTF-8 code unit
-template <class _Traits>
+_EXPORT_STD template <class _Traits>
 basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char8_t) = delete;
-template <class _Traits>
+_EXPORT_STD template <class _Traits>
 basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char8_t) = delete;
 #endif // __cpp_char8_t
 
 #if !_HAS_STREAM_INSERTION_OPERATORS_DELETED_IN_CXX20
 #ifdef _NATIVE_WCHAR_T_DEFINED
-template <class _Traits>
+_EXPORT_STD template <class _Traits>
 basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, wchar_t) = delete;
 
-template <class _Traits>
+_EXPORT_STD template <class _Traits>
 basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const wchar_t*) = delete;
 #endif // _NATIVE_WCHAR_T_DEFINED
 
-template <class _Traits>
+_EXPORT_STD template <class _Traits>
 basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char16_t) = delete;
-template <class _Traits>
+_EXPORT_STD template <class _Traits>
 basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char32_t) = delete;
 
-template <class _Traits>
+_EXPORT_STD template <class _Traits>
 basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char16_t) = delete;
-template <class _Traits>
+_EXPORT_STD template <class _Traits>
 basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char32_t) = delete;
 
-template <class _Traits>
+_EXPORT_STD template <class _Traits>
 basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char16_t*) = delete;
-template <class _Traits>
+_EXPORT_STD template <class _Traits>
 basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char32_t*) = delete;
 
-template <class _Traits>
+_EXPORT_STD template <class _Traits>
 basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char16_t*) = delete;
-template <class _Traits>
+_EXPORT_STD template <class _Traits>
 basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char32_t*) = delete;
 #endif // !_HAS_STREAM_INSERTION_OPERATORS_DELETED_IN_CXX20
 
@@ -993,14 +993,14 @@ template <class _Ostr, class _Ty>
 struct _Can_stream_out<_Ostr, _Ty, void_t<decltype(_STD declval<_Ostr&>() << _STD declval<const _Ty&>())>> : true_type {
 };
 
-template <class _Ostr, class _Ty,
+_EXPORT_STD template <class _Ostr, class _Ty,
     enable_if_t<conjunction_v<is_convertible<_Ostr*, ios_base*>, _Can_stream_out<_Ostr, _Ty>>, int> = 0>
 _Ostr&& operator<<(_Ostr&& _Os, const _Ty& _Val) { // insert to rvalue stream
     _Os << _Val;
     return _STD move(_Os);
 }
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 basic_ostream<_Elem, _Traits>& __CLRCALL_OR_CDECL endl(
     basic_ostream<_Elem, _Traits>& _Ostr) { // insert newline and flush stream
     _Ostr.put(_Ostr.widen('\n'));
@@ -1008,13 +1008,13 @@ basic_ostream<_Elem, _Traits>& __CLRCALL_OR_CDECL endl(
     return _Ostr;
 }
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 basic_ostream<_Elem, _Traits>& __CLRCALL_OR_CDECL ends(basic_ostream<_Elem, _Traits>& _Ostr) { // insert null character
     _Ostr.put(_Elem());
     return _Ostr;
 }
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 basic_ostream<_Elem, _Traits>& __CLRCALL_OR_CDECL flush(basic_ostream<_Elem, _Traits>& _Ostr) { // flush stream
     _Ostr.flush();
     return _Ostr;
@@ -1022,7 +1022,7 @@ basic_ostream<_Elem, _Traits>& __CLRCALL_OR_CDECL flush(basic_ostream<_Elem, _Tr
 
 #if _HAS_CXX20
 #ifdef _CPPRTTI
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 basic_ostream<_Elem, _Traits>& emit_on_flush(basic_ostream<_Elem, _Traits>& _Ostr) {
     const auto _Sync_buf_ptr = dynamic_cast<_Basic_syncbuf_impl<_Elem, _Traits>*>(_Ostr.rdbuf());
     if (_Sync_buf_ptr) {
@@ -1031,7 +1031,7 @@ basic_ostream<_Elem, _Traits>& emit_on_flush(basic_ostream<_Elem, _Traits>& _Ost
     return _Ostr;
 }
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 basic_ostream<_Elem, _Traits>& noemit_on_flush(basic_ostream<_Elem, _Traits>& _Ostr) {
     const auto _Sync_buf_ptr = dynamic_cast<_Basic_syncbuf_impl<_Elem, _Traits>*>(_Ostr.rdbuf());
     if (_Sync_buf_ptr) {
@@ -1040,7 +1040,7 @@ basic_ostream<_Elem, _Traits>& noemit_on_flush(basic_ostream<_Elem, _Traits>& _O
     return _Ostr;
 }
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 basic_ostream<_Elem, _Traits>& flush_emit(basic_ostream<_Elem, _Traits>& _Ostr) {
     _Ostr.flush();
     const auto _Sync_buf_ptr = dynamic_cast<_Basic_syncbuf_impl<_Elem, _Traits>*>(_Ostr.rdbuf());
@@ -1062,16 +1062,16 @@ basic_ostream<_Elem, _Traits>& flush_emit(basic_ostream<_Elem, _Traits>& _Ostr)
     return _Ostr;
 }
 #else // _CPPRTTI
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 basic_ostream<_Elem, _Traits>& emit_on_flush(basic_ostream<_Elem, _Traits>&) = delete; // requires /GR option
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 basic_ostream<_Elem, _Traits>& noemit_on_flush(basic_ostream<_Elem, _Traits>&) = delete; // requires /GR option
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 basic_ostream<_Elem, _Traits>& flush_emit(basic_ostream<_Elem, _Traits>&) = delete; // requires /GR option
 #endif // _CPPRTTI
 #endif // _HAS_CXX20
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, const error_code& _Errcode) {
     // display error code
     return _Ostr << _Errcode.category().name() << ':' << _Errcode.value();
diff --git a/stl/inc/queue b/stl/inc/queue
index ffa2955de2..86abb4ee0e 100644
--- a/stl/inc/queue
+++ b/stl/inc/queue
@@ -24,7 +24,7 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-template <class _Ty, class _Container = deque<_Ty>>
+_EXPORT_STD template <class _Ty, class _Container = deque<_Ty>>
 class queue {
 public:
     using value_type      = typename _Container::value_type;
@@ -177,45 +177,45 @@ queue(from_range_t, _Rng&&, _Alloc = _Alloc())
 #endif // __cpp_lib_concepts
 #endif // _HAS_CXX23
 
-template <class _Ty, class _Container>
+_EXPORT_STD template <class _Ty, class _Container>
 _NODISCARD bool operator==(const queue<_Ty, _Container>& _Left, const queue<_Ty, _Container>& _Right) {
     return _Left._Get_container() == _Right._Get_container();
 }
 
-template <class _Ty, class _Container>
+_EXPORT_STD template <class _Ty, class _Container>
 _NODISCARD bool operator!=(const queue<_Ty, _Container>& _Left, const queue<_Ty, _Container>& _Right) {
     return _Left._Get_container() != _Right._Get_container();
 }
 
-template <class _Ty, class _Container>
+_EXPORT_STD template <class _Ty, class _Container>
 _NODISCARD bool operator<(const queue<_Ty, _Container>& _Left, const queue<_Ty, _Container>& _Right) {
     return _Left._Get_container() < _Right._Get_container();
 }
 
-template <class _Ty, class _Container>
+_EXPORT_STD template <class _Ty, class _Container>
 _NODISCARD bool operator>(const queue<_Ty, _Container>& _Left, const queue<_Ty, _Container>& _Right) {
     return _Left._Get_container() > _Right._Get_container();
 }
 
-template <class _Ty, class _Container>
+_EXPORT_STD template <class _Ty, class _Container>
 _NODISCARD bool operator<=(const queue<_Ty, _Container>& _Left, const queue<_Ty, _Container>& _Right) {
     return _Left._Get_container() <= _Right._Get_container();
 }
 
-template <class _Ty, class _Container>
+_EXPORT_STD template <class _Ty, class _Container>
 _NODISCARD bool operator>=(const queue<_Ty, _Container>& _Left, const queue<_Ty, _Container>& _Right) {
     return _Left._Get_container() >= _Right._Get_container();
 }
 
 #ifdef __cpp_lib_concepts
-template <class _Ty, three_way_comparable _Container>
+_EXPORT_STD template <class _Ty, three_way_comparable _Container>
 _NODISCARD compare_three_way_result_t<_Container> operator<=>(
     const queue<_Ty, _Container>& _Left, const queue<_Ty, _Container>& _Right) {
     return _Left._Get_container() <=> _Right._Get_container();
 }
 #endif // __cpp_lib_concepts
 
-template <class _Ty, class _Container, enable_if_t<_Is_swappable<_Container>::value, int> = 0>
+_EXPORT_STD template <class _Ty, class _Container, enable_if_t<_Is_swappable<_Container>::value, int> = 0>
 void swap(queue<_Ty, _Container>& _Left, queue<_Ty, _Container>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
     _Left.swap(_Right);
 }
@@ -223,7 +223,7 @@ void swap(queue<_Ty, _Container>& _Left, queue<_Ty, _Container>& _Right) noexcep
 template <class _Ty, class _Container, class _Alloc>
 struct uses_allocator<queue<_Ty, _Container>, _Alloc> : uses_allocator<_Container, _Alloc>::type {};
 
-template <class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>
+_EXPORT_STD template <class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>
 class priority_queue {
 public:
     using value_type      = typename _Container::value_type;
@@ -457,7 +457,7 @@ priority_queue(from_range_t, _Rng&&, _Alloc)
 #endif // _HAS_CXX23 && defined(__cpp_lib_concepts)
 #endif // _HAS_CXX17
 
-template <class _Ty, class _Container, class _Pr,
+_EXPORT_STD template <class _Ty, class _Container, class _Pr,
     enable_if_t<_Is_swappable<_Container>::value && _Is_swappable<_Pr>::value, int> = 0>
 void swap(priority_queue<_Ty, _Container, _Pr>& _Left, priority_queue<_Ty, _Container, _Pr>& _Right) noexcept(
     noexcept(_Left.swap(_Right))) {
diff --git a/stl/inc/random b/stl/inc/random
index 32be63fa7d..b1fa1bf8d3 100644
--- a/stl/inc/random
+++ b/stl/inc/random
@@ -65,9 +65,9 @@ _INLINE_VAR constexpr long double _Exp1  = 2.71828182845904523536028747135266250
 _INLINE_VAR constexpr long double _Two32 = 4294967296.0L;
 _INLINE_VAR constexpr long double _Two31 = 2147483648.0L;
 
-_CRTIMP2_PURE float __CLRCALL_PURE_OR_CDECL _XLgamma(float);
-_CRTIMP2_PURE double __CLRCALL_PURE_OR_CDECL _XLgamma(double);
-_CRTIMP2_PURE long double __CLRCALL_PURE_OR_CDECL _XLgamma(long double);
+extern "C++" _CRTIMP2_PURE float __CLRCALL_PURE_OR_CDECL _XLgamma(float);
+extern "C++" _CRTIMP2_PURE double __CLRCALL_PURE_OR_CDECL _XLgamma(double);
+extern "C++" _CRTIMP2_PURE long double __CLRCALL_PURE_OR_CDECL _XLgamma(long double);
 
 _INLINE_VAR constexpr int _Nwords = 4;
 
@@ -147,7 +147,7 @@ private:
     basic_istream<_Elem, _Traits>& _Str;
 };
 
-class seed_seq { // standard sequence of seed values
+_EXPORT_STD class seed_seq { // standard sequence of seed values
 public:
     using result_type = unsigned int;
 
@@ -268,7 +268,7 @@ _NODISCARD constexpr int _Generate_canonical_iterations(const int _Bits, const u
     return _Ceil;
 }
 
-template <class _Real, size_t _Bits, class _Gen>
+_EXPORT_STD template <class _Real, size_t _Bits, class _Gen>
 _NODISCARD _Real generate_canonical(_Gen& _Gx) { // build a floating-point value from random sequence
     _RNG_REQUIRE_REALTYPE(generate_canonical, _Real);
 
@@ -335,10 +335,10 @@ _NODISCARD _Real _Nrand_impl(_Gen& _Gx) { // build a floating-point value from r
 _INLINE_VAR constexpr int _MP_len = 5;
 using _MP_arr                     = uint64_t[_MP_len];
 
-_NODISCARD _CRTIMP2_PURE uint64_t __CLRCALL_PURE_OR_CDECL _MP_Get(_MP_arr) noexcept;
-_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _MP_Add(_MP_arr, uint64_t) noexcept;
-_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _MP_Mul(_MP_arr, uint64_t, uint64_t) noexcept;
-_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _MP_Rem(_MP_arr, uint64_t) noexcept;
+extern "C++" _NODISCARD _CRTIMP2_PURE uint64_t __CLRCALL_PURE_OR_CDECL _MP_Get(_MP_arr) noexcept;
+extern "C++" _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _MP_Add(_MP_arr, uint64_t) noexcept;
+extern "C++" _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _MP_Mul(_MP_arr, uint64_t, uint64_t) noexcept;
+extern "C++" _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _MP_Rem(_MP_arr, uint64_t) noexcept;
 
 template <class _Uint, _Uint _Ax, _Uint _Cx, _Uint _Mx>
 _NODISCARD _Uint _Next_linear_congruential_value(_Uint _Prev) noexcept {
@@ -427,7 +427,7 @@ _NODISCARD _Uint _Get_linear_congruential_seed_from_seq(_Seed_seq& _Seq) { // N4
     return _Get_linear_congruential_seed<_Uint, _Cx, _Mx>(_Sx);
 }
 
-template <class _Uint, _Uint _Ax, _Uint _Cx, _Uint _Mx>
+_EXPORT_STD template <class _Uint, _Uint _Ax, _Uint _Cx, _Uint _Mx>
 class linear_congruential_engine { // a linear congruential generator random engine
 public:
     _RNG_REQUIRE_UINTTYPE(linear_congruential_engine, _Uint);
@@ -894,7 +894,7 @@ public:
     subtract_with_carry(_Gen& _Gx) : _Mybase(_Gx) {}
 };
 
-template <class _Ty, size_t _Wx, size_t _Sx, size_t _Rx>
+_EXPORT_STD template <class _Ty, size_t _Wx, size_t _Sx, size_t _Rx>
 class subtract_with_carry_engine : public subtract_with_carry<_Ty, (_Ty{1} << (_Wx - 1)) << 1, _Sx, _Rx> {
     // subtract_with_carry generator
 public:
@@ -1254,8 +1254,8 @@ protected:
     static constexpr int _M_mod_n   = _Mx % _Nx;
 };
 
-template <class _Ty, size_t _Wx, size_t _Nx, size_t _Mx, size_t _Rx, _Ty _Px, size_t _Ux, _Ty _Dx, size_t _Sx, _Ty _Bx,
-    size_t _Tx, _Ty _Cx, size_t _Lx, _Ty _Fx>
+_EXPORT_STD template <class _Ty, size_t _Wx, size_t _Nx, size_t _Mx, size_t _Rx, _Ty _Px, size_t _Ux, _Ty _Dx,
+    size_t _Sx, _Ty _Bx, size_t _Tx, _Ty _Cx, size_t _Lx, _Ty _Fx>
 class mersenne_twister_engine : public mersenne_twister<_Ty, _Wx, _Nx, _Mx, _Rx, _Px, _Ux, _Sx, _Bx, _Tx, _Cx, _Lx> {
 public:
     static constexpr unsigned long long _Max = (((1ULL << (_Wx - 1)) - 1) << 1) + 1;
@@ -1429,7 +1429,7 @@ private:
     int _Nx;
 };
 
-template <class _Engine, size_t _Px, size_t _Rx>
+_EXPORT_STD template <class _Engine, size_t _Px, size_t _Rx>
 class discard_block_engine : public discard_block<_Engine, _Px, _Rx> { // discard_block_engine compound engine
 public:
     static_assert(0 < _Rx && _Rx <= _Px, "invalid template argument for discard_block_engine");
@@ -1457,7 +1457,7 @@ public:
     }
 };
 
-template <class _Engine, size_t _Wx, class _UIntType>
+_EXPORT_STD template <class _Engine, size_t _Wx, class _UIntType>
 class independent_bits_engine { // independent_bits_engine compound engine
 public:
     _RNG_REQUIRE_UINTTYPE(independent_bits_engine, _UIntType);
@@ -1608,7 +1608,7 @@ private:
     _Eres _Yx1; // max value for larger packing word
 };
 
-template <class _Engine, size_t _Kx>
+_EXPORT_STD template <class _Engine, size_t _Kx>
 class shuffle_order_engine { // shuffle_order_engine compound engine
 public:
     static_assert(0 < _Kx, "invalid template argument for shuffle_order_engine");
@@ -1877,7 +1877,7 @@ private:
     param_type _Par;
 };
 
-template <class _Ty = int>
+_EXPORT_STD template <class _Ty = int>
 class uniform_int_distribution : public uniform_int<_Ty> { // uniform integer distribution
 public:
     _RNG_REQUIRE_INTTYPE(uniform_int_distribution, _Ty);
@@ -1914,7 +1914,7 @@ public:
 #endif // !_HAS_CXX20
 };
 
-class bernoulli_distribution { // class for bernoulli distribution
+_EXPORT_STD class bernoulli_distribution { // class for bernoulli distribution
 public:
     using result_type = bool;
 
@@ -2063,7 +2063,7 @@ _NODISCARD _Flt _Float_upper_bound(_Ty _Val) {
     }
 }
 
-template <class _Ty = int>
+_EXPORT_STD template <class _Ty = int>
 class geometric_distribution { // geometric distribution
 public:
     using _Ty1 = double;
@@ -2212,7 +2212,7 @@ private:
     _Ty1 _Gx0;
 };
 
-template <class _Ty = int>
+_EXPORT_STD template <class _Ty = int>
 class poisson_distribution { // poisson distribution
 public:
     using _Ty1 = double;
@@ -2360,7 +2360,7 @@ private:
     param_type _Par;
 };
 
-template <class _Ty = int>
+_EXPORT_STD template <class _Ty = int>
 class binomial_distribution { // binomial distribution
 public:
     using _Ty1 = double;
@@ -2683,7 +2683,7 @@ private:
     param_type _Par;
 };
 
-template <class _Ty = double>
+_EXPORT_STD template <class _Ty = double>
 class uniform_real_distribution : public uniform_real<_Ty> { // uniform real distribution
 public:
     _RNG_REQUIRE_REALTYPE(uniform_real_distribution, _Ty);
@@ -2719,7 +2719,7 @@ public:
 #endif // !_HAS_CXX20
 };
 
-template <class _Ty = double>
+_EXPORT_STD template <class _Ty = double>
 class exponential_distribution { // exponential distribution
 public:
     _RNG_REQUIRE_REALTYPE(exponential_distribution, _Ty);
@@ -2832,7 +2832,7 @@ private:
     param_type _Par;
 };
 
-template <class _Ty = double>
+_EXPORT_STD template <class _Ty = double>
 class normal_distribution { // normal distribution
 public:
     _RNG_REQUIRE_REALTYPE(normal_distribution, _Ty);
@@ -3020,7 +3020,7 @@ private:
     _Ty _Xx2;
 };
 
-template <class _Ty = double>
+_EXPORT_STD template <class _Ty = double>
 class gamma_distribution { // gamma distribution
 public:
     _RNG_REQUIRE_REALTYPE(gamma_distribution, _Ty);
@@ -3207,7 +3207,7 @@ private:
     param_type _Par;
 };
 
-template <class _Ty = double>
+_EXPORT_STD template <class _Ty = double>
 class weibull_distribution { // weibull distribution
 public:
     _RNG_REQUIRE_REALTYPE(weibull_distribution, _Ty);
@@ -3335,7 +3335,7 @@ private:
     param_type _Par;
 };
 
-template <class _Ty = double>
+_EXPORT_STD template <class _Ty = double>
 class extreme_value_distribution { // extreme value distribution
 public:
     _RNG_REQUIRE_REALTYPE(extreme_value_distribution, _Ty);
@@ -3464,7 +3464,7 @@ private:
     param_type _Par;
 };
 
-template <class _Ty = double>
+_EXPORT_STD template <class _Ty = double>
 class lognormal_distribution { // lognormal_distribution
 public:
     _RNG_REQUIRE_REALTYPE(lognormal_distribution, _Ty);
@@ -3591,7 +3591,7 @@ private:
     param_type _Par;
 };
 
-template <class _Ty = double>
+_EXPORT_STD template <class _Ty = double>
 class chi_squared_distribution { // chi squared distribution
 public:
     _RNG_REQUIRE_REALTYPE(chi_squared_distribution, _Ty);
@@ -3704,7 +3704,7 @@ private:
     param_type _Par;
 };
 
-template <class _Ty = double>
+_EXPORT_STD template <class _Ty = double>
 class cauchy_distribution { // Cauchy distribution
 public:
     _RNG_REQUIRE_REALTYPE(cauchy_distribution, _Ty);
@@ -3890,7 +3890,7 @@ private:
     _Ty _Bx;
 };
 
-template <class _Ty = double>
+_EXPORT_STD template <class _Ty = double>
 class fisher_f_distribution { // fisher_f distribution
 public:
     _RNG_REQUIRE_REALTYPE(fisher_f_distribution, _Ty);
@@ -4029,7 +4029,7 @@ private:
     param_type _Par;
 };
 
-template <class _Ty = double>
+_EXPORT_STD template <class _Ty = double>
 class student_t_distribution { // student_t distribution
 public:
     _RNG_REQUIRE_REALTYPE(student_t_distribution, _Ty);
@@ -4157,7 +4157,7 @@ private:
     param_type _Par;
 };
 
-template <class _Ty = int>
+_EXPORT_STD template <class _Ty = int>
 class negative_binomial_distribution { // negative binomial distribution
 public:
     _RNG_REQUIRE_INTTYPE(negative_binomial_distribution, _Ty);
@@ -4292,7 +4292,7 @@ private:
     param_type _Par;
 };
 
-template <class _Ty = int>
+_EXPORT_STD template <class _Ty = int>
 class discrete_distribution { // discrete integer distribution
 public:
     _RNG_REQUIRE_INTTYPE(discrete_distribution, _Ty);
@@ -4487,7 +4487,7 @@ public:
     param_type _Par;
 };
 
-template <class _Ty = double>
+_EXPORT_STD template <class _Ty = double>
 class piecewise_constant_distribution
     : public discrete_distribution<size_t> { // piecewise constant floating-point distribution
     // TRANSITION: unused _Mypbase subobject from base class
@@ -4673,7 +4673,7 @@ public:
     param_type _Par;
 };
 
-template <class _Ty = double>
+_EXPORT_STD template <class _Ty = double>
 class piecewise_linear_distribution
     : public discrete_distribution<size_t> { // piecewise linear floating-point distribution
     // TRANSITION: unused _Mypbase subobject from base class
@@ -4904,11 +4904,11 @@ public:
     param_type _Par;
 };
 
-using minstd_rand0 = linear_congruential_engine<unsigned int, 16807, 0, 2147483647>;
-using minstd_rand  = linear_congruential_engine<unsigned int, 48271, 0, 2147483647>;
+_EXPORT_STD using minstd_rand0 = linear_congruential_engine<unsigned int, 16807, 0, 2147483647>;
+_EXPORT_STD using minstd_rand  = linear_congruential_engine<unsigned int, 48271, 0, 2147483647>;
 
-using mt19937 = mersenne_twister_engine<unsigned int, 32, 624, 397, 31, 0x9908b0df, 11, 0xffffffff, 7, 0x9d2c5680, 15,
-    0xefc60000, 18, 1812433253>;
+_EXPORT_STD using mt19937 = mersenne_twister_engine<unsigned int, 32, 624, 397, 31, 0x9908b0df, 11, 0xffffffff, 7,
+    0x9d2c5680, 15, 0xefc60000, 18, 1812433253>;
 
 #if _HAS_TR1_NAMESPACE
 _STL_DISABLE_DEPRECATED_WARNING
@@ -4923,21 +4923,21 @@ using ranlux4_01 _DEPRECATE_TR1_NAMESPACE       = discard_block<ranlux_base_01,
 _STL_RESTORE_DEPRECATED_WARNING
 #endif // _HAS_TR1_NAMESPACE
 
-using mt19937_64 = mersenne_twister_engine<unsigned long long, 64, 312, 156, 31, 0xb5026f5aa96619e9ULL, 29,
+_EXPORT_STD using mt19937_64 = mersenne_twister_engine<unsigned long long, 64, 312, 156, 31, 0xb5026f5aa96619e9ULL, 29,
     0x5555555555555555ULL, 17, 0x71d67fffeda60000ULL, 37, 0xfff7eee000000000ULL, 43, 6364136223846793005ULL>;
 
-using ranlux24_base = subtract_with_carry_engine<unsigned int, 24, 10, 24>;
-using ranlux48_base = subtract_with_carry_engine<unsigned long long, 48, 5, 12>;
-using ranlux24      = discard_block_engine<ranlux24_base, 223, 23>;
-using ranlux48      = discard_block_engine<ranlux48_base, 389, 11>;
-using knuth_b       = shuffle_order_engine<minstd_rand0, 256>;
+_EXPORT_STD using ranlux24_base = subtract_with_carry_engine<unsigned int, 24, 10, 24>;
+_EXPORT_STD using ranlux48_base = subtract_with_carry_engine<unsigned long long, 48, 5, 12>;
+_EXPORT_STD using ranlux24      = discard_block_engine<ranlux24_base, 223, 23>;
+_EXPORT_STD using ranlux48      = discard_block_engine<ranlux48_base, 389, 11>;
+_EXPORT_STD using knuth_b       = shuffle_order_engine<minstd_rand0, 256>;
 
-using default_random_engine = mt19937;
+_EXPORT_STD using default_random_engine = mt19937;
 
 
-_CRTIMP2_PURE unsigned int __CLRCALL_PURE_OR_CDECL _Random_device();
+extern "C++" _CRTIMP2_PURE unsigned int __CLRCALL_PURE_OR_CDECL _Random_device();
 
-class random_device { // class to generate random numbers (from hardware where available)
+_EXPORT_STD class random_device { // class to generate random numbers (from hardware where available)
 public:
     using result_type = unsigned int;
 
diff --git a/stl/inc/ranges b/stl/inc/ranges
index 9e9b9b1c6f..d922bbae01 100644
--- a/stl/inc/ranges
+++ b/stl/inc/ranges
@@ -34,7 +34,7 @@ namespace ranges {
     inline constexpr bool _Is_initializer_list = _Is_specialization_v<remove_cvref_t<_Ty>, initializer_list>;
 
     // clang-format off
-    template <class _Rng>
+    _EXPORT_STD template <class _Rng>
     concept viewable_range = range<_Rng>
         && ((view<remove_cvref_t<_Rng>> && constructible_from<remove_cvref_t<_Rng>, _Rng>)
             || (!view<remove_cvref_t<_Rng>>
@@ -123,7 +123,7 @@ namespace ranges {
         template <class _Ty1, class _Ty2>
         _Pipeline(_Ty1, _Ty2) -> _Pipeline<_Ty1, _Ty2>;
 
-        template <class _Left, class _Right>
+        _EXPORT_STD template <class _Left, class _Right>
         requires _Range_adaptor_closure_object<_Left> //
             && _Range_adaptor_closure_object<_Right> //
             && constructible_from<remove_cvref_t<_Left>, _Left> //
@@ -133,7 +133,7 @@ namespace ranges {
             return _Pipeline{static_cast<_Left&&>(__l), static_cast<_Right&&>(__r)};
         }
 
-        template <class _Left, class _Right>
+        _EXPORT_STD template <class _Left, class _Right>
         requires _Range_adaptor_closure_object<_Right> && range<_Left> //
             _NODISCARD constexpr auto operator|(_Left&& __l, _Right&& __r) noexcept(
                 noexcept(_STD forward<_Right>(__r)(_STD forward<_Left>(__l)))) //
@@ -795,7 +795,7 @@ namespace ranges {
     };
 
 #if _HAS_CXX23
-    template <class _Derived>
+    _EXPORT_STD template <class _Derived>
         requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
     class range_adaptor_closure : public _Pipe::_Base<_Derived> {
     };
@@ -867,7 +867,7 @@ namespace ranges {
         tuple<_Types...> _Captures;
     };
 
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
         requires is_object_v<_Ty>
     class empty_view : public view_interface<empty_view<_Ty>> {
     public:
@@ -896,11 +896,11 @@ namespace ranges {
     inline constexpr bool enable_borrowed_range<empty_view<_Ty>> = true;
 
     namespace views {
-        template <class _Ty>
+        _EXPORT_STD template <class _Ty>
         inline constexpr empty_view<_Ty> empty;
     } // namespace views
 
-    template <_Valid_movable_box_object _Ty>
+    _EXPORT_STD template <_Valid_movable_box_object _Ty>
     class single_view : public view_interface<single_view<_Ty>> {
     public:
         // clang-format off
@@ -964,7 +964,7 @@ namespace ranges {
             // clang-format on
         };
 
-        inline constexpr _Single_fn single;
+        _EXPORT_STD inline constexpr _Single_fn single;
     } // namespace views
 
     template <class _Ty>
@@ -1224,7 +1224,7 @@ namespace ranges {
         }
     };
 
-    template <weakly_incrementable _Wi, semiregular _Bo = unreachable_sentinel_t>
+    _EXPORT_STD template <weakly_incrementable _Wi, semiregular _Bo = unreachable_sentinel_t>
         requires _Weakly_equality_comparable_with<_Wi, _Bo> && copyable<_Wi>
     class iota_view : public view_interface<iota_view<_Wi, _Bo>> {
     private:
@@ -1327,7 +1327,7 @@ namespace ranges {
             { return iota_view(static_cast<_Ty1&&>(_Val1), static_cast<_Ty2&&>(_Val2)); }
         };
 
-        inline constexpr _Iota_fn iota;
+        _EXPORT_STD inline constexpr _Iota_fn iota;
     } // namespace views
 
     template <class _Ty, class _Elem, class _Traits>
@@ -1335,7 +1335,7 @@ namespace ranges {
         __is >> __t;
     };
 
-    template <movable _Ty, class _Elem, class _Traits = char_traits<_Elem>>
+    _EXPORT_STD template <movable _Ty, class _Elem, class _Traits = char_traits<_Elem>>
         requires default_initializable<_Ty> && _Stream_extractable<_Ty, _Elem, _Traits>
     class basic_istream_view : public view_interface<basic_istream_view<_Ty, _Elem, _Traits>> {
     private:
@@ -1406,9 +1406,9 @@ namespace ranges {
         }
     };
 
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     using istream_view = basic_istream_view<_Ty, char>;
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     using wistream_view = basic_istream_view<_Ty, wchar_t>;
 
     namespace views {
@@ -1425,11 +1425,11 @@ namespace ranges {
             }
         };
 
-        template <class _Ty>
+        _EXPORT_STD template <class _Ty>
         inline constexpr _Istream_fn<_Ty> istream;
     } // namespace views
 
-    template <range _Rng>
+    _EXPORT_STD template <range _Rng>
         requires is_object_v<_Rng>
     class ref_view : public view_interface<ref_view<_Rng>> {
     private:
@@ -1484,7 +1484,7 @@ namespace ranges {
     inline constexpr bool enable_borrowed_range<ref_view<_Rng>> = true;
 
     // clang-format off
-    template <range _Rng>
+    _EXPORT_STD template <range _Rng>
         requires (movable<_Rng> && !_Is_initializer_list<_Rng>)
     class owning_view : public view_interface<owning_view<_Rng>> {
         // clang-format on
@@ -1617,14 +1617,14 @@ namespace ranges {
             }
         };
 
-        inline constexpr _All_fn all;
+        _EXPORT_STD inline constexpr _All_fn all;
 
-        template <viewable_range _Rng>
+        _EXPORT_STD template <viewable_range _Rng>
         using all_t = decltype(all(_STD declval<_Rng>()));
     } // namespace views
 
 #if _HAS_CXX23
-    template <input_range _Vw>
+    _EXPORT_STD template <input_range _Vw>
         requires view<_Vw>
     class as_rvalue_view : public view_interface<as_rvalue_view<_Vw>> {
     private:
@@ -1737,11 +1737,11 @@ namespace ranges {
             }
         };
 
-        inline constexpr _As_rvalue_fn as_rvalue;
+        _EXPORT_STD inline constexpr _As_rvalue_fn as_rvalue;
     } // namespace views
 #endif // _HAS_CXX23
 
-    template <input_range _Vw, indirect_unary_predicate<iterator_t<_Vw>> _Pr>
+    _EXPORT_STD template <input_range _Vw, indirect_unary_predicate<iterator_t<_Vw>> _Pr>
         requires view<_Vw> && is_object_v<_Pr>
     class filter_view : public _Cached_position_t<forward_range<_Vw>, _Vw, filter_view<_Vw, _Pr>> {
     private:
@@ -1991,7 +1991,7 @@ namespace ranges {
             }
         };
 
-        inline constexpr _Filter_fn filter;
+        _EXPORT_STD inline constexpr _Filter_fn filter;
     } // namespace views
 
     // clang-format off
@@ -2004,7 +2004,7 @@ namespace ranges {
 #define _NOEXCEPT_IDL0(...)
 #endif // _ITERATOR_DEBUG_LEVEL == 0
 
-    template <input_range _Vw, _Valid_movable_box_object _Fn>
+    _EXPORT_STD template <input_range _Vw, _Valid_movable_box_object _Fn>
         requires view<_Vw>
             && regular_invocable<_Fn&, range_reference_t<_Vw>>
             && _Can_reference<invoke_result_t<_Fn&, range_reference_t<_Vw>>>
@@ -2444,10 +2444,10 @@ namespace ranges {
             }
         };
 
-        inline constexpr _Transform_fn transform;
+        _EXPORT_STD inline constexpr _Transform_fn transform;
     } // namespace views
 
-    template <view _Vw>
+    _EXPORT_STD template <view _Vw>
     class take_view : public view_interface<take_view<_Vw>> {
     private:
         /* [[no_unique_address]] */ _Vw _Range{};
@@ -2701,10 +2701,10 @@ namespace ranges {
             }
         };
 
-        inline constexpr _Take_fn take;
+        _EXPORT_STD inline constexpr _Take_fn take;
     } // namespace views
 
-    template <view _Vw, class _Pr>
+    _EXPORT_STD template <view _Vw, class _Pr>
         requires input_range<_Vw> && is_object_v<_Pr> && indirect_unary_predicate<const _Pr, iterator_t<_Vw>>
     class take_while_view : public view_interface<take_while_view<_Vw, _Pr>> {
     private:
@@ -2870,10 +2870,10 @@ namespace ranges {
             }
         };
 
-        inline constexpr _Take_while_fn take_while;
+        _EXPORT_STD inline constexpr _Take_while_fn take_while;
     } // namespace views
 
-    template <view _Vw>
+    _EXPORT_STD template <view _Vw>
     class drop_view : public _Cached_position_t<forward_range<_Vw> && !(random_access_range<_Vw> && sized_range<_Vw>),
                           _Vw, drop_view<_Vw>> {
     private:
@@ -3073,10 +3073,10 @@ namespace ranges {
             }
         };
 
-        inline constexpr _Drop_fn drop;
+        _EXPORT_STD inline constexpr _Drop_fn drop;
     } // namespace views
 
-    template <view _Vw, class _Pr>
+    _EXPORT_STD template <view _Vw, class _Pr>
         requires input_range<_Vw> && is_object_v<_Pr> && indirect_unary_predicate<const _Pr, iterator_t<_Vw>>
     class drop_while_view : public _Cached_position_t<forward_range<_Vw>, _Vw, drop_while_view<_Vw, _Pr>> {
     private:
@@ -3156,10 +3156,10 @@ namespace ranges {
             }
         };
 
-        inline constexpr _Drop_while_fn drop_while;
+        _EXPORT_STD inline constexpr _Drop_while_fn drop_while;
     } // namespace views
 
-    template <input_range _Vw>
+    _EXPORT_STD template <input_range _Vw>
         requires view<_Vw> && input_range<range_reference_t<_Vw>>
     class join_view;
 
@@ -3187,7 +3187,7 @@ namespace ranges {
         requires is_reference_v<range_reference_t<_Vw>>
     class _Join_view_base<_Vw> : public view_interface<join_view<_Vw>> {};
 
-    template <input_range _Vw>
+    _EXPORT_STD template <input_range _Vw>
         requires view<_Vw> && input_range<range_reference_t<_Vw>>
     class join_view : public _Join_view_base<_Vw> {
         // clang-format on
@@ -3547,7 +3547,7 @@ namespace ranges {
             }
         };
 
-        inline constexpr _Join_fn join;
+        _EXPORT_STD inline constexpr _Join_fn join;
     } // namespace views
 
 #if _HAS_CXX23
@@ -3560,7 +3560,7 @@ namespace ranges {
     concept _Can_const_join_with =
         input_range<const _Rng> && forward_range<const _Pat> && is_reference_v<range_reference_t<const _Rng>>;
 
-    template <input_range _Vw, forward_range _Pat>
+    _EXPORT_STD template <input_range _Vw, forward_range _Pat>
         requires view<_Vw> && input_range<range_reference_t<_Vw>> && view<_Pat> //
             && _Compatible_joinable_ranges<range_reference_t<_Vw>, _Pat>
     class join_with_view;
@@ -3586,7 +3586,7 @@ namespace ranges {
     class _Join_with_view_base<_Vw, _Pat> : public view_interface<join_with_view<_Vw, _Pat>> {
     };
 
-    template <input_range _Vw, forward_range _Pat>
+    _EXPORT_STD template <input_range _Vw, forward_range _Pat>
         requires view<_Vw> && input_range<range_reference_t<_Vw>> && view<_Pat> //
             && _Compatible_joinable_ranges<range_reference_t<_Vw>, _Pat>
     class join_with_view : public _Join_with_view_base<_Vw, _Pat> {
@@ -4019,7 +4019,7 @@ namespace ranges {
             }
         };
 
-        inline constexpr _Join_with_fn join_with;
+        _EXPORT_STD inline constexpr _Join_with_fn join_with;
     } // namespace views
 #endif // _HAS_CXX23
 
@@ -4032,7 +4032,7 @@ namespace ranges {
         && requires { typename _Require_constant<remove_reference_t<_Ty>::size()>; }
         && (remove_reference_t<_Ty>::size() <= 1);
 
-    template <input_range _Vw, forward_range _Pat>
+    _EXPORT_STD template <input_range _Vw, forward_range _Pat>
         requires (view<_Vw> && view<_Pat>
             && indirectly_comparable<iterator_t<_Vw>, iterator_t<_Pat>, _RANGES equal_to>
             && (forward_range<_Vw> || _Tiny_range<_Pat>))
@@ -4049,7 +4049,7 @@ namespace ranges {
     class _Lazy_split_view_base<_Vw, _Pat> : public view_interface<lazy_split_view<_Vw, _Pat>> {};
 
     // clang-format off
-    template <input_range _Vw, forward_range _Pat>
+    _EXPORT_STD template <input_range _Vw, forward_range _Pat>
         requires (view<_Vw> && view<_Pat>
             && indirectly_comparable<iterator_t<_Vw>, iterator_t<_Pat>, _RANGES equal_to>
             && (forward_range<_Vw> || _Tiny_range<_Pat>))
@@ -4437,10 +4437,10 @@ namespace ranges {
             }
         };
 
-        inline constexpr _Lazy_split_fn lazy_split;
+        _EXPORT_STD inline constexpr _Lazy_split_fn lazy_split;
     } // namespace views
 
-    template <forward_range _Vw, forward_range _Pat>
+    _EXPORT_STD template <forward_range _Vw, forward_range _Pat>
         requires view<_Vw> && view<_Pat> && indirectly_comparable<iterator_t<_Vw>, iterator_t<_Pat>, _RANGES equal_to>
     class split_view : public view_interface<split_view<_Vw, _Pat>> {
     private:
@@ -4636,7 +4636,7 @@ namespace ranges {
             }
         };
 
-        inline constexpr _Split_fn split;
+        _EXPORT_STD inline constexpr _Split_fn split;
 
         class _Counted_fn {
         private:
@@ -4684,11 +4684,11 @@ namespace ranges {
             }
         };
 
-        inline constexpr _Counted_fn counted;
+        _EXPORT_STD inline constexpr _Counted_fn counted;
     } // namespace views
 
     // clang-format off
-    template <view _Vw>
+    _EXPORT_STD template <view _Vw>
         requires (!common_range<_Vw> && copyable<iterator_t<_Vw>>)
     class common_view : public view_interface<common_view<_Vw>> {
         // clang-format on
@@ -4799,10 +4799,10 @@ namespace ranges {
             }
         };
 
-        inline constexpr _Common_fn common;
+        _EXPORT_STD inline constexpr _Common_fn common;
     } // namespace views
 
-    template <view _Vw>
+    _EXPORT_STD template <view _Vw>
         requires bidirectional_range<_Vw>
     class reverse_view : public _Cached_position_t<!common_range<_Vw>, _Vw, reverse_view<_Vw>> {
     private:
@@ -4948,7 +4948,7 @@ namespace ranges {
             }
         };
 
-        inline constexpr _Reverse_fn reverse;
+        _EXPORT_STD inline constexpr _Reverse_fn reverse;
     } // namespace views
 
     template <class _Tuple, size_t _Index>
@@ -4965,7 +4965,7 @@ namespace ranges {
     concept _Returnable_element = is_reference_v<_Tuple> || move_constructible<tuple_element_t<_Index, _Tuple>>;
 
     // clang-format off
-    template <input_range _Vw, size_t _Index>
+    _EXPORT_STD template <input_range _Vw, size_t _Index>
         requires view<_Vw> && _Has_tuple_element<range_value_t<_Vw>, _Index>
             && _Has_tuple_element<remove_reference_t<range_reference_t<_Vw>>, _Index>
             && _Returnable_element<range_reference_t<_Vw>, _Index>
@@ -5332,9 +5332,9 @@ namespace ranges {
     template <class _Rng, size_t _Index>
     inline constexpr bool enable_borrowed_range<elements_view<_Rng, _Index>> = enable_borrowed_range<_Rng>;
 
-    template <class _Rng>
+    _EXPORT_STD template <class _Rng>
     using keys_view = elements_view<_Rng, 0>;
-    template <class _Rng>
+    _EXPORT_STD template <class _Rng>
     using values_view = elements_view<_Rng, 1>;
 
     namespace views {
@@ -5349,10 +5349,10 @@ namespace ranges {
             { return elements_view<views::all_t<_Rng>, _Index>{_STD forward<_Rng>(_Range)}; }
         };
 
-        template <size_t _Index>
+        _EXPORT_STD template <size_t _Index>
         inline constexpr _Elements_fn<_Index> elements;
-        inline constexpr auto keys   = elements<0>;
-        inline constexpr auto values = elements<1>;
+        _EXPORT_STD inline constexpr auto keys   = elements<0>;
+        _EXPORT_STD inline constexpr auto values = elements<1>;
     } // namespace views
 
 #if _HAS_CXX23
@@ -5365,7 +5365,7 @@ namespace ranges {
         return _Result;
     }
 
-    template <view _Vw>
+    _EXPORT_STD template <view _Vw>
         requires input_range<_Vw>
     class chunk_view : public view_interface<chunk_view<_Vw>> {
     private:
@@ -5916,7 +5916,7 @@ namespace ranges {
             }
         };
 
-        inline constexpr _Chunk_fn chunk;
+        _EXPORT_STD inline constexpr _Chunk_fn chunk;
     } // namespace views
 
     template <class _Vw>
@@ -5928,7 +5928,7 @@ namespace ranges {
     template <class _Vw>
     concept _Slide_caches_first = !_Slide_caches_nothing<_Vw> && !_Slide_caches_last<_Vw>;
 
-    template <forward_range _Vw>
+    _EXPORT_STD template <forward_range _Vw>
         requires view<_Vw>
     class slide_view : public _Cached_position_t<!_Slide_caches_nothing<_Vw>, _Vw, slide_view<_Vw>> {
     private:
@@ -6282,7 +6282,7 @@ namespace ranges {
             }
         };
 
-        inline constexpr _Slide_fn slide;
+        _EXPORT_STD inline constexpr _Slide_fn slide;
     } // namespace views
 
     template <class _Pr>
@@ -6305,7 +6305,7 @@ namespace ranges {
         _Pr& _Pred;
     };
 
-    template <forward_range _Vw, indirect_binary_predicate<iterator_t<_Vw>, iterator_t<_Vw>> _Pr>
+    _EXPORT_STD template <forward_range _Vw, indirect_binary_predicate<iterator_t<_Vw>, iterator_t<_Vw>> _Pr>
         requires view<_Vw> && is_object_v<_Pr>
     class chunk_by_view : public _Cached_position<_Vw, chunk_by_view<_Vw, _Pr>> {
     private:
@@ -6478,10 +6478,10 @@ namespace ranges {
             }
         };
 
-        inline constexpr _Chunk_by_fn chunk_by;
+        _EXPORT_STD inline constexpr _Chunk_by_fn chunk_by;
     } // namespace views
 
-    template <input_range _Vw>
+    _EXPORT_STD template <input_range _Vw>
         requires view<_Vw>
     class stride_view : public view_interface<stride_view<_Vw>> {
     private:
@@ -6839,7 +6839,7 @@ namespace ranges {
             }
         };
 
-        inline constexpr _Stride_fn stride;
+        _EXPORT_STD inline constexpr _Stride_fn stride;
     } // namespace views
 
 #ifdef __cpp_lib_ranges_to_container
@@ -6898,7 +6898,7 @@ namespace ranges {
     }
 
     // clang-format off
-    template <class _Container, input_range _Rng, class... _Types>
+    _EXPORT_STD template <class _Container, input_range _Rng, class... _Types>
         requires (!view<_Container>)
     _NODISCARD constexpr _Container to(_Rng&& _Range, _Types&&... _Args) {
         // clang-format on
@@ -6937,7 +6937,7 @@ namespace ranges {
     };
 
     // clang-format off
-    template <class _Container, class... _Types>
+    _EXPORT_STD template <class _Container, class... _Types>
         requires (!view<_Container>)
     _NODISCARD constexpr auto to(_Types&&... _Args) {
         return _Range_closure<_To_class_fn<_Container>, decay_t<_Types>...>{_STD forward<_Types>(_Args)...};
@@ -6976,7 +6976,7 @@ namespace ranges {
         }
     }
 
-    template <template <class...> class _Container, input_range _Rng, class... _Types,
+    _EXPORT_STD template <template <class...> class _Container, input_range _Rng, class... _Types,
         class _Deduced = remove_pointer_t<decltype(_To_helper<_Container, _Rng, _Types...>())>>
     _NODISCARD constexpr _Deduced to(_Rng&& _Range, _Types&&... _Args) {
         return _RANGES to<_Deduced>(_STD forward<_Rng>(_Range), _STD forward<_Types>(_Args)...);
@@ -6991,7 +6991,7 @@ namespace ranges {
         }
     };
 
-    template <template <class...> class _Container, class... _Types>
+    _EXPORT_STD template <template <class...> class _Container, class... _Types>
     _NODISCARD constexpr auto to(_Types&&... _Args) {
         return _Range_closure<_To_template_fn<_Container>, decay_t<_Types>...>{_STD forward<_Types>(_Args)...};
     }
@@ -6999,7 +6999,7 @@ namespace ranges {
 #endif // _HAS_CXX23
 } // namespace ranges
 
-namespace views = ranges::views;
+_EXPORT_STD namespace views = ranges::views;
 
 _STD_END
 
diff --git a/stl/inc/ratio b/stl/inc/ratio
index f35f7b21f5..bd53092f0b 100644
--- a/stl/inc/ratio
+++ b/stl/inc/ratio
@@ -64,7 +64,7 @@ _NODISCARD constexpr intmax_t _Gcd(intmax_t _Ax, intmax_t _Bx) noexcept {
     return _Ax;
 }
 
-template <intmax_t _Nx, intmax_t _Dx = 1>
+_EXPORT_STD template <intmax_t _Nx, intmax_t _Dx = 1>
 struct ratio { // holds the ratio of _Nx to _Dx
     static_assert(_Dx != 0, "zero denominator");
     static_assert(-INTMAX_MAX <= _Nx, "numerator too negative");
@@ -98,7 +98,7 @@ struct _Ratio_add { // add two ratios
         _Safe_mult<_Dx1, _Dx2 / _Gx>::value>::type;
 };
 
-template <class _Rx1, class _Rx2>
+_EXPORT_STD template <class _Rx1, class _Rx2>
 using ratio_add = typename _Ratio_add<_Rx1, _Rx2>::type;
 
 template <class _Rx1, class _Rx2>
@@ -111,7 +111,7 @@ struct _Ratio_subtract { // subtract two ratios
     using type = ratio_add<_Rx1, ratio<-_Nx2, _Dx2>>;
 };
 
-template <class _Rx1, class _Rx2>
+_EXPORT_STD template <class _Rx1, class _Rx2>
 using ratio_subtract = typename _Ratio_subtract<_Rx1, _Rx2>::type;
 
 template <class _Rx1, class _Rx2>
@@ -142,7 +142,7 @@ struct _Ratio_multiply_sfinae<_Rx1, _Rx2, _Sfinae,
     using type = ratio<_Ratio_multiply<_Rx1, _Rx2>::_Num::value, _Ratio_multiply<_Rx1, _Rx2>::_Den::value>;
 };
 
-template <class _Rx1, class _Rx2>
+_EXPORT_STD template <class _Rx1, class _Rx2>
 using ratio_multiply = typename _Ratio_multiply_sfinae<_Rx1, _Rx2, false>::type;
 
 template <class _Rx1, class _Rx2>
@@ -159,23 +159,23 @@ template <class _Rx1, class _Rx2, bool _Sfinae = true>
 using _Ratio_divide_sfinae =
     typename _Ratio_multiply_sfinae<_Rx1, typename _Ratio_divide<_Rx1, _Rx2>::_Rx2_inverse, _Sfinae>::type;
 
-template <class _Rx1, class _Rx2>
+_EXPORT_STD template <class _Rx1, class _Rx2>
 using ratio_divide = _Ratio_divide_sfinae<_Rx1, _Rx2, false>;
 
-template <class _Rx1, class _Rx2>
+_EXPORT_STD template <class _Rx1, class _Rx2>
 struct ratio_equal : bool_constant<_Rx1::num == _Rx2::num && _Rx1::den == _Rx2::den> { // tests if ratio == ratio
     static_assert(_Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_equal<R1, R2> requires R1 and R2 to be ratio<>s.");
 };
 
-template <class _Rx1, class _Rx2>
+_EXPORT_STD template <class _Rx1, class _Rx2>
 _INLINE_VAR constexpr bool ratio_equal_v = ratio_equal<_Rx1, _Rx2>::value;
 
-template <class _Rx1, class _Rx2>
+_EXPORT_STD template <class _Rx1, class _Rx2>
 struct ratio_not_equal : bool_constant<!ratio_equal_v<_Rx1, _Rx2>> { // tests if ratio != ratio
     static_assert(_Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_not_equal<R1, R2> requires R1 and R2 to be ratio<>s.");
 };
 
-template <class _Rx1, class _Rx2>
+_EXPORT_STD template <class _Rx1, class _Rx2>
 _INLINE_VAR constexpr bool ratio_not_equal_v = ratio_not_equal<_Rx1, _Rx2>::value;
 
 struct _Big_uint128 {
@@ -226,56 +226,56 @@ constexpr bool _Ratio_less(const int64_t _Nx1, const int64_t _Dx1, const int64_t
     return _Nx1 < _Nx2;
 }
 
-template <class _Rx1, class _Rx2>
+_EXPORT_STD template <class _Rx1, class _Rx2>
 struct ratio_less : bool_constant<_Ratio_less(_Rx1::num, _Rx1::den, _Rx2::num, _Rx2::den)> { // tests if ratio < ratio
     static_assert(_Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_less<R1, R2> requires R1 and R2 to be ratio<>s.");
 };
 
-template <class _Rx1, class _Rx2>
+_EXPORT_STD template <class _Rx1, class _Rx2>
 _INLINE_VAR constexpr bool ratio_less_v = ratio_less<_Rx1, _Rx2>::value;
 
-template <class _Rx1, class _Rx2>
+_EXPORT_STD template <class _Rx1, class _Rx2>
 struct ratio_less_equal : bool_constant<!ratio_less_v<_Rx2, _Rx1>> { // tests if ratio <= ratio
     static_assert(
         _Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_less_equal<R1, R2> requires R1 and R2 to be ratio<>s.");
 };
 
-template <class _Rx1, class _Rx2>
+_EXPORT_STD template <class _Rx1, class _Rx2>
 _INLINE_VAR constexpr bool ratio_less_equal_v = ratio_less_equal<_Rx1, _Rx2>::value;
 
-template <class _Rx1, class _Rx2>
+_EXPORT_STD template <class _Rx1, class _Rx2>
 struct ratio_greater : ratio_less<_Rx2, _Rx1>::type { // tests if ratio > ratio
     static_assert(_Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_greater<R1, R2> requires R1 and R2 to be ratio<>s.");
 };
 
-template <class _Rx1, class _Rx2>
+_EXPORT_STD template <class _Rx1, class _Rx2>
 _INLINE_VAR constexpr bool ratio_greater_v = ratio_greater<_Rx1, _Rx2>::value;
 
-template <class _Rx1, class _Rx2>
+_EXPORT_STD template <class _Rx1, class _Rx2>
 struct ratio_greater_equal : bool_constant<!ratio_less_v<_Rx1, _Rx2>> { // tests if ratio >= ratio
     static_assert(
         _Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_greater_equal<R1, R2> requires R1 and R2 to be ratio<>s.");
 };
 
-template <class _Rx1, class _Rx2>
+_EXPORT_STD template <class _Rx1, class _Rx2>
 _INLINE_VAR constexpr bool ratio_greater_equal_v = ratio_greater_equal<_Rx1, _Rx2>::value;
 
-using atto  = ratio<1, 1000000000000000000LL>;
-using femto = ratio<1, 1000000000000000LL>;
-using pico  = ratio<1, 1000000000000LL>;
-using nano  = ratio<1, 1000000000>;
-using micro = ratio<1, 1000000>;
-using milli = ratio<1, 1000>;
-using centi = ratio<1, 100>;
-using deci  = ratio<1, 10>;
-using deca  = ratio<10, 1>;
-using hecto = ratio<100, 1>;
-using kilo  = ratio<1000, 1>;
-using mega  = ratio<1000000, 1>;
-using giga  = ratio<1000000000, 1>;
-using tera  = ratio<1000000000000LL, 1>;
-using peta  = ratio<1000000000000000LL, 1>;
-using exa   = ratio<1000000000000000000LL, 1>;
+_EXPORT_STD using atto  = ratio<1, 1000000000000000000LL>;
+_EXPORT_STD using femto = ratio<1, 1000000000000000LL>;
+_EXPORT_STD using pico  = ratio<1, 1000000000000LL>;
+_EXPORT_STD using nano  = ratio<1, 1000000000>;
+_EXPORT_STD using micro = ratio<1, 1000000>;
+_EXPORT_STD using milli = ratio<1, 1000>;
+_EXPORT_STD using centi = ratio<1, 100>;
+_EXPORT_STD using deci  = ratio<1, 10>;
+_EXPORT_STD using deca  = ratio<10, 1>;
+_EXPORT_STD using hecto = ratio<100, 1>;
+_EXPORT_STD using kilo  = ratio<1000, 1>;
+_EXPORT_STD using mega  = ratio<1000000, 1>;
+_EXPORT_STD using giga  = ratio<1000000000, 1>;
+_EXPORT_STD using tera  = ratio<1000000000000LL, 1>;
+_EXPORT_STD using peta  = ratio<1000000000000000LL, 1>;
+_EXPORT_STD using exa   = ratio<1000000000000000000LL, 1>;
 _STD_END
 #pragma pop_macro("new")
 _STL_RESTORE_CLANG_WARNINGS
diff --git a/stl/inc/regex b/stl/inc/regex
index 5f22c4a31c..f5fb0c2ee4 100644
--- a/stl/inc/regex
+++ b/stl/inc/regex
@@ -101,7 +101,7 @@ enum _Meta_type { // meta character representations for parser
 
 namespace regex_constants {
     // constants used in regular expressions
-    enum syntax_option_type : int { // specify RE syntax rules
+    _EXPORT_STD enum syntax_option_type : int { // specify RE syntax rules
         ECMAScript = 0x01,
         basic      = 0x02,
         extended   = 0x04,
@@ -116,9 +116,9 @@ namespace regex_constants {
         collate  = 0x0800
     };
 
-    _BITMASK_OPS(syntax_option_type)
+    _BITMASK_OPS(_EXPORT_STD, syntax_option_type)
 
-    enum match_flag_type : int { // specify matching and formatting rules
+    _EXPORT_STD enum match_flag_type : int { // specify matching and formatting rules
         match_default     = 0x0000,
         match_not_bol     = 0x0001,
         match_not_eol     = 0x0002,
@@ -136,9 +136,9 @@ namespace regex_constants {
         _Skip_zero_length = 0x4000,
     };
 
-    _BITMASK_OPS(match_flag_type)
+    _BITMASK_OPS(_EXPORT_STD, match_flag_type)
 
-    enum error_type { // identify error
+    _EXPORT_STD enum error_type { // identify error
         error_collate,
         error_ctype,
         error_escape,
@@ -157,9 +157,9 @@ namespace regex_constants {
     };
 } // namespace regex_constants
 
-[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xregex_error(regex_constants::error_type _Code);
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xregex_error(regex_constants::error_type _Code);
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 class regex_traits;
 
 struct _Cl_names { // structure to associate class name with mask value
@@ -426,7 +426,7 @@ public:
     }
 };
 
-class regex_error : public runtime_error { // type of all regular expression exceptions
+_EXPORT_STD class regex_error : public runtime_error { // type of all regular expression exceptions
 public:
     explicit regex_error(regex_constants::error_type _Ex) : runtime_error(_Stringify(_Ex)), _Err(_Ex) {}
 
@@ -579,7 +579,7 @@ struct _Get_member_comparison_category<_Ty, void_t<typename _Ty::comparison_cate
 };
 #endif // _HAS_CXX20
 
-template <class _BidIt>
+_EXPORT_STD template <class _BidIt>
 class sub_match : public pair<_BidIt, _BidIt> { // class to hold contents of a capture group
 public:
     using _Mybase         = pair<_BidIt, _BidIt>;
@@ -688,18 +688,18 @@ public:
     }
 };
 
-using csub_match  = sub_match<const char*>;
-using wcsub_match = sub_match<const wchar_t*>;
-using ssub_match  = sub_match<string::const_iterator>;
-using wssub_match = sub_match<wstring::const_iterator>;
+_EXPORT_STD using csub_match  = sub_match<const char*>;
+_EXPORT_STD using wcsub_match = sub_match<const wchar_t*>;
+_EXPORT_STD using ssub_match  = sub_match<string::const_iterator>;
+_EXPORT_STD using wssub_match = sub_match<wstring::const_iterator>;
 
-template <class _BidIt>
+_EXPORT_STD template <class _BidIt>
 _NODISCARD bool operator==(const sub_match<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
     return _Left._Match_equal(_Right);
 }
 
 #if _HAS_CXX20
-template <class _BidIt>
+_EXPORT_STD template <class _BidIt>
 _NODISCARD auto operator<=>(const sub_match<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
     return static_cast<typename sub_match<_BidIt>::_Comparison_category>(_Left.compare(_Right) <=> 0);
 }
@@ -730,13 +730,13 @@ _NODISCARD bool operator>=(const sub_match<_BidIt>& _Left, const sub_match<_BidI
 }
 #endif // !_HAS_CXX20
 
-template <class _BidIt>
+_EXPORT_STD template <class _BidIt>
 _NODISCARD bool operator==(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>* _Right) {
     return _Left._Match_equal(_Right);
 }
 
 #if _HAS_CXX20
-template <class _BidIt>
+_EXPORT_STD template <class _BidIt>
 _NODISCARD auto operator<=>(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>* _Right) {
     return static_cast<typename sub_match<_BidIt>::_Comparison_category>(_Left.compare(_Right) <=> 0);
 }
@@ -797,13 +797,13 @@ _NODISCARD bool operator>=(const sub_match<_BidIt>& _Left, const _Iter_value_t<_
 }
 #endif // !_HAS_CXX20
 
-template <class _BidIt>
+_EXPORT_STD template <class _BidIt>
 _NODISCARD bool operator==(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>& _Right) {
     return _Left._Match_equal(_STD addressof(_Right), 1);
 }
 
 #if _HAS_CXX20
-template <class _BidIt>
+_EXPORT_STD template <class _BidIt>
 _NODISCARD auto operator<=>(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>& _Right) {
     return static_cast<typename sub_match<_BidIt>::_Comparison_category>(
         _Left._Compare(_STD addressof(_Right), 1) <=> 0);
@@ -865,14 +865,14 @@ _NODISCARD bool operator>=(const sub_match<_BidIt>& _Left, const _Iter_value_t<_
 }
 #endif // !_HAS_CXX20
 
-template <class _BidIt, class _Traits, class _Alloc>
+_EXPORT_STD template <class _BidIt, class _Traits, class _Alloc>
 _NODISCARD bool operator==(
     const sub_match<_BidIt>& _Left, const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Right) {
     return _Left._Match_equal(_Right.data(), _Right.size());
 }
 
 #if _HAS_CXX20
-template <class _BidIt, class _Traits, class _Alloc>
+_EXPORT_STD template <class _BidIt, class _Traits, class _Alloc>
 _NODISCARD auto operator<=>(
     const sub_match<_BidIt>& _Left, const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Right) {
     return static_cast<typename sub_match<_BidIt>::_Comparison_category>(_Left.compare(_Right) <=> 0);
@@ -945,12 +945,12 @@ _NODISCARD bool operator>=(
 }
 #endif // !_HAS_CXX20
 
-template <class _Elem, class _Traits, class _BidIt>
+_EXPORT_STD template <class _Elem, class _Traits, class _BidIt>
 basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, const sub_match<_BidIt>& _Match) {
     return _Ostr << _Match.str();
 }
 
-template <class _BidIt, class _Alloc = allocator<sub_match<_BidIt>>>
+_EXPORT_STD template <class _BidIt, class _Alloc = allocator<sub_match<_BidIt>>>
 class match_results;
 
 template <class _BidIt, class _Alloc, class _InIt, class _OutIt>
@@ -961,7 +961,7 @@ template <class _BidIt, class _Alloc, class _InIt, class _OutIt>
 _OutIt _Format_sed(const match_results<_BidIt, _Alloc>& _Match, _OutIt _Out, _InIt _First, _InIt _Last,
     regex_constants::match_flag_type _Flags = regex_constants::format_default);
 
-template <class _BidIt, class _Alloc>
+_EXPORT_STD template <class _BidIt, class _Alloc>
 class match_results { // class to hold contents of all capture groups
 public:
     using _Elem     = sub_match<_BidIt>;
@@ -1132,7 +1132,7 @@ private:
     _Elem _Null_elem;
 };
 
-template <class _BidIt, class _Alloc>
+_EXPORT_STD template <class _BidIt, class _Alloc>
 _NODISCARD bool operator==(const match_results<_BidIt, _Alloc>& _Left, const match_results<_BidIt, _Alloc>& _Right) {
     if (!_Left.ready() && !_Right.ready()) {
         return true;
@@ -1174,7 +1174,7 @@ enum _Node_flags : int { // flags for nfa nodes with special properties
     _Fl_longest = 0x08
 };
 
-_BITMASK_OPS(_Node_flags)
+_BITMASK_OPS(_EMPTY_ARGUMENT, _Node_flags)
 
 enum _Node_type { // type flag for nfa nodes
     _N_none,
@@ -1767,7 +1767,7 @@ public:
 #endif // 0 < _ITERATOR_DEBUG_LEVEL
 };
 
-template <class _Elem, class _RxTraits = regex_traits<_Elem>>
+_EXPORT_STD template <class _Elem, class _RxTraits = regex_traits<_Elem>>
 class basic_regex : public _Regex_base { // regular expression
 public:
     using value_type  = _Elem;
@@ -2018,23 +2018,23 @@ basic_regex(_FwdIt, _FwdIt, regex_constants::syntax_option_type = regex_constant
     -> basic_regex<typename iterator_traits<_FwdIt>::value_type>;
 #endif // _HAS_CXX17
 
-template <class _Elem, class _RxTraits>
+_EXPORT_STD template <class _Elem, class _RxTraits>
 void swap(basic_regex<_Elem, _RxTraits>& _Left, basic_regex<_Elem, _RxTraits>& _Right) noexcept /* strengthened */ {
     _Left.swap(_Right);
 }
 
-template <class _BidIt, class _Alloc>
+_EXPORT_STD template <class _BidIt, class _Alloc>
 void swap(match_results<_BidIt, _Alloc>& _Left, match_results<_BidIt, _Alloc>& _Right) noexcept(
     noexcept(_Left.swap(_Right))) /* strengthened */ {
     _Left.swap(_Right);
 }
 
-using regex   = basic_regex<char>;
-using wregex  = basic_regex<wchar_t>;
-using cmatch  = match_results<const char*>;
-using wcmatch = match_results<const wchar_t*>;
-using smatch  = match_results<string::const_iterator>;
-using wsmatch = match_results<wstring::const_iterator>;
+_EXPORT_STD using regex   = basic_regex<char>;
+_EXPORT_STD using wregex  = basic_regex<wchar_t>;
+_EXPORT_STD using cmatch  = match_results<const char*>;
+_EXPORT_STD using wcmatch = match_results<const wchar_t*>;
+_EXPORT_STD using smatch  = match_results<string::const_iterator>;
+_EXPORT_STD using wsmatch = match_results<wstring::const_iterator>;
 
 template <class _BidIt, class _Alloc, class _InIt, class _OutIt>
 _OutIt _Format_default(const match_results<_BidIt, _Alloc>& _Match, _OutIt _Out, _InIt _First, _InIt _Last,
@@ -2122,7 +2122,7 @@ bool _Regex_match1(_It _First, _It _Last, match_results<_BidIt, _Alloc>* _Matche
     return _Mx._Match(_Matches, _Full);
 }
 
-template <class _BidIt, class _Alloc, class _Elem, class _RxTraits>
+_EXPORT_STD template <class _BidIt, class _Alloc, class _Elem, class _RxTraits>
 bool regex_match(_BidIt _First, _BidIt _Last, match_results<_BidIt, _Alloc>& _Matches,
     const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
     // try to match regular expression to target text
@@ -2130,7 +2130,7 @@ bool regex_match(_BidIt _First, _BidIt _Last, match_results<_BidIt, _Alloc>& _Ma
     return _Regex_match1(_First, _Last, _STD addressof(_Matches), _Re, _Flgs, true);
 }
 
-template <class _BidIt, class _Elem, class _RxTraits>
+_EXPORT_STD template <class _BidIt, class _Elem, class _RxTraits>
 _NODISCARD bool regex_match(_BidIt _First, _BidIt _Last, const basic_regex<_Elem, _RxTraits>& _Re,
     regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
     // try to match regular expression to target text
@@ -2140,7 +2140,7 @@ _NODISCARD bool regex_match(_BidIt _First, _BidIt _Last, const basic_regex<_Elem
         true);
 }
 
-template <class _Elem, class _RxTraits>
+_EXPORT_STD template <class _Elem, class _RxTraits>
 _NODISCARD bool regex_match(_In_z_ const _Elem* _Str, const basic_regex<_Elem, _RxTraits>& _Re,
     regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
     // try to match regular expression to target text
@@ -2149,7 +2149,7 @@ _NODISCARD bool regex_match(_In_z_ const _Elem* _Str, const basic_regex<_Elem, _
         _Str, _Last, static_cast<match_results<const _Elem*>*>(nullptr), _Re, _Flgs | regex_constants::match_any, true);
 }
 
-template <class _Elem, class _Alloc, class _RxTraits>
+_EXPORT_STD template <class _Elem, class _Alloc, class _RxTraits>
 bool regex_match(_In_z_ const _Elem* _Str, match_results<const _Elem*, _Alloc>& _Matches,
     const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
     // try to match regular expression to target text
@@ -2157,7 +2157,7 @@ bool regex_match(_In_z_ const _Elem* _Str, match_results<const _Elem*, _Alloc>&
     return _Regex_match1(_Str, _Last, _STD addressof(_Matches), _Re, _Flgs, true);
 }
 
-template <class _StTraits, class _StAlloc, class _Alloc, class _Elem, class _RxTraits>
+_EXPORT_STD template <class _StTraits, class _StAlloc, class _Alloc, class _Elem, class _RxTraits>
 bool regex_match(const basic_string<_Elem, _StTraits, _StAlloc>& _Str,
     match_results<typename basic_string<_Elem, _StTraits, _StAlloc>::const_iterator, _Alloc>& _Matches,
     const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
@@ -2165,12 +2165,12 @@ bool regex_match(const basic_string<_Elem, _StTraits, _StAlloc>& _Str,
     return _Regex_match1(_Str.begin(), _Str.end(), _STD addressof(_Matches), _Re, _Flgs, true);
 }
 
-template <class _StTraits, class _StAlloc, class _Alloc, class _Elem, class _RxTraits>
+_EXPORT_STD template <class _StTraits, class _StAlloc, class _Alloc, class _Elem, class _RxTraits>
 bool regex_match(const basic_string<_Elem, _StTraits, _StAlloc>&&,
     match_results<typename basic_string<_Elem, _StTraits, _StAlloc>::const_iterator, _Alloc>&,
     const basic_regex<_Elem, _RxTraits>&, regex_constants::match_flag_type = regex_constants::match_default) = delete;
 
-template <class _StTraits, class _StAlloc, class _Elem, class _RxTraits>
+_EXPORT_STD template <class _StTraits, class _StAlloc, class _Elem, class _RxTraits>
 _NODISCARD bool regex_match(const basic_string<_Elem, _StTraits, _StAlloc>& _Str,
     const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
     // try to match regular expression to target text
@@ -2220,7 +2220,7 @@ bool _Regex_search2(_It _First, _It _Last, match_results<_BidIt, _Alloc>* _Match
     return _Found;
 }
 
-template <class _BidIt, class _Alloc, class _Elem, class _RxTraits>
+_EXPORT_STD template <class _BidIt, class _Alloc, class _Elem, class _RxTraits>
 bool regex_search(_BidIt _First, _BidIt _Last, match_results<_BidIt, _Alloc>& _Matches,
     const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
     // search for regular expression match in target text
@@ -2228,7 +2228,7 @@ bool regex_search(_BidIt _First, _BidIt _Last, match_results<_BidIt, _Alloc>& _M
     return _Regex_search2(_First, _Last, _STD addressof(_Matches), _Re, _Flgs, _First);
 }
 
-template <class _BidIt, class _Elem, class _RxTraits>
+_EXPORT_STD template <class _BidIt, class _Elem, class _RxTraits>
 _NODISCARD bool regex_search(_BidIt _First, _BidIt _Last, const basic_regex<_Elem, _RxTraits>& _Re,
     regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
     // search for regular expression match in target text
@@ -2238,7 +2238,7 @@ _NODISCARD bool regex_search(_BidIt _First, _BidIt _Last, const basic_regex<_Ele
         _Get_unwrapped(_First));
 }
 
-template <class _Elem, class _RxTraits>
+_EXPORT_STD template <class _Elem, class _RxTraits>
 _NODISCARD bool regex_search(_In_z_ const _Elem* _Str, const basic_regex<_Elem, _RxTraits>& _Re,
     regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
     // search for regular expression match in target text
@@ -2247,7 +2247,7 @@ _NODISCARD bool regex_search(_In_z_ const _Elem* _Str, const basic_regex<_Elem,
         _Str, _Last, static_cast<match_results<const _Elem*>*>(nullptr), _Re, _Flgs | regex_constants::match_any, _Str);
 }
 
-template <class _Elem, class _Alloc, class _RxTraits>
+_EXPORT_STD template <class _Elem, class _Alloc, class _RxTraits>
 bool regex_search(_In_z_ const _Elem* _Str, match_results<const _Elem*, _Alloc>& _Matches,
     const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
     // search for regular expression match in target text
@@ -2255,7 +2255,7 @@ bool regex_search(_In_z_ const _Elem* _Str, match_results<const _Elem*, _Alloc>&
     return _Regex_search2(_Str, _Last, _STD addressof(_Matches), _Re, _Flgs, _Str);
 }
 
-template <class _StTraits, class _StAlloc, class _Alloc, class _Elem, class _RxTraits>
+_EXPORT_STD template <class _StTraits, class _StAlloc, class _Alloc, class _Elem, class _RxTraits>
 bool regex_search(const basic_string<_Elem, _StTraits, _StAlloc>& _Str,
     match_results<typename basic_string<_Elem, _StTraits, _StAlloc>::const_iterator, _Alloc>& _Matches,
     const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
@@ -2263,12 +2263,12 @@ bool regex_search(const basic_string<_Elem, _StTraits, _StAlloc>& _Str,
     return _Regex_search2(_Str.begin(), _Str.end(), _STD addressof(_Matches), _Re, _Flgs, _Str.begin());
 }
 
-template <class _StTraits, class _StAlloc, class _Alloc, class _Elem, class _RxTraits>
+_EXPORT_STD template <class _StTraits, class _StAlloc, class _Alloc, class _Elem, class _RxTraits>
 bool regex_search(const basic_string<_Elem, _StTraits, _StAlloc>&&,
     match_results<typename basic_string<_Elem, _StTraits, _StAlloc>::const_iterator, _Alloc>&,
     const basic_regex<_Elem, _RxTraits>&, regex_constants::match_flag_type = regex_constants::match_default) = delete;
 
-template <class _StTraits, class _StAlloc, class _Elem, class _RxTraits>
+_EXPORT_STD template <class _StTraits, class _StAlloc, class _Elem, class _RxTraits>
 _NODISCARD bool regex_search(const basic_string<_Elem, _StTraits, _StAlloc>& _Str,
     const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
     // search for regular expression match in target text
@@ -2312,7 +2312,7 @@ _OutIt _Regex_replace1(_OutIt _Result, _BidIt _First, _BidIt _Last, const basic_
     return _Flgs & regex_constants::format_no_copy ? _Result : _Copy_unchecked(_Pos, _Last, _Result);
 }
 
-template <class _OutIt, class _BidIt, class _RxTraits, class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _OutIt, class _BidIt, class _RxTraits, class _Elem, class _Traits, class _Alloc>
 _OutIt regex_replace(_OutIt _Result, _BidIt _First, _BidIt _Last, const basic_regex<_Elem, _RxTraits>& _Re,
     const basic_string<_Elem, _Traits, _Alloc>& _Fmt,
     regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
@@ -2323,7 +2323,7 @@ _OutIt regex_replace(_OutIt _Result, _BidIt _First, _BidIt _Last, const basic_re
     return _Result;
 }
 
-template <class _OutIt, class _BidIt, class _RxTraits, class _Elem>
+_EXPORT_STD template <class _OutIt, class _BidIt, class _RxTraits, class _Elem>
 _OutIt regex_replace(_OutIt _Result, _BidIt _First, _BidIt _Last, const basic_regex<_Elem, _RxTraits>& _Re,
     const _Elem* _Ptr, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
     // search and replace, iterator result, NTBS format
@@ -2331,7 +2331,7 @@ _OutIt regex_replace(_OutIt _Result, _BidIt _First, _BidIt _Last, const basic_re
     return _STD regex_replace(_Result, _First, _Last, _Re, _Fmt, _Flgs);
 }
 
-template <class _RxTraits, class _Elem, class _Traits1, class _Alloc1, class _Traits2, class _Alloc2>
+_EXPORT_STD template <class _RxTraits, class _Elem, class _Traits1, class _Alloc1, class _Traits2, class _Alloc2>
 _NODISCARD basic_string<_Elem, _Traits1, _Alloc1> regex_replace(const basic_string<_Elem, _Traits1, _Alloc1>& _Str,
     const basic_regex<_Elem, _RxTraits>& _Re, const basic_string<_Elem, _Traits2, _Alloc2>& _Fmt,
     regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
@@ -2341,7 +2341,7 @@ _NODISCARD basic_string<_Elem, _Traits1, _Alloc1> regex_replace(const basic_stri
     return _Res;
 }
 
-template <class _RxTraits, class _Elem, class _Traits1, class _Alloc1>
+_EXPORT_STD template <class _RxTraits, class _Elem, class _Traits1, class _Alloc1>
 _NODISCARD basic_string<_Elem, _Traits1, _Alloc1> regex_replace(const basic_string<_Elem, _Traits1, _Alloc1>& _Str,
     const basic_regex<_Elem, _RxTraits>& _Re, const _Elem* _Ptr,
     regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
@@ -2352,7 +2352,7 @@ _NODISCARD basic_string<_Elem, _Traits1, _Alloc1> regex_replace(const basic_stri
     return _Res;
 }
 
-template <class _RxTraits, class _Elem, class _Traits2, class _Alloc2>
+_EXPORT_STD template <class _RxTraits, class _Elem, class _Traits2, class _Alloc2>
 _NODISCARD basic_string<_Elem> regex_replace(const _Elem* _Pstr, const basic_regex<_Elem, _RxTraits>& _Re,
     const basic_string<_Elem, _Traits2, _Alloc2>& _Fmt,
     regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
@@ -2363,7 +2363,7 @@ _NODISCARD basic_string<_Elem> regex_replace(const _Elem* _Pstr, const basic_reg
     return _Res;
 }
 
-template <class _RxTraits, class _Elem>
+_EXPORT_STD template <class _RxTraits, class _Elem>
 _NODISCARD basic_string<_Elem> regex_replace(const _Elem* _Pstr, const basic_regex<_Elem, _RxTraits>& _Re,
     const _Elem* _Ptr, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
     // search and replace, string result, NTBS target, NTBS format
@@ -2374,7 +2374,7 @@ _NODISCARD basic_string<_Elem> regex_replace(const _Elem* _Pstr, const basic_reg
     return _Res;
 }
 
-template <class _BidIt, class _Elem = _Iter_value_t<_BidIt>, class _RxTraits = regex_traits<_Elem>>
+_EXPORT_STD template <class _BidIt, class _Elem = _Iter_value_t<_BidIt>, class _RxTraits = regex_traits<_Elem>>
 class regex_iterator : public _Iterator_base {
 public:
     using regex_type        = basic_regex<_Elem, _RxTraits>;
@@ -2504,12 +2504,12 @@ private:
     match_results<_BidIt> _MyVal; // lookahead value (if _MyRe not null)
 };
 
-using cregex_iterator  = regex_iterator<const char*>;
-using wcregex_iterator = regex_iterator<const wchar_t*>;
-using sregex_iterator  = regex_iterator<string::const_iterator>;
-using wsregex_iterator = regex_iterator<wstring::const_iterator>;
+_EXPORT_STD using cregex_iterator  = regex_iterator<const char*>;
+_EXPORT_STD using wcregex_iterator = regex_iterator<const wchar_t*>;
+_EXPORT_STD using sregex_iterator  = regex_iterator<string::const_iterator>;
+_EXPORT_STD using wsregex_iterator = regex_iterator<wstring::const_iterator>;
 
-template <class _BidIt, class _Elem = _Iter_value_t<_BidIt>, class _RxTraits = regex_traits<_Elem>>
+_EXPORT_STD template <class _BidIt, class _Elem = _Iter_value_t<_BidIt>, class _RxTraits = regex_traits<_Elem>>
 class regex_token_iterator {
 public:
     using _Position         = regex_iterator<_BidIt, _Elem, _RxTraits>;
@@ -2694,10 +2694,10 @@ private:
     }
 };
 
-using cregex_token_iterator  = regex_token_iterator<const char*>;
-using wcregex_token_iterator = regex_token_iterator<const wchar_t*>;
-using sregex_token_iterator  = regex_token_iterator<string::const_iterator>;
-using wsregex_token_iterator = regex_token_iterator<wstring::const_iterator>;
+_EXPORT_STD using cregex_token_iterator  = regex_token_iterator<const char*>;
+_EXPORT_STD using wcregex_token_iterator = regex_token_iterator<const wchar_t*>;
+_EXPORT_STD using sregex_token_iterator  = regex_token_iterator<string::const_iterator>;
+_EXPORT_STD using wsregex_token_iterator = regex_token_iterator<wstring::const_iterator>;
 
 template <class _FwdIt, class _Elem, class _RxTraits>
 _Builder<_FwdIt, _Elem, _RxTraits>::_Builder(const _RxTraits& _Tr, regex_constants::syntax_option_type _Fx)
@@ -4611,13 +4611,13 @@ namespace _DEPRECATE_TR1_NAMESPACE tr1 {
 
 #if _HAS_CXX17
 namespace pmr {
-    template <class _BidIt>
+    _EXPORT_STD template <class _BidIt>
     using match_results = _STD match_results<_BidIt, polymorphic_allocator<sub_match<_BidIt>>>;
 
-    using cmatch  = match_results<const char*>;
-    using wcmatch = match_results<const wchar_t*>;
-    using smatch  = match_results<string::const_iterator>;
-    using wsmatch = match_results<wstring::const_iterator>;
+    _EXPORT_STD using cmatch  = match_results<const char*>;
+    _EXPORT_STD using wcmatch = match_results<const wchar_t*>;
+    _EXPORT_STD using smatch  = match_results<string::const_iterator>;
+    _EXPORT_STD using wsmatch = match_results<wstring::const_iterator>;
 } // namespace pmr
 #endif // _HAS_CXX17
 _STD_END
diff --git a/stl/inc/scoped_allocator b/stl/inc/scoped_allocator
index 906b032287..a178d7be30 100644
--- a/stl/inc/scoped_allocator
+++ b/stl/inc/scoped_allocator
@@ -46,7 +46,7 @@ using _Scoped_outermost_t = remove_reference_t<decltype(_Scoped_outermost(_STD d
 template <class _Alloc>
 using _Scoped_outermost_traits = allocator_traits<_Scoped_outermost_t<_Alloc>>;
 
-template <class _Outer, class... _Inner>
+_EXPORT_STD template <class _Outer, class... _Inner>
 class scoped_allocator_adaptor;
 
 template <class _Outer, class... _Inner>
@@ -121,7 +121,7 @@ struct _Scoped_base<_Outer> : _Outer { // nest of allocators, one deep
     }
 };
 
-template <class _Outer, class... _Inner>
+_EXPORT_STD template <class _Outer, class... _Inner>
 class scoped_allocator_adaptor : public _Scoped_base<_Outer, _Inner...> { // nest of allocators
 private:
     using _Mybase       = _Scoped_base<_Outer, _Inner...>;
@@ -251,7 +251,7 @@ template <class _Outer, class... _Inner>
 scoped_allocator_adaptor(_Outer, _Inner...) -> scoped_allocator_adaptor<_Outer, _Inner...>;
 #endif // _HAS_CXX17
 
-template <class _Outer1, class _Outer2, class... _Inner>
+_EXPORT_STD template <class _Outer1, class _Outer2, class... _Inner>
 _NODISCARD bool operator==(const scoped_allocator_adaptor<_Outer1, _Inner...>& _Left,
     const scoped_allocator_adaptor<_Outer2, _Inner...>& _Right) noexcept {
     if constexpr (sizeof...(_Inner) == 0) {
diff --git a/stl/inc/semaphore b/stl/inc/semaphore
index cea8b04d05..f7847fd93b 100644
--- a/stl/inc/semaphore
+++ b/stl/inc/semaphore
@@ -55,7 +55,7 @@ _NODISCARD unsigned long _Semaphore_remaining_timeout(const chrono::time_point<_
 
 inline constexpr ptrdiff_t _Semaphore_max = (1ULL << (sizeof(ptrdiff_t) * CHAR_BIT - 1)) - 1;
 
-template <ptrdiff_t _Least_max_value = _Semaphore_max>
+_EXPORT_STD template <ptrdiff_t _Least_max_value = _Semaphore_max>
 class counting_semaphore {
 public:
     _NODISCARD static constexpr ptrdiff_t(max)() noexcept {
@@ -299,7 +299,7 @@ private:
     atomic<unsigned char> _Counter;
 };
 
-using binary_semaphore = counting_semaphore<1>;
+_EXPORT_STD using binary_semaphore = counting_semaphore<1>;
 
 _STD_END
 
diff --git a/stl/inc/set b/stl/inc/set
index 74055ed107..666069e89f 100644
--- a/stl/inc/set
+++ b/stl/inc/set
@@ -48,7 +48,7 @@ public:
     }
 };
 
-template <class _Kty, class _Pr = less<_Kty>, class _Alloc = allocator<_Kty>>
+_EXPORT_STD template <class _Kty, class _Pr = less<_Kty>, class _Alloc = allocator<_Kty>>
 class set : public _Tree<_Tset_traits<_Kty, _Pr, _Alloc, false>> {
     // ordered red-black tree of key values, unique keys
 public:
@@ -204,7 +204,7 @@ set(from_range_t, _Rng&&, _Alloc) -> set<_RANGES range_value_t<_Rng>, less<_RANG
 #endif // _HAS_CXX23 && defined(__cpp_lib_concepts)
 #endif // _HAS_CXX17
 
-template <class _Kty, class _Pr, class _Alloc>
+_EXPORT_STD template <class _Kty, class _Pr, class _Alloc>
 _NODISCARD bool operator==(const set<_Kty, _Pr, _Alloc>& _Left, const set<_Kty, _Pr, _Alloc>& _Right) {
     return _Left.size() == _Right.size()
         && _STD equal(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(), _Right._Unchecked_begin());
@@ -218,7 +218,7 @@ _NODISCARD bool operator!=(const set<_Kty, _Pr, _Alloc>& _Left, const set<_Kty,
 #endif // !_HAS_CXX20
 
 #ifdef __cpp_lib_concepts
-template <class _Kty, class _Pr, class _Alloc>
+_EXPORT_STD template <class _Kty, class _Pr, class _Alloc>
 _NODISCARD _Synth_three_way_result<_Kty> operator<=>(
     const set<_Kty, _Pr, _Alloc>& _Left, const set<_Kty, _Pr, _Alloc>& _Right) {
     return _STD lexicographical_compare_three_way(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(),
@@ -247,19 +247,19 @@ _NODISCARD bool operator>=(const set<_Kty, _Pr, _Alloc>& _Left, const set<_Kty,
 }
 #endif // ^^^ !defined(__cpp_lib_concepts) ^^^
 
-template <class _Kty, class _Pr, class _Alloc>
+_EXPORT_STD template <class _Kty, class _Pr, class _Alloc>
 void swap(set<_Kty, _Pr, _Alloc>& _Left, set<_Kty, _Pr, _Alloc>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
     _Left.swap(_Right);
 }
 
 #if _HAS_CXX20
-template <class _Kty, class _Keylt, class _Alloc, class _Pr>
+_EXPORT_STD template <class _Kty, class _Keylt, class _Alloc, class _Pr>
 typename set<_Kty, _Keylt, _Alloc>::size_type erase_if(set<_Kty, _Keylt, _Alloc>& _Cont, _Pr _Pred) {
     return _Erase_nodes_if(_Cont, _Pass_fn(_Pred));
 }
 #endif // _HAS_CXX20
 
-template <class _Kty, class _Pr = less<_Kty>, class _Alloc = allocator<_Kty>>
+_EXPORT_STD template <class _Kty, class _Pr = less<_Kty>, class _Alloc = allocator<_Kty>>
 class multiset : public _Tree<_Tset_traits<_Kty, _Pr, _Alloc, true>> {
     // ordered red-black tree of key values, non-unique keys
 public:
@@ -419,7 +419,7 @@ multiset(from_range_t, _Rng&&, _Alloc)
 #endif // _HAS_CXX23 && defined(__cpp_lib_concepts)
 #endif // _HAS_CXX17
 
-template <class _Kty, class _Pr, class _Alloc>
+_EXPORT_STD template <class _Kty, class _Pr, class _Alloc>
 _NODISCARD bool operator==(const multiset<_Kty, _Pr, _Alloc>& _Left, const multiset<_Kty, _Pr, _Alloc>& _Right) {
     return _Left.size() == _Right.size()
         && _STD equal(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(), _Right._Unchecked_begin());
@@ -433,7 +433,7 @@ _NODISCARD bool operator!=(const multiset<_Kty, _Pr, _Alloc>& _Left, const multi
 #endif // !_HAS_CXX20
 
 #ifdef __cpp_lib_concepts
-template <class _Kty, class _Pr, class _Alloc>
+_EXPORT_STD template <class _Kty, class _Pr, class _Alloc>
 _NODISCARD _Synth_three_way_result<_Kty> operator<=>(
     const multiset<_Kty, _Pr, _Alloc>& _Left, const multiset<_Kty, _Pr, _Alloc>& _Right) {
     return _STD lexicographical_compare_three_way(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(),
@@ -462,14 +462,14 @@ _NODISCARD bool operator>=(const multiset<_Kty, _Pr, _Alloc>& _Left, const multi
 }
 #endif // ^^^ !defined(__cpp_lib_concepts) ^^^
 
-template <class _Kty, class _Pr, class _Alloc>
+_EXPORT_STD template <class _Kty, class _Pr, class _Alloc>
 void swap(multiset<_Kty, _Pr, _Alloc>& _Left, multiset<_Kty, _Pr, _Alloc>& _Right) noexcept(
     noexcept(_Left.swap(_Right))) {
     _Left.swap(_Right);
 }
 
 #if _HAS_CXX20
-template <class _Kty, class _Keylt, class _Alloc, class _Pr>
+_EXPORT_STD template <class _Kty, class _Keylt, class _Alloc, class _Pr>
 typename multiset<_Kty, _Keylt, _Alloc>::size_type erase_if(multiset<_Kty, _Keylt, _Alloc>& _Cont, _Pr _Pred) {
     return _Erase_nodes_if(_Cont, _Pass_fn(_Pred));
 }
@@ -477,10 +477,10 @@ typename multiset<_Kty, _Keylt, _Alloc>::size_type erase_if(multiset<_Kty, _Keyl
 
 #if _HAS_CXX17
 namespace pmr {
-    template <class _Kty, class _Pr = less<_Kty>>
+    _EXPORT_STD template <class _Kty, class _Pr = less<_Kty>>
     using set = _STD set<_Kty, _Pr, polymorphic_allocator<_Kty>>;
 
-    template <class _Kty, class _Pr = less<_Kty>>
+    _EXPORT_STD template <class _Kty, class _Pr = less<_Kty>>
     using multiset = _STD multiset<_Kty, _Pr, polymorphic_allocator<_Kty>>;
 } // namespace pmr
 #endif // _HAS_CXX17
diff --git a/stl/inc/shared_mutex b/stl/inc/shared_mutex
index 1ff40ea7eb..495ef05991 100644
--- a/stl/inc/shared_mutex
+++ b/stl/inc/shared_mutex
@@ -27,7 +27,7 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-class shared_mutex { // class for mutual exclusion shared across threads
+_EXPORT_STD class shared_mutex { // class for mutual exclusion shared across threads
 public:
     using native_handle_type = _Smtx_t*;
 
@@ -73,7 +73,7 @@ private:
 
 // shared_timed_mutex is not supported under /clr
 #ifndef _M_CEE
-class shared_timed_mutex { // class for mutual exclusion shared across threads
+_EXPORT_STD class shared_timed_mutex { // class for mutual exclusion shared across threads
 private:
     using _Read_cnt_t = unsigned int;
 
@@ -232,7 +232,7 @@ private:
 };
 #endif // _M_CEE
 
-template <class _Mutex>
+_EXPORT_STD template <class _Mutex>
 class shared_lock { // shareable lock
 public:
     using mutex_type = _Mutex;
@@ -373,7 +373,7 @@ private:
     }
 };
 
-template <class _Mutex>
+_EXPORT_STD template <class _Mutex>
 void swap(shared_lock<_Mutex>& _Left, shared_lock<_Mutex>& _Right) noexcept {
     _Left.swap(_Right);
 }
diff --git a/stl/inc/source_location b/stl/inc/source_location
index 9bbea21608..411313a20c 100644
--- a/stl/inc/source_location
+++ b/stl/inc/source_location
@@ -22,7 +22,7 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-struct source_location {
+_EXPORT_STD struct source_location {
     _NODISCARD static consteval source_location current(const uint_least32_t _Line_ = __builtin_LINE(),
         const uint_least32_t _Column_ = __builtin_COLUMN(), const char* const _File_ = __builtin_FILE(),
         const char* const _Function_ = __builtin_FUNCTION()) noexcept {
diff --git a/stl/inc/span b/stl/inc/span
index 77dcc714f8..7751b2a680 100644
--- a/stl/inc/span
+++ b/stl/inc/span
@@ -27,7 +27,7 @@ _STL_DISABLE_CLANG_WARNINGS
 
 _STD_BEGIN
 
-inline constexpr size_t dynamic_extent = static_cast<size_t>(-1);
+_EXPORT_STD inline constexpr size_t dynamic_extent = static_cast<size_t>(-1);
 
 template <class _Ty>
 struct _Span_iterator {
@@ -222,10 +222,10 @@ struct _Span_extent_type<_Ty, dynamic_extent> {
     size_t _Mysize{0};
 };
 
-template <class _Ty, size_t _Size>
+_EXPORT_STD template <class _Ty, size_t _Size>
 class array;
 
-template <class _Ty, size_t _Extent>
+_EXPORT_STD template <class _Ty, size_t _Extent>
 class span;
 
 #ifdef __cpp_lib_concepts
@@ -303,7 +303,7 @@ inline constexpr bool _Is_span_compatible_range = conjunction_v< //
 #endif // !__cpp_lib_concepts
 
 // [views.span]
-template <class _Ty, size_t _Extent = dynamic_extent>
+_EXPORT_STD template <class _Ty, size_t _Extent = dynamic_extent>
 class span : private _Span_extent_type<_Ty, _Extent> {
 private:
     using _Mybase = _Span_extent_type<_Ty, _Extent>;
@@ -662,13 +662,13 @@ span(const _Rng&) -> span<const typename _Rng::value_type>;
 
 #ifdef __cpp_lib_byte
 // [span.objectrep] Views of object representation
-template <class _Ty, size_t _Extent>
+_EXPORT_STD template <class _Ty, size_t _Extent>
 _NODISCARD auto as_bytes(span<_Ty, _Extent> _Sp) noexcept {
     using _ReturnType = span<const byte, _Extent == dynamic_extent ? dynamic_extent : sizeof(_Ty) * _Extent>;
     return _ReturnType{reinterpret_cast<const byte*>(_Sp.data()), _Sp.size_bytes()};
 }
 
-template <class _Ty, size_t _Extent, enable_if_t<!is_const_v<_Ty>, int> = 0>
+_EXPORT_STD template <class _Ty, size_t _Extent, enable_if_t<!is_const_v<_Ty>, int> = 0>
 _NODISCARD auto as_writable_bytes(span<_Ty, _Extent> _Sp) noexcept {
     using _ReturnType = span<byte, _Extent == dynamic_extent ? dynamic_extent : sizeof(_Ty) * _Extent>;
     return _ReturnType{reinterpret_cast<byte*>(_Sp.data()), _Sp.size_bytes()};
diff --git a/stl/inc/spanstream b/stl/inc/spanstream
index 1f92d8bbc6..d6131fa62a 100644
--- a/stl/inc/spanstream
+++ b/stl/inc/spanstream
@@ -32,7 +32,7 @@ _STD_BEGIN
 // In this file, _STD span is qualified to avoid ambiguity with span() member functions.
 // This qualification is consistently used even when it isn't strictly necessary.
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 class basic_spanbuf : public basic_streambuf<_Elem, _Traits> {
 private:
     using _Mysb = basic_streambuf<_Elem, _Traits>;
@@ -184,12 +184,12 @@ private:
     _STD span<_Elem> _Buf{};
 };
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 void swap(basic_spanbuf<_Elem, _Traits>& _Left, basic_spanbuf<_Elem, _Traits>& _Right) {
     _Left.swap(_Right);
 }
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 class basic_ispanstream : public basic_istream<_Elem, _Traits> {
 private:
     using _Mybase = basic_istream<_Elem, _Traits>;
@@ -266,12 +266,12 @@ private:
     _Mysb _Buf;
 };
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 void swap(basic_ispanstream<_Elem, _Traits>& _Left, basic_ispanstream<_Elem, _Traits>& _Right) {
     _Left.swap(_Right);
 }
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 class basic_ospanstream : public basic_ostream<_Elem, _Traits> {
 private:
     using _Mybase = basic_ostream<_Elem, _Traits>;
@@ -325,12 +325,12 @@ private:
     _Mysb _Buf;
 };
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 void swap(basic_ospanstream<_Elem, _Traits>& _Left, basic_ospanstream<_Elem, _Traits>& _Right) {
     _Left.swap(_Right);
 }
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 class basic_spanstream : public basic_iostream<_Elem, _Traits> {
 private:
     using _Mybase = basic_iostream<_Elem, _Traits>;
@@ -384,7 +384,7 @@ private:
     _Mysb _Buf;
 };
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 void swap(basic_spanstream<_Elem, _Traits>& _Left, basic_spanstream<_Elem, _Traits>& _Right) {
     _Left.swap(_Right);
 }
diff --git a/stl/inc/sstream b/stl/inc/sstream
index e5c74d43b2..f7b48bde18 100644
--- a/stl/inc/sstream
+++ b/stl/inc/sstream
@@ -19,7 +19,7 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 _STD_BEGIN
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 class basic_stringbuf
     : public basic_streambuf<_Elem, _Traits> { // stream buffer maintaining an allocated character array
 public:
@@ -526,13 +526,13 @@ private:
     allocator_type _Al; // the allocator object
 };
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 void swap(basic_stringbuf<_Elem, _Traits, _Alloc>& _Left, basic_stringbuf<_Elem, _Traits, _Alloc>& _Right) noexcept
 /* strengthened */ {
     _Left.swap(_Right);
 }
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 class basic_istringstream : public basic_istream<_Elem, _Traits> { // input stream associated with a character array
 public:
     using _Mybase        = basic_istream<_Elem, _Traits>;
@@ -646,12 +646,12 @@ private:
     _Mysb _Stringbuffer;
 };
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 void swap(basic_istringstream<_Elem, _Traits, _Alloc>& _Left, basic_istringstream<_Elem, _Traits, _Alloc>& _Right) {
     _Left.swap(_Right);
 }
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 class basic_ostringstream : public basic_ostream<_Elem, _Traits> { // output stream associated with a character array
 public:
     using _Mybase        = basic_ostream<_Elem, _Traits>;
@@ -765,12 +765,12 @@ private:
     _Mysb _Stringbuffer;
 };
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 void swap(basic_ostringstream<_Elem, _Traits, _Alloc>& _Left, basic_ostringstream<_Elem, _Traits, _Alloc>& _Right) {
     _Left.swap(_Right);
 }
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 class basic_stringstream
     : public basic_iostream<_Elem, _Traits> { // input/output stream associated with a character array
 public:
@@ -890,7 +890,7 @@ private:
     _Mysb _Stringbuffer;
 };
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 void swap(basic_stringstream<_Elem, _Traits, _Alloc>& _Left, basic_stringstream<_Elem, _Traits, _Alloc>& _Right) {
     _Left.swap(_Right);
 }
diff --git a/stl/inc/stack b/stl/inc/stack
index 24d6afe6d9..6e8a178ac7 100644
--- a/stl/inc/stack
+++ b/stl/inc/stack
@@ -22,7 +22,7 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-template <class _Ty, class _Container = deque<_Ty>>
+_EXPORT_STD template <class _Ty, class _Container = deque<_Ty>>
 class stack {
 public:
     using value_type      = typename _Container::value_type;
@@ -168,45 +168,45 @@ stack(from_range_t, _Rng&&, _Alloc) -> stack<_RANGES range_value_t<_Rng>, deque<
 #endif // __cpp_lib_concepts
 #endif // _HAS_CXX23
 
-template <class _Ty, class _Container>
+_EXPORT_STD template <class _Ty, class _Container>
 _NODISCARD bool operator==(const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
     return _Left._Get_container() == _Right._Get_container();
 }
 
-template <class _Ty, class _Container>
+_EXPORT_STD template <class _Ty, class _Container>
 _NODISCARD bool operator!=(const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
     return _Left._Get_container() != _Right._Get_container();
 }
 
-template <class _Ty, class _Container>
+_EXPORT_STD template <class _Ty, class _Container>
 _NODISCARD bool operator<(const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
     return _Left._Get_container() < _Right._Get_container();
 }
 
-template <class _Ty, class _Container>
+_EXPORT_STD template <class _Ty, class _Container>
 _NODISCARD bool operator>(const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
     return _Left._Get_container() > _Right._Get_container();
 }
 
-template <class _Ty, class _Container>
+_EXPORT_STD template <class _Ty, class _Container>
 _NODISCARD bool operator<=(const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
     return _Left._Get_container() <= _Right._Get_container();
 }
 
-template <class _Ty, class _Container>
+_EXPORT_STD template <class _Ty, class _Container>
 _NODISCARD bool operator>=(const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
     return _Left._Get_container() >= _Right._Get_container();
 }
 
 #ifdef __cpp_lib_concepts
-template <class _Ty, three_way_comparable _Container>
+_EXPORT_STD template <class _Ty, three_way_comparable _Container>
 _NODISCARD compare_three_way_result_t<_Container> operator<=>(
     const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
     return _Left._Get_container() <=> _Right._Get_container();
 }
 #endif // __cpp_lib_concepts
 
-template <class _Ty, class _Container, enable_if_t<_Is_swappable<_Container>::value, int> = 0>
+_EXPORT_STD template <class _Ty, class _Container, enable_if_t<_Is_swappable<_Container>::value, int> = 0>
 void swap(stack<_Ty, _Container>& _Left, stack<_Ty, _Container>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
     _Left.swap(_Right);
 }
diff --git a/stl/inc/stacktrace b/stl/inc/stacktrace
index e693af7add..0c9e184c73 100644
--- a/stl/inc/stacktrace
+++ b/stl/inc/stacktrace
@@ -73,7 +73,7 @@ inline size_t __stdcall _Stacktrace_string_fill_impl(
     }
 }
 
-class stacktrace_entry {
+_EXPORT_STD class stacktrace_entry {
 public:
     using native_handle_type = void*;
 
@@ -116,7 +116,7 @@ private:
     void* _Address = nullptr;
 };
 
-template <class _Alloc>
+_EXPORT_STD template <class _Alloc>
 class basic_stacktrace {
 private:
     using _Frames_t = vector<stacktrace_entry, _Alloc>;
@@ -319,38 +319,38 @@ private:
     unsigned long _Hash = 0;
 };
 
-using stacktrace = basic_stacktrace<allocator<stacktrace_entry>>;
+_EXPORT_STD using stacktrace = basic_stacktrace<allocator<stacktrace_entry>>;
 
-template <class _Alloc>
+_EXPORT_STD template <class _Alloc>
 void swap(basic_stacktrace<_Alloc>& _Ax, basic_stacktrace<_Alloc>& _Bx) noexcept(noexcept(_Ax.swap(_Bx))) {
     _Ax.swap(_Bx);
 }
 
-_NODISCARD inline string to_string(const stacktrace_entry& _Fx) {
+_EXPORT_STD _NODISCARD inline string to_string(const stacktrace_entry& _Fx) {
     string _Result;
     __std_stacktrace_address_to_string(_Fx.native_handle(), &_Result, _Stacktrace_string_fill_impl);
     return _Result;
 }
 
-template <class _Alloc>
+_EXPORT_STD template <class _Alloc>
 _NODISCARD string to_string(const basic_stacktrace<_Alloc>& _St) {
     string _Result;
     __std_stacktrace_to_string(_St._To_voidptr_array(), _St.size(), &_Result, _Stacktrace_string_fill_impl);
     return _Result;
 }
 
-template <class _CharT, class _Traits>
+_EXPORT_STD template <class _CharT, class _Traits>
 basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const stacktrace_entry& _Fx) {
     return _Os << _STD to_string(_Fx);
 }
 
-template <class _CharT, class _Traits, class _Alloc>
+_EXPORT_STD template <class _CharT, class _Traits, class _Alloc>
 basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const basic_stacktrace<_Alloc>& _St) {
     return _Os << _STD to_string(_St);
 }
 
 namespace pmr {
-    using stacktrace = basic_stacktrace<polymorphic_allocator<stacktrace_entry>>;
+    _EXPORT_STD using stacktrace = basic_stacktrace<polymorphic_allocator<stacktrace_entry>>;
 }
 
 template <>
diff --git a/stl/inc/stdexcept b/stl/inc/stdexcept
index 109d90339d..19f099169c 100644
--- a/stl/inc/stdexcept
+++ b/stl/inc/stdexcept
@@ -18,7 +18,7 @@ _STL_DISABLE_CLANG_WARNINGS
 #pragma push_macro("new")
 #undef new
 _STD_BEGIN
-class logic_error : public exception { // base of all logic-error exceptions
+_EXPORT_STD class logic_error : public exception { // base of all logic-error exceptions
 public:
     using _Mybase = exception;
 
@@ -34,7 +34,7 @@ protected:
 #endif // !_HAS_EXCEPTIONS
 };
 
-class domain_error : public logic_error { // base of all domain-error exceptions
+_EXPORT_STD class domain_error : public logic_error { // base of all domain-error exceptions
 public:
     using _Mybase = logic_error;
 
@@ -50,7 +50,7 @@ protected:
 #endif // !_HAS_EXCEPTIONS
 };
 
-class invalid_argument : public logic_error { // base of all invalid-argument exceptions
+_EXPORT_STD class invalid_argument : public logic_error { // base of all invalid-argument exceptions
 public:
     using _Mybase = logic_error;
 
@@ -66,7 +66,7 @@ protected:
 #endif // !_HAS_EXCEPTIONS
 };
 
-class length_error : public logic_error { // base of all length-error exceptions
+_EXPORT_STD class length_error : public logic_error { // base of all length-error exceptions
 public:
     using _Mybase = logic_error;
 
@@ -82,7 +82,7 @@ protected:
 #endif // !_HAS_EXCEPTIONS
 };
 
-class out_of_range : public logic_error { // base of all out-of-range exceptions
+_EXPORT_STD class out_of_range : public logic_error { // base of all out-of-range exceptions
 public:
     using _Mybase = logic_error;
 
@@ -98,7 +98,7 @@ protected:
 #endif // !_HAS_EXCEPTIONS
 };
 
-class runtime_error : public exception { // base of all runtime-error exceptions
+_EXPORT_STD class runtime_error : public exception { // base of all runtime-error exceptions
 public:
     using _Mybase = exception;
 
@@ -114,7 +114,7 @@ protected:
 #endif // !_HAS_EXCEPTIONS
 };
 
-class overflow_error : public runtime_error { // base of all overflow-error exceptions
+_EXPORT_STD class overflow_error : public runtime_error { // base of all overflow-error exceptions
 public:
     using _Mybase = runtime_error;
 
@@ -130,7 +130,7 @@ protected:
 #endif // !_HAS_EXCEPTIONS
 };
 
-class underflow_error : public runtime_error { // base of all underflow-error exceptions
+_EXPORT_STD class underflow_error : public runtime_error { // base of all underflow-error exceptions
 public:
     using _Mybase = runtime_error;
 
@@ -146,7 +146,7 @@ protected:
 #endif // !_HAS_EXCEPTIONS
 };
 
-class range_error : public runtime_error { // base of all range-error exceptions
+_EXPORT_STD class range_error : public runtime_error { // base of all range-error exceptions
 public:
     using _Mybase = runtime_error;
 
diff --git a/stl/inc/stop_token b/stl/inc/stop_token
index 39152a0ed8..3f02d984e4 100644
--- a/stl/inc/stop_token
+++ b/stl/inc/stop_token
@@ -25,14 +25,12 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-struct nostopstate_t {
-    explicit nostopstate_t() = default;
-};
+_EXPORT_STD struct nostopstate_t { explicit nostopstate_t() = default; };
 
-inline constexpr nostopstate_t nostopstate{};
+_EXPORT_STD inline constexpr nostopstate_t nostopstate{};
 
 struct _Stop_state;
-class stop_token;
+_EXPORT_STD class stop_token;
 
 class _Stop_callback_base {
     friend _Stop_state;
@@ -114,9 +112,9 @@ struct _Stop_state {
     }
 };
 
-class stop_source;
+_EXPORT_STD class stop_source;
 
-class stop_token {
+_EXPORT_STD class stop_token {
     friend stop_source;
     friend _Stop_callback_base;
 
@@ -175,7 +173,7 @@ private:
     _Stop_state* _State;
 };
 
-class stop_source {
+_EXPORT_STD class stop_source {
 public:
     stop_source() : _State{new _Stop_state} {}
     explicit stop_source(nostopstate_t) noexcept : _State{} {}
@@ -353,7 +351,7 @@ inline void _Stop_callback_base::_Detach() noexcept {
     _Token._State->_Current_callback.wait(this, memory_order_acquire);
 }
 
-template <class _Callback>
+_EXPORT_STD template <class _Callback>
 class stop_callback : public _Stop_callback_base {
 public:
     using callback_type = _Callback;
diff --git a/stl/inc/streambuf b/stl/inc/streambuf
index 2cbe9506e8..bc79182cbd 100644
--- a/stl/inc/streambuf
+++ b/stl/inc/streambuf
@@ -18,7 +18,7 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-template <class _Elem, class _Traits>
+_EXPORT_STD extern "C++" template <class _Elem, class _Traits>
 class basic_streambuf { // control read/write buffers
 protected:
     __CLR_OR_THIS_CALL basic_streambuf() : _Plocale(new locale) {
diff --git a/stl/inc/string b/stl/inc/string
index 60f14cd1b3..7c939d25b4 100644
--- a/stl/inc/string
+++ b/stl/inc/string
@@ -22,7 +22,7 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 basic_istream<_Elem, _Traits>& getline(
     basic_istream<_Elem, _Traits>&& _Istr, basic_string<_Elem, _Traits, _Alloc>& _Str, const _Elem _Delim) {
     // get characters into string, discard delimiter
@@ -65,28 +65,28 @@ basic_istream<_Elem, _Traits>& getline(
     return static_cast<basic_istream<_Elem, _Traits>&>(_Istr);
 }
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 basic_istream<_Elem, _Traits>& getline(
     basic_istream<_Elem, _Traits>&& _Istr, basic_string<_Elem, _Traits, _Alloc>& _Str) {
     // get characters into string, discard newline
     return getline(_Istr, _Str, _Istr.widen('\n'));
 }
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 basic_istream<_Elem, _Traits>& getline(
     basic_istream<_Elem, _Traits>& _Istr, basic_string<_Elem, _Traits, _Alloc>& _Str, const _Elem _Delim) {
     // get characters into string, discard delimiter
     return getline(_STD move(_Istr), _Str, _Delim);
 }
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 basic_istream<_Elem, _Traits>& getline(
     basic_istream<_Elem, _Traits>& _Istr, basic_string<_Elem, _Traits, _Alloc>& _Str) {
     // get characters into string, discard newline
     return getline(_STD move(_Istr), _Str, _Istr.widen('\n'));
 }
 
-_NODISCARD inline int stoi(const string& _Str, size_t* _Idx = nullptr, int _Base = 10) {
+_EXPORT_STD _NODISCARD inline int stoi(const string& _Str, size_t* _Idx = nullptr, int _Base = 10) {
     int& _Errno_ref  = errno; // Nonzero cost, pay it once
     const char* _Ptr = _Str.c_str();
     char* _Eptr;
@@ -108,7 +108,7 @@ _NODISCARD inline int stoi(const string& _Str, size_t* _Idx = nullptr, int _Base
     return static_cast<int>(_Ans);
 }
 
-_NODISCARD inline long stol(const string& _Str, size_t* _Idx = nullptr, int _Base = 10) {
+_EXPORT_STD _NODISCARD inline long stol(const string& _Str, size_t* _Idx = nullptr, int _Base = 10) {
     int& _Errno_ref  = errno; // Nonzero cost, pay it once
     const char* _Ptr = _Str.c_str();
     char* _Eptr;
@@ -130,7 +130,7 @@ _NODISCARD inline long stol(const string& _Str, size_t* _Idx = nullptr, int _Bas
     return _Ans;
 }
 
-_NODISCARD inline unsigned long stoul(const string& _Str, size_t* _Idx = nullptr, int _Base = 10) {
+_EXPORT_STD _NODISCARD inline unsigned long stoul(const string& _Str, size_t* _Idx = nullptr, int _Base = 10) {
     int& _Errno_ref  = errno; // Nonzero cost, pay it once
     const char* _Ptr = _Str.c_str();
     char* _Eptr;
@@ -152,7 +152,7 @@ _NODISCARD inline unsigned long stoul(const string& _Str, size_t* _Idx = nullptr
     return _Ans;
 }
 
-_NODISCARD inline long long stoll(const string& _Str, size_t* _Idx = nullptr, int _Base = 10) {
+_EXPORT_STD _NODISCARD inline long long stoll(const string& _Str, size_t* _Idx = nullptr, int _Base = 10) {
     int& _Errno_ref  = errno; // Nonzero cost, pay it once
     const char* _Ptr = _Str.c_str();
     char* _Eptr;
@@ -174,7 +174,7 @@ _NODISCARD inline long long stoll(const string& _Str, size_t* _Idx = nullptr, in
     return _Ans;
 }
 
-_NODISCARD inline unsigned long long stoull(const string& _Str, size_t* _Idx = nullptr, int _Base = 10) {
+_EXPORT_STD _NODISCARD inline unsigned long long stoull(const string& _Str, size_t* _Idx = nullptr, int _Base = 10) {
     int& _Errno_ref  = errno; // Nonzero cost, pay it once
     const char* _Ptr = _Str.c_str();
     char* _Eptr;
@@ -196,7 +196,7 @@ _NODISCARD inline unsigned long long stoull(const string& _Str, size_t* _Idx = n
     return _Ans;
 }
 
-_NODISCARD inline float stof(const string& _Str, size_t* _Idx = nullptr) {
+_EXPORT_STD _NODISCARD inline float stof(const string& _Str, size_t* _Idx = nullptr) {
     int& _Errno_ref  = errno; // Nonzero cost, pay it once
     const char* _Ptr = _Str.c_str();
     char* _Eptr;
@@ -218,7 +218,7 @@ _NODISCARD inline float stof(const string& _Str, size_t* _Idx = nullptr) {
     return _Ans;
 }
 
-_NODISCARD inline double stod(const string& _Str, size_t* _Idx = nullptr) {
+_EXPORT_STD _NODISCARD inline double stod(const string& _Str, size_t* _Idx = nullptr) {
     int& _Errno_ref  = errno; // Nonzero cost, pay it once
     const char* _Ptr = _Str.c_str();
     char* _Eptr;
@@ -240,7 +240,7 @@ _NODISCARD inline double stod(const string& _Str, size_t* _Idx = nullptr) {
     return _Ans;
 }
 
-_NODISCARD inline long double stold(const string& _Str, size_t* _Idx = nullptr) {
+_EXPORT_STD _NODISCARD inline long double stold(const string& _Str, size_t* _Idx = nullptr) {
     int& _Errno_ref  = errno; // Nonzero cost, pay it once
     const char* _Ptr = _Str.c_str();
     char* _Eptr;
@@ -262,7 +262,7 @@ _NODISCARD inline long double stold(const string& _Str, size_t* _Idx = nullptr)
     return _Ans;
 }
 
-_NODISCARD inline int stoi(const wstring& _Str, size_t* _Idx = nullptr, int _Base = 10) {
+_EXPORT_STD _NODISCARD inline int stoi(const wstring& _Str, size_t* _Idx = nullptr, int _Base = 10) {
     int& _Errno_ref     = errno; // Nonzero cost, pay it once
     const wchar_t* _Ptr = _Str.c_str();
     wchar_t* _Eptr;
@@ -284,7 +284,7 @@ _NODISCARD inline int stoi(const wstring& _Str, size_t* _Idx = nullptr, int _Bas
     return static_cast<int>(_Ans);
 }
 
-_NODISCARD inline long stol(const wstring& _Str, size_t* _Idx = nullptr, int _Base = 10) {
+_EXPORT_STD _NODISCARD inline long stol(const wstring& _Str, size_t* _Idx = nullptr, int _Base = 10) {
     int& _Errno_ref     = errno; // Nonzero cost, pay it once
     const wchar_t* _Ptr = _Str.c_str();
     wchar_t* _Eptr;
@@ -306,7 +306,7 @@ _NODISCARD inline long stol(const wstring& _Str, size_t* _Idx = nullptr, int _Ba
     return _Ans;
 }
 
-_NODISCARD inline unsigned long stoul(const wstring& _Str, size_t* _Idx = nullptr, int _Base = 10) {
+_EXPORT_STD _NODISCARD inline unsigned long stoul(const wstring& _Str, size_t* _Idx = nullptr, int _Base = 10) {
     int& _Errno_ref     = errno; // Nonzero cost, pay it once
     const wchar_t* _Ptr = _Str.c_str();
     wchar_t* _Eptr;
@@ -328,7 +328,7 @@ _NODISCARD inline unsigned long stoul(const wstring& _Str, size_t* _Idx = nullpt
     return _Ans;
 }
 
-_NODISCARD inline long long stoll(const wstring& _Str, size_t* _Idx = nullptr, int _Base = 10) {
+_EXPORT_STD _NODISCARD inline long long stoll(const wstring& _Str, size_t* _Idx = nullptr, int _Base = 10) {
     int& _Errno_ref     = errno; // Nonzero cost, pay it once
     const wchar_t* _Ptr = _Str.c_str();
     wchar_t* _Eptr;
@@ -350,7 +350,7 @@ _NODISCARD inline long long stoll(const wstring& _Str, size_t* _Idx = nullptr, i
     return _Ans;
 }
 
-_NODISCARD inline unsigned long long stoull(const wstring& _Str, size_t* _Idx = nullptr, int _Base = 10) {
+_EXPORT_STD _NODISCARD inline unsigned long long stoull(const wstring& _Str, size_t* _Idx = nullptr, int _Base = 10) {
     int& _Errno_ref     = errno; // Nonzero cost, pay it once
     const wchar_t* _Ptr = _Str.c_str();
     wchar_t* _Eptr;
@@ -372,7 +372,7 @@ _NODISCARD inline unsigned long long stoull(const wstring& _Str, size_t* _Idx =
     return _Ans;
 }
 
-_NODISCARD inline float stof(const wstring& _Str, size_t* _Idx = nullptr) {
+_EXPORT_STD _NODISCARD inline float stof(const wstring& _Str, size_t* _Idx = nullptr) {
     int& _Errno_ref     = errno; // Nonzero cost, pay it once
     const wchar_t* _Ptr = _Str.c_str();
     wchar_t* _Eptr;
@@ -394,7 +394,7 @@ _NODISCARD inline float stof(const wstring& _Str, size_t* _Idx = nullptr) {
     return _Ans;
 }
 
-_NODISCARD inline double stod(const wstring& _Str, size_t* _Idx = nullptr) {
+_EXPORT_STD _NODISCARD inline double stod(const wstring& _Str, size_t* _Idx = nullptr) {
     int& _Errno_ref     = errno; // Nonzero cost, pay it once
     const wchar_t* _Ptr = _Str.c_str();
     wchar_t* _Eptr;
@@ -416,7 +416,7 @@ _NODISCARD inline double stod(const wstring& _Str, size_t* _Idx = nullptr) {
     return _Ans;
 }
 
-_NODISCARD inline long double stold(const wstring& _Str, size_t* _Idx = nullptr) {
+_EXPORT_STD _NODISCARD inline long double stold(const wstring& _Str, size_t* _Idx = nullptr) {
     int& _Errno_ref     = errno; // Nonzero cost, pay it once
     const wchar_t* _Ptr = _Str.c_str();
     wchar_t* _Eptr;
@@ -501,81 +501,81 @@ _NODISCARD basic_string<_Elem> _UIntegral_to_string(const _Ty _Val) {
     return basic_string<_Elem>(_RNext, _Buff_end);
 }
 
-_NODISCARD inline string to_string(int _Val) {
+_EXPORT_STD _NODISCARD inline string to_string(int _Val) {
     return _Integral_to_string<char>(_Val);
 }
 
-_NODISCARD inline string to_string(unsigned int _Val) {
+_EXPORT_STD _NODISCARD inline string to_string(unsigned int _Val) {
     return _UIntegral_to_string<char>(_Val);
 }
 
-_NODISCARD inline string to_string(long _Val) {
+_EXPORT_STD _NODISCARD inline string to_string(long _Val) {
     return _Integral_to_string<char>(_Val);
 }
 
-_NODISCARD inline string to_string(unsigned long _Val) {
+_EXPORT_STD _NODISCARD inline string to_string(unsigned long _Val) {
     return _UIntegral_to_string<char>(_Val);
 }
 
-_NODISCARD inline string to_string(long long _Val) {
+_EXPORT_STD _NODISCARD inline string to_string(long long _Val) {
     return _Integral_to_string<char>(_Val);
 }
 
-_NODISCARD inline string to_string(unsigned long long _Val) {
+_EXPORT_STD _NODISCARD inline string to_string(unsigned long long _Val) {
     return _UIntegral_to_string<char>(_Val);
 }
 
-_NODISCARD inline string to_string(double _Val) {
+_EXPORT_STD _NODISCARD inline string to_string(double _Val) {
     const auto _Len = static_cast<size_t>(_CSTD _scprintf("%f", _Val));
     string _Str(_Len, '\0');
     _CSTD sprintf_s(&_Str[0], _Len + 1, "%f", _Val);
     return _Str;
 }
 
-_NODISCARD inline string to_string(float _Val) {
+_EXPORT_STD _NODISCARD inline string to_string(float _Val) {
     return _STD to_string(static_cast<double>(_Val));
 }
 
-_NODISCARD inline string to_string(long double _Val) {
+_EXPORT_STD _NODISCARD inline string to_string(long double _Val) {
     return _STD to_string(static_cast<double>(_Val));
 }
 
-_NODISCARD inline wstring to_wstring(int _Val) {
+_EXPORT_STD _NODISCARD inline wstring to_wstring(int _Val) {
     return _Integral_to_string<wchar_t>(_Val);
 }
 
-_NODISCARD inline wstring to_wstring(unsigned int _Val) {
+_EXPORT_STD _NODISCARD inline wstring to_wstring(unsigned int _Val) {
     return _UIntegral_to_string<wchar_t>(_Val);
 }
 
-_NODISCARD inline wstring to_wstring(long _Val) {
+_EXPORT_STD _NODISCARD inline wstring to_wstring(long _Val) {
     return _Integral_to_string<wchar_t>(_Val);
 }
 
-_NODISCARD inline wstring to_wstring(unsigned long _Val) {
+_EXPORT_STD _NODISCARD inline wstring to_wstring(unsigned long _Val) {
     return _UIntegral_to_string<wchar_t>(_Val);
 }
 
-_NODISCARD inline wstring to_wstring(long long _Val) {
+_EXPORT_STD _NODISCARD inline wstring to_wstring(long long _Val) {
     return _Integral_to_string<wchar_t>(_Val);
 }
 
-_NODISCARD inline wstring to_wstring(unsigned long long _Val) {
+_EXPORT_STD _NODISCARD inline wstring to_wstring(unsigned long long _Val) {
     return _UIntegral_to_string<wchar_t>(_Val);
 }
 
-_NODISCARD inline wstring to_wstring(double _Val) {
+_EXPORT_STD _NODISCARD inline wstring to_wstring(double _Val) {
     const auto _Len = static_cast<size_t>(_CSTD _scwprintf(L"%f", _Val));
     wstring _Str(_Len, L'\0');
     _CSTD swprintf_s(&_Str[0], _Len + 1, L"%f", _Val);
     return _Str;
 }
 
-_NODISCARD inline wstring to_wstring(float _Val) {
+_EXPORT_STD _NODISCARD inline wstring to_wstring(float _Val) {
     return _STD to_wstring(static_cast<double>(_Val));
 }
 
-_NODISCARD inline wstring to_wstring(long double _Val) {
+_EXPORT_STD _NODISCARD inline wstring to_wstring(long double _Val) {
     return _STD to_wstring(static_cast<double>(_Val));
 }
 _STD_END
diff --git a/stl/inc/strstream b/stl/inc/strstream
index 9d79416918..3ecad5fd21 100644
--- a/stl/inc/strstream
+++ b/stl/inc/strstream
@@ -19,7 +19,7 @@ _STL_DISABLE_CLANG_WARNINGS
 
 _STD_BEGIN
 _STL_DISABLE_DEPRECATED_WARNING
-class _CXX17_DEPRECATE_STRSTREAM strstreambuf : public streambuf {
+_EXPORT_STD class _CXX17_DEPRECATE_STRSTREAM strstreambuf : public streambuf {
     // stream buffer associated with static or allocated character array
 public:
     using _Mysb = streambuf;
@@ -421,7 +421,7 @@ inline void swap(strstreambuf& _Left, strstreambuf& _Right) {
     _Left.swap(_Right);
 }
 
-class _CXX17_DEPRECATE_STRSTREAM istrstream : public istream {
+_EXPORT_STD class _CXX17_DEPRECATE_STRSTREAM istrstream : public istream {
     // input stream associated with a character array
 public:
     using _Mybase = istream;
@@ -485,7 +485,7 @@ inline void swap(istrstream& _Left, istrstream& _Right) {
     _Left.swap(_Right);
 }
 
-class _CXX17_DEPRECATE_STRSTREAM ostrstream : public ostream {
+_EXPORT_STD class _CXX17_DEPRECATE_STRSTREAM ostrstream : public ostream {
     // output stream associated with a character array
 public:
     using _Mybase = ostream;
@@ -548,7 +548,7 @@ inline void swap(ostrstream& _Left, ostrstream& _Right) {
     _Left.swap(_Right);
 }
 
-class _CXX17_DEPRECATE_STRSTREAM strstream : public iostream {
+_EXPORT_STD class _CXX17_DEPRECATE_STRSTREAM strstream : public iostream {
     // input/output stream associated with character array buffer
 public:
     using _Mybase = iostream;
diff --git a/stl/inc/syncstream b/stl/inc/syncstream
index 70c1e37dc4..2600229a92 100644
--- a/stl/inc/syncstream
+++ b/stl/inc/syncstream
@@ -66,7 +66,7 @@ protected:
     bool _Sync_recorded{false};
 };
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 class basic_syncbuf : public _Basic_syncbuf_impl<_Elem, _Traits> {
 public:
     using int_type       = typename _Traits::int_type;
@@ -308,12 +308,12 @@ private:
     _Compressed_pair<_Alloc, shared_mutex*> _Mypair{_Zero_then_variadic_args_t{}, nullptr};
 };
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 void swap(basic_syncbuf<_Elem, _Traits, _Alloc>& _Left, basic_syncbuf<_Elem, _Traits, _Alloc>& _Right) {
     _Left.swap(_Right);
 }
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 class basic_osyncstream : public basic_ostream<_Elem, _Traits> {
 public:
     using char_type      = _Elem;
diff --git a/stl/inc/system_error b/stl/inc/system_error
index 9a6609a05c..6136fd69db 100644
--- a/stl/inc/system_error
+++ b/stl/inc/system_error
@@ -30,42 +30,42 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-enum class io_errc { // error codes for ios_base::failure
+_EXPORT_STD enum class io_errc { // error codes for ios_base::failure
     stream = 1
 };
 
-template <class _Enum>
+_EXPORT_STD template <class _Enum>
 struct is_error_code_enum : false_type {};
 
 template <>
 struct is_error_code_enum<io_errc> : true_type {};
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_error_code_enum_v = is_error_code_enum<_Ty>::value;
 
-template <class _Enum>
+_EXPORT_STD template <class _Enum>
 struct is_error_condition_enum : false_type {};
 
 template <>
 struct is_error_condition_enum<errc> : true_type {};
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_error_condition_enum_v = is_error_condition_enum<_Ty>::value;
 
-class error_code;
-class error_condition;
-_NODISCARD error_code make_error_code(errc) noexcept;
-_NODISCARD error_code make_error_code(io_errc) noexcept;
-_NODISCARD error_condition make_error_condition(errc) noexcept;
-_NODISCARD error_condition make_error_condition(io_errc) noexcept;
+_EXPORT_STD class error_code;
+_EXPORT_STD class error_condition;
+_EXPORT_STD _NODISCARD error_code make_error_code(errc) noexcept;
+_EXPORT_STD _NODISCARD error_code make_error_code(io_errc) noexcept;
+_EXPORT_STD _NODISCARD error_condition make_error_condition(errc) noexcept;
+_EXPORT_STD _NODISCARD error_condition make_error_condition(io_errc) noexcept;
 
-class error_category;
+_EXPORT_STD class error_category;
 
-_NODISCARD const error_category& generic_category() noexcept;
-_NODISCARD const error_category& iostream_category() noexcept;
-_NODISCARD const error_category& system_category() noexcept;
+_EXPORT_STD _NODISCARD const error_category& generic_category() noexcept;
+_EXPORT_STD _NODISCARD const error_category& iostream_category() noexcept;
+_EXPORT_STD _NODISCARD const error_category& system_category() noexcept;
 
-class __declspec(novtable) error_category { // categorize an error
+_EXPORT_STD class __declspec(novtable) error_category { // categorize an error
 public:
     /* constexpr */ error_category() noexcept { // TRANSITION, ABI
         _Addr = reinterpret_cast<uintptr_t>(this);
@@ -123,7 +123,7 @@ protected:
 _NODISCARD inline bool _System_error_equal(const error_code&, const error_condition&) noexcept;
 #endif // _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS
 
-class error_code { // store an implementation-specific error code and category
+_EXPORT_STD class error_code { // store an implementation-specific error code and category
 public:
     error_code() noexcept : _Myval(0), _Mycat(&_STD system_category()) {} // construct non-error
 
@@ -214,7 +214,7 @@ private:
     const error_category* _Mycat; // pointer to error category
 };
 
-class error_condition { // store an abstract error code and category
+_EXPORT_STD class error_condition { // store an abstract error code and category
 public:
     error_condition() noexcept : _Myval(0), _Mycat(&_STD generic_category()) {} // construct non-error
 
@@ -303,27 +303,28 @@ _NODISCARD inline bool _System_error_equal(const error_code& _Left, const error_
     return _Left.category().equivalent(_Left.value(), _Right) || _Right.category().equivalent(_Left, _Right.value());
 }
 #else // ^^^ _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS // !_STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS vvv
-_NODISCARD inline bool operator==(const error_code& _Left, const error_code& _Right) noexcept {
+_EXPORT_STD _NODISCARD inline bool operator==(const error_code& _Left, const error_code& _Right) noexcept {
     return _Left.category() == _Right.category() && _Left.value() == _Right.value();
 }
 
-_NODISCARD inline bool operator==(const error_code& _Left, const error_condition& _Right) noexcept {
+_EXPORT_STD _NODISCARD inline bool operator==(const error_code& _Left, const error_condition& _Right) noexcept {
     return _Left.category().equivalent(_Left.value(), _Right) || _Right.category().equivalent(_Left, _Right.value());
 }
 
-_NODISCARD inline bool operator==(const error_condition& _Left, const error_condition& _Right) noexcept {
+_EXPORT_STD _NODISCARD inline bool operator==(const error_condition& _Left, const error_condition& _Right) noexcept {
     return _Left.category() == _Right.category() && _Left.value() == _Right.value();
 }
 
 #ifdef __cpp_lib_concepts
-_NODISCARD inline strong_ordering operator<=>(const error_code& _Left, const error_code& _Right) noexcept {
+_EXPORT_STD _NODISCARD inline strong_ordering operator<=>(const error_code& _Left, const error_code& _Right) noexcept {
     if (const auto _Result = _Left.category() <=> _Right.category(); _Result != 0) {
         return _Result;
     }
     return _Left.value() <=> _Right.value();
 }
 
-_NODISCARD inline strong_ordering operator<=>(const error_condition& _Left, const error_condition& _Right) noexcept {
+_EXPORT_STD _NODISCARD inline strong_ordering operator<=>(
+    const error_condition& _Left, const error_condition& _Right) noexcept {
     if (const auto _Result = _Left.category() <=> _Right.category(); _Result != 0) {
         return _Result;
     }
@@ -382,19 +383,19 @@ _NODISCARD inline error_condition error_code::default_error_condition() const no
     return category().default_error_condition(value());
 }
 
-_NODISCARD inline error_code make_error_code(errc _Ec) noexcept {
+_EXPORT_STD _NODISCARD inline error_code make_error_code(errc _Ec) noexcept {
     return error_code(static_cast<int>(_Ec), _STD generic_category());
 }
 
-_NODISCARD inline error_code make_error_code(io_errc _Ec) noexcept {
+_EXPORT_STD _NODISCARD inline error_code make_error_code(io_errc _Ec) noexcept {
     return error_code(static_cast<int>(_Ec), _STD iostream_category());
 }
 
-_NODISCARD inline error_condition make_error_condition(errc _Ec) noexcept {
+_EXPORT_STD _NODISCARD inline error_condition make_error_condition(errc _Ec) noexcept {
     return error_condition(static_cast<int>(_Ec), _STD generic_category());
 }
 
-_NODISCARD inline error_condition make_error_condition(io_errc _Ec) noexcept {
+_EXPORT_STD _NODISCARD inline error_condition make_error_condition(io_errc _Ec) noexcept {
     return error_condition(static_cast<int>(_Ec), _STD iostream_category());
 }
 
@@ -436,7 +437,7 @@ protected:
     error_code _Mycode; // the stored error code
 };
 
-class system_error : public _System_error { // base of all system-error exceptions
+_EXPORT_STD class system_error : public _System_error { // base of all system-error exceptions
 private:
     using _Mybase = _System_error;
 
@@ -471,8 +472,8 @@ protected:
     _THROW(system_error{_STD make_error_code(_Ec)});
 }
 
-_CRTIMP2_PURE const char* __CLRCALL_PURE_OR_CDECL _Syserror_map(int);
-_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Winerror_map(int);
+extern "C++" _CRTIMP2_PURE const char* __CLRCALL_PURE_OR_CDECL _Syserror_map(int);
+extern "C++" _CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Winerror_map(int);
 
 struct _System_error_message {
     char* _Str;
@@ -646,15 +647,15 @@ _NODISCARD const _Ty& _Immortalize_memcpy_image() noexcept {
 }
 #endif // choose immortalize strategy
 
-_NODISCARD inline const error_category& generic_category() noexcept {
+_EXPORT_STD _NODISCARD inline const error_category& generic_category() noexcept {
     return _Immortalize_memcpy_image<_Generic_error_category>();
 }
 
-_NODISCARD inline const error_category& iostream_category() noexcept {
+_EXPORT_STD _NODISCARD inline const error_category& iostream_category() noexcept {
     return _Immortalize_memcpy_image<_Iostream_error_category2>();
 }
 
-_NODISCARD inline const error_category& system_category() noexcept {
+_EXPORT_STD _NODISCARD inline const error_category& system_category() noexcept {
     return _Immortalize_memcpy_image<_System_error_category>();
 }
 _STD_END
diff --git a/stl/inc/thread b/stl/inc/thread
index 0865c5cd79..57841e5b6e 100644
--- a/stl/inc/thread
+++ b/stl/inc/thread
@@ -31,10 +31,10 @@ _STL_DISABLE_CLANG_WARNINGS
 
 _STD_BEGIN
 #if _HAS_CXX20
-class jthread;
+_EXPORT_STD class jthread;
 #endif // _HAS_CXX20
 
-class thread { // class for observing and managing threads
+_EXPORT_STD class thread { // class for observing and managing threads
 public:
     class id;
 
@@ -172,9 +172,9 @@ _NODISCARD auto _To_absolute_time(const chrono::duration<_Rep, _Period>& _Rel_ti
 }
 
 namespace this_thread {
-    _NODISCARD thread::id get_id() noexcept;
+    _EXPORT_STD _NODISCARD thread::id get_id() noexcept;
 
-    inline void yield() noexcept {
+    _EXPORT_STD inline void yield() noexcept {
         _Thrd_yield();
     }
 
@@ -182,7 +182,7 @@ namespace this_thread {
         _Thrd_sleep(_Abs_time);
     }
 
-    template <class _Clock, class _Duration>
+    _EXPORT_STD template <class _Clock, class _Duration>
     void sleep_until(const chrono::time_point<_Clock, _Duration>& _Abs_time) {
 #if _HAS_CXX20
         static_assert(chrono::is_clock_v<_Clock>, "Clock type required");
@@ -199,7 +199,7 @@ namespace this_thread {
         }
     }
 
-    template <class _Rep, class _Period>
+    _EXPORT_STD template <class _Rep, class _Period>
     void sleep_for(const chrono::duration<_Rep, _Period>& _Rel_time) {
         sleep_until(_To_absolute_time(_Rel_time));
     }
@@ -231,20 +231,20 @@ _NODISCARD inline thread::id thread::get_id() const noexcept {
     return _Thr._Id;
 }
 
-_NODISCARD inline thread::id this_thread::get_id() noexcept {
+_EXPORT_STD _NODISCARD inline thread::id this_thread::get_id() noexcept {
     return _Thrd_id();
 }
 
-inline void swap(thread& _Left, thread& _Right) noexcept {
+_EXPORT_STD inline void swap(thread& _Left, thread& _Right) noexcept {
     _Left.swap(_Right);
 }
 
-_NODISCARD inline bool operator==(thread::id _Left, thread::id _Right) noexcept {
+_EXPORT_STD _NODISCARD inline bool operator==(thread::id _Left, thread::id _Right) noexcept {
     return _Left._Id == _Right._Id;
 }
 
 #if _HAS_CXX20
-_NODISCARD inline strong_ordering operator<=>(thread::id _Left, thread::id _Right) noexcept {
+_EXPORT_STD _NODISCARD inline strong_ordering operator<=>(thread::id _Left, thread::id _Right) noexcept {
     return _Left._Id <=> _Right._Id;
 }
 #else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
@@ -269,7 +269,7 @@ _NODISCARD inline bool operator>=(thread::id _Left, thread::id _Right) noexcept
 }
 #endif // !_HAS_CXX20
 
-template <class _Ch, class _Tr>
+_EXPORT_STD template <class _Ch, class _Tr>
 basic_ostream<_Ch, _Tr>& operator<<(basic_ostream<_Ch, _Tr>& _Str, thread::id _Id) {
     return _Str << _Id._Id;
 }
@@ -285,7 +285,7 @@ struct hash<thread::id> {
 };
 
 #if _HAS_CXX20
-class jthread {
+_EXPORT_STD class jthread {
 public:
     using id                 = thread::id;
     using native_handle_type = thread::native_handle_type;
diff --git a/stl/inc/tuple b/stl/inc/tuple
index 35b20b2147..ef3d4a653f 100644
--- a/stl/inc/tuple
+++ b/stl/inc/tuple
@@ -129,7 +129,7 @@ struct _Ignore { // struct that ignores assignments
     }
 };
 
-_INLINE_VAR constexpr _Ignore ignore{};
+_EXPORT_STD _INLINE_VAR constexpr _Ignore ignore{};
 
 // Note: To improve throughput, this file uses extra _STD qualification for names that appear in the
 // arguments of enable_if_t. Specifically, we qualify names which appear anywhere in the STL as members of
@@ -179,7 +179,7 @@ struct _Alloc_unpack_tuple_t {
     explicit _Alloc_unpack_tuple_t() = default;
 }; // tag type to disambiguate construction (from an allocator and unpacking a tuple/pair)
 
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
 class tuple;
 
 template <>
@@ -668,14 +668,14 @@ template <class _Alloc, class... _Types>
 tuple(allocator_arg_t, _Alloc, tuple<_Types...>) -> tuple<_Types...>;
 #endif // _HAS_CXX17
 
-template <class... _Types1, class... _Types2>
+_EXPORT_STD template <class... _Types1, class... _Types2>
 _NODISCARD constexpr bool operator==(const tuple<_Types1...>& _Left, const tuple<_Types2...>& _Right) {
     static_assert(sizeof...(_Types1) == sizeof...(_Types2), "cannot compare tuples of different sizes");
     return _Left._Equals(_Right);
 }
 
 #ifdef __cpp_lib_concepts
-template <class... _Types1, class... _Types2>
+_EXPORT_STD template <class... _Types1, class... _Types2>
 _NODISCARD constexpr common_comparison_category_t<_Synth_three_way_result<_Types1, _Types2>...> operator<=>(
     const tuple<_Types1...>& _Left, const tuple<_Types2...>& _Right) {
     static_assert(sizeof...(_Types1) == sizeof...(_Types2), "cannot compare tuples of different sizes");
@@ -711,13 +711,13 @@ _NODISCARD constexpr bool operator<=(const tuple<_Types1...>& _Left, const tuple
 }
 #endif // ^^^ !defined(__cpp_lib_concepts) ^^^
 
-template <class... _Types, enable_if_t<conjunction_v<_Is_swappable<_Types>...>, int> = 0>
+_EXPORT_STD template <class... _Types, enable_if_t<conjunction_v<_Is_swappable<_Types>...>, int> = 0>
 _CONSTEXPR20 void swap(tuple<_Types...>& _Left, tuple<_Types...>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
     _Left.swap(_Right);
 }
 
 #if _HAS_CXX23
-template <class... _Types, enable_if_t<conjunction_v<is_swappable<const _Types>...>, int> = 0>
+_EXPORT_STD template <class... _Types, enable_if_t<conjunction_v<is_swappable<const _Types>...>, int> = 0>
 constexpr void swap(const tuple<_Types...>& _Left, const tuple<_Types...>& _Right) noexcept(
     noexcept(_Left.swap(_Right))) {
     _Left.swap(_Right);
@@ -738,33 +738,33 @@ struct _Tuple_element<_Ty, tuple<_This, _Rest...>> { // recursive _Tuple_element
     using _Ttype = typename _Tuple_element<_Ty, tuple<_Rest...>>::_Ttype;
 };
 
-template <size_t _Index, class... _Types>
+_EXPORT_STD template <size_t _Index, class... _Types>
 _NODISCARD constexpr tuple_element_t<_Index, tuple<_Types...>>& get(tuple<_Types...>& _Tuple) noexcept {
     using _Ttype = typename tuple_element<_Index, tuple<_Types...>>::_Ttype;
     return static_cast<_Ttype&>(_Tuple)._Myfirst._Val;
 }
 
-template <size_t _Index, class... _Types>
+_EXPORT_STD template <size_t _Index, class... _Types>
 _NODISCARD constexpr const tuple_element_t<_Index, tuple<_Types...>>& get(const tuple<_Types...>& _Tuple) noexcept {
     using _Ttype = typename tuple_element<_Index, tuple<_Types...>>::_Ttype;
     return static_cast<const _Ttype&>(_Tuple)._Myfirst._Val;
 }
 
-template <size_t _Index, class... _Types>
+_EXPORT_STD template <size_t _Index, class... _Types>
 _NODISCARD constexpr tuple_element_t<_Index, tuple<_Types...>>&& get(tuple<_Types...>&& _Tuple) noexcept {
     using _Ty    = tuple_element_t<_Index, tuple<_Types...>>;
     using _Ttype = typename tuple_element<_Index, tuple<_Types...>>::_Ttype;
     return static_cast<_Ty&&>(static_cast<_Ttype&>(_Tuple)._Myfirst._Val);
 }
 
-template <size_t _Index, class... _Types>
+_EXPORT_STD template <size_t _Index, class... _Types>
 _NODISCARD constexpr const tuple_element_t<_Index, tuple<_Types...>>&& get(const tuple<_Types...>&& _Tuple) noexcept {
     using _Ty    = tuple_element_t<_Index, tuple<_Types...>>;
     using _Ttype = typename tuple_element<_Index, tuple<_Types...>>::_Ttype;
     return static_cast<const _Ty&&>(static_cast<const _Ttype&>(_Tuple)._Myfirst._Val);
 }
 
-template <size_t _Index, class... _Types>
+_EXPORT_STD /* TRANSITION, VSO-1538698 */ template <size_t _Index, class... _Types>
 _NODISCARD constexpr auto&& _Tuple_get(tuple<_Types...>&& _Tuple) noexcept {
     // used by pair's piecewise constructor
     using _Ty    = tuple_element_t<_Index, tuple<_Types...>>;
@@ -772,25 +772,25 @@ _NODISCARD constexpr auto&& _Tuple_get(tuple<_Types...>&& _Tuple) noexcept {
     return static_cast<_Ty&&>(static_cast<_Ttype&>(_Tuple)._Myfirst._Val);
 }
 
-template <class _Ty, class... _Types>
+_EXPORT_STD template <class _Ty, class... _Types>
 _NODISCARD constexpr _Ty& get(tuple<_Types...>& _Tuple) noexcept {
     using _Ttype = typename _Tuple_element<_Ty, tuple<_Types...>>::_Ttype;
     return static_cast<_Ttype&>(_Tuple)._Myfirst._Val;
 }
 
-template <class _Ty, class... _Types>
+_EXPORT_STD template <class _Ty, class... _Types>
 _NODISCARD constexpr const _Ty& get(const tuple<_Types...>& _Tuple) noexcept {
     using _Ttype = typename _Tuple_element<_Ty, tuple<_Types...>>::_Ttype;
     return static_cast<const _Ttype&>(_Tuple)._Myfirst._Val;
 }
 
-template <class _Ty, class... _Types>
+_EXPORT_STD template <class _Ty, class... _Types>
 _NODISCARD constexpr _Ty&& get(tuple<_Types...>&& _Tuple) noexcept {
     using _Ttype = typename _Tuple_element<_Ty, tuple<_Types...>>::_Ttype;
     return static_cast<_Ty&&>(static_cast<_Ttype&>(_Tuple)._Myfirst._Val);
 }
 
-template <class _Ty, class... _Types>
+_EXPORT_STD template <class _Ty, class... _Types>
 _NODISCARD constexpr const _Ty&& get(const tuple<_Types...>&& _Tuple) noexcept {
     using _Ttype = typename _Tuple_element<_Ty, tuple<_Types...>>::_Ttype;
     return static_cast<const _Ty&&>(static_cast<const _Ttype&>(_Tuple)._Myfirst._Val);
@@ -807,36 +807,36 @@ template <class _Tag, class _Alloc, class _Tpl, size_t... _Indices,
 constexpr tuple<_This, _Rest...>::tuple(_Tag, const _Alloc& _Al, _Tpl&& _Right, index_sequence<_Indices...>)
     : tuple(_Alloc_exact_args_t{}, _Al, _STD get<_Indices>(_STD forward<_Tpl>(_Right))...) {}
 
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
 _NODISCARD constexpr tuple<_Unrefwrap_t<_Types>...> make_tuple(_Types&&... _Args) { // make tuple from elements
     using _Ttype = tuple<_Unrefwrap_t<_Types>...>;
     return _Ttype(_STD forward<_Types>(_Args)...);
 }
 
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
 _NODISCARD constexpr tuple<_Types&...> tie(_Types&... _Args) noexcept { // make tuple from elements
     using _Ttype = tuple<_Types&...>;
     return _Ttype(_Args...);
 }
 
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
 _NODISCARD constexpr tuple<_Types&&...> forward_as_tuple(_Types&&... _Args) noexcept { // forward arguments in a tuple
     return tuple<_Types&&...>(_STD forward<_Types>(_Args)...);
 }
 
-template <class _Ty, size_t _Size>
+_EXPORT_STD template <class _Ty, size_t _Size>
 class array;
 
-template <size_t _Idx, class _Ty, size_t _Size>
+_EXPORT_STD template <size_t _Idx, class _Ty, size_t _Size>
 _NODISCARD constexpr _Ty& get(array<_Ty, _Size>& _Arr) noexcept;
 
-template <size_t _Idx, class _Ty, size_t _Size>
+_EXPORT_STD template <size_t _Idx, class _Ty, size_t _Size>
 _NODISCARD constexpr const _Ty& get(const array<_Ty, _Size>& _Arr) noexcept;
 
-template <size_t _Idx, class _Ty, size_t _Size>
+_EXPORT_STD template <size_t _Idx, class _Ty, size_t _Size>
 _NODISCARD constexpr _Ty&& get(array<_Ty, _Size>&& _Arr) noexcept;
 
-template <size_t _Idx, class _Ty, size_t _Size>
+_EXPORT_STD template <size_t _Idx, class _Ty, size_t _Size>
 _NODISCARD constexpr const _Ty&& get(const array<_Ty, _Size>&& _Arr) noexcept;
 
 template <class _Ty, class _Kx_arg, class _Ix_arg, size_t _Ix_next, class... _Sequences>
@@ -864,7 +864,7 @@ constexpr _Ret _Tuple_cat(index_sequence<_Kx...>, index_sequence<_Ix...>, _Ty _A
     return _Ret{_STD get<_Kx>(_STD get<_Ix>(_STD move(_Arg)))...};
 }
 
-template <class... _Tuples>
+_EXPORT_STD template <class... _Tuples>
 _NODISCARD constexpr typename _Tuple_cat1<_Tuples...>::_Ret tuple_cat(_Tuples&&... _Tpls) { // concatenate tuples
     using _Cat1   = _Tuple_cat1<_Tuples...>;
     using _Ret    = typename _Cat1::_Ret;
@@ -880,7 +880,7 @@ constexpr decltype(auto) _Apply_impl(_Callable&& _Obj, _Tuple&& _Tpl, index_sequ
     return _STD invoke(_STD forward<_Callable>(_Obj), _STD get<_Indices>(_STD forward<_Tuple>(_Tpl))...);
 }
 
-template <class _Callable, class _Tuple>
+_EXPORT_STD template <class _Callable, class _Tuple>
 constexpr decltype(auto) apply(_Callable&& _Obj, _Tuple&& _Tpl) noexcept(
     noexcept(_Apply_impl(_STD forward<_Callable>(_Obj), _STD forward<_Tuple>(_Tpl),
         make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{}))) {
@@ -896,7 +896,7 @@ constexpr _Ty _Make_from_tuple_impl(_Tuple&& _Tpl, index_sequence<_Indices...>)
     return _Ty(_STD get<_Indices>(_STD forward<_Tuple>(_Tpl))...);
 }
 
-template <class _Ty, class _Tuple>
+_EXPORT_STD template <class _Ty, class _Tuple>
 _NODISCARD constexpr _Ty make_from_tuple(_Tuple&& _Tpl) { // construct _Ty from the elements of _Tpl
     return _Make_from_tuple_impl<_Ty>(
         _STD forward<_Tuple>(_Tpl), make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{});
diff --git a/stl/inc/type_traits b/stl/inc/type_traits
index 495a4033b9..3db08e956e 100644
--- a/stl/inc/type_traits
+++ b/stl/inc/type_traits
@@ -19,7 +19,7 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-template <class _Ty, _Ty... _Vals>
+_EXPORT_STD template <class _Ty, _Ty... _Vals>
 struct integer_sequence { // sequence of integer parameters
     static_assert(is_integral_v<_Ty>, "integer_sequence<T, I...> requires T to be an integral type.");
 
@@ -30,16 +30,16 @@ struct integer_sequence { // sequence of integer parameters
     }
 };
 
-template <class _Ty, _Ty _Size>
+_EXPORT_STD template <class _Ty, _Ty _Size>
 using make_integer_sequence = __make_integer_seq<integer_sequence, _Ty, _Size>;
 
-template <size_t... _Vals>
+_EXPORT_STD template <size_t... _Vals>
 using index_sequence = integer_sequence<size_t, _Vals...>;
 
-template <size_t _Size>
+_EXPORT_STD template <size_t _Size>
 using make_index_sequence = make_integer_sequence<size_t, _Size>;
 
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
 using index_sequence_for = make_index_sequence<sizeof...(_Types)>;
 
 template <bool _First_value, class _First, class... _Rest>
@@ -52,7 +52,7 @@ struct _Conjunction<true, _True, _Next, _Rest...> { // the first trait is true,
     using type = typename _Conjunction<_Next::value, _Next, _Rest...>::type;
 };
 
-template <class... _Traits>
+_EXPORT_STD template <class... _Traits>
 struct conjunction : true_type {}; // If _Traits is empty, true_type
 
 template <class _First, class... _Rest>
@@ -60,22 +60,22 @@ struct conjunction<_First, _Rest...> : _Conjunction<_First::value, _First, _Rest
     // the first false trait in _Traits, or the last trait if none are false
 };
 
-template <class... _Traits>
+_EXPORT_STD template <class... _Traits>
 _INLINE_VAR constexpr bool conjunction_v = conjunction<_Traits...>::value;
 
-template <class _Trait>
+_EXPORT_STD template <class _Trait>
 struct negation : bool_constant<!static_cast<bool>(_Trait::value)> {}; // The negated result of _Trait
 
-template <class _Trait>
+_EXPORT_STD template <class _Trait>
 _INLINE_VAR constexpr bool negation_v = negation<_Trait>::value;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_void_v = is_same_v<remove_cv_t<_Ty>, void>;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_void : bool_constant<is_void_v<_Ty>> {};
 
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
 using void_t = void;
 
 template <class _Ty>
@@ -86,28 +86,28 @@ template <class _Ty>
 using _Identity_t _MSVC_KNOWN_SEMANTICS = typename _Identity<_Ty>::type;
 
 // Type modifiers
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct add_const { // add top-level const qualifier
     using type = const _Ty;
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 using add_const_t = typename add_const<_Ty>::type;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct add_volatile { // add top-level volatile qualifier
     using type = volatile _Ty;
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 using add_volatile_t = typename add_volatile<_Ty>::type;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct add_cv { // add top-level const and volatile qualifiers
     using type = const volatile _Ty;
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 using add_cv_t = typename add_cv<_Ty>::type;
 
 template <class _Ty, class = void>
@@ -122,28 +122,28 @@ struct _Add_reference<_Ty, void_t<_Ty&>> { // (referenceable type)
     using _Rvalue = _Ty&&;
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct add_lvalue_reference {
     using type = typename _Add_reference<_Ty>::_Lvalue;
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 using add_lvalue_reference_t = typename _Add_reference<_Ty>::_Lvalue;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct add_rvalue_reference {
     using type = typename _Add_reference<_Ty>::_Rvalue;
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 using add_rvalue_reference_t = typename _Add_reference<_Ty>::_Rvalue;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 add_rvalue_reference_t<_Ty> declval() noexcept {
     static_assert(_Always_false<_Ty>, "Calling declval is ill-formed, see N4892 [declval]/2.");
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct remove_extent { // remove array extent
     using type = _Ty;
 };
@@ -158,10 +158,10 @@ struct remove_extent<_Ty[]> {
     using type = _Ty;
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 using remove_extent_t = typename remove_extent<_Ty>::type;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct remove_all_extents { // remove all array extents
     using type = _Ty;
 };
@@ -176,10 +176,10 @@ struct remove_all_extents<_Ty[]> {
     using type = typename remove_all_extents<_Ty>::type;
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 using remove_all_extents_t = typename remove_all_extents<_Ty>::type;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct remove_pointer {
     using type = _Ty;
 };
@@ -204,7 +204,7 @@ struct remove_pointer<_Ty* const volatile> {
     using type = _Ty;
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 using remove_pointer_t = typename remove_pointer<_Ty>::type;
 
 template <class _Ty, class = void>
@@ -217,15 +217,15 @@ struct _Add_pointer<_Ty, void_t<remove_reference_t<_Ty>*>> { // (pointer type ca
     using type = remove_reference_t<_Ty>*;
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct add_pointer {
     using type = typename _Add_pointer<_Ty>::type;
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 using add_pointer_t = typename _Add_pointer<_Ty>::type;
 
-template <class>
+_EXPORT_STD template <class>
 _INLINE_VAR constexpr bool is_array_v = false; // determine whether type argument is an array
 
 template <class _Ty, size_t _Nx>
@@ -234,48 +234,48 @@ _INLINE_VAR constexpr bool is_array_v<_Ty[_Nx]> = true;
 template <class _Ty>
 _INLINE_VAR constexpr bool is_array_v<_Ty[]> = true;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_array : bool_constant<is_array_v<_Ty>> {};
 
 #if _HAS_CXX20
-template <class>
+_EXPORT_STD template <class>
 inline constexpr bool is_bounded_array_v = false;
 
 template <class _Ty, size_t _Nx>
 inline constexpr bool is_bounded_array_v<_Ty[_Nx]> = true;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_bounded_array : bool_constant<is_bounded_array_v<_Ty>> {};
 
-template <class>
+_EXPORT_STD template <class>
 inline constexpr bool is_unbounded_array_v = false;
 
 template <class _Ty>
 inline constexpr bool is_unbounded_array_v<_Ty[]> = true;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_unbounded_array : bool_constant<is_unbounded_array_v<_Ty>> {};
 #endif // _HAS_CXX20
 
-template <class>
+_EXPORT_STD template <class>
 _INLINE_VAR constexpr bool is_lvalue_reference_v = false; // determine whether type argument is an lvalue reference
 
 template <class _Ty>
 _INLINE_VAR constexpr bool is_lvalue_reference_v<_Ty&> = true;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_lvalue_reference : bool_constant<is_lvalue_reference_v<_Ty>> {};
 
-template <class>
+_EXPORT_STD template <class>
 _INLINE_VAR constexpr bool is_rvalue_reference_v = false; // determine whether type argument is an rvalue reference
 
 template <class _Ty>
 _INLINE_VAR constexpr bool is_rvalue_reference_v<_Ty&&> = true;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_rvalue_reference : bool_constant<is_rvalue_reference_v<_Ty>> {};
 
-template <class>
+_EXPORT_STD template <class>
 _INLINE_VAR constexpr bool is_reference_v = false; // determine whether type argument is a reference
 
 template <class _Ty>
@@ -284,10 +284,10 @@ _INLINE_VAR constexpr bool is_reference_v<_Ty&> = true;
 template <class _Ty>
 _INLINE_VAR constexpr bool is_reference_v<_Ty&&> = true;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_reference : bool_constant<is_reference_v<_Ty>> {};
 
-template <class>
+_EXPORT_STD template <class>
 _INLINE_VAR constexpr bool is_pointer_v = false; // determine whether _Ty is a pointer
 
 template <class _Ty>
@@ -302,40 +302,40 @@ _INLINE_VAR constexpr bool is_pointer_v<_Ty* volatile> = true;
 template <class _Ty>
 _INLINE_VAR constexpr bool is_pointer_v<_Ty* const volatile> = true;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_pointer : bool_constant<is_pointer_v<_Ty>> {};
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_null_pointer_v =
     is_same_v<remove_cv_t<_Ty>, nullptr_t>; // determine whether _Ty is cv-qualified nullptr_t
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_null_pointer : bool_constant<is_null_pointer_v<_Ty>> {};
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_union : bool_constant<__is_union(_Ty)> {}; // determine whether _Ty is a union
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_union_v = __is_union(_Ty);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_class : bool_constant<__is_class(_Ty)> {}; // determine whether _Ty is a class
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_class_v = __is_class(_Ty);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_fundamental_v = is_arithmetic_v<_Ty> || is_void_v<_Ty> || is_null_pointer_v<_Ty>;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_fundamental : bool_constant<is_fundamental_v<_Ty>> {}; // determine whether _Ty is a fundamental type
 
-template <class _From, class _To>
+_EXPORT_STD template <class _From, class _To>
 struct is_convertible : bool_constant<__is_convertible_to(_From, _To)> {
     // determine whether _From is convertible to _To
 };
 
-template <class _From, class _To>
+_EXPORT_STD template <class _From, class _To>
 _INLINE_VAR constexpr bool is_convertible_v = __is_convertible_to(_From, _To);
 
 #if !defined(__EDG__) && !defined(__clang__) // TRANSITION, DevCom-1627396
@@ -364,24 +364,24 @@ template <class _Ty>
 _INLINE_VAR constexpr bool is_convertible_v<volatile _Ty&, const volatile _Ty&> = true;
 #endif // ^^^ workaround
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_enum : bool_constant<__is_enum(_Ty)> {}; // determine whether _Ty is an enumerated type
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_enum_v = __is_enum(_Ty);
 
 #if _HAS_CXX23
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 inline constexpr bool is_scoped_enum_v = conjunction_v<is_enum<_Ty>, negation<is_convertible<_Ty, int>>>;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_scoped_enum : bool_constant<is_scoped_enum_v<_Ty>> {};
 #endif // _HAS_CXX23
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_compound : bool_constant<!is_fundamental_v<_Ty>> {}; // determine whether _Ty is a compound type
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_compound_v = !is_fundamental_v<_Ty>;
 
 template <class... _Types>
@@ -446,46 +446,46 @@ _NON_MEMBER_CALL(_IS_MEMFUNPTR_EXPLICIT_THIS_GUIDES, , , noexcept)
 #endif // _HAS_CXX23 && !defined(__clang__)
 
 #ifdef __clang__
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_member_function_pointer_v = __is_member_function_pointer(_Ty);
 #else // ^^^ Clang ^^^ / vvv Other vvv
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_member_function_pointer_v = _Is_memfunptr<remove_cv_t<_Ty>>::_Bool_type::value;
 #endif // ^^^ Other ^^^
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_member_function_pointer : bool_constant<is_member_function_pointer_v<_Ty>> {};
 
-template <class>
+_EXPORT_STD template <class>
 _INLINE_VAR constexpr bool is_const_v = false; // determine whether type argument is const qualified
 
 template <class _Ty>
 _INLINE_VAR constexpr bool is_const_v<const _Ty> = true;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_const : bool_constant<is_const_v<_Ty>> {};
 
-template <class>
+_EXPORT_STD template <class>
 _INLINE_VAR constexpr bool is_volatile_v = false; // determine whether type argument is volatile qualified
 
 template <class _Ty>
 _INLINE_VAR constexpr bool is_volatile_v<volatile _Ty> = true;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_volatile : bool_constant<is_volatile_v<_Ty>> {};
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_function_v = // only function types and reference types can't be const qualified
     !is_const_v<const _Ty> && !is_reference_v<_Ty>;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_function : bool_constant<is_function_v<_Ty>> {};
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_object_v = // only function types and reference types can't be const qualified
     is_const_v<const _Ty> && !is_void_v<_Ty>;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_object : bool_constant<is_object_v<_Ty>> {};
 
 template <class>
@@ -500,150 +500,150 @@ struct _Is_member_object_pointer<_Ty1 _Ty2::*> {
 };
 
 #ifdef __clang__
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_member_object_pointer_v = __is_member_object_pointer(_Ty);
 #else // ^^^ Clang / Other vvv
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_member_object_pointer_v = _Is_member_object_pointer<remove_cv_t<_Ty>>::value;
 #endif // ^^^ Other ^^^
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_member_object_pointer : bool_constant<is_member_object_pointer_v<_Ty>> {};
 
 #ifdef __clang__
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_member_pointer_v = __is_member_pointer(_Ty);
 #else // ^^^ Clang / Other vvv
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_member_pointer_v = is_member_object_pointer_v<_Ty> || is_member_function_pointer_v<_Ty>;
 #endif // ^^^ Other ^^^
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_member_pointer : bool_constant<is_member_pointer_v<_Ty>> {}; // determine whether _Ty is a pointer to member
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_scalar_v = // determine whether _Ty is a scalar type
     is_arithmetic_v<_Ty> || is_enum_v<_Ty> || is_pointer_v<_Ty> || is_member_pointer_v<_Ty> || is_null_pointer_v<_Ty>;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_scalar : bool_constant<is_scalar_v<_Ty>> {};
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct _CXX20_DEPRECATE_IS_POD is_pod : bool_constant<__is_pod(_Ty)> {}; // determine whether _Ty is a POD type
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _CXX20_DEPRECATE_IS_POD _INLINE_VAR constexpr bool is_pod_v = __is_pod(_Ty);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_empty : bool_constant<__is_empty(_Ty)> {}; // determine whether _Ty is an empty class
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_empty_v = __is_empty(_Ty);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_polymorphic : bool_constant<__is_polymorphic(_Ty)> {}; // determine whether _Ty is a polymorphic type
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_polymorphic_v = __is_polymorphic(_Ty);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_abstract : bool_constant<__is_abstract(_Ty)> {}; // determine whether _Ty is an abstract class
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_abstract_v = __is_abstract(_Ty);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_final : bool_constant<__is_final(_Ty)> {}; // determine whether _Ty is a final class
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_final_v = __is_final(_Ty);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_standard_layout : bool_constant<__is_standard_layout(_Ty)> {}; // determine whether _Ty is standard layout
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_standard_layout_v = __is_standard_layout(_Ty);
 
 #if _HAS_DEPRECATED_IS_LITERAL_TYPE
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct _CXX17_DEPRECATE_IS_LITERAL_TYPE is_literal_type : bool_constant<__is_literal_type(_Ty)> {
     // determine whether _Ty is a literal type
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _CXX17_DEPRECATE_IS_LITERAL_TYPE _INLINE_VAR constexpr bool is_literal_type_v = __is_literal_type(_Ty);
 #endif // _HAS_DEPRECATED_IS_LITERAL_TYPE
 
 #if 1 // TRANSITION, VSO-119526 and LLVM-41915
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_trivial : bool_constant<__is_trivially_constructible(_Ty) && __is_trivially_copyable(_Ty)> {
     // determine whether _Ty is a trivial type
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_trivial_v = __is_trivially_constructible(_Ty) && __is_trivially_copyable(_Ty);
 #else // ^^^ workaround / no workaround vvv
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_trivial : bool_constant<__is_trivial(_Ty)> {}; // determine whether _Ty is a trivial type
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_trivial_v = __is_trivial(_Ty);
 #endif // TRANSITION
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_trivially_copyable : bool_constant<__is_trivially_copyable(_Ty)> {
     // determine whether _Ty is a trivially copyable type
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Ty);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct has_virtual_destructor : bool_constant<__has_virtual_destructor(_Ty)> {
     // determine whether _Ty has a virtual destructor
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool has_virtual_destructor_v = __has_virtual_destructor(_Ty);
 
 #if _HAS_CXX17
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct has_unique_object_representations : bool_constant<__has_unique_object_representations(_Ty)> {
     // determine whether _Ty has unique object representations
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool has_unique_object_representations_v = __has_unique_object_representations(_Ty);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_aggregate : bool_constant<__is_aggregate(_Ty)> {}; // determine whether _Ty is an aggregate
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_aggregate_v = __is_aggregate(_Ty);
 #endif // _HAS_CXX17
 
-template <class _Ty, class... _Args>
+_EXPORT_STD template <class _Ty, class... _Args>
 struct is_constructible : bool_constant<__is_constructible(_Ty, _Args...)> {
     // determine whether _Ty can be direct-initialized with _Args...
 };
 
-template <class _Ty, class... _Args>
+_EXPORT_STD template <class _Ty, class... _Args>
 _INLINE_VAR constexpr bool is_constructible_v = __is_constructible(_Ty, _Args...);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_copy_constructible : bool_constant<__is_constructible(_Ty, add_lvalue_reference_t<const _Ty>)> {
     // determine whether _Ty can be direct-initialized with an lvalue const _Ty
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_copy_constructible_v = __is_constructible(_Ty, add_lvalue_reference_t<const _Ty>);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_default_constructible : bool_constant<__is_constructible(_Ty)> {
     // determine whether _Ty can be value-initialized
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_default_constructible_v = __is_constructible(_Ty);
 
 template <class _Ty, class = void>
@@ -658,18 +658,18 @@ template <class _Ty>
 struct _Is_implicitly_default_constructible<_Ty, void_t<decltype(_Implicitly_default_construct<_Ty>({}))>> : true_type {
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_move_constructible : bool_constant<__is_constructible(_Ty, _Ty)> {
     // determine whether _Ty can be direct-initialized from an rvalue _Ty
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_move_constructible_v = __is_constructible(_Ty, _Ty);
 
-template <class _To, class _From>
+_EXPORT_STD template <class _To, class _From>
 struct is_assignable : bool_constant<__is_assignable(_To, _From)> {}; // determine whether _From can be assigned to _To
 
-template <class _To, class _From>
+_EXPORT_STD template <class _To, class _From>
 _INLINE_VAR constexpr bool is_assignable_v = __is_assignable(_To, _From);
 
 #if defined(_IS_ASSIGNABLE_NOCHECK_SUPPORTED) && !defined(__CUDACC__)
@@ -680,15 +680,15 @@ template <class _To, class _From>
 using _Is_assignable_no_precondition_check = is_assignable<_To, _From>;
 #endif // defined(_IS_ASSIGNABLE_NOCHECK_SUPPORTED) && !defined(__CUDACC__)
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_copy_assignable
     : bool_constant<__is_assignable(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>)> {
     // determine whether an lvalue const _Ty can be assigned to an lvalue _Ty
 };
 
-template <class _Ty>
-_INLINE_VAR constexpr bool is_copy_assignable_v = __is_assignable(
-    add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>);
+_EXPORT_STD template <class _Ty>
+_INLINE_VAR constexpr bool is_copy_assignable_v =
+    __is_assignable(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>);
 
 #if defined(_IS_ASSIGNABLE_NOCHECK_SUPPORTED) && !defined(__CUDACC__)
 template <class _Ty>
@@ -707,12 +707,12 @@ template <class _Ty>
 _INLINE_VAR constexpr bool _Is_copy_assignable_unchecked_v = is_copy_assignable_v<_Ty>;
 #endif // defined(_IS_ASSIGNABLE_NOCHECK_SUPPORTED) && !defined(__CUDACC__)
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_move_assignable : bool_constant<__is_assignable(add_lvalue_reference_t<_Ty>, _Ty)> {
     // determine whether an rvalue _Ty can be assigned to an lvalue _Ty
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_move_assignable_v = __is_assignable(add_lvalue_reference_t<_Ty>, _Ty);
 
 #if defined(_IS_ASSIGNABLE_NOCHECK_SUPPORTED) && !defined(__CUDACC__)
@@ -731,150 +731,150 @@ template <class _Ty>
 _INLINE_VAR constexpr bool _Is_move_assignable_unchecked_v = is_move_assignable_v<_Ty>;
 #endif // defined(_IS_ASSIGNABLE_NOCHECK_SUPPORTED) && !defined(__CUDACC__)
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_destructible : bool_constant<__is_destructible(_Ty)> {
     // true iff remove_all_extents_t<_Ty> is a reference type, or can be explicitly destroyed
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_destructible_v = __is_destructible(_Ty);
 
-template <class _Ty, class... _Args>
+_EXPORT_STD template <class _Ty, class... _Args>
 struct is_trivially_constructible : bool_constant<__is_trivially_constructible(_Ty, _Args...)> {
     // determine whether direct-initialization of _Ty with _Args... is trivial
 };
 
-template <class _Ty, class... _Args>
+_EXPORT_STD template <class _Ty, class... _Args>
 _INLINE_VAR constexpr bool is_trivially_constructible_v = __is_trivially_constructible(_Ty, _Args...);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_trivially_copy_constructible
     : bool_constant<__is_trivially_constructible(_Ty, add_lvalue_reference_t<const _Ty>)> {
     // determine whether direct-initialization of _Ty with an lvalue const _Ty is trivial
 };
 
-template <class _Ty>
-_INLINE_VAR constexpr bool is_trivially_copy_constructible_v = __is_trivially_constructible(
-    _Ty, add_lvalue_reference_t<const _Ty>);
+_EXPORT_STD template <class _Ty>
+_INLINE_VAR constexpr bool is_trivially_copy_constructible_v =
+    __is_trivially_constructible(_Ty, add_lvalue_reference_t<const _Ty>);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_trivially_default_constructible : bool_constant<__is_trivially_constructible(_Ty)> {
     // determine whether value-initialization of _Ty is trivial
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_trivially_default_constructible_v = __is_trivially_constructible(_Ty);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_trivially_move_constructible : bool_constant<__is_trivially_constructible(_Ty, _Ty)> {
     // determine whether direct-initialization of _Ty with an rvalue _Ty is trivial
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_trivially_move_constructible_v = __is_trivially_constructible(_Ty, _Ty);
 
-template <class _To, class _From>
+_EXPORT_STD template <class _To, class _From>
 struct is_trivially_assignable : bool_constant<__is_trivially_assignable(_To, _From)> {
     // determine whether _From can be trivially assigned to _To
 };
 
-template <class _To, class _From>
+_EXPORT_STD template <class _To, class _From>
 _INLINE_VAR constexpr bool is_trivially_assignable_v = __is_trivially_assignable(_To, _From);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_trivially_copy_assignable
     : bool_constant<__is_trivially_assignable(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>)> {
     // determine whether an lvalue const _Ty can be trivially assigned to an lvalue _Ty
 };
 
-template <class _Ty>
-_INLINE_VAR constexpr bool is_trivially_copy_assignable_v = __is_trivially_assignable(
-    add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>);
+_EXPORT_STD template <class _Ty>
+_INLINE_VAR constexpr bool is_trivially_copy_assignable_v =
+    __is_trivially_assignable(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_trivially_move_assignable : bool_constant<__is_trivially_assignable(add_lvalue_reference_t<_Ty>, _Ty)> {
     // determine whether an rvalue _Ty can be trivially assigned to an lvalue _Ty
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_trivially_move_assignable_v = __is_trivially_assignable(add_lvalue_reference_t<_Ty>, _Ty);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_trivially_destructible : bool_constant<__is_trivially_destructible(_Ty)> {
     // determine whether remove_all_extents_t<_Ty> is a reference type or can trivially be explicitly destroyed
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_trivially_destructible_v = __is_trivially_destructible(_Ty);
 
-template <class _Ty, class... _Args>
+_EXPORT_STD template <class _Ty, class... _Args>
 struct is_nothrow_constructible : bool_constant<__is_nothrow_constructible(_Ty, _Args...)> {
     // determine whether direct-initialization of _Ty from _Args... is both valid and not potentially-throwing
 };
 
-template <class _Ty, class... _Args>
+_EXPORT_STD template <class _Ty, class... _Args>
 _INLINE_VAR constexpr bool is_nothrow_constructible_v = __is_nothrow_constructible(_Ty, _Args...);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_nothrow_copy_constructible
     : bool_constant<__is_nothrow_constructible(_Ty, add_lvalue_reference_t<const _Ty>)> {
     // determine whether direct-initialization of _Ty from an lvalue const _Ty is both valid
     // and not potentially-throwing
 };
 
-template <class _Ty>
-_INLINE_VAR constexpr bool is_nothrow_copy_constructible_v = __is_nothrow_constructible(
-    _Ty, add_lvalue_reference_t<const _Ty>);
+_EXPORT_STD template <class _Ty>
+_INLINE_VAR constexpr bool is_nothrow_copy_constructible_v =
+    __is_nothrow_constructible(_Ty, add_lvalue_reference_t<const _Ty>);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_nothrow_default_constructible : bool_constant<__is_nothrow_constructible(_Ty)> {
     // determine whether value-initialization of _Ty is both valid and not potentially-throwing
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_nothrow_default_constructible_v = __is_nothrow_constructible(_Ty);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_nothrow_move_constructible : bool_constant<__is_nothrow_constructible(_Ty, _Ty)> {
     // determine whether direct-initialization of _Ty from an rvalue _Ty is both valid and not potentially-throwing
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_nothrow_move_constructible_v = __is_nothrow_constructible(_Ty, _Ty);
 
-template <class _To, class _From>
+_EXPORT_STD template <class _To, class _From>
 struct is_nothrow_assignable : bool_constant<__is_nothrow_assignable(_To, _From)> {
     // determine whether assignment of _From to _To is both valid and not potentially-throwing
 };
 
-template <class _To, class _From>
+_EXPORT_STD template <class _To, class _From>
 _INLINE_VAR constexpr bool is_nothrow_assignable_v = __is_nothrow_assignable(_To, _From);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_nothrow_copy_assignable
     : bool_constant<__is_nothrow_assignable(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>)> {
     // determine whether assignment of an lvalue const _Ty to an lvalue _Ty is both valid and not potentially-throwing
 };
 
-template <class _Ty>
-_INLINE_VAR constexpr bool is_nothrow_copy_assignable_v = __is_nothrow_assignable(
-    add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>);
+_EXPORT_STD template <class _Ty>
+_INLINE_VAR constexpr bool is_nothrow_copy_assignable_v =
+    __is_nothrow_assignable(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_nothrow_move_assignable : bool_constant<__is_nothrow_assignable(add_lvalue_reference_t<_Ty>, _Ty)> {
     // determine whether assignment of an rvalue _Ty to an lvalue _Ty is both valid and not potentially-throwing
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_nothrow_move_assignable_v = __is_nothrow_assignable(add_lvalue_reference_t<_Ty>, _Ty);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_nothrow_destructible : bool_constant<__is_nothrow_destructible(_Ty)> {
     // determine whether remove_all_extents_t<_Ty> is a reference type or has
     // non-potentially-throwing explicit destruction
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_nothrow_destructible_v = __is_nothrow_destructible(_Ty);
 
 template <class _Ty, bool = is_integral_v<_Ty>>
@@ -892,16 +892,16 @@ struct _Sign_base<_Ty, false> { // floating-point _Ty is signed
     static constexpr bool _Unsigned = false;
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_signed : bool_constant<_Sign_base<_Ty>::_Signed> {}; // determine whether _Ty is a signed type
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_signed_v = _Sign_base<_Ty>::_Signed;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_unsigned : bool_constant<_Sign_base<_Ty>::_Unsigned> {}; // determine whether _Ty is an unsigned type
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_unsigned_v = _Sign_base<_Ty>::_Unsigned;
 
 template <class _Ty>
@@ -951,7 +951,7 @@ template <class _Ty>
 using _Make_signed1 = // signed partner to cv-unqualified _Ty
     typename _Make_signed2<sizeof(_Ty)>::template _Apply<_Ty>;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct make_signed { // signed partner to _Ty
     static_assert(_Is_nonbool_integral<_Ty> || is_enum_v<_Ty>,
         "make_signed<T> requires that T shall be a (possibly cv-qualified) "
@@ -960,7 +960,7 @@ struct make_signed { // signed partner to _Ty
     using type = typename remove_cv<_Ty>::template _Apply<_Make_signed1>;
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 using make_signed_t = typename make_signed<_Ty>::type;
 
 template <size_t>
@@ -996,7 +996,7 @@ template <class _Ty>
 using _Make_unsigned1 = // unsigned partner to cv-unqualified _Ty
     typename _Make_unsigned2<sizeof(_Ty)>::template _Apply<_Ty>;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct make_unsigned { // unsigned partner to _Ty
     static_assert(_Is_nonbool_integral<_Ty> || is_enum_v<_Ty>,
         "make_unsigned<T> requires that T shall be a (possibly cv-qualified) "
@@ -1005,7 +1005,7 @@ struct make_unsigned { // unsigned partner to _Ty
     using type = typename remove_cv<_Ty>::template _Apply<_Make_unsigned1>;
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 using make_unsigned_t = typename make_unsigned<_Ty>::type;
 
 template <class _Rep>
@@ -1013,10 +1013,10 @@ constexpr make_unsigned_t<_Rep> _Unsigned_value(_Rep _Val) { // makes _Val unsig
     return static_cast<make_unsigned_t<_Rep>>(_Val);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct alignment_of : integral_constant<size_t, alignof(_Ty)> {}; // determine alignment of _Ty
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr size_t alignment_of_v = alignof(_Ty);
 
 template <class _Ty, size_t _Len>
@@ -1087,12 +1087,12 @@ struct _Aligned_storage { // define type with size _Len and alignment _Align
 template <size_t _Len, size_t _Align = alignof(max_align_t)>
 using _Aligned_storage_t = typename _Aligned_storage<_Len, _Align>::type;
 
-template <size_t _Len, size_t _Align = alignof(max_align_t)>
+_EXPORT_STD template <size_t _Len, size_t _Align = alignof(max_align_t)>
 struct _CXX23_DEPRECATE_ALIGNED_STORAGE aligned_storage { // define type with size _Len and alignment _Align
     using type = _Aligned_storage_t<_Len, _Align>;
 };
 
-template <size_t _Len, size_t _Align = alignof(max_align_t)>
+_EXPORT_STD template <size_t _Len, size_t _Align = alignof(max_align_t)>
 using aligned_storage_t _CXX23_DEPRECATE_ALIGNED_STORAGE = _Aligned_storage_t<_Len, _Align>;
 
 template <size_t... _Vals>
@@ -1109,7 +1109,7 @@ struct _Maximum<_First, _Second, _Rest...> : _Maximum<(_First < _Second ? _Secon
     // find maximum value in _First, _Second, _Rest...
 };
 
-template <size_t _Len, class... _Types>
+_EXPORT_STD template <size_t _Len, class... _Types>
 struct _CXX23_DEPRECATE_ALIGNED_UNION aligned_union {
     // define type with size at least _Len, for storing anything in _Types
     static constexpr size_t _Max_len        = _Maximum<_Len, sizeof(_Types)...>::value; // NOT sizeof...(_Types)
@@ -1119,7 +1119,7 @@ struct _CXX23_DEPRECATE_ALIGNED_UNION aligned_union {
 };
 
 _STL_DISABLE_DEPRECATED_WARNING
-template <size_t _Len, class... _Types>
+_EXPORT_STD template <size_t _Len, class... _Types>
 using aligned_union_t _CXX23_DEPRECATE_ALIGNED_UNION = typename aligned_union<_Len, _Types...>::type;
 _STL_RESTORE_DEPRECATED_WARNING
 
@@ -1131,13 +1131,13 @@ struct _Underlying_type {
 template <class _Ty>
 struct _Underlying_type<_Ty, false> {};
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct underlying_type : _Underlying_type<_Ty> {}; // determine underlying type for enum
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 using underlying_type_t = typename _Underlying_type<_Ty>::type;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr size_t rank_v = 0; // determine number of dimensions of array _Ty
 
 template <class _Ty, size_t _Nx>
@@ -1146,10 +1146,10 @@ _INLINE_VAR constexpr size_t rank_v<_Ty[_Nx]> = rank_v<_Ty> + 1;
 template <class _Ty>
 _INLINE_VAR constexpr size_t rank_v<_Ty[]> = rank_v<_Ty> + 1;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct rank : integral_constant<size_t, rank_v<_Ty>> {};
 
-template <class _Ty, unsigned int _Ix = 0>
+_EXPORT_STD template <class _Ty, unsigned int _Ix = 0>
 _INLINE_VAR constexpr size_t extent_v = 0; // determine extent of dimension _Ix of array _Ty
 
 template <class _Ty, size_t _Nx>
@@ -1161,25 +1161,25 @@ _INLINE_VAR constexpr size_t extent_v<_Ty[_Nx], _Ix> = extent_v<_Ty, _Ix - 1>;
 template <class _Ty, unsigned int _Ix>
 _INLINE_VAR constexpr size_t extent_v<_Ty[], _Ix> = extent_v<_Ty, _Ix - 1>;
 
-template <class _Ty, unsigned int _Ix = 0>
+_EXPORT_STD template <class _Ty, unsigned int _Ix = 0>
 struct extent : integral_constant<size_t, extent_v<_Ty, _Ix>> {};
 
-template <class _Base, class _Derived>
+_EXPORT_STD template <class _Base, class _Derived>
 struct is_base_of : bool_constant<__is_base_of(_Base, _Derived)> {
     // determine whether _Base is a base of or the same as _Derived
 };
 
-template <class _Base, class _Derived>
+_EXPORT_STD template <class _Base, class _Derived>
 _INLINE_VAR constexpr bool is_base_of_v = __is_base_of(_Base, _Derived);
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct decay { // determines decayed version of _Ty
     using _Ty1 = remove_reference_t<_Ty>;
     using _Ty2 = typename _Select<is_function_v<_Ty1>>::template _Apply<add_pointer<_Ty1>, remove_cv<_Ty1>>;
     using type = typename _Select<is_array_v<_Ty1>>::template _Apply<add_pointer<remove_extent_t<_Ty1>>, _Ty2>::type;
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 using decay_t = typename decay<_Ty>::type;
 
 template <class _Ty1, class _Ty2>
@@ -1208,10 +1208,10 @@ struct _Decayed_cond_oper<_Ty1, _Ty2, void_t<_Conditional_type<_Ty1, _Ty2>>> {
     using type = decay_t<_Conditional_type<_Ty1, _Ty2>>;
 };
 
-template <class... _Ty>
+_EXPORT_STD template <class... _Ty>
 struct common_type;
 
-template <class... _Ty>
+_EXPORT_STD template <class... _Ty>
 using common_type_t = typename common_type<_Ty...>::type;
 
 template <>
@@ -1243,7 +1243,7 @@ template <class _Ty>
 _Ty _Returns_exactly() noexcept; // not defined
 
 #if _HAS_CXX20
-template <class, class, template <class> class, template <class> class>
+_EXPORT_STD template <class, class, template <class> class, template <class> class>
 struct basic_common_reference {};
 
 template <class _From>
@@ -1314,10 +1314,10 @@ using _Cond_res = // N4810 [meta.trans.other]/2.4
     decltype(false ? _Returns_exactly<_Ty1>() : _Returns_exactly<_Ty2>());
 #endif // ^^^ no workaround ^^^
 
-template <class...>
+_EXPORT_STD template <class...>
 struct common_reference;
 
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
 using common_reference_t = typename common_reference<_Types...>::type;
 
 // N4810 [meta.trans.other]/5.1: "If sizeof...(T) is zero ..."
@@ -1404,11 +1404,11 @@ struct common_reference<_Ty1, _Ty2, _Ty3, _Rest...> : _Fold_common_reference<voi
 #endif // _HAS_CXX20
 
 #if _HAS_CXX20
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct type_identity {
     using type = _Ty;
 };
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 using type_identity_t = typename type_identity<_Ty>::type;
 #endif // _HAS_CXX20
 
@@ -1420,31 +1420,31 @@ _INLINE_VAR constexpr bool _Is_specialization_v<_Template<_Types...>, _Template>
 template <class _Type, template <class...> class _Template>
 struct _Is_specialization : bool_constant<_Is_specialization_v<_Type, _Template>> {};
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD constexpr _Ty&& forward(
     remove_reference_t<_Ty>& _Arg) noexcept { // forward an lvalue as either an lvalue or an rvalue
     return static_cast<_Ty&&>(_Arg);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD constexpr _Ty&& forward(remove_reference_t<_Ty>&& _Arg) noexcept { // forward an rvalue as an rvalue
     static_assert(!is_lvalue_reference_v<_Ty>, "bad forward call");
     return static_cast<_Ty&&>(_Arg);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD constexpr remove_reference_t<_Ty>&& move(_Ty&& _Arg) noexcept { // forward _Arg as movable
     return static_cast<remove_reference_t<_Ty>&&>(_Arg);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD constexpr conditional_t<!is_nothrow_move_constructible_v<_Ty> && is_copy_constructible_v<_Ty>, const _Ty&,
     _Ty&&>
     move_if_noexcept(_Ty& _Arg) noexcept { // forward _Arg as movable, sometimes
     return _STD move(_Arg);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class reference_wrapper;
 
 // std::invoke isn't constexpr in C++17, and normally implementers are forbidden from "strengthening" constexpr
@@ -1556,13 +1556,13 @@ struct _Invoker1<_Callable, _Ty1, _Removed_cvref, false, true>
 template <class _Callable, class _Ty1, class _Removed_cvref>
 struct _Invoker1<_Callable, _Ty1, _Removed_cvref, false, false> : _Invoker_functor {};
 
-template <class _Callable>
+_EXPORT_STD template <class _Callable>
 _CONSTEXPR17 auto invoke(_Callable&& _Obj) noexcept(noexcept(static_cast<_Callable&&>(_Obj)()))
     -> decltype(static_cast<_Callable&&>(_Obj)()) {
     return static_cast<_Callable&&>(_Obj)();
 }
 
-template <class _Callable, class _Ty1, class... _Types2>
+_EXPORT_STD template <class _Callable, class _Ty1, class... _Types2>
 _CONSTEXPR17 auto invoke(_Callable&& _Obj, _Ty1&& _Arg1, _Types2&&... _Args2) noexcept(
     noexcept(_Invoker1<_Callable, _Ty1>::_Call(
         static_cast<_Callable&&>(_Obj), static_cast<_Ty1&&>(_Arg1), static_cast<_Types2&&>(_Args2)...)))
@@ -1608,10 +1608,10 @@ struct _Is_nothrow_convertible : bool_constant<_Is_nothrow_convertible_v<_From,
 };
 
 #if _HAS_CXX20
-template <class _From, class _To>
+_EXPORT_STD template <class _From, class _To>
 inline constexpr bool is_nothrow_convertible_v = _Is_nothrow_convertible_v<_From, _To>;
 
-template <class _From, class _To>
+_EXPORT_STD template <class _From, class _To>
 using is_nothrow_convertible = _Is_nothrow_convertible<_From, _To>;
 #endif // _HAS_CXX20
 
@@ -1683,7 +1683,7 @@ using _Select_invoke_traits = conditional_t<sizeof...(_Args) == 0, _Invoke_trait
     _Invoke_traits_nonzero<void, _Callable, _Args...>>;
 
 #if _HAS_DEPRECATED_RESULT_OF
-template <class _Fty>
+_EXPORT_STD template <class _Fty>
 struct _CXX17_DEPRECATE_RESULT_OF result_of { // explain usage
     static_assert(_Always_false<_Fty>, "result_of<CallableType> is invalid; use "
                                        "result_of<CallableType(zero or more argument types)> instead.");
@@ -1699,7 +1699,7 @@ _NON_MEMBER_CALL(_RESULT_OF, X1, X2, X3)
 #undef _RESULT_OF
 
 _STL_DISABLE_DEPRECATED_WARNING
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 using result_of_t _CXX17_DEPRECATE_RESULT_OF = typename result_of<_Ty>::type;
 _STL_RESTORE_DEPRECATED_WARNING
 #endif // _HAS_DEPRECATED_RESULT_OF
@@ -1716,44 +1716,44 @@ struct _Is_invocable_r : _Is_invocable_r_<_Rx, _Callable, _Args...> {
 };
 
 #if _HAS_CXX17
-template <class _Callable, class... _Args>
+_EXPORT_STD template <class _Callable, class... _Args>
 struct invoke_result : _Select_invoke_traits<_Callable, _Args...> {
     // determine the result type of invoking _Callable with _Args
 };
 
-template <class _Callable, class... _Args>
+_EXPORT_STD template <class _Callable, class... _Args>
 using invoke_result_t = typename _Select_invoke_traits<_Callable, _Args...>::type;
 
-template <class _Callable, class... _Args>
+_EXPORT_STD template <class _Callable, class... _Args>
 struct is_invocable : _Select_invoke_traits<_Callable, _Args...>::_Is_invocable {
     // determines whether _Callable is callable with _Args
 };
 
-template <class _Callable, class... _Args>
+_EXPORT_STD template <class _Callable, class... _Args>
 inline constexpr bool is_invocable_v = _Select_invoke_traits<_Callable, _Args...>::_Is_invocable::value;
 
-template <class _Callable, class... _Args>
+_EXPORT_STD template <class _Callable, class... _Args>
 struct is_nothrow_invocable : _Select_invoke_traits<_Callable, _Args...>::_Is_nothrow_invocable {
     // determines whether _Callable is nothrow-callable with _Args
 };
 
-template <class _Callable, class... _Args>
+_EXPORT_STD template <class _Callable, class... _Args>
 inline constexpr bool is_nothrow_invocable_v = _Select_invoke_traits<_Callable, _Args...>::_Is_nothrow_invocable::value;
 
-template <class _Rx, class _Callable, class... _Args>
+_EXPORT_STD template <class _Rx, class _Callable, class... _Args>
 struct is_invocable_r : _Is_invocable_r_<_Rx, _Callable, _Args...> {
     // determines whether _Callable is callable with _Args and return type _Rx
 };
 
-template <class _Rx, class _Callable, class... _Args>
+_EXPORT_STD template <class _Rx, class _Callable, class... _Args>
 inline constexpr bool is_invocable_r_v = _Is_invocable_r_<_Rx, _Callable, _Args...>::value;
 
-template <class _Rx, class _Callable, class... _Args>
+_EXPORT_STD template <class _Rx, class _Callable, class... _Args>
 struct is_nothrow_invocable_r : _Select_invoke_traits<_Callable, _Args...>::template _Is_nothrow_invocable_r<_Rx> {
     // determines whether _Callable is nothrow-callable with _Args and return type _Rx
 };
 
-template <class _Rx, class _Callable, class... _Args>
+_EXPORT_STD template <class _Rx, class _Callable, class... _Args>
 inline constexpr bool is_nothrow_invocable_r_v =
     _Select_invoke_traits<_Callable, _Args...>::template _Is_nothrow_invocable_r<_Rx>::value;
 #endif // _HAS_CXX17
@@ -1761,24 +1761,24 @@ inline constexpr bool is_nothrow_invocable_r_v =
 #if _HAS_CXX20
 #ifndef __EDG__ // TRANSITION, VSO-1268984
 #ifndef __clang__ // TRANSITION, LLVM-48860
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 struct is_layout_compatible : bool_constant<__is_layout_compatible(_Ty1, _Ty2)> {};
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 inline constexpr bool is_layout_compatible_v = __is_layout_compatible(_Ty1, _Ty2);
 
-template <class _Base, class _Derived>
+_EXPORT_STD template <class _Base, class _Derived>
 struct is_pointer_interconvertible_base_of : bool_constant<__is_pointer_interconvertible_base_of(_Base, _Derived)> {};
 
-template <class _Base, class _Derived>
+_EXPORT_STD template <class _Base, class _Derived>
 inline constexpr bool is_pointer_interconvertible_base_of_v = __is_pointer_interconvertible_base_of(_Base, _Derived);
 
-template <class _ClassTy, class _MemberTy>
+_EXPORT_STD template <class _ClassTy, class _MemberTy>
 _NODISCARD constexpr bool is_pointer_interconvertible_with_class(_MemberTy _ClassTy::*_Pm) noexcept {
     return __is_pointer_interconvertible_with_class(_ClassTy, _Pm);
 }
 
-template <class _ClassTy1, class _ClassTy2, class _MemberTy1, class _MemberTy2>
+_EXPORT_STD template <class _ClassTy1, class _ClassTy2, class _MemberTy1, class _MemberTy2>
 _NODISCARD constexpr bool is_corresponding_member(_MemberTy1 _ClassTy1::*_Pm1, _MemberTy2 _ClassTy2::*_Pm2) noexcept {
     return __is_corresponding_member(_ClassTy1, _ClassTy2, _Pm1, _Pm2);
 }
@@ -1856,7 +1856,7 @@ struct _Refwrap_has_ctor_from : false_type {};
 template <class _Ty, class _Uty>
 struct _Refwrap_has_ctor_from<_Ty, _Uty, void_t<decltype(_Refwrap_ctor_fun<_Ty>(_STD declval<_Uty>()))>> : true_type {};
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class reference_wrapper
 #if !_HAS_CXX20
     : public _Weak_types<_Ty>
@@ -1901,34 +1901,34 @@ template <class _Ty>
 reference_wrapper(_Ty&) -> reference_wrapper<_Ty>;
 #endif // _HAS_CXX17
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _CONSTEXPR20 reference_wrapper<_Ty> ref(_Ty& _Val) noexcept {
     return reference_wrapper<_Ty>(_Val);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 void ref(const _Ty&&) = delete;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _CONSTEXPR20 reference_wrapper<_Ty> ref(reference_wrapper<_Ty> _Val) noexcept {
     return _Val;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _CONSTEXPR20 reference_wrapper<const _Ty> cref(const _Ty& _Val) noexcept {
     return reference_wrapper<const _Ty>(_Val);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 void cref(const _Ty&&) = delete;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _CONSTEXPR20 reference_wrapper<const _Ty> cref(reference_wrapper<_Ty> _Val) noexcept {
     return _Val;
 }
 
 #if _HAS_CXX20
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct unwrap_reference {
     using type = _Ty;
 };
@@ -1936,12 +1936,12 @@ template <class _Ty>
 struct unwrap_reference<reference_wrapper<_Ty>> {
     using type = _Ty&;
 };
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 using unwrap_reference_t = typename unwrap_reference<_Ty>::type;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 using unwrap_ref_decay_t = unwrap_reference_t<decay_t<_Ty>>;
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct unwrap_ref_decay {
     using type = unwrap_ref_decay_t<_Ty>;
 };
@@ -1954,13 +1954,13 @@ template <class _Ty>
 struct _Is_nothrow_swappable;
 
 #if _HAS_CXX17
-template <class _Ty, enable_if_t<is_move_constructible_v<_Ty> && is_move_assignable_v<_Ty>, int> = 0>
+_EXPORT_STD template <class _Ty, enable_if_t<is_move_constructible_v<_Ty> && is_move_assignable_v<_Ty>, int> = 0>
 #else // ^^^ _HAS_CXX17 / !_HAS_CXX17 vvv
 template <class _Ty, int _Enabled = 0>
 #endif // _HAS_CXX17
 _CONSTEXPR20 void swap(_Ty&, _Ty&) noexcept(is_nothrow_move_constructible_v<_Ty>&& is_nothrow_move_assignable_v<_Ty>);
 
-template <class _Ty, size_t _Size, enable_if_t<_Is_swappable<_Ty>::value, int> = 0>
+_EXPORT_STD template <class _Ty, size_t _Size, enable_if_t<_Is_swappable<_Ty>::value, int> = 0>
 _CONSTEXPR20 void swap(_Ty (&)[_Size], _Ty (&)[_Size]) noexcept(_Is_nothrow_swappable<_Ty>::value);
 
 template <class _Ty1, class _Ty2, class = void>
@@ -2002,37 +2002,37 @@ struct _Is_nothrow_swappable
 };
 
 #if _HAS_CXX17
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 struct is_swappable_with : _Is_swappable_with<_Ty1, _Ty2>::type {
     // Determine if expressions with type and value category _Ty1 and _Ty2
     // can be swapped (and vice versa)
 };
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 inline constexpr bool is_swappable_with_v =
     conjunction_v<_Swappable_with_helper<_Ty1, _Ty2>, _Swappable_with_helper<_Ty2, _Ty1>>;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_swappable : _Is_swappable<_Ty>::type {}; // Determine if _Ty lvalues satisfy is_swappable_with
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 inline constexpr bool is_swappable_v = _Is_swappable<_Ty>::value;
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 struct is_nothrow_swappable_with : _Is_nothrow_swappable_with<_Ty1, _Ty2>::type {
     // Determine if expressions with type and value category _Ty1 and _Ty2
     // satisfy is_swappable_with, and can be swapped without emitting exceptions
 };
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 inline constexpr bool is_nothrow_swappable_with_v = _Is_nothrow_swappable_with<_Ty1, _Ty2>::value;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_nothrow_swappable : _Is_nothrow_swappable<_Ty>::type {
     // Determine if _Ty lvalues satisfy is_nothrow_swappable_with
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 inline constexpr bool is_nothrow_swappable_v = _Is_nothrow_swappable<_Ty>::value;
 #endif // _HAS_CXX17
 
@@ -2060,37 +2060,37 @@ struct _Is_trivially_swappable : bool_constant<_Is_trivially_swappable_v<_Ty>> {
     // true_type if and only if it is valid to swap two _Ty lvalues by exchanging object representations.
 };
 
-#define _BITMASK_OPS(_BITMASK)                                                                  \
-    _NODISCARD constexpr _BITMASK operator&(_BITMASK _Left, _BITMASK _Right) noexcept {         \
-        using _IntTy = _STD underlying_type_t<_BITMASK>;                                        \
-        return static_cast<_BITMASK>(static_cast<_IntTy>(_Left) & static_cast<_IntTy>(_Right)); \
-    }                                                                                           \
-                                                                                                \
-    _NODISCARD constexpr _BITMASK operator|(_BITMASK _Left, _BITMASK _Right) noexcept {         \
-        using _IntTy = _STD underlying_type_t<_BITMASK>;                                        \
-        return static_cast<_BITMASK>(static_cast<_IntTy>(_Left) | static_cast<_IntTy>(_Right)); \
-    }                                                                                           \
-                                                                                                \
-    _NODISCARD constexpr _BITMASK operator^(_BITMASK _Left, _BITMASK _Right) noexcept {         \
-        using _IntTy = _STD underlying_type_t<_BITMASK>;                                        \
-        return static_cast<_BITMASK>(static_cast<_IntTy>(_Left) ^ static_cast<_IntTy>(_Right)); \
-    }                                                                                           \
-                                                                                                \
-    constexpr _BITMASK& operator&=(_BITMASK& _Left, _BITMASK _Right) noexcept {                 \
-        return _Left = _Left & _Right;                                                          \
-    }                                                                                           \
-                                                                                                \
-    constexpr _BITMASK& operator|=(_BITMASK& _Left, _BITMASK _Right) noexcept {                 \
-        return _Left = _Left | _Right;                                                          \
-    }                                                                                           \
-                                                                                                \
-    constexpr _BITMASK& operator^=(_BITMASK& _Left, _BITMASK _Right) noexcept {                 \
-        return _Left = _Left ^ _Right;                                                          \
-    }                                                                                           \
-                                                                                                \
-    _NODISCARD constexpr _BITMASK operator~(_BITMASK _Left) noexcept {                          \
-        using _IntTy = _STD underlying_type_t<_BITMASK>;                                        \
-        return static_cast<_BITMASK>(~static_cast<_IntTy>(_Left));                              \
+#define _BITMASK_OPS(_MAYBE_EXPORT, _BITMASK)                                                         \
+    _MAYBE_EXPORT _NODISCARD constexpr _BITMASK operator&(_BITMASK _Left, _BITMASK _Right) noexcept { \
+        using _IntTy = _STD underlying_type_t<_BITMASK>;                                              \
+        return static_cast<_BITMASK>(static_cast<_IntTy>(_Left) & static_cast<_IntTy>(_Right));       \
+    }                                                                                                 \
+                                                                                                      \
+    _MAYBE_EXPORT _NODISCARD constexpr _BITMASK operator|(_BITMASK _Left, _BITMASK _Right) noexcept { \
+        using _IntTy = _STD underlying_type_t<_BITMASK>;                                              \
+        return static_cast<_BITMASK>(static_cast<_IntTy>(_Left) | static_cast<_IntTy>(_Right));       \
+    }                                                                                                 \
+                                                                                                      \
+    _MAYBE_EXPORT _NODISCARD constexpr _BITMASK operator^(_BITMASK _Left, _BITMASK _Right) noexcept { \
+        using _IntTy = _STD underlying_type_t<_BITMASK>;                                              \
+        return static_cast<_BITMASK>(static_cast<_IntTy>(_Left) ^ static_cast<_IntTy>(_Right));       \
+    }                                                                                                 \
+                                                                                                      \
+    _MAYBE_EXPORT constexpr _BITMASK& operator&=(_BITMASK& _Left, _BITMASK _Right) noexcept {         \
+        return _Left = _Left & _Right;                                                                \
+    }                                                                                                 \
+                                                                                                      \
+    _MAYBE_EXPORT constexpr _BITMASK& operator|=(_BITMASK& _Left, _BITMASK _Right) noexcept {         \
+        return _Left = _Left | _Right;                                                                \
+    }                                                                                                 \
+                                                                                                      \
+    _MAYBE_EXPORT constexpr _BITMASK& operator^=(_BITMASK& _Left, _BITMASK _Right) noexcept {         \
+        return _Left = _Left ^ _Right;                                                                \
+    }                                                                                                 \
+                                                                                                      \
+    _MAYBE_EXPORT _NODISCARD constexpr _BITMASK operator~(_BITMASK _Left) noexcept {                  \
+        using _IntTy = _STD underlying_type_t<_BITMASK>;                                              \
+        return static_cast<_BITMASK>(~static_cast<_IntTy>(_Left));                                    \
     }
 
 template <class _Bitmask>
@@ -2152,7 +2152,7 @@ _NODISCARD size_t _Hash_array_representation(
         _FNV_offset_basis, reinterpret_cast<const unsigned char*>(_First), _Count * sizeof(_Kty));
 }
 
-template <class _Kty>
+_EXPORT_STD template <class _Kty>
 struct hash;
 
 template <class _Kty, bool _Enabled>
@@ -2175,7 +2175,7 @@ struct _Conditionally_enabled_hash<_Kty, false> { // conditionally disabled hash
     _Conditionally_enabled_hash& operator=(_Conditionally_enabled_hash&&)      = delete;
 };
 
-template <class _Kty>
+_EXPORT_STD template <class _Kty>
 struct hash
     : _Conditionally_enabled_hash<_Kty,
           !is_const_v<_Kty> && !is_volatile_v<_Kty> && (is_enum_v<_Kty> || is_integral_v<_Kty> || is_pointer_v<_Kty>)> {
diff --git a/stl/inc/typeindex b/stl/inc/typeindex
index f10dbf3d0a..a3ec721f22 100644
--- a/stl/inc/typeindex
+++ b/stl/inc/typeindex
@@ -22,7 +22,7 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-class type_index { // wraps a typeinfo for indexing
+_EXPORT_STD class type_index { // wraps a typeinfo for indexing
 public:
     type_index(const type_info& _Tinfo) noexcept : _Tptr(&_Tinfo) {}
 
diff --git a/stl/inc/typeinfo b/stl/inc/typeinfo
index b837da7460..e1e50f05eb 100644
--- a/stl/inc/typeinfo
+++ b/stl/inc/typeinfo
@@ -27,9 +27,13 @@ _STD_BEGIN
 // size in pointers of std::function and std::any (roughly 3 pointers larger than std::string when building debug)
 _INLINE_VAR constexpr int _Small_object_num_ptrs = 6 + 16 / sizeof(void*);
 
-#if !_HAS_EXCEPTIONS
+_EXPORT_STD using ::type_info;
 
-class bad_cast : public exception { // base of all bad cast exceptions
+#if _HAS_EXCEPTIONS
+_EXPORT_STD class bad_cast;
+_EXPORT_STD class bad_typeid;
+#else // ^^^ _HAS_EXCEPTIONS / !_HAS_EXCEPTIONS vvv
+_EXPORT_STD class bad_cast : public exception { // base of all bad cast exceptions
 public:
     bad_cast(const char* _Message = "bad cast") noexcept : exception(_Message) {}
 
@@ -41,7 +45,7 @@ protected:
     }
 };
 
-class bad_typeid : public exception { // base of all bad typeid exceptions
+_EXPORT_STD class bad_typeid : public exception { // base of all bad typeid exceptions
 public:
     bad_typeid(const char* _Message = "bad typeid") noexcept : exception(_Message) {}
 
diff --git a/stl/inc/unordered_map b/stl/inc/unordered_map
index dac3da6c94..00883e77a8 100644
--- a/stl/inc/unordered_map
+++ b/stl/inc/unordered_map
@@ -62,7 +62,7 @@ public:
     }
 };
 
-template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>,
+_EXPORT_STD template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>,
     class _Alloc = allocator<pair<const _Kty, _Ty>>>
 class unordered_map : public _Hash<_Umap_traits<_Kty, _Ty, _Uhash_compare<_Kty, _Hasher, _Keyeq>, _Alloc, false>> {
     // hash table of {key, mapped} values, unique keys
@@ -521,21 +521,21 @@ unordered_map(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
 #endif // _HAS_CXX23 && defined(__cpp_lib_concepts)
 #endif // _HAS_CXX17
 
-template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
+_EXPORT_STD template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
 void swap(unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Left,
     unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
     _Left.swap(_Right);
 }
 
 #if _HAS_CXX20
-template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc, class _Pr>
+_EXPORT_STD template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc, class _Pr>
 typename unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>::size_type erase_if(
     unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Cont, _Pr _Pred) {
     return _Erase_nodes_if(_Cont, _Pass_fn(_Pred));
 }
 #endif // _HAS_CXX20
 
-template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
+_EXPORT_STD template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
 _NODISCARD bool operator==(const unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Left,
     const unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Right) {
     return _Hash_equal(_Left, _Right);
@@ -549,7 +549,7 @@ _NODISCARD bool operator!=(const unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Allo
 }
 #endif // !_HAS_CXX20
 
-template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>,
+_EXPORT_STD template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>,
     class _Alloc = allocator<pair<const _Kty, _Ty>>>
 class unordered_multimap : public _Hash<_Umap_traits<_Kty, _Ty, _Uhash_compare<_Kty, _Hasher, _Keyeq>, _Alloc, true>> {
     // hash table of {key, mapped} values, non-unique keys
@@ -890,21 +890,21 @@ unordered_multimap(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Hasher, _A
 #endif // _HAS_CXX23 && defined(__cpp_lib_concepts)
 #endif // _HAS_CXX17
 
-template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
+_EXPORT_STD template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
 void swap(unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Left,
     unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
     _Left.swap(_Right);
 }
 
 #if _HAS_CXX20
-template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc, class _Pr>
+_EXPORT_STD template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc, class _Pr>
 typename unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>::size_type erase_if(
     unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Cont, _Pr _Pred) {
     return _Erase_nodes_if(_Cont, _Pass_fn(_Pred));
 }
 #endif // _HAS_CXX20
 
-template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
+_EXPORT_STD template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
 _NODISCARD bool operator==(const unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Left,
     const unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Right) {
     return _Hash_equal(_Left, _Right);
@@ -927,10 +927,10 @@ namespace _DEPRECATE_TR1_NAMESPACE tr1 {
 
 #if _HAS_CXX17
 namespace pmr {
-    template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>>
+    _EXPORT_STD template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>>
     using unordered_map = _STD unordered_map<_Kty, _Ty, _Hasher, _Keyeq, polymorphic_allocator<pair<const _Kty, _Ty>>>;
 
-    template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>>
+    _EXPORT_STD template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>>
     using unordered_multimap =
         _STD unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, polymorphic_allocator<pair<const _Kty, _Ty>>>;
 } // namespace pmr
diff --git a/stl/inc/unordered_set b/stl/inc/unordered_set
index ff6d96110c..63e51c9fbb 100644
--- a/stl/inc/unordered_set
+++ b/stl/inc/unordered_set
@@ -59,7 +59,8 @@ public:
     }
 };
 
-template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>
+_EXPORT_STD template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>,
+    class _Alloc = allocator<_Kty>>
 class unordered_set : public _Hash<_Uset_traits<_Kty, _Uhash_compare<_Kty, _Hasher, _Keyeq>, _Alloc, false>> {
     // hash table of key-values, unique keys
 public:
@@ -375,21 +376,21 @@ unordered_set(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
 #endif // _HAS_CXX23 && defined(__cpp_lib_concepts)
 #endif // _HAS_CXX17
 
-template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
+_EXPORT_STD template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
 void swap(unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>& _Left,
     unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
     _Left.swap(_Right);
 }
 
 #if _HAS_CXX20
-template <class _Kty, class _Hasher, class _Keyeq, class _Alloc, class _Pr>
+_EXPORT_STD template <class _Kty, class _Hasher, class _Keyeq, class _Alloc, class _Pr>
 typename unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>::size_type erase_if(
     unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>& _Cont, _Pr _Pred) {
     return _Erase_nodes_if(_Cont, _Pass_fn(_Pred));
 }
 #endif // _HAS_CXX20
 
-template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
+_EXPORT_STD template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
 _NODISCARD bool operator==(const unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>& _Left,
     const unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>& _Right) {
     return _Hash_equal(_Left, _Right);
@@ -403,7 +404,8 @@ _NODISCARD bool operator!=(const unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>& _
 }
 #endif // !_HAS_CXX20
 
-template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>
+_EXPORT_STD template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>,
+    class _Alloc = allocator<_Kty>>
 class unordered_multiset : public _Hash<_Uset_traits<_Kty, _Uhash_compare<_Kty, _Hasher, _Keyeq>, _Alloc, true>> {
     // hash table of key-values, non-unique keys
 public:
@@ -715,21 +717,21 @@ unordered_multiset(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Hasher, _A
 #endif // _HAS_CXX23 && defined(__cpp_lib_concepts)
 #endif // _HAS_CXX17
 
-template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
+_EXPORT_STD template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
 void swap(unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>& _Left,
     unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
     _Left.swap(_Right);
 }
 
 #if _HAS_CXX20
-template <class _Kty, class _Hasher, class _Keyeq, class _Alloc, class _Pr>
+_EXPORT_STD template <class _Kty, class _Hasher, class _Keyeq, class _Alloc, class _Pr>
 typename unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>::size_type erase_if(
     unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>& _Cont, _Pr _Pred) {
     return _Erase_nodes_if(_Cont, _Pass_fn(_Pred));
 }
 #endif // _HAS_CXX20
 
-template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
+_EXPORT_STD template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
 _NODISCARD bool operator==(const unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>& _Left,
     const unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>& _Right) {
     return _Hash_equal(_Left, _Right);
@@ -752,10 +754,10 @@ namespace _DEPRECATE_TR1_NAMESPACE tr1 {
 
 #if _HAS_CXX17
 namespace pmr {
-    template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>>
+    _EXPORT_STD template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>>
     using unordered_set = _STD unordered_set<_Kty, _Hasher, _Keyeq, polymorphic_allocator<_Kty>>;
 
-    template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>>
+    _EXPORT_STD template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>>
     using unordered_multiset = _STD unordered_multiset<_Kty, _Hasher, _Keyeq, polymorphic_allocator<_Kty>>;
 } // namespace pmr
 #endif // _HAS_CXX17
diff --git a/stl/inc/utility b/stl/inc/utility
index 29edcde8ff..df5b488214 100644
--- a/stl/inc/utility
+++ b/stl/inc/utility
@@ -27,7 +27,7 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-template <class _Ty, class _Pr>
+_EXPORT_STD template <class _Ty, class _Pr>
 _NODISCARD constexpr const _Ty&(max) (const _Ty& _Left, const _Ty& _Right, _Pr _Pred) noexcept(
     noexcept(_Pred(_Left, _Right))) /* strengthened */ {
     // return larger of _Left and _Right
@@ -36,7 +36,7 @@ _NODISCARD constexpr const _Ty&(max) (const _Ty& _Left, const _Ty& _Right, _Pr _
 
 #pragma warning(push)
 #pragma warning(disable : 28285) // (syntax error in SAL annotation, occurs when _Ty is not an integral type)
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Post_equal_to_(_Left < _Right ? _Right : _Left) constexpr const _Ty& //
     (max) (const _Ty& _Left, const _Ty& _Right) noexcept(noexcept(_Left < _Right)) /* strengthened */ {
     // return larger of _Left and _Right
@@ -44,13 +44,13 @@ _NODISCARD _Post_equal_to_(_Left < _Right ? _Right : _Left) constexpr const _Ty&
 }
 #pragma warning(pop)
 
-template <class _Ty, class _Pr>
+_EXPORT_STD template <class _Ty, class _Pr>
 _NODISCARD constexpr _Ty(max)(initializer_list<_Ty>, _Pr); // implemented in <algorithm>
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD constexpr _Ty(max)(initializer_list<_Ty>); // implemented in <algorithm>
 
-template <class _Ty, class _Pr>
+_EXPORT_STD template <class _Ty, class _Pr>
 _NODISCARD constexpr const _Ty&(min) (const _Ty& _Left, const _Ty& _Right, _Pr _Pred) noexcept(
     noexcept(_Pred(_Right, _Left))) /* strengthened */ {
     // return smaller of _Left and _Right
@@ -59,7 +59,7 @@ _NODISCARD constexpr const _Ty&(min) (const _Ty& _Left, const _Ty& _Right, _Pr _
 
 #pragma warning(push)
 #pragma warning(disable : 28285) // (syntax error in SAL annotation, occurs when _Ty is not an integral type)
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Post_equal_to_(_Right < _Left ? _Right : _Left) constexpr const _Ty& //
     (min) (const _Ty& _Left, const _Ty& _Right) noexcept(noexcept(_Right < _Left)) /* strengthened */ {
     // return smaller of _Left and _Right
@@ -67,18 +67,18 @@ _NODISCARD _Post_equal_to_(_Right < _Left ? _Right : _Left) constexpr const _Ty&
 }
 #pragma warning(pop)
 
-template <class _Ty, class _Pr>
+_EXPORT_STD template <class _Ty, class _Pr>
 _NODISCARD constexpr _Ty(min)(initializer_list<_Ty>, _Pr); // implemented in <algorithm>
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD constexpr _Ty(min)(initializer_list<_Ty>); // implemented in <algorithm>
 
-template <class _FwdIt1, class _FwdIt2>
+_EXPORT_STD template <class _FwdIt1, class _FwdIt2>
 _CONSTEXPR20 void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right) { // swap *_Left and *_Right
     swap(*_Left, *_Right);
 }
 
-template <class _Ty, size_t _Size, enable_if_t<_Is_swappable<_Ty>::value, int> _Enabled>
+_EXPORT_STD template <class _Ty, size_t _Size, enable_if_t<_Is_swappable<_Ty>::value, int> _Enabled>
 _CONSTEXPR20 void swap(_Ty (&_Left)[_Size], _Ty (&_Right)[_Size]) noexcept(_Is_nothrow_swappable<_Ty>::value) {
     if (&_Left != &_Right) {
         _Ty* _First1 = _Left;
@@ -91,7 +91,7 @@ _CONSTEXPR20 void swap(_Ty (&_Left)[_Size], _Ty (&_Right)[_Size]) noexcept(_Is_n
 }
 
 #if _HAS_CXX17
-template <class _Ty, enable_if_t<is_move_constructible_v<_Ty> && is_move_assignable_v<_Ty>, int> _Enabled>
+_EXPORT_STD template <class _Ty, enable_if_t<is_move_constructible_v<_Ty> && is_move_assignable_v<_Ty>, int> _Enabled>
 #else // ^^^ _HAS_CXX17 / !_HAS_CXX17 vvv
 template <class _Ty, int _Enabled>
 #endif // _HAS_CXX17
@@ -107,11 +107,11 @@ _CONSTEXPR20 void _Swap_adl(_Ty& _Left, _Ty& _Right) noexcept(_Is_nothrow_swappa
     swap(_Left, _Right);
 }
 
-struct piecewise_construct_t { // tag type for pair tuple arguments
+_EXPORT_STD struct piecewise_construct_t { // tag type for pair tuple arguments
     explicit piecewise_construct_t() = default;
 };
 
-_INLINE_VAR constexpr piecewise_construct_t piecewise_construct{};
+_EXPORT_STD _INLINE_VAR constexpr piecewise_construct_t piecewise_construct{};
 
 template <class _Ty, class _Alloc, class = void>
 struct _Has_allocator_type : false_type {}; // tests for suitable _Ty::allocator_type
@@ -120,27 +120,27 @@ template <class _Ty, class _Alloc>
 struct _Has_allocator_type<_Ty, _Alloc, void_t<typename _Ty::allocator_type>>
     : is_convertible<_Alloc, typename _Ty::allocator_type>::type {}; // tests for suitable _Ty::allocator_type
 
-struct allocator_arg_t { // tag type for added allocator argument
+_EXPORT_STD struct allocator_arg_t { // tag type for added allocator argument
     explicit allocator_arg_t() = default;
 };
 
-_INLINE_VAR constexpr allocator_arg_t allocator_arg{};
+_EXPORT_STD _INLINE_VAR constexpr allocator_arg_t allocator_arg{};
 
-template <class _Ty, class _Alloc>
+_EXPORT_STD template <class _Ty, class _Alloc>
 struct uses_allocator : _Has_allocator_type<_Ty, _Alloc>::type {
     // determine whether _Ty has an allocator_type member type
 };
 
-template <class _Ty, class _Alloc>
+_EXPORT_STD template <class _Ty, class _Alloc>
 _INLINE_VAR constexpr bool uses_allocator_v = uses_allocator<_Ty, _Alloc>::value;
 
-template <class...>
+_EXPORT_STD template <class...>
 class tuple;
 
-template <size_t _Index, class... _Types>
+_EXPORT_STD /* TRANSITION, VSO-1538698 */ template <size_t _Index, class... _Types>
 _NODISCARD constexpr auto&& _Tuple_get(tuple<_Types...>&& _Tuple) noexcept;
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 struct pair { // store a pair of values
     using first_type  = _Ty1;
     using second_type = _Ty2;
@@ -348,26 +348,28 @@ template <class _Ty1, class _Ty2>
 pair(_Ty1, _Ty2) -> pair<_Ty1, _Ty2>;
 #endif // _HAS_CXX17
 
-template <class _Ty1, class _Ty2, enable_if_t<_Is_swappable<_Ty1>::value && _Is_swappable<_Ty2>::value, int> = 0>
+_EXPORT_STD template <class _Ty1, class _Ty2,
+    enable_if_t<_Is_swappable<_Ty1>::value && _Is_swappable<_Ty2>::value, int> = 0>
 _CONSTEXPR20 void swap(pair<_Ty1, _Ty2>& _Left, pair<_Ty1, _Ty2>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
     _Left.swap(_Right);
 }
 
 #if _HAS_CXX23
-template <class _Ty1, class _Ty2, enable_if_t<is_swappable_v<const _Ty1> && is_swappable_v<const _Ty2>, int> = 0>
+_EXPORT_STD template <class _Ty1, class _Ty2,
+    enable_if_t<is_swappable_v<const _Ty1> && is_swappable_v<const _Ty2>, int> = 0>
 constexpr void swap(const pair<_Ty1, _Ty2>& _Left, const pair<_Ty1, _Ty2>& _Right) noexcept(
     noexcept(_Left.swap(_Right))) {
     _Left.swap(_Right);
 }
 #endif // _HAS_CXX23
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD constexpr bool operator==(const pair<_Ty1, _Ty2>& _Left, const pair<_Ty1, _Ty2>& _Right) {
     return _Left.first == _Right.first && _Left.second == _Right.second;
 }
 
 #ifdef __cpp_lib_concepts
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD constexpr common_comparison_category_t<_Synth_three_way_result<_Ty1>, _Synth_three_way_result<_Ty2>>
     operator<=>(const pair<_Ty1, _Ty2>& _Left, const pair<_Ty1, _Ty2>& _Right) {
     if (auto _Result = _Synth_three_way{}(_Left.first, _Right.first); _Result != 0) {
@@ -437,7 +439,7 @@ struct _Unrefwrap_helper<reference_wrapper<_Ty>> { // make a reference from a re
 template <class _Ty>
 using _Unrefwrap_t = typename _Unrefwrap_helper<decay_t<_Ty>>::type;
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD constexpr pair<_Unrefwrap_t<_Ty1>, _Unrefwrap_t<_Ty2>> make_pair(_Ty1&& _Val1, _Ty2&& _Val2) noexcept(
     is_nothrow_constructible_v<_Unrefwrap_t<_Ty1>, _Ty1>&&
         is_nothrow_constructible_v<_Unrefwrap_t<_Ty2>, _Ty2>) /* strengthened */ {
@@ -447,28 +449,28 @@ _NODISCARD constexpr pair<_Unrefwrap_t<_Ty1>, _Unrefwrap_t<_Ty2>> make_pair(_Ty1
 }
 
 namespace _CXX20_DEPRECATE_REL_OPS rel_ops {
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     _CXX20_DEPRECATE_REL_OPS _NODISCARD bool operator!=(const _Ty& _Left, const _Ty& _Right) {
         return !(_Left == _Right);
     }
 
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     _CXX20_DEPRECATE_REL_OPS _NODISCARD bool operator>(const _Ty& _Left, const _Ty& _Right) {
         return _Right < _Left;
     }
 
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     _CXX20_DEPRECATE_REL_OPS _NODISCARD bool operator<=(const _Ty& _Left, const _Ty& _Right) {
         return !(_Right < _Left);
     }
 
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     _CXX20_DEPRECATE_REL_OPS _NODISCARD bool operator>=(const _Ty& _Left, const _Ty& _Right) {
         return !(_Left < _Right);
     }
 } // namespace rel_ops
 
-template <class _Tuple>
+_EXPORT_STD template <class _Tuple>
 struct tuple_size;
 
 template <class _Tuple, class = void>
@@ -487,10 +489,10 @@ struct _CXX20_DEPRECATE_VOLATILE tuple_size<volatile _Tuple> : _Tuple_size_sfina
 template <class _Tuple>
 struct _CXX20_DEPRECATE_VOLATILE tuple_size<const volatile _Tuple> : _Tuple_size_sfinae<_Tuple> {}; // ignore cv
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr size_t tuple_size_v = tuple_size<_Ty>::value;
 
-template <size_t _Index, class _Tuple>
+_EXPORT_STD template <size_t _Index, class _Tuple>
 struct tuple_element;
 
 template <size_t _Index, class _Tuple>
@@ -513,10 +515,10 @@ struct _CXX20_DEPRECATE_VOLATILE _MSVC_KNOWN_SEMANTICS tuple_element<_Index, con
     using type    = add_cv_t<typename _Mybase::type>;
 };
 
-template <size_t _Index, class _Tuple>
+_EXPORT_STD template <size_t _Index, class _Tuple>
 using tuple_element_t = typename tuple_element<_Index, _Tuple>::type;
 
-template <class _Ty, size_t _Size>
+_EXPORT_STD template <class _Ty, size_t _Size>
 class array;
 
 template <class _Ty, size_t _Size>
@@ -558,7 +560,7 @@ struct _MSVC_KNOWN_SEMANTICS tuple_element<_Idx, pair<_Ty1, _Ty2>> {
     using type = conditional_t<_Idx == 0, _Ty1, _Ty2>;
 };
 
-template <size_t _Idx, class _Ty1, class _Ty2>
+_EXPORT_STD template <size_t _Idx, class _Ty1, class _Ty2>
 _NODISCARD constexpr tuple_element_t<_Idx, pair<_Ty1, _Ty2>>& get(pair<_Ty1, _Ty2>& _Pr) noexcept {
     // get reference to element at _Idx in pair _Pr
     if constexpr (_Idx == 0) {
@@ -568,19 +570,19 @@ _NODISCARD constexpr tuple_element_t<_Idx, pair<_Ty1, _Ty2>>& get(pair<_Ty1, _Ty
     }
 }
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD constexpr _Ty1& get(pair<_Ty1, _Ty2>& _Pr) noexcept {
     // get reference to element _Ty1 in pair _Pr
     return _Pr.first;
 }
 
-template <class _Ty2, class _Ty1>
+_EXPORT_STD template <class _Ty2, class _Ty1>
 _NODISCARD constexpr _Ty2& get(pair<_Ty1, _Ty2>& _Pr) noexcept {
     // get reference to element _Ty2 in pair _Pr
     return _Pr.second;
 }
 
-template <size_t _Idx, class _Ty1, class _Ty2>
+_EXPORT_STD template <size_t _Idx, class _Ty1, class _Ty2>
 _NODISCARD constexpr const tuple_element_t<_Idx, pair<_Ty1, _Ty2>>& get(const pair<_Ty1, _Ty2>& _Pr) noexcept {
     // get const reference to element at _Idx in pair _Pr
     if constexpr (_Idx == 0) {
@@ -590,19 +592,19 @@ _NODISCARD constexpr const tuple_element_t<_Idx, pair<_Ty1, _Ty2>>& get(const pa
     }
 }
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD constexpr const _Ty1& get(const pair<_Ty1, _Ty2>& _Pr) noexcept {
     // get const reference to element _Ty1 in pair _Pr
     return _Pr.first;
 }
 
-template <class _Ty2, class _Ty1>
+_EXPORT_STD template <class _Ty2, class _Ty1>
 _NODISCARD constexpr const _Ty2& get(const pair<_Ty1, _Ty2>& _Pr) noexcept {
     // get const reference to element _Ty2 in pair _Pr
     return _Pr.second;
 }
 
-template <size_t _Idx, class _Ty1, class _Ty2>
+_EXPORT_STD template <size_t _Idx, class _Ty1, class _Ty2>
 _NODISCARD constexpr tuple_element_t<_Idx, pair<_Ty1, _Ty2>>&& get(pair<_Ty1, _Ty2>&& _Pr) noexcept {
     // get rvalue reference to element at _Idx in pair _Pr
     if constexpr (_Idx == 0) {
@@ -612,19 +614,19 @@ _NODISCARD constexpr tuple_element_t<_Idx, pair<_Ty1, _Ty2>>&& get(pair<_Ty1, _T
     }
 }
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD constexpr _Ty1&& get(pair<_Ty1, _Ty2>&& _Pr) noexcept {
     // get rvalue reference to element _Ty1 in pair _Pr
     return _STD forward<_Ty1>(_Pr.first);
 }
 
-template <class _Ty2, class _Ty1>
+_EXPORT_STD template <class _Ty2, class _Ty1>
 _NODISCARD constexpr _Ty2&& get(pair<_Ty1, _Ty2>&& _Pr) noexcept {
     // get rvalue reference to element _Ty2 in pair _Pr
     return _STD forward<_Ty2>(_Pr.second);
 }
 
-template <size_t _Idx, class _Ty1, class _Ty2>
+_EXPORT_STD template <size_t _Idx, class _Ty1, class _Ty2>
 _NODISCARD constexpr const tuple_element_t<_Idx, pair<_Ty1, _Ty2>>&& get(const pair<_Ty1, _Ty2>&& _Pr) noexcept {
     // get const rvalue reference to element at _Idx in pair _Pr
     if constexpr (_Idx == 0) {
@@ -634,19 +636,19 @@ _NODISCARD constexpr const tuple_element_t<_Idx, pair<_Ty1, _Ty2>>&& get(const p
     }
 }
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD constexpr const _Ty1&& get(const pair<_Ty1, _Ty2>&& _Pr) noexcept {
     // get const rvalue reference to element _Ty1 in pair _Pr
     return _STD forward<const _Ty1>(_Pr.first);
 }
 
-template <class _Ty2, class _Ty1>
+_EXPORT_STD template <class _Ty2, class _Ty1>
 _NODISCARD constexpr const _Ty2&& get(const pair<_Ty1, _Ty2>&& _Pr) noexcept {
     // get const rvalue reference to element _Ty2 in pair _Pr
     return _STD forward<const _Ty2>(_Pr.second);
 }
 
-template <class _Ty, class _Other = _Ty>
+_EXPORT_STD template <class _Ty, class _Other = _Ty>
 _CONSTEXPR20 _Ty exchange(_Ty& _Val, _Other&& _New_val) noexcept(
     conjunction_v<is_nothrow_move_constructible<_Ty>, is_nothrow_assignable<_Ty&, _Other>>) {
     // assign _New_val to _Val, return previous _Val
@@ -655,32 +657,32 @@ _CONSTEXPR20 _Ty exchange(_Ty& _Val, _Other&& _New_val) noexcept(
     return _Old_val;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD constexpr add_const_t<_Ty>& as_const(_Ty& _Val) noexcept { // view _Val through const lenses
     return _Val;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 void as_const(const _Ty&&) = delete;
 
 #if _HAS_CXX17
-struct in_place_t { // tag used to select a constructor which initializes a contained object in place
+_EXPORT_STD struct in_place_t { // tag used to select a constructor which initializes a contained object in place
     explicit in_place_t() = default;
 };
-inline constexpr in_place_t in_place{};
+_EXPORT_STD inline constexpr in_place_t in_place{};
 
-template <class>
+_EXPORT_STD template <class>
 struct in_place_type_t { // tag that selects a type to construct in place
     explicit in_place_type_t() = default;
 };
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 inline constexpr in_place_type_t<_Ty> in_place_type{};
 
-template <size_t>
+_EXPORT_STD template <size_t>
 struct in_place_index_t { // tag that selects the index of a type to construct in place
     explicit in_place_index_t() = default;
 };
-template <size_t _Idx>
+_EXPORT_STD template <size_t _Idx>
 inline constexpr in_place_index_t<_Idx> in_place_index{};
 #endif // _HAS_CXX17
 
@@ -696,7 +698,7 @@ inline constexpr bool _Is_standard_integer = is_integral_v<_Ty>
 #endif // __cpp_char8_t
         char16_t, char32_t>;
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD constexpr bool cmp_equal(const _Ty1 _Left, const _Ty2 _Right) noexcept {
     static_assert(_Is_standard_integer<_Ty1> && _Is_standard_integer<_Ty2>,
         "The integer comparison functions only accept standard and extended integer types.");
@@ -709,12 +711,12 @@ _NODISCARD constexpr bool cmp_equal(const _Ty1 _Left, const _Ty2 _Right) noexcep
     }
 }
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD constexpr bool cmp_not_equal(const _Ty1 _Left, const _Ty2 _Right) noexcept {
     return !_STD cmp_equal(_Left, _Right);
 }
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD constexpr bool cmp_less(const _Ty1 _Left, const _Ty2 _Right) noexcept {
     static_assert(_Is_standard_integer<_Ty1> && _Is_standard_integer<_Ty2>,
         "The integer comparison functions only accept standard and extended integer types.");
@@ -727,17 +729,17 @@ _NODISCARD constexpr bool cmp_less(const _Ty1 _Left, const _Ty2 _Right) noexcept
     }
 }
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD constexpr bool cmp_greater(const _Ty1 _Left, const _Ty2 _Right) noexcept {
     return _STD cmp_less(_Right, _Left);
 }
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD constexpr bool cmp_less_equal(const _Ty1 _Left, const _Ty2 _Right) noexcept {
     return !_STD cmp_less(_Right, _Left);
 }
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD constexpr bool cmp_greater_equal(const _Ty1 _Left, const _Ty2 _Right) noexcept {
     return !_STD cmp_less(_Left, _Right);
 }
@@ -764,7 +766,7 @@ _NODISCARD _CONSTEVAL _Ty _Max_limit() noexcept { // same as (numeric_limits<_Ty
     }
 }
 
-template <class _Rx, class _Ty>
+_EXPORT_STD template <class _Rx, class _Ty>
 _NODISCARD constexpr bool in_range(const _Ty _Value) noexcept {
     static_assert(_Is_standard_integer<_Rx> && _Is_standard_integer<_Ty>,
         "The integer comparison functions only accept standard and extended integer types.");
@@ -808,19 +810,19 @@ inline constexpr bool _Can_reference<_Ty, void_t<_Ty&>> = true;
 #endif // _HAS_CXX20
 
 #if _HAS_CXX23
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD constexpr underlying_type_t<_Ty> to_underlying(_Ty _Value) noexcept {
     return static_cast<underlying_type_t<_Ty>>(_Value);
 }
 
-[[noreturn]] __forceinline void unreachable() noexcept /* strengthened */ {
+_EXPORT_STD [[noreturn]] __forceinline void unreachable() noexcept /* strengthened */ {
     _STL_UNREACHABLE;
 #ifdef _DEBUG
     _CSTD abort(); // likely to be called in debug mode, but can't be relied upon - already entered the UB territory
 #endif // _DEBUG
 }
 
-template <class _Ty, class _Uty>
+_EXPORT_STD template <class _Ty, class _Uty>
 _NODISCARD constexpr auto&& forward_like(_Uty&& _Ux) noexcept {
     static_assert(_Can_reference<_Ty>, "std::forward_like's first template argument must be a referenceable type.");
 
diff --git a/stl/inc/valarray b/stl/inc/valarray
index a19a040c51..b0d978daf1 100644
--- a/stl/inc/valarray
+++ b/stl/inc/valarray
@@ -19,18 +19,18 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-class gslice;
-class slice;
+_EXPORT_STD class gslice;
+_EXPORT_STD class slice;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class gslice_array;
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class indirect_array;
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class mask_array;
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class slice_array;
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class valarray;
 
 template <class _Ty>
@@ -55,7 +55,7 @@ _Ty* _Allocate_for_op_delete(size_t _Count) {
 using _Boolarray = valarray<bool>;
 using _Sizarray  = valarray<size_t>;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class valarray { // store array with various indexing options
 public:
     friend _Tidy_deallocate_guard<valarray>;
@@ -595,32 +595,32 @@ template <class _Ty, size_t _Nx>
 valarray(const _Ty (&)[_Nx], size_t) -> valarray<_Ty>;
 #endif // _HAS_CXX17
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 void swap(valarray<_Ty>& _Left, valarray<_Ty>& _Right) noexcept {
     _Left.swap(_Right);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Ty* begin(valarray<_Ty>& _Array) {
     return _Array._Myptr;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD const _Ty* begin(const valarray<_Ty>& _Array) {
     return _Array._Myptr;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Ty* end(valarray<_Ty>& _Array) {
     return _Array._Myptr + _Array.size();
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD const _Ty* end(const valarray<_Ty>& _Array) {
     return _Array._Myptr + _Array.size();
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator*(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -630,7 +630,7 @@ _NODISCARD valarray<_Ty> operator*(const valarray<_Ty>& _Left, const typename va
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator*(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Right.size();
     valarray<_Ty> _Ans(_Size);
@@ -640,7 +640,7 @@ _NODISCARD valarray<_Ty> operator*(const typename valarray<_Ty>::value_type& _Le
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator/(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -650,7 +650,7 @@ _NODISCARD valarray<_Ty> operator/(const valarray<_Ty>& _Left, const typename va
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator/(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Right.size();
     valarray<_Ty> _Ans(_Size);
@@ -660,7 +660,7 @@ _NODISCARD valarray<_Ty> operator/(const typename valarray<_Ty>::value_type& _Le
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator%(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -670,7 +670,7 @@ _NODISCARD valarray<_Ty> operator%(const valarray<_Ty>& _Left, const typename va
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator%(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Right.size();
     valarray<_Ty> _Ans(_Size);
@@ -680,7 +680,7 @@ _NODISCARD valarray<_Ty> operator%(const typename valarray<_Ty>::value_type& _Le
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator+(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -690,7 +690,7 @@ _NODISCARD valarray<_Ty> operator+(const valarray<_Ty>& _Left, const typename va
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator+(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Right.size();
     valarray<_Ty> _Ans(_Size);
@@ -700,7 +700,7 @@ _NODISCARD valarray<_Ty> operator+(const typename valarray<_Ty>::value_type& _Le
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator-(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -710,7 +710,7 @@ _NODISCARD valarray<_Ty> operator-(const valarray<_Ty>& _Left, const typename va
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator-(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Right.size();
     valarray<_Ty> _Ans(_Size);
@@ -720,7 +720,7 @@ _NODISCARD valarray<_Ty> operator-(const typename valarray<_Ty>::value_type& _Le
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator^(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -730,7 +730,7 @@ _NODISCARD valarray<_Ty> operator^(const valarray<_Ty>& _Left, const typename va
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator^(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Right.size();
     valarray<_Ty> _Ans(_Size);
@@ -740,7 +740,7 @@ _NODISCARD valarray<_Ty> operator^(const typename valarray<_Ty>::value_type& _Le
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator&(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -750,7 +750,7 @@ _NODISCARD valarray<_Ty> operator&(const valarray<_Ty>& _Left, const typename va
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator&(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Right.size();
     valarray<_Ty> _Ans(_Size);
@@ -760,7 +760,7 @@ _NODISCARD valarray<_Ty> operator&(const typename valarray<_Ty>::value_type& _Le
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator|(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -770,7 +770,7 @@ _NODISCARD valarray<_Ty> operator|(const valarray<_Ty>& _Left, const typename va
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator|(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Right.size();
     valarray<_Ty> _Ans(_Size);
@@ -780,7 +780,7 @@ _NODISCARD valarray<_Ty> operator|(const typename valarray<_Ty>::value_type& _Le
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator<<(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -790,7 +790,7 @@ _NODISCARD valarray<_Ty> operator<<(const valarray<_Ty>& _Left, const typename v
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator<<(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Right.size();
     valarray<_Ty> _Ans(_Size);
@@ -800,7 +800,7 @@ _NODISCARD valarray<_Ty> operator<<(const typename valarray<_Ty>::value_type& _L
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator>>(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -810,7 +810,7 @@ _NODISCARD valarray<_Ty> operator>>(const valarray<_Ty>& _Left, const typename v
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator>>(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Right.size();
     valarray<_Ty> _Ans(_Size);
@@ -820,7 +820,7 @@ _NODISCARD valarray<_Ty> operator>>(const typename valarray<_Ty>::value_type& _L
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Boolarray operator&&(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
     const size_t _Size = _Left.size();
     valarray<bool> _Ans(_Size);
@@ -830,7 +830,7 @@ _NODISCARD _Boolarray operator&&(const valarray<_Ty>& _Left, const typename vala
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Boolarray operator&&(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Right.size();
     valarray<bool> _Ans(_Size);
@@ -840,7 +840,7 @@ _NODISCARD _Boolarray operator&&(const typename valarray<_Ty>::value_type& _Left
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Boolarray operator||(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
     const size_t _Size = _Left.size();
     valarray<bool> _Ans(_Size);
@@ -850,7 +850,7 @@ _NODISCARD _Boolarray operator||(const valarray<_Ty>& _Left, const typename vala
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Boolarray operator||(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Right.size();
     valarray<bool> _Ans(_Size);
@@ -860,7 +860,7 @@ _NODISCARD _Boolarray operator||(const typename valarray<_Ty>::value_type& _Left
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator*(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -870,7 +870,7 @@ _NODISCARD valarray<_Ty> operator*(const valarray<_Ty>& _Left, const valarray<_T
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator/(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -880,7 +880,7 @@ _NODISCARD valarray<_Ty> operator/(const valarray<_Ty>& _Left, const valarray<_T
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator%(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -890,7 +890,7 @@ _NODISCARD valarray<_Ty> operator%(const valarray<_Ty>& _Left, const valarray<_T
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator+(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -900,7 +900,7 @@ _NODISCARD valarray<_Ty> operator+(const valarray<_Ty>& _Left, const valarray<_T
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator-(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -910,7 +910,7 @@ _NODISCARD valarray<_Ty> operator-(const valarray<_Ty>& _Left, const valarray<_T
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator^(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -920,7 +920,7 @@ _NODISCARD valarray<_Ty> operator^(const valarray<_Ty>& _Left, const valarray<_T
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator&(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -930,7 +930,7 @@ _NODISCARD valarray<_Ty> operator&(const valarray<_Ty>& _Left, const valarray<_T
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator|(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -940,7 +940,7 @@ _NODISCARD valarray<_Ty> operator|(const valarray<_Ty>& _Left, const valarray<_T
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator<<(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -950,7 +950,7 @@ _NODISCARD valarray<_Ty> operator<<(const valarray<_Ty>& _Left, const valarray<_
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator>>(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -960,7 +960,7 @@ _NODISCARD valarray<_Ty> operator>>(const valarray<_Ty>& _Left, const valarray<_
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Boolarray operator&&(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Left.size();
     valarray<bool> _Ans(_Size);
@@ -970,7 +970,7 @@ _NODISCARD _Boolarray operator&&(const valarray<_Ty>& _Left, const valarray<_Ty>
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Boolarray operator||(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Left.size();
     valarray<bool> _Ans(_Size);
@@ -980,7 +980,7 @@ _NODISCARD _Boolarray operator||(const valarray<_Ty>& _Left, const valarray<_Ty>
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Boolarray operator==(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
     const size_t _Size = _Left.size();
     valarray<bool> _Ans(_Size);
@@ -990,7 +990,7 @@ _NODISCARD _Boolarray operator==(const valarray<_Ty>& _Left, const typename vala
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Boolarray operator==(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Right.size();
     valarray<bool> _Ans(_Size);
@@ -1000,7 +1000,7 @@ _NODISCARD _Boolarray operator==(const typename valarray<_Ty>::value_type& _Left
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Boolarray operator==(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Left.size();
     valarray<bool> _Ans(_Size);
@@ -1010,7 +1010,7 @@ _NODISCARD _Boolarray operator==(const valarray<_Ty>& _Left, const valarray<_Ty>
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Boolarray operator!=(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
     const size_t _Size = _Left.size();
     valarray<bool> _Ans(_Size);
@@ -1020,7 +1020,7 @@ _NODISCARD _Boolarray operator!=(const valarray<_Ty>& _Left, const typename vala
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Boolarray operator!=(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Right.size();
     valarray<bool> _Ans(_Size);
@@ -1030,7 +1030,7 @@ _NODISCARD _Boolarray operator!=(const typename valarray<_Ty>::value_type& _Left
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Boolarray operator!=(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Left.size();
     valarray<bool> _Ans(_Size);
@@ -1040,7 +1040,7 @@ _NODISCARD _Boolarray operator!=(const valarray<_Ty>& _Left, const valarray<_Ty>
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Boolarray operator<(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
     const size_t _Size = _Left.size();
     valarray<bool> _Ans(_Size);
@@ -1050,7 +1050,7 @@ _NODISCARD _Boolarray operator<(const valarray<_Ty>& _Left, const typename valar
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Boolarray operator<(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Right.size();
     valarray<bool> _Ans(_Size);
@@ -1060,7 +1060,7 @@ _NODISCARD _Boolarray operator<(const typename valarray<_Ty>::value_type& _Left,
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Boolarray operator<(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Left.size();
     valarray<bool> _Ans(_Size);
@@ -1070,7 +1070,7 @@ _NODISCARD _Boolarray operator<(const valarray<_Ty>& _Left, const valarray<_Ty>&
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Boolarray operator>(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
     const size_t _Size = _Left.size();
     valarray<bool> _Ans(_Size);
@@ -1080,7 +1080,7 @@ _NODISCARD _Boolarray operator>(const valarray<_Ty>& _Left, const typename valar
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Boolarray operator>(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Right.size();
     valarray<bool> _Ans(_Size);
@@ -1090,7 +1090,7 @@ _NODISCARD _Boolarray operator>(const typename valarray<_Ty>::value_type& _Left,
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Boolarray operator>(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Left.size();
     valarray<bool> _Ans(_Size);
@@ -1100,7 +1100,7 @@ _NODISCARD _Boolarray operator>(const valarray<_Ty>& _Left, const valarray<_Ty>&
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Boolarray operator<=(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
     const size_t _Size = _Left.size();
     valarray<bool> _Ans(_Size);
@@ -1110,7 +1110,7 @@ _NODISCARD _Boolarray operator<=(const valarray<_Ty>& _Left, const typename vala
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Boolarray operator<=(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Right.size();
     valarray<bool> _Ans(_Size);
@@ -1120,7 +1120,7 @@ _NODISCARD _Boolarray operator<=(const typename valarray<_Ty>::value_type& _Left
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Boolarray operator<=(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Left.size();
     valarray<bool> _Ans(_Size);
@@ -1130,7 +1130,7 @@ _NODISCARD _Boolarray operator<=(const valarray<_Ty>& _Left, const valarray<_Ty>
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Boolarray operator>=(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
     const size_t _Size = _Left.size();
     valarray<bool> _Ans(_Size);
@@ -1140,7 +1140,7 @@ _NODISCARD _Boolarray operator>=(const valarray<_Ty>& _Left, const typename vala
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Boolarray operator>=(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Right.size();
     valarray<bool> _Ans(_Size);
@@ -1150,7 +1150,7 @@ _NODISCARD _Boolarray operator>=(const typename valarray<_Ty>::value_type& _Left
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD _Boolarray operator>=(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Left.size();
     valarray<bool> _Ans(_Size);
@@ -1161,7 +1161,7 @@ _NODISCARD _Boolarray operator>=(const valarray<_Ty>& _Left, const valarray<_Ty>
 }
 
 // [valarray.transcend] Transcendentals
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> abs(const valarray<_Ty>& _Left) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -1171,7 +1171,7 @@ _NODISCARD valarray<_Ty> abs(const valarray<_Ty>& _Left) {
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> acos(const valarray<_Ty>& _Left) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -1181,7 +1181,7 @@ _NODISCARD valarray<_Ty> acos(const valarray<_Ty>& _Left) {
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> asin(const valarray<_Ty>& _Left) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -1191,7 +1191,7 @@ _NODISCARD valarray<_Ty> asin(const valarray<_Ty>& _Left) {
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> atan(const valarray<_Ty>& _Left) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -1201,7 +1201,7 @@ _NODISCARD valarray<_Ty> atan(const valarray<_Ty>& _Left) {
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> atan2(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -1211,7 +1211,7 @@ _NODISCARD valarray<_Ty> atan2(const valarray<_Ty>& _Left, const valarray<_Ty>&
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> atan2(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -1221,7 +1221,7 @@ _NODISCARD valarray<_Ty> atan2(const valarray<_Ty>& _Left, const typename valarr
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> atan2(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Right.size();
     valarray<_Ty> _Ans(_Size);
@@ -1231,7 +1231,7 @@ _NODISCARD valarray<_Ty> atan2(const typename valarray<_Ty>::value_type& _Left,
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> cos(const valarray<_Ty>& _Left) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -1241,7 +1241,7 @@ _NODISCARD valarray<_Ty> cos(const valarray<_Ty>& _Left) {
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> cosh(const valarray<_Ty>& _Left) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -1251,7 +1251,7 @@ _NODISCARD valarray<_Ty> cosh(const valarray<_Ty>& _Left) {
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> exp(const valarray<_Ty>& _Left) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -1261,7 +1261,7 @@ _NODISCARD valarray<_Ty> exp(const valarray<_Ty>& _Left) {
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> log(const valarray<_Ty>& _Left) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -1271,7 +1271,7 @@ _NODISCARD valarray<_Ty> log(const valarray<_Ty>& _Left) {
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> log10(const valarray<_Ty>& _Left) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -1281,7 +1281,7 @@ _NODISCARD valarray<_Ty> log10(const valarray<_Ty>& _Left) {
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> pow(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -1291,7 +1291,7 @@ _NODISCARD valarray<_Ty> pow(const valarray<_Ty>& _Left, const valarray<_Ty>& _R
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> pow(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -1301,7 +1301,7 @@ _NODISCARD valarray<_Ty> pow(const valarray<_Ty>& _Left, const typename valarray
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> pow(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
     const size_t _Size = _Right.size();
     valarray<_Ty> _Ans(_Size);
@@ -1311,7 +1311,7 @@ _NODISCARD valarray<_Ty> pow(const typename valarray<_Ty>::value_type& _Left, co
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> sin(const valarray<_Ty>& _Left) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -1321,7 +1321,7 @@ _NODISCARD valarray<_Ty> sin(const valarray<_Ty>& _Left) {
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> sinh(const valarray<_Ty>& _Left) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -1331,7 +1331,7 @@ _NODISCARD valarray<_Ty> sinh(const valarray<_Ty>& _Left) {
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> sqrt(const valarray<_Ty>& _Left) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -1341,7 +1341,7 @@ _NODISCARD valarray<_Ty> sqrt(const valarray<_Ty>& _Left) {
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> tan(const valarray<_Ty>& _Left) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -1351,7 +1351,7 @@ _NODISCARD valarray<_Ty> tan(const valarray<_Ty>& _Left) {
     return _Ans;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> tanh(const valarray<_Ty>& _Left) {
     const size_t _Size = _Left.size();
     valarray<_Ty> _Ans(_Size);
@@ -1361,7 +1361,7 @@ _NODISCARD valarray<_Ty> tanh(const valarray<_Ty>& _Left) {
     return _Ans;
 }
 
-class slice { // define a slice of a valarray
+_EXPORT_STD class slice { // define a slice of a valarray
 public:
     slice() = default;
 
@@ -1392,7 +1392,7 @@ protected:
     size_t _Stride = 0; // the distance between elements
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class slice_array : public slice { // define a slice of a valarray
 public:
     using value_type = _Ty;
@@ -1506,7 +1506,7 @@ private:
     _Ty* _Myptr; // pointer to valarray contents
 };
 
-class gslice { // define a generalized (multidimensional) slice of a valarray
+_EXPORT_STD class gslice { // define a generalized (multidimensional) slice of a valarray
 public:
     gslice() : _Start(0) {} // construct with all zeros
 
@@ -1568,7 +1568,7 @@ private:
     _Sizarray _Stride; // array of distances between elements
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class gslice_array : public gslice { // define a generalized slice of a valarray
 public:
     using value_type = _Ty;
@@ -1695,7 +1695,7 @@ private:
     _Ty* _Myptr; // pointer to valarray contents
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class mask_array { // define a subset of a valarray with an array of mask bits
 public:
     using value_type = _Ty;
@@ -1844,7 +1844,7 @@ private:
     _Ty* _Myptr; // pointer to valarray contents
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class indirect_array { // define a subset of a valarray with an array of indexes
 public:
     using value_type = _Ty;
diff --git a/stl/inc/variant b/stl/inc/variant
index 2461c21052..604c5d4a99 100644
--- a/stl/inc/variant
+++ b/stl/inc/variant
@@ -334,10 +334,10 @@ struct _Meta_cartesian_product_<_List1<_List2<_Items...>, _Lists...>> {
 
 #define _STL_STAMP(n, x) x(_STL_STAMP##n, n)
 
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
 class variant;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct variant_size; // undefined
 template <class _Ty>
 struct variant_size<const _Ty> : variant_size<_Ty>::type {};
@@ -345,15 +345,15 @@ template <class _Ty>
 struct _CXX20_DEPRECATE_VOLATILE variant_size<volatile _Ty> : variant_size<_Ty>::type {};
 template <class _Ty>
 struct _CXX20_DEPRECATE_VOLATILE variant_size<const volatile _Ty> : variant_size<_Ty>::type {};
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 inline constexpr size_t variant_size_v = variant_size<_Ty>::value;
 
 template <class... _Types>
 struct variant_size<variant<_Types...>> : integral_constant<size_t, sizeof...(_Types)> {};
 
-template <size_t _Idx, class _Ty>
+_EXPORT_STD template <size_t _Idx, class _Ty>
 struct variant_alternative; // undefined
-template <size_t _Idx, class _Ty>
+_EXPORT_STD template <size_t _Idx, class _Ty>
 using variant_alternative_t = typename variant_alternative<_Idx, _Ty>::type;
 template <size_t _Idx, class _Ty>
 struct variant_alternative<_Idx, const _Ty> {
@@ -378,7 +378,7 @@ struct variant_alternative<_Idx, variant<_Types...>> {
 #endif // __clang__
 };
 
-inline constexpr size_t variant_npos = _Meta_npos;
+_EXPORT_STD inline constexpr size_t variant_npos = _Meta_npos;
 
 template <bool _TrivialDestruction, class... _Types>
 class _Variant_storage_ {}; // empty storage (empty "_Types" case)
@@ -967,7 +967,7 @@ inline constexpr bool _Is_in_place_index_specialization = false;
 template <size_t _Idx>
 inline constexpr bool _Is_in_place_index_specialization<in_place_index_t<_Idx>> = true;
 
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
 class variant : private _SMF_control<_Variant_destroy_layer<_Types...>, _Types...> { // discriminated union
 public:
     static_assert(conjunction_v<is_object<_Types>..., negation<is_array<_Types>>..., is_destructible<_Types>...>,
@@ -1188,7 +1188,7 @@ private:
     }
 };
 
-template <class _Ty, class... _Types>
+_EXPORT_STD template <class _Ty, class... _Types>
 _NODISCARD constexpr bool holds_alternative(const variant<_Types...>& _Var) noexcept {
     // true iff _Var holds alternative _Ty
     constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
@@ -1197,7 +1197,7 @@ _NODISCARD constexpr bool holds_alternative(const variant<_Types...>& _Var) noex
     return _Var.index() == _Idx;
 }
 
-template <size_t _Idx, class... _Types>
+_EXPORT_STD template <size_t _Idx, class... _Types>
 _NODISCARD constexpr decltype(auto) get(variant<_Types...>& _Var) {
     // access the contained value of _Var if its _Idx-th alternative is active
     static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
@@ -1207,7 +1207,7 @@ _NODISCARD constexpr decltype(auto) get(variant<_Types...>& _Var) {
 
     _Throw_bad_variant_access();
 }
-template <size_t _Idx, class... _Types>
+_EXPORT_STD template <size_t _Idx, class... _Types>
 _NODISCARD constexpr decltype(auto) get(variant<_Types...>&& _Var) {
     // access the contained value of _Var if its _Idx-th alternative is active
     static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
@@ -1217,7 +1217,7 @@ _NODISCARD constexpr decltype(auto) get(variant<_Types...>&& _Var) {
 
     _Throw_bad_variant_access();
 }
-template <size_t _Idx, class... _Types>
+_EXPORT_STD template <size_t _Idx, class... _Types>
 _NODISCARD constexpr decltype(auto) get(const variant<_Types...>& _Var) {
     // access the contained value of _Var if its _Idx-th alternative is active
     static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
@@ -1227,7 +1227,7 @@ _NODISCARD constexpr decltype(auto) get(const variant<_Types...>& _Var) {
 
     _Throw_bad_variant_access();
 }
-template <size_t _Idx, class... _Types>
+_EXPORT_STD template <size_t _Idx, class... _Types>
 _NODISCARD constexpr decltype(auto) get(const variant<_Types...>&& _Var) {
     // access the contained value of _Var if its _Idx-th alternative is active
     static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
@@ -1238,7 +1238,7 @@ _NODISCARD constexpr decltype(auto) get(const variant<_Types...>&& _Var) {
     _Throw_bad_variant_access();
 }
 
-template <class _Ty, class... _Types>
+_EXPORT_STD template <class _Ty, class... _Types>
 _NODISCARD constexpr decltype(auto) get(variant<_Types...>& _Var) {
     // access the contained value of _Var if its alternative _Ty is active
     constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
@@ -1246,7 +1246,7 @@ _NODISCARD constexpr decltype(auto) get(variant<_Types...>& _Var) {
         "get<T>(variant<Types...>&) requires T to occur exactly once in Types. (N4835 [variant.get]/5)");
     return _STD get<_Idx>(_Var);
 }
-template <class _Ty, class... _Types>
+_EXPORT_STD template <class _Ty, class... _Types>
 _NODISCARD constexpr decltype(auto) get(variant<_Types...>&& _Var) {
     // access the contained value of _Var if its alternative _Ty is active
     constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
@@ -1254,7 +1254,7 @@ _NODISCARD constexpr decltype(auto) get(variant<_Types...>&& _Var) {
         "get<T>(variant<Types...>&&) requires T to occur exactly once in Types. (N4835 [variant.get]/5)");
     return _STD get<_Idx>(_STD move(_Var));
 }
-template <class _Ty, class... _Types>
+_EXPORT_STD template <class _Ty, class... _Types>
 _NODISCARD constexpr decltype(auto) get(const variant<_Types...>& _Var) {
     // access the contained value of _Var if its alternative _Ty is active
     constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
@@ -1262,7 +1262,7 @@ _NODISCARD constexpr decltype(auto) get(const variant<_Types...>& _Var) {
         "get<T>(const variant<Types...>&) requires T to occur exactly once in Types. (N4835 [variant.get]/5)");
     return _STD get<_Idx>(_Var);
 }
-template <class _Ty, class... _Types>
+_EXPORT_STD template <class _Ty, class... _Types>
 _NODISCARD constexpr decltype(auto) get(const variant<_Types...>&& _Var) {
     // access the contained value of _Var if its alternative _Ty is active
     constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
@@ -1271,20 +1271,20 @@ _NODISCARD constexpr decltype(auto) get(const variant<_Types...>&& _Var) {
     return _STD get<_Idx>(_STD move(_Var));
 }
 
-template <size_t _Idx, class... _Types>
+_EXPORT_STD template <size_t _Idx, class... _Types>
 _NODISCARD constexpr auto get_if(variant<_Types...>* _Ptr) noexcept {
     // get the address of *_Ptr's contained value if it holds alternative _Idx
     static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
     return _Ptr && _Ptr->index() == _Idx ? _STD addressof(_Variant_raw_get<_Idx>(_Ptr->_Storage())) : nullptr;
 }
-template <size_t _Idx, class... _Types>
+_EXPORT_STD template <size_t _Idx, class... _Types>
 _NODISCARD constexpr auto get_if(const variant<_Types...>* _Ptr) noexcept {
     // get the address of *_Ptr's contained value if it holds alternative _Idx
     static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
     return _Ptr && _Ptr->index() == _Idx ? _STD addressof(_Variant_raw_get<_Idx>(_Ptr->_Storage())) : nullptr;
 }
 
-template <class _Ty, class... _Types>
+_EXPORT_STD template <class _Ty, class... _Types>
 _NODISCARD constexpr add_pointer_t<_Ty> get_if(variant<_Types...>* _Ptr) noexcept {
     // get the address of *_Ptr's contained value if it holds alternative _Ty
     constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
@@ -1292,7 +1292,7 @@ _NODISCARD constexpr add_pointer_t<_Ty> get_if(variant<_Types...>* _Ptr) noexcep
         "get_if<T>(variant<Types...> *) requires T to occur exactly once in Types. (N4835 [variant.get]/9)");
     return _STD get_if<_Idx>(_Ptr);
 }
-template <class _Ty, class... _Types>
+_EXPORT_STD template <class _Ty, class... _Types>
 _NODISCARD constexpr add_pointer_t<const _Ty> get_if(const variant<_Types...>* _Ptr) noexcept {
     // get the address of *_Ptr's contained value if it holds alternative _Ty
     constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
@@ -1319,7 +1319,7 @@ struct _Variant_relop_visitor2 { // evaluate _Op with the contained value of two
     }
 };
 
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
 _NODISCARD constexpr bool operator==(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
     conjunction_v<is_nothrow_invocable_r<bool, equal_to<>, const _Types&, const _Types&>...>) /* strengthened */ {
     // determine if the arguments are both valueless or contain equal values
@@ -1329,7 +1329,7 @@ _NODISCARD constexpr bool operator==(const variant<_Types...>& _Left, const vari
         && _Variant_raw_visit(_Right_index, _Right._Storage(), _Visitor{_Left._Storage()});
 }
 
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
 _NODISCARD constexpr bool operator!=(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
     conjunction_v<is_nothrow_invocable_r<bool, not_equal_to<>, const _Types&, const _Types&>...>) /* strengthened */ {
     // determine if the arguments have different active alternatives or contain unequal values
@@ -1339,7 +1339,7 @@ _NODISCARD constexpr bool operator!=(const variant<_Types...>& _Left, const vari
         || _Variant_raw_visit(_Right_index, _Right._Storage(), _Visitor{_Left._Storage()});
 }
 
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
 _NODISCARD constexpr bool operator<(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
     conjunction_v<is_nothrow_invocable_r<bool, less<>, const _Types&, const _Types&>...>) /* strengthened */ {
     // determine if _Left has a lesser index(), or equal index() and lesser
@@ -1352,7 +1352,7 @@ _NODISCARD constexpr bool operator<(const variant<_Types...>& _Left, const varia
             && _Variant_raw_visit(_Right_offset - 1, _Right._Storage(), _Visitor{_Left._Storage()}));
 }
 
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
 _NODISCARD constexpr bool operator>(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
     conjunction_v<is_nothrow_invocable_r<bool, greater<>, const _Types&, const _Types&>...>) /* strengthened */ {
     // determine if _Left has a greater index(), or equal index() and
@@ -1365,7 +1365,7 @@ _NODISCARD constexpr bool operator>(const variant<_Types...>& _Left, const varia
             && _Variant_raw_visit(_Right_offset - 1, _Right._Storage(), _Visitor{_Left._Storage()}));
 }
 
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
 _NODISCARD constexpr bool operator<=(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
     conjunction_v<is_nothrow_invocable_r<bool, less_equal<>, const _Types&, const _Types&>...>) /* strengthened */ {
     // determine if _Left's index() is less than _Right's, or equal and
@@ -1378,7 +1378,7 @@ _NODISCARD constexpr bool operator<=(const variant<_Types...>& _Left, const vari
             && _Variant_raw_visit(_Right_offset - 1, _Right._Storage(), _Visitor{_Left._Storage()}));
 }
 
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
 _NODISCARD constexpr bool operator>=(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
     conjunction_v<is_nothrow_invocable_r<bool, greater_equal<>, const _Types&, const _Types&>...>) /* strengthened */ {
     // determine if _Left's index() is greater than _Right's, or equal and
@@ -1393,7 +1393,7 @@ _NODISCARD constexpr bool operator>=(const variant<_Types...>& _Left, const vari
 
 #ifdef __cpp_lib_concepts
 // clang-format off
-template <class... _Types>
+_EXPORT_STD template <class... _Types>
     requires (three_way_comparable<_Types> && ...)
 _NODISCARD constexpr common_comparison_category_t<compare_three_way_result_t<_Types>...>
     operator<=>(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
@@ -1604,7 +1604,7 @@ inline constexpr bool
     _Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args...>, const variant<_Types...>&&, _Rest...> =
         (_Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args..., const _Types>, _Rest...> && ...);
 
-template <class _Callable, class... _Variants, class = void_t<_As_variant<_Variants>...>>
+_EXPORT_STD template <class _Callable, class... _Variants, class = void_t<_As_variant<_Variants>...>>
 constexpr _Variant_visit_result_t<_Callable, _As_variant<_Variants>...> visit(_Callable&& _Obj, _Variants&&... _Args) {
     // Invoke _Obj with the contained values of _Args...
     constexpr auto _Size = _Variant_total_states<_Remove_cvref_t<_As_variant<_Variants>>...>;
@@ -1649,7 +1649,7 @@ inline constexpr bool _Variant_all_visit_results_convertible<_Expected, _Callabl
     const variant<_Types...>&&, _Rest...> =
     (_Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args..., const _Types>, _Rest...> && ...);
 
-template <class _Ret, class _Callable, class... _Variants, class = void_t<_As_variant<_Variants>...>>
+_EXPORT_STD template <class _Ret, class _Callable, class... _Variants, class = void_t<_As_variant<_Variants>...>>
 constexpr _Ret visit(_Callable&& _Obj, _Variants&&... _Args) {
     constexpr auto _Size = _Variant_total_states<_Remove_cvref_t<_As_variant<_Variants>>...>;
     using _ListOfIndexLists =
@@ -1667,12 +1667,12 @@ constexpr _Ret visit(_Callable&& _Obj, _Variants&&... _Args) {
 }
 #endif // _HAS_CXX20
 
-_NODISCARD constexpr bool operator==(monostate, monostate) noexcept {
+_EXPORT_STD _NODISCARD constexpr bool operator==(monostate, monostate) noexcept {
     return true;
 }
 
 #if _HAS_CXX20
-_NODISCARD constexpr strong_ordering operator<=>(monostate, monostate) noexcept {
+_EXPORT_STD _NODISCARD constexpr strong_ordering operator<=>(monostate, monostate) noexcept {
     return strong_ordering::equal;
 }
 #else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
@@ -1693,7 +1693,7 @@ _NODISCARD constexpr bool operator>=(monostate, monostate) noexcept {
 }
 #endif // !_HAS_CXX20
 
-template <class... _Types,
+_EXPORT_STD template <class... _Types,
     enable_if_t<conjunction_v<is_move_constructible<_Types>..., is_swappable<_Types>...>, int> = 0>
 _CONSTEXPR20 void swap(variant<_Types...>& _Left, variant<_Types...>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
     _Left.swap(_Right);
diff --git a/stl/inc/vector b/stl/inc/vector
index 1d3062f626..7428af2d83 100644
--- a/stl/inc/vector
+++ b/stl/inc/vector
@@ -490,7 +490,7 @@ _INLINE_VAR constexpr bool
 #pragma detect_mismatch("annotate_vector", "0")
 #endif // !_INSERT_VECTOR_ANNOTATION
 
-template <class _Ty, class _Alloc = allocator<_Ty>>
+_EXPORT_STD template <class _Ty, class _Alloc = allocator<_Ty>>
 class vector { // varying size array of values
 private:
     template <class>
@@ -2280,7 +2280,7 @@ using _Vbase = unsigned int; // word type for vector<bool> representation
 
 _INLINE_VAR constexpr int _VBITS = 8 * sizeof(_Vbase); // at least CHAR_BITS bits per word
 
-template <class _Ty, class _Alloc>
+_EXPORT_STD template <class _Ty, class _Alloc>
 _NODISCARD _CONSTEXPR20 bool operator==(const vector<_Ty, _Alloc>& _Left, const vector<_Ty, _Alloc>& _Right) {
     if (_Left.size() != _Right.size()) {
         return false;
@@ -2344,7 +2344,7 @@ struct _Vbase_compare_three_way {
 };
 
 #ifdef __cpp_lib_concepts
-template <class _Ty, class _Alloc>
+_EXPORT_STD template <class _Ty, class _Alloc>
 _NODISCARD constexpr _Synth_three_way_result<_Ty> operator<=>(
     const vector<_Ty, _Alloc>& _Left, const vector<_Ty, _Alloc>& _Right) {
     if constexpr (is_same_v<_Ty, bool>) {
@@ -2412,18 +2412,18 @@ _NODISCARD _CONSTEXPR20 bool operator>=(const vector<_Ty, _Alloc>& _Left, const
 }
 #endif // ^^^ !defined(__cpp_lib_concepts) ^^^
 
-template <class _Ty, class _Alloc>
+_EXPORT_STD template <class _Ty, class _Alloc>
 _CONSTEXPR20 void swap(vector<_Ty, _Alloc>& _Left, vector<_Ty, _Alloc>& _Right) noexcept /* strengthened */ {
     _Left.swap(_Right);
 }
 
 #if _HAS_CXX20
-template <class _Ty, class _Alloc, class _Uty>
+_EXPORT_STD template <class _Ty, class _Alloc, class _Uty>
 constexpr typename vector<_Ty, _Alloc>::size_type erase(vector<_Ty, _Alloc>& _Cont, const _Uty& _Val) {
     return _Erase_remove(_Cont, _Val);
 }
 
-template <class _Ty, class _Alloc, class _Pr>
+_EXPORT_STD template <class _Ty, class _Alloc, class _Pr>
 constexpr typename vector<_Ty, _Alloc>::size_type erase_if(vector<_Ty, _Alloc>& _Cont, _Pr _Pred) {
     return _Erase_remove_if(_Cont, _Pass_fn(_Pred));
 }
@@ -3637,7 +3637,7 @@ struct hash<vector<bool, _Alloc>> {
 
 #if _HAS_CXX17
 namespace pmr {
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     using vector = _STD vector<_Ty, polymorphic_allocator<_Ty>>;
 } // namespace pmr
 #endif // _HAS_CXX17
diff --git a/stl/inc/xatomic.h b/stl/inc/xatomic.h
index d0472d7ed4..ea27ea30b4 100644
--- a/stl/inc/xatomic.h
+++ b/stl/inc/xatomic.h
@@ -53,7 +53,7 @@ _STL_DISABLE_CLANG_WARNINGS
 _STD_BEGIN
 
 #if _HAS_CXX20
-enum class memory_order : int {
+_EXPORT_STD enum class memory_order : int {
     relaxed,
     consume,
     acquire,
@@ -69,12 +69,12 @@ enum class memory_order : int {
     memory_order_acq_rel = acq_rel,
     memory_order_seq_cst = seq_cst
 };
-inline constexpr memory_order memory_order_relaxed = memory_order::relaxed;
-inline constexpr memory_order memory_order_consume = memory_order::consume;
-inline constexpr memory_order memory_order_acquire = memory_order::acquire;
-inline constexpr memory_order memory_order_release = memory_order::release;
-inline constexpr memory_order memory_order_acq_rel = memory_order::acq_rel;
-inline constexpr memory_order memory_order_seq_cst = memory_order::seq_cst;
+_EXPORT_STD inline constexpr memory_order memory_order_relaxed = memory_order::relaxed;
+_EXPORT_STD inline constexpr memory_order memory_order_consume = memory_order::consume;
+_EXPORT_STD inline constexpr memory_order memory_order_acquire = memory_order::acquire;
+_EXPORT_STD inline constexpr memory_order memory_order_release = memory_order::release;
+_EXPORT_STD inline constexpr memory_order memory_order_acq_rel = memory_order::acq_rel;
+_EXPORT_STD inline constexpr memory_order memory_order_seq_cst = memory_order::seq_cst;
 #else // _HAS_CXX20
 enum memory_order {
     memory_order_relaxed,
@@ -86,7 +86,7 @@ enum memory_order {
 };
 #endif // _HAS_CXX20
 
-using _Atomic_counter_t = unsigned long;
+_EXPORT_STD /* TRANSITION, VSO-1592329 */ using _Atomic_counter_t = unsigned long;
 
 template <class _Integral, class _Ty>
 _NODISCARD volatile _Integral* _Atomic_address_as(_Ty& _Source) noexcept {
diff --git a/stl/inc/xcall_once.h b/stl/inc/xcall_once.h
index bd3526fed4..8ae5aa8fcd 100644
--- a/stl/inc/xcall_once.h
+++ b/stl/inc/xcall_once.h
@@ -17,7 +17,7 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-struct once_flag { // opaque data structure for call_once()
+_EXPORT_STD struct once_flag { // opaque data structure for call_once()
     constexpr once_flag() noexcept : _Opaque(nullptr) {}
 
     once_flag(const once_flag&)            = delete;
@@ -30,7 +30,7 @@ struct once_flag { // opaque data structure for call_once()
 using _Execute_once_fp_t = int(__stdcall*)(void*, void*, void**);
 
 // Returns BOOL, nonzero to indicate success, zero for failure
-_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Execute_once(
+extern "C++" _CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Execute_once(
     once_flag& _Flag, _Execute_once_fp_t _Callback, void* _Pv) noexcept;
 
 template <class _Ty>
diff --git a/stl/inc/xcharconv.h b/stl/inc/xcharconv.h
index e96f858c0b..c999e0f3ab 100644
--- a/stl/inc/xcharconv.h
+++ b/stl/inc/xcharconv.h
@@ -25,16 +25,16 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-enum class chars_format {
+_EXPORT_STD enum class chars_format {
     scientific = 0b001,
     fixed      = 0b010,
     hex        = 0b100,
     general    = fixed | scientific,
 };
 
-_BITMASK_OPS(chars_format)
+_BITMASK_OPS(_EXPORT_STD, chars_format)
 
-struct to_chars_result {
+_EXPORT_STD struct to_chars_result {
     char* ptr;
     errc ec;
 #if _HAS_CXX20
diff --git a/stl/inc/xerrc.h b/stl/inc/xerrc.h
index 8a7e7aae66..001c772fd9 100644
--- a/stl/inc/xerrc.h
+++ b/stl/inc/xerrc.h
@@ -17,7 +17,7 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-enum class errc { // names for generic error codes
+_EXPORT_STD enum class errc { // names for generic error codes
     address_family_not_supported       = 102, // EAFNOSUPPORT
     address_in_use                     = 100, // EADDRINUSE
     address_not_available              = 101, // EADDRNOTAVAIL
diff --git a/stl/inc/xfacet b/stl/inc/xfacet
index 86a985637e..ee4663bbae 100644
--- a/stl/inc/xfacet
+++ b/stl/inc/xfacet
@@ -22,7 +22,7 @@ _STL_DISABLE_CLANG_WARNINGS
 // In particular, basic_string must not be included here.
 
 _STD_BEGIN
-class _CRTIMP2_PURE_IMPORT _Facet_base { // code for reference counting a facet
+extern "C++" class _CRTIMP2_PURE_IMPORT _Facet_base { // code for reference counting a facet
 public:
     virtual __CLR_OR_THIS_CALL ~_Facet_base() noexcept {} // ensure that derived classes can be destroyed properly
 
@@ -37,7 +37,7 @@ public:
 void __CLRCALL_OR_CDECL _Facet_Register_m(_Facet_base*);
 
 #else // defined(_M_CEE)
-void __CLRCALL_OR_CDECL _Facet_Register(_Facet_base*);
+extern "C++" void __CLRCALL_OR_CDECL _Facet_Register(_Facet_base*);
 #endif // defined(_M_CEE)
 _STD_END
 #pragma pop_macro("new")
diff --git a/stl/inc/xfilesystem_abi.h b/stl/inc/xfilesystem_abi.h
index 278b17a854..574cb1002c 100644
--- a/stl/inc/xfilesystem_abi.h
+++ b/stl/inc/xfilesystem_abi.h
@@ -19,6 +19,7 @@ _STL_DISABLE_CLANG_WARNINGS
 #pragma push_macro("new")
 #undef new
 
+_EXTERN_C
 inline constexpr size_t __std_fs_max_path      = 260; // #define MAX_PATH          260
 inline constexpr size_t __std_fs_temp_path_max = __std_fs_max_path + 1;
 
@@ -76,8 +77,11 @@ enum class __std_fs_file_attr : unsigned long {
 
     _Invalid = 0xFFFFFFFF, // #define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
 };
-_BITMASK_OPS(__std_fs_file_attr)
+_END_EXTERN_C
+
+_BITMASK_OPS(_EMPTY_ARGUMENT, __std_fs_file_attr)
 
+_EXTERN_C
 enum class __std_fs_reparse_tag : unsigned long {
     _None        = 0,
     _Mount_point = (0xA0000003L), // #define IO_REPARSE_TAG_MOUNT_POINT              (0xA0000003L)
@@ -118,9 +122,11 @@ enum class __std_fs_stats_flags : unsigned long {
 
     _All_data = _Attributes | _Reparse_tag | _File_size | _Link_count | _Last_write_time
 };
+_END_EXTERN_C
 
-_BITMASK_OPS(__std_fs_stats_flags)
+_BITMASK_OPS(_EMPTY_ARGUMENT, __std_fs_stats_flags)
 
+_EXTERN_C
 struct __std_fs_stats {
     long long _Last_write_time;
     unsigned long long _File_size;
@@ -192,17 +198,21 @@ enum class __std_access_rights : unsigned long {
     //                                   | FILE_WRITE_EA | FILE_APPEND_DATA | SYNCHRONIZE)
     _File_generic_write = 0x00120116,
 };
+_END_EXTERN_C
 
-_BITMASK_OPS(__std_access_rights)
+_BITMASK_OPS(_EMPTY_ARGUMENT, __std_access_rights)
 
+_EXTERN_C
 enum class __std_fs_file_flags : unsigned long {
     _None               = 0,
     _Backup_semantics   = 0x02000000, // #define FILE_FLAG_BACKUP_SEMANTICS      0x02000000
     _Open_reparse_point = 0x00200000, // #define FILE_FLAG_OPEN_REPARSE_POINT    0x00200000
 };
+_END_EXTERN_C
 
-_BITMASK_OPS(__std_fs_file_flags)
+_BITMASK_OPS(_EMPTY_ARGUMENT, __std_fs_file_flags)
 
+_EXTERN_C
 enum class __std_fs_file_handle : intptr_t { _Invalid = -1 };
 
 enum class __std_code_page : unsigned int { _Acp = 0, _Utf8 = 65001 };
@@ -225,8 +235,9 @@ enum class __std_fs_copy_options {
     _Overwrite_existing = 0x2,
     _Update_existing    = 0x4,
 };
+_END_EXTERN_C
 
-_BITMASK_OPS(__std_fs_copy_options)
+_BITMASK_OPS(_EMPTY_ARGUMENT, __std_fs_copy_options)
 
 _EXTERN_C
 _NODISCARD __std_ulong_and_error __stdcall __std_fs_get_full_path_name(_In_z_ const wchar_t* _Source,
diff --git a/stl/inc/xhash b/stl/inc/xhash
index 4b36dd4989..4b9587a5b9 100644
--- a/stl/inc/xhash
+++ b/stl/inc/xhash
@@ -2004,7 +2004,7 @@ template <class _Hasher>
 using _Is_hasher = negation<disjunction<is_integral<_Hasher>, _Is_allocator<_Hasher>>>;
 #endif // _HAS_CXX17
 
-template <class _Traits>
+_EXPORT_STD /* TRANSITION, VSO-1538698 */ template <class _Traits>
 _NODISCARD bool _Hash_equal(const _Hash<_Traits>& _Left, const _Hash<_Traits>& _Right) {
     if (_Left.size() != _Right.size()) {
         return false;
diff --git a/stl/inc/xiosbase b/stl/inc/xiosbase
index b427a67a50..fd4ea7dc14 100644
--- a/stl/inc/xiosbase
+++ b/stl/inc/xiosbase
@@ -167,7 +167,7 @@ const typename _Iosb<_Dummy>::_Seekdir _Iosb<_Dummy>::cur;
 template <class _Dummy>
 const typename _Iosb<_Dummy>::_Seekdir _Iosb<_Dummy>::end;
 
-class _CRTIMP2_PURE_IMPORT ios_base : public _Iosb<int> { // base class for ios
+_EXPORT_STD extern "C++" class _CRTIMP2_PURE_IMPORT ios_base : public _Iosb<int> { // base class for ios
 public:
     using fmtflags = int;
     using iostate  = int;
diff --git a/stl/inc/xlocale b/stl/inc/xlocale
index 137965da85..862ce1ac6d 100644
--- a/stl/inc/xlocale
+++ b/stl/inc/xlocale
@@ -53,10 +53,10 @@ const int _Locbase<_Dummy>::all;
 template <class _Dummy>
 const int _Locbase<_Dummy>::none;
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 class collate;
 
-struct _CRTIMP2_PURE_IMPORT _Crt_new_delete { // base class for marking allocations as CRT blocks
+extern "C++" struct _CRTIMP2_PURE_IMPORT _Crt_new_delete { // base class for marking allocations as CRT blocks
 #ifdef _DEBUG
     void* __CLRCALL_OR_CDECL operator new(size_t _Size) { // replace operator new
         void* _Ptr = operator new(_Size, nothrow);
@@ -87,7 +87,7 @@ struct _CRTIMP2_PURE_IMPORT _Crt_new_delete { // base class for marking allocati
 #endif // _DEBUG
 };
 
-class locale : public _Locbase<int>, public _Crt_new_delete {
+_EXPORT_STD extern "C++" class locale : public _Locbase<int>, public _Crt_new_delete {
 public:
     using category = int;
 
@@ -418,7 +418,7 @@ struct _Facetptr { // store pointer to lazy facet for use_facet
 template <class _Facet>
 __PURE_APPDOMAIN_GLOBAL const locale::facet* _Facetptr<_Facet>::_Psave = nullptr;
 
-template <class _Facet>
+_EXPORT_STD template <class _Facet>
 const _Facet& __CRTDECL use_facet(const locale& _Loc) { // get facet reference from locale
     _BEGIN_LOCK(_LOCK_LOCALE) // the thread lock, make get atomic
     const locale::facet* _Psave = _Facetptr<_Facet>::_Psave; // static pointer to lazy facet
@@ -607,7 +607,7 @@ inline unsigned short* __CRTDECL _Maklocstr(const char* _Ptr, unsigned short*, c
 }
 #endif // defined(_NATIVE_WCHAR_T_DEFINED) && !_ENFORCE_FACET_SPECIALIZATIONS
 
-class _CRTIMP2_PURE_IMPORT codecvt_base : public locale::facet { // base class for codecvt
+_EXPORT_STD extern "C++" class _CRTIMP2_PURE_IMPORT codecvt_base : public locale::facet { // base class for codecvt
 public:
     enum { // constants for different parse states
         ok,
@@ -665,7 +665,7 @@ template <class _Elem, class _Byte>
 _INLINE_VAR constexpr bool _Is_codecvt_do_always_noconv_v =
     is_same_v<_Byte, _Elem> || (_Is_one_byte_char_like_v<_Byte> && _Is_one_byte_char_like_v<_Elem>);
 
-template <class _Elem, class _Byte, class _Statype>
+_EXPORT_STD extern "C++" template <class _Elem, class _Byte, class _Statype>
 class codecvt : public codecvt_base { // facet for converting between _Elem and _Byte sequences
 public:
     // Explicitly specialized below:
@@ -799,7 +799,7 @@ __PURE_APPDOMAIN_GLOBAL locale::id codecvt<_Elem, _Byte, _Statype>::id;
 #pragma clang diagnostic pop
 #endif // __clang__
 
-template <class _CvtTy, class _Byte, class _Statype>
+_EXPORT_STD /* TRANSITION, VSO-1538698 */ template <class _CvtTy, class _Byte, class _Statype>
 _NODISCARD int _Codecvt_do_length(
     const _CvtTy& _Cvt, _Statype& _State, const _Byte* _First1, const _Byte* _Last1, size_t _Count) {
     // return p - _First1, for the largest value p in [_First1, _Last1] such that _Cvt will successfully convert
@@ -2319,7 +2319,7 @@ private:
 };
 #endif // defined(_NATIVE_WCHAR_T_DEFINED) && !_ENFORCE_FACET_SPECIALIZATIONS
 
-template <class _Elem, class _Byte, class _Statype>
+_EXPORT_STD template <class _Elem, class _Byte, class _Statype>
 class codecvt_byname : public codecvt<_Elem, _Byte, _Statype> { // codecvt for named locale
 public:
     static_assert(!_ENFORCE_FACET_SPECIALIZATIONS
@@ -2350,7 +2350,7 @@ protected:
 #define _UP _UPPER // 'A'-'Z'
 #define _XD _HEX // '0'-'9', 'A'-'F', 'a'-'f'
 
-struct _CRTIMP2_PURE_IMPORT ctype_base : locale::facet { // base for ctype
+_EXPORT_STD extern "C++" struct _CRTIMP2_PURE_IMPORT ctype_base : locale::facet { // base for ctype
     enum { // constants for character classifications
         alnum  = _DI | _LO | _UP | _XA,
         alpha  = _LO | _UP | _XA,
@@ -2382,7 +2382,7 @@ struct _CRTIMP2_PURE_IMPORT ctype_base : locale::facet { // base for ctype
 #undef _UP
 #undef _XD
 
-template <class _Elem>
+_EXPORT_STD extern "C++" template <class _Elem>
 class ctype : public ctype_base { // facet for classifying elements, converting cases
 public:
     // ctype<char>, ctype<wchar_t>, and ctype<unsigned short> are explicitly specialized below.
@@ -3213,7 +3213,7 @@ private:
 };
 #endif // defined(_NATIVE_WCHAR_T_DEFINED) && !_ENFORCE_FACET_SPECIALIZATIONS
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 class ctype_byname : public ctype<_Elem> { // ctype for named locale
 public:
     static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
diff --git a/stl/inc/xlocbuf b/stl/inc/xlocbuf
index ae3f882d70..432800d499 100644
--- a/stl/inc/xlocbuf
+++ b/stl/inc/xlocbuf
@@ -19,7 +19,7 @@ _STL_DISABLE_CLANG_WARNINGS
 
 _STD_BEGIN
 _STL_DISABLE_DEPRECATED_WARNING
-template <class _Codecvt, class _Elem = wchar_t, class _Traits = char_traits<_Elem>>
+_EXPORT_STD template <class _Codecvt, class _Elem = wchar_t, class _Traits = char_traits<_Elem>>
 class _CXX17_DEPRECATE_CODECVT_HEADER wbuffer_convert
     : public basic_streambuf<_Elem, _Traits> { // stream buffer associated with a codecvt facet
 private:
@@ -298,7 +298,8 @@ private:
     locale _Loc; // manages reference to codecvt facet
 };
 
-template <class _Codecvt, class _Elem = wchar_t, class _Walloc = allocator<_Elem>, class _Balloc = allocator<char>>
+_EXPORT_STD template <class _Codecvt, class _Elem = wchar_t, class _Walloc = allocator<_Elem>,
+    class _Balloc = allocator<char>>
 class _CXX17_DEPRECATE_CODECVT_HEADER wstring_convert { // converts between _Elem (wide) and char (byte) strings
 private:
     enum { _BUF_INC = 8, _BUF_MAX = 16 };
diff --git a/stl/inc/xlocinfo b/stl/inc/xlocinfo
index 2d0223d6d2..27f63566a2 100644
--- a/stl/inc/xlocinfo
+++ b/stl/inc/xlocinfo
@@ -115,7 +115,7 @@ _MRTIMP2 _locale_t __cdecl _GetLocaleForCP(unsigned int);
 #endif // _M_CEE_PURE
 
 _STD_BEGIN
-class _CRTIMP2_PURE_IMPORT _Timevec { // smart pointer to information used by _Strftime
+extern "C++" class _CRTIMP2_PURE_IMPORT _Timevec { // smart pointer to information used by _Strftime
 public:
     explicit __CLR_OR_THIS_CALL _Timevec(void* _Ptr = nullptr) : _Timeptr(_Ptr) {}
 
@@ -145,7 +145,7 @@ private:
     void* _Timeptr; // pointer to time information
 };
 
-template <class _Elem>
+extern "C++" template <class _Elem>
 class _CRTIMP2_PURE_IMPORT _Yarn { // wrap a NTCTS
 public:
     __CLR_OR_THIS_CALL _Yarn() noexcept : _Myptr(nullptr), _Nul(0) {}
@@ -226,7 +226,7 @@ private:
     _Elem _Nul; // nul terminator for unallocated string
 };
 
-class _CRTIMP2_PURE_IMPORT _Locinfo { // summary of all stuff specific to a locale used by standard facets
+extern "C++" class _CRTIMP2_PURE_IMPORT _Locinfo { // summary of all stuff specific to a locale used by standard facets
 public:
     using _Collvec  = ::_Collvec;
     using _Ctypevec = ::_Ctypevec;
diff --git a/stl/inc/xlocmes b/stl/inc/xlocmes
index da9b6ad2e4..171bea273f 100644
--- a/stl/inc/xlocmes
+++ b/stl/inc/xlocmes
@@ -18,13 +18,13 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-struct messages_base : locale::facet { // base class for messages
+_EXPORT_STD struct messages_base : locale::facet { // base class for messages
     using catalog = int;
 
     explicit messages_base(size_t _Refs = 0) : locale::facet(_Refs) {}
 };
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 class messages : public messages_base { // facet for obtaining messages from a catalog
 public:
     static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
@@ -101,7 +101,7 @@ __PURE_APPDOMAIN_GLOBAL locale::id messages<_Elem>::id;
 #pragma clang diagnostic pop
 #endif // __clang__
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 class messages_byname : public messages<_Elem> { // messages for named locale
 public:
     static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
diff --git a/stl/inc/xlocmon b/stl/inc/xlocmon
index b4aeb27ef8..cf8a0d93aa 100644
--- a/stl/inc/xlocmon
+++ b/stl/inc/xlocmon
@@ -19,7 +19,7 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-struct money_base : locale::facet { // ultimate base class for moneypunct
+_EXPORT_STD struct money_base : locale::facet { // ultimate base class for moneypunct
     enum { // constants for different format codes
         symbol = '$',
         sign   = '+',
@@ -241,7 +241,7 @@ private:
     _Locinfo::_Cvtvec _Cvt; // conversion information
 };
 
-template <class _Elem, bool _Intl = false>
+_EXPORT_STD template <class _Elem, bool _Intl = false>
 class moneypunct : public _Mpunct<_Elem> { // facet for defining monetary punctuation text
 public:
     static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
@@ -284,7 +284,7 @@ __PURE_APPDOMAIN_GLOBAL locale::id moneypunct<_Elem, _Intl>::id;
 #pragma clang diagnostic pop
 #endif // __clang__
 
-template <class _Elem, bool _Intl = false>
+_EXPORT_STD template <class _Elem, bool _Intl = false>
 class moneypunct_byname : public moneypunct<_Elem, _Intl> { // moneypunct for named locale
 public:
     static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
@@ -299,7 +299,7 @@ protected:
     __CLR_OR_THIS_CALL ~moneypunct_byname() noexcept override {}
 };
 
-template <class _Elem, class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem>>>
+_EXPORT_STD template <class _Elem, class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem>>>
 class money_get : public locale::facet { // facet for converting text to encoded monetary amounts
 private:
     using _Mypunct0 = moneypunct<_Elem, false>;
@@ -603,7 +603,7 @@ __PURE_APPDOMAIN_GLOBAL locale::id money_get<_Elem, _InIt>::id;
 #pragma clang diagnostic pop
 #endif // __clang__
 
-template <class _Elem, class _OutIt = ostreambuf_iterator<_Elem, char_traits<_Elem>>>
+_EXPORT_STD template <class _Elem, class _OutIt = ostreambuf_iterator<_Elem, char_traits<_Elem>>>
 class money_put : public locale::facet { // facet for converting encoded monetary amounts to text
 private:
     using _Mypunct0 = moneypunct<_Elem, false>;
diff --git a/stl/inc/xlocnum b/stl/inc/xlocnum
index d0ca6aa751..7b935d5254 100644
--- a/stl/inc/xlocnum
+++ b/stl/inc/xlocnum
@@ -92,7 +92,7 @@ inline wchar_t* _Maklocwcs(const wchar_t* _Ptr) { // copy NTWCS to allocated sto
     return _Ptrdest;
 }
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 class numpunct : public locale::facet { // facet for defining numeric punctuation text
 private:
     friend _Tidy_guard<numpunct>;
@@ -226,7 +226,7 @@ private:
     const _Elem* _Truename; // name for true, "true" for "C" locale
 };
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 class numpunct_byname : public numpunct<_Elem> { // numpunct for named locale
 public:
     static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
@@ -255,7 +255,7 @@ __PURE_APPDOMAIN_GLOBAL locale::id numpunct<_Elem>::id;
 #endif // __clang__
 #endif // !defined(_CRTBLD) || defined(CRTDLL2) || !defined(_DLL) || defined(_M_CEE_PURE)
 
-template <class _Elem, class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem>>>
+_EXPORT_STD extern "C++" template <class _Elem, class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem>>>
 class num_get : public locale::facet { // facet for converting text to encoded numbers
 public:
     static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
@@ -1161,7 +1161,7 @@ int _Float_put_desired_precision(const streamsize _Precision, const ios_base::fm
     }
 }
 
-template <class _Elem, class _OutIt = ostreambuf_iterator<_Elem, char_traits<_Elem>>>
+_EXPORT_STD extern "C++" template <class _Elem, class _OutIt = ostreambuf_iterator<_Elem, char_traits<_Elem>>>
 class num_put : public locale::facet { // facet for converting encoded numbers to text
 public:
     static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
diff --git a/stl/inc/xloctime b/stl/inc/xloctime
index 5db025a480..67d749bc80 100644
--- a/stl/inc/xloctime
+++ b/stl/inc/xloctime
@@ -86,7 +86,7 @@ ios_base::iostate _Getint_v2(_InIt& _First, _InIt& _Last, int _Lo, int _Hi, int&
     return _State;
 }
 
-struct _CRTIMP2_PURE_IMPORT time_base : locale::facet { // base class for time_get
+_EXPORT_STD extern "C++" struct _CRTIMP2_PURE_IMPORT time_base : locale::facet { // base class for time_get
     enum dateorder { // constants for different orders of date components
         no_order,
         dmy,
@@ -100,7 +100,7 @@ struct _CRTIMP2_PURE_IMPORT time_base : locale::facet { // base class for time_g
     __CLR_OR_THIS_CALL ~time_base() noexcept override {}
 };
 
-template <class _Elem, class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem>>>
+_EXPORT_STD extern "C++" template <class _Elem, class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem>>>
 class time_get : public time_base { // facet for converting text to encoded times
 private:
     friend _Tidy_guard<time_get>;
@@ -633,7 +633,7 @@ __PURE_APPDOMAIN_GLOBAL locale::id time_get<_Elem, _InIt>::id;
 #pragma clang diagnostic pop
 #endif // __clang__
 
-template <class _Elem, class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem>>>
+_EXPORT_STD template <class _Elem, class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem>>>
 class time_get_byname : public time_get<_Elem, _InIt> { // time_get for named locale
 public:
     static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
@@ -648,7 +648,7 @@ protected:
     __CLR_OR_THIS_CALL ~time_get_byname() noexcept override {}
 };
 
-template <class _Elem, class _OutIt = ostreambuf_iterator<_Elem, char_traits<_Elem>>>
+_EXPORT_STD extern "C++" template <class _Elem, class _OutIt = ostreambuf_iterator<_Elem, char_traits<_Elem>>>
 class time_put : public locale::facet { // facet for converting encoded times to text
 public:
     static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
@@ -1036,7 +1036,7 @@ __PURE_APPDOMAIN_GLOBAL locale::id time_put<unsigned short, _OutIt>::id;
 #endif // __clang__
 #endif // defined(_CRTBLD)
 
-template <class _Elem, class _OutIt = ostreambuf_iterator<_Elem, char_traits<_Elem>>>
+_EXPORT_STD template <class _Elem, class _OutIt = ostreambuf_iterator<_Elem, char_traits<_Elem>>>
 class time_put_byname : public time_put<_Elem, _OutIt> { // time_put for named locale
 public:
     static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
diff --git a/stl/inc/xmemory b/stl/inc/xmemory
index a6c66b34fc..cdd4d07c3c 100644
--- a/stl/inc/xmemory
+++ b/stl/inc/xmemory
@@ -300,7 +300,7 @@ _CONSTEXPR20 void _Destroy_in_place(_Ty& _Obj) noexcept {
 }
 
 #if _HAS_CXX17
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _CONSTEXPR20 void destroy_at(_Ty* const _Location) noexcept /* strengthened */ {
 #if _HAS_CXX20
     if constexpr (is_array_v<_Ty>) {
@@ -450,7 +450,7 @@ struct _Get_rebind_type<_Ty, _Other, void_t<typename _Ty::template rebind<_Other
 };
 _STL_RESTORE_DEPRECATED_WARNING
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class allocator;
 
 template <class _Alloc, class = void>
@@ -514,7 +514,7 @@ template <class _Alloc>
 struct _Has_select_on_container_copy_construction<_Alloc,
     void_t<decltype(_STD declval<const _Alloc&>().select_on_container_copy_construction())>> : true_type {};
 
-template <class _Alloc>
+_EXPORT_STD template <class _Alloc>
 struct allocator_traits;
 
 _STL_DISABLE_DEPRECATED_WARNING
@@ -699,7 +699,7 @@ struct _Default_allocator_traits { // traits for std::allocator
     }
 };
 
-template <class _Alloc>
+_EXPORT_STD template <class _Alloc>
 struct allocator_traits : conditional_t<_Is_default_allocator<_Alloc>::value, _Default_allocator_traits<_Alloc>,
                               _Normal_allocator_traits<_Alloc>> {};
 
@@ -750,7 +750,7 @@ struct _Simple_types { // wraps types from allocators with simple addressing for
 };
 
 #if _HAS_CXX23
-template <class _Ptr>
+_EXPORT_STD template <class _Ptr>
 struct allocation_result {
     _Ptr ptr;
     size_t count;
@@ -762,7 +762,7 @@ concept _Has_member_allocate_at_least = requires(_Alloc _Al, size_t _Count) {
     _Al.allocate_at_least(_Count);
 };
 
-template <class _Alloc>
+_EXPORT_STD template <class _Alloc>
 _NODISCARD constexpr allocation_result<typename allocator_traits<_Alloc>::pointer> allocate_at_least(
     _Alloc& _Al, const size_t _Count) {
     if constexpr (_Has_member_allocate_at_least<_Alloc>) {
@@ -777,7 +777,7 @@ _NODISCARD constexpr allocation_result<typename allocator_traits<_Alloc>::pointe
 // The number of user bytes a single byte of ASAN shadow memory can track.
 _INLINE_VAR constexpr size_t _Asan_granularity = 8;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 class allocator {
 public:
     static_assert(!is_const_v<_Ty>, "The C++ Standard forbids containers of const elements "
@@ -891,7 +891,7 @@ public:
 };
 #endif // _HAS_DEPRECATED_ALLOCATOR_VOID || _HAS_DEPRECATED_ALLOCATOR_MEMBERS
 
-template <class _Ty, class _Other>
+_EXPORT_STD template <class _Ty, class _Other>
 _NODISCARD _CONSTEXPR20 bool operator==(const allocator<_Ty>&, const allocator<_Other>&) noexcept {
     return true;
 }
@@ -1604,7 +1604,7 @@ namespace ranges {
         return {_STD move(_IFirst), _STD move(_OFirst)};
     }
 
-    template <class _In, class _Out>
+    _EXPORT_STD template <class _In, class _Out>
     using uninitialized_move_result = in_out_result<_In, _Out>;
 
     // clang-format off
@@ -1772,7 +1772,7 @@ _CONSTEXPR20 _NoThrowFwdIt _Uninitialized_copy_unchecked(_InIt _First, const _In
     return _Backout._Release();
 }
 
-template <class _InIt, class _NoThrowFwdIt>
+_EXPORT_STD template <class _InIt, class _NoThrowFwdIt>
 _NoThrowFwdIt uninitialized_copy(const _InIt _First, const _InIt _Last, _NoThrowFwdIt _Dest) {
     // copy [_First, _Last) to raw [_Dest, ...)
     _Adl_verify_range(_First, _Last);
@@ -1843,7 +1843,7 @@ _CONSTEXPR20 _Alloc_ptr_t<_Alloc> _Uninitialized_fill_n(
     return _Backout._Release();
 }
 
-template <class _NoThrowFwdIt, class _Tval>
+_EXPORT_STD template <class _NoThrowFwdIt, class _Tval>
 void uninitialized_fill(const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last, const _Tval& _Val) {
     // copy _Val throughout raw [_First, _Last)
     _Adl_verify_range(_First, _Last);
@@ -1923,12 +1923,12 @@ _NoThrowFwdIt _Uninitialized_value_construct_n_unchecked1(_NoThrowFwdIt _UFirst,
 }
 
 #if _HAS_DEPRECATED_TEMPORARY_BUFFER
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _CXX17_DEPRECATE_TEMPORARY_BUFFER _NODISCARD pair<_Ty*, ptrdiff_t> get_temporary_buffer(ptrdiff_t _Count) noexcept {
     return _Get_temporary_buffer<_Ty>(_Count);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _CXX17_DEPRECATE_TEMPORARY_BUFFER void return_temporary_buffer(_Ty* _Pbuf) {
     _Return_temporary_buffer(_Pbuf);
 }
@@ -2040,7 +2040,7 @@ _NODISCARD constexpr bool _Allocators_equal(const _Alloc& _Lhs, const _Alloc& _R
     }
 }
 
-template <class _FwdIt, class _Ty>
+_EXPORT_STD template <class _FwdIt, class _Ty>
 _NODISCARD_REMOVE_ALG _CONSTEXPR20 _FwdIt remove(_FwdIt _First, const _FwdIt _Last, const _Ty& _Val) {
     // remove each matching _Val
     _Adl_verify_range(_First, _Last);
@@ -2061,7 +2061,7 @@ _NODISCARD_REMOVE_ALG _CONSTEXPR20 _FwdIt remove(_FwdIt _First, const _FwdIt _La
     return _First;
 }
 
-template <class _FwdIt, class _Pr>
+_EXPORT_STD template <class _FwdIt, class _Pr>
 _NODISCARD_REMOVE_ALG _CONSTEXPR20 _FwdIt remove_if(_FwdIt _First, const _FwdIt _Last, _Pr _Pred) {
     // remove each satisfying _Pred
     _Adl_verify_range(_First, _Last);
@@ -2145,7 +2145,7 @@ template <class _Ty, class _Uty>
 _INLINE_VAR constexpr bool _Is_normally_bindable<_Ty, _Uty, void_t<_Normally_bound_ref<_Ty, _Uty>>> = true;
 
 #if _HAS_CXX20
-template <class _Ty, class _Alloc, class... _Types, enable_if_t<!_Is_specialization_v<_Ty, pair>, int> = 0>
+_EXPORT_STD template <class _Ty, class _Alloc, class... _Types, enable_if_t<!_Is_specialization_v<_Ty, pair>, int> = 0>
 _NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, _Types&&... _Args) noexcept {
     if constexpr (!uses_allocator_v<_Ty, _Alloc>) {
         static_assert(is_constructible_v<_Ty, _Types...>,
@@ -2164,34 +2164,40 @@ _NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, _T
     }
 }
 
-template <class _Ty, class _Alloc, enable_if_t<_Is_specialization_v<_Ty, pair>, int> = 0>
+_EXPORT_STD template <class _Ty, class _Alloc, enable_if_t<_Is_specialization_v<_Ty, pair>, int> = 0>
 _NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al) noexcept;
 
-template <class _Ty, class _Alloc, class _Uty1, class _Uty2, enable_if_t<_Is_specialization_v<_Ty, pair>, int> = 0>
+_EXPORT_STD template <class _Ty, class _Alloc, class _Uty1, class _Uty2,
+    enable_if_t<_Is_specialization_v<_Ty, pair>, int> = 0>
 _NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, _Uty1&& _Val1, _Uty2&& _Val2) noexcept;
 
 #if _HAS_CXX23
-template <class _Ty, class _Alloc, class _Uty1, class _Uty2, enable_if_t<_Is_specialization_v<_Ty, pair>, int> = 0>
+_EXPORT_STD template <class _Ty, class _Alloc, class _Uty1, class _Uty2,
+    enable_if_t<_Is_specialization_v<_Ty, pair>, int> = 0>
 _NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, pair<_Uty1, _Uty2>& _Pair) noexcept;
 #endif // _HAS_CXX23
 
-template <class _Ty, class _Alloc, class _Uty1, class _Uty2, enable_if_t<_Is_specialization_v<_Ty, pair>, int> = 0>
+_EXPORT_STD template <class _Ty, class _Alloc, class _Uty1, class _Uty2,
+    enable_if_t<_Is_specialization_v<_Ty, pair>, int> = 0>
 _NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, const pair<_Uty1, _Uty2>& _Pair) noexcept;
 
-template <class _Ty, class _Alloc, class _Uty1, class _Uty2, enable_if_t<_Is_specialization_v<_Ty, pair>, int> = 0>
+_EXPORT_STD template <class _Ty, class _Alloc, class _Uty1, class _Uty2,
+    enable_if_t<_Is_specialization_v<_Ty, pair>, int> = 0>
 _NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, pair<_Uty1, _Uty2>&& _Pair) noexcept;
 
 #if _HAS_CXX23
-template <class _Ty, class _Alloc, class _Uty1, class _Uty2, enable_if_t<_Is_specialization_v<_Ty, pair>, int> = 0>
+_EXPORT_STD template <class _Ty, class _Alloc, class _Uty1, class _Uty2,
+    enable_if_t<_Is_specialization_v<_Ty, pair>, int> = 0>
 _NODISCARD constexpr auto uses_allocator_construction_args(
     const _Alloc& _Al, const pair<_Uty1, _Uty2>&& _Pair) noexcept;
 #endif // _HAS_CXX23
 
-template <class _Ty, class _Alloc, class _Uty,
+_EXPORT_STD template <class _Ty, class _Alloc, class _Uty,
     enable_if_t<_Is_specialization_v<_Ty, pair> && !_Is_deducible_as_pair<_Uty&>, int> = 0>
 _NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, _Uty&& _Ux) noexcept;
 
-template <class _Ty, class _Alloc, class _Tuple1, class _Tuple2, enable_if_t<_Is_specialization_v<_Ty, pair>, int> = 0>
+_EXPORT_STD template <class _Ty, class _Alloc, class _Tuple1, class _Tuple2,
+    enable_if_t<_Is_specialization_v<_Ty, pair>, int> = 0>
 _NODISCARD constexpr auto uses_allocator_construction_args(
     const _Alloc& _Al, piecewise_construct_t, _Tuple1&& _Tup1, _Tuple2&& _Tup2) noexcept {
     return _STD make_tuple(piecewise_construct,
@@ -2209,7 +2215,7 @@ _NODISCARD constexpr auto uses_allocator_construction_args(
             _STD forward<_Tuple2>(_Tup2)));
 }
 
-template <class _Ty, class _Alloc, enable_if_t<_Is_specialization_v<_Ty, pair>, int>>
+_EXPORT_STD template <class _Ty, class _Alloc, enable_if_t<_Is_specialization_v<_Ty, pair>, int>>
 _NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al) noexcept {
     // equivalent to
     // return _STD uses_allocator_construction_args<_Ty>(_Al, piecewise_construct, tuple<>{}, tuple<>{});
@@ -2217,7 +2223,8 @@ _NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al) no
         _STD uses_allocator_construction_args<typename _Ty::second_type>(_Al));
 }
 
-template <class _Ty, class _Alloc, class _Uty1, class _Uty2, enable_if_t<_Is_specialization_v<_Ty, pair>, int>>
+_EXPORT_STD template <class _Ty, class _Alloc, class _Uty1, class _Uty2,
+    enable_if_t<_Is_specialization_v<_Ty, pair>, int>>
 _NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, _Uty1&& _Val1, _Uty2&& _Val2) noexcept {
     // equivalent to
     // return _STD uses_allocator_construction_args<_Ty>(_Al, piecewise_construct,
@@ -2228,7 +2235,8 @@ _NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, _U
 }
 
 #if _HAS_CXX23
-template <class _Ty, class _Alloc, class _Uty1, class _Uty2, enable_if_t<_Is_specialization_v<_Ty, pair>, int>>
+_EXPORT_STD template <class _Ty, class _Alloc, class _Uty1, class _Uty2,
+    enable_if_t<_Is_specialization_v<_Ty, pair>, int>>
 _NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, pair<_Uty1, _Uty2>& _Pair) noexcept {
     // equivalent to
     // return _STD uses_allocator_construction_args<_Ty>(_Al, piecewise_construct,
@@ -2239,7 +2247,8 @@ _NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, pa
 }
 #endif // _HAS_CXX23
 
-template <class _Ty, class _Alloc, class _Uty1, class _Uty2, enable_if_t<_Is_specialization_v<_Ty, pair>, int>>
+_EXPORT_STD template <class _Ty, class _Alloc, class _Uty1, class _Uty2,
+    enable_if_t<_Is_specialization_v<_Ty, pair>, int>>
 _NODISCARD constexpr auto uses_allocator_construction_args(
     const _Alloc& _Al, const pair<_Uty1, _Uty2>& _Pair) noexcept {
     // equivalent to
@@ -2250,7 +2259,8 @@ _NODISCARD constexpr auto uses_allocator_construction_args(
         _STD uses_allocator_construction_args<typename _Ty::second_type>(_Al, _Pair.second));
 }
 
-template <class _Ty, class _Alloc, class _Uty1, class _Uty2, enable_if_t<_Is_specialization_v<_Ty, pair>, int>>
+_EXPORT_STD template <class _Ty, class _Alloc, class _Uty1, class _Uty2,
+    enable_if_t<_Is_specialization_v<_Ty, pair>, int>>
 _NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, pair<_Uty1, _Uty2>&& _Pair) noexcept {
     // equivalent to
     // return _STD uses_allocator_construction_args<_Ty>(_Al, piecewise_construct,
@@ -2261,7 +2271,8 @@ _NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, pa
 }
 
 #if _HAS_CXX23
-template <class _Ty, class _Alloc, class _Uty1, class _Uty2, enable_if_t<_Is_specialization_v<_Ty, pair>, int>>
+_EXPORT_STD template <class _Ty, class _Alloc, class _Uty1, class _Uty2,
+    enable_if_t<_Is_specialization_v<_Ty, pair>, int>>
 _NODISCARD constexpr auto uses_allocator_construction_args(
     const _Alloc& _Al, const pair<_Uty1, _Uty2>&& _Pair) noexcept {
     // equivalent to
@@ -2273,7 +2284,7 @@ _NODISCARD constexpr auto uses_allocator_construction_args(
 }
 #endif // _HAS_CXX23
 
-template <class _Ty, class _Alloc, class _Uty,
+_EXPORT_STD template <class _Ty, class _Alloc, class _Uty,
     enable_if_t<_Is_specialization_v<_Ty, pair> && !_Is_deducible_as_pair<_Uty&>, int>>
 _NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, _Uty&& _Ux) noexcept {
     struct _Pair_remaker {
@@ -2310,12 +2321,12 @@ _NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, _U
     return tuple<_Pair_remaker>({_Al, _Ux});
 }
 
-template <class _Ty, class _Alloc, class... _Types>
+_EXPORT_STD template <class _Ty, class _Alloc, class... _Types>
 _NODISCARD constexpr _Ty make_obj_using_allocator(const _Alloc& _Al, _Types&&... _Args) {
     return _STD make_from_tuple<_Ty>(_STD uses_allocator_construction_args<_Ty>(_Al, _STD forward<_Types>(_Args)...));
 }
 
-template <class _Ty, class _Alloc, class... _Types>
+_EXPORT_STD template <class _Ty, class _Alloc, class... _Types>
 constexpr _Ty* uninitialized_construct_using_allocator(_Ty* _Ptr, const _Alloc& _Al, _Types&&... _Args) {
     return _STD apply(
         [&](auto&&... _Construct_args) {
@@ -2326,10 +2337,8 @@ constexpr _Ty* uninitialized_construct_using_allocator(_Ty* _Ptr, const _Alloc&
 #endif // _HAS_CXX20
 
 #if _HAS_CXX23 && defined(__cpp_lib_concepts) // TRANSITION, GH-395
-struct from_range_t {
-    explicit from_range_t() = default;
-};
-inline constexpr from_range_t from_range;
+_EXPORT_STD struct from_range_t { explicit from_range_t() = default; };
+_EXPORT_STD inline constexpr from_range_t from_range;
 
 template <class _Rng, class _Elem>
 concept _Container_compatible_range =
@@ -2385,7 +2394,7 @@ protected:
     }
 };
 
-inline void* align(size_t _Bound, size_t _Size, void*& _Ptr, size_t& _Space) noexcept /* strengthened */ {
+_EXPORT_STD inline void* align(size_t _Bound, size_t _Size, void*& _Ptr, size_t& _Space) noexcept /* strengthened */ {
     // try to carve out _Size bytes on boundary _Bound
     size_t _Off = static_cast<size_t>(reinterpret_cast<uintptr_t>(_Ptr) & (_Bound - 1));
     if (_Off != 0) {
diff --git a/stl/inc/xpolymorphic_allocator.h b/stl/inc/xpolymorphic_allocator.h
index 278843e3ba..544b990020 100644
--- a/stl/inc/xpolymorphic_allocator.h
+++ b/stl/inc/xpolymorphic_allocator.h
@@ -126,7 +126,7 @@ void _Uses_allocator_construct(pair<_Ty1, _Ty2>* const _Ptr, _Outer_alloc& _Oute
 
 #if _HAS_CXX17
 namespace pmr {
-    class __declspec(novtable) memory_resource {
+    _EXPORT_STD class __declspec(novtable) memory_resource {
     public:
         virtual ~memory_resource() noexcept = default;
 
@@ -154,7 +154,8 @@ namespace pmr {
         virtual bool do_is_equal(const memory_resource& _That) const noexcept = 0;
     };
 
-    _NODISCARD inline bool operator==(const memory_resource& _Left, const memory_resource& _Right) noexcept {
+    _EXPORT_STD _NODISCARD inline bool operator==(
+        const memory_resource& _Left, const memory_resource& _Right) noexcept {
         return &_Left == &_Right || _Left.is_equal(_Right);
     }
 
@@ -167,7 +168,7 @@ namespace pmr {
     extern "C" _CRT_SATELLITE_1 memory_resource* __cdecl _Aligned_get_default_resource() noexcept;
     extern "C" _CRT_SATELLITE_1 memory_resource* __cdecl _Unaligned_get_default_resource() noexcept;
 
-    _NODISCARD inline memory_resource* get_default_resource() noexcept {
+    _EXPORT_STD _NODISCARD inline memory_resource* get_default_resource() noexcept {
 #ifdef __cpp_aligned_new
         return _Aligned_get_default_resource();
 #else // ^^^ __cpp_aligned_new / !__cpp_aligned_new vvv
@@ -176,9 +177,9 @@ namespace pmr {
     }
 
 #if _HAS_CXX20 && defined(__cpp_lib_byte)
-    template <class _Ty = byte>
+    _EXPORT_STD template <class _Ty = byte>
 #else
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
 #endif // _HAS_CXX20 && defined(__cpp_lib_byte)
     class polymorphic_allocator {
     public:
@@ -299,7 +300,7 @@ namespace pmr {
         memory_resource* _Resource = _STD pmr::get_default_resource();
     };
 
-    template <class _Ty1, class _Ty2>
+    _EXPORT_STD template <class _Ty1, class _Ty2>
     _NODISCARD bool operator==(
         const polymorphic_allocator<_Ty1>& _Left, const polymorphic_allocator<_Ty2>& _Right) noexcept {
         // polymorphic_allocators with the same resource are compatible
diff --git a/stl/inc/xstddef b/stl/inc/xstddef
index 8ffa7e78e1..12ef3fb712 100644
--- a/stl/inc/xstddef
+++ b/stl/inc/xstddef
@@ -27,13 +27,13 @@ _INLINE_VAR constexpr bool _Always_false = false;
 
 // stuff from <functional>
 #if _HAS_AUTO_PTR_ETC
-template <class _Arg, class _Result>
+_EXPORT_STD template <class _Arg, class _Result>
 struct unary_function { // base class for unary functions
     using argument_type = _Arg;
     using result_type   = _Result;
 };
 
-template <class _Arg1, class _Arg2, class _Result>
+_EXPORT_STD template <class _Arg1, class _Arg2, class _Result>
 struct binary_function { // base class for binary functions
     using first_argument_type  = _Arg1;
     using second_argument_type = _Arg2;
@@ -63,7 +63,7 @@ _NODISCARD _Ty _Fake_copy_init(_Ty) noexcept;
 
 #pragma warning(pop)
 
-template <class _Ty = void>
+_EXPORT_STD template <class _Ty = void>
 struct plus {
     using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
     using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
@@ -74,7 +74,7 @@ struct plus {
     }
 };
 
-template <class _Ty = void>
+_EXPORT_STD template <class _Ty = void>
 struct minus {
     using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
     using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
@@ -85,7 +85,7 @@ struct minus {
     }
 };
 
-template <class _Ty = void>
+_EXPORT_STD template <class _Ty = void>
 struct multiplies {
     using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
     using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
@@ -96,7 +96,7 @@ struct multiplies {
     }
 };
 
-template <class _Ty = void>
+_EXPORT_STD template <class _Ty = void>
 struct equal_to {
     using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
     using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
@@ -108,7 +108,7 @@ struct equal_to {
     }
 };
 
-template <class _Ty = void>
+_EXPORT_STD template <class _Ty = void>
 struct not_equal_to {
     using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
     using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
@@ -120,7 +120,7 @@ struct not_equal_to {
     }
 };
 
-template <class _Ty = void>
+_EXPORT_STD template <class _Ty = void>
 struct greater {
     using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
     using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
@@ -132,7 +132,7 @@ struct greater {
     }
 };
 
-template <class _Ty = void>
+_EXPORT_STD template <class _Ty = void>
 struct less {
     using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
     using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
@@ -144,7 +144,7 @@ struct less {
     }
 };
 
-template <class _Ty = void>
+_EXPORT_STD template <class _Ty = void>
 struct greater_equal {
     using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
     using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
@@ -156,7 +156,7 @@ struct greater_equal {
     }
 };
 
-template <class _Ty = void>
+_EXPORT_STD template <class _Ty = void>
 struct less_equal {
     using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
     using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
@@ -276,12 +276,12 @@ struct less_equal<void> {
     using is_transparent = int;
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD constexpr _Ty* addressof(_Ty& _Val) noexcept {
     return __builtin_addressof(_Val);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 const _Ty* addressof(const _Ty&&) = delete;
 
 template <class _Ptrty>
diff --git a/stl/inc/xstring b/stl/inc/xstring
index 1978c34cd2..cf58040574 100644
--- a/stl/inc/xstring
+++ b/stl/inc/xstring
@@ -329,7 +329,7 @@ public:
     }
 };
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 struct char_traits : _Char_traits<_Elem, long> {}; // properties of a string or stream unknown element
 
 template <>
@@ -942,7 +942,7 @@ _INLINE_VAR constexpr bool _Is_EcharT = _Is_any_of_v<_Ty, char, wchar_t,
     char16_t, char32_t>;
 
 #if _HAS_CXX17
-template <class _Elem, class _Traits = char_traits<_Elem>>
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>>
 class basic_string_view;
 
 template <class _Traits>
@@ -1213,7 +1213,7 @@ struct pointer_traits<_String_view_iterator<_Traits>> {
 // type
 #pragma warning(disable : 6510)
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 class basic_string_view { // wrapper for any kind of contiguous character buffer
 public:
     static_assert(is_same_v<_Elem, typename _Traits::char_type>,
@@ -1696,7 +1696,7 @@ namespace ranges {
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 _NODISCARD constexpr bool operator==(
     const basic_string_view<_Elem, _Traits> _Lhs, const basic_string_view<_Elem, _Traits> _Rhs) noexcept {
     return _Lhs._Equal(_Rhs);
@@ -1710,7 +1710,7 @@ _NODISCARD constexpr bool operator==(
 }
 #endif // !_HAS_CXX20
 
-template <class _Elem, class _Traits, int = 2> // TRANSITION, VSO-409326
+_EXPORT_STD template <class _Elem, class _Traits, int = 2> // TRANSITION, VSO-409326
 _NODISCARD constexpr bool operator==(
     const basic_string_view<_Elem, _Traits> _Lhs, const _Identity_t<basic_string_view<_Elem, _Traits>> _Rhs) noexcept {
     return _Lhs._Equal(_Rhs);
@@ -1829,26 +1829,26 @@ struct _Get_comparison_category<_Traits, void_t<typename _Traits::comparison_cat
 template <class _Traits>
 using _Get_comparison_category_t = typename _Get_comparison_category<_Traits>::type;
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 _NODISCARD constexpr _Get_comparison_category_t<_Traits> operator<=>(
     const basic_string_view<_Elem, _Traits> _Lhs, const basic_string_view<_Elem, _Traits> _Rhs) noexcept {
     return static_cast<_Get_comparison_category_t<_Traits>>(_Lhs.compare(_Rhs) <=> 0);
 }
 
-template <class _Elem, class _Traits, int = 2> // TRANSITION, VSO-409326
+_EXPORT_STD template <class _Elem, class _Traits, int = 2> // TRANSITION, VSO-409326
 _NODISCARD constexpr _Get_comparison_category_t<_Traits> operator<=>(
     const basic_string_view<_Elem, _Traits> _Lhs, const _Identity_t<basic_string_view<_Elem, _Traits>> _Rhs) noexcept {
     return static_cast<_Get_comparison_category_t<_Traits>>(_Lhs.compare(_Rhs) <=> 0);
 }
 #endif // _HAS_CXX20
 
-using string_view = basic_string_view<char>;
+_EXPORT_STD using string_view = basic_string_view<char>;
 #ifdef __cpp_lib_char8_t
-using u8string_view = basic_string_view<char8_t>;
+_EXPORT_STD using u8string_view = basic_string_view<char8_t>;
 #endif // __cpp_lib_char8_t
-using u16string_view = basic_string_view<char16_t>;
-using u32string_view = basic_string_view<char32_t>;
-using wstring_view   = basic_string_view<wchar_t>;
+_EXPORT_STD using u16string_view = basic_string_view<char16_t>;
+_EXPORT_STD using u32string_view = basic_string_view<char32_t>;
+_EXPORT_STD using wstring_view   = basic_string_view<wchar_t>;
 
 
 template <class _Elem>
@@ -1858,7 +1858,7 @@ struct hash<basic_string_view<_Elem>> : _Conditionally_enabled_hash<basic_string
     }
 };
 
-template <class _Elem, class _Traits>
+_EXPORT_STD template <class _Elem, class _Traits>
 basic_ostream<_Elem, _Traits>& operator<<(
     basic_ostream<_Elem, _Traits>& _Ostr, const basic_string_view<_Elem, _Traits> _Str) {
     return _Insert_string(_Ostr, _Str.data(), _Str.size());
@@ -1867,25 +1867,26 @@ basic_ostream<_Elem, _Traits>& operator<<(
 
 inline namespace literals {
     inline namespace string_view_literals {
-        _NODISCARD constexpr string_view operator"" sv(const char* _Str, size_t _Len) noexcept {
+        _EXPORT_STD _NODISCARD constexpr string_view operator"" sv(const char* _Str, size_t _Len) noexcept {
             return string_view(_Str, _Len);
         }
 
-        _NODISCARD constexpr wstring_view operator"" sv(const wchar_t* _Str, size_t _Len) noexcept {
+        _EXPORT_STD _NODISCARD constexpr wstring_view operator"" sv(const wchar_t* _Str, size_t _Len) noexcept {
             return wstring_view(_Str, _Len);
         }
 
 #ifdef __cpp_char8_t
-        _NODISCARD constexpr basic_string_view<char8_t> operator"" sv(const char8_t* _Str, size_t _Len) noexcept {
+        _EXPORT_STD _NODISCARD constexpr basic_string_view<char8_t> operator"" sv(
+            const char8_t* _Str, size_t _Len) noexcept {
             return basic_string_view<char8_t>(_Str, _Len);
         }
 #endif // __cpp_char8_t
 
-        _NODISCARD constexpr u16string_view operator"" sv(const char16_t* _Str, size_t _Len) noexcept {
+        _EXPORT_STD _NODISCARD constexpr u16string_view operator"" sv(const char16_t* _Str, size_t _Len) noexcept {
             return u16string_view(_Str, _Len);
         }
 
-        _NODISCARD constexpr u32string_view operator"" sv(const char32_t* _Str, size_t _Len) noexcept {
+        _EXPORT_STD _NODISCARD constexpr u32string_view operator"" sv(const char32_t* _Str, size_t _Len) noexcept {
             return u32string_view(_Str, _Len);
         }
     } // namespace string_view_literals
@@ -2440,7 +2441,7 @@ concept _Contiguous_range_of =
     _RANGES contiguous_range<_Rng> && same_as<remove_cvref_t<_RANGES range_reference_t<_Rng>>, _Ty>;
 #endif // _HAS_CXX23 && defined(__cpp_lib_concepts)
 
-template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
 class basic_string { // null-terminated transparent array of elements
 private:
     friend _Tidy_deallocate_guard<basic_string>;
@@ -5066,13 +5067,13 @@ basic_string(from_range_t, _Rng&&, _Alloc = _Alloc())
 #endif // _HAS_CXX23 && defined(__cpp_lib_concepts)
 #endif // _HAS_CXX17
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 _CONSTEXPR20 void swap(basic_string<_Elem, _Traits, _Alloc>& _Left,
     basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept /* strengthened */ {
     _Left.swap(_Right);
 }
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 _NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
     const basic_string<_Elem, _Traits, _Alloc>& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) {
     const auto _Left_size  = _Left.size();
@@ -5084,7 +5085,7 @@ _NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
     return {_String_constructor_concat_tag{}, _Left, _Left.c_str(), _Left_size, _Right.c_str(), _Right_size};
 }
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 _NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
     _In_z_ const _Elem* const _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) {
     using _Size_type       = typename basic_string<_Elem, _Traits, _Alloc>::size_type;
@@ -5097,7 +5098,7 @@ _NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
     return {_String_constructor_concat_tag{}, _Right, _Left, _Left_size, _Right.c_str(), _Right_size};
 }
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 _NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
     const _Elem _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) {
     const auto _Right_size = _Right.size();
@@ -5108,7 +5109,7 @@ _NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
     return {_String_constructor_concat_tag{}, _Right, _STD addressof(_Left), 1, _Right.c_str(), _Right_size};
 }
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 _NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
     const basic_string<_Elem, _Traits, _Alloc>& _Left, _In_z_ const _Elem* const _Right) {
     using _Size_type       = typename basic_string<_Elem, _Traits, _Alloc>::size_type;
@@ -5121,7 +5122,7 @@ _NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
     return {_String_constructor_concat_tag{}, _Left, _Left.c_str(), _Left_size, _Right, _Right_size};
 }
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 _NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
     const basic_string<_Elem, _Traits, _Alloc>& _Left, const _Elem _Right) {
     const auto _Left_size = _Left.size();
@@ -5132,19 +5133,19 @@ _NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
     return {_String_constructor_concat_tag{}, _Left, _Left.c_str(), _Left_size, _STD addressof(_Right), 1};
 }
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 _NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
     const basic_string<_Elem, _Traits, _Alloc>& _Left, basic_string<_Elem, _Traits, _Alloc>&& _Right) {
     return _STD move(_Right.insert(0, _Left));
 }
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 _NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
     basic_string<_Elem, _Traits, _Alloc>&& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) {
     return _STD move(_Left.append(_Right));
 }
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 _NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
     basic_string<_Elem, _Traits, _Alloc>&& _Left, basic_string<_Elem, _Traits, _Alloc>&& _Right) {
 #if _ITERATOR_DEBUG_LEVEL == 2
@@ -5157,51 +5158,51 @@ _NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
     return {_String_constructor_concat_tag{}, _Left, _Right};
 }
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 _NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
     _In_z_ const _Elem* const _Left, basic_string<_Elem, _Traits, _Alloc>&& _Right) {
     return _STD move(_Right.insert(0, _Left));
 }
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 _NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
     const _Elem _Left, basic_string<_Elem, _Traits, _Alloc>&& _Right) {
     return _STD move(_Right.insert(0, 1, _Left));
 }
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 _NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
     basic_string<_Elem, _Traits, _Alloc>&& _Left, _In_z_ const _Elem* const _Right) {
     return _STD move(_Left.append(_Right));
 }
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 _NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
     basic_string<_Elem, _Traits, _Alloc>&& _Left, const _Elem _Right) {
     _Left.push_back(_Right);
     return _STD move(_Left);
 }
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 _NODISCARD _CONSTEXPR20 bool operator==(
     const basic_string<_Elem, _Traits, _Alloc>& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept {
     return _Left._Equal(_Right);
 }
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 _NODISCARD _CONSTEXPR20 bool operator==(
     const basic_string<_Elem, _Traits, _Alloc>& _Left, _In_z_ const _Elem* const _Right) {
     return _Left._Equal(_Right);
 }
 
 #if _HAS_CXX20
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 _NODISCARD constexpr _Get_comparison_category_t<_Traits> operator<=>(
     const basic_string<_Elem, _Traits, _Alloc>& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept {
     return static_cast<_Get_comparison_category_t<_Traits>>(_Left.compare(_Right) <=> 0);
 }
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 _NODISCARD constexpr _Get_comparison_category_t<_Traits> operator<=>(
     const basic_string<_Elem, _Traits, _Alloc>& _Left, _In_z_ const _Elem* const _Right) {
     return static_cast<_Get_comparison_category_t<_Traits>>(_Left.compare(_Right) <=> 0);
@@ -5293,13 +5294,13 @@ _NODISCARD bool operator>=(const basic_string<_Elem, _Traits, _Alloc>& _Left, _I
 }
 #endif // ^^^ !_HAS_CXX20 ^^^
 
-using string  = basic_string<char, char_traits<char>, allocator<char>>;
-using wstring = basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t>>;
+_EXPORT_STD using string  = basic_string<char, char_traits<char>, allocator<char>>;
+_EXPORT_STD using wstring = basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t>>;
 #ifdef __cpp_lib_char8_t
-using u8string = basic_string<char8_t, char_traits<char8_t>, allocator<char8_t>>;
+_EXPORT_STD using u8string = basic_string<char8_t, char_traits<char8_t>, allocator<char8_t>>;
 #endif // __cpp_lib_char8_t
-using u16string = basic_string<char16_t, char_traits<char16_t>, allocator<char16_t>>;
-using u32string = basic_string<char32_t, char_traits<char32_t>, allocator<char32_t>>;
+_EXPORT_STD using u16string = basic_string<char16_t, char_traits<char16_t>, allocator<char16_t>>;
+_EXPORT_STD using u32string = basic_string<char32_t, char_traits<char32_t>, allocator<char32_t>>;
 
 template <class _Elem, class _Alloc>
 struct hash<basic_string<_Elem, char_traits<_Elem>, _Alloc>>
@@ -5309,7 +5310,7 @@ struct hash<basic_string<_Elem, char_traits<_Elem>, _Alloc>>
     }
 };
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 basic_istream<_Elem, _Traits>& operator>>(
     basic_istream<_Elem, _Traits>& _Istr, basic_string<_Elem, _Traits, _Alloc>& _Str) {
     using _Myis   = basic_istream<_Elem, _Traits>;
@@ -5358,7 +5359,7 @@ basic_istream<_Elem, _Traits>& operator>>(
     return _Istr;
 }
 
-template <class _Elem, class _Traits, class _Alloc>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
 basic_ostream<_Elem, _Traits>& operator<<(
     basic_ostream<_Elem, _Traits>& _Ostr, const basic_string<_Elem, _Traits, _Alloc>& _Str) {
     return _Insert_string(_Ostr, _Str.data(), _Str.size());
@@ -5373,25 +5374,26 @@ inline namespace literals {
 #define _CONSTEXPR20_STRING_LITERALS _CONSTEXPR20
 #endif // ^^^ no workaround ^^^
 
-        _NODISCARD _CONSTEXPR20_STRING_LITERALS string operator"" s(const char* _Str, size_t _Len) {
+        _EXPORT_STD _NODISCARD _CONSTEXPR20_STRING_LITERALS string operator"" s(const char* _Str, size_t _Len) {
             return string{_Str, _Len};
         }
 
-        _NODISCARD _CONSTEXPR20_STRING_LITERALS wstring operator"" s(const wchar_t* _Str, size_t _Len) {
+        _EXPORT_STD _NODISCARD _CONSTEXPR20_STRING_LITERALS wstring operator"" s(const wchar_t* _Str, size_t _Len) {
             return wstring{_Str, _Len};
         }
 
 #ifdef __cpp_char8_t
-        _NODISCARD _CONSTEXPR20_STRING_LITERALS basic_string<char8_t> operator"" s(const char8_t* _Str, size_t _Len) {
+        _EXPORT_STD _NODISCARD _CONSTEXPR20_STRING_LITERALS basic_string<char8_t> operator"" s(
+            const char8_t* _Str, size_t _Len) {
             return basic_string<char8_t>{_Str, _Len};
         }
 #endif // __cpp_char8_t
 
-        _NODISCARD _CONSTEXPR20_STRING_LITERALS u16string operator"" s(const char16_t* _Str, size_t _Len) {
+        _EXPORT_STD _NODISCARD _CONSTEXPR20_STRING_LITERALS u16string operator"" s(const char16_t* _Str, size_t _Len) {
             return u16string{_Str, _Len};
         }
 
-        _NODISCARD _CONSTEXPR20_STRING_LITERALS u32string operator"" s(const char32_t* _Str, size_t _Len) {
+        _EXPORT_STD _NODISCARD _CONSTEXPR20_STRING_LITERALS u32string operator"" s(const char32_t* _Str, size_t _Len) {
             return u32string{_Str, _Len};
         }
 
@@ -5401,13 +5403,13 @@ inline namespace literals {
 } // namespace literals
 
 #if _HAS_CXX20
-template <class _Elem, class _Traits, class _Alloc, class _Uty>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc, class _Uty>
 constexpr typename basic_string<_Elem, _Traits, _Alloc>::size_type erase(
     basic_string<_Elem, _Traits, _Alloc>& _Cont, const _Uty& _Val) {
     return _Erase_remove(_Cont, _Val);
 }
 
-template <class _Elem, class _Traits, class _Alloc, class _Pr>
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc, class _Pr>
 constexpr typename basic_string<_Elem, _Traits, _Alloc>::size_type erase_if(
     basic_string<_Elem, _Traits, _Alloc>& _Cont, _Pr _Pred) {
     return _Erase_remove_if(_Cont, _Pass_fn(_Pred));
@@ -5416,16 +5418,16 @@ constexpr typename basic_string<_Elem, _Traits, _Alloc>::size_type erase_if(
 
 #if _HAS_CXX17
 namespace pmr {
-    template <class _Elem, class _Traits = char_traits<_Elem>>
+    _EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>>
     using basic_string = _STD basic_string<_Elem, _Traits, polymorphic_allocator<_Elem>>;
 
-    using string = basic_string<char>;
+    _EXPORT_STD using string = basic_string<char>;
 #ifdef __cpp_lib_char8_t
-    using u8string = basic_string<char8_t>;
+    _EXPORT_STD using u8string = basic_string<char8_t>;
 #endif // __cpp_lib_char8_t
-    using u16string = basic_string<char16_t>;
-    using u32string = basic_string<char32_t>;
-    using wstring   = basic_string<wchar_t>;
+    _EXPORT_STD using u16string = basic_string<char16_t>;
+    _EXPORT_STD using u32string = basic_string<char32_t>;
+    _EXPORT_STD using wstring   = basic_string<wchar_t>;
 } // namespace pmr
 #endif // _HAS_CXX17
 _STD_END
diff --git a/stl/inc/xthreads.h b/stl/inc/xthreads.h
index a1b8ee2bfe..d7f9ba4639 100644
--- a/stl/inc/xthreads.h
+++ b/stl/inc/xthreads.h
@@ -123,8 +123,8 @@ enum { // constants for error codes
     _RESOURCE_UNAVAILABLE_TRY_AGAIN
 };
 
-[[noreturn]] _CRTIMP2_PURE void __cdecl _Throw_C_error(int _Code);
-[[noreturn]] _CRTIMP2_PURE void __cdecl _Throw_Cpp_error(int _Code);
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __cdecl _Throw_C_error(int _Code);
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __cdecl _Throw_Cpp_error(int _Code);
 
 inline int _Check_C_return(int _Res) { // throw exception on failure
     if (_Res != _Thrd_success) {
diff --git a/stl/inc/xtr1common b/stl/inc/xtr1common
index b92134c6c6..f646d9625d 100644
--- a/stl/inc/xtr1common
+++ b/stl/inc/xtr1common
@@ -17,7 +17,7 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-template <class _Ty, _Ty _Val>
+_EXPORT_STD template <class _Ty, _Ty _Val>
 struct integral_constant {
     static constexpr _Ty value = _Val;
 
@@ -33,13 +33,13 @@ struct integral_constant {
     }
 };
 
-template <bool _Val>
+_EXPORT_STD template <bool _Val>
 using bool_constant = integral_constant<bool, _Val>;
 
-using true_type  = bool_constant<true>;
-using false_type = bool_constant<false>;
+_EXPORT_STD using true_type  = bool_constant<true>;
+_EXPORT_STD using false_type = bool_constant<false>;
 
-template <bool _Test, class _Ty = void>
+_EXPORT_STD template <bool _Test, class _Ty = void>
 struct enable_if {}; // no member "type" when !_Test
 
 template <class _Ty>
@@ -47,10 +47,10 @@ struct enable_if<true, _Ty> { // type is _Ty for _Test
     using type = _Ty;
 };
 
-template <bool _Test, class _Ty = void>
+_EXPORT_STD template <bool _Test, class _Ty = void>
 using enable_if_t = typename enable_if<_Test, _Ty>::type;
 
-template <bool _Test, class _Ty1, class _Ty2>
+_EXPORT_STD template <bool _Test, class _Ty1, class _Ty2>
 struct conditional { // Choose _Ty1 if _Test is true, and _Ty2 otherwise
     using type = _Ty1;
 };
@@ -60,26 +60,26 @@ struct conditional<false, _Ty1, _Ty2> {
     using type = _Ty2;
 };
 
-template <bool _Test, class _Ty1, class _Ty2>
+_EXPORT_STD template <bool _Test, class _Ty1, class _Ty2>
 using conditional_t = typename conditional<_Test, _Ty1, _Ty2>::type;
 
 #ifdef __clang__
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 _INLINE_VAR constexpr bool is_same_v = __is_same(_Ty1, _Ty2);
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 struct is_same : bool_constant<__is_same(_Ty1, _Ty2)> {};
 #else // ^^^ Clang / not Clang vvv
-template <class, class>
+_EXPORT_STD template <class, class>
 _INLINE_VAR constexpr bool is_same_v = false; // determine whether arguments are the same type
 template <class _Ty>
 _INLINE_VAR constexpr bool is_same_v<_Ty, _Ty> = true;
 
-template <class _Ty1, class _Ty2>
+_EXPORT_STD template <class _Ty1, class _Ty2>
 struct is_same : bool_constant<is_same_v<_Ty1, _Ty2>> {};
 #endif // __clang__
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct remove_const { // remove top-level const qualifier
     using type = _Ty;
 };
@@ -89,10 +89,10 @@ struct remove_const<const _Ty> {
     using type = _Ty;
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 using remove_const_t = typename remove_const<_Ty>::type;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct remove_volatile { // remove top-level volatile qualifier
     using type = _Ty;
 };
@@ -102,10 +102,10 @@ struct remove_volatile<volatile _Ty> {
     using type = _Ty;
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 using remove_volatile_t = typename remove_volatile<_Ty>::type;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct remove_cv { // remove top-level const and volatile qualifiers
     using type = _Ty;
 
@@ -137,7 +137,7 @@ struct remove_cv<const volatile _Ty> {
     using _Apply = const volatile _Fn<_Ty>;
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 using remove_cv_t = typename remove_cv<_Ty>::type;
 
 template <bool _First_value, class _First, class... _Rest>
@@ -150,7 +150,7 @@ struct _Disjunction<false, _False, _Next, _Rest...> { // first trait is false, t
     using type = typename _Disjunction<_Next::value, _Next, _Rest...>::type;
 };
 
-template <class... _Traits>
+_EXPORT_STD template <class... _Traits>
 struct disjunction : false_type {}; // If _Traits is empty, false_type
 
 template <class _First, class... _Rest>
@@ -158,7 +158,7 @@ struct disjunction<_First, _Rest...> : _Disjunction<_First::value, _First, _Rest
     // the first true trait in _Traits, or the last trait if none are true
 };
 
-template <class... _Traits>
+_EXPORT_STD template <class... _Traits>
 _INLINE_VAR constexpr bool disjunction_v = disjunction<_Traits...>::value;
 
 template <class _Ty, class... _Types>
@@ -170,12 +170,12 @@ _NODISCARD constexpr bool _Is_constant_evaluated() noexcept { // Internal functi
 }
 
 #if _HAS_CXX20
-_NODISCARD constexpr bool is_constant_evaluated() noexcept {
+_EXPORT_STD _NODISCARD constexpr bool is_constant_evaluated() noexcept {
     return __builtin_is_constant_evaluated();
 }
 #endif // _HAS_CXX20
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_integral_v = _Is_any_of_v<remove_cv_t<_Ty>, bool, char, signed char, unsigned char,
     wchar_t,
 #ifdef __cpp_char8_t
@@ -183,23 +183,23 @@ _INLINE_VAR constexpr bool is_integral_v = _Is_any_of_v<remove_cv_t<_Ty>, bool,
 #endif // __cpp_char8_t
     char16_t, char32_t, short, unsigned short, int, unsigned int, long, unsigned long, long long, unsigned long long>;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_integral : bool_constant<is_integral_v<_Ty>> {};
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_floating_point_v = _Is_any_of_v<remove_cv_t<_Ty>, float, double, long double>;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_floating_point : bool_constant<is_floating_point_v<_Ty>> {};
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_arithmetic_v = // determine whether _Ty is an arithmetic type
     is_integral_v<_Ty> || is_floating_point_v<_Ty>;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_arithmetic : bool_constant<is_arithmetic_v<_Ty>> {};
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct remove_reference {
     using type                 = _Ty;
     using _Const_thru_ref_type = const _Ty;
@@ -217,7 +217,7 @@ struct remove_reference<_Ty&&> {
     using _Const_thru_ref_type = const _Ty&&;
 };
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 using remove_reference_t = typename remove_reference<_Ty>::type;
 
 template <class _Ty>
@@ -227,10 +227,10 @@ template <class _Ty>
 using _Remove_cvref_t _MSVC_KNOWN_SEMANTICS = remove_cv_t<remove_reference_t<_Ty>>;
 
 #if _HAS_CXX20
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 using remove_cvref_t = _Remove_cvref_t<_Ty>;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct remove_cvref {
     using type = remove_cvref_t<_Ty>;
 };
diff --git a/stl/inc/xutility b/stl/inc/xutility
index 5128eb4ed3..4f198c3216 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -207,10 +207,10 @@ _NODISCARD constexpr void* _Voidify_iter(_Iter _It) noexcept {
 
 #if _HAS_CXX20
 #ifdef __EDG__ // TRANSITION, DevCom-1691516
-template <class _Ty, class... _Types,
+_EXPORT_STD template <class _Ty, class... _Types,
     class = void_t<decltype(::new (_STD declval<void*>()) _Ty(_STD declval<_Types>()...))>>
 #else // ^^^ no workaround // workaround vvv
-template <class _Ty, class... _Types,
+_EXPORT_STD template <class _Ty, class... _Types,
     void_t<decltype(::new (_STD declval<void*>()) _Ty(_STD declval<_Types>()...))>* = nullptr>
 #endif // TRANSITION, DevCom-1691516
 constexpr _Ty* construct_at(_Ty* const _Location, _Types&&... _Args) noexcept(
@@ -237,7 +237,7 @@ void _Default_construct_in_place(_Ty& _Obj) noexcept(is_nothrow_default_construc
     ::new (_Voidify_iter(_STD addressof(_Obj))) _Ty;
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct pointer_traits {
     using pointer         = _Ty;
     using element_type    = typename _Get_element_type<_Ty>::type;
@@ -285,14 +285,14 @@ inline constexpr bool
     _Has_to_address<_Ty, void_t<decltype(pointer_traits<_Ty>::to_address(_STD declval<const _Ty&>()))>> = true;
 #endif // __cpp_lib_concepts
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 _NODISCARD constexpr _Ty* to_address(_Ty* const _Val) noexcept {
     static_assert(!is_function_v<_Ty>,
         "N4810 20.10.4 [pointer.conversion]/2: The program is ill-formed if T is a function type.");
     return _Val;
 }
 
-template <class _Ptr>
+_EXPORT_STD template <class _Ptr>
 _NODISCARD constexpr auto to_address(const _Ptr& _Val) noexcept {
     if constexpr (_Has_to_address<_Ptr>) {
         return pointer_traits<_Ptr>::to_address(_Val);
@@ -301,7 +301,7 @@ _NODISCARD constexpr auto to_address(const _Ptr& _Val) noexcept {
     }
 }
 
-struct identity {
+_EXPORT_STD struct identity {
     template <class _Ty>
     _NODISCARD constexpr _Ty&& operator()(_Ty&& _Left) const noexcept {
         return _STD forward<_Ty>(_Left);
@@ -412,14 +412,14 @@ namespace ranges {
     } // namespace _Iter_move
 
     inline namespace _Cpos {
-        inline constexpr _Iter_move::_Cpo iter_move;
+        _EXPORT_STD inline constexpr _Iter_move::_Cpo iter_move;
     }
 } // namespace ranges
 
 // iter_swap defined below since it depends on indirectly_movable_storable
 
 // clang-format off
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
     requires _Dereferenceable<_Ty> && requires(_Ty& __t) {
         { _RANGES iter_move(__t) } -> _Can_reference;
     }
@@ -436,15 +436,15 @@ concept _Indirectly_readable_impl = requires(const _It __i) {
   && common_reference_with<iter_reference_t<_It>&&, iter_rvalue_reference_t<_It>&&>
   && common_reference_with<iter_rvalue_reference_t<_It>&&, const iter_value_t<_It>&>;
 
-template <class _It>
+_EXPORT_STD template <class _It>
 concept indirectly_readable = _Indirectly_readable_impl<remove_cvref_t<_It>>;
 // clang-format on
 
-template <indirectly_readable _Ty>
+_EXPORT_STD template <indirectly_readable _Ty>
 using iter_common_reference_t = common_reference_t<iter_reference_t<_Ty>, iter_value_t<_Ty>&>;
 
-template <class _It, class _Ty>
-concept indirectly_writable = requires(_It&& __i, _Ty&& __t) {
+_EXPORT_STD template <class _It, class _Ty>
+concept indirectly_writable = requires(_It && __i, _Ty&& __t) {
     *__i                                                                = static_cast<_Ty&&>(__t);
     *static_cast<_It&&>(__i)                                            = static_cast<_Ty&&>(__t);
     const_cast<const iter_reference_t<_It>&&>(*__i)                     = static_cast<_Ty&&>(__t);
@@ -489,7 +489,7 @@ _NODISCARD constexpr auto _To_signed_like(const _Ty _Value) noexcept {
     return static_cast<_Make_signed_like_t<_Ty>>(_Value);
 }
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 concept incrementable = regular<_Ty> && weakly_incrementable<_Ty> && requires(_Ty __t) {
     { __t++ } -> same_as<_Ty>;
 };
@@ -522,29 +522,29 @@ using _Iter_concept =
     typename _Iter_concept_impl1<_Has_member_iterator_concept<_Traits>>::template _Apply<_It, _Traits>;
 
 // clang-format off
-template <class _It>
+_EXPORT_STD template <class _It>
 concept input_iterator = input_or_output_iterator<_It> && indirectly_readable<_It>
     && requires { typename _Iter_concept<_It>; }
     && derived_from<_Iter_concept<_It>, input_iterator_tag>;
 
-template <class _It, class _Ty>
+_EXPORT_STD template <class _It, class _Ty>
 concept output_iterator = input_or_output_iterator<_It> && indirectly_writable<_It, _Ty>
     && requires(_It __i, _Ty&& __t) {
         *__i++ = static_cast<_Ty&&>(__t);
     };
 
-template <class _It>
+_EXPORT_STD template <class _It>
 concept forward_iterator = input_iterator<_It> && derived_from<_Iter_concept<_It>, forward_iterator_tag>
     && incrementable<_It> && sentinel_for<_It, _It>;
 
-template <class _It>
+_EXPORT_STD template <class _It>
 concept bidirectional_iterator = forward_iterator<_It> && derived_from<_Iter_concept<_It>, bidirectional_iterator_tag>
     && requires(_It __i) {
         { --__i } -> same_as<_It&>;
         { __i-- } -> same_as<_It>;
     };
 
-template <class _It>
+_EXPORT_STD template <class _It>
 concept random_access_iterator = bidirectional_iterator<_It>
     && derived_from<_Iter_concept<_It>, random_access_iterator_tag> && totally_ordered<_It>
     && sized_sentinel_for<_It, _It> && requires(_It __i, const _It __j, const iter_difference_t<_It> __n) {
@@ -556,7 +556,7 @@ concept random_access_iterator = bidirectional_iterator<_It>
         { __j[__n] } -> same_as<iter_reference_t<_It>>;
     };
 
-template <class _It>
+_EXPORT_STD template <class _It>
 concept contiguous_iterator = random_access_iterator<_It>
     && derived_from<_Iter_concept<_It>, contiguous_iterator_tag>
     && is_lvalue_reference_v<iter_reference_t<_It>>
@@ -565,7 +565,7 @@ concept contiguous_iterator = random_access_iterator<_It>
         { _STD to_address(__i) } -> same_as<add_pointer_t<iter_reference_t<_It>>>;
     };
 
-template <class _Fn, class _It>
+_EXPORT_STD template <class _Fn, class _It>
 concept indirectly_unary_invocable = indirectly_readable<_It>
     && copy_constructible<_Fn>
     && invocable<_Fn&, iter_value_t<_It>&>
@@ -575,7 +575,7 @@ concept indirectly_unary_invocable = indirectly_readable<_It>
         invoke_result_t<_Fn&, iter_value_t<_It>&>,
         invoke_result_t<_Fn&, iter_reference_t<_It>>>;
 
-template <class _Fn, class _It>
+_EXPORT_STD template <class _Fn, class _It>
 concept indirectly_regular_unary_invocable = indirectly_readable<_It>
     && copy_constructible<_Fn>
     && regular_invocable<_Fn&, iter_value_t<_It>&>
@@ -585,14 +585,14 @@ concept indirectly_regular_unary_invocable = indirectly_readable<_It>
         invoke_result_t<_Fn&, iter_value_t<_It>&>,
         invoke_result_t<_Fn&, iter_reference_t<_It>>>;
 
-template <class _Fn, class _It>
+_EXPORT_STD template <class _Fn, class _It>
 concept indirect_unary_predicate = indirectly_readable<_It>
     && copy_constructible<_Fn>
     && predicate<_Fn&, iter_value_t<_It>&>
     && predicate<_Fn&, iter_reference_t<_It>>
     && predicate<_Fn&, iter_common_reference_t<_It>>;
 
-template <class _Fn, class _It1, class _It2>
+_EXPORT_STD template <class _Fn, class _It1, class _It2>
 concept indirect_binary_predicate = indirectly_readable<_It1>
     && indirectly_readable<_It2>
     && copy_constructible<_Fn>
@@ -602,7 +602,7 @@ concept indirect_binary_predicate = indirectly_readable<_It1>
     && predicate<_Fn&, iter_reference_t<_It1>, iter_reference_t<_It2>>
     && predicate<_Fn&, iter_common_reference_t<_It1>, iter_common_reference_t<_It2>>;
 
-template <class _Fn, class _It1, class _It2 = _It1>
+_EXPORT_STD template <class _Fn, class _It1, class _It2 = _It1>
 concept indirect_equivalence_relation = indirectly_readable<_It1>
     && indirectly_readable<_It2>
     && copy_constructible<_Fn>
@@ -612,7 +612,7 @@ concept indirect_equivalence_relation = indirectly_readable<_It1>
     && equivalence_relation<_Fn&, iter_reference_t<_It1>, iter_reference_t<_It2>>
     && equivalence_relation<_Fn&, iter_common_reference_t<_It1>, iter_common_reference_t<_It2>>;
 
-template <class _Fn, class _It1, class _It2 = _It1>
+_EXPORT_STD template <class _Fn, class _It1, class _It2 = _It1>
 concept indirect_strict_weak_order = indirectly_readable<_It1>
     && indirectly_readable<_It2>
     && copy_constructible<_Fn>
@@ -622,13 +622,13 @@ concept indirect_strict_weak_order = indirectly_readable<_It1>
     && strict_weak_order<_Fn&, iter_reference_t<_It1>, iter_reference_t<_It2>>
     && strict_weak_order<_Fn&, iter_common_reference_t<_It1>, iter_common_reference_t<_It2>>;
 
-template <class _Fn, class... _Its>
+_EXPORT_STD template <class _Fn, class... _Its>
     requires (indirectly_readable<_Its> && ...)
         && invocable<_Fn, iter_reference_t<_Its>...>
 using indirect_result_t = invoke_result_t<_Fn, iter_reference_t<_Its>...>;
 // clang-format on
 
-template <indirectly_readable _It, indirectly_regular_unary_invocable<_It> _Proj>
+_EXPORT_STD template <indirectly_readable _It, indirectly_regular_unary_invocable<_It> _Proj>
 struct projected {
     using value_type = remove_cvref_t<indirect_result_t<_Proj&, _It>>;
     indirect_result_t<_Proj&, _It> operator*() const {
@@ -641,11 +641,11 @@ struct incrementable_traits<projected<_It, _Proj>> {
     using difference_type = iter_difference_t<_It>;
 };
 
-template <class _In, class _Out>
+_EXPORT_STD template <class _In, class _Out>
 concept indirectly_movable = indirectly_readable<_In> && indirectly_writable<_Out, iter_rvalue_reference_t<_In>>;
 
 // clang-format off
-template <class _In, class _Out>
+_EXPORT_STD template <class _In, class _Out>
 concept indirectly_movable_storable = indirectly_movable<_In, _Out>
     && indirectly_writable<_Out, iter_value_t<_In>>
     && movable<iter_value_t<_In>>
@@ -653,11 +653,11 @@ concept indirectly_movable_storable = indirectly_movable<_In, _Out>
     && assignable_from<iter_value_t<_In>&, iter_rvalue_reference_t<_In> >;
 // clang-format on
 
-template <class _In, class _Out>
+_EXPORT_STD template <class _In, class _Out>
 concept indirectly_copyable = indirectly_readable<_In> && indirectly_writable<_Out, iter_reference_t<_In>>;
 
 // clang-format off
-template <class _In, class _Out>
+_EXPORT_STD template <class _In, class _Out>
 concept indirectly_copyable_storable = indirectly_copyable<_In, _Out>
     && indirectly_writable<_Out, iter_value_t<_In>&>
     && indirectly_writable<_Out, const iter_value_t<_In>&>
@@ -744,12 +744,12 @@ namespace ranges {
     } // namespace _Iter_swap
 
     inline namespace _Cpos {
-        inline constexpr _Iter_swap::_Cpo iter_swap;
+        _EXPORT_STD inline constexpr _Iter_swap::_Cpo iter_swap;
     }
 } // namespace ranges
 
 // clang-format off
-template <class _It1, class _It2 = _It1>
+_EXPORT_STD template <class _It1, class _It2 = _It1>
 concept indirectly_swappable = indirectly_readable<_It1> && indirectly_readable<_It2>
     && requires(const _It1 __i1, const _It2 __i2) {
         _RANGES iter_swap(__i1, __i1);
@@ -759,24 +759,25 @@ concept indirectly_swappable = indirectly_readable<_It1> && indirectly_readable<
     };
 // clang-format on
 
-template <class _It1, class _It2, class _Rel, class _Proj1 = identity, class _Proj2 = identity>
+_EXPORT_STD template <class _It1, class _It2, class _Rel, class _Proj1 = identity, class _Proj2 = identity>
 concept indirectly_comparable = indirect_binary_predicate<_Rel, projected<_It1, _Proj1>, projected<_It2, _Proj2>>;
 
-template <class _It>
+_EXPORT_STD template <class _It>
 concept permutable = forward_iterator<_It> && indirectly_movable_storable<_It, _It> && indirectly_swappable<_It, _It>;
 
 namespace ranges {
-    struct less;
+    _EXPORT_STD struct less;
 }
 
-template <class _It1, class _It2, class _Out, class _Pr = ranges::less, class _Pj1 = identity, class _Pj2 = identity>
+_EXPORT_STD template <class _It1, class _It2, class _Out, class _Pr = ranges::less, class _Pj1 = identity,
+    class _Pj2 = identity>
 concept mergeable = input_iterator<_It1> && input_iterator<_It2> //
     && weakly_incrementable<_Out> //
     && indirectly_copyable<_It1, _Out> //
     && indirectly_copyable<_It2, _Out> //
     && indirect_strict_weak_order<_Pr, projected<_It1, _Pj1>, projected<_It2, _Pj2>>;
 
-template <class _It, class _Pr = ranges::less, class _Proj = identity>
+_EXPORT_STD template <class _It, class _Pr = ranges::less, class _Proj = identity>
 concept sortable = permutable<_It> && indirect_strict_weak_order<_Pr, projected<_It, _Proj>>;
 
 template <class _Iter>
@@ -1036,10 +1037,10 @@ template <class _Iter>
 using _Guide_pair_t = pair<add_const_t<typename iterator_traits<_Iter>::value_type::first_type>,
     typename iterator_traits<_Iter>::value_type::second_type>;
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 struct is_execution_policy : false_type {};
 
-template <class _Ty>
+_EXPORT_STD template <class _Ty>
 inline constexpr bool is_execution_policy_v = is_execution_policy<_Ty>::value;
 
 // Note: The noexcept specifiers on all parallel algorithm overloads enforce termination as per
@@ -1128,7 +1129,7 @@ constexpr void _Debug_order_set_unchecked(_InIt _First, _InIt _Last, _Pr&& _Pred
 #endif // _ITERATOR_DEBUG_LEVEL < 2
 
 // from <iterator>
-template <class _InIt, class _Diff>
+_EXPORT_STD template <class _InIt, class _Diff>
 _CONSTEXPR17 void advance(_InIt& _Where, _Diff _Off) { // increment iterator by offset
     if constexpr (_Is_ranges_random_iter_v<_InIt>) {
         _Where += _Off;
@@ -1156,7 +1157,7 @@ _CONSTEXPR17 void advance(_InIt& _Where, _Diff _Off) { // increment iterator by
     }
 }
 
-template <class _InIt>
+_EXPORT_STD template <class _InIt>
 _NODISCARD _CONSTEXPR17 _Iter_diff_t<_InIt> distance(_InIt _First, _InIt _Last) {
     if constexpr (_Is_ranges_random_iter_v<_InIt>) {
         return _Last - _First; // assume the iterator will do debug checking
@@ -1178,7 +1179,7 @@ constexpr _InIt _Next_iter(_InIt _First) { // increment iterator
     return ++_First;
 }
 
-template <class _InIt>
+_EXPORT_STD template <class _InIt>
 _NODISCARD _CONSTEXPR17 _InIt next(_InIt _First, _Iter_diff_t<_InIt> _Off = 1) { // increment iterator
     static_assert(_Is_ranges_input_iter_v<_InIt>, "next requires input iterator");
 
@@ -1191,7 +1192,7 @@ constexpr _BidIt _Prev_iter(_BidIt _First) { // decrement iterator
     return --_First;
 }
 
-template <class _BidIt>
+_EXPORT_STD template <class _BidIt>
 _NODISCARD _CONSTEXPR17 _BidIt prev(_BidIt _First, _Iter_diff_t<_BidIt> _Off = 1) { // decrement iterator
     static_assert(_Is_ranges_bidi_iter_v<_BidIt>, "prev requires bidirectional iterator");
 
@@ -1206,7 +1207,7 @@ template <class _Iter, class _Pointer>
 _INLINE_VAR constexpr bool _Has_nothrow_operator_arrow<_Iter, _Pointer, false> = noexcept(
     _Fake_copy_init<_Pointer>(_STD declval<_Iter>().operator->()));
 
-template <class _BidIt>
+_EXPORT_STD template <class _BidIt>
 class reverse_iterator {
 public:
     using iterator_type = _BidIt;
@@ -1391,7 +1392,7 @@ protected:
     _BidIt current{};
 };
 
-template <class _BidIt1, class _BidIt2>
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
 _NODISCARD _CONSTEXPR17 bool
     operator==(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right) noexcept(
         noexcept(_Fake_copy_init<bool>(_Left._Get_current() == _Right._Get_current()))) /* strengthened */
@@ -1404,7 +1405,7 @@ _NODISCARD _CONSTEXPR17 bool
 #endif // __cpp_lib_concepts
 { return _Left._Get_current() == _Right._Get_current(); }
 
-template <class _BidIt1, class _BidIt2>
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
 _NODISCARD _CONSTEXPR17 bool
     operator!=(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right) noexcept(
         noexcept(_Fake_copy_init<bool>(_Left._Get_current() != _Right._Get_current()))) /* strengthened */
@@ -1417,7 +1418,7 @@ _NODISCARD _CONSTEXPR17 bool
 #endif // __cpp_lib_concepts
 { return _Left._Get_current() != _Right._Get_current(); }
 
-template <class _BidIt1, class _BidIt2>
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
 _NODISCARD _CONSTEXPR17 bool
     operator<(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right) noexcept(
         noexcept(_Fake_copy_init<bool>(_Left._Get_current() > _Right._Get_current()))) /* strengthened */
@@ -1430,7 +1431,7 @@ _NODISCARD _CONSTEXPR17 bool
 #endif // __cpp_lib_concepts
 { return _Left._Get_current() > _Right._Get_current(); }
 
-template <class _BidIt1, class _BidIt2>
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
 _NODISCARD _CONSTEXPR17 bool
     operator>(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right) noexcept(
         noexcept(_Fake_copy_init<bool>(_Left._Get_current() < _Right._Get_current()))) /* strengthened */
@@ -1443,7 +1444,7 @@ _NODISCARD _CONSTEXPR17 bool
 #endif // __cpp_lib_concepts
 { return _Left._Get_current() < _Right._Get_current(); }
 
-template <class _BidIt1, class _BidIt2>
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
 _NODISCARD _CONSTEXPR17 bool
     operator<=(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right) noexcept(
         noexcept(_Fake_copy_init<bool>(_Left._Get_current() >= _Right._Get_current()))) /* strengthened */
@@ -1456,7 +1457,7 @@ _NODISCARD _CONSTEXPR17 bool
 #endif // __cpp_lib_concepts
 { return _Left._Get_current() >= _Right._Get_current(); }
 
-template <class _BidIt1, class _BidIt2>
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
 _NODISCARD _CONSTEXPR17 bool
     operator>=(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right) noexcept(
         noexcept(_Fake_copy_init<bool>(_Left._Get_current() <= _Right._Get_current()))) /* strengthened */
@@ -1470,7 +1471,7 @@ _NODISCARD _CONSTEXPR17 bool
 { return _Left._Get_current() <= _Right._Get_current(); }
 
 #ifdef __cpp_lib_concepts
-template <class _BidIt1, three_way_comparable_with<_BidIt1> _BidIt2>
+_EXPORT_STD template <class _BidIt1, three_way_comparable_with<_BidIt1> _BidIt2>
 _NODISCARD constexpr compare_three_way_result_t<_BidIt1, _BidIt2>
     operator<=>(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right) noexcept(
         noexcept(_Right._Get_current() <=> _Left._Get_current())) /* strengthened */ {
@@ -1478,7 +1479,7 @@ _NODISCARD constexpr compare_three_way_result_t<_BidIt1, _BidIt2>
 }
 #endif // __cpp_lib_concepts
 
-template <class _BidIt1, class _BidIt2>
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
 _NODISCARD _CONSTEXPR17 auto
     operator-(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right) noexcept(
         noexcept(_Right._Get_current() - _Left._Get_current())) /* strengthened */
@@ -1486,13 +1487,13 @@ _NODISCARD _CONSTEXPR17 auto
     return _Right._Get_current() - _Left._Get_current();
 }
 
-template <class _BidIt>
+_EXPORT_STD template <class _BidIt>
 _NODISCARD _CONSTEXPR17 reverse_iterator<_BidIt> operator+(typename reverse_iterator<_BidIt>::difference_type _Off,
     const reverse_iterator<_BidIt>& _Right) noexcept(noexcept(_Right + _Off)) /* strengthened */ {
     return _Right + _Off;
 }
 
-template <class _BidIt>
+_EXPORT_STD template <class _BidIt>
 _NODISCARD _CONSTEXPR17 reverse_iterator<_BidIt> make_reverse_iterator(_BidIt _Iter) noexcept(
     is_nothrow_move_constructible_v<_BidIt>) /* strengthened */ {
     return reverse_iterator<_BidIt>(_STD move(_Iter));
@@ -1506,123 +1507,123 @@ inline constexpr bool disable_sized_sentinel_for<reverse_iterator<_BidIt1>, reve
 // clang-format on
 #endif // __cpp_lib_concepts
 
-template <class _Container>
+_EXPORT_STD template <class _Container>
 _NODISCARD _CONSTEXPR17 auto begin(_Container& _Cont) noexcept(noexcept(_Cont.begin())) /* strengthened */
     -> decltype(_Cont.begin()) {
     return _Cont.begin();
 }
 
-template <class _Container>
+_EXPORT_STD template <class _Container>
 _NODISCARD _CONSTEXPR17 auto begin(const _Container& _Cont) noexcept(noexcept(_Cont.begin())) /* strengthened */
     -> decltype(_Cont.begin()) {
     return _Cont.begin();
 }
 
-template <class _Container>
+_EXPORT_STD template <class _Container>
 _NODISCARD _CONSTEXPR17 auto end(_Container& _Cont) noexcept(noexcept(_Cont.end())) /* strengthened */
     -> decltype(_Cont.end()) {
     return _Cont.end();
 }
 
-template <class _Container>
+_EXPORT_STD template <class _Container>
 _NODISCARD _CONSTEXPR17 auto end(const _Container& _Cont) noexcept(noexcept(_Cont.end())) /* strengthened */
     -> decltype(_Cont.end()) {
     return _Cont.end();
 }
 
-template <class _Ty, size_t _Size>
+_EXPORT_STD template <class _Ty, size_t _Size>
 _NODISCARD constexpr _Ty* begin(_Ty (&_Array)[_Size]) noexcept {
     return _Array;
 }
 
-template <class _Ty, size_t _Size>
+_EXPORT_STD template <class _Ty, size_t _Size>
 _NODISCARD constexpr _Ty* end(_Ty (&_Array)[_Size]) noexcept {
     return _Array + _Size;
 }
 
-template <class _Container>
+_EXPORT_STD template <class _Container>
 _NODISCARD constexpr auto cbegin(const _Container& _Cont) noexcept(noexcept(_STD begin(_Cont)))
     -> decltype(_STD begin(_Cont)) {
     return _STD begin(_Cont);
 }
 
-template <class _Container>
+_EXPORT_STD template <class _Container>
 _NODISCARD constexpr auto cend(const _Container& _Cont) noexcept(noexcept(_STD end(_Cont)))
     -> decltype(_STD end(_Cont)) {
     return _STD end(_Cont);
 }
 
-template <class _Container>
+_EXPORT_STD template <class _Container>
 _NODISCARD _CONSTEXPR17 auto rbegin(_Container& _Cont) noexcept(noexcept(_Cont.rbegin())) /* strengthened */
     -> decltype(_Cont.rbegin()) {
     return _Cont.rbegin();
 }
 
-template <class _Container>
+_EXPORT_STD template <class _Container>
 _NODISCARD _CONSTEXPR17 auto rbegin(const _Container& _Cont) noexcept(noexcept(_Cont.rbegin())) /* strengthened */
     -> decltype(_Cont.rbegin()) {
     return _Cont.rbegin();
 }
 
-template <class _Container>
+_EXPORT_STD template <class _Container>
 _NODISCARD _CONSTEXPR17 auto rend(_Container& _Cont) noexcept(noexcept(_Cont.rend())) /* strengthened */
     -> decltype(_Cont.rend()) {
     return _Cont.rend();
 }
 
-template <class _Container>
+_EXPORT_STD template <class _Container>
 _NODISCARD _CONSTEXPR17 auto rend(const _Container& _Cont) noexcept(noexcept(_Cont.rend())) /* strengthened */
     -> decltype(_Cont.rend()) {
     return _Cont.rend();
 }
 
-template <class _Ty, size_t _Size>
+_EXPORT_STD template <class _Ty, size_t _Size>
 _NODISCARD _CONSTEXPR17 reverse_iterator<_Ty*> rbegin(_Ty (&_Array)[_Size]) noexcept /* strengthened */ {
     return reverse_iterator<_Ty*>(_Array + _Size);
 }
 
-template <class _Ty, size_t _Size>
+_EXPORT_STD template <class _Ty, size_t _Size>
 _NODISCARD _CONSTEXPR17 reverse_iterator<_Ty*> rend(_Ty (&_Array)[_Size]) noexcept /* strengthened */ {
     return reverse_iterator<_Ty*>(_Array);
 }
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 _NODISCARD _CONSTEXPR17 reverse_iterator<const _Elem*> rbegin(initializer_list<_Elem> _Ilist) noexcept
 /* strengthened */ {
     return reverse_iterator<const _Elem*>(_Ilist.end());
 }
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 _NODISCARD _CONSTEXPR17 reverse_iterator<const _Elem*> rend(initializer_list<_Elem> _Ilist) noexcept
 /* strengthened */ {
     return reverse_iterator<const _Elem*>(_Ilist.begin());
 }
 
-template <class _Container>
+_EXPORT_STD template <class _Container>
 _NODISCARD _CONSTEXPR17 auto crbegin(const _Container& _Cont) noexcept(noexcept(_STD rbegin(_Cont))) /* strengthened */
     -> decltype(_STD rbegin(_Cont)) {
     return _STD rbegin(_Cont);
 }
 
-template <class _Container>
+_EXPORT_STD template <class _Container>
 _NODISCARD _CONSTEXPR17 auto crend(const _Container& _Cont) noexcept(noexcept(_STD rend(_Cont))) /* strengthened */
     -> decltype(_STD rend(_Cont)) {
     return _STD rend(_Cont);
 }
 
-template <class _Container>
+_EXPORT_STD template <class _Container>
 _NODISCARD constexpr auto size(const _Container& _Cont) noexcept(noexcept(_Cont.size())) /* strengthened */
     -> decltype(_Cont.size()) {
     return _Cont.size();
 }
 
-template <class _Ty, size_t _Size>
+_EXPORT_STD template <class _Ty, size_t _Size>
 _NODISCARD constexpr size_t size(const _Ty (&)[_Size]) noexcept {
     return _Size;
 }
 
 #if _HAS_CXX20
-template <class _Container>
+_EXPORT_STD template <class _Container>
 _NODISCARD constexpr auto ssize(const _Container& _Cont) noexcept(noexcept(
     static_cast<common_type_t<ptrdiff_t, make_signed_t<decltype(_Cont.size())>>>(_Cont.size()))) /* strengthened */
     -> common_type_t<ptrdiff_t, make_signed_t<decltype(_Cont.size())>> {
@@ -1630,47 +1631,47 @@ _NODISCARD constexpr auto ssize(const _Container& _Cont) noexcept(noexcept(
     return static_cast<_Common>(_Cont.size());
 }
 
-template <class _Ty, ptrdiff_t _Size>
+_EXPORT_STD template <class _Ty, ptrdiff_t _Size>
 _NODISCARD constexpr ptrdiff_t ssize(const _Ty (&)[_Size]) noexcept {
     return _Size;
 }
 #endif // _HAS_CXX20
 
-template <class _Container>
+_EXPORT_STD template <class _Container>
 _NODISCARD_EMPTY_NON_MEMBER constexpr auto empty(const _Container& _Cont) noexcept(
     noexcept(_Cont.empty())) /* strengthened */
     -> decltype(_Cont.empty()) {
     return _Cont.empty();
 }
 
-template <class _Ty, size_t _Size>
+_EXPORT_STD template <class _Ty, size_t _Size>
 _NODISCARD_EMPTY_NON_MEMBER constexpr bool empty(const _Ty (&)[_Size]) noexcept {
     return false;
 }
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 _NODISCARD_EMPTY_NON_MEMBER constexpr bool empty(initializer_list<_Elem> _Ilist) noexcept {
     return _Ilist.size() == 0;
 }
 
-template <class _Container>
+_EXPORT_STD template <class _Container>
 _NODISCARD constexpr auto data(_Container& _Cont) noexcept(noexcept(_Cont.data())) /* strengthened */
     -> decltype(_Cont.data()) {
     return _Cont.data();
 }
 
-template <class _Container>
+_EXPORT_STD template <class _Container>
 _NODISCARD constexpr auto data(const _Container& _Cont) noexcept(noexcept(_Cont.data())) /* strengthened */
     -> decltype(_Cont.data()) {
     return _Cont.data();
 }
 
-template <class _Ty, size_t _Size>
+_EXPORT_STD template <class _Ty, size_t _Size>
 _NODISCARD constexpr _Ty* data(_Ty (&_Array)[_Size]) noexcept {
     return _Array;
 }
 
-template <class _Elem>
+_EXPORT_STD template <class _Elem>
 _NODISCARD constexpr const _Elem* data(initializer_list<_Elem> _Ilist) noexcept {
     return _Ilist.begin();
 }
@@ -1689,7 +1690,7 @@ namespace ranges {
     inline constexpr bool _Has_complete_elements<_Ty> = true;
     // clang-format on
 
-    template <class>
+    _EXPORT_STD template <class>
     inline constexpr bool enable_borrowed_range = false;
 
     template <class _Rng>
@@ -1758,10 +1759,10 @@ namespace ranges {
     } // namespace _Begin
 
     inline namespace _Cpos {
-        inline constexpr _Begin::_Cpo begin;
+        _EXPORT_STD inline constexpr _Begin::_Cpo begin;
     }
 
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     using iterator_t = decltype(_RANGES begin(_STD declval<_Ty&>()));
 
     namespace _End {
@@ -1834,16 +1835,16 @@ namespace ranges {
     } // namespace _End
 
     inline namespace _Cpos {
-        inline constexpr _End::_Cpo end;
+        _EXPORT_STD inline constexpr _End::_Cpo end;
     }
 
-    template <class _Rng>
-    concept range = requires(_Rng& __r) {
+    _EXPORT_STD template <class _Rng>
+    concept range = requires(_Rng & __r) {
         _RANGES begin(__r);
         _RANGES end(__r);
     };
 
-    template <range _Rng>
+    _EXPORT_STD template <range _Rng>
     using sentinel_t = decltype(_RANGES end(_STD declval<_Rng&>()));
 
     template <class _Wrapped>
@@ -2033,19 +2034,19 @@ namespace ranges {
         inline constexpr _Unchecked_end::_Cpo _Uend;
     }
 
-    template <class _Rng>
+    _EXPORT_STD template <class _Rng>
     concept borrowed_range = range<_Rng> && _Should_range_access<_Rng>;
 
-    template <range _Rng>
+    _EXPORT_STD template <range _Rng>
     using range_difference_t = iter_difference_t<iterator_t<_Rng>>;
 
-    template <range _Rng>
+    _EXPORT_STD template <range _Rng>
     using range_value_t = iter_value_t<iterator_t<_Rng>>;
 
-    template <range _Rng>
+    _EXPORT_STD template <range _Rng>
     using range_reference_t = iter_reference_t<iterator_t<_Rng>>;
 
-    template <range _Rng>
+    _EXPORT_STD template <range _Rng>
     using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<_Rng>>;
 
     struct _Cbegin_fn {
@@ -2060,7 +2061,7 @@ namespace ranges {
     };
 
     inline namespace _Cpos {
-        inline constexpr _Cbegin_fn cbegin;
+        _EXPORT_STD inline constexpr _Cbegin_fn cbegin;
     }
 
     struct _Cend_fn {
@@ -2075,7 +2076,7 @@ namespace ranges {
     };
 
     inline namespace _Cpos {
-        inline constexpr _Cend_fn cend;
+        _EXPORT_STD inline constexpr _Cend_fn cend;
     }
 
     namespace _Rbegin {
@@ -2143,7 +2144,7 @@ namespace ranges {
     } // namespace _Rbegin
 
     inline namespace _Cpos {
-        inline constexpr _Rbegin::_Cpo rbegin;
+        _EXPORT_STD inline constexpr _Rbegin::_Cpo rbegin;
     }
 
     namespace _Rend {
@@ -2212,7 +2213,7 @@ namespace ranges {
     } // namespace _Rend
 
     inline namespace _Cpos {
-        inline constexpr _Rend::_Cpo rend;
+        _EXPORT_STD inline constexpr _Rend::_Cpo rend;
     }
 
     struct _Crbegin_fn {
@@ -2227,7 +2228,7 @@ namespace ranges {
     };
 
     inline namespace _Cpos {
-        inline constexpr _Crbegin_fn crbegin;
+        _EXPORT_STD inline constexpr _Crbegin_fn crbegin;
     }
 
     struct _Crend_fn {
@@ -2242,10 +2243,10 @@ namespace ranges {
     };
 
     inline namespace _Cpos {
-        inline constexpr _Crend_fn crend;
+        _EXPORT_STD inline constexpr _Crend_fn crend;
     }
 
-    template <class>
+    _EXPORT_STD template <class>
     inline constexpr bool disable_sized_range = false;
 
     namespace _Size {
@@ -2326,7 +2327,7 @@ namespace ranges {
     } // namespace _Size
 
     inline namespace _Cpos {
-        inline constexpr _Size::_Cpo size;
+        _EXPORT_STD inline constexpr _Size::_Cpo size;
     }
 
     namespace _Empty {
@@ -2393,7 +2394,7 @@ namespace ranges {
     } // namespace _Empty
 
     inline namespace _Cpos {
-        inline constexpr _Empty::_Cpo empty;
+        _EXPORT_STD inline constexpr _Empty::_Cpo empty;
     }
 
     namespace _Data {
@@ -2449,7 +2450,7 @@ namespace ranges {
     } // namespace _Data
 
     inline namespace _Cpos {
-        inline constexpr _Data::_Cpo data;
+        _EXPORT_STD inline constexpr _Data::_Cpo data;
     }
 
     struct _Cdata_fn {
@@ -2464,18 +2465,18 @@ namespace ranges {
     };
 
     inline namespace _Cpos {
-        inline constexpr _Cdata_fn cdata;
+        _EXPORT_STD inline constexpr _Cdata_fn cdata;
     }
 
-    template <class _Rng>
-    concept sized_range = range<_Rng> && requires(_Rng& __r) {
+    _EXPORT_STD template <class _Rng>
+    concept sized_range = range<_Rng> && requires(_Rng & __r) {
         _RANGES size(__r);
     };
 
-    template <sized_range _Rng>
+    _EXPORT_STD template <sized_range _Rng>
     using range_size_t = decltype(_RANGES size(_STD declval<_Rng&>()));
 
-    struct view_base {};
+    _EXPORT_STD struct view_base {};
 
     template <template <class...> class _Template, class... _Args>
     void _Derived_from_specialization_impl(const _Template<_Args...>&);
@@ -2485,34 +2486,34 @@ namespace ranges {
         _RANGES _Derived_from_specialization_impl<_Template>(_Obj); // qualified: avoid ADL, handle incompletable types
     };
 
-    template <class _Derived>
+    _EXPORT_STD template <class _Derived>
         requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
     class view_interface;
 
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     inline constexpr bool enable_view =
         derived_from<_Ty, view_base> || _Derived_from_specialization_of<_Ty, view_interface>;
 
-    template <class _Ty>
+    _EXPORT_STD template <class _Ty>
     concept view = range<_Ty> && movable<_Ty> && enable_view<_Ty>;
 
-    template <class _Rng, class _Ty>
+    _EXPORT_STD template <class _Rng, class _Ty>
     concept output_range = range<_Rng> && output_iterator<iterator_t<_Rng>, _Ty>;
 
-    template <class _Rng>
+    _EXPORT_STD template <class _Rng>
     concept input_range = range<_Rng> && input_iterator<iterator_t<_Rng>>;
 
-    template <class _Rng>
+    _EXPORT_STD template <class _Rng>
     concept forward_range = range<_Rng> && forward_iterator<iterator_t<_Rng>>;
 
-    template <class _Rng>
+    _EXPORT_STD template <class _Rng>
     concept bidirectional_range = range<_Rng> && bidirectional_iterator<iterator_t<_Rng>>;
 
-    template <class _Rng>
+    _EXPORT_STD template <class _Rng>
     concept random_access_range = range<_Rng> && random_access_iterator<iterator_t<_Rng>>;
 
-    template <class _Rng>
-    concept contiguous_range = range<_Rng> && contiguous_iterator<iterator_t<_Rng>> && requires(_Rng& __r) {
+    _EXPORT_STD template <class _Rng>
+    concept contiguous_range = range<_Rng> && contiguous_iterator<iterator_t<_Rng>> && requires(_Rng & __r) {
         { _RANGES data(__r) } -> same_as<add_pointer_t<range_reference_t<_Rng>>>;
     };
 
@@ -2630,7 +2631,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Advance_fn advance{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Advance_fn advance{_Not_quite_object::_Construct_tag{}};
 
     class _Distance_fn : private _Not_quite_object {
     public:
@@ -2683,7 +2684,7 @@ namespace ranges {
         static constexpr bool _Nothrow_size<_Rng> = noexcept(_RANGES size(_STD declval<_Rng&>()));
     };
 
-    inline constexpr _Distance_fn distance{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Distance_fn distance{_Not_quite_object::_Construct_tag{}};
 
     class _Ssize_fn {
     public:
@@ -2698,7 +2699,7 @@ namespace ranges {
     };
 
     inline namespace _Cpos {
-        inline constexpr _Ssize_fn ssize;
+        _EXPORT_STD inline constexpr _Ssize_fn ssize;
     }
 
     class _Next_fn : private _Not_quite_object {
@@ -2730,7 +2731,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Next_fn next{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Next_fn next{_Not_quite_object::_Construct_tag{}};
 
     class _Prev_fn : private _Not_quite_object {
     public:
@@ -2757,7 +2758,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Prev_fn prev{_Not_quite_object::_Construct_tag{}};
+    _EXPORT_STD inline constexpr _Prev_fn prev{_Not_quite_object::_Construct_tag{}};
 
     template <forward_iterator _It, sentinel_for<_It> _Se>
     _NODISCARD constexpr _It _Find_last_iterator(
@@ -2771,7 +2772,7 @@ namespace ranges {
         }
     }
 
-    struct equal_to {
+    _EXPORT_STD struct equal_to {
         // clang-format off
         template <class _Ty1, class _Ty2>
             requires equality_comparable_with<_Ty1, _Ty2>
@@ -2784,7 +2785,7 @@ namespace ranges {
         using is_transparent = int;
     };
 
-    struct less {
+    _EXPORT_STD struct less {
         // clang-format off
         template <class _Ty1, class _Ty2>
             requires totally_ordered_with<_Ty1, _Ty2>
@@ -2797,7 +2798,7 @@ namespace ranges {
         using is_transparent = int;
     };
 
-    struct greater {
+    _EXPORT_STD struct greater {
         // clang-format off
         template <class _Ty1, class _Ty2>
             requires totally_ordered_with<_Ty1, _Ty2>
@@ -2810,7 +2811,7 @@ namespace ranges {
         using is_transparent = int;
     };
 
-    template <class _Rng>
+    _EXPORT_STD template <class _Rng>
     concept common_range = range<_Rng> && same_as<iterator_t<_Rng>, sentinel_t<_Rng>>;
 
     template <class _It, class _Se>
@@ -2824,7 +2825,7 @@ namespace ranges {
     };
 
     // clang-format off
-    template <class _Derived>
+    _EXPORT_STD template <class _Derived>
         requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
     class view_interface {
     private:
@@ -3034,13 +3035,13 @@ namespace ranges {
 
 // These declarations must be visible to qualified name lookup for _STD get in _Pair_like below, even if <tuple> hasn't
 // yet been included.
-template <size_t _Index, class... _Types>
+_EXPORT_STD template <size_t _Index, class... _Types>
 _NODISCARD constexpr tuple_element_t<_Index, tuple<_Types...>>& get(tuple<_Types...>& _Tuple) noexcept;
-template <size_t _Index, class... _Types>
+_EXPORT_STD template <size_t _Index, class... _Types>
 _NODISCARD constexpr const tuple_element_t<_Index, tuple<_Types...>>& get(const tuple<_Types...>& _Tuple) noexcept;
-template <size_t _Index, class... _Types>
+_EXPORT_STD template <size_t _Index, class... _Types>
 _NODISCARD constexpr tuple_element_t<_Index, tuple<_Types...>>&& get(tuple<_Types...>&& _Tuple) noexcept;
-template <size_t _Index, class... _Types>
+_EXPORT_STD template <size_t _Index, class... _Types>
 _NODISCARD constexpr const tuple_element_t<_Index, tuple<_Types...>>&& get(const tuple<_Types...>&& _Tuple) noexcept;
 
 namespace ranges {
@@ -3097,7 +3098,7 @@ namespace ranges {
     };
 
     // clang-format off
-    template <input_or_output_iterator _It, sentinel_for<_It> _Se, subrange_kind _Ki>
+    _EXPORT_STD template <input_or_output_iterator _It, sentinel_for<_It> _Se, subrange_kind _Ki>
         requires (_Ki == subrange_kind::sized || !sized_sentinel_for<_Se, _It>)
     class subrange : public _Subrange_base<_It, _Se, _Ki> {
         // clang-format on
@@ -3271,7 +3272,7 @@ namespace ranges {
     inline constexpr bool enable_borrowed_range<subrange<_It, _Se, _Ki>> = true;
 
     // clang-format off
-    template <size_t _Idx, class _It, class _Se, subrange_kind _Ki>
+    _EXPORT_STD template <size_t _Idx, class _It, class _Se, subrange_kind _Ki>
         requires ((_Idx == 0 && copyable<_It>) || _Idx == 1)
     _NODISCARD constexpr auto get(const subrange<_It, _Se, _Ki>& _Val) {
         if constexpr (_Idx == 0) {
@@ -3281,7 +3282,7 @@ namespace ranges {
         }
     }
 
-    template <size_t _Idx, class _It, class _Se, subrange_kind _Ki>
+    _EXPORT_STD template <size_t _Idx, class _It, class _Se, subrange_kind _Ki>
         requires (_Idx < 2)
     _NODISCARD constexpr auto get(subrange<_It, _Se, _Ki>&& _Val) {
         if constexpr (_Idx == 0) {
@@ -3292,16 +3293,16 @@ namespace ranges {
     }
     // clang-format on
 
-    struct dangling {
+    _EXPORT_STD struct dangling {
         constexpr dangling() noexcept = default;
         template <class... _Args>
         constexpr dangling(_Args&&...) noexcept {}
     };
 
-    template <range _Rng>
+    _EXPORT_STD template <range _Rng>
     using borrowed_iterator_t = conditional_t<borrowed_range<_Rng>, iterator_t<_Rng>, dangling>;
 
-    template <range _Rng>
+    _EXPORT_STD template <range _Rng>
     using borrowed_subrange_t = conditional_t<borrowed_range<_Rng>, subrange<iterator_t<_Rng>>, dangling>;
 } // namespace ranges
 #endif // __cpp_lib_concepts
@@ -3312,7 +3313,7 @@ struct _Iterator_base12;
 struct _Default_sentinel {}; // empty struct to serve as the end of a range
 
 #ifdef __cpp_lib_concepts
-template <semiregular>
+_EXPORT_STD template <semiregular>
 class move_sentinel;
 
 template <class>
@@ -3333,7 +3334,7 @@ struct _Move_iterator_category {
 };
 #endif // __cpp_lib_concepts
 
-template <class _Iter>
+_EXPORT_STD template <class _Iter>
 class move_iterator : public _Move_iterator_category<_Iter> {
 public:
     using iterator_type   = _Iter;
@@ -3590,7 +3591,7 @@ private:
     iterator_type _Current{};
 };
 
-template <class _Iter1, class _Iter2>
+_EXPORT_STD template <class _Iter1, class _Iter2>
 _NODISCARD _CONSTEXPR17 bool
     operator==(const move_iterator<_Iter1>& _Left, const move_iterator<_Iter2>& _Right) noexcept(
         noexcept(_Fake_copy_init<bool>(_Left.base() == _Right.base()))) /* strengthened */
@@ -3611,7 +3612,7 @@ _NODISCARD _CONSTEXPR17 bool operator!=(const move_iterator<_Iter1>& _Left,
 }
 #endif // !_HAS_CXX20
 
-template <class _Iter1, class _Iter2>
+_EXPORT_STD template <class _Iter1, class _Iter2>
 _NODISCARD _CONSTEXPR17 bool
     operator<(const move_iterator<_Iter1>& _Left, const move_iterator<_Iter2>& _Right) noexcept(
         noexcept(_Fake_copy_init<bool>(_Left.base() < _Right.base()))) /* strengthened */
@@ -3624,7 +3625,7 @@ _NODISCARD _CONSTEXPR17 bool
 #endif // __cpp_lib_concepts
 { return _Left.base() < _Right.base(); }
 
-template <class _Iter1, class _Iter2>
+_EXPORT_STD template <class _Iter1, class _Iter2>
 _NODISCARD _CONSTEXPR17 bool operator>(const move_iterator<_Iter1>& _Left,
     const move_iterator<_Iter2>& _Right) noexcept(noexcept(_Right < _Left)) /* strengthened */
 #ifdef __cpp_lib_concepts
@@ -3634,7 +3635,7 @@ _NODISCARD _CONSTEXPR17 bool operator>(const move_iterator<_Iter1>& _Left,
 #endif // __cpp_lib_concepts
 { return _Right < _Left; }
 
-template <class _Iter1, class _Iter2>
+_EXPORT_STD template <class _Iter1, class _Iter2>
 _NODISCARD _CONSTEXPR17 bool operator<=(const move_iterator<_Iter1>& _Left,
     const move_iterator<_Iter2>& _Right) noexcept(noexcept(_Right < _Left)) /* strengthened */
 #ifdef __cpp_lib_concepts
@@ -3644,7 +3645,7 @@ _NODISCARD _CONSTEXPR17 bool operator<=(const move_iterator<_Iter1>& _Left,
 #endif // __cpp_lib_concepts
 { return !(_Right < _Left); }
 
-template <class _Iter1, class _Iter2>
+_EXPORT_STD template <class _Iter1, class _Iter2>
 _NODISCARD _CONSTEXPR17 bool operator>=(const move_iterator<_Iter1>& _Left,
     const move_iterator<_Iter2>& _Right) noexcept(noexcept(_Left < _Right)) /* strengthened */
 #ifdef __cpp_lib_concepts
@@ -3655,21 +3656,21 @@ _NODISCARD _CONSTEXPR17 bool operator>=(const move_iterator<_Iter1>& _Left,
 { return !(_Left < _Right); }
 
 #ifdef __cpp_lib_concepts
-template <class _Iter1, three_way_comparable_with<_Iter1> _Iter2>
+_EXPORT_STD template <class _Iter1, three_way_comparable_with<_Iter1> _Iter2>
 _NODISCARD constexpr compare_three_way_result_t<_Iter1, _Iter2> operator<=>(const move_iterator<_Iter1>& _Left,
     const move_iterator<_Iter2>& _Right) noexcept(noexcept(_Left.base() <=> _Right.base())) /* strengthened */ {
     return _Left.base() <=> _Right.base();
 }
 #endif // __cpp_lib_concepts
 
-template <class _Iter1, class _Iter2>
+_EXPORT_STD template <class _Iter1, class _Iter2>
 _NODISCARD _CONSTEXPR17 auto operator-(const move_iterator<_Iter1>& _Left,
     const move_iterator<_Iter2>& _Right) noexcept(noexcept(_Left.base() - _Right.base())) /* strengthened */
     -> decltype(_Left.base() - _Right.base()) {
     return _Left.base() - _Right.base();
 }
 
-template <class _Iter>
+_EXPORT_STD template <class _Iter>
 _NODISCARD _CONSTEXPR17 move_iterator<_Iter>
     operator+(typename move_iterator<_Iter>::difference_type _Off, const move_iterator<_Iter>& _Right) noexcept(
         noexcept(move_iterator<_Iter>(_Right.base() + _Off))) /* strengthened */
@@ -3682,18 +3683,18 @@ _NODISCARD _CONSTEXPR17 move_iterator<_Iter>
 #endif // __cpp_lib_concepts
 { return move_iterator<_Iter>(_Right.base() + _Off); }
 
-template <class _Iter>
+_EXPORT_STD template <class _Iter>
 _NODISCARD _CONSTEXPR17 move_iterator<_Iter> make_move_iterator(_Iter _It) noexcept(
     is_nothrow_move_constructible_v<_Iter>) /* strengthened */ {
     return move_iterator<_Iter>(_STD move(_It));
 }
 
 #ifdef __cpp_lib_concepts
-struct default_sentinel_t {};
+_EXPORT_STD struct default_sentinel_t {};
 
-inline constexpr default_sentinel_t default_sentinel{};
+_EXPORT_STD inline constexpr default_sentinel_t default_sentinel{};
 
-struct unreachable_sentinel_t;
+_EXPORT_STD struct unreachable_sentinel_t;
 namespace _Unreachable_sentinel_detail {
     struct _Base {
         template <weakly_incrementable _Winc>
@@ -3702,9 +3703,9 @@ namespace _Unreachable_sentinel_detail {
         }
     };
 } // namespace _Unreachable_sentinel_detail
-struct unreachable_sentinel_t : _Unreachable_sentinel_detail::_Base {}; // TRANSITION, /permissive-
+_EXPORT_STD struct unreachable_sentinel_t : _Unreachable_sentinel_detail::_Base {}; // TRANSITION, /permissive-
 
-inline constexpr unreachable_sentinel_t unreachable_sentinel{};
+_EXPORT_STD inline constexpr unreachable_sentinel_t unreachable_sentinel{};
 #endif // __cpp_lib_concepts
 
 // _Iterator_is_contiguous<_Iter> reports whether an iterator is known to be contiguous.
@@ -3939,7 +3940,7 @@ _CONSTEXPR20 _OutIt _Copy_unchecked(_InIt _First, _Sent _Last, _OutIt _Dest) {
     return _Dest;
 }
 
-template <class _InIt, class _OutIt>
+_EXPORT_STD template <class _InIt, class _OutIt>
 _CONSTEXPR20 _OutIt copy(_InIt _First, _InIt _Last, _OutIt _Dest) { // copy [_First, _Last) to [_Dest, ...)
     _Adl_verify_range(_First, _Last);
     const auto _UFirst = _Get_unwrapped(_First);
@@ -3950,7 +3951,7 @@ _CONSTEXPR20 _OutIt copy(_InIt _First, _InIt _Last, _OutIt _Dest) { // copy [_Fi
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt2 copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest) noexcept /* terminates */ {
     // copy [_First, _Last) to [_Dest, ...)
     // not parallelized as benchmarks show it isn't worth it
@@ -3965,7 +3966,7 @@ namespace ranges {
     template <class _To, class _From>
     concept _Convertible_from = convertible_to<_From, _To>;
 
-    template <class _In, class _Out>
+    _EXPORT_STD template <class _In, class _Out>
     struct in_out_result {
         /* [[no_unique_address]] */ _In in;
         /* [[no_unique_address]] */ _Out out;
@@ -4035,7 +4036,7 @@ namespace ranges {
     }
 
 #if _HAS_CXX23
-    template <class _Out, class _Ty>
+    _EXPORT_STD template <class _Out, class _Ty>
     struct out_value_result {
         /* [[no_unique_address]] */ _Out out;
         /* [[no_unique_address]] */ _Ty value;
@@ -4052,7 +4053,7 @@ namespace ranges {
     };
 #endif // _HAS_CXX23
 
-    template <class _In, class _Out>
+    _EXPORT_STD template <class _In, class _Out>
     using copy_result = in_out_result<_In, _Out>;
 
     // clang-format off
@@ -4108,11 +4109,11 @@ namespace ranges {
         // clang-format on
     };
 
-    inline constexpr _Copy_fn copy{_Not_quite_object::_Construct_tag {}};
+    _EXPORT_STD inline constexpr _Copy_fn copy{_Not_quite_object::_Construct_tag {}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _InIt, class _Diff, class _OutIt>
+_EXPORT_STD template <class _InIt, class _Diff, class _OutIt>
 _CONSTEXPR20 _OutIt copy_n(_InIt _First, _Diff _Count_raw, _OutIt _Dest) {
     // copy [_First, _First + _Count) to [_Dest, ...)
     _Algorithm_int_t<_Diff> _Count = _Count_raw;
@@ -4149,7 +4150,7 @@ _CONSTEXPR20 _OutIt copy_n(_InIt _First, _Diff _Count_raw, _OutIt _Dest) {
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _Diff, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _Diff, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt2 copy_n(_ExPo&&, _FwdIt1 _First, _Diff _Count_raw, _FwdIt2 _Dest) noexcept /* terminates */ {
     // copy [_First, _First + _Count) to [_Dest, ...)
     // not parallelized as benchmarks show it isn't worth it
@@ -4201,7 +4202,7 @@ _NODISCARD _CONSTEXPR20 _BidIt2 _Copy_backward_unchecked(_BidIt1 _First, _BidIt1
     return _Dest;
 }
 
-template <class _BidIt1, class _BidIt2>
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
 _CONSTEXPR20 _BidIt2 copy_backward(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest) {
     // copy [_First, _Last) backwards to [..., _Dest)
     _Adl_verify_range(_First, _Last);
@@ -4232,7 +4233,7 @@ _CONSTEXPR20 _OutIt _Move_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest) {
     return _Dest;
 }
 
-template <class _InIt, class _OutIt>
+_EXPORT_STD template <class _InIt, class _OutIt>
 _CONSTEXPR20 _OutIt move(_InIt _First, _InIt _Last, _OutIt _Dest) {
     // move [_First, _Last) to [_Dest, ...)
     _Adl_verify_range(_First, _Last);
@@ -4244,7 +4245,7 @@ _CONSTEXPR20 _OutIt move(_InIt _First, _InIt _Last, _OutIt _Dest) {
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt2 move(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest) noexcept /* terminates */ {
     // move [_First, _Last) to [_Dest, ...)
     // not parallelized as benchmarks show it isn't worth it
@@ -4274,7 +4275,7 @@ _CONSTEXPR20 _BidIt2 _Move_backward_unchecked(_BidIt1 _First, _BidIt1 _Last, _Bi
     return _Dest;
 }
 
-template <class _BidIt1, class _BidIt2>
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
 _CONSTEXPR20 _BidIt2 move_backward(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest) {
     // move [_First, _Last) backwards to [..., _Dest)
     _Adl_verify_range(_First, _Last);
@@ -4359,7 +4360,7 @@ _NODISCARD bool _Is_all_bits_zero(const _Ty& _Val) {
     }
 }
 
-template <class _FwdIt, class _Ty>
+_EXPORT_STD template <class _FwdIt, class _Ty>
 _CONSTEXPR20 void fill(const _FwdIt _First, const _FwdIt _Last, const _Ty& _Val) {
     // copy _Val through [_First, _Last)
     _Adl_verify_range(_First, _Last);
@@ -4390,7 +4391,7 @@ _CONSTEXPR20 void fill(const _FwdIt _First, const _FwdIt _Last, const _Ty& _Val)
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
 void fill(_ExPo&&, _FwdIt _First, _FwdIt _Last, const _Ty& _Val) noexcept /* terminates */ {
     // copy _Val through [_First, _Last)
     // not parallelized as benchmarks show it isn't worth it
@@ -4399,7 +4400,7 @@ void fill(_ExPo&&, _FwdIt _First, _FwdIt _Last, const _Ty& _Val) noexcept /* ter
 }
 #endif // _HAS_CXX17
 
-template <class _OutIt, class _Diff, class _Ty>
+_EXPORT_STD template <class _OutIt, class _Diff, class _Ty>
 _CONSTEXPR20 _OutIt fill_n(_OutIt _Dest, const _Diff _Count_raw, const _Ty& _Val) {
     // copy _Val _Count times through [_Dest, ...)
     _Algorithm_int_t<_Diff> _Count = _Count_raw;
@@ -4438,7 +4439,7 @@ _CONSTEXPR20 _OutIt fill_n(_OutIt _Dest, const _Diff _Count_raw, const _Ty& _Val
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Diff, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Diff, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt fill_n(_ExPo&&, _FwdIt _Dest, _Diff _Count_raw, const _Ty& _Val) noexcept /* terminates */ {
     // copy _Val _Count times through [_Dest, ...)
     // not parallelized as benchmarks show it isn't worth it
@@ -4482,7 +4483,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Fill_n_fn fill_n{_Not_quite_object::_Construct_tag {}};
+    _EXPORT_STD inline constexpr _Fill_n_fn fill_n{_Not_quite_object::_Construct_tag {}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
@@ -4585,7 +4586,7 @@ _NODISCARD int _Memcmp_count(_CtgIt1 _First1, _CtgIt2 _First2, const size_t _Cou
     return _CSTD memcmp(_First1_ch, _First2_ch, _Count * sizeof(_Iter_value_t<_CtgIt1>));
 }
 
-template <class _InIt1, class _InIt2, class _Pr>
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Pr>
 _NODISCARD _CONSTEXPR20 bool equal(const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, _Pr _Pred) {
     // compare [_First1, _Last1) to [_First2, ...)
     _Adl_verify_range(_First1, _Last1);
@@ -4611,19 +4612,19 @@ _NODISCARD _CONSTEXPR20 bool equal(const _InIt1 _First1, const _InIt1 _Last1, co
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD bool equal(_ExPo&& _Exec, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2,
     _Pr _Pred) noexcept; // terminates
 #endif // _HAS_CXX17
 
-template <class _InIt1, class _InIt2>
+_EXPORT_STD template <class _InIt1, class _InIt2>
 _NODISCARD _CONSTEXPR20 bool equal(const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2) {
     // compare [_First1, _Last1) to [_First2, ...)
     return _STD equal(_First1, _Last1, _First2, equal_to<>{});
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD bool equal(_ExPo&& _Exec, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2) noexcept
 /* terminates */ {
     // compare [_First1, _Last1) to [_First2, ...)
@@ -4631,7 +4632,7 @@ _NODISCARD bool equal(_ExPo&& _Exec, const _FwdIt1 _First1, const _FwdIt1 _Last1
 }
 #endif // _HAS_CXX17
 
-template <class _InIt1, class _InIt2, class _Pr>
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Pr>
 _NODISCARD _CONSTEXPR20 bool equal(
     const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, const _InIt2 _Last2, _Pr _Pred) {
     // compare [_First1, _Last1) to [_First2, _Last2)
@@ -4668,12 +4669,12 @@ _NODISCARD _CONSTEXPR20 bool equal(
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD bool equal(_ExPo&& _Exec, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2,
     const _FwdIt2 _Last2, _Pr _Pred) noexcept; // terminates
 #endif // _HAS_CXX17
 
-template <class _InIt1, class _InIt2>
+_EXPORT_STD template <class _InIt1, class _InIt2>
 _NODISCARD _CONSTEXPR20 bool equal(
     const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, const _InIt2 _Last2) {
     // compare [_First1, _Last1) to [_First2, _Last2)
@@ -4681,7 +4682,7 @@ _NODISCARD _CONSTEXPR20 bool equal(
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD bool equal(_ExPo&& _Exec, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2,
     const _FwdIt2 _Last2) noexcept /* terminates */ {
     // compare [_First1, _Last1) to [_First2, _Last2)
@@ -4704,7 +4705,7 @@ namespace ranges {
         }
     }
 
-    template <class _In1, class _In2>
+    _EXPORT_STD template <class _In1, class _In2>
     struct in_in_result {
         /* [[no_unique_address]] */ _In1 in1;
         /* [[no_unique_address]] */ _In2 in2;
@@ -4720,7 +4721,7 @@ namespace ranges {
         }
     };
 
-    template <class _In1, class _In2>
+    _EXPORT_STD template <class _In1, class _In2>
     using mismatch_result = in_in_result<_In1, _In2>;
 
     // clang-format off
@@ -4826,7 +4827,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Mismatch_fn mismatch{_Not_quite_object::_Construct_tag {}};
+    _EXPORT_STD inline constexpr _Mismatch_fn mismatch{_Not_quite_object::_Construct_tag {}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
@@ -4887,7 +4888,7 @@ using _Lex_compare_memcmp_classify =
     conditional_t<_Iterators_are_contiguous<_It1, _It2> && !_Iterator_is_volatile<_It1> && !_Iterator_is_volatile<_It2>,
         typename _Lex_compare_memcmp_classify_pred<_Iter_value_t<_It1>, _Iter_value_t<_It2>, _Pr>::_Pred, void>;
 
-template <class _InIt1, class _InIt2, class _Pr>
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Pr>
 _NODISCARD _CONSTEXPR20 bool lexicographical_compare(
     const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, const _InIt2 _Last2, _Pr _Pred) {
     // order [_First1, _Last1) vs. [_First2, _Last2)
@@ -4922,7 +4923,7 @@ _NODISCARD _CONSTEXPR20 bool lexicographical_compare(
     return _UFirst1 == _ULast1 && _UFirst2 != _ULast2;
 }
 
-template <class _InIt1, class _InIt2>
+_EXPORT_STD template <class _InIt1, class _InIt2>
 _NODISCARD _CONSTEXPR20 bool lexicographical_compare(
     const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, const _InIt2 _Last2) {
     // order [_First1, _Last1) vs. [_First2, _Last2)
@@ -4930,7 +4931,7 @@ _NODISCARD _CONSTEXPR20 bool lexicographical_compare(
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD bool lexicographical_compare(_ExPo&&, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2,
     const _FwdIt2 _Last2, _Pr _Pred) noexcept /* terminates */ {
     // order [_First1, _Last1) vs. [_First2, _Last2)
@@ -4940,7 +4941,7 @@ _NODISCARD bool lexicographical_compare(_ExPo&&, const _FwdIt1 _First1, const _F
     return _STD lexicographical_compare(_First1, _Last1, _First2, _Last2, _Pass_fn(_Pred));
 }
 
-template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD bool lexicographical_compare(_ExPo&&, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2,
     const _FwdIt2 _Last2) noexcept /* terminates */ {
     // order [_First1, _Last1) vs. [_First2, _Last2)
@@ -4991,7 +4992,7 @@ using _Lex_compare_three_way_memcmp_classify =
         typename _Lex_compare_three_way_memcmp_classify_comp<_Iter_value_t<_It1>, _Iter_value_t<_It2>, _Cmp>::_Comp,
         void>;
 
-template <class _InIt1, class _InIt2, class _Cmp>
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Cmp>
 _NODISCARD constexpr auto lexicographical_compare_three_way(const _InIt1 _First1, const _InIt1 _Last1,
     const _InIt2 _First2, const _InIt2 _Last2, _Cmp _Comp) -> decltype(_Comp(*_First1, *_First2)) {
     _Adl_verify_range(_First1, _Last1);
@@ -5033,7 +5034,7 @@ _NODISCARD constexpr auto lexicographical_compare_three_way(const _InIt1 _First1
     }
 }
 
-template <class _InIt1, class _InIt2>
+_EXPORT_STD template <class _InIt1, class _InIt2>
 _NODISCARD constexpr auto lexicographical_compare_three_way(
     const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, const _InIt2 _Last2) {
     return _STD lexicographical_compare_three_way(_First1, _Last1, _First2, _Last2, compare_three_way{});
@@ -5141,7 +5142,7 @@ _NODISCARD _CONSTEXPR20 _InIt _Find_unchecked(_InIt _First, const _InIt _Last, c
     return _First;
 }
 
-template <class _InIt, class _Ty>
+_EXPORT_STD template <class _InIt, class _Ty>
 _NODISCARD _CONSTEXPR20 _InIt find(_InIt _First, const _InIt _Last, const _Ty& _Val) { // find first matching _Val
     _Adl_verify_range(_First, _Last);
     if constexpr (_Is_vb_iterator<_InIt> && is_same_v<_Ty, bool>) {
@@ -5153,7 +5154,7 @@ _NODISCARD _CONSTEXPR20 _InIt find(_InIt _First, const _InIt _Last, const _Ty& _
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _FwdIt find(_ExPo&& _Exec, _FwdIt _First, const _FwdIt _Last, const _Ty& _Val) noexcept; // terminates
 #endif // _HAS_CXX17
 
@@ -5272,11 +5273,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Find_fn find{_Not_quite_object::_Construct_tag {}};
+    _EXPORT_STD inline constexpr _Find_fn find{_Not_quite_object::_Construct_tag {}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _InIt, class _Ty>
+_EXPORT_STD template <class _InIt, class _Ty>
 _NODISCARD _CONSTEXPR20 _Iter_diff_t<_InIt> count(const _InIt _First, const _InIt _Last, const _Ty& _Val) {
     // count elements that match _Val
     _Adl_verify_range(_First, _Last);
@@ -5315,7 +5316,7 @@ _NODISCARD _CONSTEXPR20 _Iter_diff_t<_InIt> count(const _InIt _First, const _InI
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
 _NODISCARD _Iter_diff_t<_FwdIt> count(
     _ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, const _Ty& _Val) noexcept; // terminates
 #endif // _HAS_CXX17
@@ -5485,7 +5486,7 @@ _NODISCARD _CONSTEXPR20 bool _Check_match_counts(
     return true;
 }
 
-template <class _BidIt>
+_EXPORT_STD template <class _BidIt>
 _CONSTEXPR20 void reverse(const _BidIt _First, const _BidIt _Last) { // reverse elements in [_First, _Last)
     _Adl_verify_range(_First, _Last);
     auto _UFirst = _Get_unwrapped(_First);
@@ -5522,7 +5523,7 @@ _CONSTEXPR20 void reverse(const _BidIt _First, const _BidIt _Last) { // reverse
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _BidIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _BidIt, _Enable_if_execution_policy_t<_ExPo> = 0>
 void reverse(_ExPo&&, _BidIt _First, _BidIt _Last) noexcept /* terminates */ {
     // reverse elements in [_First, _Last)
     // not parallelized as benchmarks show it isn't worth it
@@ -5541,7 +5542,7 @@ constexpr pair<_BidIt, _BidIt> _Reverse_until_sentinel_unchecked(_BidIt _First,
     return pair<_BidIt, _BidIt>(_First, _Last);
 }
 
-template <class _FwdIt>
+_EXPORT_STD template <class _FwdIt>
 _CONSTEXPR20 _FwdIt rotate(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last) {
     // exchange the ranges [_First, _Mid) and [_Mid, _Last)
     // that is, rotates [_First, _Last) left by distance(_First, _Mid) positions
@@ -5598,7 +5599,7 @@ _CONSTEXPR20 _FwdIt rotate(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last) {
 }
 
 #if _HAS_CXX17
-template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_EXPORT_STD template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
 _FwdIt rotate(_ExPo&&, _FwdIt _First, _FwdIt _Mid, _FwdIt _Last) noexcept /* terminates */ {
     // rotate [_First, _Last) left by distance(_First, _Mid) positions
     // not parallelized as benchmarks show it isn't worth it
@@ -5606,7 +5607,7 @@ _FwdIt rotate(_ExPo&&, _FwdIt _First, _FwdIt _Mid, _FwdIt _Last) noexcept /* ter
 }
 #endif // _HAS_CXX17
 
-template <class _InIt, class _Pr>
+_EXPORT_STD template <class _InIt, class _Pr>
 _NODISCARD _CONSTEXPR20 _InIt find_if(_InIt _First, const _InIt _Last, _Pr _Pred) { // find first satisfying _Pred
     _Adl_verify_range(_First, _Last);
     auto _UFirst      = _Get_unwrapped(_First);
@@ -5690,7 +5691,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Find_if_fn find_if{_Not_quite_object::_Construct_tag {}};
+    _EXPORT_STD inline constexpr _Find_if_fn find_if{_Not_quite_object::_Construct_tag {}};
 
     class _Find_if_not_fn : private _Not_quite_object {
     public:
@@ -5737,7 +5738,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Find_if_not_fn find_if_not{_Not_quite_object::_Construct_tag {}};
+    _EXPORT_STD inline constexpr _Find_if_not_fn find_if_not{_Not_quite_object::_Construct_tag {}};
 
     class _Adjacent_find_fn : private _Not_quite_object {
     public:
@@ -5788,7 +5789,7 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Adjacent_find_fn adjacent_find{_Not_quite_object::_Construct_tag {}};
+    _EXPORT_STD inline constexpr _Adjacent_find_fn adjacent_find{_Not_quite_object::_Construct_tag {}};
 
     // clang-format off
     template <class _It1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
@@ -5933,11 +5934,11 @@ namespace ranges {
         }
     };
 
-    inline constexpr _Search_fn search{_Not_quite_object::_Construct_tag {}};
+    _EXPORT_STD inline constexpr _Search_fn search{_Not_quite_object::_Construct_tag {}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
-template <class _FwdIt, class _Ty, class _Pr>
+_EXPORT_STD template <class _FwdIt, class _Ty, class _Pr>
 _NODISCARD _CONSTEXPR20 _FwdIt lower_bound(_FwdIt _First, const _FwdIt _Last, const _Ty& _Val, _Pr _Pred) {
     // find first element not before _Val
     _Adl_verify_range(_First, _Last);
@@ -5959,13 +5960,13 @@ _NODISCARD _CONSTEXPR20 _FwdIt lower_bound(_FwdIt _First, const _FwdIt _Last, co
     return _First;
 }
 
-template <class _FwdIt, class _Ty>
+_EXPORT_STD template <class _FwdIt, class _Ty>
 _NODISCARD _CONSTEXPR20 _FwdIt lower_bound(_FwdIt _First, _FwdIt _Last, const _Ty& _Val) {
     // find first element not before _Val
     return _STD lower_bound(_First, _Last, _Val, less<>{});
 }
 
-template <class _FwdIt, class _Ty, class _Pr>
+_EXPORT_STD template <class _FwdIt, class _Ty, class _Pr>
 _NODISCARD _CONSTEXPR20 _FwdIt upper_bound(_FwdIt _First, _FwdIt _Last, const _Ty& _Val, _Pr _Pred) {
     // find first element that _Val is before
     _Adl_verify_range(_First, _Last);
@@ -5987,7 +5988,7 @@ _NODISCARD _CONSTEXPR20 _FwdIt upper_bound(_FwdIt _First, _FwdIt _Last, const _T
     return _First;
 }
 
-template <class _FwdIt, class _Ty>
+_EXPORT_STD template <class _FwdIt, class _Ty>
 _NODISCARD _CONSTEXPR20 _FwdIt upper_bound(_FwdIt _First, _FwdIt _Last, const _Ty& _Val) {
     // find first element that _Val is before
     return _STD upper_bound(_First, _Last, _Val, less<>{});
@@ -6086,15 +6087,16 @@ private:
     _Udiff _Bmask; // 2^_Bits - 1
 };
 
-[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xbad_alloc();
-[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xinvalid_argument(_In_z_ const char*);
-[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xlength_error(_In_z_ const char*);
-[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xout_of_range(_In_z_ const char*);
-[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xoverflow_error(_In_z_ const char*);
-[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xruntime_error(_In_z_ const char*);
-[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _XGetLastError();
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xbad_alloc();
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xinvalid_argument(_In_z_ const char*);
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xlength_error(_In_z_ const char*);
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xout_of_range(_In_z_ const char*);
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xoverflow_error(_In_z_ const char*);
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xruntime_error(_In_z_ const char*);
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _XGetLastError();
 
-template <class _Category, class _Ty, class _Diff = ptrdiff_t, class _Pointer = _Ty*, class _Reference = _Ty&>
+_EXPORT_STD template <class _Category, class _Ty, class _Diff = ptrdiff_t, class _Pointer = _Ty*,
+    class _Reference = _Ty&>
 struct _CXX17_DEPRECATE_ITERATOR_BASE_CLASS iterator { // base type for iterator classes
     using iterator_category = _Category;
     using value_type        = _Ty;
@@ -6154,7 +6156,7 @@ _NODISCARD constexpr bool _Is_finite(const _Ty _Xx) { // constexpr isfinite()
 }
 
 #if _HAS_CXX17
-struct monostate {};
+_EXPORT_STD struct monostate {};
 #endif // _HAS_CXX17
 
 _STD_END
diff --git a/stl/inc/yvals.h b/stl/inc/yvals.h
index 2b7c434afa..0b34b704da 100644
--- a/stl/inc/yvals.h
+++ b/stl/inc/yvals.h
@@ -348,7 +348,7 @@ enum _Uninitialized { // tag for suppressing initialization
     _Noinit
 };
 
-class _CRTIMP2_PURE_IMPORT _Lockit { // lock while object in existence -- MUST NEST
+extern "C++" class _CRTIMP2_PURE_IMPORT _Lockit { // lock while object in existence -- MUST NEST
 public:
 #ifdef _M_CEE_PURE
     __CLR_OR_THIS_CALL _Lockit() noexcept : _Locktype(0) {
diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h
index c453b81381..81990761b2 100644
--- a/stl/inc/yvals_core.h
+++ b/stl/inc/yvals_core.h
@@ -335,6 +335,7 @@
 // P2443R1 views::chunk_by
 // P2445R1 forward_like()
 // P2446R2 views::as_rvalue
+// P2465R3 Standard Library Modules std And std.compat
 // P2494R2 Relaxing Range Adaptors To Allow Move-Only Types
 // P2499R0 string_view Range Constructor Should Be explicit
 // P2549R1 unexpected<E>::error()
@@ -824,6 +825,13 @@ _EMIT_STL_ERROR(STL1001, "Unexpected compiler version, expected MSVC 19.34 or ne
 #define _CONSTEXPR23 inline
 #endif // ^^^ inline (not constexpr) in C++20 and earlier ^^^
 
+// P2465R3 Standard Library Modules std And std.compat
+#if _HAS_CXX23 && defined(_BUILD_STD_MODULE)
+#define _EXPORT_STD export
+#else // _HAS_CXX23 && defined(_BUILD_STD_MODULE)
+#define _EXPORT_STD
+#endif // _HAS_CXX23 && defined(_BUILD_STD_MODULE)
+
 // P0607R0 Inline Variables For The STL
 #if _HAS_CXX17
 #define _INLINE_VAR inline
@@ -1625,9 +1633,14 @@ _EMIT_STL_ERROR(STL1004, "C++98 unexpected() is incompatible with C++23 unexpect
 #define __cpp_lib_expected          202202L
 #endif // __cpp_lib_concepts
 
-#define __cpp_lib_forward_like       202207L
-#define __cpp_lib_invoke_r           202106L
-#define __cpp_lib_is_scoped_enum     202011L
+#define __cpp_lib_forward_like   202207L
+#define __cpp_lib_invoke_r       202106L
+#define __cpp_lib_is_scoped_enum 202011L
+
+#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, Clang and EDG support for modules
+#define __cpp_lib_modules 202207L
+#endif // !defined(__clang__) && !defined(__EDG__)
+
 #define __cpp_lib_move_only_function 202110L
 
 #ifdef __cpp_lib_concepts
diff --git a/stl/modules/std.compat.ixx b/stl/modules/std.compat.ixx
new file mode 100644
index 0000000000..a44c414941
--- /dev/null
+++ b/stl/modules/std.compat.ixx
@@ -0,0 +1,533 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+export module std.compat;
+
+export import std;
+
+// "C++ headers for C library facilities" [tab:headers.cpp.c]
+
+// <cassert>
+// Nothing to do, only macros.
+
+// <cctype>
+export using std::isalnum;
+export using std::isalpha;
+export using std::isblank;
+export using std::iscntrl;
+export using std::isdigit;
+export using std::isgraph;
+export using std::islower;
+export using std::isprint;
+export using std::ispunct;
+export using std::isspace;
+export using std::isupper;
+export using std::isxdigit;
+export using std::tolower;
+export using std::toupper;
+
+// <cerrno>
+// Nothing to do, only macros.
+
+// <cfenv>
+export using std::fenv_t;
+export using std::fexcept_t;
+export using std::feclearexcept;
+export using std::fegetexceptflag;
+export using std::feraiseexcept;
+export using std::fesetexceptflag;
+export using std::fetestexcept;
+export using std::fegetround;
+export using std::fesetround;
+export using std::fegetenv;
+export using std::feholdexcept;
+export using std::fesetenv;
+export using std::feupdateenv;
+
+// <cfloat>
+// Nothing to do, only macros.
+
+// <cinttypes>
+export using std::imaxdiv_t;
+export using std::imaxabs;
+export using std::imaxdiv;
+export using std::strtoimax;
+export using std::strtoumax;
+export using std::wcstoimax;
+export using std::wcstoumax;
+
+// <climits>
+// Nothing to do, only macros.
+
+// <clocale>
+export using std::lconv;
+export using std::setlocale;
+export using std::localeconv;
+
+// <cmath>
+export using std::float_t;
+export using std::double_t;
+export using std::acos;
+export using std::acosf;
+export using std::acosl;
+export using std::asin;
+export using std::asinf;
+export using std::asinl;
+export using std::atan;
+export using std::atanf;
+export using std::atanl;
+export using std::atan2;
+export using std::atan2f;
+export using std::atan2l;
+export using std::cos;
+export using std::cosf;
+export using std::cosl;
+export using std::sin;
+export using std::sinf;
+export using std::sinl;
+export using std::tan;
+export using std::tanf;
+export using std::tanl;
+export using std::acosh;
+export using std::acoshf;
+export using std::acoshl;
+export using std::asinh;
+export using std::asinhf;
+export using std::asinhl;
+export using std::atanh;
+export using std::atanhf;
+export using std::atanhl;
+export using std::cosh;
+export using std::coshf;
+export using std::coshl;
+export using std::sinh;
+export using std::sinhf;
+export using std::sinhl;
+export using std::tanh;
+export using std::tanhf;
+export using std::tanhl;
+export using std::exp;
+export using std::expf;
+export using std::expl;
+export using std::exp2;
+export using std::exp2f;
+export using std::exp2l;
+export using std::expm1;
+export using std::expm1f;
+export using std::expm1l;
+export using std::frexp;
+export using std::frexpf;
+export using std::frexpl;
+export using std::ilogb;
+export using std::ilogbf;
+export using std::ilogbl;
+export using std::ldexp;
+export using std::ldexpf;
+export using std::ldexpl;
+export using std::log;
+export using std::logf;
+export using std::logl;
+export using std::log10;
+export using std::log10f;
+export using std::log10l;
+export using std::log1p;
+export using std::log1pf;
+export using std::log1pl;
+export using std::log2;
+export using std::log2f;
+export using std::log2l;
+export using std::logb;
+export using std::logbf;
+export using std::logbl;
+export using std::modf;
+export using std::modff;
+export using std::modfl;
+export using std::scalbn;
+export using std::scalbnf;
+export using std::scalbnl;
+export using std::scalbln;
+export using std::scalblnf;
+export using std::scalblnl;
+export using std::cbrt;
+export using std::cbrtf;
+export using std::cbrtl;
+export using std::abs;
+export using std::fabs;
+export using std::fabsf;
+export using std::fabsl;
+export using std::_Binary_hypot::hypot; // export only C's hypot(x, y), not C++'s hypot(x, y, z)
+export using std::hypotf;
+export using std::hypotl;
+export using std::pow;
+export using std::powf;
+export using std::powl;
+export using std::sqrt;
+export using std::sqrtf;
+export using std::sqrtl;
+export using std::erf;
+export using std::erff;
+export using std::erfl;
+export using std::erfc;
+export using std::erfcf;
+export using std::erfcl;
+export using std::lgamma;
+export using std::lgammaf;
+export using std::lgammal;
+export using std::tgamma;
+export using std::tgammaf;
+export using std::tgammal;
+export using std::ceil;
+export using std::ceilf;
+export using std::ceill;
+export using std::floor;
+export using std::floorf;
+export using std::floorl;
+export using std::nearbyint;
+export using std::nearbyintf;
+export using std::nearbyintl;
+export using std::rint;
+export using std::rintf;
+export using std::rintl;
+export using std::lrint;
+export using std::lrintf;
+export using std::lrintl;
+export using std::llrint;
+export using std::llrintf;
+export using std::llrintl;
+export using std::round;
+export using std::roundf;
+export using std::roundl;
+export using std::lround;
+export using std::lroundf;
+export using std::lroundl;
+export using std::llround;
+export using std::llroundf;
+export using std::llroundl;
+export using std::trunc;
+export using std::truncf;
+export using std::truncl;
+export using std::fmod;
+export using std::fmodf;
+export using std::fmodl;
+export using std::remainder;
+export using std::remainderf;
+export using std::remainderl;
+export using std::remquo;
+export using std::remquof;
+export using std::remquol;
+export using std::copysign;
+export using std::copysignf;
+export using std::copysignl;
+export using std::nan;
+export using std::nanf;
+export using std::nanl;
+export using std::nextafter;
+export using std::nextafterf;
+export using std::nextafterl;
+export using std::nexttoward;
+export using std::nexttowardf;
+export using std::nexttowardl;
+export using std::fdim;
+export using std::fdimf;
+export using std::fdiml;
+export using std::fmax;
+export using std::fmaxf;
+export using std::fmaxl;
+export using std::fmin;
+export using std::fminf;
+export using std::fminl;
+export using std::fma;
+export using std::fmaf;
+export using std::fmal;
+export using std::fpclassify;
+export using std::isfinite;
+export using std::isinf;
+export using std::isnan;
+export using std::isnormal;
+export using std::signbit;
+export using std::isgreater;
+export using std::isgreaterequal;
+export using std::isless;
+export using std::islessequal;
+export using std::islessgreater;
+export using std::isunordered;
+
+// <csetjmp>
+export using std::jmp_buf;
+export using std::longjmp;
+
+// <csignal>
+export using std::sig_atomic_t;
+export using std::signal;
+export using std::raise;
+
+// <cstdarg>
+export using std::va_list;
+
+// <cstddef>
+export using std::ptrdiff_t;
+export using std::size_t;
+export using std::max_align_t;
+export using std::nullptr_t; // added to the C Standard Library in C23
+
+// <cstdint>
+export using std::int8_t;
+export using std::int16_t;
+export using std::int32_t;
+export using std::int64_t;
+export using std::int_fast8_t;
+export using std::int_fast16_t;
+export using std::int_fast32_t;
+export using std::int_fast64_t;
+export using std::int_least8_t;
+export using std::int_least16_t;
+export using std::int_least32_t;
+export using std::int_least64_t;
+export using std::intmax_t;
+export using std::intptr_t;
+export using std::uint8_t;
+export using std::uint16_t;
+export using std::uint32_t;
+export using std::uint64_t;
+export using std::uint_fast8_t;
+export using std::uint_fast16_t;
+export using std::uint_fast32_t;
+export using std::uint_fast64_t;
+export using std::uint_least8_t;
+export using std::uint_least16_t;
+export using std::uint_least32_t;
+export using std::uint_least64_t;
+export using std::uintmax_t;
+export using std::uintptr_t;
+
+// <cstdio>
+// already exported std::size_t, see <cstddef>
+export using std::FILE;
+export using std::fpos_t;
+export using std::remove;
+export using std::rename;
+export using std::tmpfile;
+export using std::tmpnam;
+export using std::fclose;
+export using std::fflush;
+export using std::fopen;
+export using std::freopen;
+export using std::setbuf;
+export using std::setvbuf;
+export using std::fprintf;
+export using std::fscanf;
+export using std::printf;
+export using std::scanf;
+export using std::snprintf;
+export using std::sprintf;
+export using std::sscanf;
+export using std::vfprintf;
+export using std::vfscanf;
+export using std::vprintf;
+export using std::vscanf;
+export using std::vsnprintf;
+export using std::vsprintf;
+export using std::vsscanf;
+export using std::fgetc;
+export using std::fgets;
+export using std::fputc;
+export using std::fputs;
+export using std::getc;
+export using std::getchar;
+export using std::putc;
+export using std::putchar;
+export using std::puts;
+export using std::ungetc;
+export using std::fread;
+export using std::fwrite;
+export using std::fgetpos;
+export using std::fseek;
+export using std::fsetpos;
+export using std::ftell;
+export using std::rewind;
+export using std::clearerr;
+export using std::feof;
+export using std::ferror;
+export using std::perror;
+
+// <cstdlib>
+// already exported std::size_t, see <cstddef>
+export using std::div_t;
+export using std::ldiv_t;
+export using std::lldiv_t;
+export using std::abort;
+export using std::atexit;
+export using std::at_quick_exit;
+export using std::exit;
+export using std::_Exit;
+export using std::quick_exit;
+export using std::getenv;
+export using std::system;
+export using std::calloc;
+export using std::free;
+export using std::malloc;
+export using std::realloc;
+export using std::atof;
+export using std::atoi;
+export using std::atol;
+export using std::atoll;
+export using std::strtod;
+export using std::strtof;
+export using std::strtold;
+export using std::strtol;
+export using std::strtoll;
+export using std::strtoul;
+export using std::strtoull;
+export using std::mblen;
+export using std::mbtowc;
+export using std::wctomb;
+export using std::mbstowcs;
+export using std::wcstombs;
+export using std::bsearch;
+export using std::qsort;
+export using std::rand;
+export using std::srand;
+// already exported std::abs, see <cmath>
+export using std::labs;
+export using std::llabs;
+export using std::div;
+export using std::ldiv;
+export using std::lldiv;
+
+// <cstring>
+// already exported std::size_t, see <cstddef>
+export using std::memcpy;
+export using std::memmove;
+export using std::strcpy;
+export using std::strncpy;
+export using std::strcat;
+export using std::strncat;
+export using std::memcmp;
+export using std::strcmp;
+export using std::strcoll;
+export using std::strncmp;
+export using std::strxfrm;
+export using std::memchr;
+export using std::strchr;
+export using std::strcspn;
+export using std::strpbrk;
+export using std::strrchr;
+export using std::strspn;
+export using std::strstr;
+export using std::strtok;
+export using std::memset;
+export using std::strerror;
+export using std::strlen;
+
+// <ctime>
+// already exported std::size_t, see <cstddef>
+export using std::clock_t;
+export using std::time_t;
+export using std::timespec;
+export using std::tm;
+export using std::clock;
+export using std::difftime;
+export using std::mktime;
+export using std::time;
+export using std::timespec_get;
+export using std::asctime;
+export using std::ctime;
+export using std::gmtime;
+export using std::localtime;
+export using std::strftime;
+
+// <cuchar>
+export using std::mbstate_t;
+// already exported std::size_t, see <cstddef>
+export using std::mbrtoc16;
+export using std::c16rtomb;
+export using std::mbrtoc32;
+export using std::c32rtomb;
+
+// <cwchar>
+// already exported std::size_t, see <cstddef>
+// already exported std::mbstate_t, see <cuchar>
+export using std::wint_t;
+// already exported std::tm, see <ctime>
+export using std::fwprintf;
+export using std::fwscanf;
+export using std::swprintf;
+export using std::swscanf;
+export using std::vfwprintf;
+export using std::vfwscanf;
+export using std::vswprintf;
+export using std::vswscanf;
+export using std::vwprintf;
+export using std::vwscanf;
+export using std::wprintf;
+export using std::wscanf;
+export using std::fgetwc;
+export using std::fgetws;
+export using std::fputwc;
+export using std::fputws;
+export using std::fwide;
+export using std::getwc;
+export using std::getwchar;
+export using std::putwc;
+export using std::putwchar;
+export using std::ungetwc;
+export using std::wcstod;
+export using std::wcstof;
+export using std::wcstold;
+export using std::wcstol;
+export using std::wcstoll;
+export using std::wcstoul;
+export using std::wcstoull;
+export using std::wcscpy;
+export using std::wcsncpy;
+export using std::wmemcpy;
+export using std::wmemmove;
+export using std::wcscat;
+export using std::wcsncat;
+export using std::wcscmp;
+export using std::wcscoll;
+export using std::wcsncmp;
+export using std::wcsxfrm;
+export using std::wmemcmp;
+export using std::wcschr;
+export using std::wcscspn;
+export using std::wcspbrk;
+export using std::wcsrchr;
+export using std::wcsspn;
+export using std::wcsstr;
+export using std::wcstok;
+export using std::wmemchr;
+export using std::wcslen;
+export using std::wmemset;
+export using std::wcsftime;
+export using std::btowc;
+export using std::wctob;
+export using std::mbsinit;
+export using std::mbrlen;
+export using std::mbrtowc;
+export using std::wcrtomb;
+export using std::mbsrtowcs;
+export using std::wcsrtombs;
+
+// <cwctype>
+// already exported std::wint_t, see <cwchar>
+export using std::wctrans_t;
+export using std::wctype_t;
+export using std::iswalnum;
+export using std::iswalpha;
+export using std::iswblank;
+export using std::iswcntrl;
+export using std::iswdigit;
+export using std::iswgraph;
+export using std::iswlower;
+export using std::iswprint;
+export using std::iswpunct;
+export using std::iswspace;
+export using std::iswupper;
+export using std::iswxdigit;
+export using std::iswctype;
+export using std::wctype;
+export using std::towlower;
+export using std::towupper;
+export using std::towctrans;
+export using std::wctrans;
diff --git a/stl/modules/std.ixx b/stl/modules/std.ixx
new file mode 100644
index 0000000000..30f8c0839a
--- /dev/null
+++ b/stl/modules/std.ixx
@@ -0,0 +1,143 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// This named module expects to be built with classic headers, not header units.
+#define _BUILD_STD_MODULE
+
+module;
+
+// The subset of "C headers" [tab:c.headers] corresponding to
+// the "C++ headers for C library facilities" [tab:headers.cpp.c]
+#include <assert.h>
+#include <ctype.h>
+#include <errno.h>
+#include <fenv.h>
+#include <float.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <locale.h>
+#include <math.h>
+#include <setjmp.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <uchar.h>
+#include <wchar.h>
+#include <wctype.h>
+
+export module std;
+
+#pragma warning(push)
+#pragma warning(disable : 5244) // '#include <meow>' in the purview of module 'std' appears erroneous.
+
+// "C++ library headers" [tab:headers.cpp]
+#include <algorithm>
+#include <any>
+#include <array>
+#include <atomic>
+#include <barrier>
+#include <bit>
+#include <bitset>
+#include <charconv>
+#include <chrono>
+#include <codecvt>
+#include <compare>
+#include <complex>
+#include <concepts>
+#include <condition_variable>
+#include <coroutine>
+#include <deque>
+#include <exception>
+#include <execution>
+#include <expected>
+#include <filesystem>
+#include <format>
+#include <forward_list>
+#include <fstream>
+#include <functional>
+#include <future>
+#include <initializer_list>
+#include <iomanip>
+#include <ios>
+#include <iosfwd>
+#include <iostream>
+#include <istream>
+#include <iterator>
+#include <latch>
+#include <limits>
+#include <list>
+#include <locale>
+#include <map>
+#include <memory>
+#include <memory_resource>
+#include <mutex>
+#include <new>
+#include <numbers>
+#include <numeric>
+#include <optional>
+#include <ostream>
+#include <queue>
+#include <random>
+#include <ranges>
+#include <ratio>
+#include <regex>
+#include <scoped_allocator>
+#include <semaphore>
+#include <set>
+#include <shared_mutex>
+#include <source_location>
+#include <span>
+#include <spanstream>
+#include <sstream>
+#include <stack>
+#include <stacktrace>
+#include <stdexcept>
+#include <stop_token>
+#include <streambuf>
+#include <string>
+#include <string_view>
+#include <strstream>
+#include <syncstream>
+#include <system_error>
+#include <thread>
+#include <tuple>
+#include <type_traits>
+#include <typeindex>
+#include <typeinfo>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <valarray>
+#include <variant>
+#include <vector>
+#include <version>
+
+// "C++ headers for C library facilities" [tab:headers.cpp.c]
+#include <cassert>
+#include <cctype>
+#include <cerrno>
+#include <cfenv>
+#include <cfloat>
+#include <cinttypes>
+#include <climits>
+#include <clocale>
+#include <cmath>
+#include <csetjmp>
+#include <csignal>
+#include <cstdarg>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+#include <cuchar>
+#include <cwchar>
+#include <cwctype>
+
+#pragma warning(pop)
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 76a64ab60d..6a0b6858af 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -6,6 +6,7 @@ set(STL_SOURCE_DIR "${PROJECT_SOURCE_DIR}")
 set(STL_TEST_OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}")
 set(STL_TEST_UTILS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/utils")
 set(STL_TESTED_HEADERS_DIR "${STL_BUILD_ROOT}/inc")
+set(STL_TESTED_MODULES_DIR "${STL_BUILD_ROOT}/modules")
 
 set(LLVM_PROJECT_SOURCE_DIR "${STL_SOURCE_DIR}/llvm-project" CACHE PATH
     "Location of the llvm-project source tree")
diff --git a/tests/std/include/force_include.hpp b/tests/std/include/force_include.hpp
index a6b97782ff..e4cf52a9f6 100644
--- a/tests/std/include/force_include.hpp
+++ b/tests/std/include/force_include.hpp
@@ -26,6 +26,10 @@ struct TestEnvironmentPreparer {
         // set stdout to be unbuffered; see GH-789
         setvbuf(stdout, nullptr, _IONBF, 0);
     }
+
+    [[nodiscard]] bool succeeded() const noexcept {
+        return true;
+    }
 };
 
 const TestEnvironmentPreparer test_environment_preparer{};
diff --git a/tests/std/include/test_header_units_and_modules.hpp b/tests/std/include/test_header_units_and_modules.hpp
new file mode 100644
index 0000000000..8d4c700913
--- /dev/null
+++ b/tests/std/include/test_header_units_and_modules.hpp
@@ -0,0 +1,1084 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// ****************************************************************************************************
+// THIS FILE IS SPECIAL!
+// Don't import or include anything here.
+// This is order-dependent. It assumes that the STL has been imported and <assert.h> has been included.
+// This is not a true header file. It doesn't need `#pragma once` or `inline`.
+// ****************************************************************************************************
+
+void test_algorithm() {
+    using namespace std;
+    puts("Testing <algorithm>.");
+    constexpr int arr[]{11, 0, 22, 0, 33, 0, 44, 0, 55};
+    assert(count(begin(arr), end(arr), 0) == 4);
+    assert(ranges::count(arr, 0) == 4);
+    static_assert(count(begin(arr), end(arr), 0) == 4);
+    static_assert(ranges::count(arr, 0) == 4);
+}
+
+void test_any() {
+    using namespace std;
+    puts("Testing <any>.");
+    any a1{1729};
+    any a2{7.5};
+    a1.swap(a2);
+    assert(any_cast<double>(a1) == 7.5);
+    assert(any_cast<int>(a2) == 1729);
+}
+
+void test_array() {
+    using namespace std;
+    puts("Testing <array>.");
+    constexpr array arr{10, 20, 30, 40, 50};
+    assert(arr[2] == 30);
+    static_assert(arr[2] == 30);
+}
+
+void test_atomic() {
+    using namespace std;
+    puts("Testing <atomic>.");
+    atomic<int> atom{1729};
+    assert(atom.load() == 1729);
+    ++atom;
+    assert(atom.load() == 1730);
+    static_assert(atomic<int>::is_always_lock_free); // implementation-defined
+}
+
+void test_barrier() {
+    using namespace std;
+    puts("Testing <barrier>.");
+    static_assert(barrier<>::max() >= 5);
+    barrier b{2};
+    atomic<int> atom{0};
+    thread t1{[&] {
+        for (int i = 0; i < 5; ++i) {
+            auto token = b.arrive();
+            b.wait(move(token));
+            atom.fetch_add(1, memory_order_relaxed);
+        }
+    }};
+    thread t2{[&] {
+        for (int i = 0; i < 3; ++i) {
+            b.arrive_and_wait();
+            atom.fetch_add(1, memory_order_relaxed);
+        }
+        b.arrive_and_drop();
+    }};
+    t1.join();
+    t2.join();
+    assert(atom.load(memory_order_relaxed) == 8);
+}
+
+void test_bit() {
+    using namespace std;
+    puts("Testing <bit>.");
+    assert(popcount(0x1234ABCDu) == 15);
+    static_assert(popcount(0x1234ABCDu) == 15);
+}
+
+void test_bitset() {
+    using namespace std;
+    puts("Testing <bitset>.");
+    constexpr bitset<32> b{0x1234ABCDu};
+    assert(b[3] && b[2] && !b[1] && b[0]);
+    static_assert(b[3] && b[2] && !b[1] && b[0]);
+}
+
+void test_charconv() {
+    using namespace std;
+    puts("Testing <charconv>.");
+    char buf[4]{};
+    const to_chars_result result = to_chars(buf, end(buf), 3.14);
+    assert(result.ec == errc{});
+    assert(result.ptr == end(buf));
+    const string_view sv{buf, size(buf)};
+    assert(sv == "3.14");
+}
+
+void test_chrono() {
+    using namespace std;
+    puts("Testing <chrono>.");
+    constexpr chrono::seconds dur = 3min;
+    assert(dur.count() == 180);
+    static_assert(dur.count() == 180);
+}
+
+#pragma warning(push)
+#pragma warning(disable : 4996) // was declared deprecated
+void test_codecvt() {
+    using namespace std;
+    puts("Testing <codecvt>.");
+    const string utf8_koshka_cat{"\xD0\xBA\xD0\xBE\xD1\x88\xD0\xBA\xD0\xB0_\xF0\x9F\x90\x88"};
+    const wstring utf16_koshka_cat{L"\x043A\x043E\x0448\x043A\x0430_\xD83D\xDC08"};
+    wstring_convert<codecvt_utf8_utf16<wchar_t>> conv;
+    assert(conv.from_bytes(utf8_koshka_cat) == utf16_koshka_cat);
+    assert(conv.to_bytes(utf16_koshka_cat) == utf8_koshka_cat);
+
+    static_assert(static_cast<int>(codecvt_mode::consume_header) == 4);
+}
+#pragma warning(pop)
+
+void test_compare() {
+    using namespace std;
+    puts("Testing <compare>.");
+    assert(is_lt(10 <=> 20));
+    static_assert(is_lt(10 <=> 20));
+}
+
+void test_complex() {
+    using namespace std;
+    puts("Testing <complex>.");
+    constexpr complex<double> c{3.0, 4.0};
+    assert(norm(c) == 25.0);
+    static_assert(norm(c) == 25.0);
+}
+
+void test_concepts() {
+    using namespace std;
+    puts("Testing <concepts>.");
+    static_assert(signed_integral<short>);
+    static_assert(!signed_integral<unsigned short>);
+    static_assert(!signed_integral<double>);
+}
+
+void test_condition_variable() {
+    using namespace std;
+    puts("Testing <condition_variable>.");
+    condition_variable cv;
+    mutex mut;
+    vector<int> vec = {5};
+
+    thread odd{[&cv, &mut, &vec] {
+        unique_lock<mutex> lk{mut};
+
+        while (vec.size() < 6) {
+            cv.wait(lk, [&vec] { return vec.size() % 2 == 1; });
+            const int n = vec.back();
+            vec.push_back(n * 10 + 1);
+            cv.notify_one();
+        }
+    }};
+
+    thread even{[&cv, &mut, &vec] {
+        unique_lock<mutex> lk{mut};
+
+        while (vec.size() < 7) {
+            cv.wait(lk, [&vec] { return vec.size() % 2 == 0; });
+            const int n = vec.back();
+            vec.push_back(n * 10 + 2);
+            cv.notify_one();
+        }
+    }};
+
+    odd.join();
+    even.join();
+
+    const vector<int> expected_val = {5, 51, 512, 5121, 51212, 512121, 5121212};
+    assert(vec == expected_val);
+
+    static_assert(static_cast<int>(cv_status::no_timeout) == 0);
+    static_assert(static_cast<int>(cv_status::timeout) == 1);
+}
+
+void test_coroutine() {
+    using namespace std;
+    puts("Testing <coroutine>.");
+    constexpr coroutine_handle<> handle{};
+    assert(handle.address() == nullptr);
+    static_assert(handle.address() == nullptr);
+}
+
+void test_deque() {
+    using namespace std;
+    puts("Testing <deque>.");
+    const deque<int> d{10, 20, 30, 40, 50};
+    assert(d[2] == 30);
+}
+
+void test_exception() {
+    using namespace std;
+    puts("Testing <exception>.");
+    assert(uncaught_exceptions() == 0);
+    const exception_ptr ep = current_exception();
+    assert(!ep);
+}
+
+void test_execution() {
+    using namespace std;
+    puts("Testing <execution>.");
+    constexpr int arr[]{11, 0, 22, 0, 33, 0, 44, 0, 55};
+    assert(count(execution::par, begin(arr), end(arr), 0) == 4);
+}
+
+void test_expected() {
+    using namespace std;
+    puts("Testing <expected>.");
+    constexpr expected<double, int> test{unexpect, 42};
+    assert(test.error() == 42);
+}
+
+void test_filesystem() {
+    using namespace std;
+    puts("Testing <filesystem>.");
+    constexpr wstring_view dot{L"."};
+    error_code ec{};
+    const filesystem::space_info info = filesystem::space(dot, ec);
+    assert(!ec);
+    assert(info.capacity > 0);
+    assert(info.capacity != static_cast<decltype(info.capacity)>(-1));
+}
+
+void test_format() {
+    using namespace std;
+    puts("Testing <format>.");
+    assert(format("{} {}", 1729, "kittens") == "1729 kittens");
+    assert(format(L"{} {}", 1729, L"kittens") == L"1729 kittens");
+}
+
+void test_forward_list() {
+    using namespace std;
+    puts("Testing <forward_list>.");
+    const forward_list<int> fl{10, 20, 30, 40, 50};
+    assert(*next(fl.begin(), 2) == 30);
+}
+
+void test_fstream() {
+    using namespace std;
+    puts("Testing <fstream>.");
+    const ifstream f{};
+    assert(!f.is_open());
+}
+
+void test_functional() {
+    using namespace std;
+    puts("Testing <functional>.");
+    function<int(int, int)> f{multiplies{}};
+    assert(f(3, 5) == 15);
+    f = [](int x, int y) { return x * 100 + y * 10; };
+    assert(f(3, 5) == 350);
+    constexpr auto b = bind(multiplies{}, placeholders::_1, 11);
+    assert(b(3) == 33);
+    static_assert(b(3) == 33);
+}
+
+void test_future() {
+    using namespace std;
+    puts("Testing <future>.");
+    promise<int> p{};
+    future<int> f{p.get_future()};
+    assert(f.wait_for(0s) == future_status::timeout);
+    p.set_value(1729);
+    assert(f.wait_for(0s) == future_status::ready);
+    assert(f.get() == 1729);
+}
+
+void test_initializer_list() {
+    using namespace std;
+    puts("Testing <initializer_list>.");
+    const initializer_list<int> il{10, 20, 30, 40, 50};
+    assert(il.begin()[2] == 30);
+}
+
+void test_iomanip() {
+    using namespace std;
+    puts("Testing <iomanip>.");
+    ostringstream oss;
+    oss << "I have " << setfill('.') << setw(7) << 9 * 9 * 9 + 10 * 10 * 10 << " cute fluffy kittens.";
+    assert(oss.str() == "I have ...1729 cute fluffy kittens.");
+    oss.str("");
+    oss << quoted(R"(Read "C:\Temp\Cat Names.txt" for more info.)");
+    const char* const expected_quoted = R"("Read \"C:\\Temp\\Cat Names.txt\" for more info.")";
+    assert(oss.str() == expected_quoted);
+}
+
+void test_ios() {
+    using namespace std;
+    puts("Testing <ios>.");
+    ios b{nullptr};
+    assert(b.rdbuf() == nullptr);
+    assert(b.rdstate() == ios_base::badbit);
+    assert(b.precision() == 6);
+    static_assert(ios_base::floatfield == (ios_base::fixed | ios_base::scientific));
+}
+
+void test_iosfwd() {
+    using namespace std;
+    puts("Testing <iosfwd>.");
+    static_assert(is_same_v<istream, basic_istream<char>>);
+    static_assert(is_same_v<wostream, basic_ostream<wchar_t>>);
+}
+
+void test_iostream() {
+    using namespace std;
+    puts("Testing <iostream>.");
+    cout << "Testing cout.\n";
+    assert(cin.tie() == &cout);
+}
+
+void test_istream() {
+    using namespace std;
+    puts("Testing <istream>.");
+    const istream is{nullptr};
+    assert(is.gcount() == 0);
+}
+
+void test_iterator() {
+    using namespace std;
+    puts("Testing <iterator>.");
+    constexpr int arr[]{10, 20, 30, 40, 50};
+    constexpr reverse_iterator<const int*> ri{end(arr)};
+    assert(*ri == 50);
+    assert(*next(ri) == 40);
+    static_assert(*ri == 50);
+    static_assert(*next(ri) == 40);
+}
+
+void test_latch() {
+    using namespace std;
+    puts("Testing <latch>.");
+    static_assert(latch::max() >= 5);
+    for (const auto& release_wait : {true, false}) {
+        latch l{5};
+        thread t1{[&] { l.wait(); }};
+        thread t2{[&] { l.arrive_and_wait(2); }};
+        l.count_down();
+        if (release_wait) {
+            l.arrive_and_wait(2);
+        } else {
+            l.count_down(2);
+        }
+        t1.join();
+        t2.join();
+    }
+}
+
+void test_limits() {
+    using namespace std;
+    puts("Testing <limits>.");
+    static_assert(numeric_limits<short>::min() == -32768);
+    static_assert(numeric_limits<short>::max() == 32767);
+}
+
+void test_list() {
+    using namespace std;
+    puts("Testing <list>.");
+    const list<int> l{10, 20, 30, 40, 50};
+    assert(*next(l.begin(), 2) == 30);
+}
+
+void test_locale() {
+    using namespace std;
+    puts("Testing <locale>.");
+    locale loc{};
+    assert(isdigit('1', loc));
+    assert(!isdigit('a', loc));
+    using L = locale;
+    static_assert((L::collate | L::ctype | L::monetary | L::numeric | L::time | L::messages | L::all) == L::all);
+}
+
+void test_map() {
+    using namespace std;
+    puts("Testing <map>.");
+    map<int, int> m{{10, 11}, {20, 22}, {30, 33}, {40, 44}, {50, 55}};
+    assert(m[30] == 33);
+}
+
+void test_memory() {
+    using namespace std;
+    puts("Testing <memory>.");
+    unique_ptr<int> up = make_unique<int>(1729);
+    assert(*up == 1729);
+    shared_ptr<int> sp{move(up)};
+    assert(!up);
+    assert(*sp == 1729);
+    weak_ptr<const int> wp{sp};
+    assert(!wp.expired());
+    shared_ptr<const int> other = wp.lock();
+    assert(*other == 1729);
+    ++*sp;
+    assert(*other == 1730);
+}
+
+void test_memory_resource() {
+    using namespace std;
+    puts("Testing <memory_resource>.");
+    pmr::monotonic_buffer_resource mbr{};
+    pmr::polymorphic_allocator<int> al{&mbr};
+    pmr::vector<int> v({10, 20, 30, 40, 50}, al);
+    assert(v[2] == 30);
+    v.push_back(60);
+    assert(v[5] == 60);
+}
+
+void test_mutex() {
+    using namespace std;
+    puts("Testing <mutex>.");
+    // see above, tested with <condition_variable>
+    int n       = 10;
+    auto lambda = [&n] { ++n; };
+    once_flag flag;
+    assert(n == 10);
+    call_once(flag, lambda);
+    assert(n == 11);
+    call_once(flag, lambda);
+    assert(n == 11);
+}
+
+void test_new() {
+    using namespace std;
+    puts("Testing <new>.");
+    bool caught_bad_alloc = false;
+
+    try {
+        throw bad_array_new_length{};
+    } catch (const bad_alloc&) {
+        caught_bad_alloc = true;
+    } catch (...) {
+        assert(false);
+    }
+
+    assert(caught_bad_alloc);
+
+    const int* const ptr = new (nothrow) int{1729};
+    assert(ptr);
+    assert(*ptr == 1729);
+    delete ptr;
+
+    static_assert(hardware_constructive_interference_size == 64); // implementation-defined
+    static_assert(hardware_destructive_interference_size == 64); // implementation-defined
+}
+
+void test_numbers() {
+    using namespace std;
+    puts("Testing <numbers>.");
+    static_assert(3.14 < numbers::pi && numbers::pi < 3.15);
+    static_assert(2.71828f < numbers::e_v<float> && numbers::e_v<float> < 2.71829f);
+}
+
+void test_numeric() {
+    using namespace std;
+    puts("Testing <numeric>.");
+    constexpr int arr[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+    assert(accumulate(begin(arr), end(arr), 0) == 55);
+    static_assert(accumulate(begin(arr), end(arr), 0) == 55);
+}
+
+void test_optional() {
+    using namespace std;
+    puts("Testing <optional>.");
+    constexpr optional<int> opt{in_place, 1729};
+    assert(opt.has_value());
+    assert(opt.value() == 1729);
+    static_assert(opt.has_value());
+    static_assert(opt.value() == 1729);
+
+    constexpr optional<int> empty{nullopt};
+    assert(!empty.has_value());
+    assert(empty.value_or(-1) == -1);
+    static_assert(!empty.has_value());
+    static_assert(empty.value_or(-1) == -1);
+}
+
+void test_ostream() {
+    using namespace std;
+    puts("Testing <ostream>.");
+    const ostream os{nullptr};
+    assert(os.rdbuf() == nullptr);
+}
+
+void test_queue() {
+    using namespace std;
+    puts("Testing <queue>.");
+    queue<int> q;
+    q.push(10);
+    q.push(20);
+    q.push(30);
+    assert(q.size() == 3);
+    assert(q.front() == 10);
+    q.pop();
+    assert(q.front() == 20);
+    q.pop();
+    assert(q.front() == 30);
+    q.pop();
+    assert(q.empty());
+
+    priority_queue<int> pq;
+    pq.push(50);
+    pq.push(10);
+    pq.push(1729);
+    pq.push(200);
+    assert(pq.size() == 4);
+    assert(pq.top() == 1729);
+    pq.pop();
+    assert(pq.top() == 200);
+    pq.pop();
+    assert(pq.top() == 50);
+    pq.pop();
+    assert(pq.top() == 10);
+    pq.pop();
+    assert(pq.empty());
+}
+
+void test_random() {
+    using namespace std;
+    puts("Testing <random>.");
+    minstd_rand0 lcg;
+    lcg.discard(9999);
+    assert(lcg() == 1043618065); // N4868 [rand.predef]/1
+}
+
+void test_ranges() {
+    using namespace std;
+    puts("Testing <ranges>.");
+    constexpr int arr[]{11, 0, 22, 0, 33, 0, 44, 0, 55};
+    assert(ranges::distance(views::filter(arr, [](int x) { return x == 0; })) == 4);
+    static_assert(ranges::distance(views::filter(arr, [](int x) { return x != 0; })) == 5);
+}
+
+void test_ratio() {
+    using namespace std;
+    puts("Testing <ratio>.");
+    static_assert(ratio_equal_v<ratio_multiply<milli, hecto>, deci>);
+}
+
+void test_regex() {
+    using namespace std;
+    puts("Testing <regex>.");
+    const regex r{R"(\w+)"};
+    const string s{"cute! fluffy? kittens."};
+    vector<string> v;
+
+    for (sregex_token_iterator it{s.begin(), s.end(), r}, end; it != end; ++it) {
+        v.push_back(it->str());
+    }
+
+    const vector<string> expected_val{"cute", "fluffy", "kittens"};
+    assert(v == expected_val);
+}
+
+void test_scoped_allocator() {
+    using namespace std;
+    puts("Testing <scoped_allocator>.");
+    vector<int, scoped_allocator_adaptor<allocator<int>>> v;
+    v.push_back(11);
+    v.push_back(22);
+    v.push_back(33);
+    constexpr int expected_val[]{11, 22, 33};
+    assert(equal(v.begin(), v.end(), begin(expected_val), end(expected_val)));
+}
+
+void test_semaphore() {
+    using namespace std;
+    puts("Testing <semaphore>.");
+    static_assert(binary_semaphore::max() >= 1);
+    binary_semaphore s{1};
+    int val{0};
+    s.acquire();
+    thread t1{[&] {
+        for (int i = 0; i < 17; ++i) {
+            s.acquire();
+            val += 100;
+            s.release();
+        }
+    }};
+    thread t2{[&] {
+        for (int i = 0; i < 29; ++i) {
+            s.acquire();
+            ++val;
+            s.release();
+        }
+    }};
+    s.release();
+    t1.join();
+    t2.join();
+    assert(val == 1729);
+}
+
+void test_set() {
+    using namespace std;
+    puts("Testing <set>.");
+    const set<int> s{10, 20, 30, 40, 50};
+    assert(*next(s.begin(), 2) == 30);
+
+    const multiset<int> ms{10, 20, 20, 30, 30, 30, 40, 40, 40, 40};
+    const auto p = ms.equal_range(30);
+    assert(distance(p.first, p.second) == 3);
+}
+
+void test_shared_mutex() {
+    using namespace std;
+    puts("Testing <shared_mutex>.");
+    condition_variable_any cv;
+    shared_mutex mut;
+    vector<int> vec = {5};
+
+    thread odd{[&cv, &mut, &vec] {
+        unique_lock<shared_mutex> lk{mut};
+
+        while (vec.size() < 6) {
+            cv.wait(lk, [&vec] { return vec.size() % 2 == 1; });
+            const int n = vec.back();
+            vec.push_back(n * 10 + 1);
+            cv.notify_one();
+        }
+    }};
+
+    thread even{[&cv, &mut, &vec] {
+        unique_lock<shared_mutex> lk{mut};
+
+        while (vec.size() < 7) {
+            cv.wait(lk, [&vec] { return vec.size() % 2 == 0; });
+            const int n = vec.back();
+            vec.push_back(n * 10 + 2);
+            cv.notify_one();
+        }
+    }};
+
+    odd.join();
+    even.join();
+
+    const vector<int> expected_val = {5, 51, 512, 5121, 51212, 512121, 5121212};
+    assert(vec == expected_val);
+}
+
+constexpr bool impl_test_source_location() {
+    using namespace std;
+    const auto sl = source_location::current();
+    assert(sl.line() == __LINE__ - 1);
+    assert(sl.column() == 1);
+    assert(sl.function_name() == "impl_test_source_location"sv);
+    assert(string_view{sl.file_name()}.ends_with("test_header_units_and_modules.hpp"sv));
+    return true;
+}
+
+void test_source_location() {
+    using namespace std;
+    puts("Testing <source_location>.");
+    assert(impl_test_source_location());
+    static_assert(impl_test_source_location());
+}
+
+void test_span() {
+    using namespace std;
+    puts("Testing <span>.");
+    constexpr int arr[]{11, 22, 33, 44, 55};
+    constexpr span<const int, 5> whole{arr};
+    constexpr span<const int, 3> mid = whole.subspan<1, 3>();
+    assert(mid[0] == 22 && mid[1] == 33 && mid[2] == 44);
+    static_assert(mid[0] == 22 && mid[1] == 33 && mid[2] == 44);
+}
+
+void test_spanstream() {
+    using namespace std;
+    puts("Testing <spanstream>.");
+    char ibuffer[] = "1 2 3 4 5";
+    ispanstream is{span<char>{ibuffer}};
+    int read = 0;
+    for (int expected_val = 1; expected_val <= 5; ++expected_val) {
+        assert(is.good());
+        is >> read;
+        assert(read == expected_val);
+    }
+
+    const char const_buffer[] = "1 2 3 4 5";
+    basic_ispanstream<char> is_const_buffer{span<const char>{const_buffer}};
+    read = 0;
+    for (int expected_val = 1; expected_val <= 5; ++expected_val) {
+        assert(is_const_buffer.good());
+        is_const_buffer >> read;
+        assert(read == expected_val);
+    }
+
+    const auto expected_val = "102030"sv;
+    char obuffer[10];
+    ospanstream os{span<char>{obuffer}};
+    os << 10 << 20 << 30;
+    assert(equal(begin(os.span()), end(os.span()), begin(expected_val), end(expected_val)));
+
+    char buffer[10];
+    spanstream s{span<char>{buffer}};
+    s << 10 << 20 << 30;
+    assert(equal(begin(s.span()), end(s.span()), begin(expected_val), end(expected_val)));
+}
+
+void test_sstream() {
+    using namespace std;
+    puts("Testing <sstream>.");
+    ostringstream oss;
+    oss << "I have " << 9 * 9 * 9 + 10 * 10 * 10 << " cute fluffy kittens.";
+    assert(oss.str() == "I have 1729 cute fluffy kittens.");
+}
+
+void test_stack() {
+    using namespace std;
+    puts("Testing <stack>.");
+    stack<int> s;
+    s.push(10);
+    s.push(20);
+    s.push(30);
+    assert(s.size() == 3);
+    assert(s.top() == 30);
+    s.pop();
+    assert(s.top() == 20);
+    s.pop();
+    assert(s.top() == 10);
+    s.pop();
+    assert(s.empty());
+}
+
+__declspec(dllexport) void test_stacktrace() { // export test_stacktrace to have it named even without debug info
+    using namespace std;
+    puts("Testing <stacktrace>.");
+    auto desc = stacktrace::current().at(0).description();
+
+    if (auto pos = desc.find("!"); pos != string::npos) {
+        desc = desc.substr(pos + 1);
+    }
+
+    if (auto pos = desc.find("+"); pos != string::npos) {
+        desc.resize(pos);
+    }
+
+    assert(desc == "test_stacktrace");
+}
+
+void test_stdexcept() {
+    using namespace std;
+    puts("Testing <stdexcept>.");
+    bool caught_puppies = false;
+
+    try {
+        throw overflow_error{"too many puppies"};
+    } catch (const runtime_error& e) {
+        caught_puppies = e.what() == "too many puppies"sv;
+    } catch (...) {
+        assert(false);
+    }
+
+    assert(caught_puppies);
+}
+
+void test_stop_token() {
+    using namespace std;
+    puts("Testing <stop_token>.");
+    vector<int> vec;
+    {
+        latch l{1};
+        jthread jt{[&](const stop_token& token) {
+            int val{1729};
+            // Generate the Collatz sequence for 1729.
+            // test_stop_token() shouldn't ask us to stop early; if it does, the sequence will be truncated.
+            while (!token.stop_requested()) {
+                vec.push_back(val);
+                if (val == 1) {
+                    break;
+                } else if (val % 2 == 0) {
+                    val /= 2;
+                } else {
+                    val = 3 * val + 1;
+                }
+            }
+            l.count_down(); // tell test_stop_token() that we're done
+            while (!token.stop_requested()) {
+                this_thread::sleep_for(10ms); // not a timing assumption; avoids spinning furiously
+            }
+            vec.push_back(-1000); // indicate that token.stop_requested() returned true
+        }};
+        l.wait(); // wait for jt to generate the sequence
+    } // destroying jt will ask it to stop
+    static constexpr int expected_val[]{1729, 5188, 2594, 1297, 3892, 1946, 973, 2920, 1460, 730, 365, 1096, 548, 274,
+        137, 412, 206, 103, 310, 155, 466, 233, 700, 350, 175, 526, 263, 790, 395, 1186, 593, 1780, 890, 445, 1336, 668,
+        334, 167, 502, 251, 754, 377, 1132, 566, 283, 850, 425, 1276, 638, 319, 958, 479, 1438, 719, 2158, 1079, 3238,
+        1619, 4858, 2429, 7288, 3644, 1822, 911, 2734, 1367, 4102, 2051, 6154, 3077, 9232, 4616, 2308, 1154, 577, 1732,
+        866, 433, 1300, 650, 325, 976, 488, 244, 122, 61, 184, 92, 46, 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5, 16,
+        8, 4, 2, 1, -1000};
+    assert(equal(vec.begin(), vec.end(), begin(expected_val), end(expected_val)));
+}
+
+void test_streambuf() {
+    using namespace std;
+    puts("Testing <streambuf>.");
+    istringstream iss{"kittens"};
+    assert(iss.rdbuf()->in_avail() == 7);
+}
+
+void test_string() {
+    using namespace std;
+    puts("Testing <string>.");
+    const string small_string{"homeowner"};
+    const string large_string{"Cute fluffy kittens are so adorable when they meow and purr."};
+    assert(small_string.find("meow") == 2);
+    assert(large_string.find("meow") == 46);
+}
+
+void test_string_view() {
+    using namespace std;
+    puts("Testing <string_view>.");
+    constexpr string_view catenary{"catenary"};
+    assert(catenary.starts_with("cat"));
+    assert(!catenary.starts_with("dog"));
+    static_assert(catenary.starts_with("cat"));
+    static_assert(!catenary.starts_with("dog"));
+}
+
+#pragma warning(push)
+#pragma warning(disable : 4996) // was declared deprecated
+void test_strstream() {
+    using namespace std;
+    puts("Testing <strstream>.");
+    istrstream istr{"1729"};
+    int n = -1;
+    istr >> n;
+    assert(n == 1729);
+}
+#pragma warning(pop)
+
+void test_syncstream() {
+    using namespace std;
+    puts("Testing <syncstream>.");
+    syncbuf sync_buf{nullptr};
+    assert(sync_buf.get_wrapped() == nullptr);
+    assert(sync_buf.get_allocator() == allocator<char>{});
+    assert(sync_buf.emit() == false);
+    osyncstream sync_str{cout};
+    sync_str << "Testing osyncstream.\n";
+    assert(sync_str.rdbuf()->get_wrapped() == cout.rdbuf());
+}
+
+void test_system_error() {
+    using namespace std;
+    puts("Testing <system_error>.");
+    const error_code code = make_error_code(errc::value_too_large);
+    assert(code.value() == static_cast<int>(errc::value_too_large));
+    assert(code.category() == generic_category());
+    assert(code);
+}
+
+void test_thread() {
+    using namespace std;
+    puts("Testing <thread>.");
+    // see above, tested with <condition_variable>
+    assert(this_thread::get_id() != thread::id{});
+}
+
+void test_tuple() {
+    using namespace std;
+    puts("Testing <tuple>.");
+    constexpr tuple<int, char, double> t{1729, 'c', 1.25};
+    assert(get<int>(t) == 1729);
+    assert(get<char>(t) == 'c');
+    assert(get<double>(t) == 1.25);
+    static_assert(get<int>(t) == 1729);
+    static_assert(get<char>(t) == 'c');
+    static_assert(get<double>(t) == 1.25);
+}
+
+void test_type_traits() {
+    using namespace std;
+    puts("Testing <type_traits>.");
+    static_assert(is_void_v<void>);
+    static_assert(!is_void_v<double>);
+    static_assert(is_same_v<remove_extent_t<int[10][20][30]>, int[20][30]>);
+    static_assert(is_same_v<remove_extent_t<double>, double>);
+
+    constexpr auto compiletime_10_or_runtime_20 = [] {
+        if (is_constant_evaluated()) {
+            return 10;
+        } else {
+            return 20;
+        }
+    };
+
+    assert(compiletime_10_or_runtime_20() == 20);
+    static_assert(compiletime_10_or_runtime_20() == 10);
+}
+
+void test_typeindex() {
+    using namespace std;
+    puts("Testing <typeindex>.");
+    const type_index ti_int{typeid(int)};
+    type_index ti{typeid(double)};
+    assert(ti != ti_int);
+    ti = ti_int;
+    assert(ti == ti_int);
+}
+
+void test_typeinfo() {
+    using namespace std;
+    puts("Testing <typeinfo>.");
+    const type_info& t1 = typeid(int);
+    const type_info& t2 = typeid(const int&);
+    const type_info& t3 = typeid(double);
+    assert(t1 == t2);
+    assert(t1 != t3);
+}
+
+void test_unordered_map() {
+    using namespace std;
+    puts("Testing <unordered_map>.");
+    unordered_map<int, int> um{{1, 1}, {2, 4}, {3, 9}, {4, 16}, {5, 25}};
+    for (const auto& p : um) {
+        assert(p.first * p.first == p.second);
+    }
+}
+
+void test_unordered_set() {
+    using namespace std;
+    puts("Testing <unordered_set>.");
+    unordered_set<int> us{10, 20, 30, 40, 50};
+    for (const auto& elem : us) {
+        assert(elem % 10 == 0);
+    }
+}
+
+void test_utility() {
+    using namespace std;
+    puts("Testing <utility>.");
+    constexpr pair<int, double> p{44, 5.5};
+    assert(p.first == 44);
+    assert(p.second == 5.5);
+    static_assert(p.first == 44);
+    static_assert(p.second == 5.5);
+
+    assert(in_range<unsigned char>(200));
+    assert(!in_range<unsigned char>(300));
+    static_assert(in_range<unsigned char>(200));
+    static_assert(!in_range<unsigned char>(300));
+
+    static_assert(is_same_v<make_integer_sequence<int, 4>, integer_sequence<int, 0, 1, 2, 3>>);
+    static_assert(is_same_v<decltype(declval<short>() + declval<unsigned short>()), int>);
+}
+
+void test_valarray() {
+    using namespace std;
+    puts("Testing <valarray>.");
+    valarray<int> val{1, 2, 3};
+    val *= 10;
+    assert(val[0] == 10 && val[1] == 20 && val[2] == 30);
+}
+
+void test_variant() {
+    using namespace std;
+    puts("Testing <variant>.");
+    constexpr const char* cats = "CATS";
+    constexpr variant<int, const char*, double> var{in_place_type<const char*>, cats};
+    static_assert(var.index() == 1);
+    static_assert(holds_alternative<const char*>(var));
+    static_assert(get<const char*>(var) == cats);
+    assert(var.index() == 1);
+    assert(holds_alternative<const char*>(var));
+    assert(get<const char*>(var) == cats);
+
+    constexpr variant<short, float, double> var2{in_place_type<double>, 2.5};
+    assert(var2.index() == 2);
+    assert(holds_alternative<double>(var2));
+    assert(get<double>(var2) == 2.5);
+    static_assert(var2.index() == 2);
+    static_assert(holds_alternative<double>(var2));
+    static_assert(get<double>(var2) == 2.5);
+}
+
+void test_vector() {
+    using namespace std;
+    puts("Testing <vector>.");
+    const vector<int> v{10, 20, 30, 40, 50};
+    assert(v[2] == 30);
+
+    const vector<bool> vb{true, true, false, true};
+    assert(vb[0] && vb[1] && !vb[2] && vb[3]);
+}
+
+void test_version() {
+    using namespace std;
+#ifdef TEST_HEADER_UNITS
+    puts("Testing <version>.");
+    static_assert(__cpp_lib_make_unique >= 201304L);
+#else // ^^^ header units / named modules vvv
+    puts("Nothing to test in <version>, only macros.");
+#endif // ^^^ named modules ^^^
+}
+
+void all_cpp_header_tests() {
+    test_algorithm();
+    test_any();
+    test_array();
+    test_atomic();
+    test_barrier();
+    test_bit();
+    test_bitset();
+    test_charconv();
+    test_chrono();
+    test_codecvt();
+    test_compare();
+    test_complex();
+    test_concepts();
+    test_condition_variable();
+    test_coroutine();
+    test_deque();
+    test_exception();
+    test_execution();
+    test_expected();
+    test_filesystem();
+    test_format();
+    test_forward_list();
+    test_fstream();
+    test_functional();
+    test_future();
+    test_initializer_list();
+    test_iomanip();
+    test_ios();
+    test_iosfwd();
+    test_iostream();
+    test_istream();
+    test_iterator();
+    test_latch();
+    test_limits();
+    test_list();
+    test_locale();
+    test_map();
+    test_memory();
+    test_memory_resource();
+    test_mutex();
+    test_new();
+    test_numbers();
+    test_numeric();
+    test_optional();
+    test_ostream();
+    test_queue();
+    test_random();
+    test_ranges();
+    test_ratio();
+    test_regex();
+    test_scoped_allocator();
+    test_semaphore();
+    test_set();
+    test_shared_mutex();
+    test_source_location();
+    test_span();
+    test_spanstream();
+    test_sstream();
+    test_stack();
+    test_stacktrace();
+    test_stdexcept();
+    test_stop_token();
+    test_streambuf();
+    test_string();
+    test_string_view();
+    test_strstream();
+    test_syncstream();
+    test_system_error();
+    test_thread();
+    test_tuple();
+    test_type_traits();
+    test_typeindex();
+    test_typeinfo();
+    test_unordered_map();
+    test_unordered_set();
+    test_utility();
+    test_valarray();
+    test_variant();
+    test_vector();
+    test_version();
+}
diff --git a/tests/std/lit.site.cfg.in b/tests/std/lit.site.cfg.in
index 06680843d1..78cdb1a713 100644
--- a/tests/std/lit.site.cfg.in
+++ b/tests/std/lit.site.cfg.in
@@ -28,6 +28,7 @@ lit_config.library_dirs[config.name]     = ['@STL_LIBRARY_OUTPUT_DIRECTORY@', '@
 lit_config.test_subdirs[config.name]     = ['@CMAKE_CURRENT_SOURCE_DIR@/tests']
 
 lit_config.cxx_headers = '@STL_TESTED_HEADERS_DIR@'
+lit_config.cxx_modules = '@STL_TESTED_MODULES_DIR@'
 lit_config.cxx_runtime = '@STL_RUNTIME_OUTPUT_DIRECTORY@'
 lit_config.target_arch = '@VCLIBS_TARGET_ARCHITECTURE@'
 lit_config.build_only  = '@TESTS_BUILD_ONLY@'.lower() in ['1', 'true', 'on']
diff --git a/tests/std/test.lst b/tests/std/test.lst
index c48a7ce349..f309c7b043 100644
--- a/tests/std/test.lst
+++ b/tests/std/test.lst
@@ -565,6 +565,7 @@ tests\P2443R1_views_chunk_by
 tests\P2443R1_views_chunk_by_death
 tests\P2445R1_forward_like
 tests\P2446R2_views_as_rvalue
+tests\P2465R3_standard_library_modules
 tests\P2494R2_move_only_range_adaptors
 tests\P2517R1_apply_conditional_noexcept
 tests\VSO_0000000_allocator_propagation
diff --git a/tests/std/tests/P1502R1_standard_library_header_units/env.lst b/tests/std/tests/P1502R1_standard_library_header_units/env.lst
index bf514e1e1c..9cdd80a2eb 100644
--- a/tests/std/tests/P1502R1_standard_library_header_units/env.lst
+++ b/tests/std/tests/P1502R1_standard_library_header_units/env.lst
@@ -3,19 +3,19 @@
 
 RUNALL_INCLUDE ..\..\..\universal_prefix.lst
 RUNALL_CROSSLIST
-PM_CL="/w14365 /D_ENFORCE_FACET_SPECIALIZATIONS=1"
+PM_CL="/w14365 /D_ENFORCE_FACET_SPECIALIZATIONS=1 /D_STL_CALL_ABORT_INSTEAD_OF_INVALID_PARAMETER"
 RUNALL_CROSSLIST
 PM_CL="/w14640 /Zc:threadSafeInit- /EHsc /std:c++latest"
 RUNALL_CROSSLIST
-PM_CL="/Zc:preprocessor /D_SILENCE_CXX17_STRSTREAM_DEPRECATION_WARNING /D_SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING"
+PM_CL="/Zc:preprocessor"
 RUNALL_CROSSLIST
 PM_CL="/MD"
 PM_CL="/MDd"
 PM_CL="/MT"
 PM_CL="/MTd"
 RUNALL_CROSSLIST
-PM_CL="/DTEST_TOPO_SORT"
-PM_CL=""
+PM_CL="/DTEST_HEADER_UNITS /DTEST_TOPO_SORT"
+PM_CL="/DTEST_HEADER_UNITS"
 # RUNALL_CROSSLIST
 # PM_CL=""
 # PM_CL="/analyze:only /analyze:autolog-" # TRANSITION, works correctly but slowly
diff --git a/tests/std/tests/P1502R1_standard_library_header_units/test.cpp b/tests/std/tests/P1502R1_standard_library_header_units/test.cpp
index c768004463..e9ec1a36cf 100644
--- a/tests/std/tests/P1502R1_standard_library_header_units/test.cpp
+++ b/tests/std/tests/P1502R1_standard_library_header_units/test.cpp
@@ -9,7 +9,6 @@
 // This EXCLUDES the <cmeow> headers in:
 // [tab:headers.cpp.c]: "Table 22: C++ headers for C library facilities"
 
-// clang-format off
 import <algorithm>;
 import <any>;
 import <array>;
@@ -90,920 +89,15 @@ import <valarray>;
 import <variant>;
 import <vector>;
 import <version>;
-// clang-format on
 
 #include <assert.h> // intentionally not <cassert>
 #include <stdio.h> // intentionally not <cstdio>
 
 #include <force_include.hpp>
-using namespace std;
 
-constexpr bool test_source_location() {
-#ifdef __cpp_lib_source_location
-    const auto sl = source_location::current();
-    assert(sl.line() == __LINE__ - 1);
-    assert(sl.column() == 1);
-    assert(sl.function_name() == "test_source_location"sv);
-    assert(string_view{sl.file_name()}.ends_with("test.cpp"sv));
-#endif // __cpp_lib_source_location
-    return true;
-}
-
-__declspec(dllexport) // for <stacktrace> test export main to have it named even without debug info
-    int main() {
-    {
-        puts("Testing <algorithm>.");
-        constexpr int arr[]{11, 0, 22, 0, 33, 0, 44, 0, 55};
-        assert(count(begin(arr), end(arr), 0) == 4);
-        assert(ranges::count(arr, 0) == 4);
-        static_assert(count(begin(arr), end(arr), 0) == 4);
-        static_assert(ranges::count(arr, 0) == 4);
-    }
-
-    {
-        puts("Testing <any>.");
-        any a1{1729};
-        any a2{7.5};
-        a1.swap(a2);
-        assert(any_cast<double>(a1) == 7.5);
-        assert(any_cast<int>(a2) == 1729);
-    }
-
-    {
-        puts("Testing <array>.");
-        constexpr array arr{10, 20, 30, 40, 50};
-        assert(arr[2] == 30);
-        static_assert(arr[2] == 30);
-    }
-
-    {
-        puts("Testing <atomic>.");
-        atomic<int> atom{1729};
-        assert(atom.load() == 1729);
-        ++atom;
-        assert(atom.load() == 1730);
-        static_assert(atomic<int>::is_always_lock_free); // implementation-defined
-    }
-
-    {
-        puts("Testing <barrier>.");
-        static_assert(barrier<>::max() >= 5);
-        barrier b{2};
-        atomic<int> atom{0};
-        thread t1{[&] {
-            for (int i = 0; i < 5; ++i) {
-                auto token = b.arrive();
-                b.wait(move(token));
-                atom.fetch_add(1, memory_order_relaxed);
-            }
-        }};
-        thread t2{[&] {
-            for (int i = 0; i < 3; ++i) {
-                b.arrive_and_wait();
-                atom.fetch_add(1, memory_order_relaxed);
-            }
-            b.arrive_and_drop();
-        }};
-        t1.join();
-        t2.join();
-        assert(atom.load(memory_order_relaxed) == 8);
-    }
-
-    {
-        puts("Testing <bit>.");
-        assert(popcount(0x1234ABCDu) == 15);
-        static_assert(popcount(0x1234ABCDu) == 15);
-    }
-
-    {
-        puts("Testing <bitset>.");
-        constexpr bitset<32> b{0x1234ABCDu};
-        assert(b[3] && b[2] && !b[1] && b[0]);
-        static_assert(b[3] && b[2] && !b[1] && b[0]);
-    }
-
-    {
-        puts("Testing <charconv>.");
-        char buf[4]{};
-        const to_chars_result result = to_chars(buf, end(buf), 3.14);
-        assert(result.ec == errc{});
-        assert(result.ptr == end(buf));
-        const string_view sv{buf, size(buf)};
-        assert(sv == "3.14");
-    }
-
-    {
-        puts("Testing <chrono>.");
-        constexpr chrono::seconds dur = 3min;
-        assert(dur.count() == 180);
-        static_assert(dur.count() == 180);
-    }
-
-    {
-        puts("Testing <codecvt>.");
-        const string utf8_koshka_cat{"\xD0\xBA\xD0\xBE\xD1\x88\xD0\xBA\xD0\xB0_\xF0\x9F\x90\x88"};
-        const wstring utf16_koshka_cat{L"\x043A\x043E\x0448\x043A\x0430_\xD83D\xDC08"};
-        wstring_convert<codecvt_utf8_utf16<wchar_t>> conv;
-        assert(conv.from_bytes(utf8_koshka_cat) == utf16_koshka_cat);
-        assert(conv.to_bytes(utf16_koshka_cat) == utf8_koshka_cat);
-
-        static_assert(static_cast<int>(codecvt_mode::consume_header) == 4);
-    }
-
-    {
-        puts("Testing <compare>.");
-        assert(is_lt(10 <=> 20));
-        static_assert(is_lt(10 <=> 20));
-    }
-
-    {
-        puts("Testing <complex>.");
-        constexpr complex<double> c{3.0, 4.0};
-        assert(norm(c) == 25.0);
-        static_assert(norm(c) == 25.0);
-    }
-
-    {
-        puts("Testing <concepts>.");
-        static_assert(signed_integral<short>);
-        static_assert(!signed_integral<unsigned short>);
-        static_assert(!signed_integral<double>);
-    }
-
-    {
-        puts("Testing <condition_variable>.");
-        condition_variable cv;
-        mutex mut;
-        vector<int> vec = {5};
-
-        thread odd{[&cv, &mut, &vec] {
-            unique_lock<mutex> lk{mut};
-
-            while (vec.size() < 6) {
-                cv.wait(lk, [&vec] { return vec.size() % 2 == 1; });
-                const int n = vec.back();
-                vec.push_back(n * 10 + 1);
-                cv.notify_one();
-            }
-        }};
-
-        thread even{[&cv, &mut, &vec] {
-            unique_lock<mutex> lk{mut};
-
-            while (vec.size() < 7) {
-                cv.wait(lk, [&vec] { return vec.size() % 2 == 0; });
-                const int n = vec.back();
-                vec.push_back(n * 10 + 2);
-                cv.notify_one();
-            }
-        }};
-
-        odd.join();
-        even.join();
-
-        const vector<int> expected_val = {5, 51, 512, 5121, 51212, 512121, 5121212};
-        assert(vec == expected_val);
-
-        static_assert(static_cast<int>(cv_status::no_timeout) == 0);
-        static_assert(static_cast<int>(cv_status::timeout) == 1);
-    }
-
-    {
-        puts("Testing <coroutine>.");
-        constexpr coroutine_handle<> handle{};
-        assert(handle.address() == nullptr);
-        static_assert(handle.address() == nullptr);
-    }
-
-    {
-        puts("Testing <deque>.");
-        const deque<int> d{10, 20, 30, 40, 50};
-        assert(d[2] == 30);
-    }
-
-    {
-        puts("Testing <exception>.");
-        assert(uncaught_exceptions() == 0);
-        const exception_ptr ep = current_exception();
-        assert(!ep);
-    }
-
-    {
-        puts("Testing <execution>.");
-        constexpr int arr[]{11, 0, 22, 0, 33, 0, 44, 0, 55};
-        assert(count(execution::par, begin(arr), end(arr), 0) == 4);
-    }
-
-    {
-        puts("Testing <expected>.");
-        constexpr expected<double, int> test{unexpect, 42};
-        assert(test.error() == 42);
-    }
-
-    {
-        puts("Testing <filesystem>.");
-        constexpr wstring_view dot{L"."};
-        error_code ec{};
-        const filesystem::space_info info = filesystem::space(dot, ec);
-        assert(!ec);
-        assert(info.capacity > 0);
-        assert(info.capacity != static_cast<decltype(info.capacity)>(-1));
-    }
-
-    {
-        puts("Testing <format>.");
-        assert(format("{} {}", 1729, "kittens") == "1729 kittens");
-        assert(format(L"{} {}", 1729, L"kittens") == L"1729 kittens");
-    }
-
-    {
-        puts("Testing <forward_list>.");
-        const forward_list<int> fl{10, 20, 30, 40, 50};
-        assert(*next(fl.begin(), 2) == 30);
-    }
-
-    {
-        puts("Testing <fstream>.");
-        const ifstream f{};
-        assert(!f.is_open());
-    }
-
-    {
-        puts("Testing <functional>.");
-        function<int(int, int)> f{multiplies{}};
-        assert(f(3, 5) == 15);
-        f = [](int x, int y) { return x * 100 + y * 10; };
-        assert(f(3, 5) == 350);
-        constexpr auto b = bind(multiplies{}, placeholders::_1, 11);
-        assert(b(3) == 33);
-        static_assert(b(3) == 33);
-    }
-
-    {
-        puts("Testing <future>.");
-        promise<int> p{};
-        future<int> f{p.get_future()};
-        assert(f.wait_for(chrono::seconds{0}) == future_status::timeout);
-        p.set_value(1729);
-        assert(f.wait_for(chrono::seconds{0}) == future_status::ready);
-        assert(f.get() == 1729);
-    }
-
-    {
-        puts("Testing <initializer_list>.");
-        const initializer_list<int> il{10, 20, 30, 40, 50};
-        assert(il.begin()[2] == 30);
-    }
-
-    {
-        puts("Testing <iomanip>.");
-        ostringstream oss;
-        oss << "I have " << setfill('.') << setw(7) << 9 * 9 * 9 + 10 * 10 * 10 << " cute fluffy kittens.";
-        assert(oss.str() == "I have ...1729 cute fluffy kittens.");
-        oss.str("");
-        oss << quoted(R"(Read "C:\Temp\Cat Names.txt" for more info.)");
-        const char* const expected_quoted = R"("Read \"C:\\Temp\\Cat Names.txt\" for more info.")";
-        assert(oss.str() == expected_quoted);
-    }
-
-    {
-        puts("Testing <ios>.");
-        ios b{nullptr};
-        assert(b.rdbuf() == nullptr);
-        assert(b.rdstate() == ios_base::badbit);
-        assert(b.precision() == 6);
-        static_assert(ios_base::floatfield == (ios_base::fixed | ios_base::scientific));
-    }
-
-    {
-        puts("Testing <iosfwd>.");
-        static_assert(is_same_v<istream, basic_istream<char>>);
-        static_assert(is_same_v<wostream, basic_ostream<wchar_t>>);
-    }
-
-    {
-        puts("Testing <iostream>.");
-        cout << "Testing P1502R1_standard_library_header_units.\n";
-        assert(cin.tie() == &cout);
-    }
-
-    {
-        puts("Testing <istream>.");
-        const istream is{nullptr};
-        assert(is.gcount() == 0);
-    }
-
-    {
-        puts("Testing <iterator>.");
-        constexpr int arr[]{10, 20, 30, 40, 50};
-        constexpr reverse_iterator<const int*> ri{end(arr)};
-        assert(*ri == 50);
-        assert(*next(ri) == 40);
-        static_assert(*ri == 50);
-        static_assert(*next(ri) == 40);
-    }
-
-    {
-        puts("Testing <latch>.");
-        static_assert(latch::max() >= 5);
-        for (const auto& release_wait : {true, false}) {
-            latch l{5};
-            thread t1{[&] { l.wait(); }};
-            thread t2{[&] { l.arrive_and_wait(2); }};
-            l.count_down();
-            if (release_wait) {
-                l.arrive_and_wait(2);
-            } else {
-                l.count_down(2);
-            }
-            t1.join();
-            t2.join();
-        }
-    }
-
-    {
-        puts("Testing <limits>.");
-        static_assert(numeric_limits<short>::min() == -32768);
-        static_assert(numeric_limits<short>::max() == 32767);
-    }
-
-    {
-        puts("Testing <list>.");
-        const list<int> l{10, 20, 30, 40, 50};
-        assert(*next(l.begin(), 2) == 30);
-    }
-
-    {
-        puts("Testing <locale>.");
-        locale loc{};
-        assert(isdigit('1', loc));
-        assert(!isdigit('a', loc));
-        using L = locale;
-        static_assert((L::collate | L::ctype | L::monetary | L::numeric | L::time | L::messages | L::all) == L::all);
-    }
-
-    {
-        puts("Testing <map>.");
-        map<int, int> m{{10, 11}, {20, 22}, {30, 33}, {40, 44}, {50, 55}};
-        assert(m[30] == 33);
-    }
-
-    {
-        puts("Testing <memory_resource>.");
-        pmr::monotonic_buffer_resource mbr{};
-        pmr::polymorphic_allocator<int> al{&mbr};
-        pmr::vector<int> v({10, 20, 30, 40, 50}, al);
-        assert(v[2] == 30);
-        v.push_back(60);
-        assert(v[5] == 60);
-    }
-
-    {
-        puts("Testing <memory>.");
-        unique_ptr<int> up = make_unique<int>(1729);
-        assert(*up == 1729);
-        shared_ptr<int> sp{move(up)};
-        assert(!up);
-        assert(*sp == 1729);
-        weak_ptr<const int> wp{sp};
-        assert(!wp.expired());
-        shared_ptr<const int> other = wp.lock();
-        assert(*other == 1729);
-        ++*sp;
-        assert(*other == 1730);
-    }
-
-    {
-        puts("Testing <mutex>.");
-        // see above, tested with <condition_variable>
-        int n       = 10;
-        auto lambda = [&n] { ++n; };
-        once_flag flag;
-        assert(n == 10);
-        call_once(flag, lambda);
-        assert(n == 11);
-        call_once(flag, lambda);
-        assert(n == 11);
-    }
-
-    {
-        puts("Testing <new>.");
-        bool caught_bad_alloc = false;
-
-        try {
-            throw bad_array_new_length{};
-        } catch (const bad_alloc&) {
-            caught_bad_alloc = true;
-        } catch (...) {
-            assert(false);
-        }
-
-        assert(caught_bad_alloc);
-
-        const int* const ptr = new (nothrow) int{1729};
-        assert(ptr);
-        assert(*ptr == 1729);
-        delete ptr;
-
-        static_assert(hardware_constructive_interference_size == 64); // implementation-defined
-        static_assert(hardware_destructive_interference_size == 64); // implementation-defined
-    }
-
-    {
-        puts("Testing <numbers>.");
-        static_assert(3.14 < numbers::pi && numbers::pi < 3.15);
-        static_assert(2.71828f < numbers::e_v<float> && numbers::e_v<float> < 2.71829f);
-    }
-
-    {
-        puts("Testing <numeric>.");
-        constexpr int arr[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
-        assert(accumulate(begin(arr), end(arr), 0) == 55);
-        static_assert(accumulate(begin(arr), end(arr), 0) == 55);
-    }
-
-    {
-        puts("Testing <optional>.");
-        constexpr optional<int> opt{in_place, 1729};
-        assert(opt.has_value());
-        assert(opt.value() == 1729);
-        static_assert(opt.has_value());
-        static_assert(opt.value() == 1729);
-
-        constexpr optional<int> empty{nullopt};
-        assert(!empty.has_value());
-        assert(empty.value_or(-1) == -1);
-        static_assert(!empty.has_value());
-        static_assert(empty.value_or(-1) == -1);
-    }
-
-    {
-        puts("Testing <ostream>.");
-        const ostream os{nullptr};
-        assert(os.rdbuf() == nullptr);
-    }
-
-    {
-        puts("Testing <queue>.");
-        queue<int> q;
-        q.push(10);
-        q.push(20);
-        q.push(30);
-        assert(q.size() == 3);
-        assert(q.front() == 10);
-        q.pop();
-        assert(q.front() == 20);
-        q.pop();
-        assert(q.front() == 30);
-        q.pop();
-        assert(q.empty());
-
-        priority_queue<int> pq;
-        pq.push(50);
-        pq.push(10);
-        pq.push(1729);
-        pq.push(200);
-        assert(pq.size() == 4);
-        assert(pq.top() == 1729);
-        pq.pop();
-        assert(pq.top() == 200);
-        pq.pop();
-        assert(pq.top() == 50);
-        pq.pop();
-        assert(pq.top() == 10);
-        pq.pop();
-        assert(pq.empty());
-    }
-
-    {
-        puts("Testing <random>.");
-        minstd_rand0 lcg;
-
-        for (int i = 0; i < 9999; ++i) {
-            (void) lcg();
-        }
-
-        assert(lcg() == 1043618065); // N4868 [rand.predef]/1
-    }
-
-    {
-        puts("Testing <ranges>.");
-        constexpr int arr[]{11, 0, 22, 0, 33, 0, 44, 0, 55};
-        assert(ranges::distance(views::filter(arr, [](int x) { return x == 0; })) == 4);
-        static_assert(ranges::distance(views::filter(arr, [](int x) { return x != 0; })) == 5);
-    }
-
-    {
-        puts("Testing <ratio>.");
-        static_assert(ratio_equal_v<ratio_multiply<milli, hecto>, deci>);
-    }
-
-    {
-        puts("Testing <regex>.");
-        const regex r{R"(\w+)"};
-        const string s{"cute! fluffy? kittens."};
-        vector<string> v;
-
-        for (sregex_token_iterator it{s.begin(), s.end(), r}, end; it != end; ++it) {
-            v.push_back(it->str());
-        }
-
-        const vector<string> expected_val{"cute", "fluffy", "kittens"};
-        assert(v == expected_val);
-    }
-
-    {
-        puts("Testing <scoped_allocator>.");
-        vector<int, scoped_allocator_adaptor<allocator<int>>> v;
-        v.push_back(11);
-        v.push_back(22);
-        v.push_back(33);
-        constexpr int expected_val[]{11, 22, 33};
-        assert(equal(v.begin(), v.end(), begin(expected_val), end(expected_val)));
-    }
-
-    {
-        puts("Testing <semaphore>.");
-        static_assert(binary_semaphore::max() >= 1);
-        binary_semaphore s{1};
-        int val{0};
-        s.acquire();
-        thread t1{[&] {
-            for (int i = 0; i < 17; ++i) {
-                s.acquire();
-                val += 100;
-                s.release();
-            }
-        }};
-        thread t2{[&] {
-            for (int i = 0; i < 29; ++i) {
-                s.acquire();
-                ++val;
-                s.release();
-            }
-        }};
-        s.release();
-        t1.join();
-        t2.join();
-        assert(val == 1729);
-    }
-
-    {
-        puts("Testing <set>.");
-        const set<int> s{10, 20, 30, 40, 50};
-        assert(*next(s.begin(), 2) == 30);
-
-        const multiset<int> ms{10, 20, 20, 30, 30, 30, 40, 40, 40, 40};
-        const auto p = ms.equal_range(30);
-        assert(distance(p.first, p.second) == 3);
-    }
-
-    {
-        puts("Testing <shared_mutex>.");
-        condition_variable_any cv;
-        shared_mutex mut;
-        vector<int> vec = {5};
-
-        thread odd{[&cv, &mut, &vec] {
-            unique_lock<shared_mutex> lk{mut};
-
-            while (vec.size() < 6) {
-                cv.wait(lk, [&vec] { return vec.size() % 2 == 1; });
-                const int n = vec.back();
-                vec.push_back(n * 10 + 1);
-                cv.notify_one();
-            }
-        }};
-
-        thread even{[&cv, &mut, &vec] {
-            unique_lock<shared_mutex> lk{mut};
-
-            while (vec.size() < 7) {
-                cv.wait(lk, [&vec] { return vec.size() % 2 == 0; });
-                const int n = vec.back();
-                vec.push_back(n * 10 + 2);
-                cv.notify_one();
-            }
-        }};
-
-        odd.join();
-        even.join();
-
-        const vector<int> expected_val = {5, 51, 512, 5121, 51212, 512121, 5121212};
-        assert(vec == expected_val);
-    }
-
-    {
-        puts("Testing <source_location>.");
-        assert(test_source_location());
-        static_assert(test_source_location());
-    }
-
-    {
-        puts("Testing <span>.");
-        constexpr int arr[]{11, 22, 33, 44, 55};
-        constexpr span<const int, 5> whole{arr};
-        constexpr span<const int, 3> mid = whole.subspan<1, 3>();
-        assert(mid[0] == 22 && mid[1] == 33 && mid[2] == 44);
-        static_assert(mid[0] == 22 && mid[1] == 33 && mid[2] == 44);
-    }
-
-    {
-        puts("Testing <spanstream>.");
-        char ibuffer[] = "1 2 3 4 5";
-        ispanstream is{span<char>{ibuffer}};
-        int read = 0;
-        for (int expected_val = 1; expected_val <= 5; ++expected_val) {
-            assert(is.good());
-            is >> read;
-            assert(read == expected_val);
-        }
-
-        const char const_buffer[] = "1 2 3 4 5";
-        basic_ispanstream<char> is_const_buffer{span<const char>{const_buffer}};
-        read = 0;
-        for (int expected_val = 1; expected_val <= 5; ++expected_val) {
-            assert(is_const_buffer.good());
-            is_const_buffer >> read;
-            assert(read == expected_val);
-        }
-
-        const auto expected_val = "102030"sv;
-        char obuffer[10];
-        ospanstream os{span<char>{obuffer}};
-        os << 10 << 20 << 30;
-        assert(equal(begin(os.span()), end(os.span()), begin(expected_val), end(expected_val)));
-
-        char buffer[10];
-        spanstream s{span<char>{buffer}};
-        s << 10 << 20 << 30;
-        assert(equal(begin(s.span()), end(s.span()), begin(expected_val), end(expected_val)));
-    }
-
-    {
-        puts("Testing <sstream>.");
-        ostringstream oss;
-        oss << "I have " << 9 * 9 * 9 + 10 * 10 * 10 << " cute fluffy kittens.";
-        assert(oss.str() == "I have 1729 cute fluffy kittens.");
-    }
-
-    {
-        puts("Testing <stack>.");
-        stack<int> s;
-        s.push(10);
-        s.push(20);
-        s.push(30);
-        assert(s.size() == 3);
-        assert(s.top() == 30);
-        s.pop();
-        assert(s.top() == 20);
-        s.pop();
-        assert(s.top() == 10);
-        s.pop();
-        assert(s.empty());
-    }
-
-    {
-        puts("Testing <stacktrace>.");
-        auto desc = stacktrace::current().at(0).description();
-
-        if (auto pos = desc.find("!"); pos != string::npos) {
-            desc = desc.substr(pos + 1);
-        }
-
-        if (auto pos = desc.find("+"); pos != string::npos) {
-            desc.resize(pos);
-        }
-
-        assert(desc == "main");
-    }
-
-    {
-        puts("Testing <stdexcept>.");
-        bool caught_puppies = false;
-
-        try {
-            throw overflow_error{"too many puppies"};
-        } catch (const runtime_error& e) {
-            caught_puppies = e.what() == string_view{"too many puppies"};
-        } catch (...) {
-            assert(false);
-        }
-
-        assert(caught_puppies);
-    }
-
-    {
-        puts("Testing <stop_token>.");
-        vector<int> vec;
-        {
-            latch l{1};
-            jthread jt{[&](const stop_token& token) {
-                int val{1729};
-                // Generate the Collatz sequence for 1729.
-                // main() shouldn't ask us to stop early; if it does, the sequence will be truncated.
-                while (!token.stop_requested()) {
-                    vec.push_back(val);
-                    if (val == 1) {
-                        break;
-                    } else if (val % 2 == 0) {
-                        val /= 2;
-                    } else {
-                        val = 3 * val + 1;
-                    }
-                }
-                l.count_down(); // tell main() that we're done
-                while (!token.stop_requested()) {
-                    this_thread::sleep_for(10ms); // not a timing assumption; avoids spinning furiously
-                }
-                vec.push_back(-1000); // indicate that token.stop_requested() returned true
-            }};
-            l.wait(); // wait for jt to generate the sequence
-        } // destroying jt will ask it to stop
-        static constexpr int expected_val[]{1729, 5188, 2594, 1297, 3892, 1946, 973, 2920, 1460, 730, 365, 1096, 548,
-            274, 137, 412, 206, 103, 310, 155, 466, 233, 700, 350, 175, 526, 263, 790, 395, 1186, 593, 1780, 890, 445,
-            1336, 668, 334, 167, 502, 251, 754, 377, 1132, 566, 283, 850, 425, 1276, 638, 319, 958, 479, 1438, 719,
-            2158, 1079, 3238, 1619, 4858, 2429, 7288, 3644, 1822, 911, 2734, 1367, 4102, 2051, 6154, 3077, 9232, 4616,
-            2308, 1154, 577, 1732, 866, 433, 1300, 650, 325, 976, 488, 244, 122, 61, 184, 92, 46, 23, 70, 35, 106, 53,
-            160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1, -1000};
-        assert(equal(vec.begin(), vec.end(), begin(expected_val), end(expected_val)));
-    }
-
-    {
-        puts("Testing <streambuf>.");
-        istringstream iss{"kittens"};
-        assert(iss.rdbuf()->in_avail() == 7);
-    }
-
-    {
-        puts("Testing <string_view>.");
-        constexpr string_view catenary{"catenary"};
-        assert(catenary.starts_with("cat"));
-        assert(!catenary.starts_with("dog"));
-        static_assert(catenary.starts_with("cat"));
-        static_assert(!catenary.starts_with("dog"));
-    }
-
-    {
-        puts("Testing <string>.");
-        const string small_string{"homeowner"};
-        const string large_string{"Cute fluffy kittens are so adorable when they meow and purr."};
-        assert(small_string.find("meow") == 2);
-        assert(large_string.find("meow") == 46);
-    }
-
-    {
-        puts("Testing <strstream>.");
-        istrstream istr{"1729"};
-        int n = -1;
-        istr >> n;
-        assert(n == 1729);
-    }
-
-    {
-        puts("Testing <syncstream>.");
-        syncbuf sync_buf{nullptr};
-        assert(sync_buf.get_wrapped() == nullptr);
-        assert(sync_buf.get_allocator() == allocator<char>{});
-        assert(sync_buf.emit() == false);
-        osyncstream sync_str{cout};
-        sync_str << "Testing P1502R1_standard_library_header_units.\n";
-        assert(sync_str.rdbuf()->get_wrapped() == cout.rdbuf());
-    }
-
-    {
-        puts("Testing <system_error>.");
-        const error_code code = make_error_code(errc::value_too_large);
-        assert(code.value() == static_cast<int>(errc::value_too_large));
-        assert(code.category() == generic_category());
-        assert(code);
-    }
-
-    {
-        puts("Testing <thread>.");
-        // see above, tested with <condition_variable>
-        assert(this_thread::get_id() != thread::id{});
-    }
-
-    {
-        puts("Testing <tuple>.");
-        constexpr tuple<int, char, double> t{1729, 'c', 1.25};
-        assert(get<int>(t) == 1729);
-        assert(get<char>(t) == 'c');
-        assert(get<double>(t) == 1.25);
-        static_assert(get<int>(t) == 1729);
-        static_assert(get<char>(t) == 'c');
-        static_assert(get<double>(t) == 1.25);
-    }
-
-    {
-        puts("Testing <type_traits>.");
-        static_assert(is_void_v<void>);
-        static_assert(!is_void_v<double>);
-        static_assert(is_same_v<remove_extent_t<int[10][20][30]>, int[20][30]>);
-        static_assert(is_same_v<remove_extent_t<double>, double>);
-
-        constexpr auto compiletime_10_or_runtime_20 = [] {
-            if (is_constant_evaluated()) {
-                return 10;
-            } else {
-                return 20;
-            }
-        };
-
-        assert(compiletime_10_or_runtime_20() == 20);
-        static_assert(compiletime_10_or_runtime_20() == 10);
-    }
-
-    {
-        puts("Testing <typeindex>.");
-        const type_index ti_int{typeid(int)};
-        type_index ti{typeid(double)};
-        assert(ti != ti_int);
-        ti = ti_int;
-        assert(ti == ti_int);
-    }
-
-    {
-        puts("Testing <typeinfo>.");
-        const type_info& t1 = typeid(int);
-        const type_info& t2 = typeid(const int&);
-        const type_info& t3 = typeid(double);
-        assert(t1 == t2);
-        assert(t1 != t3);
-    }
-
-    {
-        puts("Testing <unordered_map>.");
-        unordered_map<int, int> um{{1, 1}, {2, 4}, {3, 9}, {4, 16}, {5, 25}};
-        for (const auto& p : um) {
-            assert(p.first * p.first == p.second);
-        }
-    }
-
-    {
-        puts("Testing <unordered_set>.");
-        unordered_set<int> us{10, 20, 30, 40, 50};
-        for (const auto& elem : us) {
-            assert(elem % 10 == 0);
-        }
-    }
-
-    {
-        puts("Testing <utility>.");
-        constexpr pair<int, double> p{44, 5.5};
-        assert(p.first == 44);
-        assert(p.second == 5.5);
-        static_assert(p.first == 44);
-        static_assert(p.second == 5.5);
-
-        assert(in_range<unsigned char>(200));
-        assert(!in_range<unsigned char>(300));
-        static_assert(in_range<unsigned char>(200));
-        static_assert(!in_range<unsigned char>(300));
-
-        static_assert(is_same_v<make_integer_sequence<int, 4>, integer_sequence<int, 0, 1, 2, 3>>);
-        static_assert(is_same_v<decltype(declval<short>() + declval<unsigned short>()), int>);
-    }
-
-    {
-        puts("Testing <valarray>.");
-        valarray<int> val{1, 2, 3};
-        val *= 10;
-        assert(val[0] == 10 && val[1] == 20 && val[2] == 30);
-    }
-
-    {
-        puts("Testing <variant>.");
-        constexpr const char* cats = "CATS";
-        constexpr variant<int, const char*, double> var{in_place_type<const char*>, cats};
-        static_assert(var.index() == 1);
-        static_assert(holds_alternative<const char*>(var));
-        static_assert(get<const char*>(var) == cats);
-        assert(var.index() == 1);
-        assert(holds_alternative<const char*>(var));
-        assert(get<const char*>(var) == cats);
-
-        constexpr variant<short, float, double> var2{in_place_type<double>, 2.5};
-        assert(var2.index() == 2);
-        assert(holds_alternative<double>(var2));
-        assert(get<double>(var2) == 2.5);
-        static_assert(var2.index() == 2);
-        static_assert(holds_alternative<double>(var2));
-        static_assert(get<double>(var2) == 2.5);
-    }
-
-    {
-        puts("Testing <vector>.");
-        const vector<int> v{10, 20, 30, 40, 50};
-        assert(v[2] == 30);
-
-        const vector<bool> vb{true, true, false, true};
-        assert(vb[0] && vb[1] && !vb[2] && vb[3]);
-    }
+// SPECIAL: This is order-dependent and must be included after all other Standard imports/includes.
+#include <test_header_units_and_modules.hpp>
 
-    {
-        puts("Testing <version>.");
-        static_assert(__cpp_lib_make_unique >= 201304L);
-    }
+int main() {
+    all_cpp_header_tests();
 }
diff --git a/tests/std/tests/P2465R3_standard_library_modules/__init__.py b/tests/std/tests/P2465R3_standard_library_modules/__init__.py
new file mode 100644
index 0000000000..2ac2a854cb
--- /dev/null
+++ b/tests/std/tests/P2465R3_standard_library_modules/__init__.py
@@ -0,0 +1,2 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
diff --git a/tests/std/tests/P2465R3_standard_library_modules/classic.cpp b/tests/std/tests/P2465R3_standard_library_modules/classic.cpp
new file mode 100644
index 0000000000..b5d1e97114
--- /dev/null
+++ b/tests/std/tests/P2465R3_standard_library_modules/classic.cpp
@@ -0,0 +1,12 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// This translation unit exists to keep the classic #include directives isolated.
+
+#include <assert.h> // intentionally not <cassert>
+
+#include <force_include.hpp>
+
+void prepare_test_environment() {
+    assert(test_environment_preparer.succeeded());
+}
diff --git a/tests/std/tests/P2465R3_standard_library_modules/custom_format.py b/tests/std/tests/P2465R3_standard_library_modules/custom_format.py
new file mode 100644
index 0000000000..3f5dbd3ef3
--- /dev/null
+++ b/tests/std/tests/P2465R3_standard_library_modules/custom_format.py
@@ -0,0 +1,33 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+import os
+
+from stl.test.format import STLTestFormat, TestStep
+from stl.test.tests import TestType
+
+
+class CustomTestFormat(STLTestFormat):
+    def getBuildSteps(self, test, litConfig, shared):
+        outputDir, outputBase = test.getTempPaths()
+
+        stdIxx = os.path.join(litConfig.cxx_modules, 'std.ixx')
+        stdCompatIxx = os.path.join(litConfig.cxx_modules, 'std.compat.ixx')
+
+        testCpp = test.getSourcePath()
+        sourceDir = os.path.dirname(testCpp)
+        test2Cpp = os.path.join(sourceDir, 'test2.cpp')
+        classicCpp = os.path.join(sourceDir, 'classic.cpp')
+
+        # Dependency order is important here:
+        inputPaths = [stdIxx, stdCompatIxx, testCpp, test2Cpp, classicCpp]
+
+        cmd = [test.cxx, *inputPaths, *test.flags, *test.compileFlags]
+
+        if TestType.COMPILE in test.testType:
+            cmd += ['/c']
+        elif TestType.RUN in test.testType:
+            shared.execFile = f'{outputBase}.exe'
+            cmd += [f'/Fe{shared.execFile}', '/link', *test.linkFlags]
+
+        yield TestStep(cmd, shared.execDir, shared.env, False)
diff --git a/tests/std/tests/P2465R3_standard_library_modules/custombuild.pl b/tests/std/tests/P2465R3_standard_library_modules/custombuild.pl
new file mode 100644
index 0000000000..72dfff2de1
--- /dev/null
+++ b/tests/std/tests/P2465R3_standard_library_modules/custombuild.pl
@@ -0,0 +1,23 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+use strict;
+use warnings;
+
+use Run;
+
+sub CustomBuildHook()
+{
+    my $cwd = Run::GetCWDName();
+
+    my $stlModulesDir = $ENV{STL_MODULES_DIR};
+
+    my $stdIxx = "$stlModulesDir\\std.ixx";
+    my $stdCompatIxx = "$stlModulesDir\\std.compat.ixx";
+
+    # Dependency order is important here:
+    my @inputPaths = ($stdIxx, $stdCompatIxx, "test.cpp", "test2.cpp", "classic.cpp");
+
+    Run::ExecuteCL(join(" ", @inputPaths, "/Fe$cwd.exe"));
+}
+1
diff --git a/tests/std/tests/P2465R3_standard_library_modules/env.lst b/tests/std/tests/P2465R3_standard_library_modules/env.lst
new file mode 100644
index 0000000000..141724e0d4
--- /dev/null
+++ b/tests/std/tests/P2465R3_standard_library_modules/env.lst
@@ -0,0 +1,18 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\..\..\universal_prefix.lst
+RUNALL_CROSSLIST
+PM_CL="/w14365 /D_ENFORCE_FACET_SPECIALIZATIONS=1 /D_STL_CALL_ABORT_INSTEAD_OF_INVALID_PARAMETER"
+RUNALL_CROSSLIST
+PM_CL="/w14640 /Zc:threadSafeInit- /EHsc /std:c++latest"
+RUNALL_CROSSLIST
+PM_CL="/Zc:preprocessor"
+RUNALL_CROSSLIST
+PM_CL="/MD"
+PM_CL="/MDd"
+PM_CL="/MT"
+PM_CL="/MTd"
+RUNALL_CROSSLIST
+PM_CL=""
+PM_CL="/analyze:only /analyze:autolog-"
diff --git a/tests/std/tests/P2465R3_standard_library_modules/lit.local.cfg b/tests/std/tests/P2465R3_standard_library_modules/lit.local.cfg
new file mode 100644
index 0000000000..5e2b9cea89
--- /dev/null
+++ b/tests/std/tests/P2465R3_standard_library_modules/lit.local.cfg
@@ -0,0 +1,9 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+import os
+import site
+site.addsitedir(os.path.dirname(os.path.dirname(__file__)))
+import P2465R3_standard_library_modules.custom_format
+
+config.test_format = P2465R3_standard_library_modules.custom_format.CustomTestFormat()
diff --git a/tests/std/tests/P2465R3_standard_library_modules/test.cpp b/tests/std/tests/P2465R3_standard_library_modules/test.cpp
new file mode 100644
index 0000000000..8621cba0c8
--- /dev/null
+++ b/tests/std/tests/P2465R3_standard_library_modules/test.cpp
@@ -0,0 +1,197 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+import std;
+
+#include <assert.h> // intentionally not <cassert>
+
+// SPECIAL: This is order-dependent and must be included after all other Standard imports/includes.
+#include <test_header_units_and_modules.hpp>
+
+// INTENTIONALLY AVOIDED: using namespace std;
+
+void prepare_test_environment();
+void all_std_cmeow_tests();
+void test_module_std_compat();
+
+int main() {
+    prepare_test_environment(); // defined in classic.cpp
+    all_cpp_header_tests(); // defined in test_header_units_and_modules.hpp
+    all_std_cmeow_tests(); // defined below
+    test_module_std_compat(); // defined in test2.cpp
+}
+
+void test_std_cassert() {
+    std::puts("Nothing to test in <cassert>, only macros.");
+}
+
+void test_std_cctype() {
+    std::puts("Testing <cctype>.");
+    assert(std::isalpha('b'));
+    assert(!std::isalpha('2'));
+}
+
+void test_std_cerrno() {
+    std::puts("Nothing to test in <cerrno>, only macros.");
+}
+
+void test_std_cfenv() {
+    std::puts("Testing <cfenv>.");
+    assert(std::fegetround() >= 0);
+}
+
+void test_std_cfloat() {
+    std::puts("Nothing to test in <cfloat>, only macros.");
+}
+
+void test_std_cinttypes() {
+    std::puts("Testing <cinttypes>.");
+    assert(std::strtoumax("0xABCDEF0123456789", nullptr, 0) == 0xABCDEF0123456789ull);
+}
+
+void test_std_climits() {
+    std::puts("Nothing to test in <climits>, only macros.");
+}
+
+void test_std_clocale() {
+    std::puts("Testing <clocale>.");
+    const std::lconv* const ptr = std::localeconv();
+    assert(ptr != nullptr);
+}
+
+void test_std_cmath() {
+    std::puts("Testing <cmath>.");
+
+    // Test C++'s Sufficient Additional Overloads
+    assert(std::sqrt(25.0) == 5.0);
+    assert(std::sqrt(25.0f) == 5.0f);
+    assert(std::sqrt(25) == 5.0);
+    static_assert(std::is_same_v<decltype(std::sqrt(25.0)), double>);
+    static_assert(std::is_same_v<decltype(std::sqrt(25.0f)), float>);
+    static_assert(std::is_same_v<decltype(std::sqrt(25)), double>);
+
+    // Test C's hypot(x, y), C++'s hypot(x, y, z), and Sufficient Additional Overloads
+    assert(std::hypot(3.0, 4.0) == 5.0);
+    assert(std::hypot(3.0f, 4.0f) == 5.0f);
+    assert(std::hypot(3, 4) == 5.0);
+    static_assert(std::is_same_v<decltype(std::hypot(3.0, 4.0)), double>);
+    static_assert(std::is_same_v<decltype(std::hypot(3.0f, 4.0f)), float>);
+    static_assert(std::is_same_v<decltype(std::hypot(3, 4)), double>);
+
+    assert(std::hypot(2.0, 3.0, 6.0) == 7.0);
+    assert(std::round(std::hypot(2.0f, 3.0f, 6.0f)) == 7.0f); // compensate for rounding error
+    assert(std::hypot(2, 3, 6) == 7.0);
+    static_assert(std::is_same_v<decltype(std::hypot(2.0, 3.0, 6.0)), double>);
+    static_assert(std::is_same_v<decltype(std::hypot(2.0f, 3.0f, 6.0f)), float>);
+    static_assert(std::is_same_v<decltype(std::hypot(2, 3, 6)), double>);
+
+    // Test C++'s lerp()
+    assert(std::lerp(100.0, 110.0, 0.25) == 102.5);
+
+    // Test C++'s Special Math
+    const double rz3 = std::riemann_zeta(3.0);
+    assert(rz3 > 1.2020569031);
+    assert(rz3 < 1.2020569032);
+}
+
+void test_std_csetjmp() {
+    std::puts("Testing <csetjmp>.");
+    static_assert(sizeof(std::jmp_buf) > 0);
+}
+
+void test_std_csignal() {
+    std::puts("Testing <csignal>.");
+    static_assert(sizeof(std::sig_atomic_t) > 0);
+}
+
+void test_std_cstdarg() {
+    std::puts("Testing <cstdarg>.");
+    static_assert(sizeof(std::va_list) > 0);
+}
+
+void test_std_cstddef() {
+    std::puts("Testing <cstddef>.");
+    static_assert(std::is_signed_v<std::ptrdiff_t>);
+
+    // Test C++'s byte
+    std::byte b{0x33};
+    b |= std::byte{0x85};
+    assert(std::to_integer<unsigned char>(b) == 0xB7);
+
+    // Test C++'s nullptr_t
+    static_assert(std::nullptr_t{} == nullptr);
+}
+
+void test_std_cstdint() {
+    std::puts("Testing <cstdint>.");
+    static_assert(std::is_unsigned_v<std::uint16_t>);
+}
+
+#pragma warning(push)
+#pragma warning(disable : 4996) // was declared deprecated
+void test_std_cstdio() {
+    std::puts("Testing <cstdio>.");
+    double dbl{0.0};
+    assert(std::sscanf("-3.25", "%lg", &dbl) == 1);
+    assert(dbl == -3.25);
+}
+#pragma warning(pop)
+
+void test_std_cstdlib() {
+    std::puts("Testing <cstdlib>.");
+    assert(std::strtod("7.125", nullptr) == 7.125);
+}
+
+void test_std_cstring() {
+    std::puts("Testing <cstring>.");
+    assert(std::strcmp("cats", "dogs") < 0);
+}
+
+void test_std_ctime() {
+    std::puts("Testing <ctime>.");
+    const std::time_t now = std::time(nullptr);
+    assert(now > 0);
+}
+
+void test_std_cuchar() {
+    std::puts("Testing <cuchar>.");
+    char32_t c32{};
+    std::mbstate_t state{};
+    assert(std::mbrtoc32(&c32, "x", 1, &state) == 1);
+    assert(c32 == U'x');
+}
+
+void test_std_cwchar() {
+    std::puts("Testing <cwchar>.");
+    assert(std::wcslen(L"cute fluffy kittens") == 19);
+}
+
+void test_std_cwctype() {
+    std::puts("Testing <cwctype>.");
+    assert(std::iswalpha(L'b'));
+    assert(!std::iswalpha(L'2'));
+}
+
+void all_std_cmeow_tests() {
+    test_std_cassert();
+    test_std_cctype();
+    test_std_cerrno();
+    test_std_cfenv();
+    test_std_cfloat();
+    test_std_cinttypes();
+    test_std_climits();
+    test_std_clocale();
+    test_std_cmath();
+    test_std_csetjmp();
+    test_std_csignal();
+    test_std_cstdarg();
+    test_std_cstddef();
+    test_std_cstdint();
+    test_std_cstdio();
+    test_std_cstdlib();
+    test_std_cstring();
+    test_std_ctime();
+    test_std_cuchar();
+    test_std_cwchar();
+    test_std_cwctype();
+}
diff --git a/tests/std/tests/P2465R3_standard_library_modules/test2.cpp b/tests/std/tests/P2465R3_standard_library_modules/test2.cpp
new file mode 100644
index 0000000000..0cd158dd15
--- /dev/null
+++ b/tests/std/tests/P2465R3_standard_library_modules/test2.cpp
@@ -0,0 +1,213 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+import std.compat;
+
+#include <assert.h> // intentionally not <cassert>
+
+// INTENTIONALLY AVOIDED: using namespace std;
+
+void test_export_import_std() {
+    ::puts("std.compat: Testing `export import std;`.");
+
+    // Verify that std::vector is available:
+    const std::vector<int> v{10, 20, 30, 40, 50};
+    assert(v[2] == 30);
+
+    // Verify that `::operator new` is available:
+    const int* const ptr = new (std::nothrow) int{1729};
+    assert(ptr);
+    assert(*ptr == 1729);
+    delete ptr;
+
+    // Verify that the Sufficient Additional Overloads are available for std::sqrt():
+    assert(std::sqrt(25.0) == 5.0);
+    assert(std::sqrt(25.0f) == 5.0f);
+    assert(std::sqrt(25) == 5.0);
+    static_assert(std::is_same_v<decltype(std::sqrt(25.0)), double>);
+    static_assert(std::is_same_v<decltype(std::sqrt(25.0f)), float>);
+    static_assert(std::is_same_v<decltype(std::sqrt(25)), double>);
+}
+
+template <typename Void, typename... Args>
+struct IsGlobalHypotCallableImpl : std::false_type {};
+
+template <typename... Args>
+struct IsGlobalHypotCallableImpl<std::void_t<decltype(::hypot(std::declval<Args>()...))>, Args...> : std::true_type {};
+
+template <typename... Args>
+constexpr bool IsGlobalHypotCallable = IsGlobalHypotCallableImpl<void, Args...>::value;
+
+void test_binary_hypot() {
+    ::puts("std.compat: Testing binary hypot().");
+
+    // hypot() is special. C's hypot(x, y) and C++'s Sufficient Additional Overloads
+    // are defined in the global namespace, then dragged into namespace std.
+    // C++'s hypot(x, y, z) (and its Sufficient Additional Overloads) are defined directly within namespace std.
+    // Therefore, the std.compat module should provide only 2-arg hypot() in the global namespace, not 3-arg.
+
+    static_assert(IsGlobalHypotCallable<double, double>);
+    static_assert(IsGlobalHypotCallable<float, float>);
+    static_assert(IsGlobalHypotCallable<int, int>);
+
+    static_assert(!IsGlobalHypotCallable<double, double, double>);
+    static_assert(!IsGlobalHypotCallable<float, float, float>);
+    static_assert(!IsGlobalHypotCallable<int, int, int>);
+
+    assert(::hypot(3.0, 4.0) == 5.0);
+    assert(::hypot(3.0f, 4.0f) == 5.0f);
+    assert(::hypot(3, 4) == 5.0);
+    static_assert(std::is_same_v<decltype(::hypot(3.0, 4.0)), double>);
+    static_assert(std::is_same_v<decltype(::hypot(3.0f, 4.0f)), float>);
+    static_assert(std::is_same_v<decltype(::hypot(3, 4)), double>);
+}
+
+void test_global_cassert() {
+    ::puts("std.compat: Nothing to test in <cassert>, only macros.");
+}
+
+void test_global_cctype() {
+    ::puts("std.compat: Testing <cctype>.");
+    assert(::isalpha('b'));
+    assert(!::isalpha('2'));
+}
+
+void test_global_cerrno() {
+    ::puts("std.compat: Nothing to test in <cerrno>, only macros.");
+}
+
+void test_global_cfenv() {
+    ::puts("std.compat: Testing <cfenv>.");
+    assert(::fegetround() >= 0);
+}
+
+void test_global_cfloat() {
+    ::puts("std.compat: Nothing to test in <cfloat>, only macros.");
+}
+
+void test_global_cinttypes() {
+    ::puts("std.compat: Testing <cinttypes>.");
+    assert(::strtoumax("0xABCDEF0123456789", nullptr, 0) == 0xABCDEF0123456789ull);
+}
+
+void test_global_climits() {
+    ::puts("std.compat: Nothing to test in <climits>, only macros.");
+}
+
+void test_global_clocale() {
+    ::puts("std.compat: Testing <clocale>.");
+    const ::lconv* const ptr = ::localeconv();
+    assert(ptr != nullptr);
+}
+
+void test_global_cmath() {
+    ::puts("std.compat: Testing <cmath>.");
+
+    // Verify that the Sufficient Additional Overloads are available for ::sqrt():
+    assert(::sqrt(25.0) == 5.0);
+    assert(::sqrt(25.0f) == 5.0f);
+    assert(::sqrt(25) == 5.0);
+    static_assert(std::is_same_v<decltype(::sqrt(25.0)), double>);
+    static_assert(std::is_same_v<decltype(::sqrt(25.0f)), float>);
+    static_assert(std::is_same_v<decltype(::sqrt(25)), double>);
+}
+
+void test_global_csetjmp() {
+    ::puts("std.compat: Testing <csetjmp>.");
+    static_assert(sizeof(::jmp_buf) > 0);
+}
+
+void test_global_csignal() {
+    ::puts("std.compat: Testing <csignal>.");
+    static_assert(sizeof(::sig_atomic_t) > 0);
+}
+
+void test_global_cstdarg() {
+    ::puts("std.compat: Testing <cstdarg>.");
+    static_assert(sizeof(::va_list) > 0);
+}
+
+void test_global_cstddef() {
+    ::puts("std.compat: Testing <cstddef>.");
+    static_assert(std::is_signed_v<::ptrdiff_t>);
+}
+
+void test_global_cstdint() {
+    ::puts("std.compat: Testing <cstdint>.");
+    static_assert(std::is_unsigned_v<::uint16_t>);
+}
+
+#pragma warning(push)
+#pragma warning(disable : 4996) // was declared deprecated
+void test_global_cstdio() {
+    ::puts("std.compat: Testing <cstdio>.");
+    double dbl{0.0};
+    assert(::sscanf("-3.25", "%lg", &dbl) == 1);
+    assert(dbl == -3.25);
+}
+#pragma warning(pop)
+
+void test_global_cstdlib() {
+    ::puts("std.compat: Testing <cstdlib>.");
+    assert(::strtod("7.125", nullptr) == 7.125);
+}
+
+void test_global_cstring() {
+    ::puts("std.compat: Testing <cstring>.");
+    assert(::strcmp("cats", "dogs") < 0);
+}
+
+void test_global_ctime() {
+    ::puts("std.compat: Testing <ctime>.");
+    const ::time_t now = ::time(nullptr);
+    assert(now > 0);
+}
+
+void test_global_cuchar() {
+    ::puts("std.compat: Testing <cuchar>.");
+    char32_t c32{};
+    ::mbstate_t state{};
+    assert(::mbrtoc32(&c32, "x", 1, &state) == 1);
+    assert(c32 == U'x');
+}
+
+void test_global_cwchar() {
+    ::puts("std.compat: Testing <cwchar>.");
+    assert(::wcslen(L"cute fluffy kittens") == 19);
+}
+
+void test_global_cwctype() {
+    ::puts("std.compat: Testing <cwctype>.");
+    assert(::iswalpha(L'b'));
+    assert(!::iswalpha(L'2'));
+}
+
+void all_global_cmeow_tests() {
+    test_global_cassert();
+    test_global_cctype();
+    test_global_cerrno();
+    test_global_cfenv();
+    test_global_cfloat();
+    test_global_cinttypes();
+    test_global_climits();
+    test_global_clocale();
+    test_global_cmath();
+    test_global_csetjmp();
+    test_global_csignal();
+    test_global_cstdarg();
+    test_global_cstddef();
+    test_global_cstdint();
+    test_global_cstdio();
+    test_global_cstdlib();
+    test_global_cstring();
+    test_global_ctime();
+    test_global_cuchar();
+    test_global_cwchar();
+    test_global_cwctype();
+}
+
+void test_module_std_compat() {
+    test_export_import_std();
+    test_binary_hypot();
+    all_global_cmeow_tests();
+}
diff --git a/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp b/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
index af5509b10c..0913ac86e8 100644
--- a/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
+++ b/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
@@ -1316,6 +1316,20 @@ STATIC_ASSERT(__cpp_lib_memory_resource == 201603L);
 #endif
 #endif
 
+#if _HAS_CXX23 && !defined(__clang__) && !defined(__EDG__) // TRANSITION, Clang and EDG support for modules
+#ifndef __cpp_lib_modules
+#error __cpp_lib_modules is not defined
+#elif __cpp_lib_modules != 202207L
+#error __cpp_lib_modules is not 202207L
+#else
+STATIC_ASSERT(__cpp_lib_modules == 202207L);
+#endif
+#else
+#ifdef __cpp_lib_modules
+#error __cpp_lib_modules is defined
+#endif
+#endif
+
 #ifdef __cpp_lib_concepts
 #ifndef __cpp_lib_move_iterator_concept
 #error __cpp_lib_move_iterator_concept is not defined
diff --git a/tools/format/CMakeLists.txt b/tools/format/CMakeLists.txt
index 677b4cf261..f411d3cad5 100644
--- a/tools/format/CMakeLists.txt
+++ b/tools/format/CMakeLists.txt
@@ -37,6 +37,7 @@ if(CLANG_FORMAT)
         "../../benchmarks/inc/*"
         "../../benchmarks/src/*"
         "../../stl/inc/*"
+        "../../stl/modules/*"
         "../../stl/src/*"
         "../../tests/*"
         "../../tools/*"
@@ -47,7 +48,7 @@ if(CLANG_FORMAT)
         cmake_path(GET maybe_file FILENAME filename)
         cmake_path(GET maybe_file EXTENSION LAST_ONLY extension)
 
-        if(extension MATCHES [[^(|\.cpp|\.h|\.hpp)$]] AND NOT filename MATCHES [[^\.]])
+        if(extension MATCHES [[^(|\.cpp|\.h|\.hpp|\.ixx)$]] AND NOT filename MATCHES [[^\.]])
             list(APPEND clang_format_files "${maybe_file}")
         endif()
     endforeach()