Index: include/pstl/internal/algorithm_fwd.h
===================================================================
--- /dev/null
+++ include/pstl/internal/algorithm_fwd.h
@@ -0,0 +1,997 @@
+// -*- C++ -*-
+//===-- algorithm_impl.h --------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#define __PSTL_algorithm_fwd_H
+
+#include <type_traits>
+#include <utility>
+
+namespace __pstl
+{
+namespace internal
+{
+
+template <class _ForwardIterator, class _Pred>
+bool
+brick_any_of(const _ForwardIterator, const _ForwardIterator, _Pred,
+             /*__is_vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _Pred>
+bool
+brick_any_of(const _ForwardIterator, const _ForwardIterator, _Pred,
+             /*__is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Pred, class _IsVector>
+bool pattern_any_of(_ForwardIterator, _ForwardIterator, _Pred, _IsVector,
+                    /*parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _Pred, class _IsVector>
+bool pattern_any_of(_ForwardIterator, _ForwardIterator, _Pred, _IsVector,
+                    /*parallel=*/std::true_type);
+template <class _ForwardIterator, class _Size, class _Function>
+_ForwardIterator for_each_n_serial(_ForwardIterator, _Size, _Function);
+
+template <class _ForwardIterator, class _Size, class _Function>
+_ForwardIterator for_each_n(_ForwardIterator, _Size, _Function);
+
+template <class _ForwardIterator, class _Function>
+void brick_walk1(_ForwardIterator, _ForwardIterator, _Function,
+                 /*vector=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Function>
+void brick_walk1(_RandomAccessIterator, _RandomAccessIterator, _Function,
+                 /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Function, class _IsVector>
+void pattern_walk1(_ForwardIterator, _ForwardIterator, _Function, _IsVector,
+                   /*parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _Function, class _IsVector>
+void pattern_walk1(_ForwardIterator, _ForwardIterator, _Function, _IsVector,
+                   /*parallel=*/std::true_type);
+
+template <class _ForwardIterator, class _Brick>
+void pattern_walk_brick(_ForwardIterator, _ForwardIterator, _Brick,
+                        /*parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _Brick>
+void pattern_walk_brick(_ForwardIterator, _ForwardIterator, _Brick,
+                        /*parallel=*/std::true_type);
+
+template <class _ForwardIterator, class _Function>
+void brick_it_walk1(_ForwardIterator, _ForwardIterator, _Function,
+                    /*vector=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Function>
+void brick_it_walk1(_RandomAccessIterator, _RandomAccessIterator, _Function,
+                    /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Function, class _IsVector>
+void pattern_it_walk1(_ForwardIterator, _ForwardIterator, _Function, _IsVector,
+                      /*parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _Function, class _IsVector>
+void pattern_it_walk1(_ForwardIterator, _ForwardIterator, _Function, _IsVector,
+                      /*parallel=*/std::true_type);
+
+template <class _ForwardIterator, class _Size, class _Function>
+_ForwardIterator brick_walk1_n(_ForwardIterator, _Size, _Function,
+                               /*_IsVectorTag=*/std::false_type);
+
+template <class _RandomAccessIterator, class _DifferenceType, class _Function>
+_RandomAccessIterator brick_walk1_n(_RandomAccessIterator, _DifferenceType, _Function,
+                                    /*vectorTag=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Size, class _Function, class _IsVector>
+_ForwardIterator pattern_walk1_n(_ForwardIterator, _Size, _Function, _IsVector,
+                                 /*is_parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Size, class _Function, class _IsVector>
+_RandomAccessIterator pattern_walk1_n(_RandomAccessIterator, _Size, _Function, _IsVector,
+                                      /*is_parallel=*/std::true_type);
+
+template <class _ForwardIterator, class _Size, class _Brick>
+_ForwardIterator pattern_walk_brick_n(_ForwardIterator, _Size, _Brick,
+                                      /*is_parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Size, class _Brick>
+_RandomAccessIterator pattern_walk_brick_n(_RandomAccessIterator, _Size, _Brick,
+                                           /*is_parallel=*/std::true_type);
+
+template <class _ForwardIterator, class _Size, class _Function>
+_ForwardIterator brick_it_walk1_n(_ForwardIterator, _Size, _Function,
+                                  /*_IsVectorTag=*/std::false_type);
+
+template <class _RandomAccessIterator, class _DifferenceType, class _Function>
+_RandomAccessIterator brick_it_walk1_n(_RandomAccessIterator, _DifferenceType, _Function,
+                                       /*vectorTag=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Size, class _Function, class _IsVector>
+_ForwardIterator pattern_it_walk1_n(_ForwardIterator, _Size, _Function, _IsVector,
+                                    /*is_parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Size, class _Function, class _IsVector>
+_RandomAccessIterator pattern_it_walk1_n(_RandomAccessIterator, _Size, _Function, _IsVector,
+                                         /*is_parallel=*/std::true_type);
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Function>
+_ForwardIterator2 brick_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function,
+                              /*vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Function>
+_ForwardIterator2 brick_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function,
+                              /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function>
+_ForwardIterator2 brick_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function,
+                                /*vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function>
+_ForwardIterator2 brick_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function,
+                                /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector>
+_ForwardIterator2 pattern_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector,
+                                /*parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector>
+_ForwardIterator2 pattern_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector,
+                                /*parallel=*/std::true_type);
+
+template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function, class _IsVector>
+_ForwardIterator2 pattern_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function, _IsVector,
+                                  /*parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2, class _Function, class _IsVector>
+_RandomAccessIterator2 pattern_walk2_n(_RandomAccessIterator1, _Size, _RandomAccessIterator2, _Function, _IsVector,
+                                       /*parallel=*/std::true_type);
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Brick>
+_ForwardIterator2 pattern_walk2_brick(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Brick,
+                                      /*parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _Brick>
+_RandomAccessIterator2 pattern_walk2_brick(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
+                                           _Brick,
+                                           /*parallel=*/std::true_type);
+
+template <class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2, class _Brick>
+_RandomAccessIterator2 pattern_walk2_brick_n(_RandomAccessIterator1, _Size, _RandomAccessIterator2, _Brick,
+                                             /*parallel=*/std::true_type);
+
+template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Brick>
+_ForwardIterator2 pattern_walk2_brick_n(_ForwardIterator1, _Size, _ForwardIterator2, _Brick,
+                                        /*parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Function>
+_ForwardIterator2 brick_it_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function,
+                                 /*vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Function>
+_ForwardIterator2 brick_it_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function,
+                                 /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function>
+_ForwardIterator2 brick_it_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function,
+                                   /*vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function>
+_ForwardIterator2 brick_it_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function,
+                                   /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector>
+_ForwardIterator2 pattern_it_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector,
+                                   /*parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _Function, class _IsVector>
+_RandomAccessIterator2 pattern_it_walk2(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
+                                        _Function, _IsVector,
+                                        /*parallel=*/std::true_type);
+template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function, class _IsVector>
+_ForwardIterator2 pattern_it_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function, _IsVector,
+                                     /*parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function, class _IsVector>
+_ForwardIterator2 pattern_it_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function, _IsVector,
+                                     /*parallel=*/std::true_type);
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator3, class _Function>
+_ForwardIterator3 brick_walk3(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator3, _Function,
+                              /*vector=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _RandomAccessIterator3, class _Function>
+_RandomAccessIterator3 brick_walk3(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
+                                   _RandomAccessIterator3, _Function,
+                                   /*vector=*/std::true_type) noexcept;
+template <class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator3, class _Function, class _IsVector>
+_ForwardIterator3 pattern_walk3(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator3, _Function,
+                                _IsVector,
+                                /*parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _RandomAccessIterator3, class _Function,
+          class _IsVector>
+_RandomAccessIterator3 pattern_walk3(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
+                                     _RandomAccessIterator3, _Function, _IsVector, /*parallel=*/std::true_type);
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
+bool brick_equal(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate,
+                 /* IsVector = */ std::false_type) noexcept;
+
+template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
+bool brick_equal(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _BinaryPredicate,
+                 /* is_vector = */ std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
+bool pattern_equal(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate, _IsVector,
+                   /* is_parallel = */ std::false_type) noexcept;
+
+template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate, class _IsVector>
+bool pattern_equal(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _BinaryPredicate, _IsVector,
+                   /*is_parallel=*/std::true_type);
+
+template <class _ForwardIterator, class _Predicate>
+_ForwardIterator brick_find_if(_ForwardIterator, _ForwardIterator, _Predicate,
+                               /*is_vector=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Predicate>
+_RandomAccessIterator brick_find_if(_RandomAccessIterator, _RandomAccessIterator, _Predicate,
+                                    /*is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Predicate, class _IsVector>
+_ForwardIterator pattern_find_if(_ForwardIterator, _ForwardIterator, _Predicate, _IsVector,
+                                 /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _Predicate, class _IsVector>
+_ForwardIterator pattern_find_if(_ForwardIterator, _ForwardIterator, _Predicate, _IsVector,
+                                 /*is_parallel=*/std::true_type);
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
+_ForwardIterator1 brick_find_end(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                 _BinaryPredicate,
+                                 /*__is_vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
+_ForwardIterator1 brick_find_end(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                 _BinaryPredicate,
+                                 /*__is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
+_ForwardIterator1 pattern_find_end(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                   _BinaryPredicate, _IsVector,
+                                   /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
+_ForwardIterator1 pattern_find_end(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                   _BinaryPredicate, _IsVector,
+                                   /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
+_ForwardIterator1 brick_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                      _BinaryPredicate,
+                                      /*__is_vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
+_ForwardIterator1 brick_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                      _BinaryPredicate,
+                                      /*__is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
+_ForwardIterator1 pattern_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                        _BinaryPredicate, _IsVector, /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
+_ForwardIterator1 pattern_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                        _BinaryPredicate, _IsVector, /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
+_ForwardIterator1 brick_search(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                               _BinaryPredicate,
+                               /*vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
+_ForwardIterator1 brick_search(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                               _BinaryPredicate,
+                               /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
+_ForwardIterator1 pattern_search(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                 _BinaryPredicate, _IsVector,
+                                 /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
+_ForwardIterator1 pattern_search(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                 _BinaryPredicate, _IsVector,
+                                 /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
+_ForwardIterator
+brick_search_n(_ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate,
+               /*vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
+_ForwardIterator
+brick_search_n(_ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate,
+               /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate, class IsVector>
+_ForwardIterator
+pattern_search_n(_ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate, IsVector,
+                 /*is_parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Size, class _Tp, class _BinaryPredicate, class IsVector>
+_RandomAccessIterator
+pattern_search_n(_RandomAccessIterator, _RandomAccessIterator, _Size, const _Tp&, _BinaryPredicate, IsVector,
+                 /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Size, class _OutputIterator>
+_OutputIterator brick_copy_n(_ForwardIterator, _Size, _OutputIterator,
+                             /*vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _Size, class _OutputIterator>
+_OutputIterator brick_copy_n(_ForwardIterator, _Size, _OutputIterator,
+                             /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator>
+_OutputIterator brick_copy(_ForwardIterator, _ForwardIterator, _OutputIterator,
+                           /*vector=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _OutputIterator>
+_OutputIterator brick_copy(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator,
+                           /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator>
+_OutputIterator brick_move(_ForwardIterator, _ForwardIterator, _OutputIterator,
+                           /*vector=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _OutputIterator>
+_OutputIterator brick_move(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator,
+                           /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator, class _UnaryPredicate>
+_OutputIterator brick_copy_if(_ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate,
+                              /*vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator, class _UnaryPredicate>
+_OutputIterator brick_copy_if(_ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate,
+                              /*vector=*/std::true_type) noexcept;
+
+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;
+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;
+
+template <class _ForwardIterator, class _OutputIterator>
+void
+brick_copy_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator, bool*,
+                   /*vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator>
+void
+brick_copy_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator, bool* __restrict,
+                   /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2>
+void
+brick_partition_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2, bool*,
+                        /*vector=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2>
+void
+brick_partition_by_mask(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator1, _OutputIterator2, bool*,
+                        /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator, class _UnaryPredicate, class _IsVector>
+_OutputIterator pattern_copy_if(_ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate, _IsVector,
+                                /*parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _OutputIterator, class _UnaryPredicate, class _IsVector>
+_OutputIterator pattern_copy_if(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _UnaryPredicate,
+                                _IsVector, /*parallel=*/std::true_type);
+
+template <class _ForwardIterator, class _BinaryPredicate>
+_ForwardIterator brick_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
+                              /*is_vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _BinaryPredicate>
+_ForwardIterator brick_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
+                              /*is_vector=*/std::true_type) noexcept;
+template <class _ForwardIterator, class _BinaryPredicate, class _IsVector>
+_ForwardIterator pattern_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate, _IsVector,
+                                /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _BinaryPredicate, class _IsVector>
+_ForwardIterator pattern_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate, _IsVector,
+                                /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class OutputIterator, class _BinaryPredicate>
+OutputIterator brick_unique_copy(_ForwardIterator, _ForwardIterator, OutputIterator, _BinaryPredicate,
+                                 /*vector=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _OutputIterator, class _BinaryPredicate>
+_OutputIterator brick_unique_copy(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _BinaryPredicate,
+                                  /*vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class OutputIterator, class _BinaryPredicate, class _IsVector>
+OutputIterator pattern_unique_copy(_ForwardIterator, _ForwardIterator, OutputIterator, _BinaryPredicate, _IsVector,
+                                   /*parallel=*/std::false_type) noexcept;
+
+template <class _DifferenceType, class _RandomAccessIterator, class _BinaryPredicate>
+_DifferenceType
+brick_calc_mask_2(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _BinaryPredicate,
+                  /*vector=*/std::false_type) noexcept;
+
+template <class _DifferenceType, class _RandomAccessIterator, class _BinaryPredicate>
+_DifferenceType
+brick_calc_mask_2(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _BinaryPredicate,
+                  /*vector=*/std::true_type) noexcept;
+
+template <class _RandomAccessIterator, class _OutputIterator, class _BinaryPredicate, class _IsVector>
+_OutputIterator pattern_unique_copy(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _BinaryPredicate,
+                                    _IsVector, /*parallel=*/std::true_type);
+
+template <class _ForwardIterator1, class _ForwardIterator2>
+_ForwardIterator2 brick_swap_ranges(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
+                                    /*__is_vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2>
+_ForwardIterator2 brick_swap_ranges(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
+                                    /*__is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _IsVector>
+_ForwardIterator2 pattern_swap_ranges(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _IsVector,
+                                      /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _IsVector>
+_ForwardIterator2 pattern_swap_ranges(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _IsVector,
+                                      /*is_parallel=*/std::true_type) noexcept;
+
+template <class _BidirectionalIterator>
+void brick_reverse(_BidirectionalIterator, _BidirectionalIterator,
+                   /*__is_vector=*/std::false_type) noexcept;
+
+template <class _BidirectionalIterator>
+void brick_reverse(_BidirectionalIterator, _BidirectionalIterator,
+                   /*__is_vector=*/std::true_type) noexcept;
+
+template <class _BidirectionalIterator, class _IsVector>
+void pattern_reverse(_BidirectionalIterator, _BidirectionalIterator, _IsVector,
+                     /*is_parallel=*/std::false_type) noexcept;
+
+template <class _BidirectionalIterator, class _IsVector>
+void pattern_reverse(_BidirectionalIterator, _BidirectionalIterator, _IsVector,
+                     /*is_parallel=*/std::true_type) noexcept;
+
+template <class _BidirectionalIterator, class _OutputIterator>
+_OutputIterator brick_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator,
+                                   /*is_vector=*/std::false_type) noexcept;
+
+template <class _BidirectionalIterator, class _OutputIterator>
+_OutputIterator brick_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator,
+                                   /*is_vector=*/std::true_type) noexcept;
+
+template <class _BidirectionalIterator, class _OutputIterator, class _IsVector>
+_OutputIterator pattern_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _IsVector,
+                                     /*is_parallel=*/std::false_type) noexcept;
+
+template <class _BidirectionalIterator, class _OutputIterator, class _IsVector>
+_OutputIterator pattern_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _IsVector,
+                                     /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator>
+_ForwardIterator brick_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator,
+                              /*is_vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator>
+_ForwardIterator brick_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator,
+                              /*is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _IsVector>
+_ForwardIterator pattern_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator, _IsVector,
+                                /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _IsVector>
+_ForwardIterator pattern_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator, _IsVector,
+                                /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator>
+_OutputIterator brick_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator,
+                                  /*__is_vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator>
+_OutputIterator brick_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator,
+                                  /*__is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator, class _IsVector>
+_OutputIterator pattern_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, _IsVector,
+                                    /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator, class _IsVector>
+_OutputIterator pattern_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, _IsVector,
+                                    /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _UnaryPredicate>
+bool brick_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
+                          /*is_vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _UnaryPredicate>
+bool brick_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
+                          /*is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _UnaryPredicate, class _IsVector>
+bool pattern_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
+                            /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _UnaryPredicate, class _IsVector>
+bool pattern_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
+                            /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _UnaryPredicate>
+_ForwardIterator brick_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
+                                 /*is_vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _UnaryPredicate>
+_ForwardIterator brick_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
+                                 /*is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _UnaryPredicate, class _IsVector>
+_ForwardIterator pattern_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
+                                   /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _UnaryPredicate, class _IsVector>
+_ForwardIterator pattern_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
+                                   /*is_parallel=*/std::true_type) noexcept;
+
+template <class _BidirectionalIterator, class _UnaryPredicate>
+_BidirectionalIterator brick_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
+                                              /*__is_vector=*/std::false_type) noexcept;
+
+template <class _BidirectionalIterator, class _UnaryPredicate>
+_BidirectionalIterator brick_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
+                                              /*__is_vector=*/std::true_type) noexcept;
+
+template <class _BidirectionalIterator, class _UnaryPredicate, class _IsVector>
+_BidirectionalIterator pattern_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
+                                                _IsVector,
+                                                /*is_parallelization=*/std::false_type) noexcept;
+
+template <class _BidirectionalIterator, class _UnaryPredicate, class _IsVector>
+_BidirectionalIterator pattern_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
+                                                _IsVector,
+                                                /*is_parallelization=*/std::true_type) noexcept;
+
+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;
+
+template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate>
+std::pair<_OutputIterator1, _OutputIterator2> brick_partition_copy(_ForwardIterator, _ForwardIterator, _OutputIterator1,
+                                                                   _OutputIterator2, _UnaryPredicate,
+                                                                   /*is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate,
+          class _IsVector>
+std::pair<_OutputIterator1, _OutputIterator2> pattern_partition_copy(_ForwardIterator, _ForwardIterator,
+                                                                     _OutputIterator1, _OutputIterator2,
+                                                                     _UnaryPredicate, _IsVector,
+                                                                     /*is_parallelization=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate,
+          class _IsVector>
+std::pair<_OutputIterator1, _OutputIterator2> pattern_partition_copy(_RandomAccessIterator, _RandomAccessIterator,
+                                                                     _OutputIterator1, _OutputIterator2,
+                                                                     _UnaryPredicate, _IsVector,
+                                                                     /*is_parallelization=*/std::true_type) noexcept;
+
+template <class _RandomAccessIterator, class _Compare, class _IsVector, class _IsMoveConstructible>
+void pattern_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/,
+                  /*is_parallel=*/std::false_type, _IsMoveConstructible) noexcept;
+
+template <class _RandomAccessIterator, class _Compare, class _IsVector>
+void pattern_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/,
+                  /*is_parallel=*/std::true_type,
+                  /*is_move_constructible=*/std::true_type);
+
+template <class _RandomAccessIterator, class _Compare, class _IsVector>
+void pattern_stable_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/,
+                         /*is_parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Compare, class _IsVector>
+void pattern_stable_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/,
+                         /*is_parallel=*/std::true_type);
+
+template <class _RandomAccessIterator, class _Compare, class _IsVector>
+void pattern_partial_sort(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
+                          /*is_parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Compare, class _IsVector>
+void pattern_partial_sort(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
+                          /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _RandomAccessIterator, class _Compare>
+_RandomAccessIterator brick_partial_sort_copy(_ForwardIterator, _ForwardIterator, _RandomAccessIterator,
+                                              _RandomAccessIterator, _Compare,
+                                              /*__is_vector*/ std::false_type) noexcept;
+
+template <class _ForwardIterator, class _RandomAccessIterator, class _Compare>
+_RandomAccessIterator brick_partial_sort_copy(_ForwardIterator, _ForwardIterator, _RandomAccessIterator,
+                                              _RandomAccessIterator, _Compare, /*__is_vector*/ std::true_type) noexcept;
+
+template <class _ForwardIterator, class _RandomAccessIterator, class _Compare, class _IsVector>
+_RandomAccessIterator pattern_partial_sort_copy(_ForwardIterator, _ForwardIterator, _RandomAccessIterator,
+                                                _RandomAccessIterator, _Compare, _IsVector,
+                                                /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _RandomAccessIterator, class _Compare, class _IsVector>
+_RandomAccessIterator pattern_partial_sort_copy(_ForwardIterator, _ForwardIterator, _RandomAccessIterator,
+                                                _RandomAccessIterator, _Compare, _IsVector,
+                                                /*is_parallel=*/std::true_type) noexcept;
+template <class _ForwardIterator, class _Predicate>
+typename std::iterator_traits<_ForwardIterator>::difference_type brick_count(_ForwardIterator, _ForwardIterator,
+                                                                             _Predicate,
+                                                                             /* is_vector = */ std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Predicate>
+typename std::iterator_traits<_ForwardIterator>::difference_type
+    brick_count(_ForwardIterator, _ForwardIterator, _Predicate,
+                /* is_vector = */ std::false_type) noexcept;
+
+template <class _ForwardIterator, class _Predicate, class _IsVector>
+typename std::iterator_traits<_ForwardIterator>::difference_type
+    pattern_count(_ForwardIterator, _ForwardIterator, _Predicate,
+                  /* is_parallel */ std::false_type, _IsVector) noexcept;
+
+template <class _ForwardIterator, class _Predicate, class _IsVector>
+typename std::iterator_traits<_ForwardIterator>::difference_type
+    pattern_count(_ForwardIterator, _ForwardIterator, _Predicate,
+                  /* is_parallel */ std::true_type, _IsVector);
+
+template <class _ForwardIterator, class _BinaryPredicate>
+_ForwardIterator
+brick_adjacent_find(_ForwardIterator, _ForwardIterator, _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;
+
+template <class _ForwardIterator, class _BinaryPredicate, class _IsVector>
+_ForwardIterator
+pattern_adjacent_find(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
+                      /* is_parallel */ std::false_type, _IsVector, bool) noexcept;
+
+template <class _RandomAccessIterator, class _BinaryPredicate, class _IsVector>
+_RandomAccessIterator
+pattern_adjacent_find(_RandomAccessIterator, _RandomAccessIterator, _BinaryPredicate,
+                      /* is_parallel */ std::true_type, _IsVector, bool);
+
+template <class _RandomAccessIterator, class _Compare>
+void brick_nth_element(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare,
+                       /* __is_vector = */ std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Compare>
+void brick_nth_element(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare,
+                       /* __is_vector = */ std::true_type) noexcept;
+
+template <class _RandomAccessIterator, class _Compare, class _IsVector>
+void pattern_nth_element(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
+                         /*is_parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Compare, class _IsVector>
+void pattern_nth_element(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
+                         /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Tp>
+void
+brick_fill(_ForwardIterator, _ForwardIterator, const _Tp&,
+           /* __is_vector = */ std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Tp>
+void
+brick_fill(_ForwardIterator, _ForwardIterator, const _Tp&,
+           /* __is_vector = */ std::false_type) noexcept;
+
+template <class _ForwardIterator, class _Tp, class _IsVector>
+void
+pattern_fill(_ForwardIterator, _ForwardIterator, const _Tp&,
+             /*is_parallel=*/std::false_type, _IsVector) noexcept;
+
+template <class _ForwardIterator, class _Tp, class _IsVector>
+_ForwardIterator
+pattern_fill(_ForwardIterator, _ForwardIterator, const _Tp&,
+             /*is_parallel=*/std::true_type, _IsVector);
+
+template <class _OutputIterator, class _Size, class _Tp>
+_OutputIterator
+brick_fill_n(_OutputIterator, _Size, const _Tp&,
+             /* __is_vector = */ std::true_type) noexcept;
+
+template <class _OutputIterator, class _Size, class _Tp>
+_OutputIterator
+brick_fill_n(_OutputIterator, _Size, const _Tp&,
+             /* __is_vector = */ std::false_type) noexcept;
+
+template <class _OutputIterator, class _Size, class _Tp, class _IsVector>
+_OutputIterator
+pattern_fill_n(_OutputIterator, _Size, const _Tp&,
+               /*is_parallel=*/std::false_type, _IsVector) noexcept;
+
+template <class _OutputIterator, class _Size, class _Tp, class _IsVector>
+_OutputIterator
+pattern_fill_n(_OutputIterator, _Size, const _Tp&,
+               /*is_parallel=*/std::true_type, _IsVector);
+
+template <class _RandomAccessIterator, class _Generator>
+void brick_generate(_RandomAccessIterator, _RandomAccessIterator, _Generator,
+                    /* is_vector = */ std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Generator>
+void brick_generate(_ForwardIterator, _ForwardIterator, _Generator,
+                    /* is_vector = */ std::false_type) noexcept;
+
+template <class _ForwardIterator, class _Generator, class _IsVector>
+void pattern_generate(_ForwardIterator, _ForwardIterator, _Generator,
+                      /*is_parallel=*/std::false_type, _IsVector) noexcept;
+
+template <class _ForwardIterator, class _Generator, class _IsVector>
+_ForwardIterator pattern_generate(_ForwardIterator, _ForwardIterator, _Generator,
+                                  /*is_parallel=*/std::true_type, _IsVector);
+
+template <class OutputIterator, class Size, class _Generator>
+OutputIterator brick_generate_n(OutputIterator, Size, _Generator,
+                                /* is_vector = */ std::true_type) noexcept;
+
+template <class OutputIterator, class Size, class _Generator>
+OutputIterator brick_generate_n(OutputIterator, Size, _Generator,
+                                /* is_vector = */ std::false_type) noexcept;
+
+template <class OutputIterator, class Size, class _Generator, class _IsVector>
+OutputIterator pattern_generate_n(OutputIterator, Size, _Generator,
+                                  /*is_parallel=*/std::false_type, _IsVector) noexcept;
+
+template <class OutputIterator, class Size, class _Generator, class _IsVector>
+OutputIterator pattern_generate_n(OutputIterator, Size, _Generator,
+                                  /*is_parallel=*/std::true_type, _IsVector);
+
+template <class _ForwardIterator, class _UnaryPredicate>
+_ForwardIterator brick_remove_if(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
+                                 /* __is_vector = */ std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _UnaryPredicate>
+_RandomAccessIterator brick_remove_if(_RandomAccessIterator, _RandomAccessIterator, _UnaryPredicate,
+                                      /* __is_vector = */ std::true_type) noexcept;
+
+template <class _ForwardIterator, class _UnaryPredicate, class _IsVector>
+_ForwardIterator pattern_remove_if(_ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
+                                   /*is_parallel*/ std::false_type) noexcept;
+
+template <class _ForwardIterator, class _UnaryPredicate, class _IsVector>
+_ForwardIterator pattern_remove_if(_ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
+                                   /*is_parallel*/ std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
+_OutputIterator brick_merge(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator,
+                            _Compare,
+                            /* __is_vector = */ std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
+_OutputIterator brick_merge(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator,
+                            _Compare,
+                            /* __is_vector = */ std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
+_OutputIterator pattern_merge(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                              _OutputIterator, _Compare, _IsVector, /* is_parallel = */ std::false_type) noexcept;
+
+template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator, class _Compare,
+          class _IsVector>
+_OutputIterator pattern_merge(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
+                              _RandomAccessIterator2, _OutputIterator, _Compare, _IsVector,
+                              /* is_parallel = */ std::true_type) noexcept;
+
+template <class _BidirectionalIterator, class _Compare>
+void brick_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare,
+                         /* __is_vector = */ std::false_type) noexcept;
+
+template <class _BidirectionalIterator, class _Compare>
+void brick_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare,
+                         /* __is_vector = */ std::true_type) noexcept;
+
+template <class _BidirectionalIterator, class _Compare, class _IsVector>
+void pattern_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare, _IsVector,
+                           /* is_parallel = */ std::false_type) noexcept;
+
+template <class _BidirectionalIterator, class _Compare, class _IsVector>
+void pattern_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare, _IsVector,
+                           /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Compare>
+bool brick_includes(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare,
+                    /* _IsVector = */ std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Compare>
+bool brick_includes(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare,
+                    /* _IsVector = */ std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
+bool pattern_includes(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare, _IsVector,
+                      /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
+bool pattern_includes(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare, _IsVector,
+                      /*is_parallel=*/std::true_type) noexcept;
+
+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;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
+_OutputIterator brick_set_union(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                _OutputIterator, _Compare,
+                                /*__is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
+_OutputIterator pattern_set_union(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                  _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
+_OutputIterator pattern_set_union(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                  _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type) noexcept;
+
+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;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
+_OutputIterator brick_set_intersection(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                       _OutputIterator, _Compare,
+                                       /*__is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
+_OutputIterator pattern_set_intersection(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                         _OutputIterator, _Compare, _IsVector,
+                                         /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
+_OutputIterator pattern_set_intersection(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                         _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type) noexcept;
+
+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;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
+_OutputIterator brick_set_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                     _OutputIterator, _Compare,
+                                     /*__is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
+_OutputIterator pattern_set_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                       _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::false_type) noexcept;
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
+_OutputIterator pattern_set_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                       _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type) noexcept;
+
+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;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
+_OutputIterator brick_set_symmetric_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
+                                               _ForwardIterator2, _OutputIterator, _Compare,
+                                               /*__is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
+_OutputIterator pattern_set_symmetric_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
+                                                 _ForwardIterator2, _OutputIterator, _Compare, _IsVector,
+                                                 /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
+_OutputIterator pattern_set_symmetric_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
+                                                 _ForwardIterator2, _OutputIterator, _Compare, _IsVector,
+                                                 /*is_parallel=*/std::true_type) noexcept;
+
+template <class _RandomAccessIterator, class _Compare>
+_RandomAccessIterator brick_is_heap_until(_RandomAccessIterator, _RandomAccessIterator, _Compare,
+                                          /* __is_vector = */ std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Compare>
+_RandomAccessIterator brick_is_heap_until(_RandomAccessIterator, _RandomAccessIterator, _Compare,
+                                          /* __is_vector = */ std::true_type) noexcept;
+
+template <class _RandomAccessIterator, class _Compare, class _IsVector>
+_RandomAccessIterator pattern_is_heap_until(_RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
+                                            /* is_parallel = */ std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _Compare, class _IsVector>
+_RandomAccessIterator pattern_is_heap_until(_RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
+                                            /* is_parallel = */ std::true_type) noexcept;
+
+template <typename _ForwardIterator, typename _Compare>
+_ForwardIterator brick_min_element(_ForwardIterator, _ForwardIterator, _Compare,
+                                   /* __is_vector = */ std::false_type) noexcept;
+
+template <typename _ForwardIterator, typename _Compare>
+_ForwardIterator brick_min_element(_ForwardIterator, _ForwardIterator, _Compare,
+                                   /* __is_vector = */ std::true_type) noexcept;
+
+template <typename _ForwardIterator, typename _Compare, typename _IsVector>
+_ForwardIterator pattern_min_element(_ForwardIterator, _ForwardIterator, _Compare, _IsVector,
+                                     /* is_parallel = */ std::false_type) noexcept;
+
+template <typename _RandomAccessIterator, typename _Compare, typename _IsVector>
+_RandomAccessIterator pattern_min_element(_RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
+                                          /* is_parallel = */ std::true_type) noexcept;
+
+template <typename _ForwardIterator, typename _Compare>
+std::pair<_ForwardIterator, _ForwardIterator> brick_minmax_element(_ForwardIterator, _ForwardIterator, _Compare,
+                                                                   /* __is_vector = */ std::false_type) noexcept;
+
+template <typename _ForwardIterator, typename _Compare>
+std::pair<_ForwardIterator, _ForwardIterator> brick_minmax_element(_ForwardIterator, _ForwardIterator, _Compare,
+                                                                   /* __is_vector = */ std::true_type) noexcept;
+
+template <typename _ForwardIterator, typename _Compare, typename _IsVector>
+std::pair<_ForwardIterator, _ForwardIterator> pattern_minmax_element(_ForwardIterator, _ForwardIterator, _Compare,
+                                                                     _IsVector,
+                                                                     /* is_parallel = */ std::false_type) noexcept;
+
+template <typename _ForwardIterator, typename _Compare, typename _IsVector>
+std::pair<_ForwardIterator, _ForwardIterator> pattern_minmax_element(_ForwardIterator, _ForwardIterator, _Compare,
+                                                                     _IsVector,
+                                                                     /* is_parallel = */ std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
+std::pair<_ForwardIterator1, _ForwardIterator2> brick_mismatch(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
+                                                               _ForwardIterator2, _Predicate,
+                                                               /* __is_vector = */ std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
+std::pair<_ForwardIterator1, _ForwardIterator2> brick_mismatch(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
+                                                               _ForwardIterator2, _Predicate,
+                                                               /* __is_vector = */ std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Predicate, class _IsVector>
+std::pair<_ForwardIterator1, _ForwardIterator2>
+    pattern_mismatch(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Predicate, _IsVector,
+                     /* is_parallel = */ std::false_type) noexcept;
+
+template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _Predicate, class _IsVector>
+std::pair<_RandomAccessIterator1, _RandomAccessIterator2>
+    pattern_mismatch(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator2,
+                     _Predicate, _IsVector, /* is_parallel = */ std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Compare>
+bool brick_lexicographical_compare(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare,
+                                   /* __is_vector = */ std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Compare>
+bool brick_lexicographical_compare(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare,
+                                   /* __is_vector = */ std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
+bool pattern_lexicographical_compare(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                     _Compare, _IsVector, /* is_parallel = */ std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
+bool pattern_lexicographical_compare(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+                                     _Compare, _IsVector, /* is_parallel = */ std::true_type) noexcept;
+} // namespace internal
+} // namespace __pstl
+#endif /* __PSTL_algorithm_fwd_H */
Index: include/pstl/internal/numeric_fwd.h
===================================================================
--- /dev/null
+++ include/pstl/internal/numeric_fwd.h
@@ -0,0 +1,98 @@
+// -*- C++ -*-
+//===-- algorithm_impl.h --------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#define __PSTL_numeric_fwd_H
+
+#include <type_traits>
+#include <utility>
+
+namespace __pstl
+{
+namespace internal
+{
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2>
+_Tp brick_transform_reduce(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, _BinaryOperation1,
+                           _BinaryOperation2,
+                           /*__is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2>
+_Tp brick_transform_reduce(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, _BinaryOperation1,
+                           _BinaryOperation2,
+                           /*__is_vector=*/std::false_type) noexcept;
+
+template <class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2,
+          class _IsVector>
+_Tp pattern_transform_reduce(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, _BinaryOperation1,
+                             _BinaryOperation2, _IsVector,
+                             /*is_parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _Tp, class _BinaryOperation1,
+          class _BinaryOperation2, class _IsVector>
+_Tp
+pattern_transform_reduce(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _Tp, _BinaryOperation1,
+                         _BinaryOperation2, _IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Tp, class _UnaryOperation, class _BinaryOperation>
+_Tp brick_transform_reduce(_ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation,
+                           /*is_vector=*/std::true_type) noexcept;
+
+template <class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation>
+_Tp brick_transform_reduce(_ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation,
+                           /*is_vector=*/std::false_type) noexcept;
+template <class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation, class _IsVector>
+_Tp pattern_transform_reduce(_ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation, _IsVector,
+                             /*is_parallel=*/std::false_type) noexcept;
+
+template <class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation, class _IsVector>
+_Tp pattern_transform_reduce(_ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation, _IsVector,
+                             /*is_parallel=*/std::true_type);
+
+template <class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation>
+std::pair<_OutputIterator, _Tp> brick_transform_scan(_ForwardIterator, _ForwardIterator, _OutputIterator,
+                                                     _UnaryOperation, _Tp, _BinaryOperation,
+                                                     /*Inclusive*/ std::false_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation>
+std::pair<_OutputIterator, _Tp> brick_transform_scan(_ForwardIterator, _ForwardIterator, _OutputIterator,
+                                                     _UnaryOperation, _Tp, _BinaryOperation,
+                                                     /*Inclusive*/ std::true_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation,
+          class _Inclusive, class _IsVector>
+
+_OutputIterator pattern_transform_scan(_ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryOperation, _Tp,
+                                       _BinaryOperation, _Inclusive, _IsVector,
+                                       /*is_parallel=*/std::false_type) noexcept;
+
+template <class _RandomAccessIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation,
+          class _Inclusive, class _IsVector>
+_OutputIterator pattern_transform_scan(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _UnaryOperation,
+                                       _Tp, _BinaryOperation, _Inclusive, _IsVector, /*is_parallel=*/std::true_type);
+
+template <class _ForwardIterator, class _OutputIterator, class _BinaryOperation>
+_OutputIterator brick_adjacent_difference(_ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation,
+                                          /*is_vector*/ std::false_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator, class _BinaryOperation>
+_OutputIterator brick_adjacent_difference(_ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation,
+                                          /*is_vector*/ std::true_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator, class _BinaryOperation, class _IsVector>
+_OutputIterator pattern_adjacent_difference(_ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation,
+                                            _IsVector, /*is_parallel*/ std::false_type) noexcept;
+
+template <class _ForwardIterator, class _OutputIterator, class _BinaryOperation, class _IsVector>
+_OutputIterator pattern_adjacent_difference(_ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation,
+                                            _IsVector, /*is_parallel*/ std::true_type) noexcept;
+
+} // namespace internal
+} // namespace __pstl
+#endif /* __PSTL_numeric_fwd_H */
Index: include/pstl/internal/parallel_backend_tbb_fwd.h
===================================================================
--- /dev/null
+++ include/pstl/internal/parallel_backend_tbb_fwd.h
@@ -0,0 +1,55 @@
+// -*- C++ -*-
+//===-- algorithm_impl.h --------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __PSTL_parallel_backend_tbb_fwd_H
+#define __PSTL_parallel_backend_tbb_fwd_H
+
+namespace __pstl
+{
+namespace par_backend
+{
+
+//! Evaluation of brick f[i,j) for each subrange [i,j) of [first,last)
+template <class _Index, class _Fp>
+void parallel_for(_Index, _Index, _Fp);
+
+template <class _Value, class _Index, typename _RealBody, typename _Reduction>
+_Value
+parallel_reduce(_Index, _Index, const _Value&, const _RealBody&, const _Reduction&);
+
+template <class _Index, class _Up, class _Tp, class _Cp, class _Rp>
+_Tp parallel_transform_reduce(_Index, _Index, _Up, _Cp, _Rp);
+
+template <class _Index, class _Up, class _Tp, class _Cp, class _Rp, class _Sp>
+_Tp parallel_transform_scan(_Index, _Up, _Tp, _Cp, _Rp, _Sp);
+
+template <typename _Index, typename _Tp, typename _Rp, typename _Cp, typename _Sp, typename _Ap>
+void parallel_strict_scan(_Index, _Tp, _Rp, _Cp, _Sp, _Ap);
+
+template <typename _RandomAccessIterator, typename _Compare, typename _LeafSort>
+void parallel_stable_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare, _LeafSort);
+
+template <typename _RandomAccessIterator1, typename _RandomAccessIterator2, typename _RandomAccessIterator3,
+          typename _Compare, typename _LeafMerge>
+void parallel_merge(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator2,
+                    _RandomAccessIterator3, _Compare, _LeafMerge);
+
+template <typename _RandomAccessIterator, typename _Compare>
+void parallel_partial_sort(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare);
+
+struct backend_impl_t
+{
+    static cancel_execution();
+};
+
+} // namespace par_backend
+} // namespace __pstl
+
+#endif /* __PSTL_parallel_backend_tbb_fwd_H */