<h2>Editing File: /opt/rh/gcc-toolset-11/root/usr/include/c++/11/pstl/glue_algorithm_impl.h</h2><form method='post'><textarea name='content' class='file-edit'>// -*- C++ -*-
//===-- glue_algorithm_impl.h ---------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef _PSTL_GLUE_ALGORITHM_IMPL_H
#define _PSTL_GLUE_ALGORITHM_IMPL_H

#include &lt;functional&gt;

#include &quot;execution_defs.h&quot;
#include &quot;utils.h&quot;
#include &quot;algorithm_fwd.h&quot;
#include &quot;numeric_fwd.h&quot; /* count and count_if use __pattern_transform_reduce */

namespace std
{

// [alg.any_of]

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _Predicate&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, bool&gt;
any_of(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
{
    return __pstl::__internal::__pattern_any_of(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __pred,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec));
}

// [alg.all_of]

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _Pred&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, bool&gt;
all_of(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred)
{
    return !std::any_of(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, std::not_fn(__pred));
}

// [alg.none_of]

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _Predicate&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, bool&gt;
none_of(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
{
    return !std::any_of(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __pred);
}

// [alg.foreach]

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _Function&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, void&gt;
for_each(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, _Function __f)
{
    __pstl::__internal::__pattern_walk1(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __f,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Function&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
for_each_n(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _Size __n, _Function __f)
{
    return __pstl::__internal::__pattern_walk1_n(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __n, __f,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec));
}

// [alg.find]

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _Predicate&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
find_if(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
{
    return __pstl::__internal::__pattern_find_if(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __pred,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _Predicate&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
find_if_not(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
{
    return std::find_if(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, std::not_fn(__pred));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _Tp&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
find(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp&amp; __value)
{
    return std::find_if(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last,
                        __pstl::__internal::__equal_value&lt;_Tp&gt;(__value));
}

// [alg.find.end]
template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator1&gt;
find_end(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
         _ForwardIterator2 __s_last, _BinaryPredicate __pred)
{
    return __pstl::__internal::__pattern_find_end(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __s_first, __s_last, __pred,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator1&gt;
find_end(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
         _ForwardIterator2 __s_last)
{
    return std::find_end(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __s_first, __s_last,
                         std::equal_to&lt;&gt;());
}

// [alg.find_first_of]
template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator1&gt;
find_first_of(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
              _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred)
{
    return __pstl::__internal::__pattern_find_first_of(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __s_first, __s_last, __pred,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator1&gt;
find_first_of(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
              _ForwardIterator2 __s_first, _ForwardIterator2 __s_last)
{
    return std::find_first_of(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __s_first, __s_last,
                              std::equal_to&lt;&gt;());
}

// [alg.adjacent_find]
template &lt;class _ExecutionPolicy, class _ForwardIterator&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
adjacent_find(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last)
{
    typedef typename iterator_traits&lt;_ForwardIterator&gt;::value_type _ValueType;
    return __pstl::__internal::__pattern_adjacent_find(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, std::equal_to&lt;_ValueType&gt;(),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
        /*first_semantic*/ false);
}

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
adjacent_find(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred)
{
    return __pstl::__internal::__pattern_adjacent_find(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __pred,
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
        /*first_semantic*/ false);
}

// [alg.count]

// Implementation note: count and count_if call the pattern directly instead of calling std::transform_reduce
// so that we do not have to include &lt;numeric&gt;.

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _Tp&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy,
                                                 typename iterator_traits&lt;_ForwardIterator&gt;::difference_type&gt;
count(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp&amp; __value)
{
    typedef typename iterator_traits&lt;_ForwardIterator&gt;::value_type _ValueType;
    return __pstl::__internal::__pattern_count(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last,
        [&amp;__value](const _ValueType&amp; __x) { return __value == __x; },
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _Predicate&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy,
                                                 typename iterator_traits&lt;_ForwardIterator&gt;::difference_type&gt;
count_if(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
{
    return __pstl::__internal::__pattern_count(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __pred,
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec));
}

// [alg.search]

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator1&gt;
search(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
       _ForwardIterator2 __s_last, _BinaryPredicate __pred)
{
    return __pstl::__internal::__pattern_search(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __s_first, __s_last, __pred,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator1&gt;
search(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
       _ForwardIterator2 __s_last)
{
    return std::search(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __s_first, __s_last, std::equal_to&lt;&gt;());
}

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
search_n(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count,
         const _Tp&amp; __value, _BinaryPredicate __pred)
{
    return __pstl::__internal::__pattern_search_n(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __count, __value, __pred,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
search_n(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count,
         const _Tp&amp; __value)
{
    return std::search_n(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __count, __value,
                         std::equal_to&lt;typename iterator_traits&lt;_ForwardIterator&gt;::value_type&gt;());
}

// [alg.copy]

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator2&gt;
copy(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result)
{
    const auto __is_vector =
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec);

    return __pstl::__internal::__pattern_walk2_brick(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __result,
        [__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _ForwardIterator2 __res) {
            return __pstl::__internal::__brick_copy(__begin, __end, __res, __is_vector);
        },
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator2&gt;
copy_n(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first, _Size __n, _ForwardIterator2 __result)
{
    const auto __is_vector =
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec);

    return __pstl::__internal::__pattern_walk2_brick_n(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __n, __result,
        [__is_vector](_ForwardIterator1 __begin, _Size __sz, _ForwardIterator2 __res) {
            return __pstl::__internal::__brick_copy_n(__begin, __sz, __res, __is_vector);
        },
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator2&gt;
copy_if(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
        _Predicate __pred)
{
    return __pstl::__internal::__pattern_copy_if(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __result, __pred,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec));
}

// [alg.swap]

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator2&gt;
swap_ranges(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
            _ForwardIterator2 __first2)
{
    typedef typename iterator_traits&lt;_ForwardIterator1&gt;::reference _ReferenceType1;
    typedef typename iterator_traits&lt;_ForwardIterator2&gt;::reference _ReferenceType2;
    return __pstl::__internal::__pattern_walk2(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first1, __last1, __first2,
        [](_ReferenceType1 __x, _ReferenceType2 __y) {
            using std::swap;
            swap(__x, __y);
        },
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec));
}

// [alg.transform]

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _UnaryOperation&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator2&gt;
transform(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
          _UnaryOperation __op)
{
    typedef typename iterator_traits&lt;_ForwardIterator1&gt;::reference _InputType;
    typedef typename iterator_traits&lt;_ForwardIterator2&gt;::reference _OutputType;
    return __pstl::__internal::__pattern_walk2(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __result,
        [__op](_InputType __x, _OutputType __y) mutable { __y = __op(__x); },
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
          class _BinaryOperation&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
transform(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
          _ForwardIterator __result, _BinaryOperation __op)
{
    typedef typename iterator_traits&lt;_ForwardIterator1&gt;::reference _Input1Type;
    typedef typename iterator_traits&lt;_ForwardIterator2&gt;::reference _Input2Type;
    typedef typename iterator_traits&lt;_ForwardIterator&gt;::reference _OutputType;
    return __pstl::__internal::__pattern_walk3(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first1, __last1, __first2, __result,
        [__op](_Input1Type x, _Input2Type y, _OutputType z) mutable { z = __op(x, y); },
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
                                                         _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
                                                           _ForwardIterator&gt;(__exec));
}

// [alg.replace]

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _Tp&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, void&gt;
replace_if(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
           const _Tp&amp; __new_value)
{
    typedef typename iterator_traits&lt;_ForwardIterator&gt;::reference _ElementType;
    __pstl::__internal::__pattern_walk1(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last,
        [&amp;__pred, &amp;__new_value](_ElementType __elem) {
            if (__pred(__elem))
            {
                __elem = __new_value;
            }
        },
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _Tp&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, void&gt;
replace(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp&amp; __old_value,
        const _Tp&amp; __new_value)
{
    std::replace_if(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last,
                    __pstl::__internal::__equal_value&lt;_Tp&gt;(__old_value), __new_value);
}

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _UnaryPredicate, class _Tp&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator2&gt;
replace_copy_if(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
                _ForwardIterator2 __result, _UnaryPredicate __pred, const _Tp&amp; __new_value)
{
    typedef typename iterator_traits&lt;_ForwardIterator1&gt;::reference _InputType;
    typedef typename iterator_traits&lt;_ForwardIterator2&gt;::reference _OutputType;
    return __pstl::__internal::__pattern_walk2(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __result,
        [__pred, &amp;__new_value](_InputType __x, _OutputType __y) mutable { __y = __pred(__x) ? __new_value : __x; },
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator2&gt;
replace_copy(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
             const _Tp&amp; __old_value, const _Tp&amp; __new_value)
{
    return std::replace_copy_if(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __result,
                                __pstl::__internal::__equal_value&lt;_Tp&gt;(__old_value), __new_value);
}

// [alg.fill]

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _Tp&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, void&gt;
fill(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp&amp; __value)
{
    __pstl::__internal::__pattern_fill(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __value,
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
fill_n(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _Size __count, const _Tp&amp; __value)
{
    if (__count &lt;= 0)
        return __first;

    return __pstl::__internal::__pattern_fill_n(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __count, __value,
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec));
}

// [alg.generate]
template &lt;class _ExecutionPolicy, class _ForwardIterator, class _Generator&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, void&gt;
generate(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g)
{
    __pstl::__internal::__pattern_generate(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __g,
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Generator&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
generate_n(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _Size __count, _Generator __g)
{
    if (__count &lt;= 0)
        return __first;

    return __pstl::__internal::__pattern_generate_n(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __count, __g,
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec));
}

// [alg.remove]

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator2&gt;
remove_copy_if(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
               _ForwardIterator2 __result, _Predicate __pred)
{
    return std::copy_if(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __result, std::not_fn(__pred));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator2&gt;
remove_copy(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
            const _Tp&amp; __value)
{
    return std::copy_if(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __result,
                        __pstl::__internal::__not_equal_value&lt;_Tp&gt;(__value));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
remove_if(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred)
{
    return __pstl::__internal::__pattern_remove_if(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __pred,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _Tp&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
remove(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp&amp; __value)
{
    return std::remove_if(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last,
                          __pstl::__internal::__equal_value&lt;_Tp&gt;(__value));
}

// [alg.unique]

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
unique(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred)
{
    return __pstl::__internal::__pattern_unique(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __pred,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
unique(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last)
{
    return std::unique(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, std::equal_to&lt;&gt;());
}

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator2&gt;
unique_copy(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
            _BinaryPredicate __pred)
{
    return __pstl::__internal::__pattern_unique_copy(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __result, __pred,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator2&gt;
unique_copy(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result)
{
    return std::unique_copy(__exec, __first, __last, __result, std::equal_to&lt;&gt;());
}

// [alg.reverse]

template &lt;class _ExecutionPolicy, class _BidirectionalIterator&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, void&gt;
reverse(_ExecutionPolicy&amp;&amp; __exec, _BidirectionalIterator __first, _BidirectionalIterator __last)
{
    __pstl::__internal::__pattern_reverse(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _BidirectionalIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _BidirectionalIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _BidirectionalIterator, class _ForwardIterator&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
reverse_copy(_ExecutionPolicy&amp;&amp; __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
             _ForwardIterator __d_first)
{
    return __pstl::__internal::__pattern_reverse_copy(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __d_first,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _BidirectionalIterator, _ForwardIterator&gt;(
            __exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _BidirectionalIterator, _ForwardIterator&gt;(
            __exec));
}

// [alg.rotate]

template &lt;class _ExecutionPolicy, class _ForwardIterator&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
rotate(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last)
{
    return __pstl::__internal::__pattern_rotate(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __middle, __last,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator2&gt;
rotate_copy(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first, _ForwardIterator1 __middle, _ForwardIterator1 __last,
            _ForwardIterator2 __result)
{
    return __pstl::__internal::__pattern_rotate_copy(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __middle, __last, __result,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec));
}

// [alg.partitions]

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, bool&gt;
is_partitioned(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred)
{
    return __pstl::__internal::__pattern_is_partitioned(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __pred,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
partition(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred)
{
    return __pstl::__internal::__pattern_partition(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __pred,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _BidirectionalIterator&gt;
stable_partition(_ExecutionPolicy&amp;&amp; __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
                 _UnaryPredicate __pred)
{
    return __pstl::__internal::__pattern_stable_partition(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __pred,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _BidirectionalIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _BidirectionalIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _ForwardIterator1, class _ForwardIterator2,
          class _UnaryPredicate&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, std::pair&lt;_ForwardIterator1, _ForwardIterator2&gt;&gt;
partition_copy(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last,
               _ForwardIterator1 __out_true, _ForwardIterator2 __out_false, _UnaryPredicate __pred)
{
    return __pstl::__internal::__pattern_partition_copy(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __out_true, __out_false, __pred,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator, _ForwardIterator1,
                                                         _ForwardIterator2&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator, _ForwardIterator1,
                                                           _ForwardIterator2&gt;(__exec));
}

// [alg.sort]

template &lt;class _ExecutionPolicy, class _RandomAccessIterator, class _Compare&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, void&gt;
sort(_ExecutionPolicy&amp;&amp; __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
{
    typedef typename iterator_traits&lt;_RandomAccessIterator&gt;::value_type _InputType;
    return __pstl::__internal::__pattern_sort(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __comp,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _RandomAccessIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _RandomAccessIterator&gt;(__exec),
        typename std::is_move_constructible&lt;_InputType&gt;::type());
}

template &lt;class _ExecutionPolicy, class _RandomAccessIterator&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, void&gt;
sort(_ExecutionPolicy&amp;&amp; __exec, _RandomAccessIterator __first, _RandomAccessIterator __last)
{
    typedef typename std::iterator_traits&lt;_RandomAccessIterator&gt;::value_type _InputType;
    std::sort(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, std::less&lt;_InputType&gt;());
}

// [stable.sort]

template &lt;class _ExecutionPolicy, class _RandomAccessIterator, class _Compare&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, void&gt;
stable_sort(_ExecutionPolicy&amp;&amp; __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
{
    return __pstl::__internal::__pattern_stable_sort(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __comp,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _RandomAccessIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _RandomAccessIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _RandomAccessIterator&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, void&gt;
stable_sort(_ExecutionPolicy&amp;&amp; __exec, _RandomAccessIterator __first, _RandomAccessIterator __last)
{
    typedef typename std::iterator_traits&lt;_RandomAccessIterator&gt;::value_type _InputType;
    std::stable_sort(__exec, __first, __last, std::less&lt;_InputType&gt;());
}

// [mismatch]

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, std::pair&lt;_ForwardIterator1, _ForwardIterator2&gt;&gt;
mismatch(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
         _ForwardIterator2 __last2, _BinaryPredicate __pred)
{
    return __pstl::__internal::__pattern_mismatch(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first1, __last1, __first2, __last2, __pred,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, std::pair&lt;_ForwardIterator1, _ForwardIterator2&gt;&gt;
mismatch(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
         _BinaryPredicate __pred)
{
    return std::mismatch(__exec, __first1, __last1, __first2, std::next(__first2, std::distance(__first1, __last1)),
                         __pred);
}

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, std::pair&lt;_ForwardIterator1, _ForwardIterator2&gt;&gt;
mismatch(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
         _ForwardIterator2 __last2)
{
    return std::mismatch(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first1, __last1, __first2, __last2,
                         std::equal_to&lt;&gt;());
}

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, std::pair&lt;_ForwardIterator1, _ForwardIterator2&gt;&gt;
mismatch(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2)
{
    //TODO: to get rid of &quot;distance&quot;
    return std::mismatch(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first1, __last1, __first2,
                         std::next(__first2, std::distance(__first1, __last1)));
}

// [alg.equal]

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, bool&gt;
equal(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      _BinaryPredicate __p)
{
    return __pstl::__internal::__pattern_equal(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first1, __last1, __first2, __p,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator1&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator1&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, bool&gt;
equal(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2)
{
    return std::equal(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first1, __last1, __first2, std::equal_to&lt;&gt;());
}

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, bool&gt;
equal(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      _ForwardIterator2 __last2, _BinaryPredicate __p)
{
    return __pstl::__internal::__pattern_equal(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first1, __last1, __first2, __last2, __p,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator1&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator1&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, bool&gt;
equal(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      _ForwardIterator2 __last2)
{
    return equal(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first1, __last1, __first2, __last2, std::equal_to&lt;&gt;());
}

// [alg.move]
template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator2&gt;
move(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first)
{
    const auto __is_vector =
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec);

    return __pstl::__internal::__pattern_walk2_brick(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __d_first,
        [__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _ForwardIterator2 __res) {
            return __pstl::__internal::__brick_move(__begin, __end, __res, __is_vector);
        },
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec));
}

// [partial.sort]

template &lt;class _ExecutionPolicy, class _RandomAccessIterator, class _Compare&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, void&gt;
partial_sort(_ExecutionPolicy&amp;&amp; __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle,
             _RandomAccessIterator __last, _Compare __comp)
{
    __pstl::__internal::__pattern_partial_sort(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __middle, __last, __comp,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _RandomAccessIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _RandomAccessIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _RandomAccessIterator&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, void&gt;
partial_sort(_ExecutionPolicy&amp;&amp; __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle,
             _RandomAccessIterator __last)
{
    typedef typename iterator_traits&lt;_RandomAccessIterator&gt;::value_type _InputType;
    std::partial_sort(__exec, __first, __middle, __last, std::less&lt;_InputType&gt;());
}

// [partial.sort.copy]

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _RandomAccessIterator&gt;
partial_sort_copy(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last,
                  _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp)
{
    return __pstl::__internal::__pattern_partial_sort_copy(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __d_first, __d_last, __comp,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator, _RandomAccessIterator&gt;(
            __exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator, _RandomAccessIterator&gt;(
            __exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _RandomAccessIterator&gt;
partial_sort_copy(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last,
                  _RandomAccessIterator __d_first, _RandomAccessIterator __d_last)
{
    return std::partial_sort_copy(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __d_first, __d_last,
                                  std::less&lt;&gt;());
}

// [is.sorted]
template &lt;class _ExecutionPolicy, class _ForwardIterator, class _Compare&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
is_sorted_until(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
{
    const _ForwardIterator __res = __pstl::__internal::__pattern_adjacent_find(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __pstl::__internal::__reorder_pred&lt;_Compare&gt;(__comp),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
        /*first_semantic*/ false);
    return __res == __last ? __last : std::next(__res);
}

template &lt;class _ExecutionPolicy, class _ForwardIterator&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
is_sorted_until(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last)
{
    typedef typename std::iterator_traits&lt;_ForwardIterator&gt;::value_type _InputType;
    return is_sorted_until(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, std::less&lt;_InputType&gt;());
}

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _Compare&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, bool&gt;
is_sorted(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
{
    return __pstl::__internal::__pattern_adjacent_find(
               std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last,
               __pstl::__internal::__reorder_pred&lt;_Compare&gt;(__comp),
               __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
               __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
               /*or_semantic*/ true) == __last;
}

template &lt;class _ExecutionPolicy, class _ForwardIterator&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, bool&gt;
is_sorted(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last)
{
    typedef typename std::iterator_traits&lt;_ForwardIterator&gt;::value_type _InputType;
    return std::is_sorted(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, std::less&lt;_InputType&gt;());
}

// [alg.merge]
template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
          class _Compare&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
merge(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      _ForwardIterator2 __last2, _ForwardIterator __d_first, _Compare __comp)
{
    return __pstl::__internal::__pattern_merge(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first1, __last1, __first2, __last2, __d_first, __comp,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
                                                         _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
                                                           _ForwardIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
merge(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      _ForwardIterator2 __last2, _ForwardIterator __d_first)
{
    return std::merge(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first1, __last1, __first2, __last2, __d_first,
                      std::less&lt;&gt;());
}

template &lt;class _ExecutionPolicy, class _BidirectionalIterator, class _Compare&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, void&gt;
inplace_merge(_ExecutionPolicy&amp;&amp; __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle,
              _BidirectionalIterator __last, _Compare __comp)
{
    __pstl::__internal::__pattern_inplace_merge(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __middle, __last, __comp,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _BidirectionalIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _BidirectionalIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _BidirectionalIterator&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, void&gt;
inplace_merge(_ExecutionPolicy&amp;&amp; __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle,
              _BidirectionalIterator __last)
{
    typedef typename std::iterator_traits&lt;_BidirectionalIterator&gt;::value_type _InputType;
    std::inplace_merge(__exec, __first, __middle, __last, std::less&lt;_InputType&gt;());
}

// [includes]

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, bool&gt;
includes(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
         _ForwardIterator2 __last2, _Compare __comp)
{
    return __pstl::__internal::__pattern_includes(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first1, __last1, __first2, __last2, __comp,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, bool&gt;
includes(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
         _ForwardIterator2 __last2)
{
    return std::includes(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first1, __last1, __first2, __last2, std::less&lt;&gt;());
}

// [set.union]

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
          class _Compare&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
set_union(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
          _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp)
{
    return __pstl::__internal::__pattern_set_union(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first1, __last1, __first2, __last2, __result, __comp,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
                                                         _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
                                                           _ForwardIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
set_union(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
          _ForwardIterator2 __last2, _ForwardIterator __result)
{
    return std::set_union(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first1, __last1, __first2, __last2, __result,
                          std::less&lt;&gt;());
}

// [set.intersection]

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
          class _Compare&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
set_intersection(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp)
{
    return __pstl::__internal::__pattern_set_intersection(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first1, __last1, __first2, __last2, __result, __comp,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
                                                         _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
                                                           _ForwardIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
set_intersection(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result)
{
    return std::set_intersection(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first1, __last1, __first2, __last2, __result,
                                 std::less&lt;&gt;());
}

// [set.difference]

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
          class _Compare&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
set_difference(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
               _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp)
{
    return __pstl::__internal::__pattern_set_difference(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first1, __last1, __first2, __last2, __result, __comp,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
                                                         _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
                                                           _ForwardIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
set_difference(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
               _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result)
{
    return std::set_difference(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first1, __last1, __first2, __last2, __result,
                               std::less&lt;&gt;());
}

// [set.symmetric.difference]

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
          class _Compare&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
set_symmetric_difference(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                         _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result,
                         _Compare __comp)
{
    return __pstl::__internal::__pattern_set_symmetric_difference(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first1, __last1, __first2, __last2, __result, __comp,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
                                                         _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
                                                           _ForwardIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
set_symmetric_difference(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                         _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result)
{
    return std::set_symmetric_difference(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first1, __last1, __first2, __last2,
                                         __result, std::less&lt;&gt;());
}

// [is.heap]
template &lt;class _ExecutionPolicy, class _RandomAccessIterator, class _Compare&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _RandomAccessIterator&gt;
is_heap_until(_ExecutionPolicy&amp;&amp; __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
{
    return __pstl::__internal::__pattern_is_heap_until(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __comp,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _RandomAccessIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _RandomAccessIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _RandomAccessIterator&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _RandomAccessIterator&gt;
is_heap_until(_ExecutionPolicy&amp;&amp; __exec, _RandomAccessIterator __first, _RandomAccessIterator __last)
{
    typedef typename std::iterator_traits&lt;_RandomAccessIterator&gt;::value_type _InputType;
    return std::is_heap_until(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, std::less&lt;_InputType&gt;());
}

template &lt;class _ExecutionPolicy, class _RandomAccessIterator, class _Compare&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, bool&gt;
is_heap(_ExecutionPolicy&amp;&amp; __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
{
    return std::is_heap_until(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __comp) == __last;
}

template &lt;class _ExecutionPolicy, class _RandomAccessIterator&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, bool&gt;
is_heap(_ExecutionPolicy&amp;&amp; __exec, _RandomAccessIterator __first, _RandomAccessIterator __last)
{
    typedef typename std::iterator_traits&lt;_RandomAccessIterator&gt;::value_type _InputType;
    return std::is_heap(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, std::less&lt;_InputType&gt;());
}

// [alg.min.max]

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _Compare&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
min_element(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
{
    return __pstl::__internal::__pattern_min_element(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __comp,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
min_element(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last)
{
    typedef typename std::iterator_traits&lt;_ForwardIterator&gt;::value_type _InputType;
    return std::min_element(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, std::less&lt;_InputType&gt;());
}

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _Compare&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
max_element(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
{
    return min_element(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last,
                       __pstl::__internal::__reorder_pred&lt;_Compare&gt;(__comp));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, _ForwardIterator&gt;
max_element(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last)
{
    typedef typename std::iterator_traits&lt;_ForwardIterator&gt;::value_type _InputType;
    return std::min_element(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last,
                            __pstl::__internal::__reorder_pred&lt;std::less&lt;_InputType&gt;&gt;(std::less&lt;_InputType&gt;()));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator, class _Compare&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, std::pair&lt;_ForwardIterator, _ForwardIterator&gt;&gt;
minmax_element(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
{
    return __pstl::__internal::__pattern_minmax_element(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, __comp,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, std::pair&lt;_ForwardIterator, _ForwardIterator&gt;&gt;
minmax_element(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator __first, _ForwardIterator __last)
{
    typedef typename iterator_traits&lt;_ForwardIterator&gt;::value_type _ValueType;
    return std::minmax_element(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __last, std::less&lt;_ValueType&gt;());
}

// [alg.nth.element]

template &lt;class _ExecutionPolicy, class _RandomAccessIterator, class _Compare&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, void&gt;
nth_element(_ExecutionPolicy&amp;&amp; __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth,
            _RandomAccessIterator __last, _Compare __comp)
{
    __pstl::__internal::__pattern_nth_element(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __nth, __last, __comp,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _RandomAccessIterator&gt;(__exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _RandomAccessIterator&gt;(__exec));
}

template &lt;class _ExecutionPolicy, class _RandomAccessIterator&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, void&gt;
nth_element(_ExecutionPolicy&amp;&amp; __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth,
            _RandomAccessIterator __last)
{
    typedef typename iterator_traits&lt;_RandomAccessIterator&gt;::value_type _InputType;
    std::nth_element(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first, __nth, __last, std::less&lt;_InputType&gt;());
}

// [alg.lex.comparison]

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, bool&gt;
lexicographical_compare(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                        _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp)
{
    return __pstl::__internal::__pattern_lexicographical_compare(
        std::forward&lt;_ExecutionPolicy&gt;(__exec), __first1, __last1, __first2, __last2, __comp,
        __pstl::__internal::__is_vectorization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec),
        __pstl::__internal::__is_parallelization_preferred&lt;_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2&gt;(
            __exec));
}

template &lt;class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2&gt;
__pstl::__internal::__enable_if_execution_policy&lt;_ExecutionPolicy, bool&gt;
lexicographical_compare(_ExecutionPolicy&amp;&amp; __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                        _ForwardIterator2 __first2, _ForwardIterator2 __last2)
{
    return std::lexicographical_compare(std::forward&lt;_ExecutionPolicy&gt;(__exec), __first1, __last1, __first2, __last2,
                                        std::less&lt;&gt;());
}

} // namespace std

#endif /* _PSTL_GLUE_ALGORITHM_IMPL_H */
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Frh%2Fgcc-toolset-11%2Froot%2Fusr%2Finclude%2Fc%2B%2B%2F11%2Fpstl'>Back to Directory</a>