[libc++][PSTL][NFC] clang-format files

[philnik]

Rebased

[philnik]

Rebased

[philnik]

Rebased

[philnik]

Rebased

[philnik]

Try to fix CI

[philnik]

Try to fix CI

[philnik]

Rebased

[philnik]

Rebasex

[ldionne]

LGTM but make sure to get a green CI run after rebasing everything!

[philnik]

• Rebased
• Try to fix CI

[philnik]

Try to fix CI

[philnik]

Re-add numeric_impl.h and internal/utils.h back to the ingore_list
They should be formatted, but the generator isn't happy for some reason. I'll try to find out why later.

libcxx/include/pstl/internal/algorithm_fwd.h

 #include <iterator>
 #include <type_traits>
 #include <utility>
 
 #include "pstl_config.h"
 
 _PSTL_HIDE_FROM_ABI_PUSH
 
-namespace __pstl
-{
-namespace __internal
-{
+namespace __pstl {
+namespace __internal {
 
 //------------------------------------------------------------------------
 // any_of
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator, class _Pred>
-bool
-__brick_any_of(const _ForwardIterator, const _ForwardIterator, _Pred,
+bool __brick_any_of(const _ForwardIterator,
+                    const _ForwardIterator,
+                    _Pred,
                     /*__is_vector=*/std::false_type) noexcept;
 
 template <class _RandomAccessIterator, class _Pred>
-bool
-__brick_any_of(const _RandomAccessIterator, const _RandomAccessIterator, _Pred,
+bool __brick_any_of(const _RandomAccessIterator,
+                    const _RandomAccessIterator,
+                    _Pred,
                     /*__is_vector=*/std::true_type) noexcept;
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Pred>
-bool
-__pattern_any_of(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Pred) noexcept;
+bool __pattern_any_of(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Pred) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Pred>
-bool
-__pattern_any_of(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Pred);
+bool __pattern_any_of(
+    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Pred);
 
 //------------------------------------------------------------------------
 // walk1 (pseudo)
 //
 // walk1 evaluates f(x) for each dereferenced value x drawn from [first,last)
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator, class _Function>
-void __brick_walk1(_ForwardIterator, _ForwardIterator, _Function,
+void __brick_walk1(_ForwardIterator,
+                   _ForwardIterator,
+                   _Function,
                    /*vector=*/std::false_type) noexcept;
 
 template <class _RandomAccessIterator, class _Function>
-void __brick_walk1(_RandomAccessIterator, _RandomAccessIterator, _Function,
+void __brick_walk1(_RandomAccessIterator,
+                   _RandomAccessIterator,
+                   _Function,
                    /*vector=*/std::true_type) noexcept;
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Function>
-void
-__pattern_walk1(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Function) noexcept;
+void __pattern_walk1(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Function) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Function>
-void
-__pattern_walk1(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Function);
+void __pattern_walk1(
+    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Function);
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Brick>
-void
-__pattern_walk_brick(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Brick) noexcept;
+void __pattern_walk_brick(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Brick) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Brick>
-void
-__pattern_walk_brick(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator,
-                     _Brick);
+void __pattern_walk_brick(
+    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Brick);
 
 //------------------------------------------------------------------------
 // walk1_n
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator, class _Size, class _Function>
-_ForwardIterator __brick_walk1_n(_ForwardIterator, _Size, _Function,
-                                 /*_IsVectorTag=*/std::false_type);
+_ForwardIterator __brick_walk1_n(
+    _ForwardIterator,
+    _Size,
+    _Function,
 
 template <class _RandomAccessIterator, class _DifferenceType, class _Function>
-_RandomAccessIterator __brick_walk1_n(_RandomAccessIterator, _DifferenceType, _Function,
-                                      /*vectorTag=*/std::true_type) noexcept;
+_RandomAccessIterator __brick_walk1_n(
+    _RandomAccessIterator,
+    _DifferenceType,
+    _Function,
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Function>
-_ForwardIterator
-__pattern_walk1_n(_Tag, _ExecutionPolicy&&, _ForwardIterator, _Size, _Function) noexcept;
+_ForwardIterator __pattern_walk1_n(_Tag, _ExecutionPolicy&&, _ForwardIterator, _Size, _Function) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Function>
 _RandomAccessIterator
 __pattern_walk1_n(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _Size, _Function);
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Brick>
-_ForwardIterator
-__pattern_walk_brick_n(_Tag, _ExecutionPolicy&&, _ForwardIterator, _Size, _Brick) noexcept;
+_ForwardIterator __pattern_walk_brick_n(_Tag, _ExecutionPolicy&&, _ForwardIterator, _Size, _Brick) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Brick>
 _RandomAccessIterator
 __pattern_walk_brick_n(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _Size, _Brick);
 
 //------------------------------------------------------------------------
 // walk2 (pseudo)
 //
 // walk2 evaluates f(x,y) for deferenced values (x,y) drawn from [first1,last1) and [first2,...)
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _Function>
-_ForwardIterator2 __brick_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function,
-                                /*vector=*/std::false_type) noexcept;
+_ForwardIterator2 __brick_walk2(
+    _ForwardIterator1,
+    _ForwardIterator1,
+    _ForwardIterator2,
+    _Function,
 
 template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _Function>
-_RandomAccessIterator2 __brick_walk2(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _Function,
-                                     /*vector=*/std::true_type) noexcept;
+_RandomAccessIterator2 __brick_walk2(
+    _RandomAccessIterator1,
+    _RandomAccessIterator1,
+    _RandomAccessIterator2,
+    _Function,
 
 template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function>
-_ForwardIterator2 __brick_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function,
-                                  /*vector=*/std::false_type) noexcept;
+_ForwardIterator2 __brick_walk2_n(
+    _ForwardIterator1,
+    _Size,
+    _ForwardIterator2,
+    _Function,
 
 template <class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2, class _Function>
-_RandomAccessIterator2 __brick_walk2_n(_RandomAccessIterator1, _Size, _RandomAccessIterator2, _Function,
-                                       /*vector=*/std::true_type) noexcept;
+_RandomAccessIterator2 __brick_walk2_n(
+    _RandomAccessIterator1,
+    _Size,
+    _RandomAccessIterator2,
+    _Function,
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Function>
 _ForwardIterator2
 __pattern_walk2(_Tag, _ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function) noexcept;
 
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2,
+template <class _IsVector,
+          class _ExecutionPolicy,
+          class _RandomAccessIterator1,
+          class _RandomAccessIterator2,
           class _Function>
-_RandomAccessIterator2
-__pattern_walk2(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1,
-                _RandomAccessIterator2, _Function);
+_RandomAccessIterator2 __pattern_walk2(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator1,
+    _RandomAccessIterator1,
+    _RandomAccessIterator2,
+    _Function);
 
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2,
+template <class _Tag,
+          class _ExecutionPolicy,
+          class _ForwardIterator1,
+          class _Size,
+          class _ForwardIterator2,
           class _Function>
 _ForwardIterator2
 __pattern_walk2_n(_Tag, _ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Function) noexcept;
 
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator1, class _Size,
-          class _RandomAccessIterator2, class _Function>
-_RandomAccessIterator2
-__pattern_walk2_n(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2,
-                  _Function);
+template <class _IsVector,
+          class _ExecutionPolicy,
+          class _RandomAccessIterator1,
+          class _Size,
+          class _RandomAccessIterator2,
+          class _Function>
+_RandomAccessIterator2 __pattern_walk2_n(
+    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2, _Function);
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Brick>
-_ForwardIterator2
-__pattern_walk2_brick(_Tag, _ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
-                      _Brick) noexcept;
+_ForwardIterator2 __pattern_walk2_brick(
+    _Tag, _ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Brick) noexcept;
 
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2,
+template <class _IsVector,
+          class _ExecutionPolicy,
+          class _RandomAccessIterator1,
+          class _RandomAccessIterator2,
           class _Brick>
-_RandomAccessIterator2
-__pattern_walk2_brick(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1,
-                      _RandomAccessIterator2, _Brick);
+_RandomAccessIterator2 __pattern_walk2_brick(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator1,
+    _RandomAccessIterator1,
+    _RandomAccessIterator2,
+    _Brick);
 
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2,
+template <class _Tag,
+          class _ExecutionPolicy,
+          class _ForwardIterator1,
+          class _Size,
+          class _ForwardIterator2,
           class _Brick>
 _ForwardIterator2
 __pattern_walk2_brick_n(_Tag, _ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Brick) noexcept;
 
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator1, class _Size,
-          class _RandomAccessIterator2, class _Brick>
-_RandomAccessIterator2
-__pattern_walk2_brick_n(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator1, _Size,
-                        _RandomAccessIterator2, _Brick);
+template <class _IsVector,
+          class _ExecutionPolicy,
+          class _RandomAccessIterator1,
+          class _Size,
+          class _RandomAccessIterator2,
+          class _Brick>
+_RandomAccessIterator2 __pattern_walk2_brick_n(
+    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2, _Brick);
 
 //------------------------------------------------------------------------
 // walk3 (pseudo)
 //
 // walk3 evaluates f(x,y,z) for (x,y,z) drawn from [first1,last1), [first2,...), [first3,...)
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator3, class _Function>
-_ForwardIterator3 __brick_walk3(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator3, _Function,
-                                /*vector=*/std::false_type) noexcept;
+_ForwardIterator3 __brick_walk3(
+    _ForwardIterator1,
+    _ForwardIterator1,
+    _ForwardIterator2,
+    _ForwardIterator3,
+    _Function,
 
 template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _RandomAccessIterator3, class _Function>
-_RandomAccessIterator3 __brick_walk3(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
-                                     _RandomAccessIterator3, _Function,
-                                     /*vector=*/std::true_type) noexcept;
+_RandomAccessIterator3 __brick_walk3(
+    _RandomAccessIterator1,
+    _RandomAccessIterator1,
+    _RandomAccessIterator2,
+    _RandomAccessIterator3,
+    _Function,
 
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator3,
+template <class _Tag,
+          class _ExecutionPolicy,
+          class _ForwardIterator1,
+          class _ForwardIterator2,
+          class _ForwardIterator3,
           class _Function>
-_ForwardIterator3
-__pattern_walk3(_Tag, _ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator3,
-                _Function) noexcept;
+_ForwardIterator3 __pattern_walk3(
+    _Tag,
+    _ExecutionPolicy&&,
+    _ForwardIterator1,
+    _ForwardIterator1,
+    _ForwardIterator2,
+    _ForwardIterator3,
 
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2,
-          class _RandomAccessIterator3, class _Function>
-_RandomAccessIterator3
-__pattern_walk3(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1,
-                _RandomAccessIterator2, _RandomAccessIterator3, _Function);
+template <class _IsVector,
+          class _ExecutionPolicy,
+          class _RandomAccessIterator1,
+          class _RandomAccessIterator2,
+          class _RandomAccessIterator3,
+          class _Function>
+_RandomAccessIterator3 __pattern_walk3(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator1,
+    _RandomAccessIterator1,
+    _RandomAccessIterator2,
+    _RandomAccessIterator3,
+    _Function);
 
 //------------------------------------------------------------------------
 // equal
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-bool __brick_equal(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate,
+bool __brick_equal(_ForwardIterator1,
+                   _ForwardIterator1,
+                   _ForwardIterator2,
+                   _BinaryPredicate,
                    /* is_vector = */ std::false_type) noexcept;
 
 template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
-bool __brick_equal(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _BinaryPredicate,
+bool __brick_equal(_RandomAccessIterator1,
+                   _RandomAccessIterator1,
+                   _RandomAccessIterator2,
+                   _BinaryPredicate,
                    /* is_vector = */ std::true_type) noexcept;
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-bool
-__pattern_equal(_Tag, _ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
-                _BinaryPredicate) noexcept;
+bool __pattern_equal(
+    _Tag, _ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate) noexcept;
 
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2,
+template <class _IsVector,
+          class _ExecutionPolicy,
+          class _RandomAccessIterator1,
+          class _RandomAccessIterator2,
           class _BinaryPredicate>
-bool
-__pattern_equal(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1,
-                _RandomAccessIterator2, _BinaryPredicate);
+bool __pattern_equal(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator1,
+    _RandomAccessIterator1,
+    _RandomAccessIterator2,
+    _BinaryPredicate);
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-bool __brick_equal(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _BinaryPredicate,
+bool __brick_equal(_ForwardIterator1,
+                   _ForwardIterator1,
+                   _ForwardIterator2,
+                   _ForwardIterator2,
+                   _BinaryPredicate,
                    /* is_vector = */ std::false_type) noexcept;
 
 template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
-bool __brick_equal(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator2,
-                   _BinaryPredicate, /* is_vector = */ std::true_type) noexcept;
+bool __brick_equal(_RandomAccessIterator1,
+                   _RandomAccessIterator1,
+                   _RandomAccessIterator2,
+                   _RandomAccessIterator2,
+                   _BinaryPredicate,
+                   /* is_vector = */ std::true_type) noexcept;
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-bool
-__pattern_equal(_Tag, _ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
-                _BinaryPredicate) noexcept;
+bool __pattern_equal(
+    _Tag,
+    _ExecutionPolicy&&,
+    _ForwardIterator1,
+    _ForwardIterator1,
+    _ForwardIterator2,
+    _ForwardIterator2,
 
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2,
+template <class _IsVector,
+          class _ExecutionPolicy,
+          class _RandomAccessIterator1,
+          class _RandomAccessIterator2,
           class _BinaryPredicate>
-bool
-__pattern_equal(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1,
-                _RandomAccessIterator2, _RandomAccessIterator2, _BinaryPredicate);
+bool __pattern_equal(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator1,
+    _RandomAccessIterator1,
+    _RandomAccessIterator2,
+    _RandomAccessIterator2,
+    _BinaryPredicate);
 
 //------------------------------------------------------------------------
 // find_if
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator, class _Predicate>
-_ForwardIterator __brick_find_if(_ForwardIterator, _ForwardIterator, _Predicate,
-                                 /*is_vector=*/std::false_type) noexcept;
+_ForwardIterator __brick_find_if(
+    _ForwardIterator,
+    _ForwardIterator,
+    _Predicate,
 
 template <class _RandomAccessIterator, class _Predicate>
-_RandomAccessIterator __brick_find_if(_RandomAccessIterator, _RandomAccessIterator, _Predicate,
-                                      /*is_vector=*/std::true_type) noexcept;
+_RandomAccessIterator __brick_find_if(
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _Predicate,
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
-_ForwardIterator
-__pattern_find_if(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate) noexcept;
+_ForwardIterator __pattern_find_if(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Predicate>
-_RandomAccessIterator
-__pattern_find_if(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator,
-                  _Predicate);
+_RandomAccessIterator __pattern_find_if(
+    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Predicate);
 
 //------------------------------------------------------------------------
 // find_end
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_ForwardIterator1 __brick_find_end(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
-                                   _BinaryPredicate,
-                                   /*__is_vector=*/std::false_type) noexcept;
+_ForwardIterator1 __brick_find_end(
+    _ForwardIterator1,
+    _ForwardIterator1,
+    _ForwardIterator2,
+    _ForwardIterator2,
 
 template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
-_RandomAccessIterator1 __brick_find_end(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
-                                        _RandomAccessIterator2, _BinaryPredicate,
-                                        /*__is_vector=*/std::true_type) noexcept;
+_RandomAccessIterator1 __brick_find_end(
+    _RandomAccessIterator1,
+    _RandomAccessIterator1,
+    _RandomAccessIterator2,
+    _RandomAccessIterator2,
+    _BinaryPredicate,
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_ForwardIterator1
-__pattern_find_end(_Tag, _ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
-                   _BinaryPredicate) noexcept;
+_ForwardIterator1 __pattern_find_end(
+    _Tag,
+    _ExecutionPolicy&&,
+    _ForwardIterator1,
+    _ForwardIterator1,
+    _ForwardIterator2,
+    _ForwardIterator2,
 
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2,
+template <class _IsVector,
+          class _ExecutionPolicy,
+          class _RandomAccessIterator1,
+          class _RandomAccessIterator2,
           class _BinaryPredicate>
-_RandomAccessIterator1
-__pattern_find_end(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1,
-                   _RandomAccessIterator2, _RandomAccessIterator2, _BinaryPredicate) noexcept;
+_RandomAccessIterator1 __pattern_find_end(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator1,
+    _RandomAccessIterator1,
+    _RandomAccessIterator2,
+    _RandomAccessIterator2,
+    _BinaryPredicate) noexcept;
 
 //------------------------------------------------------------------------
 // find_first_of
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_ForwardIterator1 __brick_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
-                                        _BinaryPredicate,
-                                        /*__is_vector=*/std::false_type) noexcept;
+_ForwardIterator1 __brick_find_first_of(
+    _ForwardIterator1,
+    _ForwardIterator1,
+    _ForwardIterator2,
+    _ForwardIterator2,
 
 template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
-_RandomAccessIterator1 __brick_find_first_of(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
-                                             _RandomAccessIterator2, _BinaryPredicate,
-                                             /*__is_vector=*/std::true_type) noexcept;
+_RandomAccessIterator1 __brick_find_first_of(
+    _RandomAccessIterator1,
+    _RandomAccessIterator1,
+    _RandomAccessIterator2,
+    _RandomAccessIterator2,
+    _BinaryPredicate,
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_ForwardIterator1
-__pattern_find_first_of(_Tag, _ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
-                        _ForwardIterator2, _BinaryPredicate) noexcept;
+_ForwardIterator1 __pattern_find_first_of(
+    _Tag,
+    _ExecutionPolicy&&,
+    _ForwardIterator1,
+    _ForwardIterator1,
+    _ForwardIterator2,
+    _ForwardIterator2,
+    _BinaryPredicate) noexcept;
 
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2,
+template <class _IsVector,
+          class _ExecutionPolicy,
+          class _RandomAccessIterator1,
+          class _RandomAccessIterator2,
           class _BinaryPredicate>
-_RandomAccessIterator1
-__pattern_find_first_of(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1,
-                        _RandomAccessIterator2, _RandomAccessIterator2, _BinaryPredicate) noexcept;
+_RandomAccessIterator1 __pattern_find_first_of(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator1,
+    _RandomAccessIterator1,
+    _RandomAccessIterator2,
+    _RandomAccessIterator2,
+    _BinaryPredicate) noexcept;
 
 //------------------------------------------------------------------------
 // search
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_ForwardIterator1 __brick_search(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
-                                 _BinaryPredicate,
-                                 /*vector=*/std::false_type) noexcept;
+_ForwardIterator1 __brick_search(
+    _ForwardIterator1,
+    _ForwardIterator1,
+    _ForwardIterator2,
+    _ForwardIterator2,
 
 template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
-_RandomAccessIterator1 __brick_search(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
-                                      _RandomAccessIterator2, _BinaryPredicate,
-                                      /*vector=*/std::true_type) noexcept;
+_RandomAccessIterator1 __brick_search(
+    _RandomAccessIterator1,
+    _RandomAccessIterator1,
+    _RandomAccessIterator2,
+    _RandomAccessIterator2,
+    _BinaryPredicate,
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_ForwardIterator1
-__pattern_search(_Tag, _ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
-                 _BinaryPredicate) noexcept;
+_ForwardIterator1 __pattern_search(
+    _Tag,
+    _ExecutionPolicy&&,
+    _ForwardIterator1,
+    _ForwardIterator1,
+    _ForwardIterator2,
+    _ForwardIterator2,
 
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2,
+template <class _IsVector,
+          class _ExecutionPolicy,
+          class _RandomAccessIterator1,
+          class _RandomAccessIterator2,
           class _BinaryPredicate>
-_RandomAccessIterator1
-__pattern_search(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1,
-                 _RandomAccessIterator2, _RandomAccessIterator2, _BinaryPredicate) noexcept;
+_RandomAccessIterator1 __pattern_search(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator1,
+    _RandomAccessIterator1,
+    _RandomAccessIterator2,
+    _RandomAccessIterator2,
+    _BinaryPredicate) noexcept;
 
 //------------------------------------------------------------------------
 // search_n
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
-_ForwardIterator
-__brick_search_n(_ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate,
-                 /*vector=*/std::false_type) noexcept;
+_ForwardIterator __brick_search_n(
+    _ForwardIterator,
+    _ForwardIterator,
+    _Size,
+    const _Tp&,
+    _BinaryPredicate,
 
 template <class _RandomAccessIterator, class _Size, class _Tp, class _BinaryPredicate>
-_RandomAccessIterator
-__brick_search_n(_RandomAccessIterator, _RandomAccessIterator, _Size, const _Tp&, _BinaryPredicate,
-                 /*vector=*/std::true_type) noexcept;
+_RandomAccessIterator __brick_search_n(
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _Size,
+    const _Tp&,
+    _BinaryPredicate,
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
-_ForwardIterator
-__pattern_search_n(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Size, const _Tp&,
-                   _BinaryPredicate) noexcept;
+_ForwardIterator __pattern_search_n(
+    _Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate) noexcept;
 
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Tp,
+template <class _IsVector,
+          class _ExecutionPolicy,
+          class _RandomAccessIterator,
+          class _Size,
+          class _Tp,
           class _BinaryPredicate>
-_RandomAccessIterator
-__pattern_search_n(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Size,
-                   const _Tp&, _BinaryPredicate) noexcept;
+_RandomAccessIterator __pattern_search_n(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _Size,
+    const _Tp&,
+    _BinaryPredicate) noexcept;
 
 //------------------------------------------------------------------------
 // copy_n
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator, class _Size, class _OutputIterator>
-_OutputIterator __brick_copy_n(_ForwardIterator, _Size, _OutputIterator,
+_OutputIterator __brick_copy_n(_ForwardIterator,
+                               _Size,
+                               _OutputIterator,
                                /*vector=*/std::false_type) noexcept;
 
 template <class _RandomAccessIterator, class _Size, class _OutputIterator>
-_OutputIterator __brick_copy_n(_RandomAccessIterator, _Size, _OutputIterator,
+_OutputIterator __brick_copy_n(_RandomAccessIterator,
+                               _Size,
+                               _OutputIterator,
                                /*vector=*/std::true_type) noexcept;
 
 //------------------------------------------------------------------------
 // copy
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator, class _OutputIterator>
-_OutputIterator __brick_copy(_ForwardIterator, _ForwardIterator, _OutputIterator,
+_OutputIterator __brick_copy(_ForwardIterator,
+                             _ForwardIterator,
+                             _OutputIterator,
                              /*vector=*/std::false_type) noexcept;
 
 template <class _RandomAccessIterator, class _OutputIterator>
-_OutputIterator __brick_copy(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator,
+_OutputIterator __brick_copy(_RandomAccessIterator,
+                             _RandomAccessIterator,
+                             _OutputIterator,
                              /*vector=*/std::true_type) noexcept;
 
 //------------------------------------------------------------------------
 // move
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator, class _OutputIterator>
-_OutputIterator __brick_move(_ForwardIterator, _ForwardIterator, _OutputIterator,
+_OutputIterator __brick_move(_ForwardIterator,
+                             _ForwardIterator,
+                             _OutputIterator,
                              /*vector=*/std::false_type) noexcept;
 
 template <class _RandomAccessIterator, class _OutputIterator>
-_OutputIterator __brick_move(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator,
+_OutputIterator __brick_move(_RandomAccessIterator,
+                             _RandomAccessIterator,
+                             _OutputIterator,
                              /*vector=*/std::true_type) noexcept;
 
 //------------------------------------------------------------------------
 // swap_ranges
 //------------------------------------------------------------------------
 template <class _ForwardIterator, class _OutputIterator>
-_OutputIterator __brick_swap_ranges(_ForwardIterator, _ForwardIterator, _OutputIterator,
-                                    /*vector=*/std::false_type) noexcept;
+_OutputIterator __brick_swap_ranges(
+    _ForwardIterator,
+    _ForwardIterator,
+    _OutputIterator,
 
 template <class _RandomAccessIterator, class _OutputIterator>
-_OutputIterator __brick_swap_ranges(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator,
-                                    /*vector=*/std::true_type) noexcept;
+_OutputIterator __brick_swap_ranges(
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _OutputIterator,
 
 //------------------------------------------------------------------------
 // copy_if
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator, class _OutputIterator, class _UnaryPredicate>
-_OutputIterator __brick_copy_if(_ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate,
-                                /*vector=*/std::false_type) noexcept;
+_OutputIterator __brick_copy_if(
+    _ForwardIterator,
+    _ForwardIterator,
+    _OutputIterator,
+    _UnaryPredicate,
 
 template <class _RandomAccessIterator, class _OutputIterator, class _UnaryPredicate>
-_OutputIterator __brick_copy_if(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _UnaryPredicate,
-                                /*vector=*/std::true_type) noexcept;
+_OutputIterator __brick_copy_if(
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _OutputIterator,
+    _UnaryPredicate,
 
 template <class _DifferenceType, class _ForwardIterator, class _UnaryPredicate>
-std::pair<_DifferenceType, _DifferenceType>
-__brick_calc_mask_1(_ForwardIterator, _ForwardIterator, bool* __restrict, _UnaryPredicate,
-                    /*vector=*/std::false_type) noexcept;
+std::pair<_DifferenceType, _DifferenceType> __brick_calc_mask_1(
+    _ForwardIterator,
+    _ForwardIterator,
+    bool* __restrict,
+    _UnaryPredicate,
 template <class _DifferenceType, class _RandomAccessIterator, class _UnaryPredicate>
-std::pair<_DifferenceType, _DifferenceType>
-__brick_calc_mask_1(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _UnaryPredicate,
-                    /*vector=*/std::true_type) noexcept;
+std::pair<_DifferenceType, _DifferenceType> __brick_calc_mask_1(
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    bool* __restrict,
+    _UnaryPredicate,
 
 template <class _ForwardIterator, class _OutputIterator>
-void
-__brick_copy_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator, bool*,
-                     /*vector=*/std::false_type) noexcept;
+void __brick_copy_by_mask(
+    _ForwardIterator,
+    _ForwardIterator,
+    _OutputIterator,
+    bool*,
 
 template <class _RandomAccessIterator, class _OutputIterator>
-void
-__brick_copy_by_mask(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, bool* __restrict,
-                     /*vector=*/std::true_type) noexcept;
+void __brick_copy_by_mask(
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _OutputIterator,
+    bool* __restrict,
 
 template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2>
-void
-__brick_partition_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2, bool*,
-                          /*vector=*/std::false_type) noexcept;
+void __brick_partition_by_mask(
+    _ForwardIterator,
+    _ForwardIterator,
+    _OutputIterator1,
+    _OutputIterator2,
+    bool*,
 
 template <class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2>
-void
-__brick_partition_by_mask(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator1, _OutputIterator2, bool*,
-                          /*vector=*/std::true_type) noexcept;
+void __brick_partition_by_mask(
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _OutputIterator1,
+    _OutputIterator2,
+    bool*,
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _UnaryPredicate>
-_OutputIterator
-__pattern_copy_if(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator,
-                  _UnaryPredicate) noexcept;
+_OutputIterator __pattern_copy_if(
+    _Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate) noexcept;
 
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator,
+template <class _IsVector,
+          class _ExecutionPolicy,
+          class _RandomAccessIterator,
+          class _OutputIterator,
           class _UnaryPredicate>
-_OutputIterator
-__pattern_copy_if(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator,
-                  _OutputIterator, _UnaryPredicate);
+_OutputIterator __pattern_copy_if(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _OutputIterator,
+    _UnaryPredicate);
 
 //------------------------------------------------------------------------
 // count
 //------------------------------------------------------------------------
 
 template <class _RandomAccessIterator, class _Predicate>
-typename std::iterator_traits<_RandomAccessIterator>::difference_type
-    __brick_count(_RandomAccessIterator, _RandomAccessIterator, _Predicate,
-                  /* is_vector = */ std::true_type) noexcept;
+typename std::iterator_traits<_RandomAccessIterator>::difference_type __brick_count(
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _Predicate,
 
 template <class _ForwardIterator, class _Predicate>
-typename std::iterator_traits<_ForwardIterator>::difference_type
-    __brick_count(_ForwardIterator, _ForwardIterator, _Predicate,
-                  /* is_vector = */ std::false_type) noexcept;
+typename std::iterator_traits<_ForwardIterator>::difference_type __brick_count(
+    _ForwardIterator,
+    _ForwardIterator,
+    _Predicate,
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
 typename std::iterator_traits<_ForwardIterator>::difference_type
 __pattern_count(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Predicate>
-typename std::iterator_traits<_RandomAccessIterator>::difference_type
-__pattern_count(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator,
-                _Predicate);
+typename std::iterator_traits<_RandomAccessIterator>::difference_type __pattern_count(
+    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Predicate);
 
 //------------------------------------------------------------------------
 // unique
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator, class _BinaryPredicate>
-_ForwardIterator __brick_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
-                                /*is_vector=*/std::false_type) noexcept;
+_ForwardIterator __brick_unique(
+    _ForwardIterator,
+    _ForwardIterator,
+    _BinaryPredicate,
 
 template <class _RandomAccessIterator, class _BinaryPredicate>
-_RandomAccessIterator __brick_unique(_RandomAccessIterator, _RandomAccessIterator, _BinaryPredicate,
-                                     /*is_vector=*/std::true_type) noexcept;
+_RandomAccessIterator __brick_unique(
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _BinaryPredicate,
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
 _ForwardIterator
 __pattern_unique(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _BinaryPredicate>
-_RandomAccessIterator
-__pattern_unique(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator,
-                 _BinaryPredicate) noexcept;
+_RandomAccessIterator __pattern_unique(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator,
+    _RandomAccessIterator,
 
 //------------------------------------------------------------------------
 // unique_copy
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator, class OutputIterator, class _BinaryPredicate>
-OutputIterator __brick_unique_copy(_ForwardIterator, _ForwardIterator, OutputIterator, _BinaryPredicate,
-                                   /*vector=*/std::false_type) noexcept;
+OutputIterator __brick_unique_copy(
+    _ForwardIterator,
+    _ForwardIterator,
+    OutputIterator,
+    _BinaryPredicate,
 
 template <class _RandomAccessIterator, class _OutputIterator, class _BinaryPredicate>
-_OutputIterator __brick_unique_copy(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _BinaryPredicate,
-                                    /*vector=*/std::true_type) noexcept;
+_OutputIterator __brick_unique_copy(
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _OutputIterator,
+    _BinaryPredicate,
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _BinaryPredicate>
-_OutputIterator
-__pattern_unique_copy(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator,
-                      _BinaryPredicate) noexcept;
+_OutputIterator __pattern_unique_copy(
+    _Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryPredicate) noexcept;
 
 template <class _ExecutionPolicy, class _DifferenceType, class _RandomAccessIterator, class _BinaryPredicate>
-_DifferenceType
-__brick_calc_mask_2(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _BinaryPredicate,
-                    /*vector=*/std::false_type) noexcept;
+_DifferenceType __brick_calc_mask_2(
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    bool* __restrict,
+    _BinaryPredicate,
 
 template <class _DifferenceType, class _RandomAccessIterator, class _BinaryPredicate>
-_DifferenceType
-__brick_calc_mask_2(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _BinaryPredicate,
-                    /*vector=*/std::true_type) noexcept;
+_DifferenceType __brick_calc_mask_2(
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    bool* __restrict,
+    _BinaryPredicate,
 
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator,
+template <class _IsVector,
+          class _ExecutionPolicy,
+          class _RandomAccessIterator,
+          class _OutputIterator,
           class _BinaryPredicate>
-_OutputIterator
-__pattern_unique_copy(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator,
-                      _OutputIterator, _BinaryPredicate);
+_OutputIterator __pattern_unique_copy(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _OutputIterator,
+    _BinaryPredicate);
 
 //------------------------------------------------------------------------
 // reverse
 //------------------------------------------------------------------------
 
 template <class _BidirectionalIterator>
-void __brick_reverse(_BidirectionalIterator, _BidirectionalIterator,
+void __brick_reverse(_BidirectionalIterator,
+                     _BidirectionalIterator,
                      /*__is_vector=*/std::false_type) noexcept;
 
 template <class _RandomAccessIterator>
-void __brick_reverse(_RandomAccessIterator, _RandomAccessIterator,
+void __brick_reverse(_RandomAccessIterator,
+                     _RandomAccessIterator,
                      /*__is_vector=*/std::true_type) noexcept;
 
 template <class _BidirectionalIterator>
-void __brick_reverse(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator,
+void __brick_reverse(_BidirectionalIterator,
+                     _BidirectionalIterator,
+                     _BidirectionalIterator,
                      /*is_vector=*/std::false_type) noexcept;
 
 template <class _RandomAccessIterator>
-void __brick_reverse(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator,
+void __brick_reverse(_RandomAccessIterator,
+                     _RandomAccessIterator,
+                     _RandomAccessIterator,
                      /*is_vector=*/std::true_type) noexcept;
 
 template <class _Tag, class _ExecutionPolicy, class _BidirectionalIterator>
-void
-__pattern_reverse(_Tag, _ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator) noexcept;
+void __pattern_reverse(_Tag, _ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator>
-void
-__pattern_reverse(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator);
+void __pattern_reverse(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator);
 
 //------------------------------------------------------------------------
 // reverse_copy
 //------------------------------------------------------------------------
 
 template <class _BidirectionalIterator, class _OutputIterator>
-_OutputIterator __brick_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator,
-                                     /*is_vector=*/std::false_type) noexcept;
+_OutputIterator __brick_reverse_copy(
+    _BidirectionalIterator,
+    _BidirectionalIterator,
+    _OutputIterator,
 
 template <class _RandomAccessIterator, class _OutputIterator>
-_OutputIterator __brick_reverse_copy(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator,
-                                     /*is_vector=*/std::true_type) noexcept;
+_OutputIterator __brick_reverse_copy(
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _OutputIterator,
 
 template <class _Tag, class _ExecutionPolicy, class _BidirectionalIterator, class _OutputIterator>
-_OutputIterator
-__pattern_reverse_copy(_Tag, _ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator,
-                       _OutputIterator) noexcept;
+_OutputIterator __pattern_reverse_copy(
+    _Tag, _ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _OutputIterator) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator>
-_OutputIterator
-__pattern_reverse_copy(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator,
-                       _OutputIterator);
+_OutputIterator __pattern_reverse_copy(
+    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator);
 
 //------------------------------------------------------------------------
 // rotate
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator>
-_ForwardIterator __brick_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator,
-                                /*is_vector=*/std::false_type) noexcept;
+_ForwardIterator __brick_rotate(
+    _ForwardIterator,
+    _ForwardIterator,
+    _ForwardIterator,
 
 template <class _RandomAccessIterator>
-_RandomAccessIterator __brick_rotate(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator,
-                                     /*is_vector=*/std::true_type) noexcept;
+_RandomAccessIterator __brick_rotate(
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _RandomAccessIterator,
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator>
 _ForwardIterator
 __pattern_rotate(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator>
-_RandomAccessIterator
-__pattern_rotate(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator,
-                 _RandomAccessIterator);
+_RandomAccessIterator __pattern_rotate(
+    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator);
 
 //------------------------------------------------------------------------
 // rotate_copy
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator, class _OutputIterator>
-_OutputIterator __brick_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator,
-                                    /*__is_vector=*/std::false_type) noexcept;
+_OutputIterator __brick_rotate_copy(
+    _ForwardIterator,
+    _ForwardIterator,
+    _ForwardIterator,
+    _OutputIterator,
 
 template <class _RandomAccessIterator, class _OutputIterator>
-_OutputIterator __brick_rotate_copy(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator,
-                                    _OutputIterator,
-                                    /*__is_vector=*/std::true_type) noexcept;
+_OutputIterator __brick_rotate_copy(
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _RandomAccessIterator,
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator>
-_OutputIterator
-__pattern_rotate_copy(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator,
-                      _OutputIterator) noexcept;
+_OutputIterator __pattern_rotate_copy(
+    _Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator>
-_OutputIterator
-__pattern_rotate_copy(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator,
-                      _RandomAccessIterator, _OutputIterator);
+_OutputIterator __pattern_rotate_copy(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _OutputIterator);
 
 //------------------------------------------------------------------------
 // is_partitioned
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator, class _UnaryPredicate>
-bool __brick_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
+bool __brick_is_partitioned(_ForwardIterator,
+                            _ForwardIterator,
+                            _UnaryPredicate,
                             /*is_vector=*/std::false_type) noexcept;
 
 template <class _RandomAccessIterator, class _UnaryPredicate>
-bool __brick_is_partitioned(_RandomAccessIterator, _RandomAccessIterator, _UnaryPredicate,
+bool __brick_is_partitioned(_RandomAccessIterator,
+                            _RandomAccessIterator,
+                            _UnaryPredicate,
                             /*is_vector=*/std::true_type) noexcept;
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
-bool
-__pattern_is_partitioned(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate) noexcept;
+bool __pattern_is_partitioned(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _UnaryPredicate>
-bool
-__pattern_is_partitioned(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator,
-                         _UnaryPredicate);
+bool __pattern_is_partitioned(
+    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _UnaryPredicate);
 
 //------------------------------------------------------------------------
 // partition
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator, class _UnaryPredicate>
-_ForwardIterator __brick_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
-                                   /*is_vector=*/std::false_type) noexcept;
+_ForwardIterator __brick_partition(
+    _ForwardIterator,
+    _ForwardIterator,
+    _UnaryPredicate,
 
 template <class _RandomAccessIterator, class _UnaryPredicate>
-_RandomAccessIterator __brick_partition(_RandomAccessIterator, _RandomAccessIterator, _UnaryPredicate,
-                                        /*is_vector=*/std::true_type) noexcept;
+_RandomAccessIterator __brick_partition(
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _UnaryPredicate,
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
 _ForwardIterator
 __pattern_partition(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _UnaryPredicate>
-_RandomAccessIterator
-__pattern_partition(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator,
-                    _UnaryPredicate);
+_RandomAccessIterator __pattern_partition(
+    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _UnaryPredicate);
 
 //------------------------------------------------------------------------
 // stable_partition
 //------------------------------------------------------------------------
 
 template <class _BidirectionalIterator, class _UnaryPredicate>
-_BidirectionalIterator __brick_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
-                                                /*__is_vector=*/std::false_type) noexcept;
+_BidirectionalIterator __brick_stable_partition(
+    _BidirectionalIterator,
+    _BidirectionalIterator,
+    _UnaryPredicate,
 
 template <class _RandomAccessIterator, class _UnaryPredicate>
-_RandomAccessIterator __brick_stable_partition(_RandomAccessIterator, _RandomAccessIterator, _UnaryPredicate,
-                                               /*__is_vector=*/std::true_type) noexcept;
+_RandomAccessIterator __brick_stable_partition(
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _UnaryPredicate,
 
 template <class _Tag, class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate>
-_BidirectionalIterator
-__pattern_stable_partition(_Tag, _ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator,
-                           _UnaryPredicate) noexcept;
+_BidirectionalIterator __pattern_stable_partition(
+    _Tag, _ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _UnaryPredicate>
-_RandomAccessIterator
-__pattern_stable_partition(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator,
-                           _UnaryPredicate) noexcept;
+_RandomAccessIterator __pattern_stable_partition(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator,
+    _RandomAccessIterator,
 
 //------------------------------------------------------------------------
 // partition_copy
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate>
-std::pair<_OutputIterator1, _OutputIterator2>
-    __brick_partition_copy(_ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2, _UnaryPredicate,
-                           /*is_vector=*/std::false_type) noexcept;
+std::pair<_OutputIterator1, _OutputIterator2> __brick_partition_copy(
+    _ForwardIterator,
+    _ForwardIterator,
+    _OutputIterator1,
+    _OutputIterator2,
+    _UnaryPredicate,
 
 template <class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate>
-std::pair<_OutputIterator1, _OutputIterator2> __brick_partition_copy(_RandomAccessIterator, _RandomAccessIterator,
-                                                                     _OutputIterator1, _OutputIterator2,
-                                                                     _UnaryPredicate,
-                                                                     /*is_vector=*/std::true_type) noexcept;
+std::pair<_OutputIterator1, _OutputIterator2> __brick_partition_copy(
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _OutputIterator1,
+    _OutputIterator2,
 
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator1, class _OutputIterator2,
+template <class _Tag,
+          class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _OutputIterator1,
+          class _OutputIterator2,
+          class _UnaryPredicate>
+std::pair<_OutputIterator1, _OutputIterator2> __pattern_partition_copy(
+    _Tag,
+    _ExecutionPolicy&&,
+    _ForwardIterator,
+    _ForwardIterator,
+    _OutputIterator1,
+    _OutputIterator2,
+    _UnaryPredicate) noexcept;
+
+template <class _IsVector,
+          class _ExecutionPolicy,
+          class _RandomAccessIterator,
+          class _OutputIterator1,
+          class _OutputIterator2,
           class _UnaryPredicate>
-std::pair<_OutputIterator1, _OutputIterator2>
-__pattern_partition_copy(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator1,
-                         _OutputIterator2, _UnaryPredicate) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator1,
-          class _OutputIterator2, class _UnaryPredicate>
-std::pair<_OutputIterator1, _OutputIterator2>
-__pattern_partition_copy(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator,
-                         _OutputIterator1, _OutputIterator2, _UnaryPredicate);
+std::pair<_OutputIterator1, _OutputIterator2> __pattern_partition_copy(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _OutputIterator1,
+    _OutputIterator2,
+    _UnaryPredicate);
 
 //------------------------------------------------------------------------
 // sort
 //------------------------------------------------------------------------
 
 template <class _Tag, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsMoveConstructible>
-void
-__pattern_sort(_Tag, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare,
-               _IsMoveConstructible) noexcept;
+void __pattern_sort(
+    _Tag, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsMoveConstructible) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-void
-__pattern_sort(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare,
+void __pattern_sort(__parallel_tag<_IsVector>,
+                    _ExecutionPolicy&&,
+                    _RandomAccessIterator,
+                    _RandomAccessIterator,
+                    _Compare,
                     /*is_move_constructible=*/std::true_type);
 
 //------------------------------------------------------------------------
 // stable_sort
 //------------------------------------------------------------------------
 
 template <class _Tag, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-void
-__pattern_stable_sort(_Tag, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare) noexcept;
+void __pattern_stable_sort(_Tag, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-void
-__pattern_stable_sort(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator,
-                      _Compare);
+void __pattern_stable_sort(
+    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare);
 
 //------------------------------------------------------------------------
 // partial_sort
 //------------------------------------------------------------------------
 
 template <class _Tag, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-void
-__pattern_partial_sort(_Tag, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator,
-                       _Compare) noexcept;
+void __pattern_partial_sort(
+    _Tag, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-void
-__pattern_partial_sort(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator,
-                       _RandomAccessIterator, _Compare);
+void __pattern_partial_sort(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _Compare);
 
 //------------------------------------------------------------------------
 // partial_sort_copy
 //------------------------------------------------------------------------
 
-template <class _Tag, class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2,
+template <class _Tag,
+          class _ExecutionPolicy,
+          class _RandomAccessIterator1,
+          class _RandomAccessIterator2,
           class _Compare>
-_RandomAccessIterator2
-__pattern_partial_sort_copy(_Tag, _ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1,
-                            _RandomAccessIterator2, _RandomAccessIterator2, _Compare) noexcept;
+_RandomAccessIterator2 __pattern_partial_sort_copy(
+    _Tag,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator1,
+    _RandomAccessIterator1,
+    _RandomAccessIterator2,
+    _RandomAccessIterator2,
+    _Compare) noexcept;
 
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2,
+template <class _IsVector,
+          class _ExecutionPolicy,
+          class _RandomAccessIterator1,
+          class _RandomAccessIterator2,
           class _Compare>
-_RandomAccessIterator2
-__pattern_partial_sort_copy(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator1,
-                            _RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator2, _Compare);
+_RandomAccessIterator2 __pattern_partial_sort_copy(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator1,
+    _RandomAccessIterator1,
+    _RandomAccessIterator2,
+    _RandomAccessIterator2,
+    _Compare);
 
 //------------------------------------------------------------------------
 // adjacent_find
 //------------------------------------------------------------------------
 
 template <class _RandomAccessIterator, class _BinaryPredicate>
-_RandomAccessIterator
-__brick_adjacent_find(_RandomAccessIterator, _RandomAccessIterator, _BinaryPredicate,
-                      /* IsVector = */ std::true_type, bool) noexcept;
+_RandomAccessIterator __brick_adjacent_find(
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _BinaryPredicate,
+    /* IsVector = */ std::true_type,
+    bool) noexcept;
 
 template <class _ForwardIterator, class _BinaryPredicate>
-_ForwardIterator
-__brick_adjacent_find(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
-                      /* IsVector = */ std::false_type, bool) noexcept;
+_ForwardIterator __brick_adjacent_find(
+    _ForwardIterator,
+    _ForwardIterator,
+    _BinaryPredicate,
+    /* IsVector = */ std::false_type,
+    bool) noexcept;
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
 _ForwardIterator
 __pattern_adjacent_find(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, bool) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _BinaryPredicate>
-_RandomAccessIterator
-__pattern_adjacent_find(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator,
-                        _BinaryPredicate, bool);
+_RandomAccessIterator __pattern_adjacent_find(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _BinaryPredicate,
+    bool);
 
 //------------------------------------------------------------------------
 // nth_element
 //------------------------------------------------------------------------
 template <class _Tag, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-void
-__pattern_nth_element(_Tag, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator,
-                      _Compare) noexcept;
+void __pattern_nth_element(
+    _Tag, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-void
-__pattern_nth_element(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator,
-                      _RandomAccessIterator, _Compare) noexcept;
+void __pattern_nth_element(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _Compare) noexcept;
 
 //------------------------------------------------------------------------
 // fill, fill_n
 //------------------------------------------------------------------------
 template <class _RandomAccessIterator, class _Tp>
-void
-__brick_fill(_RandomAccessIterator, _RandomAccessIterator, const _Tp&,
+void __brick_fill(_RandomAccessIterator,
+                  _RandomAccessIterator,
+                  const _Tp&,
                   /* __is_vector = */ std::true_type) noexcept;
 
 template <class _ForwardIterator, class _Tp>
-void
-__brick_fill(_ForwardIterator, _ForwardIterator, const _Tp&,
+void __brick_fill(_ForwardIterator,
+                  _ForwardIterator,
+                  const _Tp&,
                   /* __is_vector = */ std::false_type) noexcept;
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-void
-__pattern_fill(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&) noexcept;
+void __pattern_fill(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Tp>
 _RandomAccessIterator
 __pattern_fill(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, const _Tp&);
 
 template <class _RandomAccessIterator, class _Size, class _Tp>
 _RandomAccessIterator
-__brick_fill_n(_RandomAccessIterator, _Size, const _Tp&,
+__brick_fill_n(_RandomAccessIterator,
+               _Size,
+               const _Tp&,
                /* __is_vector = */ std::true_type) noexcept;
 
 template <class _OutputIterator, class _Size, class _Tp>
 _OutputIterator
-__brick_fill_n(_OutputIterator, _Size, const _Tp&,
+__brick_fill_n(_OutputIterator,
+               _Size,
+               const _Tp&,
                /* __is_vector = */ std::false_type) noexcept;
 
 template <class _Tag, class _ExecutionPolicy, class _OutputIterator, class _Size, class _Tp>
-_OutputIterator
-__pattern_fill_n(_Tag, _ExecutionPolicy&&, _OutputIterator, _Size, const _Tp&) noexcept;
+_OutputIterator __pattern_fill_n(_Tag, _ExecutionPolicy&&, _OutputIterator, _Size, const _Tp&) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Tp>
 _RandomAccessIterator
 __pattern_fill_n(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _Size, const _Tp&);
 
 //------------------------------------------------------------------------
 // generate, generate_n
 //------------------------------------------------------------------------
 
 template <class _RandomAccessIterator, class _Generator>
-void __brick_generate(_RandomAccessIterator, _RandomAccessIterator, _Generator,
+void __brick_generate(_RandomAccessIterator,
+                      _RandomAccessIterator,
+                      _Generator,
                       /* is_vector = */ std::true_type) noexcept;
 
 template <class _ForwardIterator, class _Generator>
-void __brick_generate(_ForwardIterator, _ForwardIterator, _Generator,
+void __brick_generate(_ForwardIterator,
+                      _ForwardIterator,
+                      _Generator,
                       /* is_vector = */ std::false_type) noexcept;
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Generator>
-void
-__pattern_generate(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Generator) noexcept;
+void __pattern_generate(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Generator) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Generator>
-_RandomAccessIterator
-__pattern_generate(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator,
-                   _Generator);
+_RandomAccessIterator __pattern_generate(
+    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Generator);
 
 template <class _RandomAccessIterator, class Size, class _Generator>
-_RandomAccessIterator __brick_generate_n(_RandomAccessIterator, Size, _Generator,
-                                         /* is_vector = */ std::true_type) noexcept;
+_RandomAccessIterator __brick_generate_n(
+    _RandomAccessIterator,
+    Size,
+    _Generator,
 
 template <class OutputIterator, class Size, class _Generator>
-OutputIterator __brick_generate_n(OutputIterator, Size, _Generator,
-                                  /* is_vector = */ std::false_type) noexcept;
+OutputIterator __brick_generate_n(
+    OutputIterator,
+    Size,
+    _Generator,
 
 template <class _Tag, class _ExecutionPolicy, class OutputIterator, class Size, class _Generator>
-OutputIterator
-__pattern_generate_n(_Tag, _ExecutionPolicy&&, OutputIterator, Size, _Generator) noexcept;
+OutputIterator __pattern_generate_n(_Tag, _ExecutionPolicy&&, OutputIterator, Size, _Generator) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class Size, class _Generator>
 _RandomAccessIterator
 __pattern_generate_n(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, Size, _Generator);
 
 //------------------------------------------------------------------------
 // remove
 //------------------------------------------------------------------------
 template <class _ForwardIterator, class _UnaryPredicate>
-_ForwardIterator __brick_remove_if(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
-                                   /* __is_vector = */ std::false_type) noexcept;
+_ForwardIterator __brick_remove_if(
+    _ForwardIterator,
+    _ForwardIterator,
+    _UnaryPredicate,
 
 template <class _RandomAccessIterator, class _UnaryPredicate>
-_RandomAccessIterator __brick_remove_if(_RandomAccessIterator, _RandomAccessIterator, _UnaryPredicate,
-                                        /* __is_vector = */ std::true_type) noexcept;
+_RandomAccessIterator __brick_remove_if(
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _UnaryPredicate,
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
 _ForwardIterator
 __pattern_remove_if(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _UnaryPredicate>
-_RandomAccessIterator
-__pattern_remove_if(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator,
-                    _UnaryPredicate) noexcept;
+_RandomAccessIterator __pattern_remove_if(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator,
+    _RandomAccessIterator,
 
 //------------------------------------------------------------------------
 // merge
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
-_OutputIterator __brick_merge(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
-                              _OutputIterator, _Compare,
-                              /* __is_vector = */ std::false_type) noexcept;
+_OutputIterator __brick_merge(
+    _ForwardIterator1,
+    _ForwardIterator1,
+    _ForwardIterator2,
+    _ForwardIterator2,
+    _OutputIterator,
+    _Compare,
 
 template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator, class _Compare>
-_OutputIterator __brick_merge(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
-                              _RandomAccessIterator2, _OutputIterator, _Compare,
-                              /* __is_vector = */ std::true_type) noexcept;
+_OutputIterator __brick_merge(
+    _RandomAccessIterator1,
+    _RandomAccessIterator1,
+    _RandomAccessIterator2,
+    _RandomAccessIterator2,
+    _OutputIterator,
+    _Compare,
 
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
+template <class _Tag,
+          class _ExecutionPolicy,
+          class _ForwardIterator1,
+          class _ForwardIterator2,
+          class _OutputIterator,
           class _Compare>
-_OutputIterator
-__pattern_merge(_Tag, _ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
-                _OutputIterator, _Compare) noexcept;
+_OutputIterator __pattern_merge(
+    _Tag,
+    _ExecutionPolicy&&,
+    _ForwardIterator1,
+    _ForwardIterator1,
+    _ForwardIterator2,
+    _ForwardIterator2,
+    _OutputIterator,
+    _Compare) noexcept;
 
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2,
-          class _OutputIterator, class _Compare>
-_OutputIterator
-__pattern_merge(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1,
-                _RandomAccessIterator2, _RandomAccessIterator2, _OutputIterator, _Compare);
+template <class _IsVector,
+          class _ExecutionPolicy,
+          class _RandomAccessIterator1,
+          class _RandomAccessIterator2,
+          class _OutputIterator,
+          class _Compare>
+_OutputIterator __pattern_merge(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator1,
+    _RandomAccessIterator1,
+    _RandomAccessIterator2,
+    _RandomAccessIterator2,
+    _OutputIterator,
+    _Compare);
 
 //------------------------------------------------------------------------
 // inplace_merge
 //------------------------------------------------------------------------
 
 template <class _BidirectionalIterator, class _Compare>
-void __brick_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare,
-                           /* __is_vector = */ std::false_type) noexcept;
+void __brick_inplace_merge(
+    _BidirectionalIterator,
+    _BidirectionalIterator,
+    _BidirectionalIterator,
+    _Compare,
 
 template <class _RandomAccessIterator, class _Compare>
-void __brick_inplace_merge(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare,
-                           /* __is_vector = */ std::true_type) noexcept;
+void __brick_inplace_merge(
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _Compare,
 
 template <class _Tag, class _ExecutionPolicy, class _BidirectionalIterator, class _Compare>
-void
-__pattern_inplace_merge(_Tag, _ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator,
-                        _BidirectionalIterator, _Compare) noexcept;
+void __pattern_inplace_merge(
+    _Tag,
+    _ExecutionPolicy&&,
+    _BidirectionalIterator,
+    _BidirectionalIterator,
+    _BidirectionalIterator,
+    _Compare) noexcept;
 
 template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-void
-__pattern_inplace_merge(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator,
-                        _RandomAccessIterator, _Compare);
+void __pattern_inplace_merge(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _RandomAccessIterator,
+    _Compare);
 
 //------------------------------------------------------------------------
 // includes
 //------------------------------------------------------------------------
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare>
-bool
-__pattern_includes(_Tag, _ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
-                   _Compare) noexcept;
+bool __pattern_includes(
+    _Tag,
+    _ExecutionPolicy&&,
+    _ForwardIterator1,
+    _ForwardIterator1,
+    _ForwardIterator2,
+    _ForwardIterator2,
 
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2,
+template <class _IsVector,
+          class _ExecutionPolicy,
+          class _RandomAccessIterator1,
+          class _RandomAccessIterator2,
           class _Compare>
-bool
-__pattern_includes(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1,
-                   _RandomAccessIterator2, _RandomAccessIterator2, _Compare);
+bool __pattern_includes(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator1,
+    _RandomAccessIterator1,
+    _RandomAccessIterator2,
+    _RandomAccessIterator2,
+    _Compare);
 
 //------------------------------------------------------------------------
 // set_union
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
-_OutputIterator __brick_set_union(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
-                                  _OutputIterator, _Compare,
-                                  /*__is_vector=*/std::false_type) noexcept;
+_OutputIterator __brick_set_union(
+    _ForwardIterator1,
+    _ForwardIterator1,
+    _ForwardIterator2,
+    _ForwardIterator2,
+    _OutputIterator,
+    _Compare,
 
 template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator, class _Compare>
-_OutputIterator __brick_set_union(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
-                                  _RandomAccessIterator2, _OutputIterator, _Compare,
-                                  /*__is_vector=*/std::true_type) noexcept;
+_OutputIterator __brick_set_union(
+    _RandomAccessIterator1,
+    _RandomAccessIterator1,
+    _RandomAccessIterator2,
+    _RandomAccessIterator2,
+    _OutputIterator,
+    _Compare,
 
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
+template <class _Tag,
+          class _ExecutionPolicy,
+          class _ForwardIterator1,
+          class _ForwardIterator2,
+          class _OutputIterator,
           class _Compare>
-_OutputIterator
-__pattern_set_union(_Tag, _ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
-                    _ForwardIterator2, _OutputIterator, _Compare) noexcept;
+_OutputIterator __pattern_set_union(
+    _Tag,
+    _ExecutionPolicy&&,
+    _ForwardIterator1,
+    _ForwardIterator1,
+    _ForwardIterator2,
+    _ForwardIterator2,
+    _OutputIterator,
+    _Compare) noexcept;
 
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2,
-          class _OutputIterator, class _Compare>
-_OutputIterator
-__pattern_set_union(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1,
-                    _RandomAccessIterator2, _RandomAccessIterator2, _OutputIterator, _Compare);
+template <class _IsVector,
+          class _ExecutionPolicy,
+          class _RandomAccessIterator1,
+          class _RandomAccessIterator2,
+          class _OutputIterator,
+          class _Compare>
+_OutputIterator __pattern_set_union(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator1,
+    _RandomAccessIterator1,
+    _RandomAccessIterator2,
+    _RandomAccessIterator2,
+    _OutputIterator,
+    _Compare);
 
 //------------------------------------------------------------------------
 // set_intersection
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
-_OutputIterator __brick_set_intersection(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
-                                         _OutputIterator, _Compare,
-                                         /*__is_vector=*/std::false_type) noexcept;
+_OutputIterator __brick_set_intersection(
+    _ForwardIterator1,
+    _ForwardIterator1,
+    _ForwardIterator2,
+    _ForwardIterator2,
+    _OutputIterator,
+    _Compare,
 
 template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator, class _Compare>
-_OutputIterator __brick_set_intersection(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
-                                         _RandomAccessIterator2, _OutputIterator, _Compare,
-                                         /*__is_vector=*/std::true_type) noexcept;
+_OutputIterator __brick_set_intersection(
+    _RandomAccessIterator1,
+    _RandomAccessIterator1,
+    _RandomAccessIterator2,
+    _RandomAccessIterator2,
+    _OutputIterator,
+    _Compare,
 
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
+template <class _Tag,
+          class _ExecutionPolicy,
+          class _ForwardIterator1,
+          class _ForwardIterator2,
+          class _OutputIterator,
           class _Compare>
-_OutputIterator
-__pattern_set_intersection(_Tag, _ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
-                           _ForwardIterator2, _OutputIterator, _Compare) noexcept;
+_OutputIterator __pattern_set_intersection(
+    _Tag,
+    _ExecutionPolicy&&,
+    _ForwardIterator1,
+    _ForwardIterator1,
+    _ForwardIterator2,
+    _ForwardIterator2,
+    _OutputIterator,
+    _Compare) noexcept;
 
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2,
-          class _OutputIterator, class _Compare>
-_OutputIterator
-__pattern_set_intersection(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator1,
-                           _RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator2, _OutputIterator,
-                           _Compare);
+template <class _IsVector,
+          class _ExecutionPolicy,
+          class _RandomAccessIterator1,
+          class _RandomAccessIterator2,
+          class _OutputIterator,
+          class _Compare>
+_OutputIterator __pattern_set_intersection(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator1,
+    _RandomAccessIterator1,
+    _RandomAccessIterator2,
+    _RandomAccessIterator2,
+    _OutputIterator,
 
 //------------------------------------------------------------------------
 // set_difference
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
-_OutputIterator __brick_set_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
-                                       _OutputIterator, _Compare,
-                                       /*__is_vector=*/std::false_type) noexcept;
+_OutputIterator __brick_set_difference(
+    _ForwardIterator1,
+    _ForwardIterator1,
+    _ForwardIterator2,
+    _ForwardIterator2,
+    _OutputIterator,
+    _Compare,
 
 template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator, class _Compare>
-_OutputIterator __brick_set_difference(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
-                                       _RandomAccessIterator2, _OutputIterator, _Compare,
-                                       /*__is_vector=*/std::true_type) noexcept;
+_OutputIterator __brick_set_difference(
+    _RandomAccessIterator1,
+    _RandomAccessIterator1,
+    _RandomAccessIterator2,
+    _RandomAccessIterator2,
+    _OutputIterator,
+    _Compare,
 
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
+template <class _Tag,
+          class _ExecutionPolicy,
+          class _ForwardIterator1,
+          class _ForwardIterator2,
+          class _OutputIterator,
           class _Compare>
-_OutputIterator
-__pattern_set_difference(_Tag, _ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
-                         _ForwardIterator2, _OutputIterator, _Compare) noexcept;
+_OutputIterator __pattern_set_difference(
+    _Tag,
+    _ExecutionPolicy&&,
+    _ForwardIterator1,
+    _ForwardIterator1,
+    _ForwardIterator2,
+    _ForwardIterator2,
+    _OutputIterator,
+    _Compare) noexcept;
 
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2,
-          class _OutputIterator, class _Compare>
-_OutputIterator
-__pattern_set_difference(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1,
-                         _RandomAccessIterator2, _RandomAccessIterator2, _OutputIterator, _Compare);
+template <class _IsVector,
+          class _ExecutionPolicy,
+          class _RandomAccessIterator1,
+          class _RandomAccessIterator2,
+          class _OutputIterator,
+          class _Compare>
+_OutputIterator __pattern_set_difference(
+    __parallel_tag<_IsVector>,
+    _ExecutionPolicy&&,
+    _RandomAccessIterator1,
+    _RandomAccessIterator1,
+    _RandomAccessIterator2,
+    _RandomAccessIterator2,
+    _OutputIterator,
+    _Compare);
 
 //------------------------------------------------------------------------
 // set_symmetric_difference
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
-_OutputIterator __brick_set_symmetric_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
-                                                 _ForwardIterator2, _OutputIterator, _Compare,
-                                                 /*__is_vector=*/std::false_type) noexcept;
+_OutputIterator __brick_set_symmetric_difference(
+    _ForwardIterator1,
+    _ForwardIterator1,
+    _ForwardIterator2,
+    _ForwardIterator2,
+    _OutputIterator,
+    _Compare,
 
 template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator, class _Compare>
-_OutputIterator __brick_set_symmetric_difference(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
+_OutputIterator