Index: include/pstl/internal/algorithm_impl.h
===================================================================
--- include/pstl/internal/algorithm_impl.h
+++ include/pstl/internal/algorithm_impl.h
@@ -929,7 +929,7 @@
     auto __count_true = _DifferenceType(0);
     auto __size = __last - __first;
 
-    static_assert(internal::is_random_access_iterator<_ForwardIterator>::value,
+    static_assert(internal::__is_random_access_iterator<_ForwardIterator>::value,
                   "Pattern-brick error. Should be a random access iterator.");
 
     for (; __first != __last; ++__first, ++__mask)
@@ -2511,7 +2511,7 @@
 __pattern_generate_n(_ExecutionPolicy&& __exec, _OutputIterator __first, _Size __count, _Generator __g,
                      /*is_parallel=*/std::true_type, _IsVector __is_vector)
 {
-    static_assert(internal::is_random_access_iterator<_OutputIterator>::value,
+    static_assert(internal::__is_random_access_iterator<_OutputIterator>::value,
                   "Pattern-brick error. Should be a random access iterator.");
     return internal::__pattern_generate(std::forward<_ExecutionPolicy>(__exec), __first, __first + __count, __g,
                                         std::true_type(), __is_vector);
Index: include/pstl/internal/execution_impl.h
===================================================================
--- include/pstl/internal/execution_impl.h
+++ include/pstl/internal/execution_impl.h
@@ -25,54 +25,54 @@
 /* predicate */
 
 template <typename _Tp>
-std::false_type lazy_and(_Tp, std::false_type)
+std::false_type __lazy_and(_Tp, std::false_type)
 {
     return std::false_type{};
 };
 
 template <typename _Tp>
 inline _Tp
-lazy_and(_Tp __a, std::true_type)
+__lazy_and(_Tp __a, std::true_type)
 {
     return __a;
 }
 
 template <typename _Tp>
-std::true_type lazy_or(_Tp, std::true_type)
+std::true_type __lazy_or(_Tp, std::true_type)
 {
     return std::true_type{};
 };
 
 template <typename _Tp>
 inline _Tp
-lazy_or(_Tp __a, std::false_type)
+__lazy_or(_Tp __a, std::false_type)
 {
     return __a;
 }
 
 /* iterator */
 template <typename _IteratorType, typename... _OtherIteratorTypes>
-struct is_random_access_iterator
+struct __is_random_access_iterator
 {
     static constexpr bool value =
-        is_random_access_iterator<_IteratorType>::value && is_random_access_iterator<_OtherIteratorTypes...>::value;
+        __is_random_access_iterator<_IteratorType>::value && __is_random_access_iterator<_OtherIteratorTypes...>::value;
     typedef std::integral_constant<bool, value> type;
 };
 
 template <typename _IteratorType>
-struct is_random_access_iterator<_IteratorType>
+struct __is_random_access_iterator<_IteratorType>
     : std::is_same<typename std::iterator_traits<_IteratorType>::iterator_category, std::random_access_iterator_tag>
 {
 };
 
 /* policy */
 template <typename Policy>
-struct policy_traits
+struct __policy_traits
 {
 };
 
 template <>
-struct policy_traits<sequenced_policy>
+struct __policy_traits<sequenced_policy>
 {
     typedef std::false_type allow_parallel;
     typedef std::false_type allow_unsequenced;
@@ -80,7 +80,7 @@
 };
 
 template <>
-struct policy_traits<unsequenced_policy>
+struct __policy_traits<unsequenced_policy>
 {
     typedef std::false_type allow_parallel;
     typedef std::true_type allow_unsequenced;
@@ -89,7 +89,7 @@
 
 #if __PSTL_USE_PAR_POLICIES
 template <>
-struct policy_traits<parallel_policy>
+struct __policy_traits<parallel_policy>
 {
     typedef std::true_type allow_parallel;
     typedef std::false_type allow_unsequenced;
@@ -97,7 +97,7 @@
 };
 
 template <>
-struct policy_traits<parallel_unsequenced_policy>
+struct __policy_traits<parallel_unsequenced_policy>
 {
     typedef std::true_type allow_parallel;
     typedef std::true_type allow_unsequenced;
@@ -106,46 +106,50 @@
 #endif
 
 template <typename _ExecutionPolicy>
-using collector_t = typename policy_traits<typename std::decay<_ExecutionPolicy>::type>::collector_type;
+using __collector_t = typename __policy_traits<typename std::decay<_ExecutionPolicy>::type>::__collector_type;
 
 template <typename _ExecutionPolicy>
-using allow_vector = typename internal::policy_traits<typename std::decay<_ExecutionPolicy>::type>::allow_vector;
+using __allow_vector = typename internal::__policy_traits<typename std::decay<_ExecutionPolicy>::type>::__allow_vector;
 
 template <typename _ExecutionPolicy>
-using allow_unsequenced =
-    typename internal::policy_traits<typename std::decay<_ExecutionPolicy>::type>::allow_unsequenced;
+using __allow_unsequenced =
+    typename internal::__policy_traits<typename std::decay<_ExecutionPolicy>::type>::__allow_unsequenced;
 
 template <typename _ExecutionPolicy>
-using allow_parallel = typename internal::policy_traits<typename std::decay<_ExecutionPolicy>::type>::allow_parallel;
+using __allow_parallel =
+    typename internal::__policy_traits<typename std::decay<_ExecutionPolicy>::type>::__allow_parallel;
 
 template <typename _ExecutionPolicy, typename... _IteratorTypes>
 auto
-is_vectorization_preferred(_ExecutionPolicy&& __exec)
-    -> decltype(lazy_and(__exec.__allow_vector(), typename is_random_access_iterator<_IteratorTypes...>::type()))
+__is_vectorization_preferred(_ExecutionPolicy&& __exec)
+    -> decltype(__lazy_and(__exec.__allow_vector(), typename __is_random_access_iterator<_IteratorTypes...>::type()))
 {
-    return internal::lazy_and(__exec.__allow_vector(), typename is_random_access_iterator<_IteratorTypes...>::type());
+    return internal::__lazy_and(__exec.__allow_vector(),
+                                typename __is_random_access_iterator<_IteratorTypes...>::type());
 }
 
 template <typename _ExecutionPolicy, typename... _IteratorTypes>
 auto
-is_parallelization_preferred(_ExecutionPolicy&& __exec)
-    -> decltype(lazy_and(__exec.__allow_parallel(), typename is_random_access_iterator<_IteratorTypes...>::type()))
+__is_parallelization_preferred(_ExecutionPolicy&& __exec)
+    -> decltype(__lazy_and(__exec.__allow_parallel(), typename __is_random_access_iterator<_IteratorTypes...>::type()))
 {
-    return internal::lazy_and(__exec.__allow_parallel(), typename is_random_access_iterator<_IteratorTypes...>::type());
+    return internal::__lazy_and(__exec.__allow_parallel(),
+                                typename __is_random_access_iterator<_IteratorTypes...>::type());
 }
 
 template <typename policy, typename... _IteratorTypes>
-struct prefer_unsequenced_tag
+struct __prefer_unsequenced_tag
 {
     static constexpr bool value =
-        allow_unsequenced<policy>::value && is_random_access_iterator<_IteratorTypes...>::value;
+        __allow_unsequenced<policy>::value && __is_random_access_iterator<_IteratorTypes...>::value;
     typedef std::integral_constant<bool, value> type;
 };
 
 template <typename policy, typename... _IteratorTypes>
-struct prefer_parallel_tag
+struct __prefer_parallel_tag
 {
-    static constexpr bool value = allow_parallel<policy>::value && is_random_access_iterator<_IteratorTypes...>::value;
+    static constexpr bool value =
+        __allow_parallel<policy>::value && __is_random_access_iterator<_IteratorTypes...>::value;
     typedef std::integral_constant<bool, value> type;
 };
 
Index: include/pstl/internal/glue_algorithm_impl.h
===================================================================
--- include/pstl/internal/glue_algorithm_impl.h
+++ include/pstl/internal/glue_algorithm_impl.h
@@ -29,8 +29,8 @@
     using namespace __pstl;
     return internal::__pattern_any_of(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
 }
 
 // [alg.all_of]
@@ -60,8 +60,8 @@
 {
     using namespace __pstl;
     internal::__pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last, __f,
-                              internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
-                              internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+                              internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+                              internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Function>
@@ -71,8 +71,8 @@
     using namespace __pstl;
     return internal::__pattern_walk1_n(
         std::forward<_ExecutionPolicy>(__exec), __first, __n, __f,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
 }
 
 // [alg.find]
@@ -84,8 +84,8 @@
     using namespace __pstl;
     return internal::__pattern_find_if(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
@@ -113,8 +113,8 @@
     using namespace __pstl;
     return internal::__pattern_find_end(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, __pred,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
@@ -135,8 +135,8 @@
     using namespace __pstl;
     return internal::__pattern_find_first_of(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, __pred,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
@@ -157,8 +157,8 @@
     using namespace __pstl;
     return internal::__pattern_adjacent_find(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, std::equal_to<_ValueType>(),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), /*first_semantic*/ false);
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), /*first_semantic*/ false);
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
@@ -168,8 +168,8 @@
     using namespace __pstl;
     return internal::__pattern_adjacent_find(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred,
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), /*first_semantic*/ false);
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), /*first_semantic*/ false);
 }
 
 // [alg.count]
@@ -184,10 +184,11 @@
 {
     typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
     using namespace __pstl;
-    return internal::__pattern_count(std::forward<_ExecutionPolicy>(__exec), __first, __last,
-                                     [&__value](const _ValueType& __x) { return __value == __x; },
-                                     internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
-                                     internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+    return internal::__pattern_count(
+        std::forward<_ExecutionPolicy>(__exec), __first, __last,
+        [&__value](const _ValueType& __x) { return __value == __x; },
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
@@ -196,9 +197,10 @@
 count_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
 {
     using namespace __pstl;
-    return internal::__pattern_count(std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred,
-                                     internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
-                                     internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+    return internal::__pattern_count(
+        std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred,
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
 }
 
 // [alg.search]
@@ -211,8 +213,8 @@
     using namespace __pstl;
     return internal::__pattern_search(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, __pred,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
@@ -232,8 +234,8 @@
     using namespace __pstl;
     return internal::__pattern_search_n(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __count, __value, __pred,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp>
@@ -253,14 +255,14 @@
 {
     using namespace __pstl;
     const auto __is_vector =
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec);
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec);
 
     return internal::__pattern_walk2_brick(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __result,
         [__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _ForwardIterator2 __res) {
             return internal::__brick_copy(__begin, __end, __res, __is_vector);
         },
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2>
@@ -269,14 +271,14 @@
 {
     using namespace __pstl;
     const auto __is_vector =
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec);
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec);
 
     return internal::__pattern_walk2_brick_n(
         std::forward<_ExecutionPolicy>(__exec), __first, __n, __result,
         [__is_vector](_ForwardIterator1 __begin, _Size __sz, _ForwardIterator2 __res) {
             return internal::__brick_copy_n(__begin, __sz, __res, __is_vector);
         },
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
@@ -287,8 +289,8 @@
     using namespace __pstl;
     return internal::__pattern_copy_if(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __pred,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
 }
 
 // [alg.swap]
@@ -307,8 +309,8 @@
             using std::swap;
             swap(__x, __y);
         },
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
 }
 
 // [alg.transform]
@@ -324,8 +326,8 @@
     return internal::__pattern_walk2(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __result,
         [__op](_InputType __x, _OutputType __y) mutable { __y = __op(__x); },
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
@@ -341,10 +343,10 @@
     return internal::__pattern_walk3(
         std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __result,
         [__op](_Input1Type x, _Input2Type y, _OutputType z) mutable { z = __op(x, y); },
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>(
-            __exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
-                                               _ForwardIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
+                                               _ForwardIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
+                                                 _ForwardIterator>(__exec));
 }
 
 // [alg.replace]
@@ -363,8 +365,8 @@
                                       __elem = __new_value;
                                   }
                               },
-                              internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
-                              internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+                              internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+                              internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
@@ -387,8 +389,8 @@
     return internal::__pattern_walk2(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __result,
         [__pred, &__new_value](_InputType __x, _OutputType __y) mutable { __y = __pred(__x) ? __new_value : __x; },
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
@@ -408,8 +410,8 @@
 {
     using namespace __pstl;
     internal::__pattern_fill(std::forward<_ExecutionPolicy>(__exec), __first, __last, __value,
-                             internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
-                             internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+                             internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+                             internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp>
@@ -422,8 +424,8 @@
     using namespace __pstl;
     return internal::__pattern_fill_n(
         std::forward<_ExecutionPolicy>(__exec), __first, __count, __value,
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
 }
 
 // [alg.generate]
@@ -433,8 +435,8 @@
 {
     using namespace __pstl;
     internal::__pattern_generate(std::forward<_ExecutionPolicy>(__exec), __first, __last, __g,
-                                 internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
-                                 internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+                                 internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+                                 internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Generator>
@@ -447,8 +449,8 @@
     using namespace __pstl;
     return internal::__pattern_generate_n(
         std::forward<_ExecutionPolicy>(__exec), __first, __count, __g,
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
 }
 
 // [alg.remove]
@@ -478,8 +480,8 @@
     using namespace __pstl;
     return internal::__pattern_remove_if(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
@@ -499,8 +501,8 @@
     using namespace __pstl;
     return internal::__pattern_unique(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator>
@@ -518,8 +520,8 @@
     using namespace __pstl;
     return internal::__pattern_unique_copy(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __pred,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
@@ -538,8 +540,8 @@
     using namespace __pstl;
     internal::__pattern_reverse(
         std::forward<_ExecutionPolicy>(__exec), __first, __last,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _BidirectionalIterator, class _ForwardIterator>
@@ -550,8 +552,8 @@
     using namespace __pstl;
     return internal::__pattern_reverse_copy(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator, _ForwardIterator>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator, _ForwardIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator, _ForwardIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator, _ForwardIterator>(__exec));
 }
 
 // [alg.rotate]
@@ -563,8 +565,8 @@
     using namespace __pstl;
     return internal::__pattern_rotate(
         std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
@@ -575,8 +577,8 @@
     using namespace __pstl;
     return internal::__pattern_rotate_copy(
         std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, __result,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
 }
 
 // [alg.partitions]
@@ -588,8 +590,8 @@
     using namespace __pstl;
     return internal::__pattern_is_partitioned(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
@@ -599,8 +601,8 @@
     using namespace __pstl;
     return internal::__pattern_partition(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate>
@@ -611,8 +613,8 @@
     using namespace __pstl;
     return internal::__pattern_stable_partition(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _ForwardIterator1, class _ForwardIterator2,
@@ -624,10 +626,10 @@
     using namespace __pstl;
     return internal::__pattern_partition_copy(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __out_true, __out_false, __pred,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator, _ForwardIterator1, _ForwardIterator2>(
-            __exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator, _ForwardIterator1,
-                                               _ForwardIterator2>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator, _ForwardIterator1,
+                                               _ForwardIterator2>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator, _ForwardIterator1,
+                                                 _ForwardIterator2>(__exec));
 }
 
 // [alg.sort]
@@ -640,8 +642,8 @@
     using namespace __pstl;
     return internal::__pattern_sort(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec),
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec),
         typename std::is_move_constructible<_InputType>::type());
 }
 
@@ -662,8 +664,8 @@
     using namespace __pstl;
     return internal::__pattern_stable_sort(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _RandomAccessIterator>
@@ -684,8 +686,8 @@
     using namespace __pstl;
     return internal::__pattern_mismatch(
         std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __pred,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
@@ -725,8 +727,8 @@
     using namespace __pstl;
     return internal::__pattern_equal(
         std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __p,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
@@ -764,14 +766,14 @@
 {
     using namespace __pstl;
     const auto __is_vector =
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec);
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec);
 
     return internal::__pattern_walk2_brick(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first,
         [__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _ForwardIterator2 __res) {
             return internal::__brick_move(__begin, __end, __res, __is_vector);
         },
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
 }
 
 // [partial.sort]
@@ -784,8 +786,8 @@
     using namespace __pstl;
     internal::__pattern_partial_sort(
         std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, __comp,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _RandomAccessIterator>
@@ -807,8 +809,8 @@
     using namespace __pstl;
     return internal::__pattern_partial_sort_copy(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, __d_last, __comp,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator, _RandomAccessIterator>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator, _RandomAccessIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator, _RandomAccessIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator, _RandomAccessIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator>
@@ -828,8 +830,8 @@
     using namespace __pstl;
     const _ForwardIterator __res = internal::__pattern_adjacent_find(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __pstl::internal::__reorder_pred<_Compare>(__comp),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), /*first_semantic*/ false);
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), /*first_semantic*/ false);
     return __res == __last ? __last : std::next(__res);
 }
 
@@ -848,8 +850,8 @@
     using namespace __pstl;
     return internal::__pattern_adjacent_find(
                std::forward<_ExecutionPolicy>(__exec), __first, __last, internal::__reorder_pred<_Compare>(__comp),
-               internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
-               internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+               internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+               internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
                /*or_semantic*/ true) == __last;
 }
 
@@ -871,10 +873,10 @@
     using namespace __pstl;
     return internal::__pattern_merge(
         std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __d_first, __comp,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>(
-            __exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
-                                               _ForwardIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
+                                               _ForwardIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
+                                                 _ForwardIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
@@ -894,8 +896,8 @@
     using namespace __pstl;
     internal::__pattern_inplace_merge(
         std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, __comp,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _BidirectionalIterator>
@@ -917,8 +919,8 @@
     using namespace __pstl;
     return internal::__pattern_includes(
         std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __comp,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
@@ -941,10 +943,10 @@
     using namespace __pstl;
     return internal::__pattern_set_union(
         std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>(
-            __exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
-                                               _ForwardIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
+                                               _ForwardIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
+                                                 _ForwardIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
@@ -967,10 +969,10 @@
     using namespace __pstl;
     return internal::__pattern_set_intersection(
         std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>(
-            __exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
-                                               _ForwardIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
+                                               _ForwardIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
+                                                 _ForwardIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
@@ -993,10 +995,10 @@
     using namespace __pstl;
     return internal::__pattern_set_difference(
         std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>(
-            __exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
-                                               _ForwardIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
+                                               _ForwardIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
+                                                 _ForwardIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
@@ -1020,10 +1022,10 @@
     using namespace __pstl;
     return internal::__pattern_set_symmetric_difference(
         std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>(
-            __exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
-                                               _ForwardIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
+                                               _ForwardIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
+                                                 _ForwardIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
@@ -1043,8 +1045,8 @@
     using namespace __pstl;
     return internal::__pattern_is_heap_until(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _RandomAccessIterator>
@@ -1079,8 +1081,8 @@
     using namespace __pstl;
     return internal::__pattern_min_element(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator>
@@ -1115,8 +1117,8 @@
     using namespace __pstl;
     return internal::__pattern_minmax_element(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator>
@@ -1137,8 +1139,8 @@
     using namespace __pstl;
     internal::__pattern_nth_element(
         std::forward<_ExecutionPolicy>(__exec), __first, __nth, __last, __comp,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec));
 }
 
 template <class _ExecutionPolicy, class _RandomAccessIterator>
@@ -1160,8 +1162,8 @@
     using namespace __pstl;
     return internal::__pattern_lexicographical_compare(
         std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __comp,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
Index: include/pstl/internal/glue_memory_impl.h
===================================================================
--- include/pstl/internal/glue_memory_impl.h
+++ include/pstl/internal/glue_memory_impl.h
@@ -29,9 +29,9 @@
     using namespace __pstl;
 
     const auto __is_parallel =
-        internal::is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
     const auto __is_vector =
-        internal::is_vectorization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
 
     return internal::__invoke_if_else(
         std::integral_constant < bool, std::is_trivial<_ValueType1>::value&& std::is_trivial<_ValueType2>::value > (),
@@ -63,9 +63,9 @@
     using namespace __pstl;
 
     const auto __is_parallel =
-        internal::is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
     const auto __is_vector =
-        internal::is_vectorization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
 
     return internal::__invoke_if_else(
         std::integral_constant < bool, std::is_trivial<_ValueType1>::value&& std::is_trivial<_ValueType2>::value > (),
@@ -99,9 +99,9 @@
     using namespace __pstl;
 
     const auto __is_parallel =
-        internal::is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
     const auto __is_vector =
-        internal::is_vectorization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
 
     return internal::__invoke_if_else(
         std::integral_constant < bool, std::is_trivial<_ValueType1>::value&& std::is_trivial<_ValueType2>::value > (),
@@ -133,9 +133,9 @@
     using namespace __pstl;
 
     const auto __is_parallel =
-        internal::is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
     const auto __is_vector =
-        internal::is_vectorization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
 
     return internal::__invoke_if_else(
         std::integral_constant < bool, std::is_trivial<_ValueType1>::value&& std::is_trivial<_ValueType2>::value > (),
@@ -166,8 +166,8 @@
     typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType;
     using namespace __pstl;
 
-    const auto __is_parallel = internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
-    const auto __is_vector = internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+    const auto __is_parallel = internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+    const auto __is_vector = internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
 
     internal::__invoke_if_else(
         std::is_arithmetic<_ValueType>(),
@@ -194,8 +194,8 @@
     typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType;
     using namespace __pstl;
 
-    const auto __is_parallel = internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
-    const auto __is_vector = internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+    const auto __is_parallel = internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+    const auto __is_vector = internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
 
     return internal::__invoke_if_else(
         std::is_arithmetic<_ValueType>(),
@@ -225,8 +225,8 @@
     typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType;
     using namespace __pstl;
 
-    const auto __is_parallel = internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
-    const auto __is_vector = internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+    const auto __is_parallel = internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+    const auto __is_vector = internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
 
     internal::__invoke_if_not(std::is_trivially_destructible<_ValueType>(), [&]() {
         internal::__pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last,
@@ -242,8 +242,8 @@
     typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType;
     using namespace __pstl;
 
-    const auto __is_parallel = internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
-    const auto __is_vector = internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+    const auto __is_parallel = internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+    const auto __is_vector = internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
 
     return internal::__invoke_if_else(
         std::is_trivially_destructible<_ValueType>(), [&]() { return std::next(__first, __n); },
@@ -264,8 +264,8 @@
     typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType;
     using namespace __pstl;
 
-    const auto __is_parallel = internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
-    const auto __is_vector = internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+    const auto __is_parallel = internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+    const auto __is_vector = internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
 
     internal::__invoke_if_not(std::is_trivial<_ValueType>(), [&]() {
         internal::__pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last,
@@ -282,8 +282,8 @@
     typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType;
     using namespace __pstl;
 
-    const auto __is_parallel = internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
-    const auto __is_vector = internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+    const auto __is_parallel = internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+    const auto __is_vector = internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
 
     return internal::__invoke_if_else(std::is_trivial<_ValueType>(), [&]() { return std::next(__first, __n); },
                                       [&]() {
@@ -304,8 +304,8 @@
     typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType;
     using namespace __pstl;
 
-    const auto __is_parallel = internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
-    const auto __is_vector = internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+    const auto __is_parallel = internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+    const auto __is_vector = internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
 
     internal::__invoke_if_else(
         std::is_trivial<_ValueType>(),
@@ -331,8 +331,8 @@
     typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType;
     using namespace __pstl;
 
-    const auto __is_parallel = internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
-    const auto __is_vector = internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+    const auto __is_parallel = internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+    const auto __is_vector = internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
 
     return internal::__invoke_if_else(
         std::is_trivial<_ValueType>(),
Index: include/pstl/internal/glue_numeric_impl.h
===================================================================
--- include/pstl/internal/glue_numeric_impl.h
+++ include/pstl/internal/glue_numeric_impl.h
@@ -58,8 +58,8 @@
     return internal::__pattern_transform_reduce(
         std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __init, std::plus<_InputType>(),
         std::multiplies<_InputType>(),
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1,
@@ -71,8 +71,8 @@
     using namespace __pstl;
     return internal::__pattern_transform_reduce(
         std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __init, __binary_op1, __binary_op2,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation>
@@ -83,8 +83,8 @@
     using namespace __pstl;
     return internal::__pattern_transform_reduce(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __init, __binary_op, __unary_op,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
 }
 
 // [exclusive.scan]
@@ -150,8 +150,8 @@
     return internal::__pattern_transform_scan(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __unary_op, __init, __binary_op,
         /*inclusive=*/std::false_type(),
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
 }
 
 // [transform.inclusive.scan]
@@ -167,8 +167,8 @@
     return internal::__pattern_transform_scan(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __unary_op, __init, __binary_op,
         /*inclusive=*/std::true_type(),
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _UnaryOperation,
@@ -204,8 +204,8 @@
     using namespace __pstl;
     return internal::__pattern_adjacent_difference(
         std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, __op,
-        internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
-        internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+        internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+        internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>