Uglify unseq_backend_simd

[rodgert]

Committed by other, non-phab, means

include/pstl/internal/algorithm_impl.h

__brick_any_of(const _ForwardIterator __first, const _ForwardIterator __last, _Pred __pred,
     return std::any_of(__first, __last, __pred);
 };
 
 template <class _ForwardIterator, class _Pred>
 bool
 __brick_any_of(const _ForwardIterator __first, const _ForwardIterator __last, _Pred __pred,
                /*__is_vector=*/std::true_type) noexcept
 {
-    return unseq_backend::simd_or(__first, __last - __first, __pred);
+    return __unseq_backend::__simd_or(__first, __last - __first, __pred);
 };
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _Pred, class _IsVector>
 bool
 __pattern_any_of(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred,
                  _IsVector __is_vector, /*parallel=*/std::false_type) noexcept
 {
     return __brick_any_of(__first, __last, __pred, __is_vector);
__brick_walk1(_ForwardIterator __first, _ForwardIterator __last, _Function __f, /*vector=*/std::false_type) noexcept
     std::for_each(__first, __last, __f);
 }
 
 template <class _RandomAccessIterator, class _Function>
 void
 __brick_walk1(_RandomAccessIterator __first, _RandomAccessIterator __last, _Function __f,
               /*vector=*/std::true_type) noexcept
 {
-    unseq_backend::simd_walk_1(__first, __last - __first, __f);
+    __unseq_backend::__simd_walk_1(__first, __last - __first, __f);
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _Function, class _IsVector>
 void
 __pattern_walk1(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Function __f,
                 _IsVector __is_vector,
                 /*parallel=*/std::false_type) noexcept
 {
return __for_each_n_it_serial(__first, __n,
                                   [&__f](_ForwardIterator __it) { __f(*__it); }); // calling serial version
 }
 
 template <class _RandomAccessIterator, class _DifferenceType, class _Function>
 _RandomAccessIterator
 __brick_walk1_n(_RandomAccessIterator __first, _DifferenceType __n, _Function __f,
                 /*vectorTag=*/std::true_type) noexcept
 {
-    return unseq_backend::simd_walk_1(__first, __n, __f);
+    return __unseq_backend::__simd_walk_1(__first, __n, __f);
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Function, class _IsVector>
 _ForwardIterator
 __pattern_walk1_n(_ExecutionPolicy&&, _ForwardIterator __first, _Size __n, _Function __f, _IsVector __is_vector,
                   /*is_parallel=*/std::false_type) noexcept
 {
     return __brick_walk1_n(__first, __n, __f, __is_vector);
__brick_walk2(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Function __f,
     return __first2;
 }
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _Function>
 _ForwardIterator2
 __brick_walk2(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Function __f,
               /*vector=*/std::true_type) noexcept
 {
-    return unseq_backend::simd_walk_2(__first1, __last1 - __first1, __first2, __f);
+    return __unseq_backend::__simd_walk_2(__first1, __last1 - __first1, __first2, __f);
 }
 
 template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function>
 _ForwardIterator2
 __brick_walk2_n(_ForwardIterator1 __first1, _Size __n, _ForwardIterator2 __first2, _Function __f,
                 /*vector=*/std::false_type) noexcept
 {
     for (; __n > 0; --__n, ++__first1, ++__first2)
         __f(*__first1, *__first2);
     return __first2;
 }
 
 template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function>
 _ForwardIterator2
 __brick_walk2_n(_ForwardIterator1 __first1, _Size __n, _ForwardIterator2 __first2, _Function __f,
                 /*vector=*/std::true_type) noexcept
 {
-    return unseq_backend::simd_walk_2(__first1, __n, __first2, __f);
+    return __unseq_backend::__simd_walk_2(__first1, __n, __first2, __f);
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector>
 _ForwardIterator2
 __pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
                 _Function __f, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept
 {
     return __brick_walk2(__first1, __last1, __first2, __f, __is_vector);
__brick_walk3(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
     return __first3;
 }
 
 template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _RandomAccessIterator3, class _Function>
 _RandomAccessIterator3
 __brick_walk3(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2,
               _RandomAccessIterator3 __first3, _Function __f, /*vector=*/std::true_type) noexcept
 {
-    return unseq_backend::simd_walk_3(__first1, __last1 - __first1, __first2, __first3, __f);
+    return __unseq_backend::__simd_walk_3(__first1, __last1 - __first1, __first2, __first3, __f);
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator3,
           class _Function, class _IsVector>
 _ForwardIterator3
 __pattern_walk3(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
                 _ForwardIterator3 __first3, _Function __f, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept
 {
__brick_equal(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _BinaryPredicate __p,
     return std::equal(__first1, __last1, __first2, __p);
 }
 
 template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
 bool
 __brick_equal(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2,
               _BinaryPredicate __p, /* is_vector = */ std::true_type) noexcept
 {
-    return unseq_backend::simd_first(__first1, __last1 - __first1, __first2, __not_pred<_BinaryPredicate>(__p)).first ==
-           __last1;
+    return __unseq_backend::__simd_first(__first1, __last1 - __first1, __first2, __not_pred<_BinaryPredicate>(__p))
+               .first == __last1;
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
           class _IsVector>
 bool
 __pattern_equal(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
                 _BinaryPredicate __p, _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept
 {

 }
 
 template <class _RandomAccessIterator, class _Predicate>
 _RandomAccessIterator
 __brick_find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, _Predicate __pred,
                 /*is_vector=*/std::true_type) noexcept
 {
     typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _SizeType;
-    return unseq_backend::simd_first(
+    return __unseq_backend::__simd_first(
         __first, _SizeType(0), __last - __first,
         [&__pred](_RandomAccessIterator __it, _SizeType __i) { return __pred(__it[__i]); });
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
 _ForwardIterator
 __pattern_find_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
                   _IsVector __is_vector,
__brick_find_first_of(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
     return std::find_first_of(__first, __last, __s_first, __s_last, __pred);
 }
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
 _ForwardIterator1
 __brick_find_first_of(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
                       _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*__is_vector=*/std::true_type) noexcept
 {
-    return unseq_backend::simd_find_first_of(__first, __last, __s_first, __s_last, __pred);
+    return __unseq_backend::__simd_find_first_of(__first, __last, __s_first, __s_last, __pred);
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
           class _IsVector>
 _ForwardIterator1
 __pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last,
                         _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred,
                         _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept

 {
     return std::copy_n(__first, __n, __result);
 }
 
 template <class _ForwardIterator, class _Size, class _OutputIterator>
 _OutputIterator
 __brick_copy_n(_ForwardIterator __first, _Size __n, _OutputIterator __result, /*vector=*/std::true_type) noexcept
 {
-    return unseq_backend::simd_assign(__first, __n, __result,
-                                      [](_ForwardIterator __first, _OutputIterator __result) { *__result = *__first; });
+    return __unseq_backend::__simd_assign(
+        __first, __n, __result, [](_ForwardIterator __first, _OutputIterator __result) { *__result = *__first; });
 }
 
 //------------------------------------------------------------------------
 // copy
 //------------------------------------------------------------------------
 template <class _ForwardIterator, class _OutputIterator>
 _OutputIterator
 __brick_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
              /*vector=*/std::false_type) noexcept
 {
     return std::copy(__first, __last, __result);
 }
 
 template <class _RandomAccessIterator, class _OutputIterator>
 _OutputIterator
 __brick_copy(_RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator __result,
              /*vector=*/std::true_type) noexcept
 {
-    return unseq_backend::simd_assign(
+    return __unseq_backend::__simd_assign(
         __first, __last - __first, __result,
         [](_RandomAccessIterator __first, _OutputIterator __result) { *__result = *__first; });
 }
 
 //------------------------------------------------------------------------
 // move
 //------------------------------------------------------------------------
 template <class _ForwardIterator, class _OutputIterator>
 _OutputIterator
 __brick_move(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
              /*vector=*/std::false_type) noexcept
 {
     return std::move(__first, __last, __result);
 }
 
 template <class _RandomAccessIterator, class _OutputIterator>
 _OutputIterator
 __brick_move(_RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator __result,
              /*vector=*/std::true_type) noexcept
 {
-    return unseq_backend::simd_assign(
+    return __unseq_backend::__simd_assign(
         __first, __last - __first, __result,
         [](_RandomAccessIterator __first, _OutputIterator __result) { *__result = std::move(*__first); });
 }
 
 //------------------------------------------------------------------------
 // swap_ranges
 //------------------------------------------------------------------------
 template <class _ForwardIterator, class _OutputIterator>
 _OutputIterator
 __brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
                     /*vector=*/std::false_type) noexcept
 {
     return std::swap_ranges(__first, __last, __result);
 }
 
 template <class _ForwardIterator, class _OutputIterator>
 _OutputIterator
 __brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
                     /*vector=*/std::true_type) noexcept
 {
     using std::iter_swap;
-    return unseq_backend::simd_assign(__first, __last - __first, __result,
+    return __unseq_backend::__simd_assign(__first, __last - __first, __result,
                                           iter_swap<_ForwardIterator, _OutputIterator>);
 }
 
 //------------------------------------------------------------------------
 // copy_if
 //------------------------------------------------------------------------
 template <class _ForwardIterator, class _OutputIterator, class _UnaryPredicate>
 _OutputIterator
 __brick_copy_if(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _UnaryPredicate __pred,
                 /*vector=*/std::false_type) noexcept
 {
     return std::copy_if(__first, __last, __result, __pred);
 }
 
 template <class _ForwardIterator, class _OutputIterator, class _UnaryPredicate>
 _OutputIterator
 __brick_copy_if(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _UnaryPredicate __pred,
                 /*vector=*/std::true_type) noexcept
 {
 #if (__PSTL_MONOTONIC_PRESENT)
-    return unseq_backend::simd_copy_if(__first, __last - __first, __result, __pred);
+    return __unseq_backend::__simd_copy_if(__first, __last - __first, __result, __pred);
 #else
     return std::copy_if(__first, __last, __result, __pred);
 #endif
 }
 
 // TODO: Try to use transform_reduce for combining __brick_copy_if_phase1 on IsVector.
 template <class _DifferenceType, class _ForwardIterator, class _UnaryPredicate>
 std::pair<_DifferenceType, _DifferenceType>
__brick_calc_mask_1(_ForwardIterator __first, _ForwardIterator __last, bool* __restrict __mask, _UnaryPredicate __pred,
     return std::make_pair(__count_true, __size - __count_true);
 }
 
 template <class _DifferenceType, class _RandomAccessIterator, class _UnaryPredicate>
 std::pair<_DifferenceType, _DifferenceType>
 __brick_calc_mask_1(_RandomAccessIterator __first, _RandomAccessIterator __last, bool* __mask, _UnaryPredicate __pred,
                     /*vector=*/std::true_type) noexcept
 {
-    auto __result = unseq_backend::simd_calc_mask_1(__first, __last - __first, __mask, __pred);
+    auto __result = __unseq_backend::__simd_calc_mask_1(__first, __last - __first, __mask, __pred);
     return std::make_pair(__result, (__last - __first) - __result);
 }
 
 template <class _ForwardIterator, class _OutputIterator, class _Assigner>
 void
 __brick_copy_by_mask(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, bool* __mask,
                      _Assigner __assigner, /*vector=*/std::false_type) noexcept
 {
     for (; __first != __last; ++__first, ++__mask)
     {
         if (*__mask)
         {
             __assigner(__first, __result);
             ++__result;
         }
     }
 }
 
 template <class _ForwardIterator, class _OutputIterator, class _Assigner>
 void
 __brick_copy_by_mask(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
                      bool* __restrict __mask, _Assigner __assigner, /*vector=*/std::true_type) noexcept
 {
 #if (__PSTL_MONOTONIC_PRESENT)
-    unseq_backend::simd_copy_by_mask(__first, __last - __first, __result, __mask, __assigner);
+    __unseq_backend::__simd_copy_by_mask(__first, __last - __first, __result, __mask, __assigner);
 #else
     __brick_copy_by_mask(__first, __last, __result, __mask, __assigner, std::false_type());
 #endif
 }
 
 template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2>
 void
 __brick_partition_by_mask(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true,

 }
 
 template <class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2>
 void
 __brick_partition_by_mask(_RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator1 __out_true,
                           _OutputIterator2 __out_false, bool* __mask, /*vector=*/std::true_type) noexcept
 {
 #if (__PSTL_MONOTONIC_PRESENT)
-    unseq_backend::simd_partition_by_mask(__first, __last - __first, __out_true, __out_false, __mask);
+    __unseq_backend::__simd_partition_by_mask(__first, __last - __first, __out_true, __out_false, __mask);
 #else
     __brick_partition_by_mask(__first, __last, __out_true, __out_false, __mask, std::false_type());
 #endif
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _UnaryPredicate, class _IsVector>
 _OutputIterator
 __pattern_copy_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,

 //------------------------------------------------------------------------
 // count
 //------------------------------------------------------------------------
 template <class _ForwardIterator, class _Predicate>
 typename std::iterator_traits<_ForwardIterator>::difference_type
 __brick_count(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
               /* is_vector = */ std::true_type) noexcept
 {
-    return unseq_backend::simd_count(__first, __last - __first, __pred);
+    return __unseq_backend::__simd_count(__first, __last - __first, __pred);
 }
 
 template <class _ForwardIterator, class _Predicate>
 typename std::iterator_traits<_ForwardIterator>::difference_type
 __brick_count(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
               /* is_vector = */ std::false_type) noexcept
 {
     return std::count_if(__first, __last, __pred);

 }
 
 template <class _RandomAccessIterator, class OutputIterator, class _BinaryPredicate>
 OutputIterator
 __brick_unique_copy(_RandomAccessIterator __first, _RandomAccessIterator __last, OutputIterator __result,
                     _BinaryPredicate __pred, /*vector=*/std::true_type) noexcept
 {
 #if (__PSTL_MONOTONIC_PRESENT)
-    return unseq_backend::simd_unique_copy(__first, __last - __first, __result, __pred);
+    return __unseq_backend::__simd_unique_copy(__first, __last - __first, __result, __pred);
 #else
     return std::unique_copy(__first, __last, __result, __pred);
 #endif
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _BinaryPredicate,
           class _IsVector>
 _OutputIterator
__brick_calc_mask_2(_RandomAccessIterator __first, _RandomAccessIterator __last, bool* __restrict __mask,
     return __count;
 }
 
 template <class _DifferenceType, class _RandomAccessIterator, class _BinaryPredicate>
 _DifferenceType
 __brick_calc_mask_2(_RandomAccessIterator __first, _RandomAccessIterator __last, bool* __restrict __mask,
                     _BinaryPredicate __pred, /*vector=*/std::true_type) noexcept
 {
-    return unseq_backend::simd_calc_mask_2(__first, __last - __first, __mask, __pred);
+    return __unseq_backend::__simd_calc_mask_2(__first, __last - __first, __mask, __pred);
 }
 
 #if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _BinaryPredicate,
           class _IsVector>
 _OutputIterator
 __pattern_unique_copy(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
                       _OutputIterator __result, _BinaryPredicate __pred, _IsVector __is_vector,

 
 template <class _BidirectionalIterator>
 void
 __brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, /*__is_vector=*/std::true_type) noexcept
 {
     typedef typename std::iterator_traits<_BidirectionalIterator>::reference _ReferenceType;
 
     const auto __n = (__last - __first) / 2;
-    unseq_backend::simd_walk_2(__first, __n, std::reverse_iterator<_BidirectionalIterator>(__last),
+    __unseq_backend::__simd_walk_2(__first, __n, std::reverse_iterator<_BidirectionalIterator>(__last),
                                    [](_ReferenceType __x, _ReferenceType __y) {
                                        using std::swap;
                                        swap(__x, __y);
                                    });
 }
 
 // this brick is called in parallel version, so we can use iterator arithmetic
 template <class _BidirectionalIterator>
 void
 __brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, _BidirectionalIterator __d_last,
                 /*is_vector=*/std::false_type) noexcept
 {
     for (--__d_last; __first != __last; ++__first, --__d_last)
     {
         using std::iter_swap;
         iter_swap(__first, __d_last);
     }
 }
 
 // this brick is called in parallel version, so we can use iterator arithmetic
 template <class _BidirectionalIterator>
 void
 __brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, _BidirectionalIterator __d_last,
                 /*is_vector=*/std::true_type) noexcept
 {
     typedef typename std::iterator_traits<_BidirectionalIterator>::reference _ReferenceType;
 
-    unseq_backend::simd_walk_2(__first, __last - __first, std::reverse_iterator<_BidirectionalIterator>(__d_last),
+    __unseq_backend::__simd_walk_2(__first, __last - __first, std::reverse_iterator<_BidirectionalIterator>(__d_last),
                                    [](_ReferenceType __x, _ReferenceType __y) {
                                        using std::swap;
                                        swap(__x, __y);
                                    });
 }
 
 template <class _ExecutionPolicy, class _BidirectionalIterator, class _IsVector>
 void
 __pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last,
                   _IsVector _is_vector,
                   /*is_parallel=*/std::false_type) noexcept
 {

 template <class _BidirectionalIterator, class _OutputIterator>
 _OutputIterator
 __brick_reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __d_first,
                      /*is_vector=*/std::true_type) noexcept
 {
     typedef typename std::iterator_traits<_BidirectionalIterator>::reference _ReferenceType1;
     typedef typename std::iterator_traits<_OutputIterator>::reference _ReferenceType2;
 
-    return unseq_backend::simd_walk_2(std::reverse_iterator<_BidirectionalIterator>(__last), __last - __first,
+    return __unseq_backend::__simd_walk_2(std::reverse_iterator<_BidirectionalIterator>(__last), __last - __first,
                                           __d_first, [](_ReferenceType1 __x, _ReferenceType2 __y) { __y = __x; });
 }
 
 template <class _ExecutionPolicy, class _BidirectionalIterator, class _OutputIterator, class _IsVector>
 _OutputIterator
 __pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last,
                        _OutputIterator __d_first, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
 {
     return __brick_reverse_copy(__first, __last, __d_first, __is_vector);
__brick_rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
     while (__n > 1 && __m > 0)
     {
         using std::iter_swap;
         const auto __m_2 = __m * 2;
         if (__is_left)
         {
             for (; __last - __first >= __m_2; __first += __m)
             {
-                unseq_backend::simd_assign(__first, __m, __first + __m, iter_swap<_ForwardIterator, _ForwardIterator>);
+                __unseq_backend::__simd_assign(__first, __m, __first + __m,
+                                               iter_swap<_ForwardIterator, _ForwardIterator>);
             }
         }
         else
         {
             for (; __last - __first >= __m_2; __last -= __m)
             {
-                unseq_backend::simd_assign(__last - __m, __m, __last - __m_2,
+                __unseq_backend::__simd_assign(__last - __m, __m, __last - __m_2,
                                                iter_swap<_ForwardIterator, _ForwardIterator>);
             }
         }
         __is_left = !__is_left;
         __m = __n % __m;
         __n = __last - __first;
     }
 
     return __ret;

 {
     typedef typename std::iterator_traits<_ForwardIterator>::difference_type _SizeType;
     if (__first == __last)
     {
         return true;
     }
     else
     {
-        _ForwardIterator __result =
-            unseq_backend::simd_first(__first, _SizeType(0), __last - __first,
-                                      [&__pred](_ForwardIterator __it, _SizeType __i) { return !__pred(__it[__i]); });
+        _ForwardIterator __result = __unseq_backend::__simd_first(
+            __first, _SizeType(0), __last - __first,
         if (__result == __last)
         {
             return true;
         }
         else
         {
             ++__result;
-            return !unseq_backend::simd_or(__result, __last - __result, __pred);
+            return !__unseq_backend::__simd_or(__result, __last - __result, __pred);
         }
     }
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
 bool
 __pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
                          _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept

 }
 
 template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate>
 std::pair<_OutputIterator1, _OutputIterator2>
 __brick_partition_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true,
                        _OutputIterator2 __out_false, _UnaryPredicate __pred, /*is_vector=*/std::true_type) noexcept
 {
 #if (__PSTL_MONOTONIC_PRESENT)
-    return unseq_backend::simd_partition_copy(__first, __last - __first, __out_true, __out_false, __pred);
+    return __unseq_backend::__simd_partition_copy(__first, __last - __first, __out_true, __out_false, __pred);
 #else
     return std::partition_copy(__first, __last, __out_true, __out_false, __pred);
 #endif
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator1, class _OutputIterator2,
           class _UnaryPredicate, class _IsVector>
 std::pair<_OutputIterator1, _OutputIterator2>

 //------------------------------------------------------------------------
 // adjacent_find
 //------------------------------------------------------------------------
 template <class _ForwardIterator, class _BinaryPredicate>
 _ForwardIterator
 __brick_adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,
                       /* IsVector = */ std::true_type, bool __or_semantic) noexcept
 {
-    return unseq_backend::simd_adjacent_find(__first, __last, __pred, __or_semantic);
+    return __unseq_backend::__simd_adjacent_find(__first, __last, __pred, __or_semantic);
 }
 
 template <class _ForwardIterator, class _BinaryPredicate>
 _ForwardIterator
 __brick_adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,
                       /* IsVector = */ std::false_type, bool __or_semantic) noexcept
 {
     return std::adjacent_find(__first, __last, __pred);

 //------------------------------------------------------------------------
 // fill, fill_n
 //------------------------------------------------------------------------
 template <class _ForwardIterator, class _Tp>
 void
 __brick_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value,
              /* __is_vector = */ std::true_type) noexcept
 {
-    unseq_backend::simd_fill_n(__first, __last - __first, __value);
+    __unseq_backend::__simd_fill_n(__first, __last - __first, __value);
 }
 
 template <class _ForwardIterator, class _Tp>
 void
 __brick_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value,
              /* __is_vector = */ std::false_type) noexcept
 {
     std::fill(__first, __last, __value);
__pattern_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value,
     });
 }
 #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
 {
-    return unseq_backend::simd_fill_n(__first, __count, __value);
+    return __unseq_backend::__simd_fill_n(__first, __count, __value);
 }
 
 template <class _OutputIterator, class _Size, class _Tp>
 _OutputIterator
 __brick_fill_n(_OutputIterator __first, _Size __count, const _Tp& __value, /* __is_vector = */ std::false_type) noexcept
 {
     return std::fill_n(__first, __count, __value);
 }

 //------------------------------------------------------------------------
 // generate, generate_n
 //------------------------------------------------------------------------
 template <class _RandomAccessIterator, class _Generator>
 void
 __brick_generate(_RandomAccessIterator __first, _RandomAccessIterator __last, _Generator __g,
                  /* is_vector = */ std::true_type) noexcept
 {
-    unseq_backend::simd_generate_n(__first, __last - __first, __g);
+    __unseq_backend::__simd_generate_n(__first, __last - __first, __g);
 }
 
 template <class _ForwardIterator, class _Generator>
 void
 __brick_generate(_ForwardIterator __first, _ForwardIterator __last, _Generator __g,
                  /* is_vector = */ std::false_type) noexcept
 {
     std::generate(__first, __last, __g);
__pattern_generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g,
     });
 }
 #endif
 
 template <class OutputIterator, class Size, class _Generator>
 OutputIterator
 __brick_generate_n(OutputIterator __first, Size __count, _Generator __g, /* is_vector = */ std::true_type) noexcept
 {
-    return unseq_backend::simd_generate_n(__first, __count, __g);
+    return __unseq_backend::__simd_generate_n(__first, __count, __g);
 }
 
 template <class OutputIterator, class Size, class _Generator>
 OutputIterator
 __brick_generate_n(OutputIterator __first, Size __count, _Generator __g, /* is_vector = */ std::false_type) noexcept
 {
     return std::generate_n(__first, __count, __g);
 }

 }
 
 template <class _RandomAccessIterator, class _UnaryPredicate>
 _RandomAccessIterator
 __brick_remove_if(_RandomAccessIterator __first, _RandomAccessIterator __last, _UnaryPredicate __pred,
                   /* __is_vector = */ std::true_type) noexcept
 {
 #if __PSTL_MONOTONIC_PRESENT
-    return unseq_backend::simd_remove_if(__first, __last - __first, __pred);
+    return __unseq_backend::__simd_remove_if(__first, __last - __first, __pred);
 #else
     return std::remove_if(__first, __last, __pred);
 #endif
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
 _ForwardIterator
 __pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,

 template <class _RandomAccessIterator, class _Compare>
 _RandomAccessIterator
 __brick_is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
                       /* __is_vector = */ std::true_type) noexcept
 {
     if (__last - __first < 2)
         return __last;
     typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _SizeType;
-    return unseq_backend::simd_first(
+    return __unseq_backend::__simd_first(
         __first, _SizeType(0), __last - __first,
         [&__comp](_RandomAccessIterator __it, _SizeType __i) { return __comp(__it[(__i - 1) / 2], __it[__i]); });
 }
 
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
 _RandomAccessIterator
 __pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last,
                         _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept
is_heap_until_local(_RandomAccessIterator __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp,
     return __first + __i;
 }
 
 template <class _RandomAccessIterator, class _DifferenceType, class _Compare>
 _RandomAccessIterator
 is_heap_until_local(_RandomAccessIterator __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp,
                     /* __is_vector = */ std::true_type) noexcept
 {
-    return unseq_backend::simd_first(
+    return __unseq_backend::__simd_first(
         __first, __begin, __end,
         [&__comp](_RandomAccessIterator __it, _DifferenceType __i) { return __comp(__it[(__i - 1) / 2], __it[__i]); });
 }
 
 #if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
 _RandomAccessIterator
 __pattern_is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,

 }
 
 template <typename _ForwardIterator, typename _Compare>
 _ForwardIterator
 __brick_min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
                     /* __is_vector = */ std::true_type) noexcept
 {
 #if __PSTL_UDR_PRESENT
-    return unseq_backend::simd_min_element(__first, __last - __first, __comp);
+    return __unseq_backend::__simd_min_element(__first, __last - __first, __comp);
 #else
     return std::min_element(__first, __last, __comp);
 #endif
 }
 
 template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector>
 _ForwardIterator
 __pattern_min_element(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp,

 }
 
 template <typename _ForwardIterator, typename _Compare>
 std::pair<_ForwardIterator, _ForwardIterator>
 __brick_minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
                        /* __is_vector = */ std::true_type) noexcept
 {
 #if __PSTL_UDR_PRESENT
-    return unseq_backend::simd_minmax_element(__first, __last - __first, __comp);
+    return __unseq_backend::__simd_minmax_element(__first, __last - __first, __comp);
 #else
     return std::minmax_element(__first, __last, __comp);
 #endif
 }
 
 template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector>
 std::pair<_ForwardIterator, _ForwardIterator>
 __pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp,

 }
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
 std::pair<_ForwardIterator1, _ForwardIterator2>
 __brick_mismatch(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
                  _ForwardIterator2 __last2, _Predicate __pred, /* __is_vector = */ std::true_type) noexcept
 {
     auto __n = std::min(__last1 - __first1, __last2 - __first2);
-    return unseq_backend::simd_first(__first1, __n, __first2, __not_pred<_Predicate>(__pred));
+    return __unseq_backend::__simd_first(__first1, __n, __first2, __not_pred<_Predicate>(__pred));
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate, class _IsVector>
 std::pair<_ForwardIterator1, _ForwardIterator2>
 __pattern_mismatch(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                    _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Predicate __pred, _IsVector __is_vector,
                    /* is_parallel = */ std::false_type) noexcept
 {
__brick_lexicographical_compare(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
     }
     else
     {
         typedef typename std::iterator_traits<_ForwardIterator1>::reference ref_type1;
         typedef typename std::iterator_traits<_ForwardIterator2>::reference ref_type2;
         --__last1;
         --__last2;
         auto __n = std::min(__last1 - __first1, __last2 - __first2);
-        std::pair<_ForwardIterator1, _ForwardIterator2> __result = unseq_backend::simd_first(
+        std::pair<_ForwardIterator1, _ForwardIterator2> __result = __unseq_backend::__simd_first(
             __first1, __n, __first2, [__comp](const ref_type1 __x, const ref_type2 __y) mutable {
                 return __comp(__x, __y) || __comp(__y, __x);
             });
 
         if (__result.first == __last1 && __result.second != __last2)
         { // if first sequence shorter than second
             return !__comp(*__result.second, *__result.first);
         }

include/pstl/internal/memory_impl.h

 _OutputIterator
 __brick_uninitialized_move(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
                            /*vector=*/std::true_type) noexcept
 {
     typedef typename std::iterator_traits<_OutputIterator>::value_type __ValueType2;
     typedef typename std::iterator_traits<_ForwardIterator>::reference _ReferenceType1;
     typedef typename std::iterator_traits<_OutputIterator>::reference _ReferenceType2;
 
-    return unseq_backend::simd_walk_2(
+    return __unseq_backend::__simd_walk_2(
         __first, __last - __first, __result,
         [](_ReferenceType1 __x, _ReferenceType2 __y) { ::new (std::addressof(__y)) __ValueType2(std::move(__x)); });
 }
 
 } // namespace __internal
 } // namespace __pstl
 
 #endif /* __PSTL_memory_impl_H */

include/pstl/internal/numeric_impl.h

 
 template <class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2>
 _Tp
 __brick_transform_reduce(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Tp __init,
                          _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2,
                          /*is_vector=*/std::true_type) noexcept
 {
     typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferenceType;
-    return unseq_backend::simd_transform_reduce(
+    return __unseq_backend::__simd_transform_reduce(
         __last1 - __first1, __init, __binary_op1,
         [=, &__binary_op2](_DifferenceType __i) { return __binary_op2(__first1[__i], __first2[__i]); });
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1,
           class _BinaryOperation2, class _IsVector>
 _Tp
 __pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,

 }
 
 template <class _ForwardIterator, class _Tp, class _UnaryOperation, class _BinaryOperation>
 _Tp
 __brick_transform_reduce(_ForwardIterator __first, _ForwardIterator __last, _Tp __init, _BinaryOperation __binary_op,
                          _UnaryOperation __unary_op, /*is_vector=*/std::true_type) noexcept
 {
     typedef typename std::iterator_traits<_ForwardIterator>::difference_type _DifferenceType;
-    return unseq_backend::simd_transform_reduce(
+    return __unseq_backend::__simd_transform_reduce(
         __last - __first, __init, __binary_op,
         [=, &__unary_op](_DifferenceType __i) { return __unary_op(__first[__i]); });
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation,
           class _IsVector>
 _Tp
 __pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Tp __init,

 template <class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation,
           class _Inclusive>
 typename std::enable_if<!is_arithmetic_udop<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
 __brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
                        _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _Inclusive,
                        /*is_vector=*/std::true_type) noexcept
 {
 #if (__PSTL_UDS_PRESENT)
-    return unseq_backend::simd_scan(__first, __last - __first, __result, __unary_op, __init, __binary_op, _Inclusive());
+    return __unseq_backend::__simd_scan(__first, __last - __first, __result, __unary_op, __init, __binary_op,
+                                        _Inclusive());
 #else
     // We need to call serial brick here to call function for inclusive and exclusive scan that depends on _Inclusive() value
     return __brick_transform_scan(__first, __last, __result, __unary_op, __init, __binary_op, _Inclusive(),
                                   /*is_vector=*/std::false_type());
 #endif
 }
 
 template <class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation,

 {
     assert(__first != __last);
 
     typedef typename std::iterator_traits<_ForwardIterator1>::reference _ReferenceType1;
     typedef typename std::iterator_traits<_ForwardIterator2>::reference _ReferenceType2;
 
     auto __n = __last - __first;
     *__d_first = *__first;
-    return unseq_backend::simd_walk_3(
+    return __unseq_backend::__simd_walk_3(
         __first + 1, __n - 1, __first, __d_first + 1,
         [&__op](_ReferenceType1 __x, _ReferenceType1 __y, _ReferenceType2 __z) { __z = __op(__x, __y); });
 }
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _BinaryOperation,
           class _IsVector>
 _OutputIterator
 __pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last,

include/pstl/internal/unseq_backend_simd.h

 #include <type_traits>
 
 #include "utils.h"
 
 // This header defines the minimum set of vector routines required
 // to support parallel STL.
 namespace __pstl
 {
-namespace unseq_backend
+namespace __unseq_backend
 {
 
 // Expect vector width up to 64 (or 512 bit)
 const std::size_t __lane_size = 64;
 
 template <class _Iterator, class _DifferenceType, class _Function>
 _Iterator
-simd_walk_1(_Iterator __first, _DifferenceType __n, _Function __f) noexcept
+__simd_walk_1(_Iterator __first, _DifferenceType __n, _Function __f) noexcept
 {
     __PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 0; __i < __n; ++__i)
         __f(__first[__i]);
 
     return __first + __n;
 }
 
 template <class _Iterator1, class _DifferenceType, class _Iterator2, class _Function>
 _Iterator2
-simd_walk_2(_Iterator1 __first1, _DifferenceType __n, _Iterator2 __first2, _Function __f) noexcept
+__simd_walk_2(_Iterator1 __first1, _DifferenceType __n, _Iterator2 __first2, _Function __f) noexcept
 {
     __PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 0; __i < __n; ++__i)
         __f(__first1[__i], __first2[__i]);
     return __first2 + __n;
 }
 
 template <class _Iterator1, class _DifferenceType, class _Iterator2, class _Iterator3, class _Function>
 _Iterator3
-simd_walk_3(_Iterator1 __first1, _DifferenceType __n, _Iterator2 __first2, _Iterator3 __first3, _Function __f) noexcept
+__simd_walk_3(_Iterator1 __first1, _DifferenceType __n, _Iterator2 __first2, _Iterator3 __first3,
+              _Function __f) noexcept
 {
     __PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 0; __i < __n; ++__i)
         __f(__first1[__i], __first2[__i], __first3[__i]);
     return __first3 + __n;
 }
 
-// TODO: check whether simd_first() can be used here
+// TODO: check whether __simd_first() can be used here
 template <class _Index, class _DifferenceType, class _Pred>
 bool
-simd_or(_Index __first, _DifferenceType __n, _Pred __pred) noexcept
+__simd_or(_Index __first, _DifferenceType __n, _Pred __pred) noexcept
 {
 #if __PSTL_EARLYEXIT_PRESENT
     _DifferenceType __i;
     __PSTL_PRAGMA_VECTOR_UNALIGNED
     __PSTL_PRAGMA_SIMD_EARLYEXIT
     for (__i = 0; __i < __n; ++__i)
         if (__pred(__first[__i]))
             break;
while (__last != __first)
         }
     }
     return false;
 #endif
 }
 
 template <class _Index, class _DifferenceType, class _Compare>
 _Index
-simd_first(_Index __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp) noexcept
+__simd_first(_Index __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp) noexcept
 {
 #if __PSTL_EARLYEXIT_PRESENT
     _DifferenceType __i = __begin;
     __PSTL_PRAGMA_VECTOR_UNALIGNED // Do not generate peel loop part
         __PSTL_PRAGMA_SIMD_EARLYEXIT for (; __i < __end; ++__i)
     {
         if (__comp(__first, __i))
         {
while (__begin != __end)
         ++__begin;
     }
     return __first + __end;
 #endif //__PSTL_EARLYEXIT_PRESENT
 }
 
 template <class _Index1, class _DifferenceType, class _Index2, class _Pred>
 std::pair<_Index1, _Index2>
-simd_first(_Index1 __first1, _DifferenceType __n, _Index2 __first2, _Pred __pred) noexcept
+__simd_first(_Index1 __first1, _DifferenceType __n, _Index2 __first2, _Pred __pred) noexcept
 {
 #if __PSTL_EARLYEXIT_PRESENT
     _DifferenceType __i = 0;
     __PSTL_PRAGMA_VECTOR_UNALIGNED
     __PSTL_PRAGMA_SIMD_EARLYEXIT
     for (; __i < __n; ++__i)
         if (__pred(__first1[__i], __first2[__i]))
             break;
for (; __last1 != __first1; ++__first1, ++__first2)
             return std::make_pair(__first1, __first2);
 
     return std::make_pair(__last1, __last2);
 #endif //__PSTL_EARLYEXIT_PRESENT
 }
 
 template <class _Index, class _DifferenceType, class _Pred>
 _DifferenceType
-simd_count(_Index __index, _DifferenceType __n, _Pred __pred) noexcept
+__simd_count(_Index __index, _DifferenceType __n, _Pred __pred) noexcept
 {
     _DifferenceType __count = 0;
     __PSTL_PRAGMA_SIMD_REDUCTION(+ : __count)
     for (_DifferenceType __i = 0; __i < __n; ++__i)
         if (__pred(*(__index + __i)))
             ++__count;
 
     return __count;
 }
 
 template <class _InputIterator, class _DifferenceType, class _OutputIterator, class _BinaryPredicate>
 _OutputIterator
-simd_unique_copy(_InputIterator __first, _DifferenceType __n, _OutputIterator __result,
+__simd_unique_copy(_InputIterator __first, _DifferenceType __n, _OutputIterator __result,
                    _BinaryPredicate __pred) noexcept
 {
     if (__n == 0)
         return __result;
 
     _DifferenceType __cnt = 1;
     __result[0] = __first[0];
 
     __PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 1; __i < __n; ++__i)
     {
         __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(__cnt : 1)
         if (!__pred(__first[__i], __first[__i - 1]))
         {
             __result[__cnt] = __first[__i];
             ++__cnt;
         }
     }
     return __result + __cnt;
 }
 
 template <class _InputIterator, class _DifferenceType, class _OutputIterator, class _Assigner>
 _OutputIterator
-simd_assign(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, _Assigner __assigner) noexcept
+__simd_assign(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, _Assigner __assigner) noexcept
 {
     __PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
     __PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 0; __i < __n; ++__i)
         __assigner(__first + __i, __result + __i);
     return __result + __n;
 }
 
 template <class _InputIterator, class _DifferenceType, class _OutputIterator, class _UnaryPredicate>
 _OutputIterator
-simd_copy_if(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, _UnaryPredicate __pred) noexcept
+__simd_copy_if(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, _UnaryPredicate __pred) noexcept
 {
     _DifferenceType __cnt = 0;
 
     __PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 0; __i < __n; ++__i)
     {
         __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(__cnt : 1)
         if (__pred(__first[__i]))
         {
             __result[__cnt] = __first[__i];
             ++__cnt;
         }
     }
     return __result + __cnt;
 }
 
 template <class _InputIterator, class _DifferenceType, class _BinaryPredicate>
 _DifferenceType
-simd_calc_mask_2(_InputIterator __first, _DifferenceType __n, bool* __mask, _BinaryPredicate __pred) noexcept
+__simd_calc_mask_2(_InputIterator __first, _DifferenceType __n, bool* __mask, _BinaryPredicate __pred) noexcept
 {
     _DifferenceType __count = 0;
 
     __PSTL_PRAGMA_SIMD_REDUCTION(+ : __count)
     for (_DifferenceType __i = 0; __i < __n; ++__i)
     {
         __mask[__i] = !__pred(__first[__i], __first[__i - 1]);
         __count += __mask[__i];
     }
     return __count;
 }
 
 template <class _InputIterator, class _DifferenceType, class _UnaryPredicate>
 _DifferenceType
-simd_calc_mask_1(_InputIterator __first, _DifferenceType __n, bool* __mask, _UnaryPredicate __pred) noexcept
+__simd_calc_mask_1(_InputIterator __first, _DifferenceType __n, bool* __mask, _UnaryPredicate __pred) noexcept
 {
     _DifferenceType __count = 0;
 
     __PSTL_PRAGMA_SIMD_REDUCTION(+ : __count)
     for (_DifferenceType __i = 0; __i < __n; ++__i)
     {
         __mask[__i] = __pred(__first[__i]);
         __count += __mask[__i];
     }
     return __count;
 }
 
 template <class _InputIterator, class _DifferenceType, class _OutputIterator, class _Assigner>
 void
-simd_copy_by_mask(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, bool* __mask,
+__simd_copy_by_mask(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, bool* __mask,
                     _Assigner __assigner) noexcept
 {
     _DifferenceType __cnt = 0;
     __PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 0; __i < __n; ++__i)
     {
         if (__mask[__i])
         {
             __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(__cnt : 1)
             {
                 __assigner(__first + __i, __result + __cnt);
                 ++__cnt;
             }
         }
     }
 }
 
 template <class _InputIterator, class _DifferenceType, class _OutputIterator1, class _OutputIterator2>
 void
-simd_partition_by_mask(_InputIterator __first, _DifferenceType __n, _OutputIterator1 __out_true,
+__simd_partition_by_mask(_InputIterator __first, _DifferenceType __n, _OutputIterator1 __out_true,
                          _OutputIterator2 __out_false, bool* __mask) noexcept
 {
     _DifferenceType __cnt_true = 0, __cnt_false = 0;
     __PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 0; __i < __n; ++__i)
     {
         __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(__cnt_true : 1, __cnt_false : 1)
         if (__mask[__i])
         {
             __out_true[__cnt_true] = __first[__i];
             ++__cnt_true;
         }
         else
         {
             __out_false[__cnt_false] = __first[__i];
             ++__cnt_false;
         }
     }
 }
 
 template <class _Index, class _DifferenceType, class _Tp>
 _Index
-simd_fill_n(_Index __first, _DifferenceType __n, const _Tp& __value) noexcept
+__simd_fill_n(_Index __first, _DifferenceType __n, const _Tp& __value) noexcept
 {
     __PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
     __PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 0; __i < __n; ++__i)
         __first[__i] = __value;
     return __first + __n;
 }
 
 template <class _Index, class _DifferenceType, class _Generator>
 _Index
-simd_generate_n(_Index __first, _DifferenceType __size, _Generator __g) noexcept
+__simd_generate_n(_Index __first, _DifferenceType __size, _Generator __g) noexcept
 {
     __PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
     __PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 0; __i < __size; ++__i)
         __first[__i] = __g();
     return __first + __size;
 }
 
 template <class _Index, class _BinaryPredicate>
 _Index
-simd_adjacent_find(_Index __first, _Index __last, _BinaryPredicate __pred, bool __or_semantic) noexcept
+__simd_adjacent_find(_Index __first, _Index __last, _BinaryPredicate __pred, bool __or_semantic) noexcept
 {
     if (__last - __first < 2)
         return __last;
 
     typedef typename std::iterator_traits<_Index>::difference_type _DifferenceType;
     _DifferenceType __i = 0;
 
 #if __PSTL_EARLYEXIT_PRESENT

 
 // It was created to reduce the code inside std::enable_if
 template <typename _Tp, typename _BinaryOperation>
 using is_arithmetic_plus = std::integral_constant<bool, std::is_arithmetic<_Tp>::value &&
                                                             std::is_same<_BinaryOperation, std::plus<_Tp>>::value>;
 
 template <typename _DifferenceType, typename _Tp, typename _BinaryOperation, typename _UnaryOperation>
 typename std::enable_if<is_arithmetic_plus<_Tp, _BinaryOperation>::value, _Tp>::type
-simd_transform_reduce(_DifferenceType __n, _Tp __init, _BinaryOperation, _UnaryOperation __f) noexcept
+__simd_transform_reduce(_DifferenceType __n, _Tp __init, _BinaryOperation, _UnaryOperation __f) noexcept
 {
     __PSTL_PRAGMA_SIMD_REDUCTION(+ : __init)
     for (_DifferenceType __i = 0; __i < __n; ++__i)
         __init += __f(__i);
     return __init;
 }
 
 template <typename _Size, typename _Tp, typename _BinaryOperation, typename _UnaryOperation>
 typename std::enable_if<!is_arithmetic_plus<_Tp, _BinaryOperation>::value, _Tp>::type
-simd_transform_reduce(_Size __n, _Tp __init, _BinaryOperation __binary_op, _UnaryOperation __f) noexcept
+__simd_transform_reduce(_Size __n, _Tp __init, _BinaryOperation __binary_op, _UnaryOperation __f) noexcept
 {
     const std::size_t __block_size = __lane_size / sizeof(_Tp);
     if (__n > 2 * __block_size && __block_size > 1)
     {
         alignas(__lane_size) char __lane_[__lane_size];
         _Tp* __lane = reinterpret_cast<_Tp*>(__lane_);
 
         // initializer
__simd_transform_reduce(_Size __n, _Tp __init, _BinaryOperation __binary_op, _UnaryOperation __f) noexcept
     }
     return __init;
 }
 
 // Exclusive scan for "+" and arithmetic types
 template <class _InputIterator, class _Size, class _OutputIterator, class _UnaryOperation, class _Tp,
           class _BinaryOperation>
 typename std::enable_if<is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
-simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
+__simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
             _BinaryOperation, /*Inclusive*/ std::false_type)
 {
     __PSTL_PRAGMA_SIMD_SCAN(+ : __init)
     for (_Size __i = 0; __i < __n; ++__i)
     {
         __result[__i] = __init;
         __PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(__init)
         __init += __unary_op(__first[__i]);
     }
operator()(const _Combiner& __obj)
         __value = (*__bin_op)(__value, __obj.__value);
     }
 };
 
 // Exclusive scan for other binary operations and types
 template <class _InputIterator, class _Size, class _OutputIterator, class _UnaryOperation, class _Tp,
           class _BinaryOperation>
 typename std::enable_if<!is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
-simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
+__simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
             _BinaryOperation __binary_op, /*Inclusive*/ std::false_type)
 {
     typedef _Combiner<_Tp, _BinaryOperation> _CombinerType;
     _CombinerType __init_{__init, &__binary_op};
 
     __PSTL_PRAGMA_DECLARE_REDUCTION(__bin_op, _CombinerType)
 
     __PSTL_PRAGMA_SIMD_SCAN(__bin_op : __init_)
     for (_Size __i = 0; __i < __n; ++__i)
     {
         __result[__i] = __init_.__value;
         __PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(__init_)
         __PSTL_PRAGMA_FORCEINLINE
         __init_.__value = __binary_op(__init_.__value, __unary_op(__first[__i]));
     }
     return std::make_pair(__result + __n, __init_.__value);
 }
 
 // Inclusive scan for "+" and arithmetic types
 template <class _InputIterator, class _Size, class _OutputIterator, class _UnaryOperation, class _Tp,
           class _BinaryOperation>
 typename std::enable_if<is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
-simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
+__simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
             _BinaryOperation, /*Inclusive*/ std::true_type)
 {
     __PSTL_PRAGMA_SIMD_SCAN(+ : __init)
     for (_Size __i = 0; __i < __n; ++__i)
     {
         __init += __unary_op(__first[__i]);
         __PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(__init)
         __result[__i] = __init;
     }
     return std::make_pair(__result + __n, __init);
 }
 
 // Inclusive scan for other binary operations and types
 template <class _InputIterator, class _Size, class _OutputIterator, class _UnaryOperation, class _Tp,
           class _BinaryOperation>
 typename std::enable_if<!is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
-simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
+__simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
             _BinaryOperation __binary_op, std::true_type)
 {
     typedef _Combiner<_Tp, _BinaryOperation> _CombinerType;
     _CombinerType __init_{__init, &__binary_op};
 
     __PSTL_PRAGMA_DECLARE_REDUCTION(__bin_op, _CombinerType)
 
     __PSTL_PRAGMA_SIMD_SCAN(__bin_op : __init_)
     for (_Size __i = 0; __i < __n; ++__i)
     {
         __PSTL_PRAGMA_FORCEINLINE
         __init_.__value = __binary_op(__init_.__value, __unary_op(__first[__i]));
         __PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(__init_)
         __result[__i] = __init_.__value;
     }
     return std::make_pair(__result + __n, __init_.__value);
 }
 
 // [restriction] - std::iterator_traits<_ForwardIterator>::value_type should be DefaultConstructible.
 // complexity [violation] - We will have at most (__n-1 + number_of_lanes) comparisons instead of at most __n-1.
 template <typename _ForwardIterator, typename _Size, typename _Compare>
 _ForwardIterator
-simd_min_element(_ForwardIterator __first, _Size __n, _Compare __comp) noexcept
+__simd_min_element(_ForwardIterator __first, _Size __n, _Compare __comp) noexcept
 {
     if (__n == 0)
     {
         return __first;
     }
 
     typedef typename std::iterator_traits<_ForwardIterator>::value_type _ValueType;
     struct _ComplexType
__simd_min_element(_ForwardIterator __first, _Size __n, _Compare __comp) noexcept
     }
     return __first + __init.__min_ind;
 }
 
 // [restriction] - std::iterator_traits<_ForwardIterator>::value_type should be DefaultConstructible.
 // complexity [violation] - We will have at most (2*(__n-1) + 4*number_of_lanes) comparisons instead of at most [1.5*(__n-1)].
 template <typename _ForwardIterator, typename _Size, typename _Compare>
 std::pair<_ForwardIterator, _ForwardIterator>
-simd_minmax_element(_ForwardIterator __first, _Size __n, _Compare __comp) noexcept
+__simd_minmax_element(_ForwardIterator __first, _Size __n, _Compare __comp) noexcept
 {
     if (__n == 0)
     {
         return std::make_pair(__first, __first);
     }
     typedef typename std::iterator_traits<_ForwardIterator>::value_type _ValueType;
 
     struct _ComplexType
for (_Size __i = 1; __i < __n; ++__i)
         }
     }
     return std::make_pair(__first + __init.__min_ind, __first + __init.__max_ind);
 }
 
 template <class _InputIterator, class _DifferenceType, class _OutputIterator1, class _OutputIterator2,
           class _UnaryPredicate>
 std::pair<_OutputIterator1, _OutputIterator2>
-simd_partition_copy(_InputIterator __first, _DifferenceType __n, _OutputIterator1 __out_true,
+__simd_partition_copy(_InputIterator __first, _DifferenceType __n, _OutputIterator1 __out_true,
                       _OutputIterator2 __out_false, _UnaryPredicate __pred) noexcept
 {
     _DifferenceType __cnt_true = 0, __cnt_false = 0;
 
     __PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 0; __i < __n; ++__i)
     {
         __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(__cnt_true : 1, __cnt_false : 1)
         if (__pred(__first[__i]))
         {
             __out_true[__cnt_true] = __first[__i];
             ++__cnt_true;
         }
         else
         {
             __out_false[__cnt_false] = __first[__i];
             ++__cnt_false;
         }
     }
     return std::make_pair(__out_true + __cnt_true, __out_false + __cnt_false);
 }
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
 _ForwardIterator1
-simd_find_first_of(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
+__simd_find_first_of(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
                      _ForwardIterator2 __s_last, _BinaryPredicate __pred) noexcept
 {
     typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferencType;
 
     const _DifferencType __n1 = __last - __first;
     const _DifferencType __n2 = __s_last - __s_first;
     if (__n1 == 0 || __n2 == 0)
     {
         return __last; // according to the standard
     }
 
     // Common case
     // If first sequence larger than second then we'll run simd_first with parameters of first sequence.
     // Otherwise, vice versa.
     if (__n1 < __n2)
     {
         for (; __first != __last; ++__first)
         {
-            if (simd_or(__s_first, __n2,
+            if (__simd_or(__s_first, __n2,
                           __internal::__equal_value_by_pred<decltype(*__first), _BinaryPredicate>(*__first, __pred)))
             {
                 return __first;
             }
         }
     }
     else
     {
         for (; __s_first != __s_last; ++__s_first)
         {
-            const auto __result = unseq_backend::simd_first(
-                __first, _DifferencType(0), __n1, [__s_first, &__pred](_ForwardIterator1 __it, _DifferencType __i) {
+            const auto __result = __simd_first(__first, _DifferencType(0), __n1,
+                                               [__s_first, &__pred](_ForwardIterator1 __it, _DifferencType __i) {
                                                    return __pred(__it[__i], *__s_first);
                                                });
             if (__result != __last)
             {
                 return __result;
             }
         }
     }
     return __last;
 }
 
 template <class _RandomAccessIterator, class _DifferenceType, class _UnaryPredicate>
 _RandomAccessIterator
-simd_remove_if(_RandomAccessIterator __first, _DifferenceType __n, _UnaryPredicate __pred) noexcept
+__simd_remove_if(_RandomAccessIterator __first, _DifferenceType __n, _UnaryPredicate __pred) noexcept
 {
     // find first element we need to remove
-    auto __current = unseq_backend::simd_first(
-        __first, _DifferenceType(0), __n,
+    auto __current =
+        __simd_first(__first, _DifferenceType(0), __n,
                      [&__pred](_RandomAccessIterator __it, _DifferenceType __i) { return __pred(__it[__i]); });
     __n -= __current - __first;
 
     // if we have in sequence only one element that pred(__current[1]) != false we can exit the function
     if (__n < 2)
     {
         return __current;
     }
 
     _DifferenceType __cnt = 0;
     __PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 1; __i < __n; ++__i)
     {
         __PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(__cnt : 1)
         if (!__pred(__current[__i]))
         {
             __current[__cnt] = std::move(__current[__i]);
             ++__cnt;
         }
     }
     return __current + __cnt;
 }
-} // namespace unseq_backend
+} // namespace __unseq_backend
 } // namespace __pstl
 
 #endif /* __PSTL_unseq_backend_simd_H */