Uglify backend

[rodgert]

Committed by other, non-phab, means

include/pstl/internal/algorithm_impl.h

 
 #if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator, class _Pred, class _IsVector>
 bool
 __pattern_any_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred,
                  _IsVector __is_vector, /*parallel=*/std::true_type)
 {
     return internal::__except_handler([&]() {
-        return internal::parallel_or(std::forward<_ExecutionPolicy>(__exec), __first, __last,
+        return internal::__parallel_or(std::forward<_ExecutionPolicy>(__exec), __first, __last,
                                        [__pred, __is_vector](_ForwardIterator __i, _ForwardIterator __j) {
                                            return internal::__brick_any_of(__i, __j, __pred, __is_vector);
                                        });
     });
 }
 #endif
 
 // [alg.foreach]
 // for_each_n with no policy
 
 template <class _ForwardIterator, class _Size, class _Function>

 #if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator, class _Function, class _IsVector>
 void
 __pattern_walk1(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Function __f,
                 _IsVector __is_vector,
                 /*parallel=*/std::true_type)
 {
     internal::__except_handler([&]() {
-        par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
+        par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
                                     [__f, __is_vector](_ForwardIterator __i, _ForwardIterator __j) {
                                         internal::__brick_walk1(__i, __j, __f, __is_vector);
                                     });
     });
 }
 #endif
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _Brick>
 void
 __pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Brick __brick,
                      /*parallel=*/std::false_type) noexcept
 {
     __brick(__first, __last);
 }
 
 #if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator, class _Brick>
 void
 __pattern_walk_brick(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Brick __brick,
                      /*parallel=*/std::true_type)
 {
     internal::__except_handler([&]() {
-        par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
+        par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
                                     [__brick](_ForwardIterator __i, _ForwardIterator __j) { __brick(__i, __j); });
     });
 }
 #endif
 
 //------------------------------------------------------------------------
 // walk1_n
 //------------------------------------------------------------------------
 template <class _ForwardIterator, class _Size, class _Function>

 
 #if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Brick>
 _RandomAccessIterator
 __pattern_walk_brick_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _Size __n, _Brick __brick,
                        /*is_parallel=*/std::true_type)
 {
     return internal::__except_handler([&]() {
-        par_backend::parallel_for(
+        par_backend::__parallel_for(
             std::forward<_ExecutionPolicy>(__exec), __first, __first + __n,
             [__brick](_RandomAccessIterator __i, _RandomAccessIterator __j) { __brick(__i, __j - __i); });
         return __first + __n;
     });
 }
 #endif
 
 //------------------------------------------------------------------------

 
 #if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector>
 _ForwardIterator2
 __pattern_walk2(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                 _ForwardIterator2 __first2, _Function __f, _IsVector __is_vector, /*parallel=*/std::true_type)
 {
     return internal::__except_handler([&]() {
-        par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first1, __last1,
-                                  [__f, __first1, __first2, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) {
-                                      internal::__brick_walk2(__i, __j, __first2 + (__i - __first1), __f, __is_vector);
-                                  });
+        par_backend::__parallel_for(
+            std::forward<_ExecutionPolicy>(__exec), __first1, __last1,
         return __first2 + (__last1 - __first1);
     });
 }
 #endif
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function,
           class _IsVector>
 _ForwardIterator2

 
 #if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Brick>
 _RandomAccessIterator2
 __pattern_walk2_brick(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
                       _RandomAccessIterator2 __first2, _Brick __brick, /*parallel=*/std::true_type)
 {
     return __except_handler([&]() {
-        par_backend::parallel_for(
+        par_backend::__parallel_for(
             std::forward<_ExecutionPolicy>(__exec), __first1, __last1,
             [__first1, __first2, __brick](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
                 __brick(__i, __j, __first2 + (__i - __first1));
             });
         return __first2 + (__last1 - __first1);
     });
 }
 #endif
 
 #if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2, class _Brick>
 _RandomAccessIterator2
 __pattern_walk2_brick_n(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _Size __n,
                         _RandomAccessIterator2 __first2, _Brick __brick, /*parallel=*/std::true_type)
 {
     return __except_handler([&]() {
-        par_backend::parallel_for(
+        par_backend::__parallel_for(
             std::forward<_ExecutionPolicy>(__exec), __first1, __first1 + __n,
             [__first1, __first2, __brick](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
                 __brick(__i, __j - __i, __first2 + (__i - __first1));
             });
         return __first2 + __n;
     });
 }
 #endif

 template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2,
           class _RandomAccessIterator3, class _Function, class _IsVector>
 _RandomAccessIterator3
 __pattern_walk3(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
                 _RandomAccessIterator2 __first2, _RandomAccessIterator3 __first3, _Function __f, _IsVector __is_vector,
                 /*parallel=*/std::true_type)
 {
     return internal::__except_handler([&]() {
-        par_backend::parallel_for(
+        par_backend::__parallel_for(
             std::forward<_ExecutionPolicy>(__exec), __first1, __last1,
             [__f, __first1, __first2, __first3, __is_vector](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
                 internal::__brick_walk3(__i, __j, __first2 + (__i - __first1), __first3 + (__i - __first1), __f,
                                         __is_vector);
             });
         return __first3 + (__last1 - __first1);
     });
 }

 template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate,
           class _IsVector>
 bool
 __pattern_equal(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
                 _RandomAccessIterator2 __first2, _BinaryPredicate __p, _IsVector __is_vector,
                 /*is_parallel=*/std::true_type)
 {
     return internal::__except_handler([&]() {
-        return !internal::parallel_or(
+        return !internal::__parallel_or(
             std::forward<_ExecutionPolicy>(__exec), __first1, __last1,
             [__first1, __first2, __p, __is_vector](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
                 return !__brick_equal(__i, __j, __first2 + (__i - __first1), __p, __is_vector);
             });
     });
 }
 #endif
 

 #if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
 _ForwardIterator
 __pattern_find_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
                   _IsVector __is_vector,
                   /*is_parallel=*/std::true_type)
 {
     return internal::__except_handler([&]() {
-        return internal::parallel_find(std::forward<_ExecutionPolicy>(__exec), __first, __last,
+        return internal::__parallel_find(std::forward<_ExecutionPolicy>(__exec), __first, __last,
                                          [__pred, __is_vector](_ForwardIterator __i, _ForwardIterator __j) {
                                              return internal::__brick_find_if(__i, __j, __pred, __is_vector);
                                          },
                                          std::less<typename std::iterator_traits<_ForwardIterator>::difference_type>(),
                                          /*is_first=*/true);
     });
 }
 #endif
 
 //------------------------------------------------------------------------
 // find_end
 //------------------------------------------------------------------------
 
__pattern_find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
     {
         const bool __res = internal::__pattern_equal(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first,
                                                      __pred, __is_vector, std::true_type());
         return __res ? __first : __last;
     }
     else
     {
         return __except_handler([&]() {
-            return internal::parallel_find(
+            return internal::__parallel_find(
                 std::forward<_ExecutionPolicy>(__exec), __first, __last,
                 [__last, __s_first, __s_last, __pred, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) {
                     return internal::find_subrange(__i, __j, __last, __s_first, __s_last, __pred, false, __is_vector);
                 },
                 std::greater<typename std::iterator_traits<_ForwardIterator1>::difference_type>(), /*is_first=*/false);
         });
     }
 }

 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
           class _IsVector>
 _ForwardIterator1
 __pattern_find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
                         _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred,
                         _IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept
 {
     return __except_handler([&]() {
-        return internal::parallel_find(
+        return internal::__parallel_find(
             std::forward<_ExecutionPolicy>(__exec), __first, __last,
             [__s_first, __s_last, __pred, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) {
                 return internal::__brick_find_first_of(__i, __j, __s_first, __s_last, __pred, __is_vector);
             },
             std::less<typename std::iterator_traits<_ForwardIterator1>::difference_type>(), /*is_first=*/true);
     });
 }
 #endif
__pattern_search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
     {
         const bool __res = internal::__pattern_equal(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first,
                                                      __pred, __is_vector, std::true_type());
         return __res ? __first : __last;
     }
     else
     {
         return __except_handler([&]() {
-            return internal::parallel_find(
+            return internal::__parallel_find(
                 std::forward<_ExecutionPolicy>(__exec), __first, __last,
                 [__last, __s_first, __s_last, __pred, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) {
                     return internal::find_subrange(__i, __j, __last, __s_first, __s_last, __pred, true, __is_vector);
                 },
                 std::less<typename std::iterator_traits<_ForwardIterator1>::difference_type>(), /*is_first=*/true);
         });
     }
 }
if (__last - __first == __count)
             !internal::__pattern_any_of(std::forward<_ExecutionPolicy>(__exec), __first, __last,
                                         [&__value, &__pred](const _Tp& __val) { return !__pred(__val, __value); },
                                         __is_vector, /*is_parallel*/ std::true_type());
         return __result ? __first : __last;
     }
     else
     {
         return __except_handler([&__exec, __first, __last, __count, &__value, __pred, __is_vector]() {
-            return internal::parallel_find(
+            return internal::__parallel_find(
                 std::forward<_ExecutionPolicy>(__exec), __first, __last,
                 [__last, __count, &__value, __pred, __is_vector](_RandomAccessIterator __i, _RandomAccessIterator __j) {
                     return internal::find_subrange(__i, __j, __last, __count, __value, __pred, __is_vector);
                 },
                 std::less<typename std::iterator_traits<_RandomAccessIterator>::difference_type>(), /*is_first=*/true);
         });
     }
 }

 _OutputIterator
 __pattern_copy_if(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
                   _OutputIterator __result, _UnaryPredicate __pred, _IsVector __is_vector, /*parallel=*/std::true_type)
 {
     typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
     const _DifferenceType __n = __last - __first;
     if (_DifferenceType(1) < __n)
     {
-        par_backend::buffer<bool> __mask_buf(__n);
+        par_backend::__buffer<bool> __mask_buf(__n);
         return __except_handler([&__exec, __n, __first, __result, __is_vector, __pred, &__mask_buf]() {
             bool* __mask = __mask_buf.get();
             _DifferenceType __m{};
             par_backend::parallel_strict_scan(
                 std::forward<_ExecutionPolicy>(__exec), __n, _DifferenceType(0),
                 [=](_DifferenceType __i, _DifferenceType __len) { // Reduce
                     return __brick_calc_mask_1<_DifferenceType>(__first + __i, __first + (__i + __len), __mask + __i,
                                                                 __pred, __is_vector)

 #if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
 typename std::iterator_traits<_ForwardIterator>::difference_type
 __pattern_count(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
                 /* is_parallel */ std::true_type, _IsVector __is_vector)
 {
     typedef typename std::iterator_traits<_ForwardIterator>::difference_type _SizeType;
     return __except_handler([&]() {
-        return par_backend::parallel_reduce(
+        return par_backend::__parallel_reduce(
             std::forward<_ExecutionPolicy>(__exec), __first, __last, _SizeType(0),
             [__pred, __is_vector](_ForwardIterator __begin, _ForwardIterator __end, _SizeType __value) -> _SizeType {
                 return __value + __brick_count(__begin, __end, __pred, __is_vector);
             },
             std::plus<_SizeType>());
     });
 }
 #endif

 template <class _ExecutionPolicy, class _ForwardIterator, class _CalcMask, class _IsVector>
 _ForwardIterator
 remove_elements(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _CalcMask __calc_mask,
                 _IsVector __is_vector)
 {
     typedef typename std::iterator_traits<_ForwardIterator>::difference_type _DifferenceType;
     typedef typename std::iterator_traits<_ForwardIterator>::value_type _Tp;
     _DifferenceType __n = __last - __first;
-    par_backend::buffer<bool> __mask_buf(__n);
+    par_backend::__buffer<bool> __mask_buf(__n);
     // 1. find a first iterator that should be removed
     return __except_handler([&]() {
         bool* __mask = __mask_buf.get();
-        _DifferenceType __min = par_backend::parallel_reduce(
+        _DifferenceType __min = par_backend::__parallel_reduce(
             std::forward<_ExecutionPolicy>(__exec), _DifferenceType(0), __n, __n,
             [__first, __mask, &__calc_mask, __is_vector](_DifferenceType __i, _DifferenceType __j,
                                                          _DifferenceType __local_min) -> _DifferenceType {
                 // Create mask
                 __calc_mask(__mask + __i, __mask + __j, __first + __i);
 
                 // if minimum was found in a previous range we shouldn't do anymore
                 if (__local_min < __i)
return __except_handler([&]() {
         // No elements to remove - exit
         if (__min == __n)
         {
             return __last;
         }
         __n -= __min;
         __first += __min;
 
-        par_backend::buffer<_Tp> __buf(__n);
+        par_backend::__buffer<_Tp> __buf(__n);
         _Tp* __result = __buf.get();
         __mask += __min;
         _DifferenceType __m{};
         // 2. Elements that doesn't satisfy pred are moved to result
         par_backend::parallel_strict_scan(
             std::forward<_ExecutionPolicy>(__exec), __n, _DifferenceType(0),
             [__mask, __is_vector](_DifferenceType __i, _DifferenceType __len) {
                 return __brick_count(__mask + __i, __mask + __i + __len, [](bool __val) { return __val; }, __is_vector);
             },
             std::plus<_DifferenceType>(),
             [=](_DifferenceType __i, _DifferenceType __len, _DifferenceType __initial) {
                 __brick_copy_by_mask(__first + __i, __first + __i + __len, __result + __initial, __mask + __i,
                                      [](_ForwardIterator __x, _Tp* __z) {
                                          __invoke_if_else(std::is_trivial<_Tp>(), [&]() { *__z = std::move(*__x); },
                                                           [&]() { ::new (std::addressof(*__z)) _Tp(std::move(*__x)); });
                                      },
                                      __is_vector);
             },
             [&__m](_DifferenceType __total) { __m = __total; });
 
         // 3. Elements from result are moved to [first, last)
-        par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __result, __result + __m,
+        par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __result, __result + __m,
                                     [__result, __first, __is_vector](_Tp* __i, _Tp* __j) {
                                         __brick_move(__i, __j, __first + (__i - __result), __is_vector);
                                     });
         return __first + __m;
     });
 }
 #endif
 
 #if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector>
 _ForwardIterator

 __pattern_unique_copy(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
                       _OutputIterator __result, _BinaryPredicate __pred, _IsVector __is_vector,
                       /*parallel=*/std::true_type)
 {
     typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
     const _DifferenceType __n = __last - __first;
     if (_DifferenceType(2) < __n)
     {
-        par_backend::buffer<bool> __mask_buf(__n);
+        par_backend::__buffer<bool> __mask_buf(__n);
         if (_DifferenceType(2) < __n)
         {
             return internal::__except_handler([&__exec, __n, __first, __result, __pred, __is_vector, &__mask_buf]() {
                 bool* __mask = __mask_buf.get();
                 _DifferenceType __m{};
                 par_backend::parallel_strict_scan(
                     std::forward<_ExecutionPolicy>(__exec), __n, _DifferenceType(0),
                     [=](_DifferenceType __i, _DifferenceType __len) -> _DifferenceType { // Reduce

 }
 
 #if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _BidirectionalIterator, class _IsVector>
 void
 __pattern_reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
                   _IsVector __is_vector, /*is_parallel=*/std::true_type)
 {
-    par_backend::parallel_for(
+    par_backend::__parallel_for(
         std::forward<_ExecutionPolicy>(__exec), __first, __first + (__last - __first) / 2,
         [__is_vector, __first, __last](_BidirectionalIterator __inner_first, _BidirectionalIterator __inner_last) {
             __brick_reverse(__inner_first, __inner_last, __last - (__inner_first - __first), __is_vector);
         });
 }
 #endif
 
 //------------------------------------------------------------------------

 
 #if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _BidirectionalIterator, class _OutputIterator, class _IsVector>
 _OutputIterator
 __pattern_reverse_copy(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
                        _OutputIterator __d_first, _IsVector __is_vector, /*is_parallel=*/std::true_type)
 {
     auto __len = __last - __first;
-    par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
+    par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
                                 [__is_vector, __first, __len, __d_first](_BidirectionalIterator __inner_first,
                                                                          _BidirectionalIterator __inner_last) {
                                     __brick_reverse_copy(__inner_first, __inner_last,
                                                          __d_first + (__len - (__inner_last - __first)), __is_vector);
                                 });
     return __d_first + __len;
 }
 #endif
 
 //------------------------------------------------------------------------
 // rotate
 //------------------------------------------------------------------------
 template <class _ForwardIterator>

 __pattern_rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle,
                  _ForwardIterator __last, _IsVector __is_vector, /*is_parallel=*/std::true_type)
 {
     typedef typename std::iterator_traits<_ForwardIterator>::value_type _Tp;
     auto __n = __last - __first;
     auto __m = __middle - __first;
     if (__m <= __n / 2)
     {
-        par_backend::buffer<_Tp> __buf(__n - __m);
+        par_backend::__buffer<_Tp> __buf(__n - __m);
         return __except_handler([&__exec, __n, __m, __first, __middle, __last, __is_vector, &__buf]() {
             _Tp* __result = __buf.get();
-            par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __middle, __last,
+            par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __middle, __last,
                                         [__middle, __result, __is_vector](_ForwardIterator __b, _ForwardIterator __e) {
                                             __brick_uninitialized_move(__b, __e, __result + (__b - __middle),
                                                                        __is_vector);
                                         });
 
-            par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __middle,
+            par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __middle,
                                         [__last, __middle, __is_vector](_ForwardIterator __b, _ForwardIterator __e) {
                                             __brick_move(__b, __e, __b + (__last - __middle), __is_vector);
                                         });
 
-            par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __result, __result + (__n - __m),
+            par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __result, __result + (__n - __m),
                                         [__first, __result, __is_vector](_Tp* __b, _Tp* __e) {
                                             __brick_move(__b, __e, __first + (__b - __result), __is_vector);
                                         });
 
             return __first + (__last - __middle);
         });
     }
     else
     {
-        par_backend::buffer<_Tp> __buf(__m);
+        par_backend::__buffer<_Tp> __buf(__m);
         return __except_handler([&__exec, __n, __m, __first, __middle, __last, __is_vector, &__buf]() {
             _Tp* __result = __buf.get();
-            par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __middle,
+            par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __middle,
                                         [__first, __result, __is_vector](_ForwardIterator __b, _ForwardIterator __e) {
-                                          __brick_uninitialized_move(__b, __e, __result + (__b - __first), __is_vector);
+                                            __brick_uninitialized_move(__b, __e, __result + (__b - __first),
+                                                                       __is_vector);
                                         });
 
-            par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __middle, __last,
+            par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __middle, __last,
                                         [__first, __middle, __is_vector](_ForwardIterator __b, _ForwardIterator __e) {
                                             __brick_move(__b, __e, __first + (__b - __middle), __is_vector);
                                         });
 
-            par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __result, __result + __m,
+            par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __result, __result + __m,
                                         [__n, __m, __first, __result, __is_vector](_Tp* __b, _Tp* __e) {
                                             __brick_move(__b, __e, __first + ((__n - __m) + (__b - __result)),
                                                          __is_vector);
                                         });
 
             return __first + (__last - __middle);
         });
     }
 }
 #endif
 
 //------------------------------------------------------------------------

 
 #if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _IsVector>
 _OutputIterator
 __pattern_rotate_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle,
                       _ForwardIterator __last, _OutputIterator __result, _IsVector __is_vector,
                       /*is_parallel=*/std::true_type)
 {
-    par_backend::parallel_for(
+    par_backend::__parallel_for(
         std::forward<_ExecutionPolicy>(__exec), __first, __last,
         [__first, __last, __middle, __result, __is_vector](_ForwardIterator __b, _ForwardIterator __e) {
             if (__b > __middle)
             {
                 __brick_copy(__b, __e, __result + (__b - __middle), __is_vector);
             }
             else
             {
else
             _ReduceType __init = __not_init;
 
             // Array with states that we'll have when state from the left branch is merged with state from the right branch.
             // State is calculated by formula: new_state = table[left_state * 4 + right_state]
             _ReduceType __table[] = {__broken,     __broken,     __broken,     __broken, __broken,    __all_true,
                                      __true_false, __true_false, __broken,     __broken, __all_false, __broken,
                                      __broken,     __broken,     __true_false, __broken};
 
-            __init = par_backend::parallel_reduce(
+            __init = par_backend::__parallel_reduce(
                 std::forward<_ExecutionPolicy>(__exec), __first, __last, __init,
                 [&__pred, &__table, __is_vector](_ForwardIterator __i, _ForwardIterator __j,
                                                  _ReduceType __value) -> _ReduceType {
                     if (__value == __broken)
                     {
                         return __broken;
                     }
                     _ReduceType __res = __not_init;
                     // if first element satisfy pred
                     if (__pred(*__i))
                     {
                         // find first element that don't satisfy pred
                         _ForwardIterator __x =
                             __brick_find_if(__i + 1, __j, __not_pred<_UnaryPredicate>(__pred), __is_vector);
-      
                         if (__x != __j)
                         {
                             // find first element after "x" that satisfy pred
                             _ForwardIterator __y = __brick_find_if(__x + 1, __j, __pred, __is_vector);
                             // if it was found then range isn't partitioned by pred
                             if (__y != __j)
                             {
                                 return __broken;
return __except_handler([&]() {
             if (__val1.__end == __val1.__pivot)
             {
                 return {__new_begin, __val2.__pivot, __val2.__end};
             }
             // if true part of right range greater than false part of left range
             // then we should swap the false part of left range and last part of true part of right range
             else if (__size2 > __size1)
             {
-                par_backend::parallel_for(
+                par_backend::__parallel_for(
                     std::forward<_ExecutionPolicy>(__exec), __val1.__pivot, __val1.__pivot + __size1,
                     [__val1, __val2, __size1, __is_vector](_ForwardIterator __i, _ForwardIterator __j) {
                         __brick_swap_ranges(__i, __j, (__val2.__pivot - __size1) + (__i - __val1.__pivot), __is_vector);
                     });
                 return {__new_begin, __val2.__pivot - __size1, __val2.__end};
             }
             // else we should swap the first part of false part of left range and true part of right range
             else
             {
-                par_backend::parallel_for(
+                par_backend::__parallel_for(
                     std::forward<_ExecutionPolicy>(__exec), __val1.__pivot, __val1.__pivot + __size2,
                     [__val1, __val2, __is_vector](_ForwardIterator __i, _ForwardIterator __j) {
                         __brick_swap_ranges(__i, __j, __val2.__begin + (__i - __val1.__pivot), __is_vector);
                     });
                 return {__new_begin, __val1.__pivot + __size2, __val2.__end};
             }
         };
 
-        _PartitionRange __result =
-            par_backend::parallel_reduce(std::forward<_ExecutionPolicy>(__exec), __first, __last, __init,
-                                         [__pred, __is_vector, __reductor](_ForwardIterator __i, _ForwardIterator __j,
-                                                                           _PartitionRange __value) -> _PartitionRange {
-                                             //1. serial partition
-                                             _ForwardIterator __pivot =
-                                                 __brick_partition(__i, __j, __pred, __is_vector);
+        _PartitionRange __result = par_backend::__parallel_reduce(
+            std::forward<_ExecutionPolicy>(__exec), __first, __last, __init,
+                _ForwardIterator __pivot = __brick_partition(__i, __j, __pred, __is_vector);
 
-                                             // 2. merging of two ranges (left and right respectively)
-                                             return __reductor(__value, {__i, __pivot, __j});
-                                         },
-                                         __reductor);
         return __result.__pivot;
     });
 }
 #endif
 
 //------------------------------------------------------------------------
 // stable_partition
 //------------------------------------------------------------------------
return __except_handler([&]() {
             // then we should swap the false part of left range and last part of true part of right range
             else
             {
                 __brick_rotate(__val1.__pivot, __val2.__begin, __val2.__pivot, __is_vector);
                 return {__new_begin, __val2.__pivot - __size1, __val2.__end};
             }
         };
 
-        _PartitionRange __result = par_backend::parallel_reduce(
+        _PartitionRange __result = par_backend::__parallel_reduce(
             std::forward<_ExecutionPolicy>(__exec), __first, __last, __init,
             [&__pred, __is_vector, __reductor](_BidirectionalIterator __i, _BidirectionalIterator __j,
                                                _PartitionRange __value) -> _PartitionRange {
                 //1. serial stable_partition
                 _BidirectionalIterator __pivot = __brick_stable_partition(__i, __j, __pred, __is_vector);
 
                 // 2. merging of two ranges (left and right respectively)
                 return __reductor(__value, {__i, __pivot, __j});
__pattern_partition_copy(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
                          _OutputIterator1 __out_true, _OutputIterator2 __out_false, _UnaryPredicate __pred,
                          _IsVector __is_vector, /*is_parallelization=*/std::true_type)
 {
     typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
     typedef std::pair<_DifferenceType, _DifferenceType> _ReturnType;
     const _DifferenceType __n = __last - __first;
     if (_DifferenceType(1) < __n)
     {
-        par_backend::buffer<bool> __mask_buf(__n);
+        par_backend::__buffer<bool> __mask_buf(__n);
         return internal::__except_handler(
             [&__exec, __n, __first, __out_true, __out_false, __is_vector, __pred, &__mask_buf]() {
                 bool* __mask = __mask_buf.get();
                 _ReturnType __m{};
                 par_backend::parallel_strict_scan(
                     std::forward<_ExecutionPolicy>(__exec), __n, std::make_pair(_DifferenceType(0), _DifferenceType(0)),
                     [=](_DifferenceType __i, _DifferenceType __len) { // Reduce
                         return internal::__brick_calc_mask_1<_DifferenceType>(__first + __i, __first + (__i + __len),

 
 #if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
 void
 __pattern_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
                _IsVector /*is_vector*/, /*is_parallel=*/std::true_type, /*is_move_constructible=*/std::true_type)
 {
     __except_handler([&]() {
-        par_backend::parallel_stable_sort(std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp,
+        par_backend::__parallel_stable_sort(std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp,
                                             [](_RandomAccessIterator __first, _RandomAccessIterator __last,
                                                _Compare __comp) { std::sort(__first, __last, __comp); },
                                             __last - __first);
     });
 }
 #endif
 
 //------------------------------------------------------------------------
 // stable_sort
 //------------------------------------------------------------------------
 
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
 void
 __pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
                       _IsVector /*is_vector*/, /*is_parallel=*/std::false_type) noexcept
 {
     std::stable_sort(__first, __last, __comp);
 }
 
 #if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
 void
 __pattern_stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
                       _Compare __comp, _IsVector /*is_vector*/, /*is_parallel=*/std::true_type)
 {
     internal::__except_handler([&]() {
-        par_backend::parallel_stable_sort(std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp,
+        par_backend::__parallel_stable_sort(std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp,
                                             [](_RandomAccessIterator __first, _RandomAccessIterator __last,
                                                _Compare __comp) { std::stable_sort(__first, __last, __comp); });
     });
 }
 #endif
 
 //------------------------------------------------------------------------
 // partial_sort
 //------------------------------------------------------------------------
 

 #if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
 void
 __pattern_partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle,
                        _RandomAccessIterator __last, _Compare __comp, _IsVector, /*is_parallel=*/std::true_type)
 {
     const auto __n = __middle - __first;
     __except_handler([&]() {
-        par_backend::parallel_stable_sort(
+        par_backend::__parallel_stable_sort(
             std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp,
             [__n](_RandomAccessIterator __begin, _RandomAccessIterator __end, _Compare __comp) {
                 if (__n < __end - __begin)
                     std::partial_sort(__begin, __begin + __n, __end, __comp);
                 else
                     std::sort(__begin, __end, __comp);
             },
             __n);
__pattern_partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
     {
         return __d_first;
     }
     auto __n1 = __last - __first;
     auto __n2 = __d_last - __d_first;
     return __except_handler([&]() {
         if (__n2 >= __n1)
         {
-            par_backend::parallel_stable_sort(
+            par_backend::__parallel_stable_sort(
                 std::forward<_ExecutionPolicy>(__exec), __d_first, __d_first + __n1, __comp,
                 [__first, __d_first, __is_vector](_RandomAccessIterator __i, _RandomAccessIterator __j,
                                                   _Compare __comp) {
                     _ForwardIterator __i1 = __first + (__i - __d_first);
                     _ForwardIterator __j1 = __first + (__j - __d_first);
 
                 // 1. Copy elements from input to output
 #if !__PSTL_ICC_18_OMP_SIMD_BROKEN
                     __brick_copy(__i1, __j1, __i, __is_vector);
 #else
                     std::copy(__i1, __j1, __i);
 #endif
                     // 2. Sort elements in output sequence
                     std::sort(__i, __j, __comp);
                 },
                 __n1);
             return __d_first + __n1;
         }
         else
         {
             typedef typename std::iterator_traits<_ForwardIterator>::value_type _T1;
             typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _T2;
-            par_backend::buffer<_T1> __buf(__n1);
+            par_backend::__buffer<_T1> __buf(__n1);
             _T1* __r = __buf.get();
 
-            par_backend::parallel_stable_sort(std::forward<_ExecutionPolicy>(__exec), __r, __r + __n1, __comp,
+            par_backend::__parallel_stable_sort(std::forward<_ExecutionPolicy>(__exec), __r, __r + __n1, __comp,
                                                 [__n2, __first, __r](_T1* __i, _T1* __j, _Compare __comp) {
                                                     _ForwardIterator __it = __first + (__i - __r);
 
                                                     // 1. Copy elements from input to raw memory
                                                     for (_T1* __k = __i; __k != __j; ++__k, ++__it)
                                                     {
                                                         ::new (__k) _T2(*__it);
                                                     }
 
-                                                  // 2. Sort elements in temporary buffer
+                                                    // 2. Sort elements in temporary __buffer
                                                     if (__n2 < __j - __i)
                                                         std::partial_sort(__i, __i + __n2, __j, __comp);
                                                     else
                                                         std::sort(__i, __j, __comp);
                                                 },
                                                 __n2);
 
-            // 3. Move elements from temporary buffer to output
-            par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __r, __r + __n2,
+            // 3. Move elements from temporary __buffer to output
+            par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __r, __r + __n2,
                                         [__r, __d_first, __is_vector](_T1* __i, _T1* __j) {
                                             __brick_move(__i, __j, __d_first + (__i - __r), __is_vector);
                                         });
             return __d_first + __n2;
         }
     });
 }
 #endif
 
 //------------------------------------------------------------------------
 // adjacent_find

 __pattern_adjacent_find(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
                         _BinaryPredicate __pred, /* is_parallel */ std::true_type, _IsVector __is_vector,
                         bool __or_semantic)
 {
     if (__last - __first < 2)
         return __last;
 
     return internal::__except_handler([&]() {
-        return par_backend::parallel_reduce(
+        return par_backend::__parallel_reduce(
             std::forward<_ExecutionPolicy>(__exec), __first, __last, __last,
             [__last, __pred, __is_vector, __or_semantic](_RandomAccessIterator __begin, _RandomAccessIterator __end,
                                                          _RandomAccessIterator __value) -> _RandomAccessIterator {
                 // TODO: investigate performance benefits from the use of shared variable for the result,
                 // checking (compare_and_swap idiom) its __value at __first.
                 if (__or_semantic && __value < __last)
                 { //found
-                    par_backend::cancel_execution();
+                    par_backend::__cancel_execution();
                     return __value;
                 }
 
                 if (__value > __begin)
                 {
                     // modify __end to check the predicate on the boundary __values;
                     // TODO: to use a custom range with boundaries overlapping
                     // TODO: investigate what if we remove "if" below and run algorithm on range [__first, __last-1)

 
 #if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _IsVector>
 _ForwardIterator
 __pattern_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value,
                /*is_parallel=*/std::true_type, _IsVector __is_vector)
 {
     return __except_handler([&__exec, __first, __last, &__value, __is_vector]() {
-        par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
+        par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
                                     [&__value, __is_vector](_ForwardIterator __begin, _ForwardIterator __end) {
                                         internal::__brick_fill(__begin, __end, __value, __is_vector);
                                     });
         return __last;
     });
 }
 #endif
 
 template <class _OutputIterator, class _Size, class _Tp>
 _OutputIterator
 __brick_fill_n(_OutputIterator __first, _Size __count, const _Tp& __value, /* __is_vector = */ std::true_type) noexcept

 
 #if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator, class _Generator, class _IsVector>
 _ForwardIterator
 __pattern_generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g,
                    /*is_parallel=*/std::true_type, _IsVector __is_vector)
 {
     return internal::__except_handler([&]() {
-        par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
+        par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
                                     [__g, __is_vector](_ForwardIterator __begin, _ForwardIterator __end) {
                                         internal::__brick_generate(__begin, __end, __g, __is_vector);
                                     });
         return __last;
     });
 }
 #endif
 
 template <class OutputIterator, class Size, class _Generator>
 OutputIterator
 __brick_generate_n(OutputIterator __first, Size __count, _Generator __g, /* is_vector = */ std::true_type) noexcept

 #if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator,
           class _Compare, class _IsVector>
 _OutputIterator
 __pattern_merge(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
                 _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _OutputIterator __d_first,
                 _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type)
 {
-    par_backend::parallel_merge(
+    par_backend::__parallel_merge(
         std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __d_first, __comp,
         [__is_vector](_RandomAccessIterator1 __f1, _RandomAccessIterator1 __l1, _RandomAccessIterator2 __f2,
                       _RandomAccessIterator2 __l2, _OutputIterator __f3,
                       _Compare __comp) { return __brick_merge(__f1, __l1, __f2, __l2, __f3, __comp, __is_vector); });
     return __d_first + (__last1 - __first1) + (__last2 - __first2);
 }
 #endif
 
__pattern_inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle,
                         /*is_parallel=*/std::true_type)
 {
     if (__first == __last || __first == __middle || __middle == __last)
     {
         return;
     }
     typedef typename std::iterator_traits<_BidirectionalIterator>::value_type _Tp;
     auto __n = __last - __first;
-    par_backend::buffer<_Tp> __buf(__n);
+    par_backend::__buffer<_Tp> __buf(__n);
     _Tp* __r = __buf.get();
     __except_handler([&]() {
         auto __move_values = [](_BidirectionalIterator __x, _Tp* __z) {
             __invoke_if_else(std::is_trivial<_Tp>(), [&]() { *__z = std::move(*__x); },
                              [&]() { ::new (std::addressof(*__z)) _Tp(std::move(*__x)); });
         };
 
         auto __move_sequences = [](_BidirectionalIterator __first1, _BidirectionalIterator __last1, _Tp* __first2) {
             return __brick_uninitialized_move(__first1, __last1, __first2, _IsVector());
         };
 
-        par_backend::parallel_merge(
+        par_backend::__parallel_merge(
             std::forward<_ExecutionPolicy>(__exec), __first, __middle, __middle, __last, __r, __comp,
             [__n, __move_values, __move_sequences](_BidirectionalIterator __f1, _BidirectionalIterator __l1,
                                                    _BidirectionalIterator __f2, _BidirectionalIterator __l2, _Tp* __f3,
                                                    _Compare __comp) {
-                auto __func = par_backend::serial_move_merge<decltype(__move_values), decltype(__move_sequences)>(
+                auto __func = par_backend::__serial_move_merge<decltype(__move_values), decltype(__move_sequences)>(
                     __n, __move_values, __move_sequences);
                 __func(__f1, __l1, __f2, __l2, __f3, __comp);
                 return __f3 + (__l1 - __f1) + (__l2 - __f2);
             });
-        par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __r, __r + __n,
+        par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __r, __r + __n,
                                     [__r, __first, __is_vector](_Tp* __i, _Tp* __j) {
                                         __brick_move(__i, __j, __first + (__i - __r), __is_vector);
                                     });
     });
 }
 #endif
 
 //------------------------------------------------------------------------
 // includes
 //------------------------------------------------------------------------
 
__pattern_includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
     __first1 = std::lower_bound(__first1, __last1, *__first2, __comp);
     if (__first1 == __last1)
         return false;
 
     if (__last2 - __first2 == 1)
         return !__comp(*__first1, *__first2) && !__comp(*__first2, *__first1);
 
     return __except_handler([&]() {
-        return !internal::parallel_or(
+        return !internal::__parallel_or(
             std::forward<_ExecutionPolicy>(__exec), __first2, __last2,
             [__first1, __last1, __first2, __last2, &__comp](_ForwardIterator2 __i, _ForwardIterator2 __j) {
                 assert(__j > __i);
                 //assert(__j - __i > 1);
 
                 //1. moving boundaries to "consume" subsequence of equal elements
                 auto __is_equal = [&__comp](_ForwardIterator2 __a, _ForwardIterator2 __b) -> bool {
                     return !__comp(*__a, *__b) && !__comp(*__b, *__a);

 #endif
 
 constexpr auto __set_algo_cut_off = 1000;
 
 #if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
           class _Compare, class _IsVector, class _SizeFunction, class _SetOP>
 _OutputIterator
-parallel_set_op(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+__parallel_set_op(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                   _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
                   _SizeFunction __size_func, _SetOP __set_op, _IsVector __is_vector)
 {
     typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferenceType;
     typedef typename std::iterator_traits<_OutputIterator>::value_type _T;
 
     struct _SetRange
     {
         _DifferenceType __pos, __len, __buf_pos;
         bool
         empty() const
         {
             return __len == 0;
         }
     };
 
     const _DifferenceType __n1 = __last1 - __first1;
     const _DifferenceType __n2 = __last2 - __first2;
 
-    par_backend::buffer<_T> __buf(__size_func(__n1, __n2));
+    par_backend::__buffer<_T> __buf(__size_func(__n1, __n2));
 
     return __except_handler([&__exec, __n1, __first1, __last1, __first2, __last2, __result, __is_vector, __comp,
                              __size_func, __set_op, &__buf]() {
         auto __buffer = __buf.get();
         _DifferenceType __m{};
         auto __scan = [=](_DifferenceType, _DifferenceType, const _SetRange& __s) { // Scan
             if (!__s.empty())
                 __brick_move(__buffer + __s.__buf_pos, __buffer + (__s.__buf_pos + __s.__len), __result + __s.__pos,
if (__n1 == 0)
                                      std::true_type());
 
     // testing  whether the sequences are intersected
     _ForwardIterator1 __left_bound_seq_1 = lower_bound(__first1, __last1, *__first2, __comp);
 
     if (__left_bound_seq_1 == __last1)
     {
         //{1} < {2}: seq2 is wholly greater than seq1, so, do parallel copying seq1 and seq2
-        par_backend::parallel_invoke(std::forward<_ExecutionPolicy>(__exec),
+        par_backend::__parallel_invoke(std::forward<_ExecutionPolicy>(__exec),
                                        [=] {
                                            __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1,
                                                                  __last1, __result, copy_range1, std::true_type());
                                        },
                                        [=] {
                                            __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2,
-                                                               __last2, __result + __n1, copy_range2, std::true_type());
+                                                                 __last2, __result + __n1, copy_range2,
+                                                                 std::true_type());
                                        });
         return __result + __n1 + __n2;
     }
 
     // testing  whether the sequences are intersected
     _ForwardIterator2 __left_bound_seq_2 = lower_bound(__first2, __last2, *__first1, __comp);
 
     if (__left_bound_seq_2 == __last2)
     {
         //{2} < {1}: seq2 is wholly greater than seq1, so, do parallel copying seq1 and seq2
-        par_backend::parallel_invoke(std::forward<_ExecutionPolicy>(__exec),
+        par_backend::__parallel_invoke(std::forward<_ExecutionPolicy>(__exec),
                                        [=] {
                                            __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2,
                                                                  __last2, __result, copy_range2, std::true_type());
                                        },
                                        [=] {
                                            __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1,
-                                                               __last1, __result + __n2, copy_range1, std::true_type());
+                                                                 __last1, __result + __n2, copy_range1,
+                                                                 std::true_type());
                                        });
         return __result + __n1 + __n2;
     }
 
     const auto __m1 = __left_bound_seq_1 - __first1;
     if (__m1 > __set_algo_cut_off)
     {
         auto __res_or = __result;
         __result += __m1; //we know proper offset due to [first1; left_bound_seq_1) < [first2; last2)
-        par_backend::parallel_invoke(
+        par_backend::__parallel_invoke(
             std::forward<_ExecutionPolicy>(__exec),
             //do parallel copying of [first1; left_bound_seq_1)
             [=] {
                 __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1, __left_bound_seq_1, __res_or,
                                       copy_range1, std::true_type());
             },
             [=, &__result] {
-                __result = parallel_set_op(std::forward<_ExecutionPolicy>(__exec), __left_bound_seq_1, __last1,
+                __result = __parallel_set_op(std::forward<_ExecutionPolicy>(__exec), __left_bound_seq_1, __last1,
                                              __first2, __last2, __result, __comp,
                                              [](_DifferenceType __n, _DifferenceType __m) { return __n + __m; },
                                              __set_union_op, __is_vector);
             });
         return __result;
     }
 
     const auto __m2 = __left_bound_seq_2 - __first2;
     assert(__m1 == 0 || __m2 == 0);
     if (__m2 > __set_algo_cut_off)
     {
         auto __res_or = __result;
         __result += __m2; //we know proper offset due to [first2; left_bound_seq_2) < [first1; last1)
-        par_backend::parallel_invoke(
+        par_backend::__parallel_invoke(
             std::forward<_ExecutionPolicy>(__exec),
             //do parallel copying of [first2; left_bound_seq_2)
             [=] {
                 __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2, __left_bound_seq_2, __res_or,
                                       copy_range2, std::true_type());
             },
             [=, &__result] {
-                __result = parallel_set_op(std::forward<_ExecutionPolicy>(__exec), __first1, __last1,
+                __result = __parallel_set_op(std::forward<_ExecutionPolicy>(__exec), __first1, __last1,
                                              __left_bound_seq_2, __last2, __result, __comp,
                                              [](_DifferenceType __n, _DifferenceType __m) { return __n + __m; },
                                              __set_union_op, __is_vector);
             });
         return __result;
     }
 
-    return parallel_set_op(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result,
+    return __parallel_set_op(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result,
                              __comp, [](_DifferenceType __n, _DifferenceType __m) { return __n + __m; }, __set_union_op,
                              __is_vector);
 }
 #endif
 
 //------------------------------------------------------------------------
 // set_union
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
__pattern_set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
     //{2} < {1}: seq 1 is wholly greater than seq 2, so, the intersection is empty
     if (__left_bound_seq_2 == __last2)
         return __result;
 
     const auto __m1 = __last1 - __left_bound_seq_1 + __n2;
     if (__m1 > __set_algo_cut_off)
     {
         //we know proper offset due to [first1; left_bound_seq_1) < [first2; last2)
-        return parallel_set_op(std::forward<_ExecutionPolicy>(__exec), __left_bound_seq_1, __last1, __first2, __last2,
-                               __result, __comp,
-                               [](_DifferenceType __n, _DifferenceType __m) { return std::min(__n, __m); },
-                               [](_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
-                                  _ForwardIterator2 __last2, _T* __result, _Compare __comp) {
-                                   return std::set_intersection(__first1, __last1, __first2, __last2, __result, __comp);
-                               },
-                               __is_vector);
+        return __parallel_set_op(
+            std::forward<_ExecutionPolicy>(__exec), __left_bound_seq_1, __last1, __first2, __last2, __result, __comp,
     }
 
     const auto __m2 = __last2 - __left_bound_seq_2 + __n1;
     if (__m2 > __set_algo_cut_off)
     {
         //we know proper offset due to [first2; left_bound_seq_2) < [first1; last1)
-        __result = parallel_set_op(
+        __result = __parallel_set_op(
             std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __left_bound_seq_2, __last2, __result, __comp,
             [](_DifferenceType __n, _DifferenceType __m) { return std::min(__n, __m); },
             [](_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
                _ForwardIterator2 __last2, _T* __result, _Compare __comp) {
                 return std::set_intersection(__first2, __last2, __first1, __last1, __result, __comp);
             },
             __is_vector);
         return __result;
if (__left_bound_seq_2 == __last2)
         return __pattern_walk2_brick(
             std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result,
             [__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _OutputIterator __res) {
                 return __brick_copy(__begin, __end, __res, __is_vector);
             },
             std::true_type());
 
     if (__n1 + __n2 > __set_algo_cut_off)
-        return parallel_set_op(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result,
+        return __parallel_set_op(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result,
                                  __comp, [](_DifferenceType __n, _DifferenceType __m) { return __n; },
                                  [](_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
                                     _ForwardIterator2 __last2, _T* __result, _Compare __comp) {
                                      return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp);
                                  },
                                  __is_vector);
 
     // use serial algorithm
     return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp);
 }
 #endif
 
 //------------------------------------------------------------------------
 // set_symmetric_difference

 _RandomAccessIterator
 __pattern_is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
                         _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept
 {
     if (__last - __first < 2)
         return __last;
 
     return internal::__except_handler([&]() {
-        return internal::parallel_find(
+        return internal::__parallel_find(
             std::forward<_ExecutionPolicy>(__exec), __first, __last,
             [__first, __comp, __is_vector](_RandomAccessIterator __i, _RandomAccessIterator __j) {
                 return internal::is_heap_until_local(__first, __i - __first, __j - __first, __comp, __is_vector);
             },
             std::less<typename std::iterator_traits<_RandomAccessIterator>::difference_type>(), /*is_first=*/true);
     });
 }
 #endif

 _RandomAccessIterator
 __pattern_min_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
                       _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type)
 {
     if (__first == __last)
         return __last;
 
     return internal::__except_handler([&]() {
-        return par_backend::parallel_reduce(
+        return par_backend::__parallel_reduce(
             std::forward<_ExecutionPolicy>(__exec), __first + 1, __last, __first,
             [=](_RandomAccessIterator __begin, _RandomAccessIterator __end,
                 _RandomAccessIterator __init) -> _RandomAccessIterator {
                 const _RandomAccessIterator subresult = __brick_min_element(__begin, __end, __comp, __is_vector);
                 return internal::__cmp_iterators_by_values(__init, subresult, __comp);
             },
             [=](_RandomAccessIterator __it1, _RandomAccessIterator __it2) -> _RandomAccessIterator {
                 return internal::__cmp_iterators_by_values(__it1, __it2, __comp);
__pattern_minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
                          _IsVector __is_vector, /* is_parallel = */ std::true_type)
 {
     if (__first == __last)
         return std::make_pair(__first, __first);
 
     return internal::__except_handler([&]() {
         typedef std::pair<_ForwardIterator, _ForwardIterator> _Result;
 
-        return par_backend::parallel_reduce(
+        return par_backend::__parallel_reduce(
             std::forward<_ExecutionPolicy>(__exec), __first + 1, __last, std::make_pair(__first, __first),
             [=](_ForwardIterator __begin, _ForwardIterator __end, _Result __init) -> _Result {
                 const _Result __subresult = __brick_minmax_element(__begin, __end, __comp, __is_vector);
                 return std::make_pair(internal::__cmp_iterators_by_values(__subresult.first, __init.first, __comp),
                                       internal::__cmp_iterators_by_values(__init.second, __subresult.second,
                                                                           internal::__not_pred<_Compare>(__comp)));
             },
             [=](_Result __p1, _Result __p2) -> _Result {
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Predicate,
           class _IsVector>
 std::pair<_RandomAccessIterator1, _RandomAccessIterator2>
 __pattern_mismatch(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
                    _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _Predicate __pred,
                    _IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept
 {
     return internal::__except_handler([&]() {
         auto __n = std::min(__last1 - __first1, __last2 - __first2);
-        auto __result = internal::parallel_find(
+        auto __result = internal::__parallel_find(
             std::forward<_ExecutionPolicy>(__exec), __first1, __first1 + __n,
             [__first1, __first2, __pred, __is_vector](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
                 return internal::__brick_mismatch(__i, __j, __first2 + (__i - __first1), __first2 + (__j - __first1),
                                                   __pred, __is_vector)
                     .first;
             },
             std::less<typename std::iterator_traits<_RandomAccessIterator1>::difference_type>(), /*is_first=*/true);
         return std::make_pair(__result, __first2 + (__result - __first1));
__pattern_lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
     }
     else
     {
         typedef typename std::iterator_traits<_ForwardIterator1>::reference _RefType1;
         typedef typename std::iterator_traits<_ForwardIterator2>::reference _RefType2;
         --__last1;
         --__last2;
         auto __n = std::min(__last1 - __first1, __last2 - __first2);
-        auto __result = internal::parallel_find(
+        auto __result = internal::__parallel_find(
             std::forward<_ExecutionPolicy>(__exec), __first1, __first1 + __n,
             [__first1, __first2, &__comp, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) {
                 return __brick_mismatch(__i, __j, __first2 + (__i - __first1), __first2 + (__j - __first1),
                                         [&__comp](const _RefType1 __x, const _RefType2 __y) {
                                             return !__comp(__x, __y) && !__comp(__y, __x);
                                         },
                                         __is_vector)
                     .first;

include/pstl/internal/numeric_impl.h

 template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Tp,
           class _BinaryOperation1, class _BinaryOperation2, class _IsVector>
 _Tp
 __pattern_transform_reduce(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
                            _RandomAccessIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1,
                            _BinaryOperation2 __binary_op2, _IsVector __is_vector, /*is_parallel=*/std::true_type)
 {
     return internal::__except_handler([&]() {
-        return par_backend::parallel_transform_reduce(
+        return par_backend::__parallel_transform_reduce(
             std::forward<_ExecutionPolicy>(__exec), __first1, __last1,
             [__first1, __first2, __binary_op2](_RandomAccessIterator1 __i) mutable {
                 return __binary_op2(*__i, *(__first2 + (__i - __first1)));
             },
             __init,
             __binary_op1, // Combine
             [__first1, __first2, __binary_op1, __binary_op2,
              __is_vector](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j, _Tp __init) -> _Tp {

 template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation,
           class _IsVector>
 _Tp
 __pattern_transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init,
                            _BinaryOperation __binary_op, _UnaryOperation __unary_op, _IsVector __is_vector,
                            /*is_parallel=*/std::true_type)
 {
     return __except_handler([&]() {
-        return par_backend::parallel_transform_reduce(
+        return par_backend::__parallel_transform_reduce(
             std::forward<_ExecutionPolicy>(__exec), __first, __last,
             [__unary_op](_ForwardIterator __i) mutable { return __unary_op(*__i); }, __init, __binary_op,
             [__unary_op, __binary_op, __is_vector](_ForwardIterator __i, _ForwardIterator __j, _Tp __init) {
                 return __brick_transform_reduce(__i, __j, __init, __binary_op, __unary_op, __is_vector);
             });
     });
 }
 #endif

 typename std::enable_if<!std::is_floating_point<_Tp>::value, _OutputIterator>::type
 __pattern_transform_scan(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
                          _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op,
                          _Inclusive, _IsVector __is_vector, /*is_parallel=*/std::true_type)
 {
     typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
 
     return internal::__except_handler([&]() {
-        par_backend::parallel_transform_scan(
+        par_backend::__parallel_transform_scan(
             std::forward<_ExecutionPolicy>(__exec), __last - __first,
             [__first, __unary_op](_DifferenceType __i) mutable { return __unary_op(__first[__i]); }, __init,
             __binary_op,
             [__first, __unary_op, __binary_op](_DifferenceType __i, _DifferenceType __j, _Tp __init) {
                 // Execute serial __brick_transform_reduce, due to the explicit SIMD vectorization (reduction) requires a commutative operation for the guarantee of correct scan.
                 return internal::__brick_transform_reduce(__first + __i, __first + __j, __init, __binary_op, __unary_op,
                                                           /*__is_vector*/ std::false_type());
             },
__pattern_adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
                               _ForwardIterator2 __d_first, _BinaryOperation __op, _IsVector __is_vector,
                               /*is_parallel=*/std::true_type)
 {
     assert(__first != __last);
     typedef typename std::iterator_traits<_ForwardIterator1>::reference _ReferenceType1;
     typedef typename std::iterator_traits<_ForwardIterator2>::reference _ReferenceType2;
 
     *__d_first = *__first;
-    par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last - 1,
+    par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last - 1,
                                 [&__op, __is_vector, __d_first, __first](_ForwardIterator1 __b, _ForwardIterator1 __e) {
                                     _ForwardIterator2 __d_b = __d_first + (__b - __first);
                                     __brick_walk3(__b, __e, __b + 1, __d_b + 1,
-                                                [&__op](_ReferenceType1 __x, _ReferenceType1 __y, _ReferenceType2 __z) {
-                                                    __z = __op(__y, __x);
-                                                },
+                                                  [&__op](_ReferenceType1 __x, _ReferenceType1 __y,
+                                                          _ReferenceType2 __z) { __z = __op(__y, __x); },
                                                   __is_vector);
                                 });
     return __d_first + (__last - __first);
 }
 #endif
 
 } // namespace internal
 } // namespace __pstl
 
 #endif /* __PSTL_numeric_impl_H */

include/pstl/internal/parallel_backend_tbb.h

 {
 
 //! Raw memory buffer with automatic freeing and no exceptions.
 /** Some of our algorithms need to start with raw memory buffer,
 not an initialize array, because initialization/destruction
 would make the span be at least O(N). */
 // tbb::allocator can improve performance in some cases.
 template <typename _Tp>
-class buffer
+class __buffer
 {
     tbb::tbb_allocator<_Tp> _M_allocator;
     _Tp* _M_ptr;
     const std::size_t _M_buf_size;
-    buffer(const buffer&) = delete;
+    __buffer(const __buffer&) = delete;
     void
-    operator=(const buffer&) = delete;
+    operator=(const __buffer&) = delete;
 
   public:
     //! Try to obtain buffer of given size to store objects of _Tp type
-    buffer(std::size_t n) : _M_allocator(), _M_ptr(_M_allocator.allocate(n)), _M_buf_size(n) {}
+    __buffer(std::size_t n) : _M_allocator(), _M_ptr(_M_allocator.allocate(n)), _M_buf_size(n) {}
     //! True if buffer was successfully obtained, zero otherwise.
     operator bool() const { return _M_ptr != NULL; }
     //! Return pointer to buffer, or  NULL if buffer could not be obtained.
     _Tp*
     get() const
     {
         return _M_ptr;
     }
     //! Destroy buffer
-    ~buffer() { _M_allocator.deallocate(_M_ptr, _M_buf_size); }
+    ~__buffer() { _M_allocator.deallocate(_M_ptr, _M_buf_size); }
 };
 
 // Wrapper for tbb::task
 inline void
-cancel_execution()
+__cancel_execution()
 {
     tbb::task::self().group()->cancel_group_execution();
 }
 
 //------------------------------------------------------------------------
 // parallel_for
 //------------------------------------------------------------------------
 
 template <class _Index, class _RealBody>
-class parallel_for_body
+class __parallel_for_body
 {
   public:
-    parallel_for_body(const _RealBody& __body) : _M_body(__body) {}
-    parallel_for_body(const parallel_for_body& __body) : _M_body(__body._M_body) {}
+    __parallel_for_body(const _RealBody& __body) : _M_body(__body) {}
+    __parallel_for_body(const __parallel_for_body& __body) : _M_body(__body._M_body) {}
     void
     operator()(const tbb::blocked_range<_Index>& __range) const
     {
         _M_body(__range.begin(), __range.end());
     }
 
   private:
     _RealBody _M_body;
 };
 
 //! Evaluation of brick f[i,j) for each subrange [i,j) of [first,last)
 // wrapper over tbb::parallel_for
 template <class _ExecutionPolicy, class _Index, class _Fp>
 void
-parallel_for(_ExecutionPolicy&&, _Index __first, _Index __last, _Fp __f)
+__parallel_for(_ExecutionPolicy&&, _Index __first, _Index __last, _Fp __f)
 {
-    tbb::this_task_arena::isolate(
-        [=]() { tbb::parallel_for(tbb::blocked_range<_Index>(__first, __last), parallel_for_body<_Index, _Fp>(__f)); });
+    tbb::this_task_arena::isolate([=]() {
+        tbb::parallel_for(tbb::blocked_range<_Index>(__first, __last), __parallel_for_body<_Index, _Fp>(__f));
+    });
 }
 
 //! Evaluation of brick f[i,j) for each subrange [i,j) of [first,last)
 // wrapper over tbb::parallel_reduce
 template <class _ExecutionPolicy, class _Value, class _Index, typename _RealBody, typename _Reduction>
 _Value
-parallel_reduce(_ExecutionPolicy&&, _Index __first, _Index __last, const _Value& __identity,
+__parallel_reduce(_ExecutionPolicy&&, _Index __first, _Index __last, const _Value& __identity,
                   const _RealBody& __real_body, const _Reduction& __reduction)
 {
     return tbb::this_task_arena::isolate([__first, __last, &__identity, &__real_body, &__reduction]() -> _Value {
         return tbb::parallel_reduce(
             tbb::blocked_range<_Index>(__first, __last), __identity,
             [__real_body](const tbb::blocked_range<_Index>& __r, const _Value& __value) -> _Value {
                 return __real_body(__r.begin(), __r.end(), __value);
             },
             __reduction);
     });
 }
 
 //------------------------------------------------------------------------
 // parallel_transform_reduce
 //
 // Notation:
 //      r(i,j,init) returns reduction of init with reduction over [i,j)
 //      u(i) returns f(i,i+1,identity) for a hypothetical left identity element of r
 //      c(x,y) combines values x and y that were the result of r or u
 //------------------------------------------------------------------------
 
 template <class _Index, class _Up, class _Tp, class _Cp, class _Rp>
-struct par_trans_red_body
+struct __par_trans_red_body
 {
     alignas(_Tp) char _M_sum_storage[sizeof(_Tp)]; // Holds generalized non-commutative sum when has_sum==true
     _Rp _M_brick_reduce;                           // Most likely to have non-empty layout
     _Up _M_u;
     _Cp _M_combine;
     bool _M_has_sum; // Put last to minimize size of class
     _Tp&
     sum()
     {
         __TBB_ASSERT(_M_has_sum, "sum expected");
         return *(_Tp*)_M_sum_storage;
     }
-    par_trans_red_body(_Up __u, _Tp __init, _Cp __c, _Rp __r)
+    __par_trans_red_body(_Up __u, _Tp __init, _Cp __c, _Rp __r)
         : _M_brick_reduce(__r), _M_u(__u), _M_combine(__c), _M_has_sum(true)
     {
         new (_M_sum_storage) _Tp(__init);
     }
 
-    par_trans_red_body(par_trans_red_body& __left, tbb::split)
+    __par_trans_red_body(__par_trans_red_body& __left, tbb::split)
         : _M_brick_reduce(__left._M_brick_reduce), _M_u(__left._M_u), _M_combine(__left._M_combine), _M_has_sum(false)
     {
     }
 
-    ~par_trans_red_body()
+    ~__par_trans_red_body()
     {
         // 17.6.5.12 tells us to not worry about catching exceptions from destructors.
         if (_M_has_sum)
             sum().~_Tp();
     }
 
     void
-    join(par_trans_red_body& __rhs)
+    join(__par_trans_red_body& __rhs)
     {
         sum() = _M_combine(sum(), __rhs.sum());
     }
 
     void
     operator()(const tbb::blocked_range<_Index>& __range)
     {
         _Index __i = __range.begin();
operator()(const tbb::blocked_range<_Index>& __range)
                 return;
         }
         sum() = _M_brick_reduce(__i, __j, sum());
     }
 };
 
 template <class _ExecutionPolicy, class _Index, class _Up, class _Tp, class _Cp, class _Rp>
 _Tp
-parallel_transform_reduce(_ExecutionPolicy&&, _Index __first, _Index __last, _Up __u, _Tp __init, _Cp __combine,
+__parallel_transform_reduce(_ExecutionPolicy&&, _Index __first, _Index __last, _Up __u, _Tp __init, _Cp __combine,
                             _Rp __brick_reduce)
 {
-    par_trans_red_body<_Index, _Up, _Tp, _Cp, _Rp> __body(__u, __init, __combine, __brick_reduce);
+    __par_trans_red_body<_Index, _Up, _Tp, _Cp, _Rp> __body(__u, __init, __combine, __brick_reduce);
     // The grain size of 3 is used in order to provide mininum 2 elements for each body
     tbb::this_task_arena::isolate(
         [__first, __last, &__body]() { tbb::parallel_reduce(tbb::blocked_range<_Index>(__first, __last, 3), __body); });
     return __body.sum();
 }
 
 //------------------------------------------------------------------------
 // parallel_scan
 //------------------------------------------------------------------------
 
 template <class _Index, class _Up, class _Tp, class _Cp, class _Rp, class _Sp>
-class trans_scan_body
+class __trans_scan_body
 {
     alignas(_Tp) char _M_sum_storage[sizeof(_Tp)]; // Holds generalized non-commutative sum when has_sum==true
     _Rp _M_brick_reduce;                           // Most likely to have non-empty layout
     _Up _M_u;
     _Cp _M_combine;
     _Sp _M_scan;
     bool _M_has_sum; // Put last to minimize size of class
   public:
-    trans_scan_body(_Up __u, _Tp __init, _Cp __combine, _Rp __reduce, _Sp __scan)
+    __trans_scan_body(_Up __u, _Tp __init, _Cp __combine, _Rp __reduce, _Sp __scan)
         : _M_brick_reduce(__reduce), _M_u(__u), _M_combine(__combine), _M_scan(__scan), _M_has_sum(true)
     {
         new (_M_sum_storage) _Tp(__init);
     }
 
-    trans_scan_body(trans_scan_body& __b, tbb::split)
+    __trans_scan_body(__trans_scan_body& __b, tbb::split)
         : _M_brick_reduce(__b._M_brick_reduce), _M_u(__b._M_u), _M_combine(__b._M_combine), _M_scan(__b._M_scan),
           _M_has_sum(false)
     {
     }
 
-    ~trans_scan_body()
+    ~__trans_scan_body()
     {
         // 17.6.5.12 tells us to not worry about catching exceptions from destructors.
         if (_M_has_sum)
             sum().~_Tp();
     }
 
     _Tp&
     sum() const
public:
 
     void
     operator()(const tbb::blocked_range<_Index>& __range, tbb::final_scan_tag)
     {
         sum() = _M_scan(__range.begin(), __range.end(), sum());
     }
 
     void
-    reverse_join(trans_scan_body& __a)
+    reverse_join(__trans_scan_body& __a)
     {
         if (_M_has_sum)
         {
             sum() = _M_combine(__a.sum(), sum());
         }
         else
         {
             new (&_M_sum_storage) _Tp(__a.sum());
             _M_has_sum = true;
         }
     }
 
     void
-    assign(trans_scan_body& __b)
+    assign(__trans_scan_body& __b)
     {
         sum() = __b.sum();
     }
 };
 
 template <typename _Index>
 _Index
-split(_Index __m)
+__split(_Index __m)
 {
     _Index __k = 1;
     while (2 * __k < __m)
         __k *= 2;
     return __k;
 }
 
 //------------------------------------------------------------------------
 // parallel_strict_scan
 //------------------------------------------------------------------------
 
 template <typename _Index, typename _Tp, typename _Rp, typename _Cp>
 void
-upsweep(_Index __i, _Index __m, _Index __tilesize, _Tp* __r, _Index __lastsize, _Rp __reduce, _Cp __combine)
+__upsweep(_Index __i, _Index __m, _Index __tilesize, _Tp* __r, _Index __lastsize, _Rp __reduce, _Cp __combine)
 {
     if (__m == 1)
         __r[0] = __reduce(__i * __tilesize, __lastsize);
     else
     {
-        _Index __k = split(__m);
-        tbb::parallel_invoke([=] { par_backend::upsweep(__i, __k, __tilesize, __r, __tilesize, __reduce, __combine); },
-                             [=] {
-                                 par_backend::upsweep(__i + __k, __m - __k, __tilesize, __r + __k, __lastsize, __reduce,
-                                                      __combine);
-                             });
+        _Index __k = __split(__m);
+        tbb::parallel_invoke(
+            [=] { par_backend::__upsweep(__i, __k, __tilesize, __r, __tilesize, __reduce, __combine); },
+                par_backend::__upsweep(__i + __k, __m - __k, __tilesize, __r + __k, __lastsize, __reduce, __combine);
         if (__m == 2 * __k)
             __r[__m - 1] = __combine(__r[__k - 1], __r[__m - 1]);
     }
 }
 
 template <typename _Index, typename _Tp, typename _Cp, typename _Sp>
 void
-downsweep(_Index __i, _Index __m, _Index __tilesize, _Tp* __r, _Index __lastsize, _Tp __initial, _Cp __combine,
+__downsweep(_Index __i, _Index __m, _Index __tilesize, _Tp* __r, _Index __lastsize, _Tp __initial, _Cp __combine,
             _Sp __scan)
 {
     if (__m == 1)
         __scan(__i * __tilesize, __lastsize, __initial);
     else
     {
-        const _Index __k = par_backend::split(__m);
+        const _Index __k = par_backend::__split(__m);
         tbb::parallel_invoke(
-            [=] { par_backend::downsweep(__i, __k, __tilesize, __r, __tilesize, __initial, __combine, __scan); },
+            [=] { par_backend::__downsweep(__i, __k, __tilesize, __r, __tilesize, __initial, __combine, __scan); },
             // Assumes that __combine never throws.
             //TODO: Consider adding a requirement for user functors to be constant.
             [=, &__combine] {
-                par_backend::downsweep(__i + __k, __m - __k, __tilesize, __r + __k, __lastsize,
+                par_backend::__downsweep(__i + __k, __m - __k, __tilesize, __r + __k, __lastsize,
                                          __combine(__initial, __r[__k - 1]), __combine, __scan);
             });
     }
 }
 
 // Adapted from Intel(R) Cilk(TM) version from cilkpub.
 // Let i:len denote a counted interval of length n starting at i.  s denotes a generalized-sum value.
 // Expected actions of the functors are:
 //     reduce(i,len) -> s  -- return reduction value of i:len.
 //     combine(s1,s2) -> s -- return merged sum
 //     apex(s) -- do any processing necessary between reduce and scan.
 //     scan(i,len,initial) -- perform scan over i:len starting with initial.
 // The initial range 0:n is partitioned into consecutive subranges.
 // reduce and scan are each called exactly once per subrange.
 // Thus callers can rely upon side effects in reduce.
 // combine must not throw an exception.
 // apex is called exactly once, after all calls to reduce and before all calls to scan.
-// For example, it's useful for allocating a buffer used by scan but whose size is the sum of all reduction values.
+// For example, it's useful for allocating a __buffer used by scan but whose size is the sum of all reduction values.
 // T must have a trivial constructor and destructor.
 template <class _ExecutionPolicy, typename _Index, typename _Tp, typename _Rp, typename _Cp, typename _Sp, typename _Ap>
 void
 parallel_strict_scan(_ExecutionPolicy&&, _Index __n, _Tp __initial, _Rp __reduce, _Cp __combine, _Sp __scan, _Ap __apex)
 {
     tbb::this_task_arena::isolate([=, &__combine]() {
         if (__n > 1)
         {
             _Index __p = tbb::this_task_arena::max_concurrency();
             const _Index __slack = 4;
             _Index __tilesize = (__n - 1) / (__slack * __p) + 1;
             _Index __m = (__n - 1) / __tilesize;
-            buffer<_Tp> __buf(__m + 1);
+            __buffer<_Tp> __buf(__m + 1);
             _Tp* __r = __buf.get();
-            par_backend::upsweep(_Index(0), _Index(__m + 1), __tilesize, __r, __n - __m * __tilesize, __reduce,
+            par_backend::__upsweep(_Index(0), _Index(__m + 1), __tilesize, __r, __n - __m * __tilesize, __reduce,
                                    __combine);
             // When __apex is a no-op and __combine has no side effects, a good optimizer
             // should be able to eliminate all code between here and __apex.
             // Alternatively, provide a default value for __apex that can be
             // recognized by metaprogramming that conditionlly executes the following.
             size_t __k = __m + 1;
             _Tp __t = __r[__k - 1];
             while ((__k &= __k - 1))
                 __t = __combine(__r[__k - 1], __t);
             __apex(__combine(__initial, __t));
-            par_backend::downsweep(_Index(0), _Index(__m + 1), __tilesize, __r, __n - __m * __tilesize, __initial,
+            par_backend::__downsweep(_Index(0), _Index(__m + 1), __tilesize, __r, __n - __m * __tilesize, __initial,
                                      __combine, __scan);
             return;
         }
         // Fewer than 2 elements in sequence, or out of memory.  Handle has single block.
         _Tp __sum = __initial;
         if (__n)
             __sum = __combine(__sum, __reduce(_Index(0), __n));
         __apex(__sum);
         if (__n)
             __scan(_Index(0), __n, __initial);
     });
 }
 
 template <class _ExecutionPolicy, class _Index, class _Up, class _Tp, class _Cp, class _Rp, class _Sp>
 _Tp
-parallel_transform_scan(_ExecutionPolicy&&, _Index __n, _Up __u, _Tp __init, _Cp __combine, _Rp __brick_reduce,
+__parallel_transform_scan(_ExecutionPolicy&&, _Index __n, _Up __u, _Tp __init, _Cp __combine, _Rp __brick_reduce,
                           _Sp __scan)
 {
-    trans_scan_body<_Index, _Up, _Tp, _Cp, _Rp, _Sp> __body(__u, __init, __combine, __brick_reduce, __scan);
+    __trans_scan_body<_Index, _Up, _Tp, _Cp, _Rp, _Sp> __body(__u, __init, __combine, __brick_reduce, __scan);
     auto __range = tbb::blocked_range<_Index>(0, __n);
     tbb::this_task_arena::isolate([__range, &__body]() { tbb::parallel_scan(__range, __body); });
     return __body.sum();
 }
 
 //------------------------------------------------------------------------
 // parallel_stable_sort
 //------------------------------------------------------------------------
 
 //------------------------------------------------------------------------
 // stable_sort utilities
 //
 // These are used by parallel implementations but do not depend on them.
 //------------------------------------------------------------------------
 
 template <typename _RandomAccessIterator1, typename _RandomAccessIterator2, typename _RandomAccessIterator3,
           typename _Compare, typename _Cleanup, typename _LeafMerge>
-class merge_task : public tbb::task
+class __merge_task : public tbb::task
 {
     /*override*/ tbb::task*
     execute();
     _RandomAccessIterator1 _M_xs, _M_xe;
     _RandomAccessIterator2 _M_ys, _M_ye;
     _RandomAccessIterator3 _M_zs;
     _Compare _M_comp;
     _Cleanup _M_cleanup;
     _LeafMerge _M_leaf_merge;
 
   public:
-    merge_task(_RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, _RandomAccessIterator2 __ys,
+    __merge_task(_RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, _RandomAccessIterator2 __ys,
                  _RandomAccessIterator2 __ye, _RandomAccessIterator3 __zs, _Compare __comp, _Cleanup __cleanup,
                  _LeafMerge __leaf_merge)
         : _M_xs(__xs), _M_xe(__xe), _M_ys(__ys), _M_ye(__ye), _M_zs(__zs), _M_comp(__comp), _M_cleanup(__cleanup),
           _M_leaf_merge(__leaf_merge)
     {
     }
 };
 
 #define __PSTL_MERGE_CUT_OFF 2000
 
 template <typename _RandomAccessIterator1, typename _RandomAccessIterator2, typename _RandomAccessIterator3,
           typename __M_Compare, typename _Cleanup, typename _LeafMerge>
 tbb::task*
-merge_task<_RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator3, __M_Compare, _Cleanup,
+__merge_task<_RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator3, __M_Compare, _Cleanup,
              _LeafMerge>::execute()
 {
     typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _DifferenceType1;
     typedef typename std::iterator_traits<_RandomAccessIterator2>::difference_type _DifferenceType2;
     typedef typename std::common_type<_DifferenceType1, _DifferenceType2>::type _SizeType;
     const _SizeType __n = (_M_xe - _M_xs) + (_M_ye - _M_ys);
     const _SizeType __merge_cut_off = __PSTL_MERGE_CUT_OFF;
     if (__n <= __merge_cut_off)
     {
else
         }
         else
         {
             __xm = _M_xs + (_M_xe - _M_xs) / 2;
             __ym = std::lower_bound(_M_ys, _M_ye, *__xm, _M_comp);
         }
         const _RandomAccessIterator3 __zm = _M_zs + ((__xm - _M_xs) + (__ym - _M_ys));
         tbb::task* __right = new (tbb::task::allocate_additional_child_of(*parent()))
-            merge_task(__xm, _M_xe, __ym, _M_ye, __zm, _M_comp, _M_cleanup, _M_leaf_merge);
+            __merge_task(__xm, _M_xe, __ym, _M_ye, __zm, _M_comp, _M_cleanup, _M_leaf_merge);
         tbb::task::spawn(*__right);
         tbb::task::recycle_as_continuation();
         _M_xe = __xm;
         _M_ye = __ym;
     }
     return this;
 }
 
 template <typename _RandomAccessIterator1, typename _RandomAccessIterator2, typename _Compare, typename _LeafSort>
-class stable_sort_task : public tbb::task
+class __stable_sort_task : public tbb::task
 {
   public:
     typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _DifferenceType1;
     typedef typename std::iterator_traits<_RandomAccessIterator2>::difference_type _DifferenceType2;
     typedef typename std::common_type<_DifferenceType1, _DifferenceType2>::type _SizeType;
 
   private:
     /*override*/ tbb::task*
     execute();
     _RandomAccessIterator1 _M_xs, _M_xe;
     _RandomAccessIterator2 _M_zs;
     _Compare _M_comp;
     _LeafSort _M_leaf_sort;
     int32_t _M_inplace;
     _SizeType _M_nsort;
 
   public:
-    stable_sort_task(_RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, _RandomAccessIterator2 __zs,
+    __stable_sort_task(_RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, _RandomAccessIterator2 __zs,
                        int32_t __inplace, _Compare __comp, _LeafSort __leaf_sort, _SizeType __n)
         : _M_xs(__xs), _M_xe(__xe), _M_zs(__zs), _M_comp(__comp), _M_leaf_sort(__leaf_sort), _M_inplace(__inplace),
           _M_nsort(__n)
     {
     }
 };
 
 //! Binary operator that does nothing
-struct binary_no_op
+struct __binary_no_op
 {
     template <typename _T>
     void operator()(_T, _T)
     {
     }
 };
 
 #define __PSTL_STABLE_SORT_CUT_OFF 500
 
 template <typename _RandomAccessIterator1, typename _RandomAccessIterator2, typename _Compare, typename _LeafSort>
 tbb::task*
-stable_sort_task<_RandomAccessIterator1, _RandomAccessIterator2, _Compare, _LeafSort>::execute()
+__stable_sort_task<_RandomAccessIterator1, _RandomAccessIterator2, _Compare, _LeafSort>::execute()
 {
     const _SizeType __n = _M_xe - _M_xs;
     const _SizeType __nmerge = _M_nsort > 0 ? _M_nsort : __n;
     const _SizeType __sort_cut_off = __PSTL_STABLE_SORT_CUT_OFF;
     if (__n <= __sort_cut_off)
     {
         _M_leaf_sort(_M_xs, _M_xe, _M_comp);
         if (_M_inplace != 2)
-            init_buf(_M_xs, _M_xe, _M_zs, _M_inplace == 0);
+            __init_buf(_M_xs, _M_xe, _M_zs, _M_inplace == 0);
         return NULL;
     }
     else
     {
         const _RandomAccessIterator1 __xm = _M_xs + __n / 2;
         const _RandomAccessIterator2 __zm = _M_zs + (__xm - _M_xs);
         const _RandomAccessIterator2 __ze = _M_zs + __n;
         task* __m;
         auto __move_values = [](_RandomAccessIterator2 __x, _RandomAccessIterator1 __z) { *__z = std::move(*__x); };
         auto __move_sequences = [](_RandomAccessIterator2 __first1, _RandomAccessIterator2 __last1,
                                    _RandomAccessIterator1 __first2) { return std::move(__first1, __last1, __first2); };
         if (_M_inplace == 2)
             __m = new (allocate_continuation())
-                merge_task<_RandomAccessIterator2, _RandomAccessIterator2, _RandomAccessIterator1, _Compare,
-                           serial_destroy, serial_move_merge<decltype(__move_values), decltype(__move_sequences)>>(
-                    _M_zs, __zm, __zm, __ze, _M_xs, _M_comp, serial_destroy(),
-                    serial_move_merge<decltype(__move_values), decltype(__move_sequences)>(__nmerge, __move_values,
+                __merge_task<_RandomAccessIterator2, _RandomAccessIterator2, _RandomAccessIterator1, _Compare,
+                             __serial_destroy,
+                             __serial_move_merge<decltype(__move_values), decltype(__move_sequences)>>(
+                    _M_zs, __zm, __zm, __ze, _M_xs, _M_comp, __serial_destroy(),
+                    __serial_move_merge<decltype(__move_values), decltype(__move_sequences)>(__nmerge, __move_values,
                                                                                              __move_sequences));
         else if (_M_inplace)
             __m = new (allocate_continuation())
-                merge_task<_RandomAccessIterator2, _RandomAccessIterator2, _RandomAccessIterator1, _Compare,
-                           binary_no_op, serial_move_merge<decltype(__move_values), decltype(__move_sequences)>>(
-                    _M_zs, __zm, __zm, __ze, _M_xs, _M_comp, binary_no_op(),
-                    serial_move_merge<decltype(__move_values), decltype(__move_sequences)>(__nmerge, __move_values,
+                __merge_task<_RandomAccessIterator2, _RandomAccessIterator2, _RandomAccessIterator1, _Compare,
+                             __binary_no_op, __serial_move_merge<decltype(__move_values), decltype(__move_sequences)>>(
+                    _M_zs, __zm, __zm, __ze, _M_xs, _M_comp, __binary_no_op(),
+                    __serial_move_merge<decltype(__move_values), decltype(__move_sequences)>(__nmerge, __move_values,
                                                                                              __move_sequences));
         else
         {
             auto __move_values = [](_RandomAccessIterator1 __x, _RandomAccessIterator2 __z) { *__z = std::move(*__x); };
             auto __move_sequences = [](_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
                                        _RandomAccessIterator2 __first2) {
                 return std::move(__first1, __last1, __first2);
             };
             __m = new (allocate_continuation())
-                merge_task<_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _Compare,
-                           binary_no_op, serial_move_merge<decltype(__move_values), decltype(__move_sequences)>>(
-                    _M_xs, __xm, __xm, _M_xe, _M_zs, _M_comp, binary_no_op(),
-                    serial_move_merge<decltype(__move_values), decltype(__move_sequences)>(__nmerge, __move_values,
+                __merge_task<_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _Compare,
+                             __binary_no_op, __serial_move_merge<decltype(__move_values), decltype(__move_sequences)>>(
+                    _M_xs, __xm, __xm, _M_xe, _M_zs, _M_comp, __binary_no_op(),
+                    __serial_move_merge<decltype(__move_values), decltype(__move_sequences)>(__nmerge, __move_values,
                                                                                              __move_sequences));
         }
         __m->set_ref_count(2);
         task* __right = new (__m->allocate_child())
-            stable_sort_task(__xm, _M_xe, __zm, !_M_inplace, _M_comp, _M_leaf_sort, __nmerge);
+            __stable_sort_task(__xm, _M_xe, __zm, !_M_inplace, _M_comp, _M_leaf_sort, __nmerge);
         spawn(*__right);
         recycle_as_child_of(*__m);
         _M_xe = __xm;
         _M_inplace = !_M_inplace;
     }
     return this;
 }
 
 template <class _ExecutionPolicy, typename _RandomAccessIterator, typename _Compare, typename _LeafSort>
 void
-parallel_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator __xs, _RandomAccessIterator __xe, _Compare __comp,
+__parallel_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator __xs, _RandomAccessIterator __xe, _Compare __comp,
                        _LeafSort __leaf_sort, std::size_t __nsort = 0)
 {
     tbb::this_task_arena::isolate([=, &__nsort]() {
         //sorting based on task tree and parallel merge
         typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _ValueType;
         typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
         const _DifferenceType __n = __xe - __xs;
         if (__nsort == 0)
             __nsort = __n;
 
         const _DifferenceType __sort_cut_off = __PSTL_STABLE_SORT_CUT_OFF;
         if (__n > __sort_cut_off)
         {
             assert(__nsort > 0 && __nsort <= __n);
-            buffer<_ValueType> __buf(__n);
+            __buffer<_ValueType> __buf(__n);
             using tbb::task;
             task::spawn_root_and_wait(*new (task::allocate_root())
-                                          stable_sort_task<_RandomAccessIterator, _ValueType*, _Compare, _LeafSort>(
+                                          __stable_sort_task<_RandomAccessIterator, _ValueType*, _Compare, _LeafSort>(
                                               __xs, __xe, (_ValueType*)__buf.get(), 2, __comp, __leaf_sort, __nsort));
             return;
         }
         //serial sort
         __leaf_sort(__xs, __xe, __comp);
     });
 }
 
 //------------------------------------------------------------------------
 // parallel_merge
 //------------------------------------------------------------------------
 
 template <class _ExecutionPolicy, typename _RandomAccessIterator1, typename _RandomAccessIterator2,
           typename _RandomAccessIterator3, typename _Compare, typename _LeafMerge>
 void
-parallel_merge(_ExecutionPolicy&&, _RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe,
+__parallel_merge(_ExecutionPolicy&&, _RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe,
                  _RandomAccessIterator2 __ys, _RandomAccessIterator2 __ye, _RandomAccessIterator3 __zs, _Compare __comp,
                  _LeafMerge __leaf_merge)
 {
     typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _DifferenceType1;
     typedef typename std::iterator_traits<_RandomAccessIterator2>::difference_type _DifferenceType2;
     typedef typename std::common_type<_DifferenceType1, _DifferenceType2>::type _SizeType;
     const _SizeType __n = (__xe - __xs) + (__ye - __ys);
     const _SizeType __merge_cut_off = __PSTL_MERGE_CUT_OFF;
     if (__n <= __merge_cut_off)
     {
         // Fall back on serial merge
         __leaf_merge(__xs, __xe, __ys, __ye, __zs, __comp);
     }
     else
     {
         tbb::this_task_arena::isolate([=]() {
-            typedef merge_task<_RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator3, _Compare,
-                               par_backend::binary_no_op, _LeafMerge>
+            typedef __merge_task<_RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator3, _Compare,
+                                 par_backend::__binary_no_op, _LeafMerge>
                 _TaskType;
             tbb::task::spawn_root_and_wait(*new (tbb::task::allocate_root()) _TaskType(
-                __xs, __xe, __ys, __ye, __zs, __comp, par_backend::binary_no_op(), __leaf_merge));
+                __xs, __xe, __ys, __ye, __zs, __comp, par_backend::__binary_no_op(), __leaf_merge));
         });
     }
 }
 
 //------------------------------------------------------------------------
 // parallel_invoke
 //------------------------------------------------------------------------
 template <class _ExecutionPolicy, typename _F1, typename _F2>
 void
-parallel_invoke(_ExecutionPolicy&&, _F1&& __f1, _F2&& __f2)
+__parallel_invoke(_ExecutionPolicy&&, _F1&& __f1, _F2&& __f2)
 {
     //TODO: a version of tbb::this_task_arena::isolate with variadic arguments pack should be added in the future
     tbb::this_task_arena::isolate([&]() { tbb::parallel_invoke(std::forward<_F1>(__f1), std::forward<_F2>(__f2)); });
 }
 
 } // namespace par_backend
 } // namespace __pstl
 
 #endif /* __PSTL_parallel_backend_tbb_H */

include/pstl/internal/parallel_backend_utils.h

 #include "utils.h"
 
 namespace __pstl
 {
 namespace par_backend
 {
 
 //! Destroy sequence [xs,xe)
-struct serial_destroy
+struct __serial_destroy
 {
     template <typename _RandomAccessIterator>
     void
     operator()(_RandomAccessIterator __zs, _RandomAccessIterator __ze)
     {
         typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _ValueType;
         while (__zs != __ze)
         {
             --__ze;
             (*__ze).~_ValueType();
         }
     }
 };
 
 //! Merge sequences [__xs,__xe) and [__ys,__ye) to output sequence [__zs,(__xe-__xs)+(__ye-__ys)), using std::move
 template <class _MoveValues, class _MoveSequences>
-struct serial_move_merge
+struct __serial_move_merge
 {
     const std::size_t _M_nmerge;
     _MoveValues _M_move_values;
     _MoveSequences _M_move_sequences;
 
-    explicit serial_move_merge(std::size_t __nmerge, _MoveValues __move_values, _MoveSequences __move_sequences)
+    explicit __serial_move_merge(std::size_t __nmerge, _MoveValues __move_values, _MoveSequences __move_sequences)
         : _M_nmerge(__nmerge), _M_move_values(__move_values), _M_move_sequences(__move_sequences)
     {
     }
     template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _RandomAccessIterator3, class _Compare>
     void
     operator()(_RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, _RandomAccessIterator2 __ys,
                _RandomAccessIterator2 __ye, _RandomAccessIterator3 __zs, _Compare __comp)
     {
operator()(_RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, _RandomAccessIterator2 __ys,
             __ye = __xe;
         }
         _M_move_sequences(__ys, __ye, __zs);
     }
 };
 
 template <typename _RandomAccessIterator1, typename _OutputIterator>
 void
-init_buf(_RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, _OutputIterator __zs, bool __bMove)
+__init_buf(_RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, _OutputIterator __zs, bool __bMove)
 {
     const _OutputIterator __ze = __zs + (__xe - __xs);
     typedef typename std::iterator_traits<_OutputIterator>::value_type _ValueType;
     if (__bMove)
     {
         // Initialize the temporary buffer and move keys to it.
         for (; __zs != __ze; ++__xs, ++__zs)
             new (&*__zs) _ValueType(std::move(*__xs));
     }
     else
     {
         // Initialize the temporary buffer
         for (; __zs != __ze; ++__zs)
             new (&*__zs) _ValueType;
     }
 }
 
+// TODO is this actually used anywhere?
 template <typename _Buf>
-class stack
+class __stack
 {
     typedef typename std::iterator_traits<decltype(_Buf(0).get())>::value_type _ValueType;
     typedef typename std::iterator_traits<_ValueType*>::difference_type _DifferenceType;
 
     _Buf _M_buf;
     _ValueType* _M_ptr;
     _DifferenceType _M_maxsize;
 
-    stack(const stack&) = delete;
+    __stack(const __stack&) = delete;
     void
-    operator=(const stack&) = delete;
+    operator=(const __stack&) = delete;
 
   public:
-    stack(_DifferenceType __max_size) : _M_buf(__max_size), _M_maxsize(__max_size) { _M_ptr = _M_buf.get(); }
+    __stack(_DifferenceType __max_size) : _M_buf(__max_size), _M_maxsize(__max_size) { _M_ptr = _M_buf.get(); }
 
-    ~stack()
+    ~__stack()
     {
         assert(size() <= _M_maxsize);
         while (!empty())
             pop();
     }
 
     const _Buf&
     buffer() const

include/pstl/internal/parallel_impl.h

 
 //------------------------------------------------------------------------
 // parallel_find
 //-----------------------------------------------------------------------
 /** Return extremum value returned by brick f[i,j) for subranges [i,j) of [first,last)
 Each f[i,j) must return a value in [i,j). */
 template <class _ExecutionPolicy, class _Index, class _Brick, class _Compare>
 _Index
-parallel_find(_ExecutionPolicy&& __exec, _Index __first, _Index __last, _Brick __f, _Compare __comp, bool __b_first)
+__parallel_find(_ExecutionPolicy&& __exec, _Index __first, _Index __last, _Brick __f, _Compare __comp, bool __b_first)
 {
     typedef typename std::iterator_traits<_Index>::difference_type _DifferenceType;
     const _DifferenceType __n = __last - __first;
     _DifferenceType __initial_dist = __b_first ? __n : -1;
     std::atomic<_DifferenceType> __extremum(__initial_dist);
     // TODO: find out what is better here: parallel_for or parallel_reduce
-    par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
+    par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
                                 [__comp, __f, __first, &__extremum](_Index __i, _Index __j) {
                                     // See "Reducing Contention Through Priority Updates", PPoPP '13, for discussion of
                                     // why using a shared variable scales fairly well in this situation.
                                     if (__comp(__i - __first, __extremum))
                                     {
                                         _Index __res = __f(__i, __j);
                                         // If not '__last' returned then we found what we want so put this to extremum
                                         if (__res != __j)
                                         {
                                             const _DifferenceType __k = __res - __first;
                                             for (_DifferenceType __old = __extremum; __comp(__k, __old);
                                                  __old = __extremum)
                                             {
                                                 __extremum.compare_exchange_weak(__old, __k);
                                             }
                                         }
                                     }
                                 });
     return __extremum != __initial_dist ? __first + __extremum : __last;
 }
 
 //------------------------------------------------------------------------
 // parallel_or
 //------------------------------------------------------------------------
 //! Return true if brick f[i,j) returns true for some subrange [i,j) of [first,last)
 template <class _ExecutionPolicy, class _Index, class _Brick>
 bool
-parallel_or(_ExecutionPolicy&& __exec, _Index __first, _Index __last, _Brick __f)
+__parallel_or(_ExecutionPolicy&& __exec, _Index __first, _Index __last, _Brick __f)
 {
     std::atomic<bool> __found(false);
-    par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
+    par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
                                 [__f, &__found](_Index __i, _Index __j) {
                                     if (!__found.load(std::memory_order_relaxed) && __f(__i, __j))
                                     {
                                         __found.store(true, std::memory_order_relaxed);
-                                      par_backend::cancel_execution();
+                                        par_backend::__cancel_execution();
                                     }
                                 });
     return __found;
 }
 
 } // namespace internal
 } // namespace __pstl
 
 #endif /* __PSTL_parallel_impl_H */