[algorithms] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpnvw_taza/{from.md → to.md} +3298 -634

tmp/tmpnvw_taza/{from.md → to.md} RENAMED Viewed

@@ -5,25 +5,26 @@
 This Clause describes components that C++ programs may use to perform
 algorithmic operations on containers [[containers]] and other sequences.
 The following subclauses describe components for non-modifying sequence
 operations, mutating sequence operations, sorting and related
-operations, and algorithms from the ISO C library, as summarized in
 [[algorithms.summary]].
 **Table: Algorithms library summary** <a id="algorithms.summary">[algorithms.summary]</a>
 | Subclause                    |                                   | Header        |
 | ---------------------------- | --------------------------------- | ------------- |
 | [[algorithms.requirements]]  | Algorithms requirements           |               |
-| [[algorithms.parallel]]      | Parallel algorithms               | |
 | [[algorithms.results]]       | Algorithm result types            | `<algorithm>` |
 | [[alg.nonmodifying]]         | Non-modifying sequence operations |               |
 | [[alg.modifying.operations]] | Mutating sequence operations      |               |
 | [[alg.sorting]]              | Sorting and related operations    |               |
 | [[numeric.ops]]              | Generalized numeric operations    | `<numeric>`   |
 | [[specialized.algorithms]]   | Specialized `<memory>` algorithms | `<memory>`    |
 | [[alg.c.library]]            | C library algorithms              | `<cstdlib>`   |
 ## Algorithms requirements <a id="algorithms.requirements">[[algorithms.requirements]]</a>
@@ -31,34 +32,13 @@ All of the algorithms are separated from the particular implementations
 of data structures and are parameterized by iterator types. Because of
 this, they can work with program-defined data structures, as long as
 these data structures have iterator types satisfying the assumptions on
 the algorithms.
-The entities defined in the `std::ranges` namespace in this Clause are
-not found by argument-dependent name lookup [[basic.lookup.argdep]].
-When found by unqualified [[basic.lookup.unqual]] name lookup for the
-*postfix-expression* in a function call [[expr.call]], they inhibit
-argument-dependent name lookup.
-[*Example 1*:
-``` cpp
-void foo() {
-  using namespace std::ranges;
-  std::vector<int> vec{1,2,3};
-  find(begin(vec), end(vec), 2);        // #1
-}
-```
-The function call expression at `#1` invokes `std::ranges::find`, not
-`std::find`, despite that (a) the iterator type returned from
-`begin(vec)` and `end(vec)` may be associated with namespace `std` and
-(b) `std::find` is more specialized [[temp.func.order]] than
-`std::ranges::find` since the former requires its first two parameters
-to have the same type.
-— *end example*]
 For purposes of determining the existence of data races, algorithms
 shall not modify objects referenced through an iterator argument unless
 the specification requires such modification.
@@ -187,10 +167,18 @@ and if \[`b`, `a`) denotes a range, the same as those of
 iter_difference_t<decltype(b)> n = 0;
 for (auto tmp = b; tmp != a; ++tmp) --n;
 return n;
 ```
 In the description of the algorithms, given an iterator `a` whose
 difference type is `D`, and an expression `n` of integer-like type other
 than cv `D`, the semantics of `a + n` and `a - n` are, respectively,
 those of `a + D(n)` and `a - D(n)`.
@@ -198,19 +186,27 @@ In the description of algorithm return values, a sentinel value `s`
 denoting the end of a range \[`i`, `s`) is sometimes returned where an
 iterator is expected. In these cases, the semantics are as if the
 sentinel is converted into an iterator using `ranges::next(i, s)`.
 Overloads of algorithms that take `range` arguments [[range.range]]
-behave as if they are implemented by calling `ranges::begin` and
-`ranges::end` on the `range`(s) and dispatching to the overload in
-namespace `ranges` that takes separate iterator and sentinel arguments.
 The well-formedness and behavior of a call to an algorithm with an
 explicitly-specified template argument list is unspecified, except where
 explicitly stated otherwise.
-[*Note 3*: Consequently, an implementation can declare an algorithm
 with different template parameters than those presented. — *end note*]
 ## Parallel algorithms <a id="algorithms.parallel">[[algorithms.parallel]]</a>
 ### Preamble <a id="algorithms.parallel.defns">[[algorithms.parallel.defns]]</a>
@@ -218,22 +214,31 @@ with different template parameters than those presented. — *end note*]
 Subclause [[algorithms.parallel]] describes components that C++ programs
 may use to perform operations on containers and other sequences in
 parallel.
 A *parallel algorithm* is a function template listed in this document
-with a template parameter named `ExecutionPolicy`.
-Parallel algorithms access objects indirectly accessible via their
 arguments by invoking the following functions:
-- All operations of the categories of the iterators that the algorithm
-  is instantiated with.
 - Operations on those sequence elements that are required by its
   specification.
-- User-provided function objects to be applied during the execution of
   the algorithm, if required by the specification.
-- Operations on those function objects required by the specification.
   \[*Note 1*: See  [[algorithms.requirements]]. — *end note*]
 These functions are herein called *element access functions*.
 [*Example 1*:
@@ -250,11 +255,12 @@ The `sort` function may invoke the following element access functions:
 — *end example*]
 A standard library function is *vectorization-unsafe* if it is specified
 to synchronize with another function invocation, or another function
 invocation is specified to synchronize with it, and if it is not a
-memory allocation or deallocation function.
 [*Note 2*: Implementations must ensure that internal synchronization
 inside standard library functions does not prevent forward progress when
 those functions are executed by threads of execution with weakly
 parallel forward progress guarantees. — *end note*]
@@ -280,25 +286,26 @@ different threads of execution.
 — *end example*]
 ### Requirements on user-provided function objects <a id="algorithms.parallel.user">[[algorithms.parallel.user]]</a>
-Unless otherwise specified, function objects passed into parallel
-algorithms as objects of type `Predicate`, `BinaryPredicate`, `Compare`,
-`UnaryOperation`, `BinaryOperation`, `BinaryOperation1`,
-`BinaryOperation2`, and the operators used by the analogous overloads to
 these parallel algorithms that are formed by an invocation with the
 specified default predicate or operation (where applicable) shall not
 directly or indirectly modify objects via their arguments, nor shall
 they rely on the identity of the provided objects.
 ### Effect of execution policies on algorithm execution <a id="algorithms.parallel.exec">[[algorithms.parallel.exec]]</a>
-Parallel algorithms have template parameters named `ExecutionPolicy`
-[[execpol]] which describe the manner in which the execution of these
-algorithms may be parallelized and the manner in which they apply the
-element access functions.
 If an object is modified by an element access function, the algorithm
 will perform no other unsynchronized accesses to that object. The
 modifying element access functions are those which are specified as
 modifying the object.
@@ -470,40 +477,174 @@ During the execution of a parallel algorithm, if temporary memory
 resources are required for parallelization and none are available, the
 algorithm throws a `bad_alloc` exception.
 During the execution of a parallel algorithm, if the invocation of an
 element access function exits via an uncaught exception, the behavior is
-determined by the `ExecutionPolicy`.
-### `ExecutionPolicy` algorithm overloads <a id="algorithms.parallel.overloads">[[algorithms.parallel.overloads]]</a>
 Parallel algorithms are algorithm overloads. Each parallel algorithm
-overload has an additional template type parameter named
-`ExecutionPolicy`, which is the first template parameter. Additionally,
-each parallel algorithm overload has an additional function parameter of
-type `ExecutionPolicy&&`, which is the first function parameter.
 [*Note 1*: Not all algorithms have parallel algorithm
 overloads. — *end note*]
-Unless otherwise specified, the semantics of `ExecutionPolicy` algorithm
-overloads are identical to their overloads without.
-Unless otherwise specified, the complexity requirements of
-`ExecutionPolicy` algorithm overloads are relaxed from the complexity
-requirements of the overloads without as follows: when the guarantee
-says “at most *expr*” or “exactly *expr*” and does not specify the
-number of assignments or swaps, and *expr* is not already expressed with
-𝑂() notation, the complexity of the algorithm shall be
 𝑂(\placeholder{expr}).
-Parallel algorithms shall not participate in overload resolution unless
-`is_execution_policy_v<remove_cvref_t<ExecutionPolicy>>` is `true`.
 ## Header `<algorithm>` synopsis <a id="algorithm.syn">[[algorithm.syn]]</a>
 ``` cpp
 #include <initializer_list>     // see [initializer.list.syn]
 namespace std {
   namespace ranges {
     // [algorithms.results], algorithm result types
@@ -538,64 +679,98 @@ namespace std {
   // [alg.nonmodifying], non-modifying sequence operations
   // [alg.all.of], all of
   template<class InputIterator, class Predicate>
     constexpr bool all_of(InputIterator first, InputIterator last, Predicate pred);
   template<class ExecutionPolicy, class ForwardIterator, class Predicate>
-    bool all_of(ExecutionPolicy&& exec,                         // see [algorithms.parallel.overloads]
                 ForwardIterator first, ForwardIterator last, Predicate pred);
   namespace ranges {
     template<input_iterator I, sentinel_for<I> S, class Proj = identity,
              indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr bool all_of(I first, S last, Pred pred, Proj proj = {});
     template<input_range R, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr bool all_of(R&& r, Pred pred, Proj proj = {});
   }
   // [alg.any.of], any of
   template<class InputIterator, class Predicate>
     constexpr bool any_of(InputIterator first, InputIterator last, Predicate pred);
   template<class ExecutionPolicy, class ForwardIterator, class Predicate>
-    bool any_of(ExecutionPolicy&& exec,                         // see [algorithms.parallel.overloads]
                 ForwardIterator first, ForwardIterator last, Predicate pred);
   namespace ranges {
     template<input_iterator I, sentinel_for<I> S, class Proj = identity,
              indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr bool any_of(I first, S last, Pred pred, Proj proj = {});
     template<input_range R, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr bool any_of(R&& r, Pred pred, Proj proj = {});
   }
   // [alg.none.of], none of
   template<class InputIterator, class Predicate>
     constexpr bool none_of(InputIterator first, InputIterator last, Predicate pred);
   template<class ExecutionPolicy, class ForwardIterator, class Predicate>
-    bool none_of(ExecutionPolicy&& exec,                        // see [algorithms.parallel.overloads]
                  ForwardIterator first, ForwardIterator last, Predicate pred);
   namespace ranges {
     template<input_iterator I, sentinel_for<I> S, class Proj = identity,
              indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr bool none_of(I first, S last, Pred pred, Proj proj = {});
     template<input_range R, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr bool none_of(R&& r, Pred pred, Proj proj = {});
   }
   // [alg.contains], contains
   namespace ranges {
-    template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
       requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
       constexpr bool contains(I first, S last, const T& value, Proj proj = {});
-    template<input_range R, class T, class Proj = identity>
       requires
         indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
       constexpr bool contains(R&& r, const T& value, Proj proj = {});
     template<forward_iterator I1, sentinel_for<I1> S1,
              forward_iterator I2, sentinel_for<I2> S2,
              class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
       requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
       constexpr bool contains_subrange(I1 first1, S1 last1, I2 first2, S2 last2,
@@ -603,17 +778,29 @@ namespace std {
     template<forward_range R1, forward_range R2,
              class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
       requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
       constexpr bool contains_subrange(R1&& r1, R2&& r2,
                                        Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
   }
   // [alg.foreach], for each
   template<class InputIterator, class Function>
     constexpr Function for_each(InputIterator first, InputIterator last, Function f);
   template<class ExecutionPolicy, class ForwardIterator, class Function>
-    void for_each(ExecutionPolicy&& exec,                       // see [algorithms.parallel.overloads]
                   ForwardIterator first, ForwardIterator last, Function f);
   namespace ranges {
     template<class I, class F>
       using for_each_result = in_fun_result<I, F>;
@@ -624,97 +811,182 @@ namespace std {
         for_each(I first, S last, Fun f, Proj proj = {});
     template<input_range R, class Proj = identity,
              indirectly_unary_invocable<projected<iterator_t<R>, Proj>> Fun>
       constexpr for_each_result<borrowed_iterator_t<R>, Fun>
         for_each(R&& r, Fun f, Proj proj = {});
   }
   template<class InputIterator, class Size, class Function>
     constexpr InputIterator for_each_n(InputIterator first, Size n, Function f);
   template<class ExecutionPolicy, class ForwardIterator, class Size, class Function>
-    ForwardIterator for_each_n(ExecutionPolicy&& exec,          // see [algorithms.parallel.overloads]
                                ForwardIterator first, Size n, Function f);
   namespace ranges {
     template<class I, class F>
       using for_each_n_result = in_fun_result<I, F>;
     template<input_iterator I, class Proj = identity,
              indirectly_unary_invocable<projected<I, Proj>> Fun>
       constexpr for_each_n_result<I, Fun>
         for_each_n(I first, iter_difference_t<I> n, Fun f, Proj proj = {});
   }
   // [alg.find], find
-  template<class InputIterator, class T>
     constexpr InputIterator find(InputIterator first, InputIterator last,
                                  const T& value);
-  template<class ExecutionPolicy, class ForwardIterator, class T>
-    ForwardIterator find(ExecutionPolicy&& exec,                // see [algorithms.parallel.overloads]
                          ForwardIterator first, ForwardIterator last,
                          const T& value);
   template<class InputIterator, class Predicate>
     constexpr InputIterator find_if(InputIterator first, InputIterator last,
                                     Predicate pred);
   template<class ExecutionPolicy, class ForwardIterator, class Predicate>
-    ForwardIterator find_if(ExecutionPolicy&& exec,             // see [algorithms.parallel.overloads]
                             ForwardIterator first, ForwardIterator last,
                             Predicate pred);
   template<class InputIterator, class Predicate>
     constexpr InputIterator find_if_not(InputIterator first, InputIterator last,
                                         Predicate pred);
   template<class ExecutionPolicy, class ForwardIterator, class Predicate>
-    ForwardIterator find_if_not(ExecutionPolicy&& exec,         // see [algorithms.parallel.overloads]
                                 ForwardIterator first, ForwardIterator last,
                                 Predicate pred);
   namespace ranges {
-    template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
       requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
       constexpr I find(I first, S last, const T& value, Proj proj = {});
-    template<input_range R, class T, class Proj = identity>
       requires indirect_binary_predicate<ranges::equal_to,
                                          projected<iterator_t<R>, Proj>, const T*>
       constexpr borrowed_iterator_t<R>
         find(R&& r, const T& value, Proj proj = {});
     template<input_iterator I, sentinel_for<I> S, class Proj = identity,
              indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr I find_if(I first, S last, Pred pred, Proj proj = {});
     template<input_range R, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr borrowed_iterator_t<R>
         find_if(R&& r, Pred pred, Proj proj = {});
     template<input_iterator I, sentinel_for<I> S, class Proj = identity,
              indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr I find_if_not(I first, S last, Pred pred, Proj proj = {});
     template<input_range R, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr borrowed_iterator_t<R>
         find_if_not(R&& r, Pred pred, Proj proj = {});
   }
   // [alg.find.last], find last
   namespace ranges {
-    template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity>
       requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
       constexpr subrange<I> find_last(I first, S last, const T& value, Proj proj = {});
-    template<forward_range R, class T, class Proj = identity>
       requires
         indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
       constexpr borrowed_subrange_t<R> find_last(R&& r, const T& value, Proj proj = {});
     template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
              indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr subrange<I> find_last_if(I first, S last, Pred pred, Proj proj = {});
     template<forward_range R, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr borrowed_subrange_t<R> find_last_if(R&& r, Pred pred, Proj proj = {});
     template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
              indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr subrange<I> find_last_if_not(I first, S last, Pred pred, Proj proj = {});
     template<forward_range R, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr borrowed_subrange_t<R> find_last_if_not(R&& r, Pred pred, Proj proj = {});
   }
   // [alg.find.end], find end
   template<class ForwardIterator1, class ForwardIterator2>
     constexpr ForwardIterator1
@@ -725,17 +997,17 @@ namespace std {
       find_end(ForwardIterator1 first1, ForwardIterator1 last1,
                ForwardIterator2 first2, ForwardIterator2 last2,
                BinaryPredicate pred);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
     ForwardIterator1
-      find_end(ExecutionPolicy&& exec,                          // see [algorithms.parallel.overloads]
                ForwardIterator1 first1, ForwardIterator1 last1,
                ForwardIterator2 first2, ForwardIterator2 last2);
   template<class ExecutionPolicy, class ForwardIterator1,
            class ForwardIterator2, class BinaryPredicate>
     ForwardIterator1
-      find_end(ExecutionPolicy&& exec,                          // see [algorithms.parallel.overloads]
                ForwardIterator1 first1, ForwardIterator1 last1,
                ForwardIterator2 first2, ForwardIterator2 last2,
                BinaryPredicate pred);
   namespace ranges {
@@ -749,13 +1021,27 @@ namespace std {
              class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
       requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
       constexpr borrowed_subrange_t<R1>
         find_end(R1&& r1, R2&& r2, Pred pred = {},
                  Proj1 proj1 = {}, Proj2 proj2 = {});
   }
-  // [alg.find.first.of], find first
   template<class InputIterator, class ForwardIterator>
     constexpr InputIterator
       find_first_of(InputIterator first1, InputIterator last1,
                     ForwardIterator first2, ForwardIterator last2);
   template<class InputIterator, class ForwardIterator, class BinaryPredicate>
@@ -763,17 +1049,17 @@ namespace std {
       find_first_of(InputIterator first1, InputIterator last1,
                     ForwardIterator first2, ForwardIterator last2,
                     BinaryPredicate pred);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
     ForwardIterator1
-      find_first_of(ExecutionPolicy&& exec,                     // see [algorithms.parallel.overloads]
                     ForwardIterator1 first1, ForwardIterator1 last1,
                     ForwardIterator2 first2, ForwardIterator2 last2);
   template<class ExecutionPolicy, class ForwardIterator1,
            class ForwardIterator2, class BinaryPredicate>
     ForwardIterator1
-      find_first_of(ExecutionPolicy&& exec,                     // see [algorithms.parallel.overloads]
                     ForwardIterator1 first1, ForwardIterator1 last1,
                     ForwardIterator2 first2, ForwardIterator2 last2,
                     BinaryPredicate pred);
   namespace ranges {
@@ -786,10 +1072,23 @@ namespace std {
              class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
       requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
       constexpr borrowed_iterator_t<R1>
         find_first_of(R1&& r1, R2&& r2, Pred pred = {},
                       Proj1 proj1 = {}, Proj2 proj2 = {});
   }
   // [alg.adjacent.find], adjacent find
   template<class ForwardIterator>
     constexpr ForwardIterator
@@ -798,15 +1097,15 @@ namespace std {
     constexpr ForwardIterator
       adjacent_find(ForwardIterator first, ForwardIterator last,
                     BinaryPredicate pred);
   template<class ExecutionPolicy, class ForwardIterator>
     ForwardIterator
-      adjacent_find(ExecutionPolicy&& exec,                     // see [algorithms.parallel.overloads]
                     ForwardIterator first, ForwardIterator last);
   template<class ExecutionPolicy, class ForwardIterator, class BinaryPredicate>
     ForwardIterator
-      adjacent_find(ExecutionPolicy&& exec,                     // see [algorithms.parallel.overloads]
                     ForwardIterator first, ForwardIterator last,
                     BinaryPredicate pred);
   namespace ranges {
     template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
@@ -817,49 +1116,86 @@ namespace std {
     template<forward_range R, class Proj = identity,
              indirect_binary_predicate<projected<iterator_t<R>, Proj>,
                                        projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
       constexpr borrowed_iterator_t<R>
         adjacent_find(R&& r, Pred pred = {}, Proj proj = {});
   }
   // [alg.count], count
-  template<class InputIterator, class T>
     constexpr typename iterator_traits<InputIterator>::difference_type
       count(InputIterator first, InputIterator last, const T& value);
-  template<class ExecutionPolicy, class ForwardIterator, class T>
     typename iterator_traits<ForwardIterator>::difference_type
-      count(ExecutionPolicy&& exec,                             // see [algorithms.parallel.overloads]
             ForwardIterator first, ForwardIterator last, const T& value);
   template<class InputIterator, class Predicate>
     constexpr typename iterator_traits<InputIterator>::difference_type
       count_if(InputIterator first, InputIterator last, Predicate pred);
   template<class ExecutionPolicy, class ForwardIterator, class Predicate>
     typename iterator_traits<ForwardIterator>::difference_type
-      count_if(ExecutionPolicy&& exec,                          // see [algorithms.parallel.overloads]
                ForwardIterator first, ForwardIterator last, Predicate pred);
   namespace ranges {
-    template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
       requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
       constexpr iter_difference_t<I>
         count(I first, S last, const T& value, Proj proj = {});
-    template<input_range R, class T, class Proj = identity>
       requires indirect_binary_predicate<ranges::equal_to,
                                          projected<iterator_t<R>, Proj>, const T*>
       constexpr range_difference_t<R>
         count(R&& r, const T& value, Proj proj = {});
     template<input_iterator I, sentinel_for<I> S, class Proj = identity,
              indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr iter_difference_t<I>
         count_if(I first, S last, Pred pred, Proj proj = {});
     template<input_range R, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr range_difference_t<R>
         count_if(R&& r, Pred pred, Proj proj = {});
   }
-  // [mismatch], mismatch
   template<class InputIterator1, class InputIterator2>
     constexpr pair<InputIterator1, InputIterator2>
       mismatch(InputIterator1 first1, InputIterator1 last1,
                InputIterator2 first2);
   template<class InputIterator1, class InputIterator2, class BinaryPredicate>
@@ -875,28 +1211,28 @@ namespace std {
       mismatch(InputIterator1 first1, InputIterator1 last1,
                InputIterator2 first2, InputIterator2 last2,
                BinaryPredicate pred);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
     pair<ForwardIterator1, ForwardIterator2>
-      mismatch(ExecutionPolicy&& exec,                          // see [algorithms.parallel.overloads]
                ForwardIterator1 first1, ForwardIterator1 last1,
                ForwardIterator2 first2);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class BinaryPredicate>
     pair<ForwardIterator1, ForwardIterator2>
-      mismatch(ExecutionPolicy&& exec,                          // see [algorithms.parallel.overloads]
                ForwardIterator1 first1, ForwardIterator1 last1,
                ForwardIterator2 first2, BinaryPredicate pred);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
     pair<ForwardIterator1, ForwardIterator2>
-      mismatch(ExecutionPolicy&& exec,                          // see [algorithms.parallel.overloads]
                ForwardIterator1 first1, ForwardIterator1 last1,
                ForwardIterator2 first2, ForwardIterator2 last2);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class BinaryPredicate>
     pair<ForwardIterator1, ForwardIterator2>
-      mismatch(ExecutionPolicy&& exec,                          // see [algorithms.parallel.overloads]
                ForwardIterator1 first1, ForwardIterator1 last1,
                ForwardIterator2 first2, ForwardIterator2 last2,
                BinaryPredicate pred);
   namespace ranges {
@@ -913,10 +1249,24 @@ namespace std {
              class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
       requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
       constexpr mismatch_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
         mismatch(R1&& r1, R2&& r2, Pred pred = {},
                  Proj1 proj1 = {}, Proj2 proj2 = {});
   }
   // [alg.equal], equal
   template<class InputIterator1, class InputIterator2>
     constexpr bool equal(InputIterator1 first1, InputIterator1 last1,
@@ -930,25 +1280,25 @@ namespace std {
   template<class InputIterator1, class InputIterator2, class BinaryPredicate>
     constexpr bool equal(InputIterator1 first1, InputIterator1 last1,
                          InputIterator2 first2, InputIterator2 last2,
                          BinaryPredicate pred);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
-    bool equal(ExecutionPolicy&& exec,                          // see [algorithms.parallel.overloads]
                ForwardIterator1 first1, ForwardIterator1 last1,
                ForwardIterator2 first2);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class BinaryPredicate>
-    bool equal(ExecutionPolicy&& exec,                          // see [algorithms.parallel.overloads]
                ForwardIterator1 first1, ForwardIterator1 last1,
                ForwardIterator2 first2, BinaryPredicate pred);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
-    bool equal(ExecutionPolicy&& exec,                          // see [algorithms.parallel.overloads]
                ForwardIterator1 first1, ForwardIterator1 last1,
                ForwardIterator2 first2, ForwardIterator2 last2);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class BinaryPredicate>
-    bool equal(ExecutionPolicy&& exec,                          // see [algorithms.parallel.overloads]
                ForwardIterator1 first1, ForwardIterator1 last1,
                ForwardIterator2 first2, ForwardIterator2 last2,
                BinaryPredicate pred);
   namespace ranges {
@@ -961,10 +1311,22 @@ namespace std {
     template<input_range R1, input_range R2, class Pred = ranges::equal_to,
              class Proj1 = identity, class Proj2 = identity>
       requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
       constexpr bool equal(R1&& r1, R2&& r2, Pred pred = {},
                            Proj1 proj1 = {}, Proj2 proj2 = {});
   }
   // [alg.is.permutation], is permutation
   template<class ForwardIterator1, class ForwardIterator2>
     constexpr bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
@@ -1007,17 +1369,17 @@ namespace std {
       search(ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2,
              BinaryPredicate pred);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
     ForwardIterator1
-      search(ExecutionPolicy&& exec,                            // see [algorithms.parallel.overloads]
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class BinaryPredicate>
     ForwardIterator1
-      search(ExecutionPolicy&& exec,                            // see [algorithms.parallel.overloads]
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2,
              BinaryPredicate pred);
   namespace ranges {
@@ -1032,46 +1394,78 @@ namespace std {
              class Proj1 = identity, class Proj2 = identity>
       requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
       constexpr borrowed_subrange_t<R1>
         search(R1&& r1, R2&& r2, Pred pred = {},
                Proj1 proj1 = {}, Proj2 proj2 = {});
   }
-  template<class ForwardIterator, class Size, class T>
     constexpr ForwardIterator
       search_n(ForwardIterator first, ForwardIterator last,
                Size count, const T& value);
-  template<class ForwardIterator, class Size, class T, class BinaryPredicate>
     constexpr ForwardIterator
       search_n(ForwardIterator first, ForwardIterator last,
                Size count, const T& value, BinaryPredicate pred);
-  template<class ExecutionPolicy, class ForwardIterator, class Size, class T>
     ForwardIterator
-      search_n(ExecutionPolicy&& exec,                          // see [algorithms.parallel.overloads]
                ForwardIterator first, ForwardIterator last,
                Size count, const T& value);
-  template<class ExecutionPolicy, class ForwardIterator, class Size, class T,
-           class BinaryPredicate>
     ForwardIterator
-      search_n(ExecutionPolicy&& exec,                          // see [algorithms.parallel.overloads]
                ForwardIterator first, ForwardIterator last,
                Size count, const T& value,
                BinaryPredicate pred);
   namespace ranges {
-    template<forward_iterator I, sentinel_for<I> S, class T,
-             class Pred = ranges::equal_to, class Proj = identity>
       requires indirectly_comparable<I, const T*, Pred, Proj>
       constexpr subrange<I>
         search_n(I first, S last, iter_difference_t<I> count,
                  const T& value, Pred pred = {}, Proj proj = {});
-    template<forward_range R, class T, class Pred = ranges::equal_to,
-             class Proj = identity>
       requires indirectly_comparable<iterator_t<R>, const T*, Pred, Proj>
       constexpr borrowed_subrange_t<R>
         search_n(R&& r, range_difference_t<R> count,
                  const T& value, Pred pred = {}, Proj proj = {});
   }
   template<class ForwardIterator, class Searcher>
     constexpr ForwardIterator
       search(ForwardIterator first, ForwardIterator last, const Searcher& searcher);
@@ -1087,10 +1481,23 @@ namespace std {
              class Proj1 = identity, class Proj2 = identity>
       requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
       constexpr bool starts_with(R1&& r1, R2&& r2, Pred pred = {},
                                  Proj1 proj1 = {}, Proj2 proj2 = {});
     // [alg.ends.with], ends with
     template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
              class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
       requires (forward_iterator<I1> || sized_sentinel_for<S1, I1>) &&
                (forward_iterator<I2> || sized_sentinel_for<S2, I2>) &&
@@ -1103,10 +1510,23 @@ namespace std {
                (forward_range<R2> || sized_range<R2>) &&
                indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
       constexpr bool ends_with(R1&& r1, R2&& r2, Pred pred = {},
                                Proj1 proj1 = {}, Proj2 proj2 = {});
     // [alg.fold], fold
     template<class F>
     class flipped {     // exposition only
       F f;              // exposition only
@@ -1132,15 +1552,16 @@ namespace std {
     template<class F, class T, class I>
       concept indirectly-binary-right-foldable =    // exposition only
         indirectly-binary-left-foldable<flipped<F>, T, I>;
-    template<input_iterator I, sentinel_for<I> S, class T,
              indirectly-binary-left-foldable<T, I> F>
       constexpr auto fold_left(I first, S last, T init, F f);
-    template<input_range R, class T, indirectly-binary-left-foldable<T, iterator_t<R>> F>
       constexpr auto fold_left(R&& r, T init, F f);
     template<input_iterator I, sentinel_for<I> S,
              indirectly-binary-left-foldable<iter_value_t<I>, I> F>
       requires constructible_from<iter_value_t<I>, iter_reference_t<I>>
@@ -1148,15 +1569,15 @@ namespace std {
     template<input_range R, indirectly-binary-left-foldable<range_value_t<R>, iterator_t<R>> F>
       requires constructible_from<range_value_t<R>, range_reference_t<R>>
       constexpr auto fold_left_first(R&& r, F f);
-    template<bidirectional_iterator I, sentinel_for<I> S, class T,
              indirectly-binary-right-foldable<T, I> F>
       constexpr auto fold_right(I first, S last, T init, F f);
-    template<bidirectional_range R, class T,
              indirectly-binary-right-foldable<T, iterator_t<R>> F>
       constexpr auto fold_right(R&& r, T init, F f);
     template<bidirectional_iterator I, sentinel_for<I> S,
              indirectly-binary-right-foldable<iter_value_t<I>, I> F>
@@ -1171,15 +1592,16 @@ namespace std {
     template<class I, class T>
       using fold_left_with_iter_result = in_value_result<I, T>;
     template<class I, class T>
       using fold_left_first_with_iter_result = in_value_result<I, T>;
-    template<input_iterator I, sentinel_for<I> S, class T,
              indirectly-binary-left-foldable<T, I> F>
       constexpr see below fold_left_with_iter(I first, S last, T init, F f);
-    template<input_range R, class T, indirectly-binary-left-foldable<T, iterator_t<R>> F>
       constexpr see below fold_left_with_iter(R&& r, T init, F f);
     template<input_iterator I, sentinel_for<I> S,
              indirectly-binary-left-foldable<iter_value_t<I>, I> F>
       requires constructible_from<iter_value_t<I>, iter_reference_t<I>>
@@ -1195,11 +1617,11 @@ namespace std {
   // [alg.copy], copy
   template<class InputIterator, class OutputIterator>
     constexpr OutputIterator copy(InputIterator first, InputIterator last,
                                   OutputIterator result);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
-    ForwardIterator2 copy(ExecutionPolicy&& exec,               // see [algorithms.parallel.overloads]
                           ForwardIterator1 first, ForwardIterator1 last,
                           ForwardIterator2 result);
   namespace ranges {
     template<class I, class O>
@@ -1211,18 +1633,28 @@ namespace std {
         copy(I first, S last, O result);
     template<input_range R, weakly_incrementable O>
       requires indirectly_copyable<iterator_t<R>, O>
       constexpr copy_result<borrowed_iterator_t<R>, O>
         copy(R&& r, O result);
   }
   template<class InputIterator, class Size, class OutputIterator>
     constexpr OutputIterator copy_n(InputIterator first, Size n,
                                     OutputIterator result);
   template<class ExecutionPolicy, class ForwardIterator1, class Size,
            class ForwardIterator2>
-    ForwardIterator2 copy_n(ExecutionPolicy&& exec,             // see [algorithms.parallel.overloads]
                             ForwardIterator1 first, Size n,
                             ForwardIterator2 result);
   namespace ranges {
     template<class I, class O>
@@ -1230,18 +1662,25 @@ namespace std {
     template<input_iterator I, weakly_incrementable O>
       requires indirectly_copyable<I, O>
       constexpr copy_n_result<I, O>
         copy_n(I first, iter_difference_t<I> n, O result);
   }
   template<class InputIterator, class OutputIterator, class Predicate>
     constexpr OutputIterator copy_if(InputIterator first, InputIterator last,
                                      OutputIterator result, Predicate pred);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class Predicate>
-    ForwardIterator2 copy_if(ExecutionPolicy&& exec,            // see [algorithms.parallel.overloads]
                              ForwardIterator1 first, ForwardIterator1 last,
                              ForwardIterator2 result, Predicate pred);
   namespace ranges {
     template<class I, class O>
@@ -1255,10 +1694,25 @@ namespace std {
     template<input_range R, weakly_incrementable O, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       requires indirectly_copyable<iterator_t<R>, O>
       constexpr copy_if_result<borrowed_iterator_t<R>, O>
         copy_if(R&& r, O result, Pred pred, Proj proj = {});
   }
   template<class BidirectionalIterator1, class BidirectionalIterator2>
     constexpr BidirectionalIterator2
       copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
@@ -1282,11 +1736,11 @@ namespace std {
   template<class InputIterator, class OutputIterator>
     constexpr OutputIterator move(InputIterator first, InputIterator last,
                                   OutputIterator result);
   template<class ExecutionPolicy, class ForwardIterator1,
            class ForwardIterator2>
-    ForwardIterator2 move(ExecutionPolicy&& exec,               // see [algorithms.parallel.overloads]
                           ForwardIterator1 first, ForwardIterator1 last,
                           ForwardIterator2 result);
   namespace ranges {
     template<class I, class O>
@@ -1298,10 +1752,20 @@ namespace std {
         move(I first, S last, O result);
     template<input_range R, weakly_incrementable O>
       requires indirectly_movable<iterator_t<R>, O>
       constexpr move_result<borrowed_iterator_t<R>, O>
         move(R&& r, O result);
   }
   template<class BidirectionalIterator1, class BidirectionalIterator2>
     constexpr BidirectionalIterator2
       move_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
@@ -1324,11 +1788,11 @@ namespace std {
   // [alg.swap], swap
   template<class ForwardIterator1, class ForwardIterator2>
     constexpr ForwardIterator2 swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1,
                                            ForwardIterator2 first2);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
-    ForwardIterator2 swap_ranges(ExecutionPolicy&& exec,        // see [algorithms.parallel.overloads]
                                  ForwardIterator1 first1, ForwardIterator1 last1,
                                  ForwardIterator2 first2);
   namespace ranges {
     template<class I1, class I2>
@@ -1340,10 +1804,20 @@ namespace std {
         swap_ranges(I1 first1, S1 last1, I2 first2, S2 last2);
     template<input_range R1, input_range R2>
       requires indirectly_swappable<iterator_t<R1>, iterator_t<R2>>
       constexpr swap_ranges_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
         swap_ranges(R1&& r1, R2&& r2);
   }
   template<class ForwardIterator1, class ForwardIterator2>
     constexpr void iter_swap(ForwardIterator1 a, ForwardIterator2 b);
@@ -1359,17 +1833,17 @@ namespace std {
                 InputIterator2 first2, OutputIterator result,
                 BinaryOperation binary_op);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class UnaryOperation>
     ForwardIterator2
-      transform(ExecutionPolicy&& exec,                         // see [algorithms.parallel.overloads]
                 ForwardIterator1 first1, ForwardIterator1 last1,
                 ForwardIterator2 result, UnaryOperation op);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator, class BinaryOperation>
     ForwardIterator
-      transform(ExecutionPolicy&& exec,                         // see [algorithms.parallel.overloads]
                 ForwardIterator1 first1, ForwardIterator1 last1,
                 ForwardIterator2 first2, ForwardIterator result,
                 BinaryOperation binary_op);
   namespace ranges {
@@ -1385,10 +1859,24 @@ namespace std {
              class Proj = identity>
       requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R>, Proj>>>
       constexpr unary_transform_result<borrowed_iterator_t<R>, O>
         transform(R&& r, O result, F op, Proj proj = {});
     template<class I1, class I2, class O>
       using binary_transform_result = in_in_out_result<I1, I2, O>;
     template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
              weakly_incrementable O, copy_constructible F, class Proj1 = identity,
@@ -1403,142 +1891,256 @@ namespace std {
       requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R1>, Proj1>,
                                    projected<iterator_t<R2>, Proj2>>>
       constexpr binary_transform_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
         transform(R1&& r1, R2&& r2, O result,
                   F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});
   }
   // [alg.replace], replace
   template<class ForwardIterator, class T>
     constexpr void replace(ForwardIterator first, ForwardIterator last,
                            const T& old_value, const T& new_value);
-  template<class ExecutionPolicy, class ForwardIterator, class T>
-    void replace(ExecutionPolicy&& exec,                        // see [algorithms.parallel.overloads]
                  ForwardIterator first, ForwardIterator last,
                  const T& old_value, const T& new_value);
-  template<class ForwardIterator, class Predicate, class T>
     constexpr void replace_if(ForwardIterator first, ForwardIterator last,
                               Predicate pred, const T& new_value);
-  template<class ExecutionPolicy, class ForwardIterator, class Predicate, class T>
-    void replace_if(ExecutionPolicy&& exec,                     // see [algorithms.parallel.overloads]
                     ForwardIterator first, ForwardIterator last,
                     Predicate pred, const T& new_value);
   namespace ranges {
-    template<input_iterator I, sentinel_for<I> S, class T1, class T2, class Proj = identity>
       requires indirectly_writable<I, const T2&> &&
                indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*>
       constexpr I
         replace(I first, S last, const T1& old_value, const T2& new_value, Proj proj = {});
-    template<input_range R, class T1, class T2, class Proj = identity>
       requires indirectly_writable<iterator_t<R>, const T2&> &&
                indirect_binary_predicate<ranges::equal_to,
                                          projected<iterator_t<R>, Proj>, const T1*>
       constexpr borrowed_iterator_t<R>
         replace(R&& r, const T1& old_value, const T2& new_value, Proj proj = {});
-    template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity,
              indirect_unary_predicate<projected<I, Proj>> Pred>
       requires indirectly_writable<I, const T&>
       constexpr I replace_if(I first, S last, Pred pred, const T& new_value, Proj proj = {});
-    template<input_range R, class T, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       requires indirectly_writable<iterator_t<R>, const T&>
       constexpr borrowed_iterator_t<R>
         replace_if(R&& r, Pred pred, const T& new_value, Proj proj = {});
   }
   template<class InputIterator, class OutputIterator, class T>
     constexpr OutputIterator replace_copy(InputIterator first, InputIterator last,
                                           OutputIterator result,
                                           const T& old_value, const T& new_value);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class T>
-    ForwardIterator2 replace_copy(ExecutionPolicy&& exec,       // see [algorithms.parallel.overloads]
                                   ForwardIterator1 first, ForwardIterator1 last,
                                   ForwardIterator2 result,
                                   const T& old_value, const T& new_value);
-  template<class InputIterator, class OutputIterator, class Predicate, class T>
     constexpr OutputIterator replace_copy_if(InputIterator first, InputIterator last,
                                              OutputIterator result,
                                              Predicate pred, const T& new_value);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
-           class Predicate, class T>
-    ForwardIterator2 replace_copy_if(ExecutionPolicy&& exec,    // see [algorithms.parallel.overloads]
                                      ForwardIterator1 first, ForwardIterator1 last,
                                      ForwardIterator2 result,
                                      Predicate pred, const T& new_value);
   namespace ranges {
     template<class I, class O>
       using replace_copy_result = in_out_result<I, O>;
-    template<input_iterator I, sentinel_for<I> S, class T1, class T2,
- output_iterator<const T2&> O, class Proj = identity>
       requires indirectly_copyable<I, O> &&
-               indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*>
       constexpr replace_copy_result<I, O>
         replace_copy(I first, S last, O result, const T1& old_value, const T2& new_value,
                      Proj proj = {});
-    template<input_range R, class T1, class T2, output_iterator<const T2&> O,
-             class Proj = identity>
       requires indirectly_copyable<iterator_t<R>, O> &&
                indirect_binary_predicate<ranges::equal_to,
-                                         projected<iterator_t<R>, Proj>, const T1*>
       constexpr replace_copy_result<borrowed_iterator_t<R>, O>
         replace_copy(R&& r, O result, const T1& old_value, const T2& new_value,
                      Proj proj = {});
     template<class I, class O>
       using replace_copy_if_result = in_out_result<I, O>;
-    template<input_iterator I, sentinel_for<I> S, class T, output_iterator<const T&> O,
              class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
-      requires indirectly_copyable<I, O>
       constexpr replace_copy_if_result<I, O>
         replace_copy_if(I first, S last, O result, Pred pred, const T& new_value,
                         Proj proj = {});
-    template<input_range R, class T, output_iterator<const T&> O, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
-      requires indirectly_copyable<iterator_t<R>, O>
       constexpr replace_copy_if_result<borrowed_iterator_t<R>, O>
         replace_copy_if(R&& r, O result, Pred pred, const T& new_value,
                         Proj proj = {});
   }
   // [alg.fill], fill
-  template<class ForwardIterator, class T>
     constexpr void fill(ForwardIterator first, ForwardIterator last, const T& value);
-  template<class ExecutionPolicy, class ForwardIterator, class T>
-    void fill(ExecutionPolicy&& exec,                           // see [algorithms.parallel.overloads]
               ForwardIterator first, ForwardIterator last, const T& value);
-  template<class OutputIterator, class Size, class T>
-    constexpr OutputIterator fill_n(OutputIterator first, Size n, const T& value);
   template<class ExecutionPolicy, class ForwardIterator,
-           class Size, class T>
-    ForwardIterator fill_n(ExecutionPolicy&& exec,              // see [algorithms.parallel.overloads]
                            ForwardIterator first, Size n, const T& value);
   namespace ranges {
-    template<class T, output_iterator<const T&> O, sentinel_for<O> S>
       constexpr O fill(O first, S last, const T& value);
-    template<class T, output_range<const T&> R>
       constexpr borrowed_iterator_t<R> fill(R&& r, const T& value);
-    template<class T, output_iterator<const T&> O>
       constexpr O fill_n(O first, iter_difference_t<O> n, const T& value);
   }
   // [alg.generate], generate
   template<class ForwardIterator, class Generator>
     constexpr void generate(ForwardIterator first, ForwardIterator last,
                             Generator gen);
   template<class ExecutionPolicy, class ForwardIterator, class Generator>
-    void generate(ExecutionPolicy&& exec,                       // see [algorithms.parallel.overloads]
                   ForwardIterator first, ForwardIterator last,
                   Generator gen);
   template<class OutputIterator, class Size, class Generator>
     constexpr OutputIterator generate_n(OutputIterator first, Size n, Generator gen);
   template<class ExecutionPolicy, class ForwardIterator, class Size, class Generator>
-    ForwardIterator generate_n(ExecutionPolicy&& exec,          // see [algorithms.parallel.overloads]
                                ForwardIterator first, Size n, Generator gen);
   namespace ranges {
     template<input_or_output_iterator O, sentinel_for<O> S, copy_constructible F>
       requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
@@ -1547,86 +2149,142 @@ namespace std {
       requires invocable<F&> && output_range<R, invoke_result_t<F&>>
       constexpr borrowed_iterator_t<R> generate(R&& r, F gen);
     template<input_or_output_iterator O, copy_constructible F>
       requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
       constexpr O generate_n(O first, iter_difference_t<O> n, F gen);
   }
   // [alg.remove], remove
-  template<class ForwardIterator, class T>
     constexpr ForwardIterator remove(ForwardIterator first, ForwardIterator last,
                                      const T& value);
-  template<class ExecutionPolicy, class ForwardIterator, class T>
-    ForwardIterator remove(ExecutionPolicy&& exec,              // see [algorithms.parallel.overloads]
                            ForwardIterator first, ForwardIterator last,
                            const T& value);
   template<class ForwardIterator, class Predicate>
     constexpr ForwardIterator remove_if(ForwardIterator first, ForwardIterator last,
                                         Predicate pred);
   template<class ExecutionPolicy, class ForwardIterator, class Predicate>
-    ForwardIterator remove_if(ExecutionPolicy&& exec,           // see [algorithms.parallel.overloads]
                               ForwardIterator first, ForwardIterator last,
                               Predicate pred);
   namespace ranges {
-    template<permutable I, sentinel_for<I> S, class T, class Proj = identity>
       requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
       constexpr subrange<I> remove(I first, S last, const T& value, Proj proj = {});
-    template<forward_range R, class T, class Proj = identity>
       requires permutable<iterator_t<R>> &&
                indirect_binary_predicate<ranges::equal_to,
                                          projected<iterator_t<R>, Proj>, const T*>
       constexpr borrowed_subrange_t<R>
         remove(R&& r, const T& value, Proj proj = {});
     template<permutable I, sentinel_for<I> S, class Proj = identity,
              indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr subrange<I> remove_if(I first, S last, Pred pred, Proj proj = {});
     template<forward_range R, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       requires permutable<iterator_t<R>>
       constexpr borrowed_subrange_t<R>
         remove_if(R&& r, Pred pred, Proj proj = {});
   }
-  template<class InputIterator, class OutputIterator, class T>
     constexpr OutputIterator
       remove_copy(InputIterator first, InputIterator last,
                   OutputIterator result, const T& value);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
-           class T>
     ForwardIterator2
-      remove_copy(ExecutionPolicy&& exec,                       // see [algorithms.parallel.overloads]
                   ForwardIterator1 first, ForwardIterator1 last,
                   ForwardIterator2 result, const T& value);
   template<class InputIterator, class OutputIterator, class Predicate>
     constexpr OutputIterator
       remove_copy_if(InputIterator first, InputIterator last,
                      OutputIterator result, Predicate pred);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class Predicate>
     ForwardIterator2
-      remove_copy_if(ExecutionPolicy&& exec,                    // see [algorithms.parallel.overloads]
                      ForwardIterator1 first, ForwardIterator1 last,
                      ForwardIterator2 result, Predicate pred);
   namespace ranges {
     template<class I, class O>
       using remove_copy_result = in_out_result<I, O>;
-    template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class T,
-             class Proj = identity>
       requires indirectly_copyable<I, O> &&
                indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
       constexpr remove_copy_result<I, O>
         remove_copy(I first, S last, O result, const T& value, Proj proj = {});
-    template<input_range R, weakly_incrementable O, class T, class Proj = identity>
       requires indirectly_copyable<iterator_t<R>, O> &&
                indirect_binary_predicate<ranges::equal_to,
                                          projected<iterator_t<R>, Proj>, const T*>
       constexpr remove_copy_result<borrowed_iterator_t<R>, O>
         remove_copy(R&& r, O result, const T& value, Proj proj = {});
     template<class I, class O>
       using remove_copy_if_result = in_out_result<I, O>;
     template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
              class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
@@ -1636,23 +2294,38 @@ namespace std {
     template<input_range R, weakly_incrementable O, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       requires indirectly_copyable<iterator_t<R>, O>
       constexpr remove_copy_if_result<borrowed_iterator_t<R>, O>
         remove_copy_if(R&& r, O result, Pred pred, Proj proj = {});
   }
   // [alg.unique], unique
   template<class ForwardIterator>
     constexpr ForwardIterator unique(ForwardIterator first, ForwardIterator last);
   template<class ForwardIterator, class BinaryPredicate>
     constexpr ForwardIterator unique(ForwardIterator first, ForwardIterator last,
                                      BinaryPredicate pred);
   template<class ExecutionPolicy, class ForwardIterator>
-    ForwardIterator unique(ExecutionPolicy&& exec,              // see [algorithms.parallel.overloads]
                            ForwardIterator first, ForwardIterator last);
   template<class ExecutionPolicy, class ForwardIterator, class BinaryPredicate>
-    ForwardIterator unique(ExecutionPolicy&& exec,              // see [algorithms.parallel.overloads]
                            ForwardIterator first, ForwardIterator last,
                            BinaryPredicate pred);
   namespace ranges {
     template<permutable I, sentinel_for<I> S, class Proj = identity,
@@ -1661,10 +2334,22 @@ namespace std {
     template<forward_range R, class Proj = identity,
              indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
       requires permutable<iterator_t<R>>
       constexpr borrowed_subrange_t<R>
         unique(R&& r, C comp = {}, Proj proj = {});
   }
   template<class InputIterator, class OutputIterator>
     constexpr OutputIterator
       unique_copy(InputIterator first, InputIterator last,
@@ -1673,17 +2358,17 @@ namespace std {
     constexpr OutputIterator
       unique_copy(InputIterator first, InputIterator last,
                   OutputIterator result, BinaryPredicate pred);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
     ForwardIterator2
-      unique_copy(ExecutionPolicy&& exec,                       // see [algorithms.parallel.overloads]
                   ForwardIterator1 first, ForwardIterator1 last,
                   ForwardIterator2 result);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class BinaryPredicate>
     ForwardIterator2
-      unique_copy(ExecutionPolicy&& exec,                       // see [algorithms.parallel.overloads]
                   ForwardIterator1 first, ForwardIterator1 last,
                   ForwardIterator2 result, BinaryPredicate pred);
   namespace ranges {
     template<class I, class O>
@@ -1703,93 +2388,151 @@ namespace std {
                (forward_iterator<iterator_t<R>> ||
                 (input_iterator<O> && same_as<range_value_t<R>, iter_value_t<O>>) ||
                 indirectly_copyable_storable<iterator_t<R>, O>)
       constexpr unique_copy_result<borrowed_iterator_t<R>, O>
         unique_copy(R&& r, O result, C comp = {}, Proj proj = {});
   }
   // [alg.reverse], reverse
   template<class BidirectionalIterator>
     constexpr void reverse(BidirectionalIterator first, BidirectionalIterator last);
   template<class ExecutionPolicy, class BidirectionalIterator>
-    void reverse(ExecutionPolicy&& exec,                        // see [algorithms.parallel.overloads]
                  BidirectionalIterator first, BidirectionalIterator last);
   namespace ranges {
     template<bidirectional_iterator I, sentinel_for<I> S>
       requires permutable<I>
       constexpr I reverse(I first, S last);
     template<bidirectional_range R>
       requires permutable<iterator_t<R>>
       constexpr borrowed_iterator_t<R> reverse(R&& r);
   }
   template<class BidirectionalIterator, class OutputIterator>
     constexpr OutputIterator
       reverse_copy(BidirectionalIterator first, BidirectionalIterator last,
                    OutputIterator result);
   template<class ExecutionPolicy, class BidirectionalIterator, class ForwardIterator>
     ForwardIterator
-      reverse_copy(ExecutionPolicy&& exec,                      // see [algorithms.parallel.overloads]
                    BidirectionalIterator first, BidirectionalIterator last,
                    ForwardIterator result);
   namespace ranges {
     template<class I, class O>
       using reverse_copy_result = in_out_result<I, O>;
     template<bidirectional_iterator I, sentinel_for<I> S, weakly_incrementable O>
       requires indirectly_copyable<I, O>
       constexpr reverse_copy_result<I, O>
         reverse_copy(I first, S last, O result);
     template<bidirectional_range R, weakly_incrementable O>
       requires indirectly_copyable<iterator_t<R>, O>
       constexpr reverse_copy_result<borrowed_iterator_t<R>, O>
         reverse_copy(R&& r, O result);
   }
   // [alg.rotate], rotate
   template<class ForwardIterator>
     constexpr ForwardIterator rotate(ForwardIterator first,
                                      ForwardIterator middle,
                                      ForwardIterator last);
   template<class ExecutionPolicy, class ForwardIterator>
-    ForwardIterator rotate(ExecutionPolicy&& exec,              // see [algorithms.parallel.overloads]
                            ForwardIterator first,
                            ForwardIterator middle,
                            ForwardIterator last);
   namespace ranges {
     template<permutable I, sentinel_for<I> S>
       constexpr subrange<I> rotate(I first, I middle, S last);
     template<forward_range R>
       requires permutable<iterator_t<R>>
       constexpr borrowed_subrange_t<R> rotate(R&& r, iterator_t<R> middle);
   }
   template<class ForwardIterator, class OutputIterator>
     constexpr OutputIterator
       rotate_copy(ForwardIterator first, ForwardIterator middle,
                   ForwardIterator last, OutputIterator result);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
     ForwardIterator2
-      rotate_copy(ExecutionPolicy&& exec,                       // see [algorithms.parallel.overloads]
                   ForwardIterator1 first, ForwardIterator1 middle,
                   ForwardIterator1 last, ForwardIterator2 result);
   namespace ranges {
     template<class I, class O>
       using rotate_copy_result = in_out_result<I, O>;
     template<forward_iterator I, sentinel_for<I> S, weakly_incrementable O>
       requires indirectly_copyable<I, O>
       constexpr rotate_copy_result<I, O>
         rotate_copy(I first, I middle, S last, O result);
     template<forward_range R, weakly_incrementable O>
       requires indirectly_copyable<iterator_t<R>, O>
       constexpr rotate_copy_result<borrowed_iterator_t<R>, O>
         rotate_copy(R&& r, iterator_t<R> middle, O result);
   }
   // [alg.random.sample], sample
   template<class PopulationIterator, class SampleIterator,
            class Distance, class UniformRandomBitGenerator>
@@ -1833,52 +2576,70 @@ namespace std {
     constexpr ForwardIterator
       shift_left(ForwardIterator first, ForwardIterator last,
                  typename iterator_traits<ForwardIterator>::difference_type n);
   template<class ExecutionPolicy, class ForwardIterator>
     ForwardIterator
-      shift_left(ExecutionPolicy&& exec,                        // see [algorithms.parallel.overloads]
                  ForwardIterator first, ForwardIterator last,
                  typename iterator_traits<ForwardIterator>::difference_type n);
   namespace ranges {
     template<permutable I, sentinel_for<I> S>
       constexpr subrange<I> shift_left(I first, S last, iter_difference_t<I> n);
     template<forward_range R>
       requires permutable<iterator_t<R>>
       constexpr borrowed_subrange_t<R> shift_left(R&& r, range_difference_t<R> n);
   }
   template<class ForwardIterator>
     constexpr ForwardIterator
       shift_right(ForwardIterator first, ForwardIterator last,
                   typename iterator_traits<ForwardIterator>::difference_type n);
   template<class ExecutionPolicy, class ForwardIterator>
     ForwardIterator
-      shift_right(ExecutionPolicy&& exec,                       // see [algorithms.parallel.overloads]
                   ForwardIterator first, ForwardIterator last,
                   typename iterator_traits<ForwardIterator>::difference_type n);
   namespace ranges {
     template<permutable I, sentinel_for<I> S>
       constexpr subrange<I> shift_right(I first, S last, iter_difference_t<I> n);
     template<forward_range R>
       requires permutable<iterator_t<R>>
       constexpr borrowed_subrange_t<R> shift_right(R&& r, range_difference_t<R> n);
   }
   // [alg.sorting], sorting and related operations
   // [alg.sort], sorting
   template<class RandomAccessIterator>
     constexpr void sort(RandomAccessIterator first, RandomAccessIterator last);
   template<class RandomAccessIterator, class Compare>
     constexpr void sort(RandomAccessIterator first, RandomAccessIterator last,
                         Compare comp);
   template<class ExecutionPolicy, class RandomAccessIterator>
-    void sort(ExecutionPolicy&& exec,                           // see [algorithms.parallel.overloads]
               RandomAccessIterator first, RandomAccessIterator last);
   template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
-    void sort(ExecutionPolicy&& exec,                           // see [algorithms.parallel.overloads]
               RandomAccessIterator first, RandomAccessIterator last,
               Compare comp);
   namespace ranges {
     template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
@@ -1888,48 +2649,69 @@ namespace std {
         sort(I first, S last, Comp comp = {}, Proj proj = {});
     template<random_access_range R, class Comp = ranges::less, class Proj = identity>
       requires sortable<iterator_t<R>, Comp, Proj>
       constexpr borrowed_iterator_t<R>
         sort(R&& r, Comp comp = {}, Proj proj = {});
   }
   template<class RandomAccessIterator>
-    void stable_sort(RandomAccessIterator first, RandomAccessIterator last);
   template<class RandomAccessIterator, class Compare>
-    void stable_sort(RandomAccessIterator first, RandomAccessIterator last,
                                Compare comp);
   template<class ExecutionPolicy, class RandomAccessIterator>
-    void stable_sort(ExecutionPolicy&& exec,                    // see [algorithms.parallel.overloads]
                      RandomAccessIterator first, RandomAccessIterator last);
   template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
-    void stable_sort(ExecutionPolicy&& exec,                    // see [algorithms.parallel.overloads]
                      RandomAccessIterator first, RandomAccessIterator last,
                      Compare comp);
   namespace ranges {
     template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
              class Proj = identity>
       requires sortable<I, Comp, Proj>
-      I stable_sort(I first, S last, Comp comp = {}, Proj proj = {});
     template<random_access_range R, class Comp = ranges::less, class Proj = identity>
       requires sortable<iterator_t<R>, Comp, Proj>
       borrowed_iterator_t<R>
-        stable_sort(R&& r, Comp comp = {}, Proj proj = {});
   }
   template<class RandomAccessIterator>
     constexpr void partial_sort(RandomAccessIterator first, RandomAccessIterator middle,
                                 RandomAccessIterator last);
   template<class RandomAccessIterator, class Compare>
     constexpr void partial_sort(RandomAccessIterator first, RandomAccessIterator middle,
                                 RandomAccessIterator last, Compare comp);
   template<class ExecutionPolicy, class RandomAccessIterator>
-    void partial_sort(ExecutionPolicy&& exec,                   // see [algorithms.parallel.overloads]
                       RandomAccessIterator first, RandomAccessIterator middle,
                       RandomAccessIterator last);
   template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
-    void partial_sort(ExecutionPolicy&& exec,                   // see [algorithms.parallel.overloads]
                       RandomAccessIterator first, RandomAccessIterator middle,
                       RandomAccessIterator last, Compare comp);
   namespace ranges {
     template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
@@ -1940,10 +2722,22 @@ namespace std {
     template<random_access_range R, class Comp = ranges::less, class Proj = identity>
       requires sortable<iterator_t<R>, Comp, Proj>
       constexpr borrowed_iterator_t<R>
         partial_sort(R&& r, iterator_t<R> middle, Comp comp = {},
                      Proj proj = {});
   }
   template<class InputIterator, class RandomAccessIterator>
     constexpr RandomAccessIterator
       partial_sort_copy(InputIterator first, InputIterator last,
@@ -1955,18 +2749,18 @@ namespace std {
                         RandomAccessIterator result_first,
                         RandomAccessIterator result_last,
                         Compare comp);
   template<class ExecutionPolicy, class ForwardIterator, class RandomAccessIterator>
     RandomAccessIterator
-      partial_sort_copy(ExecutionPolicy&& exec,                 // see [algorithms.parallel.overloads]
                         ForwardIterator first, ForwardIterator last,
                         RandomAccessIterator result_first,
                         RandomAccessIterator result_last);
   template<class ExecutionPolicy, class ForwardIterator, class RandomAccessIterator,
            class Compare>
     RandomAccessIterator
-      partial_sort_copy(ExecutionPolicy&& exec,                 // see [algorithms.parallel.overloads]
                         ForwardIterator first, ForwardIterator last,
                         RandomAccessIterator result_first,
                         RandomAccessIterator result_last,
                         Compare comp);
@@ -1989,32 +2783,60 @@ namespace std {
                indirect_strict_weak_order<Comp, projected<iterator_t<R1>, Proj1>,
                                           projected<iterator_t<R2>, Proj2>>
       constexpr partial_sort_copy_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
         partial_sort_copy(R1&& r, R2&& result_r, Comp comp = {},
                           Proj1 proj1 = {}, Proj2 proj2 = {});
   }
   template<class ForwardIterator>
     constexpr bool is_sorted(ForwardIterator first, ForwardIterator last);
   template<class ForwardIterator, class Compare>
     constexpr bool is_sorted(ForwardIterator first, ForwardIterator last,
                              Compare comp);
   template<class ExecutionPolicy, class ForwardIterator>
-    bool is_sorted(ExecutionPolicy&& exec,                      // see [algorithms.parallel.overloads]
                    ForwardIterator first, ForwardIterator last);
   template<class ExecutionPolicy, class ForwardIterator, class Compare>
-    bool is_sorted(ExecutionPolicy&& exec,                      // see [algorithms.parallel.overloads]
                    ForwardIterator first, ForwardIterator last,
                    Compare comp);
   namespace ranges {
     template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
              indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
       constexpr bool is_sorted(I first, S last, Comp comp = {}, Proj proj = {});
     template<forward_range R, class Proj = identity,
              indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       constexpr bool is_sorted(R&& r, Comp comp = {}, Proj proj = {});
   }
   template<class ForwardIterator>
     constexpr ForwardIterator
       is_sorted_until(ForwardIterator first, ForwardIterator last);
@@ -2022,15 +2844,15 @@ namespace std {
     constexpr ForwardIterator
       is_sorted_until(ForwardIterator first, ForwardIterator last,
                       Compare comp);
   template<class ExecutionPolicy, class ForwardIterator>
     ForwardIterator
-      is_sorted_until(ExecutionPolicy&& exec,                   // see [algorithms.parallel.overloads]
                       ForwardIterator first, ForwardIterator last);
   template<class ExecutionPolicy, class ForwardIterator, class Compare>
     ForwardIterator
-      is_sorted_until(ExecutionPolicy&& exec,                   // see [algorithms.parallel.overloads]
                       ForwardIterator first, ForwardIterator last,
                       Compare comp);
   namespace ranges {
     template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
@@ -2038,25 +2860,35 @@ namespace std {
       constexpr I is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {});
     template<forward_range R, class Proj = identity,
              indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       constexpr borrowed_iterator_t<R>
         is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});
   }
   // [alg.nth.element], Nth element
   template<class RandomAccessIterator>
     constexpr void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
                                RandomAccessIterator last);
   template<class RandomAccessIterator, class Compare>
     constexpr void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
                                RandomAccessIterator last, Compare comp);
   template<class ExecutionPolicy, class RandomAccessIterator>
-    void nth_element(ExecutionPolicy&& exec,                    // see [algorithms.parallel.overloads]
                      RandomAccessIterator first, RandomAccessIterator nth,
                      RandomAccessIterator last);
   template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
-    void nth_element(ExecutionPolicy&& exec,                    // see [algorithms.parallel.overloads]
                      RandomAccessIterator first, RandomAccessIterator nth,
                      RandomAccessIterator last, Compare comp);
   namespace ranges {
     template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
@@ -2066,118 +2898,150 @@ namespace std {
         nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {});
     template<random_access_range R, class Comp = ranges::less, class Proj = identity>
       requires sortable<iterator_t<R>, Comp, Proj>
       constexpr borrowed_iterator_t<R>
         nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {});
   }
   // [alg.binary.search], binary search
-  template<class ForwardIterator, class T>
     constexpr ForwardIterator
       lower_bound(ForwardIterator first, ForwardIterator last,
                   const T& value);
-  template<class ForwardIterator, class T, class Compare>
     constexpr ForwardIterator
       lower_bound(ForwardIterator first, ForwardIterator last,
                   const T& value, Compare comp);
   namespace ranges {
-    template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
              indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
       constexpr I lower_bound(I first, S last, const T& value, Comp comp = {},
                               Proj proj = {});
-    template<forward_range R, class T, class Proj = identity,
              indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
                ranges::less>
       constexpr borrowed_iterator_t<R>
         lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
   }
-  template<class ForwardIterator, class T>
     constexpr ForwardIterator
       upper_bound(ForwardIterator first, ForwardIterator last,
                   const T& value);
-  template<class ForwardIterator, class T, class Compare>
     constexpr ForwardIterator
       upper_bound(ForwardIterator first, ForwardIterator last,
                   const T& value, Compare comp);
   namespace ranges {
-    template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
              indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
       constexpr I upper_bound(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
-    template<forward_range R, class T, class Proj = identity,
              indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
                ranges::less>
       constexpr borrowed_iterator_t<R>
         upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
   }
-  template<class ForwardIterator, class T>
     constexpr pair<ForwardIterator, ForwardIterator>
       equal_range(ForwardIterator first, ForwardIterator last,
                   const T& value);
-  template<class ForwardIterator, class T, class Compare>
     constexpr pair<ForwardIterator, ForwardIterator>
       equal_range(ForwardIterator first, ForwardIterator last,
                   const T& value, Compare comp);
   namespace ranges {
-    template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
              indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
       constexpr subrange<I>
         equal_range(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
-    template<forward_range R, class T, class Proj = identity,
              indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
                ranges::less>
       constexpr borrowed_subrange_t<R>
         equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {});
   }
-  template<class ForwardIterator, class T>
     constexpr bool
       binary_search(ForwardIterator first, ForwardIterator last,
                     const T& value);
-  template<class ForwardIterator, class T, class Compare>
     constexpr bool
       binary_search(ForwardIterator first, ForwardIterator last,
                     const T& value, Compare comp);
   namespace ranges {
-    template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
              indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
       constexpr bool binary_search(I first, S last, const T& value, Comp comp = {},
                                    Proj proj = {});
-    template<forward_range R, class T, class Proj = identity,
              indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
                ranges::less>
       constexpr bool binary_search(R&& r, const T& value, Comp comp = {},
                                    Proj proj = {});
   }
   // [alg.partitions], partitions
   template<class InputIterator, class Predicate>
     constexpr bool is_partitioned(InputIterator first, InputIterator last, Predicate pred);
   template<class ExecutionPolicy, class ForwardIterator, class Predicate>
-    bool is_partitioned(ExecutionPolicy&& exec,                 // see [algorithms.parallel.overloads]
                         ForwardIterator first, ForwardIterator last, Predicate pred);
   namespace ranges {
     template<input_iterator I, sentinel_for<I> S, class Proj = identity,
              indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr bool is_partitioned(I first, S last, Pred pred, Proj proj = {});
     template<input_range R, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr bool is_partitioned(R&& r, Pred pred, Proj proj = {});
   }
   template<class ForwardIterator, class Predicate>
     constexpr ForwardIterator partition(ForwardIterator first,
                                         ForwardIterator last,
                                         Predicate pred);
   template<class ExecutionPolicy, class ForwardIterator, class Predicate>
-    ForwardIterator partition(ExecutionPolicy&& exec,           // see [algorithms.parallel.overloads]
                               ForwardIterator first,
                               ForwardIterator last,
                               Predicate pred);
   namespace ranges {
@@ -2188,31 +3052,55 @@ namespace std {
     template<forward_range R, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       requires permutable<iterator_t<R>>
       constexpr borrowed_subrange_t<R>
         partition(R&& r, Pred pred, Proj proj = {});
   }
   template<class BidirectionalIterator, class Predicate>
-    BidirectionalIterator stable_partition(BidirectionalIterator first,
                                                      BidirectionalIterator last,
                                                      Predicate pred);
   template<class ExecutionPolicy, class BidirectionalIterator, class Predicate>
-    BidirectionalIterator stable_partition(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                                           BidirectionalIterator first,
                                            BidirectionalIterator last,
                                            Predicate pred);
   namespace ranges {
     template<bidirectional_iterator I, sentinel_for<I> S, class Proj = identity,
              indirect_unary_predicate<projected<I, Proj>> Pred>
       requires permutable<I>
-      subrange<I> stable_partition(I first, S last, Pred pred, Proj proj = {});
     template<bidirectional_range R, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       requires permutable<iterator_t<R>>
-      borrowed_subrange_t<R> stable_partition(R&& r, Pred pred, Proj proj = {});
   }
   template<class InputIterator, class OutputIterator1,
            class OutputIterator2, class Predicate>
     constexpr pair<OutputIterator1, OutputIterator2>
@@ -2220,11 +3108,11 @@ namespace std {
                      OutputIterator1 out_true, OutputIterator2 out_false,
                      Predicate pred);
   template<class ExecutionPolicy, class ForwardIterator, class ForwardIterator1,
            class ForwardIterator2, class Predicate>
     pair<ForwardIterator1, ForwardIterator2>
-      partition_copy(ExecutionPolicy&& exec,                    // see [algorithms.parallel.overloads]
                      ForwardIterator first, ForwardIterator last,
                      ForwardIterator1 out_true, ForwardIterator2 out_false,
                      Predicate pred);
   namespace ranges {
@@ -2243,10 +3131,30 @@ namespace std {
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       requires indirectly_copyable<iterator_t<R>, O1> &&
                indirectly_copyable<iterator_t<R>, O2>
       constexpr partition_copy_result<borrowed_iterator_t<R>, O1, O2>
         partition_copy(R&& r, O1 out_true, O2 out_false, Pred pred, Proj proj = {});
   }
   template<class ForwardIterator, class Predicate>
     constexpr ForwardIterator
       partition_point(ForwardIterator first, ForwardIterator last,
@@ -2275,18 +3183,18 @@ namespace std {
             InputIterator2 first2, InputIterator2 last2,
             OutputIterator result, Compare comp);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator>
     ForwardIterator
-      merge(ExecutionPolicy&& exec,                             // see [algorithms.parallel.overloads]
             ForwardIterator1 first1, ForwardIterator1 last1,
             ForwardIterator2 first2, ForwardIterator2 last2,
             ForwardIterator result);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator, class Compare>
     ForwardIterator
-      merge(ExecutionPolicy&& exec,                             // see [algorithms.parallel.overloads]
             ForwardIterator1 first1, ForwardIterator1 last1,
             ForwardIterator2 first2, ForwardIterator2 last2,
             ForwardIterator result, Compare comp);
   namespace ranges {
@@ -2304,41 +3212,69 @@ namespace std {
              class Proj1 = identity, class Proj2 = identity>
       requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
       constexpr merge_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
         merge(R1&& r1, R2&& r2, O result,
               Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
   }
   template<class BidirectionalIterator>
-    void inplace_merge(BidirectionalIterator first,
                                  BidirectionalIterator middle,
                                  BidirectionalIterator last);
   template<class BidirectionalIterator, class Compare>
-    void inplace_merge(BidirectionalIterator first,
                                  BidirectionalIterator middle,
                                  BidirectionalIterator last, Compare comp);
   template<class ExecutionPolicy, class BidirectionalIterator>
-    void inplace_merge(ExecutionPolicy&& exec,                  // see [algorithms.parallel.overloads]
                        BidirectionalIterator first,
                        BidirectionalIterator middle,
                        BidirectionalIterator last);
   template<class ExecutionPolicy, class BidirectionalIterator, class Compare>
-    void inplace_merge(ExecutionPolicy&& exec,                  // see [algorithms.parallel.overloads]
                        BidirectionalIterator first,
                        BidirectionalIterator middle,
                        BidirectionalIterator last, Compare comp);
   namespace ranges {
     template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
              class Proj = identity>
       requires sortable<I, Comp, Proj>
- I inplace_merge(I first, I middle, S last, Comp comp = {}, Proj proj = {});
     template<bidirectional_range R, class Comp = ranges::less, class Proj = identity>
       requires sortable<iterator_t<R>, Comp, Proj>
       borrowed_iterator_t<R>
-        inplace_merge(R&& r, iterator_t<R> middle, Comp comp = {},
-                      Proj proj = {});
   }
   // [alg.set.operations], set operations
   template<class InputIterator1, class InputIterator2>
     constexpr bool includes(InputIterator1 first1, InputIterator1 last1,
@@ -2346,16 +3282,16 @@ namespace std {
   template<class InputIterator1, class InputIterator2, class Compare>
     constexpr bool includes(InputIterator1 first1, InputIterator1 last1,
                             InputIterator2 first2, InputIterator2 last2,
                             Compare comp);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
-    bool includes(ExecutionPolicy&& exec,                       // see [algorithms.parallel.overloads]
                   ForwardIterator1 first1, ForwardIterator1 last1,
                   ForwardIterator2 first2, ForwardIterator2 last2);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class Compare>
-    bool includes(ExecutionPolicy&& exec,                       // see [algorithms.parallel.overloads]
                   ForwardIterator1 first1, ForwardIterator1 last1,
                   ForwardIterator2 first2, ForwardIterator2 last2,
                   Compare comp);
   namespace ranges {
@@ -2369,10 +3305,24 @@ namespace std {
              class Proj2 = identity,
              indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
                                         projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
       constexpr bool includes(R1&& r1, R2&& r2, Comp comp = {},
                               Proj1 proj1 = {}, Proj2 proj2 = {});
   }
   template<class InputIterator1, class InputIterator2, class OutputIterator>
     constexpr OutputIterator
       set_union(InputIterator1 first1, InputIterator1 last1,
@@ -2384,18 +3334,18 @@ namespace std {
                 InputIterator2 first2, InputIterator2 last2,
                 OutputIterator result, Compare comp);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator>
     ForwardIterator
-      set_union(ExecutionPolicy&& exec,                         // see [algorithms.parallel.overloads]
                 ForwardIterator1 first1, ForwardIterator1 last1,
                 ForwardIterator2 first2, ForwardIterator2 last2,
                 ForwardIterator result);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator, class Compare>
     ForwardIterator
-      set_union(ExecutionPolicy&& exec,                         // see [algorithms.parallel.overloads]
                 ForwardIterator1 first1, ForwardIterator1 last1,
                 ForwardIterator2 first2, ForwardIterator2 last2,
                 ForwardIterator result, Compare comp);
   namespace ranges {
@@ -2413,10 +3363,28 @@ namespace std {
              class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
       requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
       constexpr set_union_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
         set_union(R1&& r1, R2&& r2, O result, Comp comp = {},
                   Proj1 proj1 = {}, Proj2 proj2 = {});
   }
   template<class InputIterator1, class InputIterator2, class OutputIterator>
     constexpr OutputIterator
       set_intersection(InputIterator1 first1, InputIterator1 last1,
@@ -2428,18 +3396,18 @@ namespace std {
                        InputIterator2 first2, InputIterator2 last2,
                        OutputIterator result, Compare comp);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator>
     ForwardIterator
-      set_intersection(ExecutionPolicy&& exec,                  // see [algorithms.parallel.overloads]
                        ForwardIterator1 first1, ForwardIterator1 last1,
                        ForwardIterator2 first2, ForwardIterator2 last2,
                        ForwardIterator result);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator, class Compare>
     ForwardIterator
-      set_intersection(ExecutionPolicy&& exec,                  // see [algorithms.parallel.overloads]
                        ForwardIterator1 first1, ForwardIterator1 last1,
                        ForwardIterator2 first2, ForwardIterator2 last2,
                        ForwardIterator result, Compare comp);
   namespace ranges {
@@ -2457,10 +3425,28 @@ namespace std {
              class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
       requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
       constexpr set_intersection_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
         set_intersection(R1&& r1, R2&& r2, O result,
                          Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
   }
   template<class InputIterator1, class InputIterator2, class OutputIterator>
     constexpr OutputIterator
       set_difference(InputIterator1 first1, InputIterator1 last1,
@@ -2472,18 +3458,18 @@ namespace std {
                      InputIterator2 first2, InputIterator2 last2,
                      OutputIterator result, Compare comp);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator>
     ForwardIterator
-      set_difference(ExecutionPolicy&& exec,                    // see [algorithms.parallel.overloads]
                      ForwardIterator1 first1, ForwardIterator1 last1,
                      ForwardIterator2 first2, ForwardIterator2 last2,
                      ForwardIterator result);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator, class Compare>
     ForwardIterator
-      set_difference(ExecutionPolicy&& exec,                    // see [algorithms.parallel.overloads]
                      ForwardIterator1 first1, ForwardIterator1 last1,
                      ForwardIterator2 first2, ForwardIterator2 last2,
                      ForwardIterator result, Compare comp);
   namespace ranges {
@@ -2501,10 +3487,27 @@ namespace std {
              class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
       requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
       constexpr set_difference_result<borrowed_iterator_t<R1>, O>
         set_difference(R1&& r1, R2&& r2, O result,
                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
   }
   template<class InputIterator1, class InputIterator2, class OutputIterator>
     constexpr OutputIterator
       set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
@@ -2516,18 +3519,18 @@ namespace std {
                                InputIterator2 first2, InputIterator2 last2,
                                OutputIterator result, Compare comp);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator>
     ForwardIterator
-      set_symmetric_difference(ExecutionPolicy&& exec,          // see [algorithms.parallel.overloads]
                                ForwardIterator1 first1, ForwardIterator1 last1,
                                ForwardIterator2 first2, ForwardIterator2 last2,
                                ForwardIterator result);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator, class Compare>
     ForwardIterator
-      set_symmetric_difference(ExecutionPolicy&& exec,          // see [algorithms.parallel.overloads]
                                ForwardIterator1 first1, ForwardIterator1 last1,
                                ForwardIterator2 first2, ForwardIterator2 last2,
                                ForwardIterator result, Compare comp);
   namespace ranges {
@@ -2547,10 +3550,28 @@ namespace std {
       requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
       constexpr set_symmetric_difference_result<borrowed_iterator_t<R1>,
                                                 borrowed_iterator_t<R2>, O>
         set_symmetric_difference(R1&& r1, R2&& r2, O result, Comp comp = {},
                                  Proj1 proj1 = {}, Proj2 proj2 = {});
   }
   // [alg.heap.operations], heap operations
   template<class RandomAccessIterator>
     constexpr void push_heap(RandomAccessIterator first, RandomAccessIterator last);
@@ -2628,24 +3649,33 @@ namespace std {
     constexpr bool is_heap(RandomAccessIterator first, RandomAccessIterator last);
   template<class RandomAccessIterator, class Compare>
     constexpr bool is_heap(RandomAccessIterator first, RandomAccessIterator last,
                            Compare comp);
   template<class ExecutionPolicy, class RandomAccessIterator>
-    bool is_heap(ExecutionPolicy&& exec,                        // see [algorithms.parallel.overloads]
                  RandomAccessIterator first, RandomAccessIterator last);
   template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
-    bool is_heap(ExecutionPolicy&& exec,                        // see [algorithms.parallel.overloads]
                  RandomAccessIterator first, RandomAccessIterator last,
                  Compare comp);
   namespace ranges {
     template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
              indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
       constexpr bool is_heap(I first, S last, Comp comp = {}, Proj proj = {});
     template<random_access_range R, class Proj = identity,
              indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       constexpr bool is_heap(R&& r, Comp comp = {}, Proj proj = {});
   }
   template<class RandomAccessIterator>
     constexpr RandomAccessIterator
       is_heap_until(RandomAccessIterator first, RandomAccessIterator last);
@@ -2653,15 +3683,15 @@ namespace std {
     constexpr RandomAccessIterator
       is_heap_until(RandomAccessIterator first, RandomAccessIterator last,
                     Compare comp);
   template<class ExecutionPolicy, class RandomAccessIterator>
     RandomAccessIterator
-      is_heap_until(ExecutionPolicy&& exec,                     // see [algorithms.parallel.overloads]
                     RandomAccessIterator first, RandomAccessIterator last);
   template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
     RandomAccessIterator
-      is_heap_until(ExecutionPolicy&& exec,                     // see [algorithms.parallel.overloads]
                     RandomAccessIterator first, RandomAccessIterator last,
                     Compare comp);
   namespace ranges {
     template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
@@ -2669,10 +3699,20 @@ namespace std {
       constexpr I is_heap_until(I first, S last, Comp comp = {}, Proj proj = {});
     template<random_access_range R, class Proj = identity,
              indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       constexpr borrowed_iterator_t<R>
         is_heap_until(R&& r, Comp comp = {}, Proj proj = {});
   }
   // [alg.min.max], minimum and maximum
   template<class T> constexpr const T& min(const T& a, const T& b);
   template<class T, class Compare>
@@ -2692,10 +3732,15 @@ namespace std {
     template<input_range R, class Proj = identity,
              indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
       constexpr range_value_t<R>
         min(R&& r, Comp comp = {}, Proj proj = {});
   }
   template<class T> constexpr const T& max(const T& a, const T& b);
   template<class T, class Compare>
     constexpr const T& max(const T& a, const T& b, Compare comp);
@@ -2714,10 +3759,15 @@ namespace std {
     template<input_range R, class Proj = identity,
              indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
       constexpr range_value_t<R>
         max(R&& r, Comp comp = {}, Proj proj = {});
   }
   template<class T> constexpr pair<const T&, const T&> minmax(const T& a, const T& b);
   template<class T, class Compare>
     constexpr pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp);
@@ -2741,22 +3791,27 @@ namespace std {
     template<input_range R, class Proj = identity,
              indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
       constexpr minmax_result<range_value_t<R>>
         minmax(R&& r, Comp comp = {}, Proj proj = {});
   }
   template<class ForwardIterator>
     constexpr ForwardIterator min_element(ForwardIterator first, ForwardIterator last);
   template<class ForwardIterator, class Compare>
     constexpr ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
                                           Compare comp);
   template<class ExecutionPolicy, class ForwardIterator>
-    ForwardIterator min_element(ExecutionPolicy&& exec,         // see [algorithms.parallel.overloads]
                                 ForwardIterator first, ForwardIterator last);
   template<class ExecutionPolicy, class ForwardIterator, class Compare>
-    ForwardIterator min_element(ExecutionPolicy&& exec,         // see [algorithms.parallel.overloads]
                                 ForwardIterator first, ForwardIterator last,
                                 Compare comp);
   namespace ranges {
     template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
@@ -2764,22 +3819,33 @@ namespace std {
       constexpr I min_element(I first, S last, Comp comp = {}, Proj proj = {});
     template<forward_range R, class Proj = identity,
              indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       constexpr borrowed_iterator_t<R>
         min_element(R&& r, Comp comp = {}, Proj proj = {});
   }
   template<class ForwardIterator>
     constexpr ForwardIterator max_element(ForwardIterator first, ForwardIterator last);
   template<class ForwardIterator, class Compare>
     constexpr ForwardIterator max_element(ForwardIterator first, ForwardIterator last,
                                           Compare comp);
   template<class ExecutionPolicy, class ForwardIterator>
-    ForwardIterator max_element(ExecutionPolicy&& exec,         // see [algorithms.parallel.overloads]
                                 ForwardIterator first, ForwardIterator last);
   template<class ExecutionPolicy, class ForwardIterator, class Compare>
-    ForwardIterator max_element(ExecutionPolicy&& exec,         // see [algorithms.parallel.overloads]
                                 ForwardIterator first, ForwardIterator last,
                                 Compare comp);
   namespace ranges {
     template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
@@ -2787,25 +3853,36 @@ namespace std {
       constexpr I max_element(I first, S last, Comp comp = {}, Proj proj = {});
     template<forward_range R, class Proj = identity,
              indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       constexpr borrowed_iterator_t<R>
         max_element(R&& r, Comp comp = {}, Proj proj = {});
   }
   template<class ForwardIterator>
     constexpr pair<ForwardIterator, ForwardIterator>
       minmax_element(ForwardIterator first, ForwardIterator last);
   template<class ForwardIterator, class Compare>
     constexpr pair<ForwardIterator, ForwardIterator>
       minmax_element(ForwardIterator first, ForwardIterator last, Compare comp);
   template<class ExecutionPolicy, class ForwardIterator>
     pair<ForwardIterator, ForwardIterator>
-      minmax_element(ExecutionPolicy&& exec,                    // see [algorithms.parallel.overloads]
                      ForwardIterator first, ForwardIterator last);
   template<class ExecutionPolicy, class ForwardIterator, class Compare>
     pair<ForwardIterator, ForwardIterator>
-      minmax_element(ExecutionPolicy&& exec,                    // see [algorithms.parallel.overloads]
                      ForwardIterator first, ForwardIterator last, Compare comp);
   namespace ranges {
     template<class I>
       using minmax_element_result = min_max_result<I>;
@@ -2816,10 +3893,21 @@ namespace std {
         minmax_element(I first, S last, Comp comp = {}, Proj proj = {});
     template<forward_range R, class Proj = identity,
              indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       constexpr minmax_element_result<borrowed_iterator_t<R>>
         minmax_element(R&& r, Comp comp = {}, Proj proj = {});
   }
   // [alg.clamp], bounded value
   template<class T>
     constexpr const T& clamp(const T& v, const T& lo, const T& hi);
@@ -2843,17 +3931,17 @@ namespace std {
       lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
                               InputIterator2 first2, InputIterator2 last2,
                               Compare comp);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
     bool
-      lexicographical_compare(ExecutionPolicy&& exec,           // see [algorithms.parallel.overloads]
                               ForwardIterator1 first1, ForwardIterator1 last1,
                               ForwardIterator2 first2, ForwardIterator2 last2);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class Compare>
     bool
-      lexicographical_compare(ExecutionPolicy&& exec,           // see [algorithms.parallel.overloads]
                               ForwardIterator1 first1, ForwardIterator1 last1,
                               ForwardIterator2 first2, ForwardIterator2 last2,
                               Compare comp);
   namespace ranges {
@@ -2869,10 +3957,25 @@ namespace std {
              indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
                                         projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
       constexpr bool
         lexicographical_compare(R1&& r1, R2&& r2, Comp comp = {},
                                 Proj1 proj1 = {}, Proj2 proj2 = {});
   }
   // [alg.three.way], three-way comparison algorithms
   template<class InputIterator1, class InputIterator2, class Cmp>
     constexpr auto
@@ -3130,10 +4233,17 @@ template<input_iterator I, sentinel_for<I> S, class Proj = identity,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr bool ranges::all_of(I first, S last, Pred pred, Proj proj = {});
 template<input_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr bool ranges::all_of(R&& r, Pred pred, Proj proj = {});
 ```
 Let E be:
 - `pred(*i)` for the overloads in namespace `std`;
@@ -3159,10 +4269,17 @@ template<input_iterator I, sentinel_for<I> S, class Proj = identity,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr bool ranges::any_of(I first, S last, Pred pred, Proj proj = {});
 template<input_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr bool ranges::any_of(R&& r, Pred pred, Proj proj = {});
 ```
 Let E be:
 - `pred(*i)` for the overloads in namespace `std`;
@@ -3188,10 +4305,17 @@ template<input_iterator I, sentinel_for<I> S, class Proj = identity,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr bool ranges::none_of(I first, S last, Pred pred, Proj proj = {});
 template<input_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr bool ranges::none_of(R&& r, Pred pred, Proj proj = {});
 ```
 Let E be:
 - `pred(*i)` for the overloads in namespace `std`;
@@ -3205,20 +4329,36 @@ Let E be:
 any projection.
 ### Contains <a id="alg.contains">[[alg.contains]]</a>
 ``` cpp
-template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
   requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
   constexpr bool ranges::contains(I first, S last, const T& value, Proj proj = {});
-template<input_range R, class T, class Proj = identity>
   requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
   constexpr bool ranges::contains(R&& r, const T& value, Proj proj = {});
 ```
 *Returns:* `ranges::find(std::move(first), last, value, proj) != last`.
 ``` cpp
 template<forward_iterator I1, sentinel_for<I1> S1,
          forward_iterator I2, sentinel_for<I2> S2,
          class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
   requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
@@ -3230,11 +4370,36 @@ template<forward_range R1, forward_range R2,
   constexpr bool ranges::contains_subrange(R1&& r1, R2&& r2, Pred pred = {},
                                            Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
 *Returns:*
-`first2 == last2 || !ranges::search(first1, last1, first2, last2, pred, proj1, proj2).empty()`.
 ### For each <a id="alg.foreach">[[alg.foreach]]</a>
 ``` cpp
 template<class InputIterator, class Function>
@@ -3314,10 +4479,43 @@ the range \[`first`, `last`), starting from `first` and proceeding to
 *Remarks:* If `f` returns a result, the result is ignored.
 [*Note 6*: The overloads in namespace `ranges` require `Fun` to model
 `copy_constructible`. — *end note*]
 ``` cpp
 template<class InputIterator, class Size, class Function>
   constexpr InputIterator for_each_n(InputIterator first, Size n, Function f);
 ```
@@ -3325,17 +4523,17 @@ template<class InputIterator, class Size, class Function>
 type [[conv.integral]], [[class.conv]].
 *Preconditions:* `n >= 0` is `true`. `Function` meets the
 *Cpp17MoveConstructible* requirements.
-[*Note 7*: `Function` need not meet the requirements of
 *Cpp17CopyConstructible*. — *end note*]
 *Effects:* Applies `f` to the result of dereferencing every iterator in
 the range \[`first`, `first + n`) in order.
-[*Note 8*: If the type of `first` meets the requirements of a mutable
 iterator, `f` can apply non-constant functions through the dereferenced
 iterator. — *end note*]
 *Returns:* `first + n`.
@@ -3354,11 +4552,11 @@ type [[conv.integral]], [[class.conv]].
 *Cpp17CopyConstructible* requirements.
 *Effects:* Applies `f` to the result of dereferencing every iterator in
 the range \[`first`, `first + n`).
-[*Note 9*: If the type of `first` meets the requirements of a mutable
 iterator, `f` can apply non-constant functions through the dereferenced
 iterator. — *end note*]
 *Returns:* `first + n`.
@@ -3377,27 +4575,56 @@ template<input_iterator I, class Proj = identity,
 *Preconditions:* `n >= 0` is `true`.
 *Effects:* Calls `invoke(f, invoke(proj, *i))` for every iterator `i` in
 the range \[`first`, `first + n`) in order.
-[*Note 10*: If the result of `invoke(proj, *i)` is a mutable reference,
 `f` can apply non-constant functions. — *end note*]
 *Returns:* `{first + n, std::move(f)}`.
 *Remarks:* If `f` returns a result, the result is ignored.
-[*Note 11*: The overload in namespace `ranges` requires `Fun` to model
 `copy_constructible`. — *end note*]
 ### Find <a id="alg.find">[[alg.find]]</a>
 ``` cpp
-template<class InputIterator, class T>
   constexpr InputIterator find(InputIterator first, InputIterator last,
                                const T& value);
-template<class ExecutionPolicy, class ForwardIterator, class T>
   ForwardIterator find(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
                        const T& value);
 template<class InputIterator, class Predicate>
   constexpr InputIterator find_if(InputIterator first, InputIterator last,
@@ -3412,31 +4639,58 @@ template<class InputIterator, class Predicate>
 template<class ExecutionPolicy, class ForwardIterator, class Predicate>
   ForwardIterator find_if_not(ExecutionPolicy&& exec,
                               ForwardIterator first, ForwardIterator last,
                               Predicate pred);
-template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
   requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
   constexpr I ranges::find(I first, S last, const T& value, Proj proj = {});
-template<input_range R, class T, class Proj = identity>
   requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
   constexpr borrowed_iterator_t<R>
     ranges::find(R&& r, const T& value, Proj proj = {});
 template<input_iterator I, sentinel_for<I> S, class Proj = identity,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr I ranges::find_if(I first, S last, Pred pred, Proj proj = {});
 template<input_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr borrowed_iterator_t<R>
     ranges::find_if(R&& r, Pred pred, Proj proj = {});
 template<input_iterator I, sentinel_for<I> S, class Proj = identity,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr I ranges::find_if_not(I first, S last, Pred pred, Proj proj = {});
 template<input_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr borrowed_iterator_t<R>
     ranges::find_if_not(R&& r, Pred pred, Proj proj = {});
 ```
 Let E be:
 - `*i == value` for `find`;
@@ -3453,28 +4707,58 @@ which E is `true`. Returns `last` if no such iterator is found.
 predicate and any projection.
 ### Find last <a id="alg.find.last">[[alg.find.last]]</a>
 ``` cpp
-template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity>
   requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
   constexpr subrange<I> ranges::find_last(I first, S last, const T& value, Proj proj = {});
-template<forward_range R, class T, class Proj = identity>
   requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
   constexpr borrowed_subrange_t<R> ranges::find_last(R&& r, const T& value, Proj proj = {});
 template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr subrange<I> ranges::find_last_if(I first, S last, Pred pred, Proj proj = {});
 template<forward_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr borrowed_subrange_t<R> ranges::find_last_if(R&& r, Pred pred, Proj proj = {});
 template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr subrange<I> ranges::find_last_if_not(I first, S last, Pred pred, Proj proj = {});
 template<forward_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr borrowed_subrange_t<R> ranges::find_last_if_not(R&& r, Pred pred, Proj proj = {});
 ```
 Let E be:
 - `bool(invoke(proj, *i) == value)` for `ranges::find_last`;
@@ -3526,10 +4810,24 @@ template<forward_range R1, forward_range R2,
          class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
   requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
   constexpr borrowed_subrange_t<R1>
     ranges::find_end(R1&& r1, R2&& r2, Pred pred = {},
                      Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
 Let:
 - `pred` be `equal_to{}` for the overloads with no parameter `pred`;
@@ -3553,11 +4851,11 @@ Let:
 *Complexity:* At most
 `(last2 - first2) * (last1 - first1 - (last2 - first2) + 1)`
 applications of the corresponding predicate and any projections.
-### Find first <a id="alg.find.first.of">[[alg.find.first.of]]</a>
 ``` cpp
 template<class InputIterator, class ForwardIterator>
   constexpr InputIterator
     find_first_of(InputIterator first1, InputIterator last1,
@@ -3593,10 +4891,23 @@ template<input_range R1, forward_range R2,
   requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
   constexpr borrowed_iterator_t<R1>
     ranges::find_first_of(R1&& r1, R2&& r2,
                           Pred pred = {},
                           Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
 Let E be:
 - `*i == *j` for the overloads with no parameter `pred`;
@@ -3610,12 +4921,12 @@ Let E be:
 *Returns:* The first iterator `i` in the range \[`first1`, `last1`) such
 that for some iterator `j` in the range \[`first2`, `last2`) E holds.
 Returns `last1` if \[`first2`, `last2`) is empty or if no such iterator
 is found.
-*Complexity:* At most `(last1-first1) * (last2-first2)` applications of
-the corresponding predicate and any projections.
 ### Adjacent find <a id="alg.adjacent.find">[[alg.adjacent.find]]</a>
 ``` cpp
 template<class ForwardIterator>
@@ -3642,10 +4953,21 @@ template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
   constexpr I ranges::adjacent_find(I first, S last, Pred pred = {}, Proj proj = {});
 template<forward_range R, class Proj = identity,
          indirect_binary_predicate<projected<iterator_t<R>, Proj>,
                                    projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
   constexpr borrowed_iterator_t<R> ranges::adjacent_find(R&& r, Pred pred = {}, Proj proj = {});
 ```
 Let E be:
 - `*i == *(i + 1)` for the overloads with no parameter `pred`;
@@ -3656,25 +4978,25 @@ Let E be:
 *Returns:* The first iterator `i` such that both `i` and `i + 1` are in
 the range \[`first`, `last`) for which E holds. Returns `last` if no
 such iterator is found.
-*Complexity:* For the overloads with no `ExecutionPolicy`, exactly
 $$\min(\texttt{(i - first) + 1}, \ \texttt{(last - first) - 1})$$
 applications of the corresponding predicate, where `i` is
-`adjacent_find`’s return value. For the overloads with an
-`ExecutionPolicy`, 𝑂(`last - first`) applications of the corresponding
-predicate, and no more than twice as many applications of any
-projection.
 ### Count <a id="alg.count">[[alg.count]]</a>
 ``` cpp
-template<class InputIterator, class T>
   constexpr typename iterator_traits<InputIterator>::difference_type
     count(InputIterator first, InputIterator last, const T& value);
-template<class ExecutionPolicy, class ForwardIterator, class T>
   typename iterator_traits<ForwardIterator>::difference_type
     count(ExecutionPolicy&& exec,
           ForwardIterator first, ForwardIterator last, const T& value);
 template<class InputIterator, class Predicate>
@@ -3683,26 +5005,48 @@ template<class InputIterator, class Predicate>
 template<class ExecutionPolicy, class ForwardIterator, class Predicate>
   typename iterator_traits<ForwardIterator>::difference_type
     count_if(ExecutionPolicy&& exec,
              ForwardIterator first, ForwardIterator last, Predicate pred);
-template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
   requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
   constexpr iter_difference_t<I>
     ranges::count(I first, S last, const T& value, Proj proj = {});
-template<input_range R, class T, class Proj = identity>
   requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
   constexpr range_difference_t<R>
     ranges::count(R&& r, const T& value, Proj proj = {});
 template<input_iterator I, sentinel_for<I> S, class Proj = identity,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr iter_difference_t<I>
     ranges::count_if(I first, S last, Pred pred, Proj proj = {});
 template<input_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr range_difference_t<R>
     ranges::count_if(R&& r, Pred pred, Proj proj = {});
 ```
 Let E be:
 - `*i == value` for the overloads with no parameter `pred` or `proj`;
@@ -3717,11 +5061,11 @@ Let E be:
 `last`) for which E holds.
 *Complexity:* Exactly `last - first` applications of the corresponding
 predicate and any projection.
-### Mismatch <a id="mismatch">[[mismatch]]</a>
 ``` cpp
 template<class InputIterator1, class InputIterator2>
   constexpr pair<InputIterator1, InputIterator2>
     mismatch(InputIterator1 first1, InputIterator1 last1,
@@ -3778,14 +5122,28 @@ template<input_range R1, input_range R2,
          class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
   requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
   constexpr ranges::mismatch_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
     ranges::mismatch(R1&& r1, R2&& r2, Pred pred = {},
                      Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
-Let `last2` be `first2 + (last1 - first1)` for the overloads with no
-parameter `last2` or `r2`.
 Let E be:
 - `!(*(first1 + n) == *(first2 + n))` for the overloads with no
   parameter `pred`;
@@ -3852,16 +5210,28 @@ template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for
 template<input_range R1, input_range R2, class Pred = ranges::equal_to,
          class Proj1 = identity, class Proj2 = identity>
   requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
   constexpr bool ranges::equal(R1&& r1, R2&& r2, Pred pred = {},
                                Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
 Let:
-- `last2` be `first2 + (last1 - first1)` for the overloads with no
- parameter `last2` or `r2`;
 - `pred` be `equal_to{}` for the overloads with no parameter `pred`;
 - E be:
   - `pred(*i, *(first2 + (i - first1)))` for the overloads with no
     parameter `proj1`;
   - `invoke(pred, invoke(proj1, *i), invoke(proj2, *(first2 + (i - first1))))`
@@ -3877,24 +5247,20 @@ Otherwise return `true` if E holds for every iterator `i` in the range
   *Cpp17RandomAccessIterator* requirements [[random.access.iterators]]
   and `last1 - first1 != last2 - first2` for the overloads in namespace
   `std`;
 - the types of `first1`, `last1`, `first2`, and `last2` pairwise model
   `sized_sentinel_for` [[iterator.concept.sizedsentinel]] and
-  `last1 - first1 != last2 - first2` for the first overload in namespace
-  `ranges`,
 - `R1` and `R2` each model `sized_range` and
-  `ranges::distance(r1) != ranges::distance(r2)` for the second overload
-  in namespace `ranges`,
 then no applications of the corresponding predicate and each projection;
-otherwise,
-- For the overloads with no `ExecutionPolicy`, at most
-  min(`last1 - first1`,  `last2 - first2`) applications of the
-  corresponding predicate and any projections.
-- For the overloads with an `ExecutionPolicy`, 𝑂(min(`last1 - first1`,
-   `last2 - first2`)) applications of the corresponding predicate.
 ### Is permutation <a id="alg.is.permutation">[[alg.is.permutation]]</a>
 ``` cpp
 template<class ForwardIterator1, class ForwardIterator2>
@@ -3958,11 +5324,11 @@ Otherwise return `true` if there exists a permutation of the elements in
 the range \[`first2`, `last2`), bounded by \[`pfirst`, `plast`), such
 that `ranges::equal(first1, last1, pfirst, plast, pred, proj1, proj2)`
 returns `true`; otherwise, returns `false`.
 *Complexity:* No applications of the corresponding predicate and
-projections if:
 - for the first overload,
   - `S1` and `I1` model `sized_sentinel_for<S1, I1>`,
   - `S2` and `I2` model `sized_sentinel_for<S2, I2>`, and
   - `last1 - first1 != last2 - first2`;
@@ -4002,12 +5368,13 @@ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            ForwardIterator2 first2, ForwardIterator2 last2,
            BinaryPredicate pred);
 ```
 *Returns:* The first iterator `i` in the range \[`first1`,
-`last1 - (last2-first2)`) such that for every non-negative integer `n`
-less than `last2 - first2` the following corresponding conditions hold:
 `*(i + n) == *(first2 + n), pred(*(i + n), *(first2 + n)) != false`.
 Returns `first1` if \[`first2`, `last2`) is empty, otherwise returns
 `last1` if no such iterator is found.
 *Complexity:* At most `(last1 - first1) * (last2 - first2)` applications
@@ -4025,16 +5392,30 @@ template<forward_range R1, forward_range R2, class Pred = ranges::equal_to,
          class Proj1 = identity, class Proj2 = identity>
   requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
   constexpr borrowed_subrange_t<R1>
     ranges::search(R1&& r1, R2&& r2, Pred pred = {},
                    Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
 *Returns:*
 - `{i, i + (last2 - first2)}`, where `i` is the first iterator in the
-  range \[`first1`, `last1 - (last2 - first2)`) such that for every
   non-negative integer `n` less than `last2 - first2` the condition
   ``` cpp
   bool(invoke(pred, invoke(proj1, *(i + n)), invoke(proj2, *(first2 + n))))
   ```
@@ -4043,27 +5424,29 @@ template<forward_range R1, forward_range R2, class Pred = ranges::equal_to,
 *Complexity:* At most `(last1 - first1) * (last2 - first2)` applications
 of the corresponding predicate and projections.
 ``` cpp
-template<class ForwardIterator, class Size, class T>
   constexpr ForwardIterator
     search_n(ForwardIterator first, ForwardIterator last,
              Size count, const T& value);
-template<class ExecutionPolicy, class ForwardIterator, class Size, class T>
   ForwardIterator
     search_n(ExecutionPolicy&& exec,
              ForwardIterator first, ForwardIterator last,
              Size count, const T& value);
-template<class ForwardIterator, class Size, class T,
          class BinaryPredicate>
   constexpr ForwardIterator
     search_n(ForwardIterator first, ForwardIterator last,
              Size count, const T& value,
              BinaryPredicate pred);
-template<class ExecutionPolicy, class ForwardIterator, class Size, class T,
          class BinaryPredicate>
   ForwardIterator
     search_n(ExecutionPolicy&& exec,
              ForwardIterator first, ForwardIterator last,
              Size count, const T& value,
@@ -4071,36 +5454,53 @@ template<class ExecutionPolicy, class ForwardIterator, class Size, class T,
 ```
 *Mandates:* The type `Size` is convertible to an integral
 type [[conv.integral]], [[class.conv]].
-*Returns:* The first iterator `i` in the range \[`first`, `last-count`)
-such that for every non-negative integer `n` less than `count` the
-following corresponding conditions hold:
-`*(i + n) == value, pred(*(i + n), value) != false`. Returns `last` if
-no such iterator is found.
 *Complexity:* At most `last - first` applications of the corresponding
 predicate.
 ``` cpp
-template<forward_iterator I, sentinel_for<I> S, class T,
-         class Pred = ranges::equal_to, class Proj = identity>
   requires indirectly_comparable<I, const T*, Pred, Proj>
   constexpr subrange<I>
     ranges::search_n(I first, S last, iter_difference_t<I> count,
                      const T& value, Pred pred = {}, Proj proj = {});
-template<forward_range R, class T, class Pred = ranges::equal_to,
-         class Proj = identity>
   requires indirectly_comparable<iterator_t<R>, const T*, Pred, Proj>
   constexpr borrowed_subrange_t<R>
     ranges::search_n(R&& r, range_difference_t<R> count,
                      const T& value, Pred pred = {}, Proj proj = {});
 ```
 *Returns:* `{i, i + count}` where `i` is the first iterator in the range
-\[`first`, `last - count`) such that for every non-negative integer `n`
 less than `count`, the following condition holds:
 `invoke(pred, invoke(proj, *(i + n)), value)`. Returns `{last, last}` if
 no such iterator is found.
 *Complexity:* At most `last - first` applications of the corresponding
@@ -4137,10 +5537,32 @@ template<input_range R1, input_range R2, class Pred = ranges::equal_to, class Pr
 ``` cpp
 ranges::mismatch(std::move(first1), last1, std::move(first2), last2,
                  pred, proj1, proj2).in2 == last2
 ```
 ### Ends with <a id="alg.ends.with">[[alg.ends.with]]</a>
 ``` cpp
 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
          class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
@@ -4151,17 +5573,35 @@ template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for
                                    Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
 Let `N1` be `last1 - first1` and `N2` be `last2 - first2`.
-*Returns:* `false` if `N1` < `N2`, otherwise
 ``` cpp
 ranges::equal(std::move(first1) + (N1 - N2), last1, std::move(first2), last2,
               pred, proj1, proj2)
 ```
 ``` cpp
 template<input_range R1, input_range R2, class Pred = ranges::equal_to, class Proj1 = identity,
          class Proj2 = identity>
   requires (forward_range<R1> || sized_range<R1>) &&
            (forward_range<R2> || sized_range<R2>) &&
@@ -4170,22 +5610,44 @@ template<input_range R1, input_range R2, class Pred = ranges::equal_to, class Pr
                                    Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
 Let `N1` be `ranges::distance(r1)` and `N2` be `ranges::distance(r2)`.
-*Returns:* `false` if `N1` < `N2`, otherwise
 ``` cpp
-ranges::equal(ranges::drop_view(ranges::ref_view(r1), N1 - N2), r2, pred, proj1, proj2)
 ```
 ### Fold <a id="alg.fold">[[alg.fold]]</a>
 ``` cpp
-template<input_iterator I, sentinel_for<I> S, class T, indirectly-binary-left-foldable<T, I> F>
   constexpr auto ranges::fold_left(I first, S last, T init, F f);
-template<input_range R, class T, indirectly-binary-left-foldable<T, iterator_t<R>> F>
   constexpr auto ranges::fold_left(R&& r, T init, F f);
 ```
 *Returns:*
@@ -4208,14 +5670,14 @@ template<input_range R, indirectly-binary-left-foldable<range_value_t<R>, iterat
 ``` cpp
 ranges::fold_left_first_with_iter(std::move(first), last, f).value
 ```
 ``` cpp
-template<bidirectional_iterator I, sentinel_for<I> S, class T,
          indirectly-binary-right-foldable<T, I> F>
   constexpr auto ranges::fold_right(I first, S last, T init, F f);
-template<bidirectional_range R, class T,
          indirectly-binary-right-foldable<T, iterator_t<R>> F>
   constexpr auto ranges::fold_right(R&& r, T init, F f);
 ```
 *Effects:* Equivalent to:
@@ -4254,14 +5716,15 @@ I tail = ranges::prev(ranges::next(first, std::move(last)));
 return optional<U>(in_place,
   ranges::fold_right(std::move(first), tail, iter_value_t<I>(*tail), std::move(f)));
 ```
 ``` cpp
-template<input_iterator I, sentinel_for<I> S, class T,
          indirectly-binary-left-foldable<T, I> F>
   constexpr see below ranges::fold_left_with_iter(I first, S last, T init, F f);
-template<input_range R, class T, indirectly-binary-left-foldable<T, iterator_t<R>> F>
   constexpr see below ranges::fold_left_with_iter(R&& r, T init, F f);
 ```
 Let `U` be `decay_t<invoke_result_t<F&, T, iter_reference_t<I>>>`.
@@ -4347,25 +5810,43 @@ range \[`result`, `result + `N) starting from `first` and proceeding to
 *Complexity:* Exactly N assignments.
 ``` cpp
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
-  ForwardIterator2 copy(ExecutionPolicy&& policy,
                         ForwardIterator1 first, ForwardIterator1 last,
                         ForwardIterator2 result);
 ```
 *Preconditions:* The ranges \[`first`, `last`) and \[`result`,
-`result + (last - first)`) do not overlap.
-*Effects:* Copies elements in the range \[`first`, `last`) into the
-range \[`result`, `result + (last - first)`). For each non-negative
-integer `n < (last - first)`, performs `*(result + n) = *(first + n)`.
-*Returns:* `result + (last - first)`.
-*Complexity:* Exactly `last - first` assignments.
 ``` cpp
 template<class InputIterator, class Size, class OutputIterator>
   constexpr OutputIterator copy_n(InputIterator first, Size n,
                                   OutputIterator result);
@@ -4376,13 +5857,24 @@ template<class ExecutionPolicy, class ForwardIterator1, class Size, class Forwar
 template<input_iterator I, weakly_incrementable O>
   requires indirectly_copyable<I, O>
   constexpr ranges::copy_n_result<I, O>
     ranges::copy_n(I first, iter_difference_t<I> n, O result);
 ```
-Let N be max(0, `n`).
 *Mandates:* The type `Size` is convertible to an integral
 type [[conv.integral]], [[class.conv]].
 *Effects:* For each non-negative integer i < N, performs
@@ -4413,38 +5905,66 @@ template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Proj
 template<input_range R, weakly_incrementable O, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   requires indirectly_copyable<iterator_t<R>, O>
   constexpr ranges::copy_if_result<borrowed_iterator_t<R>, O>
     ranges::copy_if(R&& r, O result, Pred pred, Proj proj = {});
 ```
-Let E be:
 - `bool(pred(*i))` for the overloads in namespace `std`;
 - `bool(invoke(pred, invoke(proj, *i)))` for the overloads in namespace
-  `ranges`,
-and N be the number of iterators `i` in the range \[`first`, `last`) for
-which the condition E holds.
 *Preconditions:* The ranges \[`first`, `last`) and \[`result`,
-`result + (last - first)`) do not overlap.
-[*Note 1*: For the overload with an `ExecutionPolicy`, there might be a
-performance cost if `iterator_traits<ForwardIterator1>::value_type` is
-not *Cpp17MoveConstructible*
-([[cpp17.moveconstructible]]). — *end note*]
-*Effects:* Copies all of the elements referred to by the iterator `i` in
-the range \[`first`, `last`) for which E is `true`.
 *Returns:*
 - `result + `N for the overloads in namespace `std`.
-- `{last, result + `N`}` for the overloads in namespace `ranges`.
-*Complexity:* Exactly `last - first` applications of the corresponding
 predicate and any projection.
 *Remarks:* Stable [[algorithm.stable]].
 ``` cpp
@@ -4497,11 +6017,11 @@ template<input_range R, weakly_incrementable O>
   requires indirectly_movable<iterator_t<R>, O>
   constexpr ranges::move_result<borrowed_iterator_t<R>, O>
     ranges::move(R&& r, O result);
 ```
-Let E be
 - `std::move(*(first + `n`))` for the overload in namespace `std`;
 - `ranges::iter_move(first + `n`)` for the overloads in namespace
   `ranges`.
@@ -4510,36 +6030,58 @@ Let N be `last - first`.
 *Preconditions:* `result` is not in the range \[`first`, `last`).
 *Effects:* Moves elements in the range \[`first`, `last`) into the range
 \[`result`, `result + `N) starting from `first` and proceeding to
 `last`. For each non-negative integer n < N, performs
-`*(result + `n`) = `E.
 *Returns:*
 - `result + `N for the overload in namespace `std`.
 - `{last, result + `N`}` for the overloads in namespace `ranges`.
 *Complexity:* Exactly N assignments.
 ``` cpp
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
-  ForwardIterator2 move(ExecutionPolicy&& policy,
                         ForwardIterator1 first, ForwardIterator1 last,
                         ForwardIterator2 result);
 ```
-Let N be `last - first`.
 *Preconditions:* The ranges \[`first`, `last`) and \[`result`,
 `result + `N) do not overlap.
-*Effects:* Moves elements in the range \[`first`, `last`) into the range
-\[`result`, `result + `N). For each non-negative integer n < N, performs
-`*(result + `n`) = std::move(*(first + `n`))`.
-*Returns:* `result + `N.
 *Complexity:* Exactly N assignments.
 ``` cpp
 template<class BidirectionalIterator1, class BidirectionalIterator2>
@@ -4555,11 +6097,11 @@ template<bidirectional_range R, bidirectional_iterator I>
   requires indirectly_movable<iterator_t<R>, I>
   constexpr ranges::move_backward_result<borrowed_iterator_t<R>, I>
     ranges::move_backward(R&& r, I result);
 ```
-Let E be
 - `std::move(*(last - `n`))` for the overload in namespace `std`;
 - `ranges::iter_move(last - `n`)` for the overloads in namespace
   `ranges`.
@@ -4569,11 +6111,11 @@ Let N be `last - first`.
 *Effects:* Moves elements in the range \[`first`, `last`) into the range
 \[`result - `N, `result`) starting from `last - 1` and proceeding to
 `first`.[^3]
-For each positive integer n ≤ N, performs `*(result - `n`) = `E.
 *Returns:*
 - `result - `N for the overload in namespace `std`.
 - `{last, result - `N`}` for the overloads in namespace `ranges`.
@@ -4599,16 +6141,26 @@ template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for
     ranges::swap_ranges(I1 first1, S1 last1, I2 first2, S2 last2);
 template<input_range R1, input_range R2>
   requires indirectly_swappable<iterator_t<R1>, iterator_t<R2>>
   constexpr ranges::swap_ranges_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
     ranges::swap_ranges(R1&& r1, R2&& r2);
 ```
 Let:
-- `last2` be `first2 + (last1 - first1)` for the overloads with no
-  parameter named `last2`;
 - M be min(`last1 - first1`,  `last2 - first2`).
 *Preconditions:* The two ranges \[`first1`, `last1`) and \[`first2`,
 `last2`) do not overlap. For the overloads in namespace `std`,
 `*(first1 + `n`)` is swappable with [[swappable.requirements]]
@@ -4676,10 +6228,25 @@ template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
 template<input_range R, weakly_incrementable O, copy_constructible F,
          class Proj = identity>
   requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R>, Proj>>>
   constexpr ranges::unary_transform_result<borrowed_iterator_t<R>, O>
     ranges::transform(R&& r, O result, F op, Proj proj = {});
 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
          weakly_incrementable O, copy_constructible F, class Proj1 = identity,
          class Proj2 = identity>
   requires indirectly_writable<O, indirect_result_t<F&, projected<I1, Proj1>,
                                projected<I2, Proj2>>>
@@ -4691,104 +6258,165 @@ template<input_range R1, input_range R2, weakly_incrementable O,
   requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R1>, Proj1>,
                                projected<iterator_t<R2>, Proj2>>>
   constexpr ranges::binary_transform_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
     ranges::transform(R1&& r1, R2&& r2, O result,
                       F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
 Let:
-- `last2` be `first2 + (last1 - first1)` for the overloads with
-  parameter `first2` but no parameter `last2`;
-- N be `last1 - first1` for unary transforms, or
   min(`last1 - first1`,  `last2 - first2`) for binary transforms;
-- E be
   - `op(*(first1 + (i - result)))` for unary transforms defined in
     namespace `std`;
   - `binary_op(*(first1 + (i - result)), *(first2 + (i - result)))` for
     binary transforms defined in namespace `std`;
   - `invoke(op, invoke(proj, *(first1 + (i - result))))` for unary
     transforms defined in namespace `ranges`;
   - `invoke(binary_op, invoke(proj1, *(first1 + (i - result))), invoke(proj2,*(first2 + (i - result))))`
     for binary transforms defined in namespace `ranges`.
-*Preconditions:* `op` and `binary_op` do not invalidate iterators or
-subranges, nor modify elements in the ranges
 - \[`first1`, `first1 + `N\],
 - \[`first2`, `first2 + `N\], and
 - \[`result`, `result + `N\].[^4]
 *Effects:* Assigns through every iterator `i` in the range \[`result`,
-`result + `N) a new corresponding value equal to E.
 *Returns:*
 - `result + `N for the overloads defined in namespace `std`.
 - `{first1 + `N`, result + `N`}` for unary transforms defined in
   namespace `ranges`.
 - `{first1 + `N`, first2 + `N`, result + `N`}` for binary transforms
   defined in namespace `ranges`.
 *Complexity:* Exactly N applications of `op` or `binary_op`, and any
-projections. This requirement also applies to the overload with an
-`ExecutionPolicy`.
 *Remarks:* `result` may be equal to `first1` or `first2`.
 ### Replace <a id="alg.replace">[[alg.replace]]</a>
 ``` cpp
-template<class ForwardIterator, class T>
   constexpr void replace(ForwardIterator first, ForwardIterator last,
                          const T& old_value, const T& new_value);
-template<class ExecutionPolicy, class ForwardIterator, class T>
   void replace(ExecutionPolicy&& exec,
                ForwardIterator first, ForwardIterator last,
                const T& old_value, const T& new_value);
-template<class ForwardIterator, class Predicate, class T>
   constexpr void replace_if(ForwardIterator first, ForwardIterator last,
                             Predicate pred, const T& new_value);
-template<class ExecutionPolicy, class ForwardIterator, class Predicate, class T>
   void replace_if(ExecutionPolicy&& exec,
                   ForwardIterator first, ForwardIterator last,
                   Predicate pred, const T& new_value);
-template<input_iterator I, sentinel_for<I> S, class T1, class T2, class Proj = identity>
   requires indirectly_writable<I, const T2&> &&
            indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*>
   constexpr I
     ranges::replace(I first, S last, const T1& old_value, const T2& new_value, Proj proj = {});
-template<input_range R, class T1, class T2, class Proj = identity>
   requires indirectly_writable<iterator_t<R>, const T2&> &&
            indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T1*>
   constexpr borrowed_iterator_t<R>
     ranges::replace(R&& r, const T1& old_value, const T2& new_value, Proj proj = {});
-template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   requires indirectly_writable<I, const T&>
   constexpr I ranges::replace_if(I first, S last, Pred pred, const T& new_value, Proj proj = {});
-template<input_range R, class T, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   requires indirectly_writable<iterator_t<R>, const T&>
   constexpr borrowed_iterator_t<R>
     ranges::replace_if(R&& r, Pred pred, const T& new_value, Proj proj = {});
 ```
-Let E be
 - `bool(*i == old_value)` for `replace`;
 - `bool(pred(*i))` for `replace_if`;
 - `bool(invoke(proj, *i) == old_value)` for `ranges::replace`;
 - `bool(invoke(pred, invoke(proj, *i)))` for `ranges::replace_if`.
 *Mandates:* `new_value` is writable [[iterator.requirements.general]] to
 `first`.
 *Effects:* Substitutes elements referred by the iterator `i` in the
-range \[`first`, `last`) with `new_value`, when E is `true`.
 *Returns:* `last` for the overloads in namespace `ranges`.
 *Complexity:* Exactly `last - first` applications of the corresponding
 predicate and any projection.
@@ -4817,90 +6445,150 @@ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
     replace_copy_if(ExecutionPolicy&& exec,
                     ForwardIterator1 first, ForwardIterator1 last,
                     ForwardIterator2 result,
                     Predicate pred, const T& new_value);
-template<input_iterator I, sentinel_for<I> S, class T1, class T2, output_iterator<const T2&> O,
-         class Proj = identity>
   requires indirectly_copyable<I, O> &&
-           indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*>
   constexpr ranges::replace_copy_result<I, O>
     ranges::replace_copy(I first, S last, O result, const T1& old_value, const T2& new_value,
                          Proj proj = {});
-template<input_range R, class T1, class T2, output_iterator<const T2&> O,
-         class Proj = identity>
   requires indirectly_copyable<iterator_t<R>, O> &&
            indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T1*>
   constexpr ranges::replace_copy_result<borrowed_iterator_t<R>, O>
     ranges::replace_copy(R&& r, O result, const T1& old_value, const T2& new_value,
                          Proj proj = {});
-template<input_iterator I, sentinel_for<I> S, class T, output_iterator<const T&> O,
          class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
-  requires indirectly_copyable<I, O>
   constexpr ranges::replace_copy_if_result<I, O>
     ranges::replace_copy_if(I first, S last, O result, Pred pred, const T& new_value,
                             Proj proj = {});
-template<input_range R, class T, output_iterator<const T&> O, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
-  requires indirectly_copyable<iterator_t<R>, O>
   constexpr ranges::replace_copy_if_result<borrowed_iterator_t<R>, O>
     ranges::replace_copy_if(R&& r, O result, Pred pred, const T& new_value,
                             Proj proj = {});
 ```
-Let E be
 - `bool(*(first + (i - result)) == old_value)` for `replace_copy`;
 - `bool(pred(*(first + (i - result))))` for `replace_copy_if`;
 - `bool(invoke(proj, *(first + (i - result))) == old_value)` for
   `ranges::replace_copy`;
 - `bool(invoke(pred, invoke(proj, *(first + (i - result)))))` for
   `ranges::replace_copy_if`.
 *Mandates:* The results of the expressions `*first` and `new_value` are
 writable [[iterator.requirements.general]] to `result`.
 *Preconditions:* The ranges \[`first`, `last`) and \[`result`,
-`result + (last - first)`) do not overlap.
 *Effects:* Assigns through every iterator `i` in the range \[`result`,
-`result + (last - first)`) a new corresponding value
-- `new_value` if E is `true` or
 - `*(first + (i - result))` otherwise.
 *Returns:*
-- `result + (last - first)` for the overloads in namespace `std`.
-- `{last, result + (last - first)}` for the overloads in namespace
-  `ranges`.
-*Complexity:* Exactly `last - first` applications of the corresponding
-predicate and any projection.
 ### Fill <a id="alg.fill">[[alg.fill]]</a>
 ``` cpp
-template<class ForwardIterator, class T>
   constexpr void fill(ForwardIterator first, ForwardIterator last, const T& value);
-template<class ExecutionPolicy, class ForwardIterator, class T>
   void fill(ExecutionPolicy&& exec,
             ForwardIterator first, ForwardIterator last, const T& value);
-template<class OutputIterator, class Size, class T>
   constexpr OutputIterator fill_n(OutputIterator first, Size n, const T& value);
-template<class ExecutionPolicy, class ForwardIterator, class Size, class T>
   ForwardIterator fill_n(ExecutionPolicy&& exec,
                          ForwardIterator first, Size n, const T& value);
-template<class T, output_iterator<const T&> O, sentinel_for<O> S>
   constexpr O ranges::fill(O first, S last, const T& value);
-template<class T, output_range<const T&> R>
   constexpr borrowed_iterator_t<R> ranges::fill(R&& r, const T& value);
-template<class T, output_iterator<const T&> O>
   constexpr O ranges::fill_n(O first, iter_difference_t<O> n, const T& value);
 ```
 Let N be max(0, `n`) for the `fill_n` algorithms, and `last - first` for
 the `fill` algorithms.
@@ -4940,10 +6628,21 @@ template<class R, copy_constructible F>
   requires invocable<F&> && output_range<R, invoke_result_t<F&>>
   constexpr borrowed_iterator_t<R> ranges::generate(R&& r, F gen);
 template<input_or_output_iterator O, copy_constructible F>
   requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
   constexpr O ranges::generate_n(O first, iter_difference_t<O> n, F gen);
 ```
 Let N be max(0, `n`) for the `generate_n` algorithms, and `last - first`
 for the `generate` algorithms.
@@ -4955,17 +6654,21 @@ through each iterator in the range \[`first`, `first + `N).
 *Returns:* `first + `N.
 *Complexity:* Exactly N evaluations of `gen()` and assignments.
 ### Remove <a id="alg.remove">[[alg.remove]]</a>
 ``` cpp
-template<class ForwardIterator, class T>
   constexpr ForwardIterator remove(ForwardIterator first, ForwardIterator last,
                                    const T& value);
-template<class ExecutionPolicy, class ForwardIterator, class T>
   ForwardIterator remove(ExecutionPolicy&& exec,
                          ForwardIterator first, ForwardIterator last,
                          const T& value);
 template<class ForwardIterator, class Predicate>
@@ -4974,26 +6677,52 @@ template<class ForwardIterator, class Predicate>
 template<class ExecutionPolicy, class ForwardIterator, class Predicate>
   ForwardIterator remove_if(ExecutionPolicy&& exec,
                             ForwardIterator first, ForwardIterator last,
                             Predicate pred);
-template<permutable I, sentinel_for<I> S, class T, class Proj = identity>
   requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
   constexpr subrange<I> ranges::remove(I first, S last, const T& value, Proj proj = {});
-template<forward_range R, class T, class Proj = identity>
   requires permutable<iterator_t<R>> &&
            indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
   constexpr borrowed_subrange_t<R>
     ranges::remove(R&& r, const T& value, Proj proj = {});
 template<permutable I, sentinel_for<I> S, class Proj = identity,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr subrange<I> ranges::remove_if(I first, S last, Pred pred, Proj proj = {});
 template<forward_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   requires permutable<iterator_t<R>>
   constexpr borrowed_subrange_t<R>
     ranges::remove_if(R&& r, Pred pred, Proj proj = {});
 ```
 Let E be
 - `bool(*i == value)` for `remove`;
@@ -5022,16 +6751,17 @@ predicate and any projection.
 the returned value, has a valid but unspecified state, because the
 algorithms can eliminate elements by moving from elements that were
 originally in that range. — *end note*]
 ``` cpp
-template<class InputIterator, class OutputIterator, class T>
   constexpr OutputIterator
     remove_copy(InputIterator first, InputIterator last,
                 OutputIterator result, const T& value);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
-         class T>
   ForwardIterator2
     remove_copy(ExecutionPolicy&& exec,
                 ForwardIterator1 first, ForwardIterator1 last,
                 ForwardIterator2 result, const T& value);
@@ -5044,63 +6774,109 @@ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
   ForwardIterator2
     remove_copy_if(ExecutionPolicy&& exec,
                    ForwardIterator1 first, ForwardIterator1 last,
                    ForwardIterator2 result, Predicate pred);
-template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class T,
-         class Proj = identity>
   requires indirectly_copyable<I, O> &&
            indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
   constexpr ranges::remove_copy_result<I, O>
     ranges::remove_copy(I first, S last, O result, const T& value, Proj proj = {});
-template<input_range R, weakly_incrementable O, class T, class Proj = identity>
   requires indirectly_copyable<iterator_t<R>, O> &&
            indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
   constexpr ranges::remove_copy_result<borrowed_iterator_t<R>, O>
     ranges::remove_copy(R&& r, O result, const T& value, Proj proj = {});
 template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
          class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
   requires indirectly_copyable<I, O>
   constexpr ranges::remove_copy_if_result<I, O>
     ranges::remove_copy_if(I first, S last, O result, Pred pred, Proj proj = {});
 template<input_range R, weakly_incrementable O, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   requires indirectly_copyable<iterator_t<R>, O>
   constexpr ranges::remove_copy_if_result<borrowed_iterator_t<R>, O>
     ranges::remove_copy_if(R&& r, O result, Pred pred, Proj proj = {});
 ```
-Let E be
 - `bool(*i == value)` for `remove_copy`;
 - `bool(pred(*i))` for `remove_copy_if`;
 - `bool(invoke(proj, *i) == value)` for `ranges::remove_copy`;
 - `bool(invoke(pred, invoke(proj, *i)))` for `ranges::remove_copy_if`.
-Let N be the number of elements in \[`first`, `last`) for which E is
-`false`.
 *Mandates:* `*first` is writable [[iterator.requirements.general]] to
 `result`.
 *Preconditions:* The ranges \[`first`, `last`) and \[`result`,
-`result + (last - first)`) do not overlap.
-[*Note 2*: For the overloads with an `ExecutionPolicy`, there might be
-a performance cost if `iterator_traits<ForwardIterator1>::value_type`
-does not meet the *Cpp17MoveConstructible*
-([[cpp17.moveconstructible]]) requirements. — *end note*]
-*Effects:* Copies all the elements referred to by the iterator `i` in
-the range \[`first`, `last`) for which E is `false`.
 *Returns:*
 - `result + `N, for the algorithms in namespace `std`.
-- `{last, result + `N`}`, for the algorithms in namespace `ranges`.
-*Complexity:* Exactly `last - first` applications of the corresponding
 predicate and any projection.
 *Remarks:* Stable [[algorithm.stable]].
 ### Unique <a id="alg.unique">[[alg.unique]]</a>
@@ -5126,10 +6902,20 @@ template<permutable I, sentinel_for<I> S, class Proj = identity,
 template<forward_range R, class Proj = identity,
          indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
   requires permutable<iterator_t<R>>
   constexpr borrowed_subrange_t<R>
     ranges::unique(R&& r, C comp = {}, Proj proj = {});
 ```
 Let `pred` be `equal_to{}` for the overloads with no parameter `pred`,
 and let E be
@@ -5191,52 +6977,83 @@ template<input_range R, weakly_incrementable O, class Proj = identity,
            (forward_iterator<iterator_t<R>> ||
             (input_iterator<O> && same_as<range_value_t<R>, iter_value_t<O>>) ||
             indirectly_copyable_storable<iterator_t<R>, O>)
   constexpr ranges::unique_copy_result<borrowed_iterator_t<R>, O>
     ranges::unique_copy(R&& r, O result, C comp = {}, Proj proj = {});
 ```
 Let `pred` be `equal_to{}` for the overloads in namespace `std` with no
-parameter `pred`, and let E be
 - `bool(pred(*i, *(i - 1)))` for the overloads in namespace `std`;
 - `bool(invoke(comp, invoke(proj, *i), invoke(proj, *(i - 1))))` for the
   overloads in namespace `ranges`.
 *Mandates:* `*first` is writable [[iterator.requirements.general]] to
 `result`.
 *Preconditions:*
-- The ranges \[`first`, `last`) and \[`result`, `result+(last-first)`)
- do not overlap.
 - For the overloads in namespace `std`:
   - The comparison function is an equivalence relation.
   - For the overloads with no `ExecutionPolicy`, let `T` be the value
     type of `InputIterator`. If `InputIterator` models
     `forward_iterator` [[iterator.concept.forward]], then there are no
     additional requirements for `T`. Otherwise, if `OutputIterator`
     meets the *Cpp17ForwardIterator* requirements and its value type is
     the same as `T`, then `T` meets the *Cpp17CopyAssignable*
     ([[cpp17.copyassignable]]) requirements. Otherwise, `T` meets both
     the *Cpp17CopyConstructible* ([[cpp17.copyconstructible]]) and
-    *Cpp17CopyAssignable* requirements. \[*Note 1*: For the overloads
-    with an `ExecutionPolicy`, there might be a performance cost if the
-    value type of `ForwardIterator1` does not meet both the
-    *Cpp17CopyConstructible* and *Cpp17CopyAssignable*
-    requirements. — *end note*]
-*Effects:* Copies only the first element from every consecutive group of
-equal elements referred to by the iterator `i` in the range \[`first`,
-`last`) for which E holds.
 *Returns:*
 - `result + `N for the overloads in namespace `std`.
-- `{last, result + `N`}` for the overloads in namespace `ranges`.
-*Complexity:* Exactly `last - first - 1` applications of the
 corresponding predicate and no more than twice as many applications of
 any projection.
 ### Reverse <a id="alg.reverse">[[alg.reverse]]</a>
@@ -5251,10 +7068,17 @@ template<bidirectional_iterator I, sentinel_for<I> S>
   requires permutable<I>
   constexpr I ranges::reverse(I first, S last);
 template<bidirectional_range R>
   requires permutable<iterator_t<R>>
   constexpr borrowed_iterator_t<R> ranges::reverse(R&& r);
 ```
 *Preconditions:* For the overloads in namespace `std`,
 `BidirectionalIterator` meets the *Cpp17ValueSwappable*
 requirements [[swappable.requirements]].
@@ -5304,10 +7128,38 @@ following assignment takes place:
 - `result + `N for the overloads in namespace `std`.
 - `{last, result + `N`}` for the overloads in namespace `ranges`.
 *Complexity:* Exactly N assignments.
 ### Rotate <a id="alg.rotate">[[alg.rotate]]</a>
 ``` cpp
 template<class ForwardIterator>
   constexpr ForwardIterator
@@ -5317,10 +7169,13 @@ template<class ExecutionPolicy, class ForwardIterator>
     rotate(ExecutionPolicy&& exec,
            ForwardIterator first, ForwardIterator middle, ForwardIterator last);
 template<permutable I, sentinel_for<I> S>
   constexpr subrange<I> ranges::rotate(I first, I middle, S last);
 ```
 *Preconditions:* \[`first`, `middle`) and \[`middle`, `last`) are valid
 ranges. For the overloads in namespace `std`, `ForwardIterator` meets
 the *Cpp17ValueSwappable* requirements [[swappable.requirements]], and
@@ -5349,10 +7204,22 @@ template<forward_range R>
 ```
 *Effects:* Equivalent to:
 `return ranges::rotate(ranges::begin(r), middle, ranges::end(r));`
 ``` cpp
 template<class ForwardIterator, class OutputIterator>
   constexpr OutputIterator
     rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last,
                 OutputIterator result);
@@ -5384,10 +7251,38 @@ following assignment takes place:
 - `result + `N for the overloads in namespace `std`.
 - `{last, result + `N`}` for the overload in namespace `ranges`.
 *Complexity:* Exactly N assignments.
 ``` cpp
 template<forward_range R, weakly_incrementable O>
   requires indirectly_copyable<iterator_t<R>, O>
   constexpr ranges::rotate_copy_result<borrowed_iterator_t<R>, O>
     ranges::rotate_copy(R&& r, iterator_t<R> middle, O result);
@@ -5397,10 +7292,24 @@ template<forward_range R, weakly_incrementable O>
 ``` cpp
 return ranges::rotate_copy(ranges::begin(r), middle, ranges::end(r), std::move(result));
 ```
 ### Sample <a id="alg.random.sample">[[alg.random.sample]]</a>
 ``` cpp
 template<class PopulationIterator, class SampleIterator,
          class Distance, class UniformRandomBitGenerator>
@@ -5509,26 +7418,34 @@ template<class ExecutionPolicy, class ForwardIterator>
 template<permutable I, sentinel_for<I> S>
   constexpr subrange<I> ranges::shift_left(I first, S last, iter_difference_t<I> n);
 template<forward_range R>
   requires permutable<iterator_t<R>>
-  constexpr borrowed_subrange_t<R> ranges::shift_left(R&& r, range_difference_t<R> n)
 ```
 *Preconditions:* `n >= 0` is `true`. For the overloads in namespace
 `std`, the type of `*first` meets the *Cpp17MoveAssignable*
 requirements.
 *Effects:* If `n == 0` or `n >= last - first`, does nothing. Otherwise,
 moves the element from position `first + n + i` into position
 `first + i` for each non-negative integer `i < (last - first) - n`. For
-the overloads without an `ExecutionPolicy` template parameter, does so
-in order starting from `i = 0` and proceeding to
-`i = (last - first) - n - 1`.
 *Returns:* Let *NEW_LAST* be `first + (last - first - n)` if
-`n < last - first`, otherwise `first`.
 - *NEW_LAST* for the overloads in namespace `std`.
 - `{first, `*`NEW_LAST`*`}` for the overloads in namespace `ranges`.
 *Complexity:* At most `(last - first) - n` assignments.
@@ -5546,10 +7463,19 @@ template<class ExecutionPolicy, class ForwardIterator>
 template<permutable I, sentinel_for<I> S>
   constexpr subrange<I> ranges::shift_right(I first, S last, iter_difference_t<I> n);
 template<forward_range R>
   requires permutable<iterator_t<R>>
   constexpr borrowed_subrange_t<R> ranges::shift_right(R&& r, range_difference_t<R> n);
 ```
 *Preconditions:* `n >= 0` is `true`. For the overloads in namespace
 `std`, the type of `*first` meets the *Cpp17MoveAssignable*
 requirements, and `ForwardIterator` meets the
@@ -5558,20 +7484,19 @@ the *Cpp17ValueSwappable* requirements.
 *Effects:* If `n == 0` or `n >= last - first`, does nothing. Otherwise,
 moves the element from position `first + i` into position
 `first + n + i` for each non-negative integer `i < (last - first) - n`.
 Does so in order starting from `i = (last - first) - n - 1` and
-proceeding to `i = 0` if:
-- for the overload in namespace `std` without an `ExecutionPolicy`
- template parameter, `ForwardIterator` meets the
-  *Cpp17BidirectionalIterator* requirements,
-- for the overloads in namespace `ranges`, `I` models
-  `bidirectional_iterator`.
 *Returns:* Let *NEW_FIRST* be `first + n` if `n < last - first`,
-otherwise `last`.
 - *NEW_FIRST* for the overloads in namespace `std`.
 - `{`*`NEW_FIRST`*`, last}` for the overloads in namespace `ranges`.
 *Complexity:* At most `(last - first) - n` assignments or swaps.
@@ -5672,10 +7597,19 @@ template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
     ranges::sort(I first, S last, Comp comp = {}, Proj proj = {});
 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
   requires sortable<iterator_t<R>, Comp, Proj>
   constexpr borrowed_iterator_t<R>
     ranges::sort(R&& r, Comp comp = {}, Proj proj = {});
 ```
 Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
 no parameters by those names.
@@ -5695,31 +7629,41 @@ projections.
 #### `stable_sort` <a id="stable.sort">[[stable.sort]]</a>
 ``` cpp
 template<class RandomAccessIterator>
-  void stable_sort(RandomAccessIterator first, RandomAccessIterator last);
 template<class ExecutionPolicy, class RandomAccessIterator>
   void stable_sort(ExecutionPolicy&& exec,
                    RandomAccessIterator first, RandomAccessIterator last);
 template<class RandomAccessIterator, class Compare>
-  void stable_sort(RandomAccessIterator first, RandomAccessIterator last,
                              Compare comp);
 template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
   void stable_sort(ExecutionPolicy&& exec,
                    RandomAccessIterator first, RandomAccessIterator last,
                    Compare comp);
 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
          class Proj = identity>
   requires sortable<I, Comp, Proj>
-  I ranges::stable_sort(I first, S last, Comp comp = {}, Proj proj = {});
 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
   requires sortable<iterator_t<R>, Comp, Proj>
-  borrowed_iterator_t<R>
     ranges::stable_sort(R&& r, Comp comp = {}, Proj proj = {});
 ```
 Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
 no parameters by those names.
@@ -5769,10 +7713,14 @@ template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
          class Proj = identity>
   requires sortable<I, Comp, Proj>
   constexpr I
     ranges::partial_sort(I first, I middle, S last, Comp comp = {}, Proj proj = {});
 ```
 Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
 no parameters by those names.
@@ -5804,10 +7752,26 @@ template<random_access_range R, class Comp = ranges::less, class Proj = identity
 ``` cpp
 return ranges::partial_sort(ranges::begin(r), middle, ranges::end(r), comp, proj);
 ```
 #### `partial_sort_copy` <a id="partial.sort.copy">[[partial.sort.copy]]</a>
 ``` cpp
 template<class InputIterator, class RandomAccessIterator>
   constexpr RandomAccessIterator
@@ -5851,10 +7815,29 @@ template<input_range R1, random_access_range R2, class Comp = ranges::less,
            indirect_strict_weak_order<Comp, projected<iterator_t<R1>, Proj1>,
                                       projected<iterator_t<R2>, Proj2>>
   constexpr ranges::partial_sort_copy_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
     ranges::partial_sort_copy(R1&& r, R2&& result_r, Comp comp = {},
                               Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
 Let N be min(`last - first`,  `result_last - result_first`). Let `comp`
 be `less{}`, and `proj1` and `proj2` be `identity{}` for the overloads
 with no parameters by those names.
@@ -5951,10 +7934,26 @@ template<forward_range R, class Proj = identity,
 ```
 *Effects:* Equivalent to:
 `return ranges::is_sorted_until(first, last, comp, proj) == last;`
 ``` cpp
 template<class ForwardIterator>
   constexpr ForwardIterator
     is_sorted_until(ForwardIterator first, ForwardIterator last);
 template<class ExecutionPolicy, class ForwardIterator>
@@ -5977,10 +7976,20 @@ template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
   constexpr I ranges::is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {});
 template<forward_range R, class Proj = identity,
          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
   constexpr borrowed_iterator_t<R>
     ranges::is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});
 ```
 Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
 no parameters by those names.
@@ -6011,10 +8020,14 @@ template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
          class Proj = identity>
   requires sortable<I, Comp, Proj>
   constexpr I
     ranges::nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {});
 ```
 Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
 no parameters by those names.
@@ -6032,13 +8045,13 @@ Also for every iterator `i` in the range \[`first`, `nth`) and every
 iterator `j` in the range \[`nth`, `last`) it holds that:
 `bool(invoke(comp, invoke(proj, *j), invoke(proj, *i)))` is `false`.
 *Returns:* `last` for the overload in namespace `ranges`.
-*Complexity:* For the overloads with no `ExecutionPolicy`, linear on
-average. For the overloads with an `ExecutionPolicy`, 𝑂(N) applications
-of the predicate, and 𝑂(N log N) swaps, where N = `last - first`.
 ``` cpp
 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
   requires sortable<iterator_t<R>, Comp, Proj>
   constexpr borrowed_iterator_t<R>
@@ -6049,10 +8062,25 @@ template<random_access_range R, class Comp = ranges::less, class Proj = identity
 ``` cpp
 return ranges::nth_element(ranges::begin(r), nth, ranges::end(r), comp, proj);
 ```
 ### Binary search <a id="alg.binary.search">[[alg.binary.search]]</a>
 #### General <a id="alg.binary.search.general">[[alg.binary.search.general]]</a>
 All of the algorithms in [[alg.binary.search]] are versions of binary
@@ -6066,25 +8094,28 @@ through the data structure. For non-random access iterators they execute
 a linear number of steps.
 #### `lower_bound` <a id="lower.bound">[[lower.bound]]</a>
 ``` cpp
-template<class ForwardIterator, class T>
   constexpr ForwardIterator
     lower_bound(ForwardIterator first, ForwardIterator last,
                 const T& value);
-template<class ForwardIterator, class T, class Compare>
   constexpr ForwardIterator
     lower_bound(ForwardIterator first, ForwardIterator last,
                 const T& value, Compare comp);
-template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
          indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
   constexpr I ranges::lower_bound(I first, S last, const T& value, Comp comp = {},
                                   Proj proj = {});
-template<forward_range R, class T, class Proj = identity,
          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
            ranges::less>
   constexpr borrowed_iterator_t<R>
     ranges::lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
 ```
@@ -6104,24 +8135,27 @@ such that for every iterator `j` in the range \[`first`, `i`),
 projections.
 #### `upper_bound` <a id="upper.bound">[[upper.bound]]</a>
 ``` cpp
-template<class ForwardIterator, class T>
   constexpr ForwardIterator
     upper_bound(ForwardIterator first, ForwardIterator last,
                 const T& value);
-template<class ForwardIterator, class T, class Compare>
   constexpr ForwardIterator
     upper_bound(ForwardIterator first, ForwardIterator last,
                 const T& value, Compare comp);
-template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
          indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
   constexpr I ranges::upper_bound(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
-template<forward_range R, class T, class Proj = identity,
          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
            ranges::less>
   constexpr borrowed_iterator_t<R>
     ranges::upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
 ```
@@ -6141,26 +8175,29 @@ such that for every iterator `j` in the range \[`first`, `i`),
 projections.
 #### `equal_range` <a id="equal.range">[[equal.range]]</a>
 ``` cpp
-template<class ForwardIterator, class T>
   constexpr pair<ForwardIterator, ForwardIterator>
     equal_range(ForwardIterator first,
                 ForwardIterator last, const T& value);
-template<class ForwardIterator, class T, class Compare>
   constexpr pair<ForwardIterator, ForwardIterator>
     equal_range(ForwardIterator first,
                 ForwardIterator last, const T& value,
                 Compare comp);
-template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
          indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
   constexpr subrange<I>
     ranges::equal_range(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
-template<forward_range R, class T, class Proj = identity,
          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
            ranges::less>
   constexpr borrowed_subrange_t<R>
     ranges::equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {});
 ```
@@ -6170,11 +8207,11 @@ parameters by those names.
 *Preconditions:* The elements `e` of \[`first`, `last`) are partitioned
 with respect to the expressions
 `bool(invoke(comp, invoke(proj, e), value))` and
 `!bool(invoke(comp, value, invoke(proj, e)))`. Also, for all elements
-`e` of `[first, last)`, `bool(comp(e, value))` implies
 `!bool(comp(value, e))` for the overloads in namespace `std`.
 *Returns:*
 - For the overloads in namespace `std`:
@@ -6192,25 +8229,28 @@ with respect to the expressions
 projections.
 #### `binary_search` <a id="binary.search">[[binary.search]]</a>
 ``` cpp
-template<class ForwardIterator, class T>
   constexpr bool
     binary_search(ForwardIterator first, ForwardIterator last,
                   const T& value);
-template<class ForwardIterator, class T, class Compare>
   constexpr bool
     binary_search(ForwardIterator first, ForwardIterator last,
                   const T& value, Compare comp);
-template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
          indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
   constexpr bool ranges::binary_search(I first, S last, const T& value, Comp comp = {},
                                        Proj proj = {});
-template<forward_range R, class T, class Proj = identity,
          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
            ranges::less>
   constexpr bool ranges::binary_search(R&& r, const T& value, Comp comp = {},
                                        Proj proj = {});
 ```
@@ -6220,11 +8260,11 @@ parameters by those names.
 *Preconditions:* The elements `e` of \[`first`, `last`) are partitioned
 with respect to the expressions
 `bool(invoke(comp, invoke(proj, e), value))` and
 `!bool(invoke(comp, value, invoke(proj, e)))`. Also, for all elements
-`e` of `[first, last)`, `bool(comp(e, value))` implies
 `!bool(comp(value, e))` for the overloads in namespace `std`.
 *Returns:* `true` if and only if for some iterator `i` in the range
 \[`first`, `last`),
 `!bool(invoke(comp, invoke(proj, *i), value)) && !bool(invoke(comp, value, invoke(proj, *i)))`
@@ -6246,10 +8286,17 @@ template<input_iterator I, sentinel_for<I> S, class Proj = identity,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr bool ranges::is_partitioned(I first, S last, Pred pred, Proj proj = {});
 template<input_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr bool ranges::is_partitioned(R&& r, Pred pred, Proj proj = {});
 ```
 Let `proj` be `identity{}` for the overloads with no parameter named
 `proj`.
@@ -6264,22 +8311,29 @@ are partitioned with respect to the expression
 template<class ForwardIterator, class Predicate>
   constexpr ForwardIterator
     partition(ForwardIterator first, ForwardIterator last, Predicate pred);
 template<class ExecutionPolicy, class ForwardIterator, class Predicate>
   ForwardIterator
-    partition(ExecutionPolicy&& exec,
-              ForwardIterator first, ForwardIterator last, Predicate pred);
 template<permutable I, sentinel_for<I> S, class Proj = identity,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr subrange<I>
     ranges::partition(I first, S last, Pred pred, Proj proj = {});
 template<forward_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   requires permutable<iterator_t<R>>
   constexpr borrowed_subrange_t<R>
     ranges::partition(R&& r, Pred pred, Proj proj = {});
 ```
 Let `proj` be `identity{}` for the overloads with no parameter named
 `proj` and let E(x) be `bool(invoke(pred, invoke(proj, `x`)))`.
@@ -6296,35 +8350,47 @@ iterator `j` in \[`first`, `i`) and `false` for every iterator `j` in
 - `i` for the overloads in namespace `std`.
 - `{i, last}` for the overloads in namespace `ranges`.
 *Complexity:* Let N = `last - first`:
-- For the overload with no `ExecutionPolicy`, exactly N applications of
   the predicate and projection. At most N / 2 swaps if the type of
   `first` meets the *Cpp17BidirectionalIterator* requirements for the
   overloads in namespace `std` or models `bidirectional_iterator` for
   the overloads in namespace `ranges`, and at most N swaps otherwise.
-- For the overload with an `ExecutionPolicy`, 𝑂(N log N) swaps and 𝑂(N)
   applications of the predicate.
 ``` cpp
 template<class BidirectionalIterator, class Predicate>
   BidirectionalIterator
-    stable_partition(BidirectionalIterator first, BidirectionalIterator last, Predicate pred);
 template<class ExecutionPolicy, class BidirectionalIterator, class Predicate>
   BidirectionalIterator
     stable_partition(ExecutionPolicy&& exec,
                      BidirectionalIterator first, BidirectionalIterator last, Predicate pred);
 template<bidirectional_iterator I, sentinel_for<I> S, class Proj = identity,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   requires permutable<I>
-  subrange<I> ranges::stable_partition(I first, S last, Pred pred, Proj proj = {});
 template<bidirectional_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   requires permutable<iterator_t<R>>
-  borrowed_subrange_t<R> ranges::stable_partition(R&& r, Pred pred, Proj proj = {});
 ```
 Let `proj` be `identity{}` for the overloads with no parameter named
 `proj` and let E(x) be `bool(invoke(pred, invoke(proj, `x`)))`.
@@ -6345,14 +8411,14 @@ range \[`i`, `last`), E(`*j`) is `false`. Returns:
 - `i` for the overloads in namespace `std`.
 - `{i, last}` for the overloads in namespace `ranges`.
 *Complexity:* Let N = `last - first`:
-- For the overloads with no `ExecutionPolicy`, at most N log₂ N swaps,
- but only 𝑂(N) swaps if there is enough extra memory. Exactly N
   applications of the predicate and projection.
-- For the overload with an `ExecutionPolicy`, 𝑂(N log N) swaps and 𝑂(N)
   applications of the predicate.
 ``` cpp
 template<class InputIterator, class OutputIterator1, class OutputIterator2, class Predicate>
   constexpr pair<OutputIterator1, OutputIterator2>
@@ -6376,37 +8442,80 @@ template<input_range R, weakly_incrementable O1, weakly_incrementable O2,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   requires indirectly_copyable<iterator_t<R>, O1> &&
            indirectly_copyable<iterator_t<R>, O2>
   constexpr ranges::partition_copy_result<borrowed_iterator_t<R>, O1, O2>
     ranges::partition_copy(R&& r, O1 out_true, O2 out_false, Pred pred, Proj proj = {});
 ```
 Let `proj` be `identity{}` for the overloads with no parameter named
 `proj` and let E(x) be `bool(invoke(pred, invoke(proj, `x`)))`.
 *Mandates:* For the overloads in namespace `std`, the expression
 `*first` is writable [[iterator.requirements.general]] to `out_true` and
 `out_false`.
 *Preconditions:* The input range and output ranges do not overlap.
-[*Note 1*: For the overload with an `ExecutionPolicy`, there might be a
-performance cost if `first`’s value type does not meet the
-*Cpp17CopyConstructible* requirements. — *end note*]
-*Effects:* For each iterator `i` in \[`first`, `last`), copies `*i` to
-the output range beginning with `out_true` if E(`*i`) is `true`, or to
-the output range beginning with `out_false` otherwise.
-*Returns:* Let `o1` be the end of the output range beginning at
-`out_true`, and `o2` the end of the output range beginning at
-`out_false`. Returns
 - `{o1, o2}` for the overloads in namespace `std`.
-- `{last, o1, o2}` for the overloads in namespace `ranges`.
-*Complexity:* Exactly `last - first` applications of `pred` and `proj`.
 ``` cpp
 template<class ForwardIterator, class Predicate>
   constexpr ForwardIterator
     partition_point(ForwardIterator first, ForwardIterator last, Predicate pred);
@@ -6474,56 +8583,87 @@ template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ra
          class Proj1 = identity, class Proj2 = identity>
   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
   constexpr ranges::merge_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
     ranges::merge(R1&& r1, R2&& r2, O result,
                   Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
-Let N be `(last1 - first1) + (last2 - first2)`. Let `comp` be `less{}`,
-`proj1` be `identity{}`, and `proj2` be `identity{}`, for the overloads
-with no parameters by those names.
 *Preconditions:* The ranges \[`first1`, `last1`) and \[`first2`,
 `last2`) are sorted with respect to `comp` and `proj1` or `proj2`,
 respectively. The resulting range does not overlap with either of the
 original ranges.
-*Effects:* Copies all the elements of the two ranges \[`first1`,
-`last1`) and \[`first2`, `last2`) into the range \[`result`,
-`result_last`), where `result_last` is `result + `N. If an element `a`
-precedes `b` in an input range, `a` is copied into the output range
-before `b`. If `e1` is an element of \[`first1`, `last1`) and `e2` of
-\[`first2`, `last2`), `e2` is copied into the output range before `e1`
-if and only if
-`bool(invoke(comp, invoke(proj2, e2), invoke(proj1, e1)))` is `true`.
 *Returns:*
-- `result_last` for the overloads in namespace `std`.
-- `{last1, last2, result_last}` for the overloads in namespace `ranges`.
 *Complexity:*
-- For the overloads with no `ExecutionPolicy`, at most N - 1 comparisons
   and applications of each projection.
-- For the overloads with an `ExecutionPolicy`, 𝑂(N) comparisons.
 *Remarks:* Stable [[algorithm.stable]].
 ``` cpp
 template<class BidirectionalIterator>
-  void inplace_merge(BidirectionalIterator first,
                                BidirectionalIterator middle,
                                BidirectionalIterator last);
 template<class ExecutionPolicy, class BidirectionalIterator>
   void inplace_merge(ExecutionPolicy&& exec,
                      BidirectionalIterator first,
                      BidirectionalIterator middle,
                      BidirectionalIterator last);
 template<class BidirectionalIterator, class Compare>
-  void inplace_merge(BidirectionalIterator first,
                                BidirectionalIterator middle,
                                BidirectionalIterator last, Compare comp);
 template<class ExecutionPolicy, class BidirectionalIterator, class Compare>
   void inplace_merge(ExecutionPolicy&& exec,
                      BidirectionalIterator first,
@@ -6531,11 +8671,15 @@ template<class ExecutionPolicy, class BidirectionalIterator, class Compare>
                      BidirectionalIterator last, Compare comp);
 template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
          class Proj = identity>
   requires sortable<I, Comp, Proj>
-  I ranges::inplace_merge(I first, I middle, S last, Comp comp = {}, Proj proj = {});
 ```
 Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
 no parameters by those names.
@@ -6553,31 +8697,47 @@ and `proj`.
 *Returns:* `last` for the overload in namespace `ranges`.
 *Complexity:* Let N = `last - first`:
-- For the overloads with no `ExecutionPolicy`, and if enough additional
-  memory is available, exactly N - 1 comparisons.
 - Otherwise, 𝑂(N log N) comparisons.
 In either case, twice as many projections as comparisons.
 *Remarks:* Stable [[algorithm.stable]].
 ``` cpp
 template<bidirectional_range R, class Comp = ranges::less, class Proj = identity>
   requires sortable<iterator_t<R>, Comp, Proj>
-  borrowed_iterator_t<R>
     ranges::inplace_merge(R&& r, iterator_t<R> middle, Comp comp = {}, Proj proj = {});
 ```
 *Effects:* Equivalent to:
 ``` cpp
 return ranges::inplace_merge(ranges::begin(r), middle, ranges::end(r), comp, proj);
 ```
 ### Set operations on sorted structures <a id="alg.set.operations">[[alg.set.operations]]</a>
 #### General <a id="alg.set.operations.general">[[alg.set.operations.general]]</a>
 Subclause [[alg.set.operations]] defines all the basic set operations on
@@ -6618,10 +8778,24 @@ template<input_range R1, input_range R2, class Proj1 = identity,
          class Proj2 = identity,
          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
   constexpr bool ranges::includes(R1&& r1, R2&& r2, Comp comp = {},
                                   Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
 Let `comp` be `less{}`, `proj1` be `identity{}`, and `proj2` be
 `identity{}`, for the overloads with no parameters by those names.
@@ -6679,29 +8853,58 @@ template<input_range R1, input_range R2, weakly_incrementable O,
          class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
   constexpr ranges::set_union_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
     ranges::set_union(R1&& r1, R2&& r2, O result, Comp comp = {},
                       Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
-Let `comp` be `less{}`, and `proj1` and `proj2` be `identity{}` for the
-overloads with no parameters by those names.
 *Preconditions:* The ranges \[`first1`, `last1`) and \[`first2`,
 `last2`) are sorted with respect to `comp` and `proj1` or `proj2`,
 respectively. The resulting range does not overlap with either of the
 original ranges.
-*Effects:* Constructs a sorted union of the elements from the two
-ranges; that is, the set of elements that are present in one or both of
-the ranges.
-*Returns:* Let `result_last` be the end of the constructed range.
-Returns
 - `result_last` for the overloads in namespace `std`.
-- `{last1, last2, result_last}` for the overloads in namespace `ranges`.
 *Complexity:* At most `2 * ((last1 - first1) + (last2 - first2)) - 1`
 comparisons and applications of each projection.
 *Remarks:* Stable [[algorithm.stable]]. If \[`first1`, `last1`) contains
@@ -6753,29 +8956,58 @@ template<input_range R1, input_range R2, weakly_incrementable O,
          class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
   constexpr ranges::set_intersection_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
     ranges::set_intersection(R1&& r1, R2&& r2, O result,
                              Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
-Let `comp` be `less{}`, and `proj1` and `proj2` be `identity{}` for the
-overloads with no parameters by those names.
 *Preconditions:* The ranges \[`first1`, `last1`) and \[`first2`,
 `last2`) are sorted with respect to `comp` and `proj1` or `proj2`,
 respectively. The resulting range does not overlap with either of the
 original ranges.
-*Effects:* Constructs a sorted intersection of the elements from the two
 ranges; that is, the set of elements that are present in both of the
 ranges.
-*Returns:* Let `result_last` be the end of the constructed range.
-Returns
 - `result_last` for the overloads in namespace `std`.
-- `{last1, last2, result_last}` for the overloads in namespace `ranges`.
 *Complexity:* At most `2 * ((last1 - first1) + (last2 - first2)) - 1`
 comparisons and applications of each projection.
 *Remarks:* Stable [[algorithm.stable]]. If \[`first1`, `last1`) contains
@@ -6825,29 +9057,56 @@ template<input_range R1, input_range R2, weakly_incrementable O,
          class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
   constexpr ranges::set_difference_result<borrowed_iterator_t<R1>, O>
     ranges::set_difference(R1&& r1, R2&& r2, O result,
                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
-Let `comp` be `less{}`, and `proj1` and `proj2` be `identity{}` for the
-overloads with no parameters by those names.
 *Preconditions:* The ranges \[`first1`, `last1`) and \[`first2`,
 `last2`) are sorted with respect to `comp` and `proj1` or `proj2`,
 respectively. The resulting range does not overlap with either of the
 original ranges.
-*Effects:* Copies the elements of the range \[`first1`, `last1`) which
-are not present in the range \[`first2`, `last2`) to the range beginning
-at `result`. The elements in the constructed range are sorted.
-*Returns:* Let `result_last` be the end of the constructed range.
-Returns
 - `result_last` for the overloads in namespace `std`.
-- `{last1, result_last}` for the overloads in namespace `ranges`.
 *Complexity:* At most `2 * ((last1 - first1) + (last2 - first2)) - 1`
 comparisons and applications of each projection.
 *Remarks:* If \[`first1`, `last1`) contains m elements that are
@@ -6899,31 +9158,62 @@ template<input_range R1, input_range R2, weakly_incrementable O,
   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
   constexpr ranges::set_symmetric_difference_result<borrowed_iterator_t<R1>,
                                                     borrowed_iterator_t<R2>, O>
     ranges::set_symmetric_difference(R1&& r1, R2&& r2, O result, Comp comp = {},
                                      Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
-Let `comp` be `less{}`, and `proj1` and `proj2` be `identity{}` for the
-overloads with no parameters by those names.
 *Preconditions:* The ranges \[`first1`, `last1`) and \[`first2`,
 `last2`) are sorted with respect to `comp` and `proj1` or `proj2`,
 respectively. The resulting range does not overlap with either of the
 original ranges.
 *Effects:* Copies the elements of the range \[`first1`, `last1`) that
 are not present in the range \[`first2`, `last2`), and the elements of
 the range \[`first2`, `last2`) that are not present in the range
-\[`first1`, `last1`) to the range beginning at `result`. The elements in
-the constructed range are sorted.
-*Returns:* Let `result_last` be the end of the constructed range.
-Returns
 - `result_last` for the overloads in namespace `std`.
-- `{last1, last2, result_last}` for the overloads in namespace `ranges`.
 *Complexity:* At most `2 * ((last1 - first1) + (last2 - first2)) - 1`
 comparisons and applications of each projection.
 *Remarks:* Stable [[algorithm.stable]]. If \[`first1`, `last1`) contains
@@ -7162,10 +9452,26 @@ template<random_access_range R, class Proj = identity,
 ```
 *Effects:* Equivalent to:
 `return ranges::is_heap_until(first, last, comp, proj) == last;`
 ``` cpp
 template<class RandomAccessIterator>
   constexpr RandomAccessIterator
     is_heap_until(RandomAccessIterator first, RandomAccessIterator last);
 template<class ExecutionPolicy, class RandomAccessIterator>
@@ -7188,10 +9494,19 @@ template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
   constexpr I ranges::is_heap_until(I first, S last, Comp comp = {}, Proj proj = {});
 template<random_access_range R, class Proj = identity,
          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
   constexpr borrowed_iterator_t<R>
     ranges::is_heap_until(R&& r, Comp comp = {}, Proj proj = {});
 ```
 Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
 no parameters by those names.
@@ -7237,10 +9552,15 @@ template<copyable T, class Proj = identity,
 template<input_range R, class Proj = identity,
          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
   requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
   constexpr range_value_t<R>
     ranges::min(R&& r, Comp comp = {}, Proj proj = {});
 ```
 *Preconditions:* `ranges::distance(r) > 0`. For the overloads in
 namespace `std`, `T` meets the *Cpp17CopyConstructible* requirements.
 For the first form, `T` meets the *Cpp17LessThanComparable* requirements
@@ -7290,10 +9610,15 @@ template<copyable T, class Proj = identity,
 template<input_range R, class Proj = identity,
          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
   requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
   constexpr range_value_t<R>
     ranges::max(R&& r, Comp comp = {}, Proj proj = {});
 ```
 *Preconditions:* `ranges::distance(r) > 0`. For the overloads in
 namespace `std`, `T` meets the *Cpp17CopyConstructible* requirements.
 For the first form, `T` meets the *Cpp17LessThanComparable* requirements
@@ -7344,10 +9669,15 @@ template<copyable T, class Proj = identity,
 template<input_range R, class Proj = identity,
          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
   requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
   constexpr ranges::minmax_result<range_value_t<R>>
     ranges::minmax(R&& r, Comp comp = {}, Proj proj = {});
 ```
 *Preconditions:* `ranges::distance(r) > 0`. For the overloads in
 namespace `std`, `T` meets the *Cpp17CopyConstructible* requirements.
 For the first form, type `T` meets the *Cpp17LessThanComparable*
@@ -7384,10 +9714,20 @@ template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
   constexpr I ranges::min_element(I first, S last, Comp comp = {}, Proj proj = {});
 template<forward_range R, class Proj = identity,
          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
   constexpr borrowed_iterator_t<R>
     ranges::min_element(R&& r, Comp comp = {}, Proj proj = {});
 ```
 Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
 no parameters by those names.
@@ -7423,10 +9763,20 @@ template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
   constexpr I ranges::max_element(I first, S last, Comp comp = {}, Proj proj = {});
 template<forward_range R, class Proj = identity,
          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
   constexpr borrowed_iterator_t<R>
     ranges::max_element(R&& r, Comp comp = {}, Proj proj = {});
 ```
 Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
 no parameters by those names.
@@ -7465,10 +9815,20 @@ template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
     ranges::minmax_element(I first, S last, Comp comp = {}, Proj proj = {});
 template<forward_range R, class Proj = identity,
          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
   constexpr ranges::minmax_element_result<borrowed_iterator_t<R>>
     ranges::minmax_element(R&& r, Comp comp = {}, Proj proj = {});
 ```
 *Returns:* `{first, first}` if \[`first`, `last`) is empty, otherwise
 `{m, M}`, where `m` is the first iterator in \[`first`, `last`) such
 that no iterator in the range refers to a smaller element, and where `M`
@@ -7551,10 +9911,24 @@ template<input_range R1, input_range R2, class Proj1 = identity,
          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
   constexpr bool
     ranges::lexicographical_compare(R1&& r1, R2&& r2, Comp comp = {},
                                     Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
 *Returns:* `true` if and only if the sequence of elements defined by the
 range \[`first1`, `last1`) is lexicographically less than the sequence
 of elements defined by the range \[`first2`, `last2`).
@@ -7713,10 +10087,11 @@ otherwise `false`. Returns:
 *Complexity:* At most `(last - first) / 2` swaps.
 ## Header `<numeric>` synopsis <a id="numeric.ops.overview">[[numeric.ops.overview]]</a>
 ``` cpp
 namespace std {
   // [accumulate], accumulate
   template<class InputIterator, class T>
     constexpr T accumulate(InputIterator first, InputIterator last, T init);
   template<class InputIterator, class T, class BinaryOperation>
@@ -7732,17 +10107,17 @@ namespace std {
   template<class InputIterator, class T, class BinaryOperation>
     constexpr T reduce(InputIterator first, InputIterator last, T init,
                        BinaryOperation binary_op);
   template<class ExecutionPolicy, class ForwardIterator>
     typename iterator_traits<ForwardIterator>::value_type
-      reduce(ExecutionPolicy&& exec,                            // see [algorithms.parallel.overloads]
              ForwardIterator first, ForwardIterator last);
   template<class ExecutionPolicy, class ForwardIterator, class T>
-    T reduce(ExecutionPolicy&& exec,                            // see [algorithms.parallel.overloads]
              ForwardIterator first, ForwardIterator last, T init);
   template<class ExecutionPolicy, class ForwardIterator, class T, class BinaryOperation>
-    T reduce(ExecutionPolicy&& exec,                            // see [algorithms.parallel.overloads]
              ForwardIterator first, ForwardIterator last, T init, BinaryOperation binary_op);
   // [inner.product], inner product
   template<class InputIterator1, class InputIterator2, class T>
     constexpr T inner_product(InputIterator1 first1, InputIterator1 last1,
@@ -7766,23 +10141,23 @@ namespace std {
            class BinaryOperation, class UnaryOperation>
     constexpr T transform_reduce(InputIterator first, InputIterator last, T init,
                                  BinaryOperation binary_op, UnaryOperation unary_op);
   template<class ExecutionPolicy,
            class ForwardIterator1, class ForwardIterator2, class T>
-    T transform_reduce(ExecutionPolicy&& exec,                  // see [algorithms.parallel.overloads]
                        ForwardIterator1 first1, ForwardIterator1 last1,
                        ForwardIterator2 first2, T init);
   template<class ExecutionPolicy,
            class ForwardIterator1, class ForwardIterator2, class T,
            class BinaryOperation1, class BinaryOperation2>
-    T transform_reduce(ExecutionPolicy&& exec,                  // see [algorithms.parallel.overloads]
                        ForwardIterator1 first1, ForwardIterator1 last1,
                        ForwardIterator2 first2, T init,
                        BinaryOperation1 binary_op1, BinaryOperation2 binary_op2);
   template<class ExecutionPolicy, class ForwardIterator, class T,
            class BinaryOperation, class UnaryOperation>
-    T transform_reduce(ExecutionPolicy&& exec,                  // see [algorithms.parallel.overloads]
                        ForwardIterator first, ForwardIterator last, T init,
                        BinaryOperation binary_op, UnaryOperation unary_op);
   // [partial.sum], partial sum
   template<class InputIterator, class OutputIterator>
@@ -7803,17 +10178,17 @@ namespace std {
     constexpr OutputIterator
       exclusive_scan(InputIterator first, InputIterator last,
                      OutputIterator result, T init, BinaryOperation binary_op);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class T>
     ForwardIterator2
-      exclusive_scan(ExecutionPolicy&& exec,                    // see [algorithms.parallel.overloads]
                      ForwardIterator1 first, ForwardIterator1 last,
                      ForwardIterator2 result, T init);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class T,
            class BinaryOperation>
     ForwardIterator2
-      exclusive_scan(ExecutionPolicy&& exec,                    // see [algorithms.parallel.overloads]
                      ForwardIterator1 first, ForwardIterator1 last,
                      ForwardIterator2 result, T init, BinaryOperation binary_op);
   // [inclusive.scan], inclusive scan
   template<class InputIterator, class OutputIterator>
@@ -7828,23 +10203,23 @@ namespace std {
     constexpr OutputIterator
       inclusive_scan(InputIterator first, InputIterator last,
                      OutputIterator result, BinaryOperation binary_op, T init);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
     ForwardIterator2
-      inclusive_scan(ExecutionPolicy&& exec,                    // see [algorithms.parallel.overloads]
                      ForwardIterator1 first, ForwardIterator1 last,
                      ForwardIterator2 result);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class BinaryOperation>
     ForwardIterator2
-      inclusive_scan(ExecutionPolicy&& exec,                    // see [algorithms.parallel.overloads]
                      ForwardIterator1 first, ForwardIterator1 last,
                      ForwardIterator2 result, BinaryOperation binary_op);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class BinaryOperation, class T>
     ForwardIterator2
-      inclusive_scan(ExecutionPolicy&& exec,                    // see [algorithms.parallel.overloads]
                      ForwardIterator1 first, ForwardIterator1 last,
                      ForwardIterator2 result, BinaryOperation binary_op, T init);
   // [transform.exclusive.scan], transform exclusive scan
   template<class InputIterator, class OutputIterator, class T,
@@ -7854,11 +10229,11 @@ namespace std {
                                OutputIterator result, T init,
                                BinaryOperation binary_op, UnaryOperation unary_op);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class T,
            class BinaryOperation, class UnaryOperation>
     ForwardIterator2
-      transform_exclusive_scan(ExecutionPolicy&& exec,          // see [algorithms.parallel.overloads]
                                ForwardIterator1 first, ForwardIterator1 last,
                                ForwardIterator2 result, T init,
                                BinaryOperation binary_op, UnaryOperation unary_op);
   // [transform.inclusive.scan], transform inclusive scan
@@ -7875,18 +10250,18 @@ namespace std {
                                OutputIterator result,
                                BinaryOperation binary_op, UnaryOperation unary_op, T init);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class BinaryOperation, class UnaryOperation>
     ForwardIterator2
-      transform_inclusive_scan(ExecutionPolicy&& exec,          // see [algorithms.parallel.overloads]
                                ForwardIterator1 first, ForwardIterator1 last,
                                ForwardIterator2 result, BinaryOperation binary_op,
                                UnaryOperation unary_op);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class BinaryOperation, class UnaryOperation, class T>
     ForwardIterator2
-      transform_inclusive_scan(ExecutionPolicy&& exec,          // see [algorithms.parallel.overloads]
                                ForwardIterator1 first, ForwardIterator1 last,
                                ForwardIterator2 result,
                                BinaryOperation binary_op, UnaryOperation unary_op, T init);
   // [adjacent.difference], adjacent difference
@@ -7898,17 +10273,17 @@ namespace std {
     constexpr OutputIterator
       adjacent_difference(InputIterator first, InputIterator last,
                           OutputIterator result, BinaryOperation binary_op);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
     ForwardIterator2
-      adjacent_difference(ExecutionPolicy&& exec,               // see [algorithms.parallel.overloads]
                           ForwardIterator1 first, ForwardIterator1 last,
                           ForwardIterator2 result);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class BinaryOperation>
     ForwardIterator2
-      adjacent_difference(ExecutionPolicy&& exec,               // see [algorithms.parallel.overloads]
                           ForwardIterator1 first, ForwardIterator1 last,
                           ForwardIterator2 result, BinaryOperation binary_op);
   // [numeric.iota], iota
   template<class ForwardIterator, class T>
@@ -7937,10 +10312,22 @@ namespace std {
   // [numeric.ops.midpoint], midpoint
   template<class T>
     constexpr T midpoint(T a, T b) noexcept;
   template<class T>
     constexpr T* midpoint(T* a, T* b);
 }
 ```
 ## Generalized numeric operations <a id="numeric.ops">[[numeric.ops]]</a>
@@ -7950,20 +10337,20 @@ namespace std {
 specify requirements throughout [[numeric.ops]] is
 intentional. — *end note*]
 ### Definitions <a id="numerics.defns">[[numerics.defns]]</a>
-Define `GENERALIZED_NONCOMMUTATIVE_SUM(op, a1, ..., aN)` as follows:
 - `a1` when `N` is `1`, otherwise
-- `op(GENERALIZED_NONCOMMUTATIVE_SUM(op, a1, ..., aK),`
-  `\phantom{op(}GENERALIZED_NONCOMMUTATIVE_SUM(op, aM, ..., aN))` for
- any `K` where 1 < K+1 = M ≤ N.
-Define `GENERALIZED_SUM(op, a1, ..., aN)` as
-`GENERALIZED_NONCOMMUTATIVE_SUM(op, b1, ..., bN)`, where `b1, ..., bN`
-may be any permutation of `a1, ..., aN`.
 ### Accumulate <a id="accumulate">[[accumulate]]</a>
 ``` cpp
 template<class InputIterator, class T>
@@ -8060,11 +10447,11 @@ are convertible to `T`.
 - `T` meets the *Cpp17MoveConstructible* ([[cpp17.moveconstructible]])
   requirements.
 - `binary_op` neither invalidates iterators or subranges, nor modifies
   elements in the range \[`first`, `last`\].
-*Returns:* *GENERALIZED_SUM*(binary_op, init, \*i, ...) for every `i` in
 \[`first`, `last`).
 *Complexity:* 𝑂(`last - first`) applications of `binary_op`.
 [*Note 1*: The difference between `reduce` and `accumulate` is that
@@ -8168,11 +10555,11 @@ are convertible to `T`.
   `first2 + (last1 - first1)`\].
 *Returns:*
 ``` cpp
-GENERALIZED_SUM(binary_op1, init, binary_op2(*i, *(first2 + (i - first1))), ...)
 ```
 for every iterator `i` in \[`first1`, `last1`).
 *Complexity:* 𝑂(`last1 - first1`) applications each of `binary_op1` and
@@ -8208,11 +10595,11 @@ are convertible to `T`.
   elements in the range \[`first`, `last`\].
 *Returns:*
 ``` cpp
-GENERALIZED_SUM(binary_op, init, unary_op(*i), ...)
 ```
 for every iterator `i` in \[`first`, `last`).
 *Complexity:* 𝑂(`last - first`) applications each of `unary_op` and
@@ -8320,11 +10707,11 @@ are convertible to `T`.
 *Effects:* For each integer `K` in \[`0`, `last - first`) assigns
 through `result + K` the value of:
 ``` cpp
 GENERALIZED_NONCOMMUTATIVE_SUM(
-    binary_op, init, *(first + 0), *(first + 1), ..., *(first + K - 1))
 ```
 *Returns:* The end of the resulting range beginning at `result`.
 *Complexity:* 𝑂(`last - first`) applications of `binary_op`.
@@ -8411,15 +10798,14 @@ convertible to `U`.
 *Effects:* For each integer `K` in \[`0`, `last - first`) assigns
 through `result + K` the value of
 - *GENERALIZED_NONCOMMUTATIVE_SUM*(
-      binary_op, init, \*(first + 0), \*(first + 1), ..., \*(first +
-  K))
   if `init` is provided, or
 - *GENERALIZED_NONCOMMUTATIVE_SUM*(
-      binary_op, \*(first + 0), \*(first + 1), ..., \*(first + K))
   otherwise.
 *Returns:* The end of the resulting range beginning at `result`.
 *Complexity:* 𝑂(`last - first`) applications of `binary_op`.
@@ -8470,11 +10856,11 @@ are convertible to `T`.
 through `result + K` the value of:
 ``` cpp
 GENERALIZED_NONCOMMUTATIVE_SUM(
     binary_op, init,
-    unary_op(*(first + 0)), unary_op(*(first + 1)), ..., unary_op(*(first + K - 1)))
 ```
 *Returns:* The end of the resulting range beginning at `result`.
 *Complexity:* 𝑂(`last - first`) applications each of `unary_op` and
@@ -8547,16 +10933,16 @@ are convertible to `T`; otherwise,
 *Effects:* For each integer `K` in \[`0`, `last - first`) assigns
 through `result + K` the value of
 - *GENERALIZED_NONCOMMUTATIVE_SUM*(
       binary_op, init,
-      unary_op(\*(first + 0)), unary_op(\*(first + 1)), ...,
   unary_op(\*(first + K)))
   if `init` is provided, or
 - *GENERALIZED_NONCOMMUTATIVE_SUM*(
       binary_op,
-      unary_op(\*(first + 0)), unary_op(\*(first + 1)), ...,
   unary_op(\*(first + K)))
   otherwise.
 *Returns:* The end of the resulting range beginning at `result`.
@@ -8626,12 +11012,12 @@ every iterator `i` in \[`first + 1`, `last`) in order, creates an object
 `val` whose type is `T`, initializes it with `*i`, computes
 `binary_op(val, std::move(acc))`, assigns the result to
 `*(result + (i - first))`, and move assigns from `val` to `acc`.
 For the overloads with an `ExecutionPolicy` and a non-empty range,
-performs `*result = *first`. Then, for every `d` in
-`[1, last - first - 1]`, performs
 `*(result + d) = binary_op(*(first + d), *(first + (d - 1)))`.
 *Returns:* `result + (last - first)`.
 *Complexity:* Exactly `(last - first) - 1` applications of the binary
@@ -8750,10 +11136,86 @@ considered to be equivalent to a pointer to a hypothetical array element
 n for this purpose. — *end note*]
 *Returns:* A pointer to array element $i+\frac{j-i}{2}$ of `x`, where
 the result of the division is truncated towards zero.
 ## Specialized `<memory>` algorithms <a id="specialized.algorithms">[[specialized.algorithms]]</a>
 ### General <a id="specialized.algorithms.general">[[specialized.algorithms.general]]</a>
 The contents specified in [[specialized.algorithms]] are declared in the
@@ -8762,18 +11224,31 @@ header `<memory>`.
 Unless otherwise specified, if an exception is thrown in the following
 algorithms, objects constructed by a placement *new-expression*
 [[expr.new]] are destroyed in an unspecified order before allowing the
 exception to propagate.
 Some algorithms specified in [[specialized.algorithms]] make use of the
-exposition-only function `voidify`:
 ``` cpp
 template<class T>
   constexpr void* voidify(T& obj) noexcept {
     return addressof(obj);
   }
 ```
 ### Special memory concepts <a id="special.mem.concepts">[[special.mem.concepts]]</a>
 Some algorithms in this subclause are constrained with the following
@@ -8806,10 +11281,25 @@ assignment, or comparisons between valid values of type `I` and `S`.
 [*Note 2*: This concept allows some `sentinel_for`
 [[iterator.concept.sentinel]] operations to throw
 exceptions. — *end note*]
 ``` cpp
 template<class R>
 concept nothrow-input-range = // exposition only
   range<R> &&
   nothrow-input-iterator<iterator_t<R>> &&
@@ -8826,44 +11316,97 @@ concept nothrow-forward-iterator = // exposition only
   nothrow-input-iterator<I> &&
   forward_iterator<I> &&
   nothrow-sentinel-for<I, I>;
 ```
-[*Note 3*: This concept allows some `forward_iterator`
 [[iterator.concept.forward]] operations to throw
 exceptions. — *end note*]
 ``` cpp
 template<class R>
 concept nothrow-forward-range = // exposition only
   nothrow-input-range<R> &&
   nothrow-forward-iterator<iterator_t<R>>;
 ```
 ### `uninitialized_default_construct` <a id="uninitialized.construct.default">[[uninitialized.construct.default]]</a>
 ``` cpp
 template<class NoThrowForwardIterator>
-  void uninitialized_default_construct(NoThrowForwardIterator first, NoThrowForwardIterator last);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; ++first)
-  ::new (voidify(*first))
-    typename iterator_traits<NoThrowForwardIterator>::value_type;
 ```
 ``` cpp
 namespace ranges {
   template<nothrow-forward-iterator I, nothrow-sentinel-for<I> S>
     requires default_initializable<iter_value_t<I>>
-    I uninitialized_default_construct(I first, S last);
   template<nothrow-forward-range R>
     requires default_initializable<range_value_t<R>>
-    borrowed_iterator_t<R> uninitialized_default_construct(R&& r);
 }
 ```
 *Effects:* Equivalent to:
@@ -8873,27 +11416,27 @@ for (; first != last; ++first)
 return first;
 ```
 ``` cpp
 template<class NoThrowForwardIterator, class Size>
- NoThrowForwardIterator uninitialized_default_construct_n(NoThrowForwardIterator first, Size n);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; n > 0; (void)++first, --n)
-  ::new (voidify(*first))
-    typename iterator_traits<NoThrowForwardIterator>::value_type;
 return first;
 ```
 ``` cpp
 namespace ranges {
   template<nothrow-forward-iterator I>
     requires default_initializable<iter_value_t<I>>
-    I uninitialized_default_construct_n(I first, iter_difference_t<I> n);
 }
 ```
 *Effects:* Equivalent to:
@@ -8904,29 +11447,29 @@ return uninitialized_default_construct(counted_iterator(first, n),
 ### `uninitialized_value_construct` <a id="uninitialized.construct.value">[[uninitialized.construct.value]]</a>
 ``` cpp
 template<class NoThrowForwardIterator>
-  void uninitialized_value_construct(NoThrowForwardIterator first, NoThrowForwardIterator last);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; ++first)
-  ::new (voidify(*first))
-    typename iterator_traits<NoThrowForwardIterator>::value_type();
 ```
 ``` cpp
 namespace ranges {
   template<nothrow-forward-iterator I, nothrow-sentinel-for<I> S>
     requires default_initializable<iter_value_t<I>>
-    I uninitialized_value_construct(I first, S last);
   template<nothrow-forward-range R>
     requires default_initializable<range_value_t<R>>
-    borrowed_iterator_t<R> uninitialized_value_construct(R&& r);
 }
 ```
 *Effects:* Equivalent to:
@@ -8936,27 +11479,27 @@ for (; first != last; ++first)
 return first;
 ```
 ``` cpp
 template<class NoThrowForwardIterator, class Size>
- NoThrowForwardIterator uninitialized_value_construct_n(NoThrowForwardIterator first, Size n);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; n > 0; (void)++first, --n)
-  ::new (voidify(*first))
-    typename iterator_traits<NoThrowForwardIterator>::value_type();
 return first;
 ```
 ``` cpp
 namespace ranges {
   template<nothrow-forward-iterator I>
     requires default_initializable<iter_value_t<I>>
-    I uninitialized_value_construct_n(I first, iter_difference_t<I> n);
 }
 ```
 *Effects:* Equivalent to:
@@ -8967,37 +11510,36 @@ return uninitialized_value_construct(counted_iterator(first, n),
 ### `uninitialized_copy` <a id="uninitialized.copy">[[uninitialized.copy]]</a>
 ``` cpp
 template<class InputIterator, class NoThrowForwardIterator>
-  NoThrowForwardIterator uninitialized_copy(InputIterator first, InputIterator last,
                                                       NoThrowForwardIterator result);
 ```
 *Preconditions:* `result`+\[0, `(last - first)`) does not overlap with
 \[`first`, `last`).
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; ++result, (void)++first)
-  ::new (voidify(*result))
-    typename iterator_traits<NoThrowForwardIterator>::value_type(*first);
 ```
 *Returns:* `result`.
 ``` cpp
 namespace ranges {
   template<input_iterator I, sentinel_for<I> S1,
            nothrow-forward-iterator O, nothrow-sentinel-for<O> S2>
     requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
-    uninitialized_copy_result<I, O>
       uninitialized_copy(I ifirst, S1 ilast, O ofirst, S2 olast);
   template<input_range IR, nothrow-forward-range OR>
     requires constructible_from<range_value_t<OR>, range_reference_t<IR>>
-    uninitialized_copy_result<borrowed_iterator_t<IR>, borrowed_iterator_t<OR>>
       uninitialized_copy(IR&& in_range, OR&& out_range);
 }
 ```
 *Preconditions:* \[`ofirst`, `olast`) does not overlap with \[`ifirst`,
@@ -9011,32 +11553,31 @@ for (; ifirst != ilast && ofirst != olast; ++ofirst, (void)++ifirst)
 return {std::move(ifirst), ofirst};
 ```
 ``` cpp
 template<class InputIterator, class Size, class NoThrowForwardIterator>
-  NoThrowForwardIterator uninitialized_copy_n(InputIterator first, Size n,
                                                         NoThrowForwardIterator result);
 ```
 *Preconditions:* `result`+\[0, `n`) does not overlap with `first`+\[0,
 `n`).
 *Effects:* Equivalent to:
 ``` cpp
 for (; n > 0; ++result, (void)++first, --n)
-  ::new (voidify(*result))
-    typename iterator_traits<NoThrowForwardIterator>::value_type(*first);
 ```
 *Returns:* `result`.
 ``` cpp
 namespace ranges {
   template<input_iterator I, nothrow-forward-iterator O, nothrow-sentinel-for<O> S>
     requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
-    uninitialized_copy_n_result<I, O>
       uninitialized_copy_n(I ifirst, iter_difference_t<I> n, O ofirst, S olast);
 }
 ```
 *Preconditions:* \[`ofirst`, `olast`) does not overlap with
@@ -9052,11 +11593,11 @@ return {std::move(t.in).base(), t.out};
 ### `uninitialized_move` <a id="uninitialized.move">[[uninitialized.move]]</a>
 ``` cpp
 template<class InputIterator, class NoThrowForwardIterator>
-  NoThrowForwardIterator uninitialized_move(InputIterator first, InputIterator last,
                                                       NoThrowForwardIterator result);
 ```
 *Preconditions:* `result`+\[0, `(last - first)`) does not overlap with
 \[`first`, `last`).
@@ -9064,24 +11605,24 @@ template<class InputIterator, class NoThrowForwardIterator>
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; (void)++result, ++first)
   ::new (voidify(*result))
- typename iterator_traits<NoThrowForwardIterator>::value_type(std::move(*first));
 return result;
 ```
 ``` cpp
 namespace ranges {
   template<input_iterator I, sentinel_for<I> S1,
            nothrow-forward-iterator O, nothrow-sentinel-for<O> S2>
     requires constructible_from<iter_value_t<O>, iter_rvalue_reference_t<I>>
-    uninitialized_move_result<I, O>
       uninitialized_move(I ifirst, S1 ilast, O ofirst, S2 olast);
   template<input_range IR, nothrow-forward-range OR>
     requires constructible_from<range_value_t<OR>, range_rvalue_reference_t<IR>>
-    uninitialized_move_result<borrowed_iterator_t<IR>, borrowed_iterator_t<OR>>
       uninitialized_move(IR&& in_range, OR&& out_range);
 }
 ```
 *Preconditions:* \[`ofirst`, `olast`) does not overlap with \[`ifirst`,
@@ -9100,11 +11641,11 @@ return {std::move(ifirst), ofirst};
 \[`ifirst`, `ilast`) are left in a valid, but unspecified
 state. — *end note*]
 ``` cpp
 template<class InputIterator, class Size, class NoThrowForwardIterator>
-  pair<InputIterator, NoThrowForwardIterator>
     uninitialized_move_n(InputIterator first, Size n, NoThrowForwardIterator result);
 ```
 *Preconditions:* `result`+\[0, `n`) does not overlap with `first`+\[0,
 `n`).
@@ -9112,19 +11653,19 @@ template<class InputIterator, class Size, class NoThrowForwardIterator>
 *Effects:* Equivalent to:
 ``` cpp
 for (; n > 0; ++result, (void)++first, --n)
   ::new (voidify(*result))
- typename iterator_traits<NoThrowForwardIterator>::value_type(std::move(*first));
 return {first, result};
 ```
 ``` cpp
 namespace ranges {
   template<input_iterator I, nothrow-forward-iterator O, nothrow-sentinel-for<O> S>
     requires constructible_from<iter_value_t<O>, iter_rvalue_reference_t<I>>
-    uninitialized_move_n_result<I, O>
       uninitialized_move_n(I ifirst, iter_difference_t<I> n, O ofirst, S olast);
 }
 ```
 *Preconditions:* \[`ofirst`, `olast`) does not overlap with
@@ -9144,29 +11685,29 @@ state. — *end note*]
 ### `uninitialized_fill` <a id="uninitialized.fill">[[uninitialized.fill]]</a>
 ``` cpp
 template<class NoThrowForwardIterator, class T>
-  void uninitialized_fill(NoThrowForwardIterator first, NoThrowForwardIterator last, const T& x);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; ++first)
-  ::new (voidify(*first))
-    typename iterator_traits<NoThrowForwardIterator>::value_type(x);
 ```
 ``` cpp
 namespace ranges {
   template<nothrow-forward-iterator I, nothrow-sentinel-for<I> S, class T>
     requires constructible_from<iter_value_t<I>, const T&>
-    I uninitialized_fill(I first, S last, const T& x);
   template<nothrow-forward-range R, class T>
     requires constructible_from<range_value_t<R>, const T&>
-    borrowed_iterator_t<R> uninitialized_fill(R&& r, const T& x);
 }
 ```
 *Effects:* Equivalent to:
@@ -9176,27 +11717,27 @@ for (; first != last; ++first)
 return first;
 ```
 ``` cpp
 template<class NoThrowForwardIterator, class Size, class T>
- NoThrowForwardIterator uninitialized_fill_n(NoThrowForwardIterator first, Size n, const T& x);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; n--; ++first)
-  ::new (voidify(*first))
-    typename iterator_traits<NoThrowForwardIterator>::value_type(x);
 return first;
 ```
 ``` cpp
 namespace ranges {
   template<nothrow-forward-iterator I, class T>
     requires constructible_from<iter_value_t<I>, const T&>
-    I uninitialized_fill_n(I first, iter_difference_t<I> n, const T& x);
 }
 ```
 *Effects:* Equivalent to:
@@ -9214,17 +11755,22 @@ namespace ranges {
   template<class T, class... Args>
     constexpr T* construct_at(T* location, Args&&... args);
 }
 ```
-*Constraints:* The expression
 `::new (declval<void*>()) T(declval<Args>()...)` is well-formed when
 treated as an unevaluated operand [[term.unevaluated.operand]].
 *Effects:* Equivalent to:
 ``` cpp
   return ::new (voidify(*location)) T(std::forward<Args>(args)...);
 ```
 ### `destroy` <a id="specialized.destroy">[[specialized.destroy]]</a>
@@ -9299,19 +11845,121 @@ namespace ranges {
 ``` cpp
 return destroy(counted_iterator(std::move(first), n), default_sentinel).base();
 ```
 ## C library algorithms <a id="alg.c.library">[[alg.c.library]]</a>
 [*Note 1*: The header `<cstdlib>` declares the functions described in
 this subclause. — *end note*]
 ``` cpp
-void* bsearch(const void* key, const void* base, size_t nmemb, size_t size,
               c-compare-pred* compar);
-void* bsearch(const void* key, const void* base, size_t nmemb, size_t size,
                     compare-pred* compar);
 void qsort(void* base, size_t nmemb, size_t size, c-compare-pred* compar);
 void qsort(void* base, size_t nmemb, size_t size, compare-pred* compar);
 ```
@@ -9322,11 +11970,11 @@ void qsort(void* base, size_t nmemb, size_t size, compare-pred* compar);
 standard library.
 *Throws:* Any exception thrown by `compar`
 [[res.on.exception.handling]].
-See also: ISO C 7.22.5
 <!-- Link reference definitions -->
 [accumulate]: #accumulate
 [adjacent.difference]: #adjacent.difference
 [alg.adjacent.find]: #alg.adjacent.find
@@ -9346,24 +11994,29 @@ See also: ISO C 7.22.5
 [alg.find.end]: #alg.find.end
 [alg.find.first.of]: #alg.find.first.of
 [alg.find.last]: #alg.find.last
 [alg.fold]: #alg.fold
 [alg.foreach]: #alg.foreach
 [alg.generate]: #alg.generate
 [alg.heap.operations]: #alg.heap.operations
 [alg.heap.operations.general]: #alg.heap.operations.general
 [alg.is.permutation]: #alg.is.permutation
 [alg.lex.comparison]: #alg.lex.comparison
 [alg.merge]: #alg.merge
 [alg.min.max]: #alg.min.max
 [alg.modifying.operations]: #alg.modifying.operations
 [alg.move]: #alg.move
 [alg.none.of]: #alg.none.of
 [alg.nonmodifying]: #alg.nonmodifying
 [alg.nth.element]: #alg.nth.element
 [alg.partitions]: #alg.partitions
 [alg.permutation.generators]: #alg.permutation.generators
 [alg.random.sample]: #alg.random.sample
 [alg.random.shuffle]: #alg.random.shuffle
 [alg.remove]: #alg.remove
 [alg.replace]: #alg.replace
 [alg.reverse]: #alg.reverse
@@ -9391,13 +12044,14 @@ See also: ISO C 7.22.5
 [algorithms.parallel.overloads]: #algorithms.parallel.overloads
 [algorithms.parallel.user]: #algorithms.parallel.user
 [algorithms.requirements]: #algorithms.requirements
 [algorithms.results]: #algorithms.results
 [algorithms.summary]: #algorithms.summary
 [basic.compound]: basic.md#basic.compound
-[basic.lookup.argdep]: basic.md#basic.lookup.argdep
-[basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [bidirectional.iterators]: iterators.md#bidirectional.iterators
 [binary.search]: #binary.search
 [class.conv]: class.md#class.conv
 [concept.booleantestable]: concepts.md#concept.booleantestable
 [containers]: containers.md#containers
@@ -9406,21 +12060,30 @@ See also: ISO C 7.22.5
 [cpp17.copyconstructible]: #cpp17.copyconstructible
 [cpp17.lessthancomparable]: #cpp17.lessthancomparable
 [cpp17.moveassignable]: #cpp17.moveassignable
 [cpp17.moveconstructible]: #cpp17.moveconstructible
 [equal.range]: #equal.range
 [exclusive.scan]: #exclusive.scan
-[execpol]: utilities.md#execpol
-[expr.call]: expr.md#expr.call
 [expr.new]: expr.md#expr.new
 [forward.iterators]: iterators.md#forward.iterators
 [function.objects]: utilities.md#function.objects
 [includes]: #includes
 [inclusive.scan]: #inclusive.scan
 [inner.product]: #inner.product
 [input.iterators]: iterators.md#input.iterators
 [intro.execution]: basic.md#intro.execution
 [intro.progress]: basic.md#intro.progress
 [is.heap]: #is.heap
 [is.sorted]: #is.sorted
 [iterator.concept.bidir]: iterators.md#iterator.concept.bidir
 [iterator.concept.forward]: iterators.md#iterator.concept.forward
@@ -9430,19 +12093,21 @@ See also: ISO C 7.22.5
 [iterator.concept.sizedsentinel]: iterators.md#iterator.concept.sizedsentinel
 [iterator.requirements]: iterators.md#iterator.requirements
 [iterator.requirements.general]: iterators.md#iterator.requirements.general
 [lower.bound]: #lower.bound
 [make.heap]: #make.heap
-[mismatch]: #mismatch
 [multiset]: containers.md#multiset
 [numeric.iota]: #numeric.iota
 [numeric.ops]: #numeric.ops
 [numeric.ops.gcd]: #numeric.ops.gcd
 [numeric.ops.general]: #numeric.ops.general
 [numeric.ops.lcm]: #numeric.ops.lcm
 [numeric.ops.midpoint]: #numeric.ops.midpoint
 [numeric.ops.overview]: #numeric.ops.overview
 [numerics.defns]: #numerics.defns
 [output.iterators]: iterators.md#output.iterators
 [partial.sort]: #partial.sort
 [partial.sort.copy]: #partial.sort.copy
 [partial.sum]: #partial.sum
@@ -9465,11 +12130,10 @@ See also: ISO C 7.22.5
 [specialized.algorithms.general]: #specialized.algorithms.general
 [specialized.construct]: #specialized.construct
 [specialized.destroy]: #specialized.destroy
 [stable.sort]: #stable.sort
 [swappable.requirements]: library.md#swappable.requirements
-[temp.func.order]: temp.md#temp.func.order
 [term.unevaluated.operand]: expr.md#term.unevaluated.operand
 [thread.jthread.class]: thread.md#thread.jthread.class
 [thread.thread.class]: thread.md#thread.thread.class
 [transform.exclusive.scan]: #transform.exclusive.scan
 [transform.inclusive.scan]: #transform.inclusive.scan

 This Clause describes components that C++ programs may use to perform
 algorithmic operations on containers [[containers]] and other sequences.
 The following subclauses describe components for non-modifying sequence
 operations, mutating sequence operations, sorting and related
+operations, and algorithms from the C library, as summarized in
 [[algorithms.summary]].
 **Table: Algorithms library summary** <a id="algorithms.summary">[algorithms.summary]</a>
 | Subclause                    |                                   | Header        |
 | ---------------------------- | --------------------------------- | ------------- |
 | [[algorithms.requirements]]  | Algorithms requirements           |               |
+| [[algorithms.parallel]]      | Parallel algorithms               | `<execution>` |
 | [[algorithms.results]]       | Algorithm result types            | `<algorithm>` |
 | [[alg.nonmodifying]]         | Non-modifying sequence operations |               |
 | [[alg.modifying.operations]] | Mutating sequence operations      |               |
 | [[alg.sorting]]              | Sorting and related operations    |               |
 | [[numeric.ops]]              | Generalized numeric operations    | `<numeric>`   |
 | [[specialized.algorithms]]   | Specialized `<memory>` algorithms | `<memory>`    |
+| [[alg.rand]]                 | Specialized `<random>` algorithms | `<random>`    |
 | [[alg.c.library]]            | C library algorithms              | `<cstdlib>`   |
 ## Algorithms requirements <a id="algorithms.requirements">[[algorithms.requirements]]</a>
 of data structures and are parameterized by iterator types. Because of
 this, they can work with program-defined data structures, as long as
 these data structures have iterator types satisfying the assumptions on
 the algorithms.
+The entities defined in the `std::ranges` namespace in this Clause and
+specified as function templates are algorithm function objects
+[[alg.func.obj]].
 For purposes of determining the existence of data races, algorithms
 shall not modify objects referenced through an iterator argument unless
 the specification requires such modification.
 iter_difference_t<decltype(b)> n = 0;
 for (auto tmp = b; tmp != a; ++tmp) --n;
 return n;
 ```
+For each iterator `i` and sentinel `s` produced from a range `r`, the
+semantics of `s - i` has the same type, value, and value category as
+`ranges::distance(i, s)`.
+[*Note 3*: The implementation can use `ranges::distance(r)` when that
+produces the same value as `ranges::distance(i, s)`. This can be more
+efficient for sized ranges. — *end note*]
 In the description of the algorithms, given an iterator `a` whose
 difference type is `D`, and an expression `n` of integer-like type other
 than cv `D`, the semantics of `a + n` and `a - n` are, respectively,
 those of `a + D(n)` and `a - D(n)`.
 denoting the end of a range \[`i`, `s`) is sometimes returned where an
 iterator is expected. In these cases, the semantics are as if the
 sentinel is converted into an iterator using `ranges::next(i, s)`.
 Overloads of algorithms that take `range` arguments [[range.range]]
+behave as if they are implemented by dispatching to the overload in
+namespace `ranges` that takes separate iterator and sentinel arguments,
+where for each range argument `r`
+- a corresponding iterator argument is initialized with
+  `ranges::begin(r)` and
+- a corresponding sentinel argument is initialized with
+  `ranges::end(r)`, or
+  `ranges::next(ranges::{}begin(r), ranges::end(r))` if the type of `r`
+  models `forward_range` and computing `ranges::next` meets the
+  specified complexity requirements.
 The well-formedness and behavior of a call to an algorithm with an
 explicitly-specified template argument list is unspecified, except where
 explicitly stated otherwise.
+[*Note 4*: Consequently, an implementation can declare an algorithm
 with different template parameters than those presented. — *end note*]
 ## Parallel algorithms <a id="algorithms.parallel">[[algorithms.parallel]]</a>
 ### Preamble <a id="algorithms.parallel.defns">[[algorithms.parallel.defns]]</a>
 Subclause [[algorithms.parallel]] describes components that C++ programs
 may use to perform operations on containers and other sequences in
 parallel.
 A *parallel algorithm* is a function template listed in this document
+with a template parameter named `ExecutionPolicy` or constrained by the
+following exposition-only concept:
+``` cpp
+template<class Ep>
+  concept execution-policy = is_execution_policy_v<remove_cvref_t<Ep>>;     // exposition only
+```
+Such a template parameter is termed an
+*execution policy template parameter*.
+A parallel algorithm accesses objects indirectly accessible via its
 arguments by invoking the following functions:
+- All operations of the categories of the iterators, sentinels, or
+ `mdspan` types that the algorithm is instantiated with.
 - Operations on those sequence elements that are required by its
   specification.
+- User-provided invocable objects to be applied during the execution of
   the algorithm, if required by the specification.
+- Operations on those invocable objects required by the specification.
   \[*Note 1*: See  [[algorithms.requirements]]. — *end note*]
 These functions are herein called *element access functions*.
 [*Example 1*:
 — *end example*]
 A standard library function is *vectorization-unsafe* if it is specified
 to synchronize with another function invocation, or another function
 invocation is specified to synchronize with it, and if it is not a
+memory allocation or deallocation function or lock-free atomic
+modify-write operation [[atomics.order]].
 [*Note 2*: Implementations must ensure that internal synchronization
 inside standard library functions does not prevent forward progress when
 those functions are executed by threads of execution with weakly
 parallel forward progress guarantees. — *end note*]
 — *end example*]
 ### Requirements on user-provided function objects <a id="algorithms.parallel.user">[[algorithms.parallel.user]]</a>
+Unless otherwise specified, invocable objects passed into parallel
+algorithms as objects of a type denoted by a template parameter named
+`Predicate`, `BinaryPredicate`, `Compare`, `UnaryOperation`,
+`BinaryOperation`, `BinaryOperation1`, `BinaryOperation2`,
+`BinaryDivideOp`, or constrained by a concept that subsumes
+`regular_invocable` and the operators used by the analogous overloads to
 these parallel algorithms that are formed by an invocation with the
 specified default predicate or operation (where applicable) shall not
 directly or indirectly modify objects via their arguments, nor shall
 they rely on the identity of the provided objects.
 ### Effect of execution policies on algorithm execution <a id="algorithms.parallel.exec">[[algorithms.parallel.exec]]</a>
+An execution policy template parameter describes the manner in which the
+execution of a parallel algorithm may be parallelized and the manner in
+which it applies the element access functions.
 If an object is modified by an element access function, the algorithm
 will perform no other unsynchronized accesses to that object. The
 modifying element access functions are those which are specified as
 modifying the object.
 resources are required for parallelization and none are available, the
 algorithm throws a `bad_alloc` exception.
 During the execution of a parallel algorithm, if the invocation of an
 element access function exits via an uncaught exception, the behavior is
+determined by the execution policy.
+### Parallel algorithm overloads <a id="algorithms.parallel.overloads">[[algorithms.parallel.overloads]]</a>
 Parallel algorithms are algorithm overloads. Each parallel algorithm
+overload has an additional function parameter P of type `T&&` as the
+first function parameter, where `T` is the execution policy template
+parameter.
 [*Note 1*: Not all algorithms have parallel algorithm
 overloads. — *end note*]
+Unless otherwise specified, the semantics of calling a parallel
+algorithm overload are identical to calling the corresponding algorithm
+overload without the parameter P, using all but the first argument.
+Unless otherwise specified, the complexity requirements of a parallel
+algorithm overload are relaxed from the complexity requirements of the
+corresponding overload without the parameter P as follows: when the
+guarantee says “at most *expr*” or “exactly *expr*” and does not specify
+the number of assignments or swaps, and *expr* is not already expressed
+with 𝑂() notation, the complexity of the algorithm shall be
 𝑂(\placeholder{expr}).
+A parallel algorithm with a template parameter named `ExecutionPolicy`
+shall not participate in overload resolution unless that template
+parameter satisfies `execution-policy`.
+### Execution policies <a id="execpol">[[execpol]]</a>
+#### General <a id="execpol.general">[[execpol.general]]</a>
+Subclause  [[execpol]] describes classes that are *execution policy*
+types. An object of an execution policy type indicates the kinds of
+parallelism allowed in the execution of an algorithm and expresses the
+consequent requirements on the element access functions. Execution
+policy types are declared in header `<execution>`.
+[*Example 1*:
+``` cpp
+using namespace std;
+vector<int> v = ...;
+// standard sequential sort
+sort(v.begin(), v.end());
+// explicitly sequential sort
+sort(execution::seq, v.begin(), v.end());
+// permitting parallel execution
+sort(execution::par, v.begin(), v.end());
+// permitting vectorization as well
+sort(execution::par_unseq, v.begin(), v.end());
+```
+— *end example*]
+[*Note 1*: Implementations can provide additional execution policies to
+those described in this document as extensions to address parallel
+architectures that require idiosyncratic parameters for efficient
+execution. — *end note*]
+#### Execution policy type trait <a id="execpol.type">[[execpol.type]]</a>
+``` cpp
+template<class T> struct is_execution_policy;
+```
+`is_execution_policy` can be used to detect execution policies for the
+purpose of excluding function signatures from otherwise ambiguous
+overload resolution participation.
+`is_execution_policy<T>` is a *Cpp17UnaryTypeTrait* with a base
+characteristic of `true_type` if `T` is the type of a standard or
+*implementation-defined* execution policy, otherwise `false_type`.
+[*Note 1*: This provision reserves the privilege of creating
+non-standard execution policies to the library
+implementation. — *end note*]
+The behavior of a program that adds specializations for
+`is_execution_policy` is undefined.
+#### Sequenced execution policy <a id="execpol.seq">[[execpol.seq]]</a>
+``` cpp
+class execution::sequenced_policy { unspecified };
+```
+The class `execution::sequenced_policy` is an execution policy type used
+as a unique type to disambiguate parallel algorithm overloading and
+require that a parallel algorithm’s execution may not be parallelized.
+During the execution of a parallel algorithm with the
+`execution::sequenced_policy` policy, if the invocation of an element
+access function exits via an exception, `terminate` is
+invoked [[except.terminate]].
+#### Parallel execution policy <a id="execpol.par">[[execpol.par]]</a>
+``` cpp
+class execution::parallel_policy { unspecified };
+```
+The class `execution::parallel_policy` is an execution policy type used
+as a unique type to disambiguate parallel algorithm overloading and
+indicate that a parallel algorithm’s execution may be parallelized.
+During the execution of a parallel algorithm with the
+`execution::parallel_policy` policy, if the invocation of an element
+access function exits via an exception, `terminate` is
+invoked [[except.terminate]].
+#### Parallel and unsequenced execution policy <a id="execpol.parunseq">[[execpol.parunseq]]</a>
+``` cpp
+class execution::parallel_unsequenced_policy { unspecified };
+```
+The class `execution::parallel_unsequenced_policy` is an execution
+policy type used as a unique type to disambiguate parallel algorithm
+overloading and indicate that a parallel algorithm’s execution may be
+parallelized and vectorized.
+During the execution of a parallel algorithm with the
+`execution::parallel_unsequenced_policy` policy, if the invocation of an
+element access function exits via an exception, `terminate` is
+invoked [[except.terminate]].
+#### Unsequenced execution policy <a id="execpol.unseq">[[execpol.unseq]]</a>
+``` cpp
+class execution::unsequenced_policy { unspecified };
+```
+The class `unsequenced_policy` is an execution policy type used as a
+unique type to disambiguate parallel algorithm overloading and indicate
+that a parallel algorithm’s execution may be vectorized, e.g., executed
+on a single thread using instructions that operate on multiple data
+items.
+During the execution of a parallel algorithm with the
+`execution::unsequenced_policy` policy, if the invocation of an element
+access function exits via an exception, `terminate` is
+invoked [[except.terminate]].
+#### Execution policy objects <a id="execpol.objects">[[execpol.objects]]</a>
+``` cpp
+inline constexpr execution::sequenced_policy            execution::seq{ unspecified };
+inline constexpr execution::parallel_policy             execution::par{ unspecified };
+inline constexpr execution::parallel_unsequenced_policy execution::par_unseq{ unspecified };
+inline constexpr execution::unsequenced_policy          execution::unseq{ unspecified };
+```
+The header `<execution>` declares global objects associated with each
+type of execution policy.
 ## Header `<algorithm>` synopsis <a id="algorithm.syn">[[algorithm.syn]]</a>
 ``` cpp
+// mostly freestanding
 #include <initializer_list>     // see [initializer.list.syn]
 namespace std {
   namespace ranges {
     // [algorithms.results], algorithm result types
   // [alg.nonmodifying], non-modifying sequence operations
   // [alg.all.of], all of
   template<class InputIterator, class Predicate>
     constexpr bool all_of(InputIterator first, InputIterator last, Predicate pred);
   template<class ExecutionPolicy, class ForwardIterator, class Predicate>
+    bool all_of(ExecutionPolicy&& exec,                         // freestanding-deleted, see [algorithms.parallel.overloads]
                 ForwardIterator first, ForwardIterator last, Predicate pred);
   namespace ranges {
     template<input_iterator I, sentinel_for<I> S, class Proj = identity,
              indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr bool all_of(I first, S last, Pred pred, Proj proj = {});
     template<input_range R, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr bool all_of(R&& r, Pred pred, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+      bool all_of(Ep&& exec, I first, S last, Pred pred, Proj proj = {});   // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      bool all_of(Ep&& exec, R&& r, Pred pred, Proj proj = {});             // freestanding-deleted
   }
   // [alg.any.of], any of
   template<class InputIterator, class Predicate>
     constexpr bool any_of(InputIterator first, InputIterator last, Predicate pred);
   template<class ExecutionPolicy, class ForwardIterator, class Predicate>
+    bool any_of(ExecutionPolicy&& exec,                         // freestanding-deleted, see [algorithms.parallel.overloads]
                 ForwardIterator first, ForwardIterator last, Predicate pred);
   namespace ranges {
     template<input_iterator I, sentinel_for<I> S, class Proj = identity,
              indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr bool any_of(I first, S last, Pred pred, Proj proj = {});
     template<input_range R, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr bool any_of(R&& r, Pred pred, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+      bool any_of(Ep&& exec, I first, S last, Pred pred, Proj proj = {});   // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      bool any_of(Ep&& exec, R&& r, Pred pred, Proj proj = {});             // freestanding-deleted
   }
   // [alg.none.of], none of
   template<class InputIterator, class Predicate>
     constexpr bool none_of(InputIterator first, InputIterator last, Predicate pred);
   template<class ExecutionPolicy, class ForwardIterator, class Predicate>
+    bool none_of(ExecutionPolicy&& exec,                        // freestanding-deleted, see [algorithms.parallel.overloads]
                  ForwardIterator first, ForwardIterator last, Predicate pred);
   namespace ranges {
     template<input_iterator I, sentinel_for<I> S, class Proj = identity,
              indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr bool none_of(I first, S last, Pred pred, Proj proj = {});
     template<input_range R, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr bool none_of(R&& r, Pred pred, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+      bool none_of(Ep&& exec, I first, S last, Pred pred, Proj proj = {});  // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      bool none_of(Ep&& exec, R&& r, Pred pred, Proj proj = {});            // freestanding-deleted
   }
   // [alg.contains], contains
   namespace ranges {
+    template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+             class T = projected_value_t<I, Proj>>
       requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
       constexpr bool contains(I first, S last, const T& value, Proj proj = {});
+    template<input_range R, class Proj = identity,
+             class T = projected_value_t<iterator_t<R>, Proj>>
       requires
         indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
       constexpr bool contains(R&& r, const T& value, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity, class T = projected_value_t<I, Proj>>
+      requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
+      bool contains(Ep&& exec, I first, S last, const T& value,
+                    Proj proj = {});                                        // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             class T = projected_value_t<iterator_t<R>, Proj>>
+      requires
+        indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
+      bool contains(Ep&& exec, R&& r, const T& value, Proj proj = {});      // freestanding-deleted
     template<forward_iterator I1, sentinel_for<I1> S1,
              forward_iterator I2, sentinel_for<I2> S2,
              class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
       requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
       constexpr bool contains_subrange(I1 first1, S1 last1, I2 first2, S2 last2,
     template<forward_range R1, forward_range R2,
              class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
       requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
       constexpr bool contains_subrange(R1&& r1, R2&& r2,
                                        Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
+    template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+             random_access_iterator I2, sized_sentinel_for<I2> S2,
+             class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+      requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+      bool contains_subrange(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
+                             Proj1 proj1 = {}, Proj2 proj2 = {});           // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+             class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+      requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+      bool contains_subrange(Ep&& exec, R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {},
+                             Proj2 proj2 = {});                             // freestanding-deleted
   }
   // [alg.foreach], for each
   template<class InputIterator, class Function>
     constexpr Function for_each(InputIterator first, InputIterator last, Function f);
   template<class ExecutionPolicy, class ForwardIterator, class Function>
+    void for_each(ExecutionPolicy&& exec,                       // freestanding-deleted, see [algorithms.parallel.overloads]
                   ForwardIterator first, ForwardIterator last, Function f);
   namespace ranges {
     template<class I, class F>
       using for_each_result = in_fun_result<I, F>;
         for_each(I first, S last, Fun f, Proj proj = {});
     template<input_range R, class Proj = identity,
              indirectly_unary_invocable<projected<iterator_t<R>, Proj>> Fun>
       constexpr for_each_result<borrowed_iterator_t<R>, Fun>
         for_each(R&& r, Fun f, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity,
+             indirectly_unary_invocable<projected<I, Proj>> Fun>
+      I for_each(Ep&& exec, I first, S last, Fun f, Proj proj = {});        // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             indirectly_unary_invocable<projected<iterator_t<R>, Proj>> Fun>
+      borrowed_iterator_t<R>
+        for_each(Ep&& exec, R&& r, Fun f, Proj proj = {});                  // freestanding-deleted
   }
   template<class InputIterator, class Size, class Function>
     constexpr InputIterator for_each_n(InputIterator first, Size n, Function f);
   template<class ExecutionPolicy, class ForwardIterator, class Size, class Function>
+    ForwardIterator for_each_n(ExecutionPolicy&& exec,          // freestanding-deleted, see [algorithms.parallel.overloads]
                                ForwardIterator first, Size n, Function f);
   namespace ranges {
     template<class I, class F>
       using for_each_n_result = in_fun_result<I, F>;
     template<input_iterator I, class Proj = identity,
              indirectly_unary_invocable<projected<I, Proj>> Fun>
       constexpr for_each_n_result<I, Fun>
         for_each_n(I first, iter_difference_t<I> n, Fun f, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, class Proj = identity,
+             indirectly_unary_invocable<projected<I, Proj>> Fun>
+      I for_each_n(Ep&& exec, I first, iter_difference_t<I> n, Fun f,
+                   Proj proj = {});                             // freestanding-deleted
   }
   // [alg.find], find
+  template<class InputIterator, class T = iterator_traits<InputIterator>::value_type>
     constexpr InputIterator find(InputIterator first, InputIterator last,
                                  const T& value);
+  template<class ExecutionPolicy, class ForwardIterator,
+           class T = iterator_traits<ForwardIterator>::value_type>
+    ForwardIterator find(ExecutionPolicy&& exec,                // freestanding-deleted, see [algorithms.parallel.overloads]
                          ForwardIterator first, ForwardIterator last,
                          const T& value);
   template<class InputIterator, class Predicate>
     constexpr InputIterator find_if(InputIterator first, InputIterator last,
                                     Predicate pred);
   template<class ExecutionPolicy, class ForwardIterator, class Predicate>
+    ForwardIterator find_if(ExecutionPolicy&& exec,             // freestanding-deleted, see [algorithms.parallel.overloads]
                             ForwardIterator first, ForwardIterator last,
                             Predicate pred);
   template<class InputIterator, class Predicate>
     constexpr InputIterator find_if_not(InputIterator first, InputIterator last,
                                         Predicate pred);
   template<class ExecutionPolicy, class ForwardIterator, class Predicate>
+    ForwardIterator find_if_not(ExecutionPolicy&& exec,         // freestanding-deleted, see [algorithms.parallel.overloads]
                                 ForwardIterator first, ForwardIterator last,
                                 Predicate pred);
   namespace ranges {
+    template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+             class T = projected_value_t<I, Proj>>
       requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
       constexpr I find(I first, S last, const T& value, Proj proj = {});
+    template<input_range R, class Proj = identity,
+             class T = projected_value_t<iterator_t<R>, Proj>>
       requires indirect_binary_predicate<ranges::equal_to,
                                          projected<iterator_t<R>, Proj>, const T*>
       constexpr borrowed_iterator_t<R>
         find(R&& r, const T& value, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity, class T = projected_value_t<I, Proj>>
+      requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
+      I find(Ep&& exec, I first, S last, const T& value, Proj proj = {});   // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             class T = projected_value_t<iterator_t<R>, Proj>>
+      requires indirect_binary_predicate<ranges::equal_to,
+                                         projected<iterator_t<R>, Proj>, const T*>
+      borrowed_iterator_t<R>
+        find(Ep&& exec, R&& r, const T& value, Proj proj = {});             // freestanding-deleted
     template<input_iterator I, sentinel_for<I> S, class Proj = identity,
              indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr I find_if(I first, S last, Pred pred, Proj proj = {});
     template<input_range R, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr borrowed_iterator_t<R>
         find_if(R&& r, Pred pred, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+      I find_if(Ep&& exec, I first, S last, Pred pred, Proj proj = {});     // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      borrowed_iterator_t<R>
+        find_if(Ep&& exec, R&& r, Pred pred, Proj proj = {});               // freestanding-deleted
     template<input_iterator I, sentinel_for<I> S, class Proj = identity,
              indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr I find_if_not(I first, S last, Pred pred, Proj proj = {});
     template<input_range R, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr borrowed_iterator_t<R>
         find_if_not(R&& r, Pred pred, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+      I find_if_not(Ep&& exec, I first, S last, Pred pred, Proj proj = {}); // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      borrowed_iterator_t<R>
+        find_if_not(Ep&& exec, R&& r, Pred pred, Proj proj = {});           // freestanding-deleted
   }
   // [alg.find.last], find last
   namespace ranges {
+    template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+             class T = projected_value_t<I, Proj>>
       requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
       constexpr subrange<I> find_last(I first, S last, const T& value, Proj proj = {});
+    template<forward_range R, class Proj = identity,
+             class T = projected_value_t<iterator_t<R>, Proj>>
       requires
         indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
       constexpr borrowed_subrange_t<R> find_last(R&& r, const T& value, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity, class T = projected_value_t<I, Proj>>
+      requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
+      subrange<I>
+        find_last(Ep&& exec, I first, S last, const T& value,
+                  Proj proj = {});                                          // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             class T = projected_value_t<iterator_t<R>, Proj>>
+      requires
+        indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
+      borrowed_subrange_t<R>
+        find_last(Ep&& exec, R&& r, const T& value, Proj proj = {});        // freestanding-deleted
     template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
              indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr subrange<I> find_last_if(I first, S last, Pred pred, Proj proj = {});
     template<forward_range R, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr borrowed_subrange_t<R> find_last_if(R&& r, Pred pred, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+      subrange<I>
+        find_last_if(Ep&& exec, I first, S last, Pred pred,
+                     Proj proj = {});                                       // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R,
+             class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      borrowed_subrange_t<R>
+        find_last_if(Ep&& exec, R&& r, Pred pred, Proj proj = {});          // freestanding-deleted
     template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
              indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr subrange<I> find_last_if_not(I first, S last, Pred pred, Proj proj = {});
     template<forward_range R, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr borrowed_subrange_t<R> find_last_if_not(R&& r, Pred pred, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity,
+             indirect_unary_predicate<projected<I, Proj>> Pred>
+      subrange<I>
+        find_last_if_not(Ep&& exec, I first, S last, Pred pred,
+                         Proj proj = {});                                   // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      borrowed_subrange_t<R>
+        find_last_if_not(Ep&& exec, R&& r, Pred pred, Proj proj = {});      // freestanding-deleted
   }
   // [alg.find.end], find end
   template<class ForwardIterator1, class ForwardIterator2>
     constexpr ForwardIterator1
       find_end(ForwardIterator1 first1, ForwardIterator1 last1,
                ForwardIterator2 first2, ForwardIterator2 last2,
                BinaryPredicate pred);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
     ForwardIterator1
+      find_end(ExecutionPolicy&& exec,                          // freestanding-deleted, see [algorithms.parallel.overloads]
                ForwardIterator1 first1, ForwardIterator1 last1,
                ForwardIterator2 first2, ForwardIterator2 last2);
   template<class ExecutionPolicy, class ForwardIterator1,
            class ForwardIterator2, class BinaryPredicate>
     ForwardIterator1
+      find_end(ExecutionPolicy&& exec,                          // freestanding-deleted, see [algorithms.parallel.overloads]
                ForwardIterator1 first1, ForwardIterator1 last1,
                ForwardIterator2 first2, ForwardIterator2 last2,
                BinaryPredicate pred);
   namespace ranges {
              class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
       requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
       constexpr borrowed_subrange_t<R1>
         find_end(R1&& r1, R2&& r2, Pred pred = {},
                  Proj1 proj1 = {}, Proj2 proj2 = {});
+    template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+             random_access_iterator I2, sized_sentinel_for<I2> S2,
+             class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+      requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+      subrange<I1>
+        find_end(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
+                 Proj1 proj1 = {}, Proj2 proj2 = {});           // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+             class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+      requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+      borrowed_subrange_t<R1>
+        find_end(Ep&& exec, R1&& r1, R2&& r2, Pred pred = {},
+                 Proj1 proj1 = {}, Proj2 proj2 = {});           // freestanding-deleted
   }
+  // [alg.find.first.of], find first of
   template<class InputIterator, class ForwardIterator>
     constexpr InputIterator
       find_first_of(InputIterator first1, InputIterator last1,
                     ForwardIterator first2, ForwardIterator last2);
   template<class InputIterator, class ForwardIterator, class BinaryPredicate>
       find_first_of(InputIterator first1, InputIterator last1,
                     ForwardIterator first2, ForwardIterator last2,
                     BinaryPredicate pred);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
     ForwardIterator1
+      find_first_of(ExecutionPolicy&& exec,                     // freestanding-deleted, see [algorithms.parallel.overloads]
                     ForwardIterator1 first1, ForwardIterator1 last1,
                     ForwardIterator2 first2, ForwardIterator2 last2);
   template<class ExecutionPolicy, class ForwardIterator1,
            class ForwardIterator2, class BinaryPredicate>
     ForwardIterator1
+      find_first_of(ExecutionPolicy&& exec,                     // freestanding-deleted, see [algorithms.parallel.overloads]
                     ForwardIterator1 first1, ForwardIterator1 last1,
                     ForwardIterator2 first2, ForwardIterator2 last2,
                     BinaryPredicate pred);
   namespace ranges {
              class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
       requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
       constexpr borrowed_iterator_t<R1>
         find_first_of(R1&& r1, R2&& r2, Pred pred = {},
                       Proj1 proj1 = {}, Proj2 proj2 = {});
+    template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+             random_access_iterator I2, sized_sentinel_for<I2> S2,
+             class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+      requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+      I1 find_first_of(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
+                       Proj1 proj1 = {}, Proj2 proj2 = {});     // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+             class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+      requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+      borrowed_iterator_t<R1>
+        find_first_of(Ep&& exec, R1&& r1, R2&& r2, Pred pred = {},
+                      Proj1 proj1 = {}, Proj2 proj2 = {});      // freestanding-deleted
   }
   // [alg.adjacent.find], adjacent find
   template<class ForwardIterator>
     constexpr ForwardIterator
     constexpr ForwardIterator
       adjacent_find(ForwardIterator first, ForwardIterator last,
                     BinaryPredicate pred);
   template<class ExecutionPolicy, class ForwardIterator>
     ForwardIterator
+      adjacent_find(ExecutionPolicy&& exec,                     // freestanding-deleted, see [algorithms.parallel.overloads]
                     ForwardIterator first, ForwardIterator last);
   template<class ExecutionPolicy, class ForwardIterator, class BinaryPredicate>
     ForwardIterator
+      adjacent_find(ExecutionPolicy&& exec,                     // freestanding-deleted, see [algorithms.parallel.overloads]
                     ForwardIterator first, ForwardIterator last,
                     BinaryPredicate pred);
   namespace ranges {
     template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
     template<forward_range R, class Proj = identity,
              indirect_binary_predicate<projected<iterator_t<R>, Proj>,
                                        projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
       constexpr borrowed_iterator_t<R>
         adjacent_find(R&& r, Pred pred = {}, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity,
+             indirect_binary_predicate<projected<I, Proj>,
+                                       projected<I, Proj>> Pred = ranges::equal_to>
+      I adjacent_find(Ep&& exec, I first, S last, Pred pred = {},
+                      Proj proj = {});                                      // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             indirect_binary_predicate<projected<iterator_t<R>, Proj>,
+                                       projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
+      borrowed_iterator_t<R>
+        adjacent_find(Ep&& exec, R&& r, Pred pred = {}, Proj proj = {});    // freestanding-deleted
   }
   // [alg.count], count
+  template<class InputIterator, class T = iterator_traits<InputIterator>::value_type>
     constexpr typename iterator_traits<InputIterator>::difference_type
       count(InputIterator first, InputIterator last, const T& value);
+  template<class ExecutionPolicy, class ForwardIterator,
+           class T = iterator_traits<ForwardIterator>::value_type>
     typename iterator_traits<ForwardIterator>::difference_type
+      count(ExecutionPolicy&& exec,                             // freestanding-deleted, see [algorithms.parallel.overloads]
             ForwardIterator first, ForwardIterator last, const T& value);
   template<class InputIterator, class Predicate>
     constexpr typename iterator_traits<InputIterator>::difference_type
       count_if(InputIterator first, InputIterator last, Predicate pred);
   template<class ExecutionPolicy, class ForwardIterator, class Predicate>
     typename iterator_traits<ForwardIterator>::difference_type
+      count_if(ExecutionPolicy&& exec,                          // freestanding-deleted, see [algorithms.parallel.overloads]
                ForwardIterator first, ForwardIterator last, Predicate pred);
   namespace ranges {
+    template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+             class T = projected_value_t<I, Proj>>
       requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
       constexpr iter_difference_t<I>
         count(I first, S last, const T& value, Proj proj = {});
+    template<input_range R, class Proj = identity,
+             class T = projected_value_t<iterator_t<R>, Proj>>
       requires indirect_binary_predicate<ranges::equal_to,
                                          projected<iterator_t<R>, Proj>, const T*>
       constexpr range_difference_t<R>
         count(R&& r, const T& value, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity, class T = projected_value_t<I, Proj>>
+      requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
+      iter_difference_t<I>
+        count(Ep&& exec, I first, S last, const T& value, Proj proj = {});  // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             class T = projected_value_t<iterator_t<R>, Proj>>
+      requires indirect_binary_predicate<ranges::equal_to,
+                                         projected<iterator_t<R>, Proj>, const T*>
+      range_difference_t<R>
+        count(Ep&& exec, R&& r, const T& value, Proj proj = {});            // freestanding-deleted
     template<input_iterator I, sentinel_for<I> S, class Proj = identity,
              indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr iter_difference_t<I>
         count_if(I first, S last, Pred pred, Proj proj = {});
     template<input_range R, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr range_difference_t<R>
         count_if(R&& r, Pred pred, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+      iter_difference_t<I>
+        count_if(Ep&& exec, I first, S last, Pred pred, Proj proj = {});    // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      range_difference_t<R>
+        count_if(Ep&& exec, R&& r, Pred pred, Proj proj = {});              // freestanding-deleted
   }
+  // [alg.mismatch], mismatch
   template<class InputIterator1, class InputIterator2>
     constexpr pair<InputIterator1, InputIterator2>
       mismatch(InputIterator1 first1, InputIterator1 last1,
                InputIterator2 first2);
   template<class InputIterator1, class InputIterator2, class BinaryPredicate>
       mismatch(InputIterator1 first1, InputIterator1 last1,
                InputIterator2 first2, InputIterator2 last2,
                BinaryPredicate pred);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
     pair<ForwardIterator1, ForwardIterator2>
+      mismatch(ExecutionPolicy&& exec,                          // freestanding-deleted, see [algorithms.parallel.overloads]
                ForwardIterator1 first1, ForwardIterator1 last1,
                ForwardIterator2 first2);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class BinaryPredicate>
     pair<ForwardIterator1, ForwardIterator2>
+      mismatch(ExecutionPolicy&& exec,                          // freestanding-deleted, see [algorithms.parallel.overloads]
                ForwardIterator1 first1, ForwardIterator1 last1,
                ForwardIterator2 first2, BinaryPredicate pred);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
     pair<ForwardIterator1, ForwardIterator2>
+      mismatch(ExecutionPolicy&& exec,                          // freestanding-deleted, see [algorithms.parallel.overloads]
                ForwardIterator1 first1, ForwardIterator1 last1,
                ForwardIterator2 first2, ForwardIterator2 last2);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class BinaryPredicate>
     pair<ForwardIterator1, ForwardIterator2>
+      mismatch(ExecutionPolicy&& exec,                          // freestanding-deleted, see [algorithms.parallel.overloads]
                ForwardIterator1 first1, ForwardIterator1 last1,
                ForwardIterator2 first2, ForwardIterator2 last2,
                BinaryPredicate pred);
   namespace ranges {
              class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
       requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
       constexpr mismatch_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
         mismatch(R1&& r1, R2&& r2, Pred pred = {},
                  Proj1 proj1 = {}, Proj2 proj2 = {});
+    template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+             random_access_iterator I2, sized_sentinel_for<I2> S2,
+             class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+      requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+      mismatch_result<I1, I2>
+        mismatch(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
+                 Proj1 proj1 = {}, Proj2 proj2 = {});           // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+             class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+      requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+      mismatch_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
+        mismatch(Ep&& exec, R1&& r1, R2&& r2, Pred pred = {},
+                 Proj1 proj1 = {}, Proj2 proj2 = {});           // freestanding-deleted
   }
   // [alg.equal], equal
   template<class InputIterator1, class InputIterator2>
     constexpr bool equal(InputIterator1 first1, InputIterator1 last1,
   template<class InputIterator1, class InputIterator2, class BinaryPredicate>
     constexpr bool equal(InputIterator1 first1, InputIterator1 last1,
                          InputIterator2 first2, InputIterator2 last2,
                          BinaryPredicate pred);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
+    bool equal(ExecutionPolicy&& exec,                          // freestanding-deleted, see [algorithms.parallel.overloads]
                ForwardIterator1 first1, ForwardIterator1 last1,
                ForwardIterator2 first2);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class BinaryPredicate>
+    bool equal(ExecutionPolicy&& exec,                          // freestanding-deleted, see [algorithms.parallel.overloads]
                ForwardIterator1 first1, ForwardIterator1 last1,
                ForwardIterator2 first2, BinaryPredicate pred);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
+    bool equal(ExecutionPolicy&& exec,                          // freestanding-deleted, see [algorithms.parallel.overloads]
                ForwardIterator1 first1, ForwardIterator1 last1,
                ForwardIterator2 first2, ForwardIterator2 last2);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class BinaryPredicate>
+    bool equal(ExecutionPolicy&& exec,                          // freestanding-deleted, see [algorithms.parallel.overloads]
                ForwardIterator1 first1, ForwardIterator1 last1,
                ForwardIterator2 first2, ForwardIterator2 last2,
                BinaryPredicate pred);
   namespace ranges {
     template<input_range R1, input_range R2, class Pred = ranges::equal_to,
              class Proj1 = identity, class Proj2 = identity>
       requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
       constexpr bool equal(R1&& r1, R2&& r2, Pred pred = {},
                            Proj1 proj1 = {}, Proj2 proj2 = {});
+    template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+             random_access_iterator I2, sized_sentinel_for<I2> S2,
+             class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+      requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+      bool equal(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2,
+                 Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});       // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+             class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+      requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+      bool equal(Ep&& exec, R1&& r1, R2&& r2,
+                 Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});       // freestanding-deleted
   }
   // [alg.is.permutation], is permutation
   template<class ForwardIterator1, class ForwardIterator2>
     constexpr bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
       search(ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2,
              BinaryPredicate pred);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
     ForwardIterator1
+      search(ExecutionPolicy&& exec,                            // freestanding-deleted, see [algorithms.parallel.overloads]
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class BinaryPredicate>
     ForwardIterator1
+      search(ExecutionPolicy&& exec,                            // freestanding-deleted, see [algorithms.parallel.overloads]
              ForwardIterator1 first1, ForwardIterator1 last1,
              ForwardIterator2 first2, ForwardIterator2 last2,
              BinaryPredicate pred);
   namespace ranges {
              class Proj1 = identity, class Proj2 = identity>
       requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
       constexpr borrowed_subrange_t<R1>
         search(R1&& r1, R2&& r2, Pred pred = {},
                Proj1 proj1 = {}, Proj2 proj2 = {});
+    template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+             random_access_iterator I2, sized_sentinel_for<I2> S2,
+             class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+      requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+      subrange<I1>
+        search(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2,
+               Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});         // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+             class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+      requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+      borrowed_subrange_t<R1>
+        search(Ep&& exec, R1&& r1, R2&& r2,
+               Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});         // freestanding-deleted
   }
+  template<class ForwardIterator, class Size,
+           class T = iterator_traits<ForwardIterator>::value_type>
     constexpr ForwardIterator
       search_n(ForwardIterator first, ForwardIterator last,
                Size count, const T& value);
+  template<class ForwardIterator, class Size,
+           class T = iterator_traits<ForwardIterator>::value_type, class BinaryPredicate>
     constexpr ForwardIterator
       search_n(ForwardIterator first, ForwardIterator last,
                Size count, const T& value, BinaryPredicate pred);
+  template<class ExecutionPolicy, class ForwardIterator, class Size,
+           class T = iterator_traits<ForwardIterator>::value_type>
     ForwardIterator
+      search_n(ExecutionPolicy&& exec,                          // freestanding-deleted, see [algorithms.parallel.overloads]
                ForwardIterator first, ForwardIterator last,
                Size count, const T& value);
+  template<class ExecutionPolicy, class ForwardIterator, class Size,
+           class T = iterator_traits<ForwardIterator>::value_type, class BinaryPredicate>
     ForwardIterator
+      search_n(ExecutionPolicy&& exec,                          // freestanding-deleted, see [algorithms.parallel.overloads]
                ForwardIterator first, ForwardIterator last,
                Size count, const T& value,
                BinaryPredicate pred);
   namespace ranges {
+    template<forward_iterator I, sentinel_for<I> S,
+             class Pred = ranges::equal_to, class Proj = identity,
+             class T = projected_value_t<I, Proj>>
       requires indirectly_comparable<I, const T*, Pred, Proj>
       constexpr subrange<I>
         search_n(I first, S last, iter_difference_t<I> count,
                  const T& value, Pred pred = {}, Proj proj = {});
+    template<forward_range R, class Pred = ranges::equal_to,
+             class Proj = identity, class T = projected_value_t<I, Proj>>
       requires indirectly_comparable<iterator_t<R>, const T*, Pred, Proj>
       constexpr borrowed_subrange_t<R>
         search_n(R&& r, range_difference_t<R> count,
                  const T& value, Pred pred = {}, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Pred = ranges::equal_to, class Proj = identity,
+             class T = projected_value_t<I, Proj>>
+      requires indirectly_comparable<I, const T*, Pred, Proj>
+      subrange<I>
+        search_n(Ep&& exec, I first, S last, iter_difference_t<I> count,
+                 const T& value, Pred pred = {}, Proj proj = {});           // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Pred = ranges::equal_to,
+             class Proj = identity, class T = projected_value_t<iterator_t<R>, Proj>>
+      requires indirectly_comparable<iterator_t<R>, const T*, Pred, Proj>
+      borrowed_subrange_t<R>
+        search_n(Ep&& exec, R&& r, range_difference_t<R> count,
+                 const T& value, Pred pred = {}, Proj proj = {});           // freestanding-deleted
   }
   template<class ForwardIterator, class Searcher>
     constexpr ForwardIterator
       search(ForwardIterator first, ForwardIterator last, const Searcher& searcher);
              class Proj1 = identity, class Proj2 = identity>
       requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
       constexpr bool starts_with(R1&& r1, R2&& r2, Pred pred = {},
                                  Proj1 proj1 = {}, Proj2 proj2 = {});
+    template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+             random_access_iterator I2, sized_sentinel_for<I2> S2,
+             class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+      requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+      bool starts_with(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2,
+                       Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R1,
+             sized-random-access-range R2, class Pred = ranges::equal_to,
+             class Proj1 = identity, class Proj2 = identity>
+      requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+      bool starts_with(Ep&& exec, R1&& r1, R2&& r2,
+                       Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // freestanding-deleted
     // [alg.ends.with], ends with
     template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
              class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
       requires (forward_iterator<I1> || sized_sentinel_for<S1, I1>) &&
                (forward_iterator<I2> || sized_sentinel_for<S2, I2>) &&
                (forward_range<R2> || sized_range<R2>) &&
                indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
       constexpr bool ends_with(R1&& r1, R2&& r2, Pred pred = {},
                                Proj1 proj1 = {}, Proj2 proj2 = {});
+    template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+             random_access_iterator I2, sized_sentinel_for<I2> S2,
+             class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+      requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+      bool ends_with(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2,
+                     Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});   // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R1,
+             sized-random-access-range R2, class Pred = ranges::equal_to,
+             class Proj1 = identity, class Proj2 = identity>
+      requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+      bool ends_with(Ep&& exec, R1&& r1, R2&& r2,
+                     Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});   // freestanding-deleted
     // [alg.fold], fold
     template<class F>
     class flipped {     // exposition only
       F f;              // exposition only
     template<class F, class T, class I>
       concept indirectly-binary-right-foldable =    // exposition only
         indirectly-binary-left-foldable<flipped<F>, T, I>;
+    template<input_iterator I, sentinel_for<I> S, class T = iter_value_t<I>,
              indirectly-binary-left-foldable<T, I> F>
       constexpr auto fold_left(I first, S last, T init, F f);
+    template<input_range R, class T = range_value_t<R>,
+             indirectly-binary-left-foldable<T, iterator_t<R>> F>
       constexpr auto fold_left(R&& r, T init, F f);
     template<input_iterator I, sentinel_for<I> S,
              indirectly-binary-left-foldable<iter_value_t<I>, I> F>
       requires constructible_from<iter_value_t<I>, iter_reference_t<I>>
     template<input_range R, indirectly-binary-left-foldable<range_value_t<R>, iterator_t<R>> F>
       requires constructible_from<range_value_t<R>, range_reference_t<R>>
       constexpr auto fold_left_first(R&& r, F f);
+    template<bidirectional_iterator I, sentinel_for<I> S, class T = iter_value_t<I>,
              indirectly-binary-right-foldable<T, I> F>
       constexpr auto fold_right(I first, S last, T init, F f);
+    template<bidirectional_range R, class T = range_value_t<R>,
              indirectly-binary-right-foldable<T, iterator_t<R>> F>
       constexpr auto fold_right(R&& r, T init, F f);
     template<bidirectional_iterator I, sentinel_for<I> S,
              indirectly-binary-right-foldable<iter_value_t<I>, I> F>
     template<class I, class T>
       using fold_left_with_iter_result = in_value_result<I, T>;
     template<class I, class T>
       using fold_left_first_with_iter_result = in_value_result<I, T>;
+    template<input_iterator I, sentinel_for<I> S, class T = iter_value_t<I>,
              indirectly-binary-left-foldable<T, I> F>
       constexpr see below fold_left_with_iter(I first, S last, T init, F f);
+    template<input_range R, class T = range_value_t<R>,
+             indirectly-binary-left-foldable<T, iterator_t<R>> F>
       constexpr see below fold_left_with_iter(R&& r, T init, F f);
     template<input_iterator I, sentinel_for<I> S,
              indirectly-binary-left-foldable<iter_value_t<I>, I> F>
       requires constructible_from<iter_value_t<I>, iter_reference_t<I>>
   // [alg.copy], copy
   template<class InputIterator, class OutputIterator>
     constexpr OutputIterator copy(InputIterator first, InputIterator last,
                                   OutputIterator result);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
+    ForwardIterator2 copy(ExecutionPolicy&& exec,               // freestanding-deleted, see [algorithms.parallel.overloads]
                           ForwardIterator1 first, ForwardIterator1 last,
                           ForwardIterator2 result);
   namespace ranges {
     template<class I, class O>
         copy(I first, S last, O result);
     template<input_range R, weakly_incrementable O>
       requires indirectly_copyable<iterator_t<R>, O>
       constexpr copy_result<borrowed_iterator_t<R>, O>
         copy(R&& r, O result);
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             random_access_iterator O, sized_sentinel_for<O> OutS>
+      requires indirectly_copyable<I, O>
+      copy_result<I, O>
+        copy(Ep&& exec, I first, S last, O result, OutS result_last);       // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR>
+      requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>>
+      copy_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+        copy(Ep&& exec, R&& r, OutR&& result_r);                            // freestanding-deleted
   }
   template<class InputIterator, class Size, class OutputIterator>
     constexpr OutputIterator copy_n(InputIterator first, Size n,
                                     OutputIterator result);
   template<class ExecutionPolicy, class ForwardIterator1, class Size,
            class ForwardIterator2>
+    ForwardIterator2 copy_n(ExecutionPolicy&& exec,             // freestanding-deleted, see [algorithms.parallel.overloads]
                             ForwardIterator1 first, Size n,
                             ForwardIterator2 result);
   namespace ranges {
     template<class I, class O>
     template<input_iterator I, weakly_incrementable O>
       requires indirectly_copyable<I, O>
       constexpr copy_n_result<I, O>
         copy_n(I first, iter_difference_t<I> n, O result);
+    template<execution-policy Ep, random_access_iterator I, random_access_iterator O,
+             sized_sentinel_for<O> OutS>
+      requires indirectly_copyable<I, O>
+      copy_n_result<I, O>
+        copy_n(Ep&& exec, I first, iter_difference_t<I> n, O result,
+               OutS result_last);                               // freestanding-deleted
   }
   template<class InputIterator, class OutputIterator, class Predicate>
     constexpr OutputIterator copy_if(InputIterator first, InputIterator last,
                                      OutputIterator result, Predicate pred);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class Predicate>
+    ForwardIterator2 copy_if(ExecutionPolicy&& exec,            // freestanding-deleted, see [algorithms.parallel.overloads]
                              ForwardIterator1 first, ForwardIterator1 last,
                              ForwardIterator2 result, Predicate pred);
   namespace ranges {
     template<class I, class O>
     template<input_range R, weakly_incrementable O, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       requires indirectly_copyable<iterator_t<R>, O>
       constexpr copy_if_result<borrowed_iterator_t<R>, O>
         copy_if(R&& r, O result, Pred pred, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             random_access_iterator O, sized_sentinel_for<O> OutS,
+             class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+      requires indirectly_copyable<I, O>
+      copy_if_result<I, O>
+        copy_if(Ep&& exec, I first, S last, O result, OutS result_last,
+                Pred pred, Proj proj = {});                     // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR,
+             class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>>
+      copy_if_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+        copy_if(Ep&& exec, R&& r, OutR&& result_r, Pred pred,
+                Proj proj = {});                                // freestanding-deleted
   }
   template<class BidirectionalIterator1, class BidirectionalIterator2>
     constexpr BidirectionalIterator2
       copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
   template<class InputIterator, class OutputIterator>
     constexpr OutputIterator move(InputIterator first, InputIterator last,
                                   OutputIterator result);
   template<class ExecutionPolicy, class ForwardIterator1,
            class ForwardIterator2>
+    ForwardIterator2 move(ExecutionPolicy&& exec,               // freestanding-deleted, see [algorithms.parallel.overloads]
                           ForwardIterator1 first, ForwardIterator1 last,
                           ForwardIterator2 result);
   namespace ranges {
     template<class I, class O>
         move(I first, S last, O result);
     template<input_range R, weakly_incrementable O>
       requires indirectly_movable<iterator_t<R>, O>
       constexpr move_result<borrowed_iterator_t<R>, O>
         move(R&& r, O result);
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             random_access_iterator O, sized_sentinel_for<O> OutS>
+      requires indirectly_movable<I, O>
+      move_result<I, O>
+        move(Ep&& exec, I first, S last, O result, OutS result_last);       // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR>
+      requires indirectly_movable<iterator_t<R>, iterator_t<OutR>>
+      move_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+        move(Ep&& exec, R&& r, OutR&& result_r);                            // freestanding-deleted
   }
   template<class BidirectionalIterator1, class BidirectionalIterator2>
     constexpr BidirectionalIterator2
       move_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
   // [alg.swap], swap
   template<class ForwardIterator1, class ForwardIterator2>
     constexpr ForwardIterator2 swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1,
                                            ForwardIterator2 first2);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
+    ForwardIterator2 swap_ranges(ExecutionPolicy&& exec,        // freestanding-deleted, see [algorithms.parallel.overloads]
                                  ForwardIterator1 first1, ForwardIterator1 last1,
                                  ForwardIterator2 first2);
   namespace ranges {
     template<class I1, class I2>
         swap_ranges(I1 first1, S1 last1, I2 first2, S2 last2);
     template<input_range R1, input_range R2>
       requires indirectly_swappable<iterator_t<R1>, iterator_t<R2>>
       constexpr swap_ranges_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
         swap_ranges(R1&& r1, R2&& r2);
+    template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+             random_access_iterator I2, sized_sentinel_for<I2> S2>
+      requires indirectly_swappable<I1, I2>
+      swap_ranges_result<I1, I2>
+        swap_ranges(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2);   // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2>
+      requires indirectly_swappable<iterator_t<R1>, iterator_t<R2>>
+      swap_ranges_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
+        swap_ranges(Ep&& exec, R1&& r1, R2&& r2);                           // freestanding-deleted
   }
   template<class ForwardIterator1, class ForwardIterator2>
     constexpr void iter_swap(ForwardIterator1 a, ForwardIterator2 b);
                 InputIterator2 first2, OutputIterator result,
                 BinaryOperation binary_op);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class UnaryOperation>
     ForwardIterator2
+      transform(ExecutionPolicy&& exec,                         // freestanding-deleted, see [algorithms.parallel.overloads]
                 ForwardIterator1 first1, ForwardIterator1 last1,
                 ForwardIterator2 result, UnaryOperation op);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator, class BinaryOperation>
     ForwardIterator
+      transform(ExecutionPolicy&& exec,                         // freestanding-deleted, see [algorithms.parallel.overloads]
                 ForwardIterator1 first1, ForwardIterator1 last1,
                 ForwardIterator2 first2, ForwardIterator result,
                 BinaryOperation binary_op);
   namespace ranges {
              class Proj = identity>
       requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R>, Proj>>>
       constexpr unary_transform_result<borrowed_iterator_t<R>, O>
         transform(R&& r, O result, F op, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             random_access_iterator O, sized_sentinel_for<O> OutS,
+             copy_constructible F, class Proj = identity>
+      requires indirectly_writable<O, indirect_result_t<F&, projected<I, Proj>>>
+      unary_transform_result<I, O>
+        transform(Ep&& exec, I first1, S last1, O result, OutS result_last,
+                  F op, Proj proj = {});                                    // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR,
+             copy_constructible F, class Proj = identity>
+      requires indirectly_writable<iterator_t<OutR>,
+                                   indirect_result_t<F&, projected<iterator_t<R>, Proj>>>
+      unary_transform_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+        transform(Ep&& exec, R&& r, OutR&& result_r, F op, Proj proj = {}); // freestanding-deleted
     template<class I1, class I2, class O>
       using binary_transform_result = in_in_out_result<I1, I2, O>;
     template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
              weakly_incrementable O, copy_constructible F, class Proj1 = identity,
       requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R1>, Proj1>,
                                    projected<iterator_t<R2>, Proj2>>>
       constexpr binary_transform_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
         transform(R1&& r1, R2&& r2, O result,
                   F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});
+    template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+             random_access_iterator I2, sized_sentinel_for<I2> S2,
+             random_access_iterator O, sized_sentinel_for<O> OutS,
+             copy_constructible F, class Proj1 = identity, class Proj2 = identity>
+      requires indirectly_writable<O, indirect_result_t<F&, projected<I1, Proj1>,
+                                   projected<I2, Proj2>>>
+      binary_transform_result<I1, I2, O>
+        transform(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2,
+                  O result, OutS result_last,
+                  F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});         // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+             sized-random-access-range OutR, copy_constructible F,
+             class Proj1 = identity, class Proj2 = identity>
+      requires indirectly_writable<iterator_t<OutR>,
+                                   indirect_result_t<F&, projected<iterator_t<R1>, Proj1>,
+                                   projected<iterator_t<R2>, Proj2>>>
+      binary_transform_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>,
+                              borrowed_iterator_t<OutR>>
+        transform(Ep&& exec, R1&& r1, R2&& r2, OutR&& result_r,
+                  F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});         // freestanding-deleted
   }
   // [alg.replace], replace
   template<class ForwardIterator, class T>
     constexpr void replace(ForwardIterator first, ForwardIterator last,
                            const T& old_value, const T& new_value);
+  template<class ExecutionPolicy, class ForwardIterator,
+           class T = iterator_traits<ForwardIterator>::value_type>
+    void replace(ExecutionPolicy&& exec,                        // freestanding-deleted, see [algorithms.parallel.overloads]
                  ForwardIterator first, ForwardIterator last,
                  const T& old_value, const T& new_value);
+  template<class ForwardIterator, class Predicate,
+           class T = iterator_traits<ForwardIterator>::value_type>
     constexpr void replace_if(ForwardIterator first, ForwardIterator last,
                               Predicate pred, const T& new_value);
+  template<class ExecutionPolicy, class ForwardIterator, class Predicate,
+           class T = iterator_traits<ForwardIterator>::value_type>
+    void replace_if(ExecutionPolicy&& exec,                     // freestanding-deleted, see [algorithms.parallel.overloads]
                     ForwardIterator first, ForwardIterator last,
                     Predicate pred, const T& new_value);
   namespace ranges {
+    template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+             class T1 = projected_value_t<I, Proj>, class T2 = T1>
       requires indirectly_writable<I, const T2&> &&
                indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*>
       constexpr I
         replace(I first, S last, const T1& old_value, const T2& new_value, Proj proj = {});
+    template<input_range R, class Proj = identity,
+             class T1 = projected_value_t<iterator_t<R>, Proj>, class T2 = T1>
       requires indirectly_writable<iterator_t<R>, const T2&> &&
                indirect_binary_predicate<ranges::equal_to,
                                          projected<iterator_t<R>, Proj>, const T1*>
       constexpr borrowed_iterator_t<R>
         replace(R&& r, const T1& old_value, const T2& new_value, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity, class T1 = projected_value_t<I, Proj>, class T2 = T1>
+      requires indirectly_writable<I, const T2&> &&
+               indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*>
+      I replace(Ep&& exec, I first, S last,
+                const T1& old_value, const T2& new_value, Proj proj = {});  // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             class T1 = projected_value_t<iterator_t<R>, Proj>, class T2 = T1>
+      requires indirectly_writable<iterator_t<R>, const T2&> &&
+               indirect_binary_predicate<ranges::equal_to,
+                                         projected<iterator_t<R>, Proj>, const T1*>
+      borrowed_iterator_t<R>
+        replace(Ep&& exec, R&& r, const T1& old_value, const T2& new_value,
+                Proj proj = {});                                            // freestanding-deleted
+    template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+             class T = projected_value_t<I, Proj>,
              indirect_unary_predicate<projected<I, Proj>> Pred>
       requires indirectly_writable<I, const T&>
       constexpr I replace_if(I first, S last, Pred pred, const T& new_value, Proj proj = {});
+    template<input_range R, class Proj = identity, class T = projected_value_t<I, Proj>,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       requires indirectly_writable<iterator_t<R>, const T&>
       constexpr borrowed_iterator_t<R>
         replace_if(R&& r, Pred pred, const T& new_value, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity, class T = projected_value_t<I, Proj>,
+             indirect_unary_predicate<projected<I, Proj>> Pred>
+      requires indirectly_writable<I, const T&>
+      I replace_if(Ep&& exec, I first, S last, Pred pred,
+                   const T& new_value, Proj proj = {});         // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             class T = projected_value_t<iterator_t<R>, Proj>,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      requires indirectly_writable<iterator_t<R>, const T&>
+      borrowed_iterator_t<R>
+        replace_if(Ep&& exec, R&& r, Pred pred, const T& new_value,
+                   Proj proj = {});                             // freestanding-deleted
   }
   template<class InputIterator, class OutputIterator, class T>
     constexpr OutputIterator replace_copy(InputIterator first, InputIterator last,
                                           OutputIterator result,
                                           const T& old_value, const T& new_value);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class T>
+    ForwardIterator2 replace_copy(ExecutionPolicy&& exec,       // freestanding-deleted, see [algorithms.parallel.overloads]
                                   ForwardIterator1 first, ForwardIterator1 last,
                                   ForwardIterator2 result,
                                   const T& old_value, const T& new_value);
+  template<class InputIterator, class OutputIterator, class Predicate,
+           class T = iterator_traits<OutputIterator>::value_type>
     constexpr OutputIterator replace_copy_if(InputIterator first, InputIterator last,
                                              OutputIterator result,
                                              Predicate pred, const T& new_value);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
+           class Predicate, class T = iterator_traits<ForwardIterator2>::value_type>
+    ForwardIterator2 replace_copy_if(ExecutionPolicy&& exec,    // freestanding-deleted, see [algorithms.parallel.overloads]
                                      ForwardIterator1 first, ForwardIterator1 last,
                                      ForwardIterator2 result,
                                      Predicate pred, const T& new_value);
   namespace ranges {
     template<class I, class O>
       using replace_copy_result = in_out_result<I, O>;
+    template<input_iterator I, sentinel_for<I> S, class O,
+             class Proj = identity,
+             class T1 = projected_value_t<I, Proj>, class T2 = iter_value_t<O>>
       requires indirectly_copyable<I, O> &&
+               indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*> &&
+               output_iterator<O, const T2&>
       constexpr replace_copy_result<I, O>
         replace_copy(I first, S last, O result, const T1& old_value, const T2& new_value,
                      Proj proj = {});
+    template<input_range R, class O, class Proj = identity,
+             class T1 = projected_value_t<iterator_t<R>, Proj>, class T2 = iter_value_t<O>>
       requires indirectly_copyable<iterator_t<R>, O> &&
                indirect_binary_predicate<ranges::equal_to,
+                                         projected<iterator_t<R>, Proj>, const T1*> &&
+               output_iterator<O, const T2&>
       constexpr replace_copy_result<borrowed_iterator_t<R>, O>
         replace_copy(R&& r, O result, const T1& old_value, const T2& new_value,
                      Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             random_access_iterator O, sized_sentinel_for<O> OutS,
+             class Proj = identity,
+             class T1 = projected_value_t<I, Proj>, class T2 = iter_value_t<O>>
+      requires indirectly_copyable<I, O> &&
+               indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*> &&
+               indirectly_writable<O, const T2&>
+      replace_copy_result<I, O>
+        replace_copy(Ep&& exec, I first, S last, O result, OutS result_last, const T1& old_value,
+                     const T2& new_value, Proj proj = {});      // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR,
+             class Proj = identity, class T1 = projected_value_t<iterator_t<R>, Proj>,
+             class T2 = range_value_t<OutR>>
+      requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>> &&
+               indirect_binary_predicate<ranges::equal_to,
+                                         projected<iterator_t<R>, Proj>, const T1*> &&
+               indirectly_writable<iterator_t<OutR>, const T2&>
+      replace_copy_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+        replace_copy(Ep&& exec, R&& r, OutR&& result_r, const T1& old_value, const T2& new_value,
+                     Proj proj = {});                           // freestanding-deleted
     template<class I, class O>
       using replace_copy_if_result = in_out_result<I, O>;
+    template<input_iterator I, sentinel_for<I> S, class O, class T = iter_value_t<O>,
              class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+      requires indirectly_copyable<I, O> && output_iterator<O, const T&>
       constexpr replace_copy_if_result<I, O>
         replace_copy_if(I first, S last, O result, Pred pred, const T& new_value,
                         Proj proj = {});
+    template<input_range R, class O, class T = iter_value_t<O>, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      requires indirectly_copyable<iterator_t<R>, O> && output_iterator<O, const T&>
       constexpr replace_copy_if_result<borrowed_iterator_t<R>, O>
         replace_copy_if(R&& r, O result, Pred pred, const T& new_value,
                         Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             random_access_iterator O, sized_sentinel_for<O> OutS, class T = iter_value_t<O>,
+             class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+      requires indirectly_copyable<I, O> && indirectly_writable<O, const T&>
+      replace_copy_if_result<I, O>
+        replace_copy_if(Ep&& exec, I first, S last, O result, OutS result_last,
+                        Pred pred, const T& new_value, Proj proj = {});     // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR,
+             class T = range_value_t<OutR>, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>> &&
+               indirectly_writable<iterator_t<OutR>, const T&>
+      replace_copy_if_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+        replace_copy_if(Ep&& exec, R&& r, OutR&& result_r, Pred pred, const T& new_value,
+                        Proj proj = {});                                    // freestanding-deleted
   }
   // [alg.fill], fill
+  template<class ForwardIterator, class T = iterator_traits<ForwardIterator>::value_type>
     constexpr void fill(ForwardIterator first, ForwardIterator last, const T& value);
+  template<class ExecutionPolicy, class ForwardIterator,
+           class T = iterator_traits<ForwardIterator>::value_type>
+    void fill(ExecutionPolicy&& exec,                           // freestanding-deleted, see [algorithms.parallel.overloads]
               ForwardIterator first, ForwardIterator last, const T& value);
+  template<class OutputIterator, class Size,
+           class T = iterator_traits<OutputIterator>::value_type>
+    constexpr OutputIterator fill_n(OutputIterator first, Size n, const T& value)
   template<class ExecutionPolicy, class ForwardIterator,
+           class Size, class T = iterator_traits<ForwardIterator>::value_type>
+    ForwardIterator fill_n(ExecutionPolicy&& exec,              // freestanding-deleted, see [algorithms.parallel.overloads]
                            ForwardIterator first, Size n, const T& value);
   namespace ranges {
+    template<class O, sentinel_for<O> S, class T = iter_value_t<O>>
+      requires output_iterator<O, const T&>
       constexpr O fill(O first, S last, const T& value);
+    template<class R, class T = range_value_t<R>>
+      requires output_range<R, const T&>
       constexpr borrowed_iterator_t<R> fill(R&& r, const T& value);
+    template<class O, class T = iter_value_t<O>>
+      requires output_iterator<O, const T&>
       constexpr O fill_n(O first, iter_difference_t<O> n, const T& value);
+    template<execution-policy Ep, random_access_iterator O, sized_sentinel_for<O> S,
+             class T = iter_value_t<O>>
+      requires indirectly_writable<O, const T&>
+      O fill(Ep&& exec, O first, S last, const T& value);                   // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class T = range_value_t<R>>
+      requires indirectly_writable<iterator_t<R>, const T&>
+      borrowed_iterator_t<R> fill(Ep&& exec, R&& r, const T& value);        // freestanding-deleted
+    template<execution-policy Ep, random_access_iterator O, class T = iter_value_t<O>>
+      requires indirectly_writable<O, const T&>
+      O fill_n(Ep&& exec, O first, iter_difference_t<O> n, const T& value); // freestanding-deleted
   }
   // [alg.generate], generate
   template<class ForwardIterator, class Generator>
     constexpr void generate(ForwardIterator first, ForwardIterator last,
                             Generator gen);
   template<class ExecutionPolicy, class ForwardIterator, class Generator>
+    void generate(ExecutionPolicy&& exec,                       // freestanding-deleted, see [algorithms.parallel.overloads]
                   ForwardIterator first, ForwardIterator last,
                   Generator gen);
   template<class OutputIterator, class Size, class Generator>
     constexpr OutputIterator generate_n(OutputIterator first, Size n, Generator gen);
   template<class ExecutionPolicy, class ForwardIterator, class Size, class Generator>
+    ForwardIterator generate_n(ExecutionPolicy&& exec,          // freestanding-deleted, see [algorithms.parallel.overloads]
                                ForwardIterator first, Size n, Generator gen);
   namespace ranges {
     template<input_or_output_iterator O, sentinel_for<O> S, copy_constructible F>
       requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
       requires invocable<F&> && output_range<R, invoke_result_t<F&>>
       constexpr borrowed_iterator_t<R> generate(R&& r, F gen);
     template<input_or_output_iterator O, copy_constructible F>
       requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
       constexpr O generate_n(O first, iter_difference_t<O> n, F gen);
+    template<execution-policy Ep, random_access_iterator O, sized_sentinel_for<O> S,
+             copy_constructible F>
+      requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
+      O generate(Ep&& exec, O first, S last, F gen);                        // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, copy_constructible F>
+      requires invocable<F&> && indirectly_writable<iterator_t<R>, invoke_result_t<F&>>
+      borrowed_iterator_t<R> generate(Ep&& exec, R&& r, F gen);             // freestanding-deleted
+    template<execution-policy Ep, random_access_iterator O, copy_constructible F>
+      requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
+      O generate_n(Ep&& exec, O first, iter_difference_t<O> n, F gen);      // freestanding-deleted
   }
   // [alg.remove], remove
+  template<class ForwardIterator, class T = iterator_traits<ForwardIterator>::value_type>
     constexpr ForwardIterator remove(ForwardIterator first, ForwardIterator last,
                                      const T& value);
+  template<class ExecutionPolicy, class ForwardIterator,
+           class T = iterator_traits<ForwardIterator>::value_type>
+    ForwardIterator remove(ExecutionPolicy&& exec,              // freestanding-deleted, see [algorithms.parallel.overloads]
                            ForwardIterator first, ForwardIterator last,
                            const T& value);
   template<class ForwardIterator, class Predicate>
     constexpr ForwardIterator remove_if(ForwardIterator first, ForwardIterator last,
                                         Predicate pred);
   template<class ExecutionPolicy, class ForwardIterator, class Predicate>
+    ForwardIterator remove_if(ExecutionPolicy&& exec,           // freestanding-deleted, see [algorithms.parallel.overloads]
                               ForwardIterator first, ForwardIterator last,
                               Predicate pred);
   namespace ranges {
+    template<permutable I, sentinel_for<I> S, class Proj = identity,
+             class T = projected_value_t<I, Proj>>
       requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
       constexpr subrange<I> remove(I first, S last, const T& value, Proj proj = {});
+    template<forward_range R, class Proj = identity,
+             class T = projected_value_t<iterator_t<R>, Proj>>
       requires permutable<iterator_t<R>> &&
                indirect_binary_predicate<ranges::equal_to,
                                          projected<iterator_t<R>, Proj>, const T*>
       constexpr borrowed_subrange_t<R>
         remove(R&& r, const T& value, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity, class T = projected_value_t<I, Proj>>
+      requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
+      subrange<I> remove(Ep&& exec, I first, S last, const T& value,
+                         Proj proj = {});                                   // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             class T = projected_value_t<iterator_t<R>, Proj>>
+      requires permutable<iterator_t<R>> &&
+               indirect_binary_predicate<ranges::equal_to,
+                                         projected<iterator_t<R>, Proj>, const T*>
+      borrowed_subrange_t<R>
+        remove(Ep&& exec, R&& r, const T& value, Proj proj = {});           // freestanding-deleted
     template<permutable I, sentinel_for<I> S, class Proj = identity,
              indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr subrange<I> remove_if(I first, S last, Pred pred, Proj proj = {});
     template<forward_range R, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       requires permutable<iterator_t<R>>
       constexpr borrowed_subrange_t<R>
         remove_if(R&& r, Pred pred, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+      subrange<I>
+        remove_if(Ep&& exec, I first, S last, Pred pred, Proj proj = {});   // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      requires permutable<iterator_t<R>>
+      borrowed_subrange_t<R>
+        remove_if(Ep&& exec, R&& r, Pred pred, Proj proj = {});             // freestanding-deleted
   }
+  template<class InputIterator, class OutputIterator,
+           class T = iterator_traits<InputIterator>::value_type>
     constexpr OutputIterator
       remove_copy(InputIterator first, InputIterator last,
                   OutputIterator result, const T& value);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
+           class T = iterator_traits<ForwardIterator1>::value_type>
     ForwardIterator2
+      remove_copy(ExecutionPolicy&& exec,                       // freestanding-deleted, see [algorithms.parallel.overloads]
                   ForwardIterator1 first, ForwardIterator1 last,
                   ForwardIterator2 result, const T& value);
   template<class InputIterator, class OutputIterator, class Predicate>
     constexpr OutputIterator
       remove_copy_if(InputIterator first, InputIterator last,
                      OutputIterator result, Predicate pred);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class Predicate>
     ForwardIterator2
+      remove_copy_if(ExecutionPolicy&& exec,                    // freestanding-deleted, see [algorithms.parallel.overloads]
                      ForwardIterator1 first, ForwardIterator1 last,
                      ForwardIterator2 result, Predicate pred);
   namespace ranges {
     template<class I, class O>
       using remove_copy_result = in_out_result<I, O>;
+    template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
+             class Proj = identity, class T = projected_value_t<I, Proj>>
       requires indirectly_copyable<I, O> &&
                indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
       constexpr remove_copy_result<I, O>
         remove_copy(I first, S last, O result, const T& value, Proj proj = {});
+    template<input_range R, weakly_incrementable O, class Proj = identity,
+             class T = projected_value_t<iterator_t<R>, Proj>>
       requires indirectly_copyable<iterator_t<R>, O> &&
                indirect_binary_predicate<ranges::equal_to,
                                          projected<iterator_t<R>, Proj>, const T*>
       constexpr remove_copy_result<borrowed_iterator_t<R>, O>
         remove_copy(R&& r, O result, const T& value, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             random_access_iterator O, sized_sentinel_for<O> OutS,
+             class Proj = identity, class T = projected_value_t<I, Proj>>
+      requires indirectly_copyable<I, O> &&
+               indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
+      remove_copy_result<I, O>
+        remove_copy(Ep&& exec, I first, S last, O result, OutS result_last, const T& value,
+                    Proj proj = {});                                        // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR,
+             class Proj = identity, class T = projected_value_t<iterator_t<R>, Proj>>
+      requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>> &&
+               indirect_binary_predicate<ranges::equal_to,
+                                         projected<iterator_t<R>, Proj>, const T*>
+      remove_copy_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+        remove_copy(Ep&& exec, R&& r, OutR&& result_r, const T& value,
+                    Proj proj = {});                                        // freestanding-deleted
     template<class I, class O>
       using remove_copy_if_result = in_out_result<I, O>;
     template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
              class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
     template<input_range R, weakly_incrementable O, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       requires indirectly_copyable<iterator_t<R>, O>
       constexpr remove_copy_if_result<borrowed_iterator_t<R>, O>
         remove_copy_if(R&& r, O result, Pred pred, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             random_access_iterator O, sized_sentinel_for<O> OutS,
+             class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+      requires indirectly_copyable<I, O>
+      remove_copy_if_result<I, O>
+        remove_copy_if(Ep&& exec, I first, S last, O result, OutS result_last, Pred pred,
+                       Proj proj = {});                         // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR,
+             class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>>
+      remove_copy_if_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+        remove_copy_if(Ep&& exec, R&& r, OutR&& result_r, Pred pred,
+                       Proj proj = {});                         // freestanding-deleted
   }
   // [alg.unique], unique
   template<class ForwardIterator>
     constexpr ForwardIterator unique(ForwardIterator first, ForwardIterator last);
   template<class ForwardIterator, class BinaryPredicate>
     constexpr ForwardIterator unique(ForwardIterator first, ForwardIterator last,
                                      BinaryPredicate pred);
   template<class ExecutionPolicy, class ForwardIterator>
+    ForwardIterator unique(ExecutionPolicy&& exec,              // freestanding-deleted, see [algorithms.parallel.overloads]
                            ForwardIterator first, ForwardIterator last);
   template<class ExecutionPolicy, class ForwardIterator, class BinaryPredicate>
+    ForwardIterator unique(ExecutionPolicy&& exec,              // freestanding-deleted, see [algorithms.parallel.overloads]
                            ForwardIterator first, ForwardIterator last,
                            BinaryPredicate pred);
   namespace ranges {
     template<permutable I, sentinel_for<I> S, class Proj = identity,
     template<forward_range R, class Proj = identity,
              indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
       requires permutable<iterator_t<R>>
       constexpr borrowed_subrange_t<R>
         unique(R&& r, C comp = {}, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity,
+             indirect_equivalence_relation<projected<I, Proj>> C = ranges::equal_to>
+      requires permutable<I>
+      subrange<I> unique(Ep&& exec, I first, S last, C comp = {},
+                         Proj proj = {});                       // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
+      requires permutable<iterator_t<R>>
+      borrowed_subrange_t<R>
+        unique(Ep&& exec, R&& r, C comp = {}, Proj proj = {});  // freestanding-deleted
   }
   template<class InputIterator, class OutputIterator>
     constexpr OutputIterator
       unique_copy(InputIterator first, InputIterator last,
     constexpr OutputIterator
       unique_copy(InputIterator first, InputIterator last,
                   OutputIterator result, BinaryPredicate pred);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
     ForwardIterator2
+      unique_copy(ExecutionPolicy&& exec,                       // freestanding-deleted, see [algorithms.parallel.overloads]
                   ForwardIterator1 first, ForwardIterator1 last,
                   ForwardIterator2 result);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class BinaryPredicate>
     ForwardIterator2
+      unique_copy(ExecutionPolicy&& exec,                       // freestanding-deleted, see [algorithms.parallel.overloads]
                   ForwardIterator1 first, ForwardIterator1 last,
                   ForwardIterator2 result, BinaryPredicate pred);
   namespace ranges {
     template<class I, class O>
                (forward_iterator<iterator_t<R>> ||
                 (input_iterator<O> && same_as<range_value_t<R>, iter_value_t<O>>) ||
                 indirectly_copyable_storable<iterator_t<R>, O>)
       constexpr unique_copy_result<borrowed_iterator_t<R>, O>
         unique_copy(R&& r, O result, C comp = {}, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             random_access_iterator O, sized_sentinel_for<O> OutS, class Proj = identity,
+             indirect_equivalence_relation<projected<I, Proj>> C = ranges::equal_to>
+      requires indirectly_copyable<I, O>
+      unique_copy_result<I, O>
+        unique_copy(Ep&& exec, I first, S last, O result, OutS result_last, C comp = {},
+                    Proj proj = {});                            // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR,
+             class Proj = identity,
+             indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
+      requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>>
+      unique_copy_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+        unique_copy(Ep&& exec, R&& r, OutR&& result_r, C comp = {},
+                    Proj proj = {});                            // freestanding-deleted
   }
   // [alg.reverse], reverse
   template<class BidirectionalIterator>
     constexpr void reverse(BidirectionalIterator first, BidirectionalIterator last);
   template<class ExecutionPolicy, class BidirectionalIterator>
+    void reverse(ExecutionPolicy&& exec,                        // freestanding-deleted, see [algorithms.parallel.overloads]
                  BidirectionalIterator first, BidirectionalIterator last);
   namespace ranges {
     template<bidirectional_iterator I, sentinel_for<I> S>
       requires permutable<I>
       constexpr I reverse(I first, S last);
     template<bidirectional_range R>
       requires permutable<iterator_t<R>>
       constexpr borrowed_iterator_t<R> reverse(R&& r);
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S>
+      requires permutable<I>
+      I reverse(Ep&& exec, I first, S last);                    // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R>
+      requires permutable<iterator_t<R>>
+      borrowed_iterator_t<R> reverse(Ep&& exec, R&& r);         // freestanding-deleted
   }
   template<class BidirectionalIterator, class OutputIterator>
     constexpr OutputIterator
       reverse_copy(BidirectionalIterator first, BidirectionalIterator last,
                    OutputIterator result);
   template<class ExecutionPolicy, class BidirectionalIterator, class ForwardIterator>
     ForwardIterator
+      reverse_copy(ExecutionPolicy&& exec,                      // freestanding-deleted, see [algorithms.parallel.overloads]
                    BidirectionalIterator first, BidirectionalIterator last,
                    ForwardIterator result);
   namespace ranges {
     template<class I, class O>
       using reverse_copy_result = in_out_result<I, O>;
+    template<class I, class O>
+      using reverse_copy_truncated_result = in_in_out_result<I, I, O>;
     template<bidirectional_iterator I, sentinel_for<I> S, weakly_incrementable O>
       requires indirectly_copyable<I, O>
       constexpr reverse_copy_result<I, O>
         reverse_copy(I first, S last, O result);
     template<bidirectional_range R, weakly_incrementable O>
       requires indirectly_copyable<iterator_t<R>, O>
       constexpr reverse_copy_result<borrowed_iterator_t<R>, O>
         reverse_copy(R&& r, O result);
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             random_access_iterator O, sized_sentinel_for<O> OutS>
+      requires indirectly_copyable<I, O>
+      reverse_copy_truncated_result<I, O>
+        reverse_copy(Ep&& exec, I first, S last, O result,
+                     OutS result_last);                         // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR>
+      requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>>
+      reverse_copy_truncated_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+        reverse_copy(Ep&& exec, R&& r, OutR&& result_r);        // freestanding-deleted
   }
   // [alg.rotate], rotate
   template<class ForwardIterator>
     constexpr ForwardIterator rotate(ForwardIterator first,
                                      ForwardIterator middle,
                                      ForwardIterator last);
   template<class ExecutionPolicy, class ForwardIterator>
+    ForwardIterator rotate(ExecutionPolicy&& exec,              // freestanding-deleted, see [algorithms.parallel.overloads]
                            ForwardIterator first,
                            ForwardIterator middle,
                            ForwardIterator last);
   namespace ranges {
     template<permutable I, sentinel_for<I> S>
       constexpr subrange<I> rotate(I first, I middle, S last);
     template<forward_range R>
       requires permutable<iterator_t<R>>
       constexpr borrowed_subrange_t<R> rotate(R&& r, iterator_t<R> middle);
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S>
+      requires permutable<I>
+      subrange<I>
+        rotate(Ep&& exec, I first, I middle, S last);           // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R>
+      requires permutable<iterator_t<R>>
+      borrowed_subrange_t<R>
+        rotate(Ep&& exec, R&& r, iterator_t<R> middle);         // freestanding-deleted
   }
   template<class ForwardIterator, class OutputIterator>
     constexpr OutputIterator
       rotate_copy(ForwardIterator first, ForwardIterator middle,
                   ForwardIterator last, OutputIterator result);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
     ForwardIterator2
+      rotate_copy(ExecutionPolicy&& exec,                       // freestanding-deleted, see [algorithms.parallel.overloads]
                   ForwardIterator1 first, ForwardIterator1 middle,
                   ForwardIterator1 last, ForwardIterator2 result);
   namespace ranges {
     template<class I, class O>
       using rotate_copy_result = in_out_result<I, O>;
+    template<class I, class O>
+      using rotate_copy_truncated_result = in_in_out_result<I, I, O>;
     template<forward_iterator I, sentinel_for<I> S, weakly_incrementable O>
       requires indirectly_copyable<I, O>
       constexpr rotate_copy_result<I, O>
         rotate_copy(I first, I middle, S last, O result);
     template<forward_range R, weakly_incrementable O>
       requires indirectly_copyable<iterator_t<R>, O>
       constexpr rotate_copy_result<borrowed_iterator_t<R>, O>
         rotate_copy(R&& r, iterator_t<R> middle, O result);
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             random_access_iterator O, sized_sentinel_for<O> OutS>
+      requires indirectly_copyable<I, O>
+      rotate_copy_truncated_result<I, O>
+        rotate_copy(Ep&& exec, I first, I middle, S last, O result,     // freestanding-deleted
+                    OutS result_last);
+    template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR>
+      requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>>
+      rotate_copy_truncated_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+        rotate_copy(Ep&& exec, R&& r, iterator_t<R> middle,             // freestanding-deleted
+                    OutR&& result_r);
   }
   // [alg.random.sample], sample
   template<class PopulationIterator, class SampleIterator,
            class Distance, class UniformRandomBitGenerator>
     constexpr ForwardIterator
       shift_left(ForwardIterator first, ForwardIterator last,
                  typename iterator_traits<ForwardIterator>::difference_type n);
   template<class ExecutionPolicy, class ForwardIterator>
     ForwardIterator
+      shift_left(ExecutionPolicy&& exec,                        // freestanding-deleted, see [algorithms.parallel.overloads]
                  ForwardIterator first, ForwardIterator last,
                  typename iterator_traits<ForwardIterator>::difference_type n);
   namespace ranges {
     template<permutable I, sentinel_for<I> S>
       constexpr subrange<I> shift_left(I first, S last, iter_difference_t<I> n);
     template<forward_range R>
       requires permutable<iterator_t<R>>
       constexpr borrowed_subrange_t<R> shift_left(R&& r, range_difference_t<R> n);
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S>
+      requires permutable<I>
+      subrange<I>
+        shift_left(Ep&& exec, I first, S last, iter_difference_t<I> n);     // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R>
+      requires permutable<iterator_t<R>>
+      borrowed_subrange_t<R>
+        shift_left(Ep&& exec, R&& r, range_difference_t<R> n);              // freestanding-deleted
   }
   template<class ForwardIterator>
     constexpr ForwardIterator
       shift_right(ForwardIterator first, ForwardIterator last,
                   typename iterator_traits<ForwardIterator>::difference_type n);
   template<class ExecutionPolicy, class ForwardIterator>
     ForwardIterator
+      shift_right(ExecutionPolicy&& exec,                       // freestanding-deleted, see [algorithms.parallel.overloads]
                   ForwardIterator first, ForwardIterator last,
                   typename iterator_traits<ForwardIterator>::difference_type n);
   namespace ranges {
     template<permutable I, sentinel_for<I> S>
       constexpr subrange<I> shift_right(I first, S last, iter_difference_t<I> n);
     template<forward_range R>
       requires permutable<iterator_t<R>>
       constexpr borrowed_subrange_t<R> shift_right(R&& r, range_difference_t<R> n);
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S>
+      requires permutable<I>
+      subrange<I>
+        shift_right(Ep&& exec, I first, S last, iter_difference_t<I> n);    // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R>
+      requires permutable<iterator_t<R>>
+      borrowed_subrange_t<R>
+        shift_right(Ep&& exec, R&& r, range_difference_t<R> n);             // freestanding-deleted
   }
   // [alg.sorting], sorting and related operations
   // [alg.sort], sorting
   template<class RandomAccessIterator>
     constexpr void sort(RandomAccessIterator first, RandomAccessIterator last);
   template<class RandomAccessIterator, class Compare>
     constexpr void sort(RandomAccessIterator first, RandomAccessIterator last,
                         Compare comp);
   template<class ExecutionPolicy, class RandomAccessIterator>
+    void sort(ExecutionPolicy&& exec,                           // freestanding-deleted, see [algorithms.parallel.overloads]
               RandomAccessIterator first, RandomAccessIterator last);
   template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
+    void sort(ExecutionPolicy&& exec,                           // freestanding-deleted, see [algorithms.parallel.overloads]
               RandomAccessIterator first, RandomAccessIterator last,
               Compare comp);
   namespace ranges {
     template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
         sort(I first, S last, Comp comp = {}, Proj proj = {});
     template<random_access_range R, class Comp = ranges::less, class Proj = identity>
       requires sortable<iterator_t<R>, Comp, Proj>
       constexpr borrowed_iterator_t<R>
         sort(R&& r, Comp comp = {}, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Comp = ranges::less, class Proj = identity>
+      requires sortable<I, Comp, Proj>
+      I sort(Ep&& exec, I first, S last, Comp comp = {}, Proj proj = {});   // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Comp = ranges::less,
+             class Proj = identity>
+      requires sortable<iterator_t<R>, Comp, Proj>
+      borrowed_iterator_t<R>
+        sort(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});             // freestanding-deleted
   }
   template<class RandomAccessIterator>
+ constexpr void stable_sort(RandomAccessIterator first, RandomAccessIterator last);  // hosted
   template<class RandomAccessIterator, class Compare>
+ constexpr void stable_sort(RandomAccessIterator first, RandomAccessIterator last,   // hosted
                                Compare comp);
   template<class ExecutionPolicy, class RandomAccessIterator>
+    void stable_sort(ExecutionPolicy&& exec,                    // hosted, see [algorithms.parallel.overloads]
                      RandomAccessIterator first, RandomAccessIterator last);
   template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
+    void stable_sort(ExecutionPolicy&& exec,                    // hosted, see [algorithms.parallel.overloads]
                      RandomAccessIterator first, RandomAccessIterator last,
                      Compare comp);
   namespace ranges {
     template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
              class Proj = identity>
       requires sortable<I, Comp, Proj>
+ constexpr I stable_sort(I first, S last, Comp comp = {}, Proj proj = {});         // hosted
     template<random_access_range R, class Comp = ranges::less, class Proj = identity>
       requires sortable<iterator_t<R>, Comp, Proj>
+      constexpr borrowed_iterator_t<R>
+        stable_sort(R&& r, Comp comp = {}, Proj proj = {});                             // hosted
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Comp = ranges::less, class Proj = identity>
+      requires sortable<I, Comp, Proj>
+      I stable_sort(Ep&& exec, I first, S last, Comp comp = {},
+                    Proj proj = {});                                        // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Comp = ranges::less,
+             class Proj = identity>
+      requires sortable<iterator_t<R>, Comp, Proj>
       borrowed_iterator_t<R>
+        stable_sort(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});      // freestanding-deleted
   }
   template<class RandomAccessIterator>
     constexpr void partial_sort(RandomAccessIterator first, RandomAccessIterator middle,
                                 RandomAccessIterator last);
   template<class RandomAccessIterator, class Compare>
     constexpr void partial_sort(RandomAccessIterator first, RandomAccessIterator middle,
                                 RandomAccessIterator last, Compare comp);
   template<class ExecutionPolicy, class RandomAccessIterator>
+    void partial_sort(ExecutionPolicy&& exec,                   // freestanding-deleted, see [algorithms.parallel.overloads]
                       RandomAccessIterator first, RandomAccessIterator middle,
                       RandomAccessIterator last);
   template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
+    void partial_sort(ExecutionPolicy&& exec,                   // freestanding-deleted, see [algorithms.parallel.overloads]
                       RandomAccessIterator first, RandomAccessIterator middle,
                       RandomAccessIterator last, Compare comp);
   namespace ranges {
     template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
     template<random_access_range R, class Comp = ranges::less, class Proj = identity>
       requires sortable<iterator_t<R>, Comp, Proj>
       constexpr borrowed_iterator_t<R>
         partial_sort(R&& r, iterator_t<R> middle, Comp comp = {},
                      Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Comp = ranges::less, class Proj = identity>
+      requires sortable<I, Comp, Proj>
+      I partial_sort(Ep&& exec, I first, I middle, S last, Comp comp = {},
+                     Proj proj = {});                           // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R,
+             class Comp = ranges::less, class Proj = identity>
+      requires sortable<iterator_t<R>, Comp, Proj>
+      borrowed_iterator_t<R>
+        partial_sort(Ep&& exec, R&& r, iterator_t<R> middle, Comp comp = {},
+                     Proj proj = {});                           // freestanding-deleted
   }
   template<class InputIterator, class RandomAccessIterator>
     constexpr RandomAccessIterator
       partial_sort_copy(InputIterator first, InputIterator last,
                         RandomAccessIterator result_first,
                         RandomAccessIterator result_last,
                         Compare comp);
   template<class ExecutionPolicy, class ForwardIterator, class RandomAccessIterator>
     RandomAccessIterator
+      partial_sort_copy(ExecutionPolicy&& exec,                 // freestanding-deleted, see [algorithms.parallel.overloads]
                         ForwardIterator first, ForwardIterator last,
                         RandomAccessIterator result_first,
                         RandomAccessIterator result_last);
   template<class ExecutionPolicy, class ForwardIterator, class RandomAccessIterator,
            class Compare>
     RandomAccessIterator
+      partial_sort_copy(ExecutionPolicy&& exec,                 // freestanding-deleted, see [algorithms.parallel.overloads]
                         ForwardIterator first, ForwardIterator last,
                         RandomAccessIterator result_first,
                         RandomAccessIterator result_last,
                         Compare comp);
                indirect_strict_weak_order<Comp, projected<iterator_t<R1>, Proj1>,
                                           projected<iterator_t<R2>, Proj2>>
       constexpr partial_sort_copy_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
         partial_sort_copy(R1&& r, R2&& result_r, Comp comp = {},
                           Proj1 proj1 = {}, Proj2 proj2 = {});
+    template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+             random_access_iterator I2, sized_sentinel_for<I2> S2,
+             class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
+      requires indirectly_copyable<I1, I2> && sortable<I2, Comp, Proj2> &&
+               indirect_strict_weak_order<Comp, projected<I1, Proj1>, projected<I2, Proj2>>
+      partial_sort_copy_result<I1, I2>
+        partial_sort_copy(Ep&& exec, I1 first, S1 last, I2 result_first, S2 result_last,
+                          Comp comp = {}, Proj1 proj1 = {},
+                          Proj2 proj2 = {});                    // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+             class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
+      requires indirectly_copyable<iterator_t<R1>, iterator_t<R2>> &&
+               sortable<iterator_t<R2>, Comp, Proj2> &&
+               indirect_strict_weak_order<Comp, projected<iterator_t<R1>, Proj1>,
+                                          projected<iterator_t<R2>, Proj2>>
+      partial_sort_copy_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
+        partial_sort_copy(Ep&& exec, R1&& r, R2&& result_r, Comp comp = {},
+                          Proj1 proj1 = {}, Proj2 proj2 = {});  // freestanding-deleted
   }
   template<class ForwardIterator>
     constexpr bool is_sorted(ForwardIterator first, ForwardIterator last);
   template<class ForwardIterator, class Compare>
     constexpr bool is_sorted(ForwardIterator first, ForwardIterator last,
                              Compare comp);
   template<class ExecutionPolicy, class ForwardIterator>
+    bool is_sorted(ExecutionPolicy&& exec,                      // freestanding-deleted, see [algorithms.parallel.overloads]
                    ForwardIterator first, ForwardIterator last);
   template<class ExecutionPolicy, class ForwardIterator, class Compare>
+    bool is_sorted(ExecutionPolicy&& exec,                      // freestanding-deleted, see [algorithms.parallel.overloads]
                    ForwardIterator first, ForwardIterator last,
                    Compare comp);
   namespace ranges {
     template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
              indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
       constexpr bool is_sorted(I first, S last, Comp comp = {}, Proj proj = {});
     template<forward_range R, class Proj = identity,
              indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       constexpr bool is_sorted(R&& r, Comp comp = {}, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity,
+             indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+      bool is_sorted(Ep&& exec, I first, S last, Comp comp = {},
+                     Proj proj = {});                                       // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+      bool is_sorted(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});     // freestanding-deleted
   }
   template<class ForwardIterator>
     constexpr ForwardIterator
       is_sorted_until(ForwardIterator first, ForwardIterator last);
     constexpr ForwardIterator
       is_sorted_until(ForwardIterator first, ForwardIterator last,
                       Compare comp);
   template<class ExecutionPolicy, class ForwardIterator>
     ForwardIterator
+      is_sorted_until(ExecutionPolicy&& exec,                   // freestanding-deleted, see [algorithms.parallel.overloads]
                       ForwardIterator first, ForwardIterator last);
   template<class ExecutionPolicy, class ForwardIterator, class Compare>
     ForwardIterator
+      is_sorted_until(ExecutionPolicy&& exec,                   // freestanding-deleted, see [algorithms.parallel.overloads]
                       ForwardIterator first, ForwardIterator last,
                       Compare comp);
   namespace ranges {
     template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
       constexpr I is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {});
     template<forward_range R, class Proj = identity,
              indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       constexpr borrowed_iterator_t<R>
         is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity,
+             indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+      I is_sorted_until(Ep&& exec, I first, S last, Comp comp = {},
+                        Proj proj = {});                                    // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+      borrowed_iterator_t<R>
+        is_sorted_until(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});  // freestanding-deleted
   }
   // [alg.nth.element], Nth element
   template<class RandomAccessIterator>
     constexpr void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
                                RandomAccessIterator last);
   template<class RandomAccessIterator, class Compare>
     constexpr void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
                                RandomAccessIterator last, Compare comp);
   template<class ExecutionPolicy, class RandomAccessIterator>
+    void nth_element(ExecutionPolicy&& exec,                    // freestanding-deleted, see [algorithms.parallel.overloads]
                      RandomAccessIterator first, RandomAccessIterator nth,
                      RandomAccessIterator last);
   template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
+    void nth_element(ExecutionPolicy&& exec,                    // freestanding-deleted, see [algorithms.parallel.overloads]
                      RandomAccessIterator first, RandomAccessIterator nth,
                      RandomAccessIterator last, Compare comp);
   namespace ranges {
     template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
         nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {});
     template<random_access_range R, class Comp = ranges::less, class Proj = identity>
       requires sortable<iterator_t<R>, Comp, Proj>
       constexpr borrowed_iterator_t<R>
         nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Comp = ranges::less, class Proj = identity>
+      requires sortable<I, Comp, Proj>
+      I nth_element(Ep&& exec, I first, I nth, S last, Comp comp = {},
+                    Proj proj = {});                            // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Comp = ranges::less,
+             class Proj = identity>
+      requires sortable<iterator_t<R>, Comp, Proj>
+      borrowed_iterator_t<R>
+        nth_element(Ep&& exec, R&& r, iterator_t<R> nth, Comp comp = {},
+                    Proj proj = {});                            // freestanding-deleted
   }
   // [alg.binary.search], binary search
+  template<class ForwardIterator, class T = iterator_traits<ForwardIterator>::value_type>
     constexpr ForwardIterator
       lower_bound(ForwardIterator first, ForwardIterator last,
                   const T& value);
+  template<class ForwardIterator, class T = iterator_traits<ForwardIterator>::value_type,
+           class Compare>
     constexpr ForwardIterator
       lower_bound(ForwardIterator first, ForwardIterator last,
                   const T& value, Compare comp);
   namespace ranges {
+    template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+             class T = projected_value_t<I, Proj>,
              indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
       constexpr I lower_bound(I first, S last, const T& value, Comp comp = {},
                               Proj proj = {});
+    template<forward_range R, class Proj = identity,
+             class T = projected_value_t<iterator_t<R>, Proj>,
              indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
                ranges::less>
       constexpr borrowed_iterator_t<R>
         lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
   }
+  template<class ForwardIterator, class T = iterator_traits<ForwardIterator>::value_type>
     constexpr ForwardIterator
       upper_bound(ForwardIterator first, ForwardIterator last,
                   const T& value);
+  template<class ForwardIterator, class T = iterator_traits<ForwardIterator>::value_type,
+           class Compare>
     constexpr ForwardIterator
       upper_bound(ForwardIterator first, ForwardIterator last,
                   const T& value, Compare comp);
   namespace ranges {
+    template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+             class T = projected_value_t<I, Proj>
              indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
       constexpr I upper_bound(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
+    template<forward_range R, class Proj = identity,
+             class T = projected_value_t<iterator_t<R>, Proj>,
              indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
                ranges::less>
       constexpr borrowed_iterator_t<R>
         upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
   }
+  template<class ForwardIterator, class T = iterator_traits<ForwardIterator>::value_type>
     constexpr pair<ForwardIterator, ForwardIterator>
       equal_range(ForwardIterator first, ForwardIterator last,
                   const T& value);
+  template<class ForwardIterator, class T = iterator_traits<ForwardIterator>::value_type,
+           class Compare>
     constexpr pair<ForwardIterator, ForwardIterator>
       equal_range(ForwardIterator first, ForwardIterator last,
                   const T& value, Compare comp);
   namespace ranges {
+    template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+             class T = projected_value_t<I, Proj,
              indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
       constexpr subrange<I>
         equal_range(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
+    template<forward_range R, class Proj = identity,
+             class T = projected_value_t<iterator_t<R>, Proj>,
              indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
                ranges::less>
       constexpr borrowed_subrange_t<R>
         equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {});
   }
+  template<class ForwardIterator, class T = iterator_traits<ForwardIterator>::value_type>
     constexpr bool
       binary_search(ForwardIterator first, ForwardIterator last,
                     const T& value);
+  template<class ForwardIterator, class T = iterator_traits<ForwardIterator>::value_type,
+           class Compare>
     constexpr bool
       binary_search(ForwardIterator first, ForwardIterator last,
                     const T& value, Compare comp);
   namespace ranges {
+    template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+             class T = projected_value_t<I, Proj>,
              indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
       constexpr bool binary_search(I first, S last, const T& value, Comp comp = {},
                                    Proj proj = {});
+    template<forward_range R, class Proj = identity,
+             class T = projected_value_t<iterator_t<R>, Proj>,
              indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
                ranges::less>
       constexpr bool binary_search(R&& r, const T& value, Comp comp = {},
                                    Proj proj = {});
   }
   // [alg.partitions], partitions
   template<class InputIterator, class Predicate>
     constexpr bool is_partitioned(InputIterator first, InputIterator last, Predicate pred);
   template<class ExecutionPolicy, class ForwardIterator, class Predicate>
+    bool is_partitioned(ExecutionPolicy&& exec,                 // freestanding-deleted, see [algorithms.parallel.overloads]
                         ForwardIterator first, ForwardIterator last, Predicate pred);
   namespace ranges {
     template<input_iterator I, sentinel_for<I> S, class Proj = identity,
              indirect_unary_predicate<projected<I, Proj>> Pred>
       constexpr bool is_partitioned(I first, S last, Pred pred, Proj proj = {});
     template<input_range R, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       constexpr bool is_partitioned(R&& r, Pred pred, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+      bool is_partitioned(Ep&& exec, I first, S last, Pred pred,
+                          Proj proj = {});                                  // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      bool is_partitioned(Ep&& exec, R&& r, Pred pred, Proj proj = {});     // freestanding-deleted
   }
   template<class ForwardIterator, class Predicate>
     constexpr ForwardIterator partition(ForwardIterator first,
                                         ForwardIterator last,
                                         Predicate pred);
   template<class ExecutionPolicy, class ForwardIterator, class Predicate>
+    ForwardIterator partition(ExecutionPolicy&& exec,           // freestanding-deleted, see [algorithms.parallel.overloads]
                               ForwardIterator first,
                               ForwardIterator last,
                               Predicate pred);
   namespace ranges {
     template<forward_range R, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       requires permutable<iterator_t<R>>
       constexpr borrowed_subrange_t<R>
         partition(R&& r, Pred pred, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+      subrange<I>
+        partition(Ep&& exec, I first, S last, Pred pred, Proj proj = {});   // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      requires permutable<iterator_t<R>>
+      borrowed_subrange_t<R>
+        partition(Ep&& exec, R&& r, Pred pred, Proj proj = {});             // freestanding-deleted
   }
   template<class BidirectionalIterator, class Predicate>
+ constexpr BidirectionalIterator stable_partition(BidirectionalIterator first,   // hosted
                                                      BidirectionalIterator last,
                                                      Predicate pred);
   template<class ExecutionPolicy, class BidirectionalIterator, class Predicate>
+    BidirectionalIterator stable_partition(ExecutionPolicy&& exec, // hosted,
+                                           BidirectionalIterator first,             // see [algorithms.parallel.overloads]
                                            BidirectionalIterator last,
                                            Predicate pred);
   namespace ranges {
     template<bidirectional_iterator I, sentinel_for<I> S, class Proj = identity,
              indirect_unary_predicate<projected<I, Proj>> Pred>
       requires permutable<I>
+ constexpr subrange<I> stable_partition(I first, S last, Pred pred,            // hosted
+                                             Proj proj = {});
     template<bidirectional_range R, class Proj = identity,
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       requires permutable<iterator_t<R>>
+ constexpr borrowed_subrange_t<R> stable_partition(R&& r, Pred pred,           // hosted
+                                                        Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+      requires permutable<I>
+      subrange<I>
+        stable_partition(Ep&& exec, I first, S last, Pred pred,
+                         Proj proj = {});                                   // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      requires permutable<iterator_t<R>>
+      borrowed_subrange_t<R>
+        stable_partition(Ep&& exec, R&& r, Pred pred, Proj proj = {});      // freestanding-deleted
   }
   template<class InputIterator, class OutputIterator1,
            class OutputIterator2, class Predicate>
     constexpr pair<OutputIterator1, OutputIterator2>
                      OutputIterator1 out_true, OutputIterator2 out_false,
                      Predicate pred);
   template<class ExecutionPolicy, class ForwardIterator, class ForwardIterator1,
            class ForwardIterator2, class Predicate>
     pair<ForwardIterator1, ForwardIterator2>
+      partition_copy(ExecutionPolicy&& exec,                    // freestanding-deleted, see [algorithms.parallel.overloads]
                      ForwardIterator first, ForwardIterator last,
                      ForwardIterator1 out_true, ForwardIterator2 out_false,
                      Predicate pred);
   namespace ranges {
              indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
       requires indirectly_copyable<iterator_t<R>, O1> &&
                indirectly_copyable<iterator_t<R>, O2>
       constexpr partition_copy_result<borrowed_iterator_t<R>, O1, O2>
         partition_copy(R&& r, O1 out_true, O2 out_false, Pred pred, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             random_access_iterator O1, sized_sentinel_for<O1> OutS1,
+             random_access_iterator O2, sized_sentinel_for<O2> OutS2,
+             class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+      requires indirectly_copyable<I, O1> && indirectly_copyable<I, O2>
+      partition_copy_result<I, O1, O2>
+        partition_copy(Ep&& exec, I first, S last, O1 out_true, OutS1 last_true,
+                       O2 out_false, OutS2 last_false, Pred pred,
+                       Proj proj = {});                         // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R,
+             sized-random-access-range OutR1, sized-random-access-range OutR2,
+             class Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+      requires indirectly_copyable<iterator_t<R>, iterator_t<OutR1>> &&
+               indirectly_copyable<iterator_t<R>, iterator_t<OutR2>>
+      partition_copy_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR1>,
+                            borrowed_iterator_t<OutR2>>
+        partition_copy(Ep&& exec, R&& r, OutR1&& out_true_r, OutR2&& out_false_r, Pred pred,
+                       Proj proj = {});                         // freestanding-deleted
   }
   template<class ForwardIterator, class Predicate>
     constexpr ForwardIterator
       partition_point(ForwardIterator first, ForwardIterator last,
             InputIterator2 first2, InputIterator2 last2,
             OutputIterator result, Compare comp);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator>
     ForwardIterator
+      merge(ExecutionPolicy&& exec,                             // freestanding-deleted, see [algorithms.parallel.overloads]
             ForwardIterator1 first1, ForwardIterator1 last1,
             ForwardIterator2 first2, ForwardIterator2 last2,
             ForwardIterator result);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator, class Compare>
     ForwardIterator
+      merge(ExecutionPolicy&& exec,                             // freestanding-deleted, see [algorithms.parallel.overloads]
             ForwardIterator1 first1, ForwardIterator1 last1,
             ForwardIterator2 first2, ForwardIterator2 last2,
             ForwardIterator result, Compare comp);
   namespace ranges {
              class Proj1 = identity, class Proj2 = identity>
       requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
       constexpr merge_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
         merge(R1&& r1, R2&& r2, O result,
               Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
+    template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+             random_access_iterator I2, sized_sentinel_for<I2> S2,
+             random_access_iterator O, sized_sentinel_for<O> OutS, class Comp = ranges::less,
+             class Proj1 = identity, class Proj2 = identity>
+      requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
+      merge_result<I1, I2, O>
+        merge(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2, O result, OutS result_last,
+              Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});          // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+             sized-random-access-range OutR, class Comp = ranges::less,
+             class Proj1 = identity, class Proj2 = identity>
+      requires mergeable<iterator_t<R1>, iterator_t<R2>, iterator_t<OutR>, Comp, Proj1, Proj2>
+      merge_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, borrowed_iterator_t<OutR>>
+        merge(Ep&& exec, R1&& r1, R2&& r2, OutR&& result_r,
+              Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});          // freestanding-deleted
   }
   template<class BidirectionalIterator>
+ constexpr void inplace_merge(BidirectionalIterator first,   // hosted
                                  BidirectionalIterator middle,
                                  BidirectionalIterator last);
   template<class BidirectionalIterator, class Compare>
+ constexpr void inplace_merge(BidirectionalIterator first,   // hosted
                                  BidirectionalIterator middle,
                                  BidirectionalIterator last, Compare comp);
   template<class ExecutionPolicy, class BidirectionalIterator>
+    void inplace_merge(ExecutionPolicy&& exec,                  // hosted, see [algorithms.parallel.overloads]
                        BidirectionalIterator first,
                        BidirectionalIterator middle,
                        BidirectionalIterator last);
   template<class ExecutionPolicy, class BidirectionalIterator, class Compare>
+    void inplace_merge(ExecutionPolicy&& exec,                  // hosted, see [algorithms.parallel.overloads]
                        BidirectionalIterator first,
                        BidirectionalIterator middle,
                        BidirectionalIterator last, Compare comp);
   namespace ranges {
     template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
              class Proj = identity>
       requires sortable<I, Comp, Proj>
+ constexpr I
+        inplace_merge(I first, I middle, S last, Comp comp = {}, Proj proj = {});       // hosted
     template<bidirectional_range R, class Comp = ranges::less, class Proj = identity>
       requires sortable<iterator_t<R>, Comp, Proj>
+      constexpr borrowed_iterator_t<R>
+        inplace_merge(R&& r, iterator_t<R> middle, Comp comp = {}, Proj proj = {});     // hosted
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Comp = ranges::less, class Proj = identity>
+      requires sortable<I, Comp, Proj>
+      I inplace_merge(Ep&& exec, I first, I middle, S last, Comp comp = {},
+                      Proj proj = {});                          // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Comp = ranges::less,
+             class Proj = identity>
+      requires sortable<iterator_t<R>, Comp, Proj>
       borrowed_iterator_t<R>
+        inplace_merge(Ep&& exec, R&& r, iterator_t<R> middle, Comp comp = {},
+                      Proj proj = {});                          // freestanding-deleted
   }
   // [alg.set.operations], set operations
   template<class InputIterator1, class InputIterator2>
     constexpr bool includes(InputIterator1 first1, InputIterator1 last1,
   template<class InputIterator1, class InputIterator2, class Compare>
     constexpr bool includes(InputIterator1 first1, InputIterator1 last1,
                             InputIterator2 first2, InputIterator2 last2,
                             Compare comp);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
+    bool includes(ExecutionPolicy&& exec,                       // freestanding-deleted, see [algorithms.parallel.overloads]
                   ForwardIterator1 first1, ForwardIterator1 last1,
                   ForwardIterator2 first2, ForwardIterator2 last2);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class Compare>
+    bool includes(ExecutionPolicy&& exec,                       // freestanding-deleted, see [algorithms.parallel.overloads]
                   ForwardIterator1 first1, ForwardIterator1 last1,
                   ForwardIterator2 first2, ForwardIterator2 last2,
                   Compare comp);
   namespace ranges {
              class Proj2 = identity,
              indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
                                         projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
       constexpr bool includes(R1&& r1, R2&& r2, Comp comp = {},
                               Proj1 proj1 = {}, Proj2 proj2 = {});
+    template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+             random_access_iterator I2, sized_sentinel_for<I2> S2,
+             class Proj1 = identity, class Proj2 = identity,
+             indirect_strict_weak_order<projected<I1, Proj1>, projected<I2, Proj2>> Comp =
+               ranges::less>
+      bool includes(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2,
+                    Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});    // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+             class Proj1 = identity, class Proj2 = identity,
+             indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
+                                        projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
+      bool includes(Ep&& exec, R1&& r1, R2&& r2,
+                    Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});    // freestanding-deleted
   }
   template<class InputIterator1, class InputIterator2, class OutputIterator>
     constexpr OutputIterator
       set_union(InputIterator1 first1, InputIterator1 last1,
                 InputIterator2 first2, InputIterator2 last2,
                 OutputIterator result, Compare comp);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator>
     ForwardIterator
+      set_union(ExecutionPolicy&& exec,                         // freestanding-deleted, see [algorithms.parallel.overloads]
                 ForwardIterator1 first1, ForwardIterator1 last1,
                 ForwardIterator2 first2, ForwardIterator2 last2,
                 ForwardIterator result);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator, class Compare>
     ForwardIterator
+      set_union(ExecutionPolicy&& exec,                         // freestanding-deleted, see [algorithms.parallel.overloads]
                 ForwardIterator1 first1, ForwardIterator1 last1,
                 ForwardIterator2 first2, ForwardIterator2 last2,
                 ForwardIterator result, Compare comp);
   namespace ranges {
              class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
       requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
       constexpr set_union_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
         set_union(R1&& r1, R2&& r2, O result, Comp comp = {},
                   Proj1 proj1 = {}, Proj2 proj2 = {});
+    template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+             random_access_iterator I2, sized_sentinel_for<I2> S2,
+             random_access_iterator O, sized_sentinel_for<O> OutS, class Comp = ranges::less,
+             class Proj1 = identity, class Proj2 = identity>
+      requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
+      set_union_result<I1, I2, O>
+        set_union(Ep&& exec, I1 first1, S1 last1,
+                  I2 first2, S2 last2, O result, OutS result_last,
+                  Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});      // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+             sized-random-access-range OutR, class Comp = ranges::less,
+             class Proj1 = identity, class Proj2 = identity>
+      requires mergeable<iterator_t<R1>, iterator_t<R2>, iterator_t<OutR>, Comp, Proj1, Proj2>
+      set_union_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>,
+                       borrowed_iterator_t<OutR>>
+        set_union(Ep&& exec, R1&& r1, R2&& r2, OutR&& result_r, Comp comp = {},
+                  Proj1 proj1 = {}, Proj2 proj2 = {});                      // freestanding-deleted
   }
   template<class InputIterator1, class InputIterator2, class OutputIterator>
     constexpr OutputIterator
       set_intersection(InputIterator1 first1, InputIterator1 last1,
                        InputIterator2 first2, InputIterator2 last2,
                        OutputIterator result, Compare comp);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator>
     ForwardIterator
+      set_intersection(ExecutionPolicy&& exec,                  // freestanding-deleted, see [algorithms.parallel.overloads]
                        ForwardIterator1 first1, ForwardIterator1 last1,
                        ForwardIterator2 first2, ForwardIterator2 last2,
                        ForwardIterator result);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator, class Compare>
     ForwardIterator
+      set_intersection(ExecutionPolicy&& exec,                  // freestanding-deleted, see [algorithms.parallel.overloads]
                        ForwardIterator1 first1, ForwardIterator1 last1,
                        ForwardIterator2 first2, ForwardIterator2 last2,
                        ForwardIterator result, Compare comp);
   namespace ranges {
              class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
       requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
       constexpr set_intersection_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
         set_intersection(R1&& r1, R2&& r2, O result,
                          Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
+    template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+             random_access_iterator I2, sized_sentinel_for<I2> S2,
+             random_access_iterator O, sized_sentinel_for<O> OutS, class Comp = ranges::less,
+             class Proj1 = identity, class Proj2 = identity>
+      requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
+      set_intersection_result<I1, I2, O>
+        set_intersection(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2,
+                         O result, OutS result_last, Comp comp = {}, Proj1 proj1 = {},
+                         Proj2 proj2 = {});                     // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+             sized-random-access-range OutR, class Comp = ranges::less,
+             class Proj1 = identity, class Proj2 = identity>
+      requires mergeable<iterator_t<R1>, iterator_t<R2>, iterator_t<OutR>, Comp, Proj1, Proj2>
+      set_intersection_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>,
+                              borrowed_iterator_t<OutR>>
+        set_intersection(Ep&& exec, R1&& r1, R2&& r2, OutR&& result_r, Comp comp = {},
+                         Proj1 proj1 = {}, Proj2 proj2 = {});   // freestanding-deleted
   }
   template<class InputIterator1, class InputIterator2, class OutputIterator>
     constexpr OutputIterator
       set_difference(InputIterator1 first1, InputIterator1 last1,
                      InputIterator2 first2, InputIterator2 last2,
                      OutputIterator result, Compare comp);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator>
     ForwardIterator
+      set_difference(ExecutionPolicy&& exec,                    // freestanding-deleted, see [algorithms.parallel.overloads]
                      ForwardIterator1 first1, ForwardIterator1 last1,
                      ForwardIterator2 first2, ForwardIterator2 last2,
                      ForwardIterator result);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator, class Compare>
     ForwardIterator
+      set_difference(ExecutionPolicy&& exec,                    // freestanding-deleted, see [algorithms.parallel.overloads]
                      ForwardIterator1 first1, ForwardIterator1 last1,
                      ForwardIterator2 first2, ForwardIterator2 last2,
                      ForwardIterator result, Compare comp);
   namespace ranges {
              class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
       requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
       constexpr set_difference_result<borrowed_iterator_t<R1>, O>
         set_difference(R1&& r1, R2&& r2, O result,
                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
+    template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+             random_access_iterator I2, sized_sentinel_for<I2> S2,
+             random_access_iterator O, sized_sentinel_for<O> OutS, class Comp = ranges::less,
+             class Proj1 = identity, class Proj2 = identity>
+      requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
+      set_difference_result<I1, O>
+        set_difference(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2,
+                       O result, OutS result_last, Comp comp = {}, Proj1 proj1 = {},
+                       Proj2 proj2 = {});                       // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+             sized-random-access-range OutR, class Comp = ranges::less,
+             class Proj1 = identity, class Proj2 = identity>
+      requires mergeable<iterator_t<R1>, iterator_t<R2>, iterator_t<OutR>, Comp, Proj1, Proj2>
+      set_difference_result<borrowed_iterator_t<R1>, borrowed_iterator_t<OutR>>
+        set_difference(Ep&& exec, R1&& r1, R2&& r2, OutR&& result_r, Comp comp = {},
+                       Proj1 proj1 = {}, Proj2 proj2 = {});     // freestanding-deleted
   }
   template<class InputIterator1, class InputIterator2, class OutputIterator>
     constexpr OutputIterator
       set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
                                InputIterator2 first2, InputIterator2 last2,
                                OutputIterator result, Compare comp);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator>
     ForwardIterator
+      set_symmetric_difference(ExecutionPolicy&& exec,          // freestanding-deleted, see [algorithms.parallel.overloads]
                                ForwardIterator1 first1, ForwardIterator1 last1,
                                ForwardIterator2 first2, ForwardIterator2 last2,
                                ForwardIterator result);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class ForwardIterator, class Compare>
     ForwardIterator
+      set_symmetric_difference(ExecutionPolicy&& exec,          // freestanding-deleted, see [algorithms.parallel.overloads]
                                ForwardIterator1 first1, ForwardIterator1 last1,
                                ForwardIterator2 first2, ForwardIterator2 last2,
                                ForwardIterator result, Compare comp);
   namespace ranges {
       requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
       constexpr set_symmetric_difference_result<borrowed_iterator_t<R1>,
                                                 borrowed_iterator_t<R2>, O>
         set_symmetric_difference(R1&& r1, R2&& r2, O result, Comp comp = {},
                                  Proj1 proj1 = {}, Proj2 proj2 = {});
+    template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+             random_access_iterator I2, sized_sentinel_for<I2> S2,
+             random_access_iterator O, sized_sentinel_for<O> OutS, class Comp = ranges::less,
+             class Proj1 = identity, class Proj2 = identity>
+      requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
+      set_symmetric_difference_result<I1, I2, O>
+        set_symmetric_difference(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2,
+                                 O result, OutS result_last, Comp comp = {},
+                                 Proj1 proj1 = {}, Proj2 proj2 = {});       // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+             sized-random-access-range OutR, class Comp = ranges::less,
+             class Proj1 = identity, class Proj2 = identity>
+      requires mergeable<iterator_t<R1>, iterator_t<R2>, iterator_t<OutR>, Comp, Proj1, Proj2>
+      set_symmetric_difference_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>,
+                                      borrowed_iterator_t<OutR>>
+        set_symmetric_difference(Ep&& exec, R1&& r1, R2&& r2, OutR&& result_r, Comp comp = {},
+                                 Proj1 proj1 = {}, Proj2 proj2 = {});       // freestanding-deleted
   }
   // [alg.heap.operations], heap operations
   template<class RandomAccessIterator>
     constexpr void push_heap(RandomAccessIterator first, RandomAccessIterator last);
     constexpr bool is_heap(RandomAccessIterator first, RandomAccessIterator last);
   template<class RandomAccessIterator, class Compare>
     constexpr bool is_heap(RandomAccessIterator first, RandomAccessIterator last,
                            Compare comp);
   template<class ExecutionPolicy, class RandomAccessIterator>
+    bool is_heap(ExecutionPolicy&& exec,                        // freestanding-deleted, see [algorithms.parallel.overloads]
                  RandomAccessIterator first, RandomAccessIterator last);
   template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
+    bool is_heap(ExecutionPolicy&& exec,                        // freestanding-deleted, see [algorithms.parallel.overloads]
                  RandomAccessIterator first, RandomAccessIterator last,
                  Compare comp);
   namespace ranges {
     template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
              indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
       constexpr bool is_heap(I first, S last, Comp comp = {}, Proj proj = {});
     template<random_access_range R, class Proj = identity,
              indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       constexpr bool is_heap(R&& r, Comp comp = {}, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity,
+             indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+      bool is_heap(Ep&& exec, I first, S last, Comp comp = {},
+                   Proj proj = {});                                         // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+      bool is_heap(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});       // freestanding-deleted
   }
   template<class RandomAccessIterator>
     constexpr RandomAccessIterator
       is_heap_until(RandomAccessIterator first, RandomAccessIterator last);
     constexpr RandomAccessIterator
       is_heap_until(RandomAccessIterator first, RandomAccessIterator last,
                     Compare comp);
   template<class ExecutionPolicy, class RandomAccessIterator>
     RandomAccessIterator
+      is_heap_until(ExecutionPolicy&& exec,                     // freestanding-deleted, see [algorithms.parallel.overloads]
                     RandomAccessIterator first, RandomAccessIterator last);
   template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
     RandomAccessIterator
+      is_heap_until(ExecutionPolicy&& exec,                     // freestanding-deleted, see [algorithms.parallel.overloads]
                     RandomAccessIterator first, RandomAccessIterator last,
                     Compare comp);
   namespace ranges {
     template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
       constexpr I is_heap_until(I first, S last, Comp comp = {}, Proj proj = {});
     template<random_access_range R, class Proj = identity,
              indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       constexpr borrowed_iterator_t<R>
         is_heap_until(R&& r, Comp comp = {}, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity,
+             indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+      I is_heap_until(Ep&& exec, I first, S last, Comp comp = {},
+                      Proj proj = {});                                      // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+      borrowed_iterator_t<R>
+        is_heap_until(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});    // freestanding-deleted
   }
   // [alg.min.max], minimum and maximum
   template<class T> constexpr const T& min(const T& a, const T& b);
   template<class T, class Compare>
     template<input_range R, class Proj = identity,
              indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
       constexpr range_value_t<R>
         min(R&& r, Comp comp = {}, Proj proj = {});
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+      requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
+      range_value_t<R>
+        min(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});              // freestanding-deleted
   }
   template<class T> constexpr const T& max(const T& a, const T& b);
   template<class T, class Compare>
     constexpr const T& max(const T& a, const T& b, Compare comp);
     template<input_range R, class Proj = identity,
              indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
       constexpr range_value_t<R>
         max(R&& r, Comp comp = {}, Proj proj = {});
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+      requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
+      range_value_t<R>
+        max(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});              // freestanding-deleted
   }
   template<class T> constexpr pair<const T&, const T&> minmax(const T& a, const T& b);
   template<class T, class Compare>
     constexpr pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp);
     template<input_range R, class Proj = identity,
              indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
       constexpr minmax_result<range_value_t<R>>
         minmax(R&& r, Comp comp = {}, Proj proj = {});
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+      requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
+      minmax_result<range_value_t<R>>
+        minmax(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});           // freestanding-deleted
   }
   template<class ForwardIterator>
     constexpr ForwardIterator min_element(ForwardIterator first, ForwardIterator last);
   template<class ForwardIterator, class Compare>
     constexpr ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
                                           Compare comp);
   template<class ExecutionPolicy, class ForwardIterator>
+    ForwardIterator min_element(ExecutionPolicy&& exec,         // freestanding-deleted, see [algorithms.parallel.overloads]
                                 ForwardIterator first, ForwardIterator last);
   template<class ExecutionPolicy, class ForwardIterator, class Compare>
+    ForwardIterator min_element(ExecutionPolicy&& exec,         // freestanding-deleted, see [algorithms.parallel.overloads]
                                 ForwardIterator first, ForwardIterator last,
                                 Compare comp);
   namespace ranges {
     template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
       constexpr I min_element(I first, S last, Comp comp = {}, Proj proj = {});
     template<forward_range R, class Proj = identity,
              indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       constexpr borrowed_iterator_t<R>
         min_element(R&& r, Comp comp = {}, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity,
+             indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+      I min_element(Ep&& exec, I first, S last, Comp comp = {},
+                    Proj proj = {});                                        // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R,
+             class Proj = identity,
+             indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+      borrowed_iterator_t<R>
+        min_element(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});      // freestanding-deleted
   }
   template<class ForwardIterator>
     constexpr ForwardIterator max_element(ForwardIterator first, ForwardIterator last);
   template<class ForwardIterator, class Compare>
     constexpr ForwardIterator max_element(ForwardIterator first, ForwardIterator last,
                                           Compare comp);
   template<class ExecutionPolicy, class ForwardIterator>
+    ForwardIterator max_element(ExecutionPolicy&& exec,         // freestanding-deleted, see [algorithms.parallel.overloads]
                                 ForwardIterator first, ForwardIterator last);
   template<class ExecutionPolicy, class ForwardIterator, class Compare>
+    ForwardIterator max_element(ExecutionPolicy&& exec,         // freestanding-deleted, see [algorithms.parallel.overloads]
                                 ForwardIterator first, ForwardIterator last,
                                 Compare comp);
   namespace ranges {
     template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
       constexpr I max_element(I first, S last, Comp comp = {}, Proj proj = {});
     template<forward_range R, class Proj = identity,
              indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       constexpr borrowed_iterator_t<R>
         max_element(R&& r, Comp comp = {}, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity,
+             indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+      I max_element(Ep&& exec, I first, S last, Comp comp = {},
+                    Proj proj = {});                                        // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R,
+             class Proj = identity,
+             indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+      borrowed_iterator_t<R>
+        max_element(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});      // freestanding-deleted
   }
   template<class ForwardIterator>
     constexpr pair<ForwardIterator, ForwardIterator>
       minmax_element(ForwardIterator first, ForwardIterator last);
   template<class ForwardIterator, class Compare>
     constexpr pair<ForwardIterator, ForwardIterator>
       minmax_element(ForwardIterator first, ForwardIterator last, Compare comp);
   template<class ExecutionPolicy, class ForwardIterator>
     pair<ForwardIterator, ForwardIterator>
+      minmax_element(ExecutionPolicy&& exec,                    // freestanding-deleted, see [algorithms.parallel.overloads]
                      ForwardIterator first, ForwardIterator last);
   template<class ExecutionPolicy, class ForwardIterator, class Compare>
     pair<ForwardIterator, ForwardIterator>
+      minmax_element(ExecutionPolicy&& exec,                    // freestanding-deleted, see [algorithms.parallel.overloads]
                      ForwardIterator first, ForwardIterator last, Compare comp);
   namespace ranges {
     template<class I>
       using minmax_element_result = min_max_result<I>;
         minmax_element(I first, S last, Comp comp = {}, Proj proj = {});
     template<forward_range R, class Proj = identity,
              indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
       constexpr minmax_element_result<borrowed_iterator_t<R>>
         minmax_element(R&& r, Comp comp = {}, Proj proj = {});
+    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+             class Proj = identity,
+             indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+      minmax_element_result<I>
+        minmax_element(Ep&& exec, I first, S last, Comp comp = {},
+                       Proj proj = {});                                     // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+             indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+      minmax_element_result<borrowed_iterator_t<R>>
+        minmax_element(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});   // freestanding-deleted
   }
   // [alg.clamp], bounded value
   template<class T>
     constexpr const T& clamp(const T& v, const T& lo, const T& hi);
       lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
                               InputIterator2 first2, InputIterator2 last2,
                               Compare comp);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
     bool
+      lexicographical_compare(ExecutionPolicy&& exec,           // freestanding-deleted, see [algorithms.parallel.overloads]
                               ForwardIterator1 first1, ForwardIterator1 last1,
                               ForwardIterator2 first2, ForwardIterator2 last2);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class Compare>
     bool
+      lexicographical_compare(ExecutionPolicy&& exec,           // freestanding-deleted, see [algorithms.parallel.overloads]
                               ForwardIterator1 first1, ForwardIterator1 last1,
                               ForwardIterator2 first2, ForwardIterator2 last2,
                               Compare comp);
   namespace ranges {
              indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
                                         projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
       constexpr bool
         lexicographical_compare(R1&& r1, R2&& r2, Comp comp = {},
                                 Proj1 proj1 = {}, Proj2 proj2 = {});
+    template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+             random_access_iterator I2, sized_sentinel_for<I2> S2,
+             class Proj1 = identity, class Proj2 = identity,
+             indirect_strict_weak_order<projected<I1, Proj1>,
+                                        projected<I2, Proj2>> Comp = ranges::less>
+      bool lexicographical_compare(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2,
+                                   Comp comp = {}, Proj1 proj1 = {},
+                                   Proj2 proj2 = {});                       // freestanding-deleted
+    template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+             class Proj1 = identity, class Proj2 = identity,
+             indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
+                                        projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
+      bool lexicographical_compare(Ep&& exec, R1&& r1, R2&& r2, Comp comp = {},
+                                   Proj1 proj1 = {}, Proj2 proj2 = {});     // freestanding-deleted
   }
   // [alg.three.way], three-way comparison algorithms
   template<class InputIterator1, class InputIterator2, class Cmp>
     constexpr auto
          indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr bool ranges::all_of(I first, S last, Pred pred, Proj proj = {});
 template<input_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr bool ranges::all_of(R&& r, Pred pred, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+  bool ranges::all_of(Ep&& exec, I first, S last, Pred pred, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  bool ranges::all_of(Ep&& exec, R&& r, Pred pred, Proj proj = {});
 ```
 Let E be:
 - `pred(*i)` for the overloads in namespace `std`;
          indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr bool ranges::any_of(I first, S last, Pred pred, Proj proj = {});
 template<input_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr bool ranges::any_of(R&& r, Pred pred, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+  bool ranges::any_of(Ep&& exec, I first, S last, Pred pred, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  bool ranges::any_of(Ep&& exec, R&& r, Pred pred, Proj proj = {});
 ```
 Let E be:
 - `pred(*i)` for the overloads in namespace `std`;
          indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr bool ranges::none_of(I first, S last, Pred pred, Proj proj = {});
 template<input_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr bool ranges::none_of(R&& r, Pred pred, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+  bool ranges::none_of(Ep&& exec, I first, S last, Pred pred, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  bool ranges::none_of(Ep&& exec, R&& r, Pred pred, Proj proj = {});
 ```
 Let E be:
 - `pred(*i)` for the overloads in namespace `std`;
 any projection.
 ### Contains <a id="alg.contains">[[alg.contains]]</a>
 ``` cpp
+template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+         class T = projected_value_t<I, Proj>>
   requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
   constexpr bool ranges::contains(I first, S last, const T& value, Proj proj = {});
+template<input_range R, class Proj = identity, class T = projected_value_t<iterator_t<R>, Proj>>
   requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
   constexpr bool ranges::contains(R&& r, const T& value, Proj proj = {});
 ```
 *Returns:* `ranges::find(std::move(first), last, value, proj) != last`.
+``` cpp
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity, class T = projected_value_t<I, Proj>>
+  requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
+  bool ranges::contains(Ep&& exec, I first, S last, const T& value, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         class T = projected_value_t<iterator_t<R>, Proj>>
+  requires
+    indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
+  bool ranges::contains(Ep&& exec, R&& r, const T& value, Proj proj = {});
+```
+*Returns:*
+`ranges::find(std::forward<Ep>(exec), first, last, value, proj) != last`.
 ``` cpp
 template<forward_iterator I1, sentinel_for<I1> S1,
          forward_iterator I2, sentinel_for<I2> S2,
          class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
   requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
   constexpr bool ranges::contains_subrange(R1&& r1, R2&& r2, Pred pred = {},
                                            Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
 *Returns:*
+``` cpp
+first2 == last2 || !ranges::search(first1, last1, first2, last2,
+                                   pred, proj1, proj2).empty()
+```
+``` cpp
+template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+         random_access_iterator I2, sized_sentinel_for<I2> S2,
+         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+  bool ranges::contains_subrange(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2,
+                                 Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+  bool ranges::contains_subrange(Ep&& exec, R1&& r1, R2&& r2, Pred pred = {},
+                                 Proj1 proj1 = {}, Proj2 proj2 = {});
+```
+*Returns:*
+``` cpp
+first2 == last2 || !ranges::search(std::forward<Ep>(exec), first1, last1,
+                                   first2, last2, pred, proj1, proj2).empty()
+```
 ### For each <a id="alg.foreach">[[alg.foreach]]</a>
 ``` cpp
 template<class InputIterator, class Function>
 *Remarks:* If `f` returns a result, the result is ignored.
 [*Note 6*: The overloads in namespace `ranges` require `Fun` to model
 `copy_constructible`. — *end note*]
+``` cpp
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity,
+         indirectly_unary_invocable<projected<I, Proj>> Fun>
+  I ranges::for_each(Ep&& exec, I first, S last, Fun f, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         indirectly_unary_invocable<projected<iterator_t<R>, Proj>> Fun>
+  borrowed_iterator_t<R>
+    ranges::for_each(Ep&& exec, R&& r, Fun f, Proj proj = {});
+```
+*Effects:* Calls `invoke(f, invoke(proj, *i))` for every iterator `i` in
+the range \[`first`, `last`).
+[*Note 7*: If the result of `invoke(proj, *i)` is a mutable reference,
+`f` can apply non-constant functions. — *end note*]
+*Returns:* `last`.
+*Complexity:* Applies `f` and `proj` exactly `last - first` times.
+*Remarks:*
+- If `f` returns a result, the result is ignored.
+- Implementations do not have the freedom granted under
+  [[algorithms.parallel.exec]] to make arbitrary copies of elements from
+  the input sequence.
+- `f` may modify objects via its arguments [[algorithms.parallel.user]].
+[*Note 8*: Does not return a copy of its `Fun` parameter, since
+parallelization often does not permit efficient state
+accumulation. — *end note*]
 ``` cpp
 template<class InputIterator, class Size, class Function>
   constexpr InputIterator for_each_n(InputIterator first, Size n, Function f);
 ```
 type [[conv.integral]], [[class.conv]].
 *Preconditions:* `n >= 0` is `true`. `Function` meets the
 *Cpp17MoveConstructible* requirements.
+[*Note 9*: `Function` need not meet the requirements of
 *Cpp17CopyConstructible*. — *end note*]
 *Effects:* Applies `f` to the result of dereferencing every iterator in
 the range \[`first`, `first + n`) in order.
+[*Note 10*: If the type of `first` meets the requirements of a mutable
 iterator, `f` can apply non-constant functions through the dereferenced
 iterator. — *end note*]
 *Returns:* `first + n`.
 *Cpp17CopyConstructible* requirements.
 *Effects:* Applies `f` to the result of dereferencing every iterator in
 the range \[`first`, `first + n`).
+[*Note 11*: If the type of `first` meets the requirements of a mutable
 iterator, `f` can apply non-constant functions through the dereferenced
 iterator. — *end note*]
 *Returns:* `first + n`.
 *Preconditions:* `n >= 0` is `true`.
 *Effects:* Calls `invoke(f, invoke(proj, *i))` for every iterator `i` in
 the range \[`first`, `first + n`) in order.
+[*Note 12*: If the result of `invoke(proj, *i)` is a mutable reference,
 `f` can apply non-constant functions. — *end note*]
 *Returns:* `{first + n, std::move(f)}`.
 *Remarks:* If `f` returns a result, the result is ignored.
+[*Note 13*: The overload in namespace `ranges` requires `Fun` to model
 `copy_constructible`. — *end note*]
+``` cpp
+template<execution-policy Ep, random_access_iterator I, class Proj = identity,
+         indirectly_unary_invocable<projected<I, Proj>> Fun>
+  I ranges::for_each_n(Ep&& exec, I first, iter_difference_t<I> n, Fun f, Proj proj = {});
+```
+*Preconditions:* `n >= 0` is `true`.
+*Effects:* Calls `invoke(f, invoke(proj, *i))` for every iterator `i` in
+the range \[`first`, `first + n`).
+[*Note 14*: If the result of `invoke(proj, *i)` is a mutable reference,
+`f` can apply non-constant functions. — *end note*]
+*Returns:* `first + n`.
+*Remarks:*
+- If `f` returns a result, the result is ignored.
+- Implementations do not have the freedom granted under
+  [[algorithms.parallel.exec]] to make arbitrary copies of elements from
+  the input sequence.
+- `f` may modify objects via its arguments [[algorithms.parallel.user]].
+[*Note 15*: Does not return a copy of its `Fun` parameter, since
+parallelization often does not permit efficient state
+accumulation. — *end note*]
 ### Find <a id="alg.find">[[alg.find]]</a>
 ``` cpp
+template<class InputIterator, class T = iterator_traits<InputIterator>::value_type>
   constexpr InputIterator find(InputIterator first, InputIterator last,
                                const T& value);
+template<class ExecutionPolicy, class ForwardIterator,
+         class T = iterator_traits<ForwardIterator>::value_type>
   ForwardIterator find(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
                        const T& value);
 template<class InputIterator, class Predicate>
   constexpr InputIterator find_if(InputIterator first, InputIterator last,
 template<class ExecutionPolicy, class ForwardIterator, class Predicate>
   ForwardIterator find_if_not(ExecutionPolicy&& exec,
                               ForwardIterator first, ForwardIterator last,
                               Predicate pred);
+template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+         class T = projected_value_t<I, Proj>>
   requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
   constexpr I ranges::find(I first, S last, const T& value, Proj proj = {});
+template<input_range R, class Proj = identity, class T = projected_value_t<iterator_t<R>, Proj>>
   requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
   constexpr borrowed_iterator_t<R>
     ranges::find(R&& r, const T& value, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity, class T = projected_value_t<I, Proj>>
+  requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
+  I ranges::find(Ep&& exec, I first, S last, const T& value, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         class T = projected_value_t<iterator_t<R>, Proj>>
+  requires indirect_binary_predicate<ranges::equal_to,
+                                     projected<iterator_t<R>, Proj>, const T*>
+  borrowed_iterator_t<R> ranges::find(Ep&& exec, R&& r, const T& value, Proj proj = {});
 template<input_iterator I, sentinel_for<I> S, class Proj = identity,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr I ranges::find_if(I first, S last, Pred pred, Proj proj = {});
 template<input_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr borrowed_iterator_t<R>
     ranges::find_if(R&& r, Pred pred, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+  I ranges::find_if(Ep&& exec, I first, S last, Pred pred, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  borrowed_iterator_t<R> ranges::find_if(Ep&& exec, R&& r, Pred pred, Proj proj = {});
 template<input_iterator I, sentinel_for<I> S, class Proj = identity,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr I ranges::find_if_not(I first, S last, Pred pred, Proj proj = {});
 template<input_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr borrowed_iterator_t<R>
     ranges::find_if_not(R&& r, Pred pred, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+  I ranges::find_if_not(Ep&& exec, I first, S last, Pred pred, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  borrowed_iterator_t<R> ranges::find_if_not(Ep&& exec, R&& r, Pred pred, Proj proj = {});
 ```
 Let E be:
 - `*i == value` for `find`;
 predicate and any projection.
 ### Find last <a id="alg.find.last">[[alg.find.last]]</a>
 ``` cpp
+template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+         class T = projected_value_t<I, Proj>>
   requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
   constexpr subrange<I> ranges::find_last(I first, S last, const T& value, Proj proj = {});
+template<forward_range R, class Proj = identity,
+         class T = projected_value_t<iterator_t<R>, Proj>>
   requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
   constexpr borrowed_subrange_t<R> ranges::find_last(R&& r, const T& value, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity, class T = projected_value_t<I, Proj>>
+  requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
+  subrange<I> ranges::find_last(Ep&& exec, I first, S last, const T& value, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         class T = projected_value_t<iterator_t<R>, Proj>>
+  requires
+    indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
+  borrowed_subrange_t<R> ranges::find_last(Ep&& exec, R&& r, const T& value, Proj proj = {});
 template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr subrange<I> ranges::find_last_if(I first, S last, Pred pred, Proj proj = {});
 template<forward_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr borrowed_subrange_t<R> ranges::find_last_if(R&& r, Pred pred, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+  subrange<I> ranges::find_last_if(Ep&& exec, I first, S last, Pred pred, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R,
+         class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  borrowed_subrange_t<R> ranges::find_last_if(Ep&& exec, R&& r, Pred pred, Proj proj = {});
 template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr subrange<I> ranges::find_last_if_not(I first, S last, Pred pred, Proj proj = {});
 template<forward_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr borrowed_subrange_t<R> ranges::find_last_if_not(R&& r, Pred pred, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity,
+         indirect_unary_predicate<projected<I, Proj>> Pred>
+  subrange<I> ranges::find_last_if_not(Ep&& exec, I first, S last, Pred pred, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  borrowed_subrange_t<R> ranges::find_last_if_not(Ep&& exec, R&& r, Pred pred, Proj proj = {});
 ```
 Let E be:
 - `bool(invoke(proj, *i) == value)` for `ranges::find_last`;
          class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
   requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
   constexpr borrowed_subrange_t<R1>
     ranges::find_end(R1&& r1, R2&& r2, Pred pred = {},
                      Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+         random_access_iterator I2, sized_sentinel_for<I2> S2,
+         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+  subrange<I1>
+    ranges::find_end(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
+                     Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+  borrowed_subrange_t<R1>
+    ranges::find_end(Ep&& exec, R1&& r1, R2&& r2, Pred pred = {},
+                     Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
 Let:
 - `pred` be `equal_to{}` for the overloads with no parameter `pred`;
 *Complexity:* At most
 `(last2 - first2) * (last1 - first1 - (last2 - first2) + 1)`
 applications of the corresponding predicate and any projections.
+### Find first of <a id="alg.find.first.of">[[alg.find.first.of]]</a>
 ``` cpp
 template<class InputIterator, class ForwardIterator>
   constexpr InputIterator
     find_first_of(InputIterator first1, InputIterator last1,
   requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
   constexpr borrowed_iterator_t<R1>
     ranges::find_first_of(R1&& r1, R2&& r2,
                           Pred pred = {},
                           Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+         random_access_iterator I2, sized_sentinel_for<I2> S2,
+         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+  I1 ranges::find_first_of(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
+                           Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+  borrowed_iterator_t<R1>
+    ranges::find_first_of(Ep&& exec, R1&& r1, R2&& r2, Pred pred = {},
+                          Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
 Let E be:
 - `*i == *j` for the overloads with no parameter `pred`;
 *Returns:* The first iterator `i` in the range \[`first1`, `last1`) such
 that for some iterator `j` in the range \[`first2`, `last2`) E holds.
 Returns `last1` if \[`first2`, `last2`) is empty or if no such iterator
 is found.
+*Complexity:* At most `(last1 - first1) * (last2 - first2)` applications
+of the corresponding predicate and any projections.
 ### Adjacent find <a id="alg.adjacent.find">[[alg.adjacent.find]]</a>
 ``` cpp
 template<class ForwardIterator>
   constexpr I ranges::adjacent_find(I first, S last, Pred pred = {}, Proj proj = {});
 template<forward_range R, class Proj = identity,
          indirect_binary_predicate<projected<iterator_t<R>, Proj>,
                                    projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
   constexpr borrowed_iterator_t<R> ranges::adjacent_find(R&& r, Pred pred = {}, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity,
+         indirect_binary_predicate<projected<I, Proj>,
+                                   projected<I, Proj>> Pred = ranges::equal_to>
+  I ranges::adjacent_find(Ep&& exec, I first, S last, Pred pred = {}, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         indirect_binary_predicate<projected<iterator_t<R>, Proj>,
+                                   projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
+  borrowed_iterator_t<R>
+    ranges::adjacent_find(Ep&& exec, R&& r, Pred pred = {}, Proj proj = {});
 ```
 Let E be:
 - `*i == *(i + 1)` for the overloads with no parameter `pred`;
 *Returns:* The first iterator `i` such that both `i` and `i + 1` are in
 the range \[`first`, `last`) for which E holds. Returns `last` if no
 such iterator is found.
+*Complexity:* For the non-parallel algorithm overloads, exactly
 $$\min(\texttt{(i - first) + 1}, \ \texttt{(last - first) - 1})$$
 applications of the corresponding predicate, where `i` is
+`adjacent_find`’s return value. For the parallel algorithm overloads,
+𝑂(`last - first`) applications of the corresponding predicate. No more
+than twice as many applications of any projection.
 ### Count <a id="alg.count">[[alg.count]]</a>
 ``` cpp
+template<class InputIterator, class T = iterator_traits<InputIterator>::value_type>
   constexpr typename iterator_traits<InputIterator>::difference_type
     count(InputIterator first, InputIterator last, const T& value);
+template<class ExecutionPolicy, class ForwardIterator,
+         class T = iterator_traits<ForwardIterator>::value_type>
   typename iterator_traits<ForwardIterator>::difference_type
     count(ExecutionPolicy&& exec,
           ForwardIterator first, ForwardIterator last, const T& value);
 template<class InputIterator, class Predicate>
 template<class ExecutionPolicy, class ForwardIterator, class Predicate>
   typename iterator_traits<ForwardIterator>::difference_type
     count_if(ExecutionPolicy&& exec,
              ForwardIterator first, ForwardIterator last, Predicate pred);
+template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+         class T = projected_value_t<I, Proj>>
   requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
   constexpr iter_difference_t<I>
     ranges::count(I first, S last, const T& value, Proj proj = {});
+template<input_range R, class Proj = identity, class T = projected_value_t<iterator_t<R>, Proj>>
   requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
   constexpr range_difference_t<R>
     ranges::count(R&& r, const T& value, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity, class T = projected_value_t<I, Proj>>
+  requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
+  iter_difference_t<I>
+    ranges::count(Ep&& exec, I first, S last, const T& value, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         class T = projected_value_t<iterator_t<R>, Proj>>
+  requires indirect_binary_predicate<ranges::equal_to,
+                                      projected<iterator_t<R>, Proj>, const T*>
+  range_difference_t<R> ranges::count(Ep&& exec, R&& r, const T& value, Proj proj = {});
 template<input_iterator I, sentinel_for<I> S, class Proj = identity,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr iter_difference_t<I>
     ranges::count_if(I first, S last, Pred pred, Proj proj = {});
 template<input_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr range_difference_t<R>
     ranges::count_if(R&& r, Pred pred, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+  iter_difference_t<I>
+    ranges::count_if(Ep&& exec, I first, S last, Pred pred, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  range_difference_t<R>
+    ranges::count_if(Ep&& exec, R&& r, Pred pred, Proj proj = {});
 ```
 Let E be:
 - `*i == value` for the overloads with no parameter `pred` or `proj`;
 `last`) for which E holds.
 *Complexity:* Exactly `last - first` applications of the corresponding
 predicate and any projection.
+### Mismatch <a id="alg.mismatch">[[alg.mismatch]]</a>
 ``` cpp
 template<class InputIterator1, class InputIterator2>
   constexpr pair<InputIterator1, InputIterator2>
     mismatch(InputIterator1 first1, InputIterator1 last1,
          class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
   requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
   constexpr ranges::mismatch_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
     ranges::mismatch(R1&& r1, R2&& r2, Pred pred = {},
                      Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+         random_access_iterator I2, sized_sentinel_for<I2> S2,
+         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+  ranges::mismatch_result<I1, I2>
+    ranges::mismatch(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
+                     Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+  ranges::mismatch_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
+    ranges::mismatch(Ep&& exec, R1&& r1, R2&& r2, Pred pred = {},
+                     Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
+Let `last2` be `first2 + (last1 - first1)` for the overloads in
+namespace `std` with no parameter `last2`.
 Let E be:
 - `!(*(first1 + n) == *(first2 + n))` for the overloads with no
   parameter `pred`;
 template<input_range R1, input_range R2, class Pred = ranges::equal_to,
          class Proj1 = identity, class Proj2 = identity>
   requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
   constexpr bool ranges::equal(R1&& r1, R2&& r2, Pred pred = {},
                                Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+         random_access_iterator I2, sized_sentinel_for<I2> S2,
+         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+  bool ranges::equal(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2,
+                     Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+  bool ranges::equal(Ep&& exec, R1&& r1, R2&& r2,
+                     Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
 Let:
+- `last2` be `first2 + (last1 - first1)` for the overloads in namespace
+  `std` with no parameter `last2`;
 - `pred` be `equal_to{}` for the overloads with no parameter `pred`;
 - E be:
   - `pred(*i, *(first2 + (i - first1)))` for the overloads with no
     parameter `proj1`;
   - `invoke(pred, invoke(proj1, *i), invoke(proj2, *(first2 + (i - first1))))`
   *Cpp17RandomAccessIterator* requirements [[random.access.iterators]]
   and `last1 - first1 != last2 - first2` for the overloads in namespace
   `std`;
 - the types of `first1`, `last1`, `first2`, and `last2` pairwise model
   `sized_sentinel_for` [[iterator.concept.sizedsentinel]] and
+  `last1 - first1 != last2 - first2` for the first and third overloads
+ in namespace `ranges`, or
 - `R1` and `R2` each model `sized_range` and
+  `ranges::distance(r1) != ranges::distance(r2)` for the second and
+ fourth overloads in namespace `ranges`,
 then no applications of the corresponding predicate and each projection;
+otherwise, at most
+$$\min(\texttt{last1 - first1}, \ \texttt{last2 - first2})$$
+applications of the corresponding predicate and any projections.
 ### Is permutation <a id="alg.is.permutation">[[alg.is.permutation]]</a>
 ``` cpp
 template<class ForwardIterator1, class ForwardIterator2>
 the range \[`first2`, `last2`), bounded by \[`pfirst`, `plast`), such
 that `ranges::equal(first1, last1, pfirst, plast, pred, proj1, proj2)`
 returns `true`; otherwise, returns `false`.
 *Complexity:* No applications of the corresponding predicate and
+projections if
 - for the first overload,
   - `S1` and `I1` model `sized_sentinel_for<S1, I1>`,
   - `S2` and `I2` model `sized_sentinel_for<S2, I2>`, and
   - `last1 - first1 != last2 - first2`;
            ForwardIterator2 first2, ForwardIterator2 last2,
            BinaryPredicate pred);
 ```
 *Returns:* The first iterator `i` in the range \[`first1`,
+`last1 - (last2 - first2)`\] such that for every non-negative integer
+`n` less than `last2 - first2` the following corresponding conditions
+hold:
 `*(i + n) == *(first2 + n), pred(*(i + n), *(first2 + n)) != false`.
 Returns `first1` if \[`first2`, `last2`) is empty, otherwise returns
 `last1` if no such iterator is found.
 *Complexity:* At most `(last1 - first1) * (last2 - first2)` applications
          class Proj1 = identity, class Proj2 = identity>
   requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
   constexpr borrowed_subrange_t<R1>
     ranges::search(R1&& r1, R2&& r2, Pred pred = {},
                    Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+         random_access_iterator I2, sized_sentinel_for<I2> S2,
+         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+  subrange<I1>
+    ranges::search(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2,
+                   Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+  borrowed_subrange_t<R1>
+    ranges::search(Ep&& exec, R1&& r1, R2&& r2,
+                   Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
 *Returns:*
 - `{i, i + (last2 - first2)}`, where `i` is the first iterator in the
+  range \[`first1`, `last1 - (last2 - first2)`\] such that for every
   non-negative integer `n` less than `last2 - first2` the condition
   ``` cpp
   bool(invoke(pred, invoke(proj1, *(i + n)), invoke(proj2, *(first2 + n))))
   ```
 *Complexity:* At most `(last1 - first1) * (last2 - first2)` applications
 of the corresponding predicate and projections.
 ``` cpp
+template<class ForwardIterator, class Size, class T = iterator_traits<ForwardIterator>::value_type>
   constexpr ForwardIterator
     search_n(ForwardIterator first, ForwardIterator last,
              Size count, const T& value);
+template<class ExecutionPolicy, class ForwardIterator, class Size,
+         class T = iterator_traits<ForwardIterator>::value_type>
   ForwardIterator
     search_n(ExecutionPolicy&& exec,
              ForwardIterator first, ForwardIterator last,
              Size count, const T& value);
+template<class ForwardIterator, class Size, class T = iterator_traits<ForwardIterator>::value_type,
          class BinaryPredicate>
   constexpr ForwardIterator
     search_n(ForwardIterator first, ForwardIterator last,
              Size count, const T& value,
              BinaryPredicate pred);
+template<class ExecutionPolicy, class ForwardIterator, class Size,
+         class T = iterator_traits<ForwardIterator>::value_type,
          class BinaryPredicate>
   ForwardIterator
     search_n(ExecutionPolicy&& exec,
              ForwardIterator first, ForwardIterator last,
              Size count, const T& value,
 ```
 *Mandates:* The type `Size` is convertible to an integral
 type [[conv.integral]], [[class.conv]].
+Let E be `pred(*(i + n), value) != false` for the overloads with a
+parameter `pred`, and `*(i + n) == value` otherwise.
+*Returns:* The first iterator `i` in the range \[`first`,
+`last - count`\] such that for every non-negative integer `n` less than
+`count` the condition E is `true`. Returns `last` if no such iterator is
+found.
 *Complexity:* At most `last - first` applications of the corresponding
 predicate.
 ``` cpp
+template<forward_iterator I, sentinel_for<I> S,
+         class Pred = ranges::equal_to, class Proj = identity,
+         class T = projected_value_t<I, Proj>>
   requires indirectly_comparable<I, const T*, Pred, Proj>
   constexpr subrange<I>
     ranges::search_n(I first, S last, iter_difference_t<I> count,
                      const T& value, Pred pred = {}, Proj proj = {});
+template<forward_range R, class Pred = ranges::equal_to,
+         class Proj = identity, class T = projected_value_t<iterator_t<R>, Proj>>
   requires indirectly_comparable<iterator_t<R>, const T*, Pred, Proj>
   constexpr borrowed_subrange_t<R>
     ranges::search_n(R&& r, range_difference_t<R> count,
                      const T& value, Pred pred = {}, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Pred = ranges::equal_to, class Proj = identity,
+         class T = projected_value_t<I, Proj>>
+  requires indirectly_comparable<I, const T*, Pred, Proj>
+  subrange<I>
+    ranges::search_n(Ep&& exec, I first, S last, iter_difference_t<I> count,
+                     const T& value, Pred pred = {}, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Pred = ranges::equal_to,
+         class Proj = identity, class T = projected_value_t<iterator_t<R>, Proj>>
+  requires indirectly_comparable<iterator_t<R>, const T*, Pred, Proj>
+  borrowed_subrange_t<R>
+    ranges::search_n(Ep&& exec, R&& r, range_difference_t<R> count,
+                     const T& value, Pred pred = {}, Proj proj = {});
 ```
 *Returns:* `{i, i + count}` where `i` is the first iterator in the range
+\[`first`, `last - count`\] such that for every non-negative integer `n`
 less than `count`, the following condition holds:
 `invoke(pred, invoke(proj, *(i + n)), value)`. Returns `{last, last}` if
 no such iterator is found.
 *Complexity:* At most `last - first` applications of the corresponding
 ``` cpp
 ranges::mismatch(std::move(first1), last1, std::move(first2), last2,
                  pred, proj1, proj2).in2 == last2
 ```
+``` cpp
+template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+         random_access_iterator I2, sized_sentinel_for<I2> S2,
+         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+  bool ranges::starts_with(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2,
+                           Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, sized-random-access-range R1,
+         sized-random-access-range R2, class Pred = ranges::equal_to,
+         class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+  bool ranges::starts_with(Ep&& exec, R1&& r1, R2&& r2,
+                           Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
+```
+*Returns:*
+``` cpp
+ranges::mismatch(std::forward<Ep>(exec), std::move(first1), last1, std::move(first2),
+                 last2, pred, proj1, proj2).in2 == last2
+```
 ### Ends with <a id="alg.ends.with">[[alg.ends.with]]</a>
 ``` cpp
 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
          class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
                                    Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
 Let `N1` be `last1 - first1` and `N2` be `last2 - first2`.
+*Returns:* `false` if `N1` < `N2`, otherwise:
 ``` cpp
 ranges::equal(std::move(first1) + (N1 - N2), last1, std::move(first2), last2,
               pred, proj1, proj2)
 ```
+``` cpp
+template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+         random_access_iterator I2, sized_sentinel_for<I2> S2,
+         class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+  bool ranges::ends_with(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2,
+                         Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
+```
+Let `N1` be `last1 - first1` and `N2` be `last2 - first2`.
+*Returns:* `false` if `N1` < `N2`, otherwise:
+``` cpp
+ranges::equal(std::forward<Ep>(exec), std::move(first1) + (N1 - N2), last1,
+              std::move(first2), last2, pred, proj1, proj2)
+```
 ``` cpp
 template<input_range R1, input_range R2, class Pred = ranges::equal_to, class Proj1 = identity,
          class Proj2 = identity>
   requires (forward_range<R1> || sized_range<R1>) &&
            (forward_range<R2> || sized_range<R2>) &&
                                    Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
 Let `N1` be `ranges::distance(r1)` and `N2` be `ranges::distance(r2)`.
+*Returns:* `false` if `N1` < `N2`, otherwise:
 ``` cpp
+ranges::equal(views::drop(ranges::ref_view(r1), N1 - static_cast<decltype(N1)>(N2)),
+              r2, pred, proj1, proj2)
+```
+``` cpp
+template<execution-policy Ep, sized-random-access-range R1,
+         sized-random-access-range R2, class Pred = ranges::equal_to,
+         class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+  bool ranges::ends_with(Ep&& exec, R1&& r1, R2&& r2,
+                         Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
+```
+Let `N1` be `ranges::distance(r1)` and `N2` be `ranges::distance(r2)`.
+*Returns:* `false` if `N1` < `N2`, otherwise:
+``` cpp
+ranges::equal(std::forward<Ep>(exec),
+              views::drop(ranges::ref_view(r1), N1 - static_cast<decltype(N1)>(N2)),
+              r2, pred, proj1, proj2)
 ```
 ### Fold <a id="alg.fold">[[alg.fold]]</a>
 ``` cpp
+template<input_iterator I, sentinel_for<I> S, class T = iter_value_t<I>,
+         indirectly-binary-left-foldable<T, I> F>
   constexpr auto ranges::fold_left(I first, S last, T init, F f);
+template<input_range R, class T = range_value_t<R>,
+         indirectly-binary-left-foldable<T, iterator_t<R>> F>
   constexpr auto ranges::fold_left(R&& r, T init, F f);
 ```
 *Returns:*
 ``` cpp
 ranges::fold_left_first_with_iter(std::move(first), last, f).value
 ```
 ``` cpp
+template<bidirectional_iterator I, sentinel_for<I> S, class T = iter_value_t<I>,
          indirectly-binary-right-foldable<T, I> F>
   constexpr auto ranges::fold_right(I first, S last, T init, F f);
+template<bidirectional_range R, class T = range_value_t<R>,
          indirectly-binary-right-foldable<T, iterator_t<R>> F>
   constexpr auto ranges::fold_right(R&& r, T init, F f);
 ```
 *Effects:* Equivalent to:
 return optional<U>(in_place,
   ranges::fold_right(std::move(first), tail, iter_value_t<I>(*tail), std::move(f)));
 ```
 ``` cpp
+template<input_iterator I, sentinel_for<I> S, class T = iter_value_t<I>,
          indirectly-binary-left-foldable<T, I> F>
   constexpr see below ranges::fold_left_with_iter(I first, S last, T init, F f);
+template<input_range R, class T = range_value_t<R>,
+         indirectly-binary-left-foldable<T, iterator_t<R>> F>
   constexpr see below ranges::fold_left_with_iter(R&& r, T init, F f);
 ```
 Let `U` be `decay_t<invoke_result_t<F&, T, iter_reference_t<I>>>`.
 *Complexity:* Exactly N assignments.
 ``` cpp
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
+  ForwardIterator2 copy(ExecutionPolicy&& exec,
                         ForwardIterator1 first, ForwardIterator1 last,
                         ForwardIterator2 result);
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         random_access_iterator O, sized_sentinel_for<O> OutS>
+  requires indirectly_copyable<I, O>
+  ranges::copy_result<I, O>
+    ranges::copy(Ep&& exec, I first, S last, O result, OutS result_last);
+template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR>
+  requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>>
+  ranges::copy_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+    ranges::copy(Ep&& exec, R&& r, OutR&& result_r);
 ```
+Let `result_last` be `result + (last - first)` for the overload in
+namespace `std`.
+Let N be min(`last - first`,  `result_last - result`).
 *Preconditions:* The ranges \[`first`, `last`) and \[`result`,
+`result + `N) do not overlap.
+*Effects:* Copies elements in the range \[`first`, `first + `N) into the
+range \[`result`, `result + `N). For each non-negative integer n < N,
+performs `*(result + `n`) = *(first + `n`)`.
+*Returns:*
+- `result + `N for the overload in namespace `std`.
+- `{first + `N`, result + `N`}` for the overloads in namespace `ranges`.
+*Complexity:* Exactly N assignments.
 ``` cpp
 template<class InputIterator, class Size, class OutputIterator>
   constexpr OutputIterator copy_n(InputIterator first, Size n,
                                   OutputIterator result);
 template<input_iterator I, weakly_incrementable O>
   requires indirectly_copyable<I, O>
   constexpr ranges::copy_n_result<I, O>
     ranges::copy_n(I first, iter_difference_t<I> n, O result);
+template<execution-policy Ep, random_access_iterator I, random_access_iterator O,
+         sized_sentinel_for<O> OutS>
+  requires indirectly_copyable<I, O>
+  ranges::copy_n_result<I, O>
+    ranges::copy_n(Ep&& exec, I first, iter_difference_t<I> n, O result, OutS result_last);
 ```
+Let M be max(0, `n`).
+Let `result_last` be `result + `M for the overloads with no parameter
+`result_last`.
+Let N be min(`result_last - result`, M).
 *Mandates:* The type `Size` is convertible to an integral
 type [[conv.integral]], [[class.conv]].
 *Effects:* For each non-negative integer i < N, performs
 template<input_range R, weakly_incrementable O, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   requires indirectly_copyable<iterator_t<R>, O>
   constexpr ranges::copy_if_result<borrowed_iterator_t<R>, O>
     ranges::copy_if(R&& r, O result, Pred pred, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+          random_access_iterator O, sized_sentinel_for<O> OutS,
+          class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+  requires indirectly_copyable<I, O>
+  ranges::copy_if_result<I, O>
+    ranges::copy_if(Ep&& exec, I first, S last, O result, OutS result_last,
+                    Pred pred, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR,
+          class Proj = identity,
+          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>>
+  ranges::copy_if_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+    ranges::copy_if(Ep&& exec, R&& r, OutR&& result_r, Pred pred, Proj proj = {});
 ```
+Let E(`i`) be:
 - `bool(pred(*i))` for the overloads in namespace `std`;
 - `bool(invoke(pred, invoke(proj, *i)))` for the overloads in namespace
+  `ranges`.
+Let:
+- M be the number of iterators `i` in the range \[`first`, `last`) for
+  which the condition E(`i`) holds;
+- `result_last` be `result + `M for the overloads with no parameter
+  `result_last` or `result_r`;
+- N be min(M,  `result_last - result`).
 *Preconditions:* The ranges \[`first`, `last`) and \[`result`,
+`result + `N) do not overlap.
+[*Note 1*: For the parallel algorithm overload in namespace `std`,
+there can be a performance cost if
+`iterator_traits<ForwardIterator1>::value_type` does not meet the
+*Cpp17MoveConstructible* ([[cpp17.moveconstructible]]) requirements.
+For the parallel algorithm overloads in namespace `ranges`, there can be
+a performance cost if `iter_value_t<I>` does not model
+`move_constructible`. — *end note*]
+*Effects:* Copies the first N elements referred to by the iterator `i`
+in the range \[`first`, `last`) for which E(`i`) is `true` into the
+range \[`result`, `result + `N).
 *Returns:*
 - `result + `N for the overloads in namespace `std`.
+- `{last, result + `N`}` for the overloads in namespace `ranges`, if N
+  is equal to M.
+- Otherwise, `{j, result_last}` for the overloads in namespace `ranges`,
+  where `j` is the iterator in \[`first`, `last`) for which E(`j`) holds
+  and there are exactly N iterators `i` in \[`first`, `j`) for which
+  E(`i`) holds.
+*Complexity:* At most `last - first` applications of the corresponding
 predicate and any projection.
 *Remarks:* Stable [[algorithm.stable]].
 ``` cpp
   requires indirectly_movable<iterator_t<R>, O>
   constexpr ranges::move_result<borrowed_iterator_t<R>, O>
     ranges::move(R&& r, O result);
 ```
+Let E(n) be
 - `std::move(*(first + `n`))` for the overload in namespace `std`;
 - `ranges::iter_move(first + `n`)` for the overloads in namespace
   `ranges`.
 *Preconditions:* `result` is not in the range \[`first`, `last`).
 *Effects:* Moves elements in the range \[`first`, `last`) into the range
 \[`result`, `result + `N) starting from `first` and proceeding to
 `last`. For each non-negative integer n < N, performs
+`*(result + `n`) = `E(n).
 *Returns:*
 - `result + `N for the overload in namespace `std`.
 - `{last, result + `N`}` for the overloads in namespace `ranges`.
 *Complexity:* Exactly N assignments.
 ``` cpp
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
+  ForwardIterator2 move(ExecutionPolicy&& exec,
                         ForwardIterator1 first, ForwardIterator1 last,
                         ForwardIterator2 result);
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         random_access_iterator O, sized_sentinel_for<O> OutS>
+  requires indirectly_movable<I, O>
+  ranges::move_result<I, O>
+    ranges::move(Ep&& exec, I first, S last, O result, OutS result_last);
+template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR>
+  requires indirectly_movable<iterator_t<R>, iterator_t<OutR>>
+  ranges::move_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+    ranges::move(Ep&& exec, R&& r, OutR&& result_r);
 ```
+Let E(n) be:
+- `std::move(*(first + `n`))` for the overload in namespace `std`;
+- `ranges::iter_move(first + `n`)` for the overloads in namespace
+  `ranges`.
+Let `result_last` be `result + (last - first)` for the overloads in
+namespace `std`.
+Let N be min(`last - first`,  `result_last - result`).
 *Preconditions:* The ranges \[`first`, `last`) and \[`result`,
 `result + `N) do not overlap.
+*Effects:* Moves elements in the range \[`first`, `first + `N) into the
+range \[`result`, `result + `N). For each non-negative integer n < N,
+performs `*(result + `n`) = `E(n).
+*Returns:*
+- `result + `N for the overload in namespace `std`.
+- `{first + `N`, result + `N`}` for the overloads in namespace `ranges`.
 *Complexity:* Exactly N assignments.
 ``` cpp
 template<class BidirectionalIterator1, class BidirectionalIterator2>
   requires indirectly_movable<iterator_t<R>, I>
   constexpr ranges::move_backward_result<borrowed_iterator_t<R>, I>
     ranges::move_backward(R&& r, I result);
 ```
+Let E(n) be
 - `std::move(*(last - `n`))` for the overload in namespace `std`;
 - `ranges::iter_move(last - `n`)` for the overloads in namespace
   `ranges`.
 *Effects:* Moves elements in the range \[`first`, `last`) into the range
 \[`result - `N, `result`) starting from `last - 1` and proceeding to
 `first`.[^3]
+For each positive integer n ≤ N, performs `*(result - `n`) = `E(n).
 *Returns:*
 - `result - `N for the overload in namespace `std`.
 - `{last, result - `N`}` for the overloads in namespace `ranges`.
     ranges::swap_ranges(I1 first1, S1 last1, I2 first2, S2 last2);
 template<input_range R1, input_range R2>
   requires indirectly_swappable<iterator_t<R1>, iterator_t<R2>>
   constexpr ranges::swap_ranges_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
     ranges::swap_ranges(R1&& r1, R2&& r2);
+template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+         random_access_iterator I2, sized_sentinel_for<I2> S2>
+  requires indirectly_swappable<I1, I2>
+  ranges::swap_ranges_result<I1, I2>
+    ranges::swap_ranges(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2);
+template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2>
+  requires indirectly_swappable<iterator_t<R1>, iterator_t<R2>>
+  ranges::swap_ranges_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
+    ranges::swap_ranges(Ep&& exec, R1&& r1, R2&& r2);
 ```
 Let:
+- `last2` be `first2 + (last1 - first1)` for the overloads in namespace
+ `std` with no parameter named `last2`;
 - M be min(`last1 - first1`,  `last2 - first2`).
 *Preconditions:* The two ranges \[`first1`, `last1`) and \[`first2`,
 `last2`) do not overlap. For the overloads in namespace `std`,
 `*(first1 + `n`)` is swappable with [[swappable.requirements]]
 template<input_range R, weakly_incrementable O, copy_constructible F,
          class Proj = identity>
   requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R>, Proj>>>
   constexpr ranges::unary_transform_result<borrowed_iterator_t<R>, O>
     ranges::transform(R&& r, O result, F op, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         random_access_iterator O, sized_sentinel_for<O> OutS,
+         copy_constructible F, class Proj = identity>
+  requires indirectly_writable<O, indirect_result_t<F&, projected<I, Proj>>>
+  ranges::unary_transform_result<I, O>
+    ranges::transform(Ep&& exec, I first1, S last1, O result, OutS result_last,
+                      F op, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR,
+          copy_constructible F, class Proj = identity>
+  requires indirectly_writable<iterator_t<OutR>,
+                                indirect_result_t<F&, projected<iterator_t<R>, Proj>>>
+  ranges::unary_transform_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+    ranges::transform(Ep&& exec, R&& r, OutR&& result_r, F op, Proj proj = {});
 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
          weakly_incrementable O, copy_constructible F, class Proj1 = identity,
          class Proj2 = identity>
   requires indirectly_writable<O, indirect_result_t<F&, projected<I1, Proj1>,
                                projected<I2, Proj2>>>
   requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R1>, Proj1>,
                                projected<iterator_t<R2>, Proj2>>>
   constexpr ranges::binary_transform_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
     ranges::transform(R1&& r1, R2&& r2, O result,
                       F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+         random_access_iterator I2, sized_sentinel_for<I2> S2,
+         random_access_iterator O, sized_sentinel_for<O> OutS,
+         copy_constructible F, class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_writable<O, indirect_result_t<F&, projected<I1, Proj1>,
+                                projected<I2, Proj2>>>
+  ranges::binary_transform_result<I1, I2, O>
+    ranges::transform(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2,
+                      O result, OutS result_last,
+                      F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+         sized-random-access-range OutR, copy_constructible F,
+          class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_writable<iterator_t<OutR>,
+                                indirect_result_t<F&, projected<iterator_t<R1>, Proj1>,
+                                projected<iterator_t<R2>, Proj2>>>
+  ranges::binary_transform_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>,
+                                  borrowed_iterator_t<OutR>>
+    ranges::transform(Ep&& exec, R1&& r1, R2&& r2, OutR&& result_r,
+                      F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
 Let:
+- `last2` be `first2 + (last1 - first1)` for the overloads in namespace
+ `std` with parameter `first2` but no parameter `last2`;
+- M be `last1 - first1` for unary transforms, or
   min(`last1 - first1`,  `last2 - first2`) for binary transforms;
+- `result_last` be `result + `M for the overloads with no parameter
+  `result_last` or `result_r`;
+- N be min(M,  `result_last - result`);
+- E(`i`) be
   - `op(*(first1 + (i - result)))` for unary transforms defined in
     namespace `std`;
   - `binary_op(*(first1 + (i - result)), *(first2 + (i - result)))` for
     binary transforms defined in namespace `std`;
   - `invoke(op, invoke(proj, *(first1 + (i - result))))` for unary
     transforms defined in namespace `ranges`;
   - `invoke(binary_op, invoke(proj1, *(first1 + (i - result))), invoke(proj2,*(first2 + (i - result))))`
     for binary transforms defined in namespace `ranges`.
+*Preconditions:* For parallel algorithm overloads `op` and `binary_op`
+satisfy the requirements specified in [[algorithms.parallel.user]]. `op`
+and `binary_op` do not invalidate iterators or subranges, nor modify
+elements in the ranges
 - \[`first1`, `first1 + `N\],
 - \[`first2`, `first2 + `N\], and
 - \[`result`, `result + `N\].[^4]
 *Effects:* Assigns through every iterator `i` in the range \[`result`,
+`result + `N) a new corresponding value equal to E(`i`).
 *Returns:*
 - `result + `N for the overloads defined in namespace `std`.
 - `{first1 + `N`, result + `N`}` for unary transforms defined in
   namespace `ranges`.
 - `{first1 + `N`, first2 + `N`, result + `N`}` for binary transforms
   defined in namespace `ranges`.
 *Complexity:* Exactly N applications of `op` or `binary_op`, and any
+projections. This requirement also applies to the parallel algorithm
+overloads.
 *Remarks:* `result` may be equal to `first1` or `first2`.
 ### Replace <a id="alg.replace">[[alg.replace]]</a>
 ``` cpp
+template<class ForwardIterator, class T = iterator_traits<ForwardIterator>::value_type>
   constexpr void replace(ForwardIterator first, ForwardIterator last,
                          const T& old_value, const T& new_value);
+template<class ExecutionPolicy, class ForwardIterator,
+         class T = iterator_traits<ForwardIterator>::value_type>
   void replace(ExecutionPolicy&& exec,
                ForwardIterator first, ForwardIterator last,
                const T& old_value, const T& new_value);
+template<class ForwardIterator, class Predicate,
+         class T = iterator_traits<ForwardIterator>::value_type>
   constexpr void replace_if(ForwardIterator first, ForwardIterator last,
                             Predicate pred, const T& new_value);
+template<class ExecutionPolicy, class ForwardIterator, class Predicate,
+         class T = iterator_traits<ForwardIterator>::value_type>
   void replace_if(ExecutionPolicy&& exec,
                   ForwardIterator first, ForwardIterator last,
                   Predicate pred, const T& new_value);
+template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+         class T1 = projected_value_t<I, Proj>, class T2 = T1>
   requires indirectly_writable<I, const T2&> &&
            indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*>
   constexpr I
     ranges::replace(I first, S last, const T1& old_value, const T2& new_value, Proj proj = {});
+template<input_range R, class Proj = identity,
+         class T1 = projected_value_t<iterator_t<R>, Proj>, class T2 = T1>
   requires indirectly_writable<iterator_t<R>, const T2&> &&
            indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T1*>
   constexpr borrowed_iterator_t<R>
     ranges::replace(R&& r, const T1& old_value, const T2& new_value, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity, class T1 = projected_value_t<I, Proj>, class T2 = T1>
+  requires indirectly_writable<I, const T2&> &&
+           indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*>
+  I ranges::replace(Ep&& exec, I first, S last,
+                    const T1& old_value, const T2& new_value, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         class T1 = projected_value_t<iterator_t<R>, Proj>, class T2 = T1>
+  requires indirectly_writable<iterator_t<R>, const T2&> &&
+            indirect_binary_predicate<ranges::equal_to,
+                                      projected<iterator_t<R>, Proj>, const T1*>
+  borrowed_iterator_t<R>
+    ranges::replace(Ep&& exec, R&& r, const T1& old_value, const T2& new_value,
+                    Proj proj = {});
+template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+         class T = projected_value_t<I, Proj>,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   requires indirectly_writable<I, const T&>
   constexpr I ranges::replace_if(I first, S last, Pred pred, const T& new_value, Proj proj = {});
+template<input_range R, class Proj = identity, class T = projected_value_t<iterator_t<R>, Proj>,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   requires indirectly_writable<iterator_t<R>, const T&>
   constexpr borrowed_iterator_t<R>
     ranges::replace_if(R&& r, Pred pred, const T& new_value, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity, class T = projected_value_t<I, Proj>,
+         indirect_unary_predicate<projected<I, Proj>> Pred>
+  requires indirectly_writable<I, const T&>
+  I ranges::replace_if(Ep&& exec, I first, S last, Pred pred,
+                       const T& new_value, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         class T = projected_value_t<iterator_t<R>, Proj>,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  requires indirectly_writable<iterator_t<R>, const T&>
+  borrowed_iterator_t<R>
+    ranges::replace_if(Ep&& exec, R&& r, Pred pred, const T& new_value, Proj proj = {});
 ```
+Let E(`i`) be
 - `bool(*i == old_value)` for `replace`;
 - `bool(pred(*i))` for `replace_if`;
 - `bool(invoke(proj, *i) == old_value)` for `ranges::replace`;
 - `bool(invoke(pred, invoke(proj, *i)))` for `ranges::replace_if`.
 *Mandates:* `new_value` is writable [[iterator.requirements.general]] to
 `first`.
 *Effects:* Substitutes elements referred by the iterator `i` in the
+range \[`first`, `last`) with `new_value`, when E(`i`) is `true`.
 *Returns:* `last` for the overloads in namespace `ranges`.
 *Complexity:* Exactly `last - first` applications of the corresponding
 predicate and any projection.
     replace_copy_if(ExecutionPolicy&& exec,
                     ForwardIterator1 first, ForwardIterator1 last,
                     ForwardIterator2 result,
                     Predicate pred, const T& new_value);
+template<input_iterator I, sentinel_for<I> S, class O,
+         class Proj = identity, class T1 = projected_value_t<I, Proj>, class T2 = iter_value_t<O>>
   requires indirectly_copyable<I, O> &&
+           indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*> &&
+           output_iterator<O, const T2&>
   constexpr ranges::replace_copy_result<I, O>
     ranges::replace_copy(I first, S last, O result, const T1& old_value, const T2& new_value,
                          Proj proj = {});
+template<input_range R, class O, class Proj = identity,
+         class T1 = projected_value_t<iterator_t<R>, Proj>, class T2 = iter_value_t<O>>
   requires indirectly_copyable<iterator_t<R>, O> &&
            indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T1*>
+           && output_iterator<O, const T2&>
   constexpr ranges::replace_copy_result<borrowed_iterator_t<R>, O>
     ranges::replace_copy(R&& r, O result, const T1& old_value, const T2& new_value,
                          Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         random_access_iterator O, sized_sentinel_for<O> OutS,
+         class Proj = identity,
+         class T1 = projected_value_t<I, Proj>, class T2 = iter_value_t<O>>
+  requires indirectly_copyable<I, O> &&
+           indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*> &&
+           indirectly_writable<O, const T2&>
+  ranges::replace_copy_result<I, O>
+    ranges::replace_copy(Ep&& exec, I first, S last, O result, OutS result_last,
+                         const T1& old_value, const T2& new_value, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR,
+         class Proj = identity, class T1 = projected_value_t<iterator_t<R>, Proj>,
+         class T2 = range_value_t<OutR>>
+  requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>> &&
+           indirect_binary_predicate<ranges::equal_to,
+                                      projected<iterator_t<R>, Proj>, const T1*> &&
+           indirectly_writable<iterator_t<OutR>, const T2&>
+  ranges::replace_copy_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+    ranges::replace_copy(Ep&& exec, R&& r, OutR&& result_r, const T1& old_value,
+                         const T2& new_value, Proj proj = {});
+template<input_iterator I, sentinel_for<I> S,class O, class T = iter_value_t<O>,
          class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+  requires indirectly_copyable<I, O> && output_iterator<O, const T&>
   constexpr ranges::replace_copy_if_result<I, O>
     ranges::replace_copy_if(I first, S last, O result, Pred pred, const T& new_value,
                             Proj proj = {});
+template<input_range R, class O, class T = iter_value_t<O>, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  requires indirectly_copyable<iterator_t<R>, O> && output_iterator<O, const T&>
   constexpr ranges::replace_copy_if_result<borrowed_iterator_t<R>, O>
     ranges::replace_copy_if(R&& r, O result, Pred pred, const T& new_value,
                             Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         random_access_iterator O, sized_sentinel_for<O> OutS, class T = iter_value_t<O>,
+         class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+  requires indirectly_copyable<I, O> && indirectly_writable<O, const T&>
+  ranges::replace_copy_if_result<I, O>
+    ranges::replace_copy_if(Ep&& exec, I first, S last, O result, OutS result_last,
+                            Pred pred, const T& new_value, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR,
+         class T = range_value_t<OutR>, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>> &&
+           indirectly_writable<OutR, const T&>
+  ranges::replace_copy_if_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+    ranges::replace_copy_if(Ep&& exec, R&& r, OutR&& result_r, Pred pred, const T& new_value,
+                            Proj proj = {});
 ```
+Let E(`i`) be
 - `bool(*(first + (i - result)) == old_value)` for `replace_copy`;
 - `bool(pred(*(first + (i - result))))` for `replace_copy_if`;
 - `bool(invoke(proj, *(first + (i - result))) == old_value)` for
   `ranges::replace_copy`;
 - `bool(invoke(pred, invoke(proj, *(first + (i - result)))))` for
   `ranges::replace_copy_if`.
+Let:
+- `result_last` be `result + (last - first)` for the overloads with no
+  parameter `result_last` or `result_r`;
+- N be min(`last - first`,  `result_last - result`).
 *Mandates:* The results of the expressions `*first` and `new_value` are
 writable [[iterator.requirements.general]] to `result`.
 *Preconditions:* The ranges \[`first`, `last`) and \[`result`,
+`result + `N) do not overlap.
 *Effects:* Assigns through every iterator `i` in the range \[`result`,
+`result + `N) a new corresponding value
+- `new_value` if E(`i`) is `true` or
 - `*(first + (i - result))` otherwise.
 *Returns:*
+- `result + `N for the overloads in namespace `std`.
+- `{first + `N`, result + `N`}` for the overloads in namespace `ranges`.
+*Complexity:* Exactly N applications of the corresponding predicate and
+any projection.
 ### Fill <a id="alg.fill">[[alg.fill]]</a>
 ``` cpp
+template<class ForwardIterator, class T = iterator_traits<ForwardIterator>::value_type>
   constexpr void fill(ForwardIterator first, ForwardIterator last, const T& value);
+template<class ExecutionPolicy, class ForwardIterator,
+         class T = iterator_traits<ForwardIterator>::value_type>
   void fill(ExecutionPolicy&& exec,
             ForwardIterator first, ForwardIterator last, const T& value);
+template<class OutputIterator, class Size, class T = iterator_traits<OutputIterator>::value_type>
   constexpr OutputIterator fill_n(OutputIterator first, Size n, const T& value);
+template<class ExecutionPolicy, class ForwardIterator, class Size,
+         class T = iterator_traits<ForwardIterator>::value_type>
   ForwardIterator fill_n(ExecutionPolicy&& exec,
                          ForwardIterator first, Size n, const T& value);
+template<class O, sentinel_for<O> S, class T = iter_value_t<O>>
+  requires output_iterator<O, const T&>
   constexpr O ranges::fill(O first, S last, const T& value);
+template<class R, class T = range_value_t<R>>
+  requires output_range<R, const T&>
   constexpr borrowed_iterator_t<R> ranges::fill(R&& r, const T& value);
+template<class O, class T = iter_value_t<O>>
+  requires output_iterator<O, const T&>
   constexpr O ranges::fill_n(O first, iter_difference_t<O> n, const T& value);
+template<execution-policy Ep, random_access_iterator O, sized_sentinel_for<O> S,
+         class T = iter_value_t<O>>
+  requires indirectly_writable<O, const T&>
+  O ranges::fill(Ep&& exec, O first, S last, const T& value);
+template<execution-policy Ep, sized-random-access-range R, class T = range_value_t<R>>
+  requires indirectly_writable<iterator_t<R>, const T&>
+  borrowed_iterator_t<R> fill(Ep&& exec, R&& r, const T& value);
+template<execution-policy Ep, random_access_iterator O, class T = iter_value_t<O>>
+  requires indirectly_writable<O, const T&>
+  O ranges::fill_n(Ep&& exec, O first, iter_difference_t<O> n, const T& value);
 ```
 Let N be max(0, `n`) for the `fill_n` algorithms, and `last - first` for
 the `fill` algorithms.
   requires invocable<F&> && output_range<R, invoke_result_t<F&>>
   constexpr borrowed_iterator_t<R> ranges::generate(R&& r, F gen);
 template<input_or_output_iterator O, copy_constructible F>
   requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
   constexpr O ranges::generate_n(O first, iter_difference_t<O> n, F gen);
+template<execution-policy Ep, random_access_iterator O, sized_sentinel_for<O> S,
+         copy_constructible F>
+  requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
+  O ranges::generate(Ep&& exec, O first, S last, F gen);
+template<execution-policy Ep, sized-random-access-range R, copy_constructible F>
+  requires invocable<F&> && indirectly_writable<iterator_t<R>, invoke_result_t<F&>>
+  borrowed_iterator_t<R> ranges::generate(Ep&& exec, R&& r, F gen);
+template<execution-policy Ep, random_access_iterator O, copy_constructible F>
+  requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
+  O ranges::generate_n(Ep&& exec, O first, iter_difference_t<O> n, F gen);
 ```
 Let N be max(0, `n`) for the `generate_n` algorithms, and `last - first`
 for the `generate` algorithms.
 *Returns:* `first + `N.
 *Complexity:* Exactly N evaluations of `gen()` and assignments.
+*Remarks:* `gen` may modify objects via its arguments for parallel
+algorithm overloads [[algorithms.parallel.user]].
 ### Remove <a id="alg.remove">[[alg.remove]]</a>
 ``` cpp
+template<class ForwardIterator, class T = iterator_traits<ForwardIterator>::value_type>
   constexpr ForwardIterator remove(ForwardIterator first, ForwardIterator last,
                                    const T& value);
+template<class ExecutionPolicy, class ForwardIterator,
+         class T = iterator_traits<ForwardIterator>::value_type>
   ForwardIterator remove(ExecutionPolicy&& exec,
                          ForwardIterator first, ForwardIterator last,
                          const T& value);
 template<class ForwardIterator, class Predicate>
 template<class ExecutionPolicy, class ForwardIterator, class Predicate>
   ForwardIterator remove_if(ExecutionPolicy&& exec,
                             ForwardIterator first, ForwardIterator last,
                             Predicate pred);
+template<permutable I, sentinel_for<I> S, class Proj = identity,
+         class T = projected_value_t<I, Proj>>
   requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
   constexpr subrange<I> ranges::remove(I first, S last, const T& value, Proj proj = {});
+template<forward_range R, class Proj = identity,
+         class T = projected_value_t<iterator_t<R>, Proj>>
   requires permutable<iterator_t<R>> &&
            indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
   constexpr borrowed_subrange_t<R>
     ranges::remove(R&& r, const T& value, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity, class T = projected_value_t<I, Proj>>
+  requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
+  subrange<I>
+    ranges::remove(Ep&& exec, I first, S last, const T& value, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         class T = projected_value_t<iterator_t<R>, Proj>>
+  requires permutable<iterator_t<R>> &&
+           indirect_binary_predicate<ranges::equal_to,
+                                      projected<iterator_t<R>, Proj>, const T*>
+  borrowed_subrange_t<R>
+    ranges::remove(Ep&& exec, R&& r, const T& value, Proj proj = {});
 template<permutable I, sentinel_for<I> S, class Proj = identity,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr subrange<I> ranges::remove_if(I first, S last, Pred pred, Proj proj = {});
 template<forward_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   requires permutable<iterator_t<R>>
   constexpr borrowed_subrange_t<R>
     ranges::remove_if(R&& r, Pred pred, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+  subrange<I>
+    ranges::remove_if(Ep&& exec, I first, S last, Pred pred, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  requires permutable<iterator_t<R>>
+  borrowed_subrange_t<R>
+    ranges::remove_if(Ep&& exec, R&& r, Pred pred, Proj proj = {});
 ```
 Let E be
 - `bool(*i == value)` for `remove`;
 the returned value, has a valid but unspecified state, because the
 algorithms can eliminate elements by moving from elements that were
 originally in that range. — *end note*]
 ``` cpp
+template<class InputIterator, class OutputIterator,
+         class T = iterator_traits<InputIterator>::value_type>
   constexpr OutputIterator
     remove_copy(InputIterator first, InputIterator last,
                 OutputIterator result, const T& value);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
+         class T = iterator_traits<ForwardIterator1>::value_type>
   ForwardIterator2
     remove_copy(ExecutionPolicy&& exec,
                 ForwardIterator1 first, ForwardIterator1 last,
                 ForwardIterator2 result, const T& value);
   ForwardIterator2
     remove_copy_if(ExecutionPolicy&& exec,
                    ForwardIterator1 first, ForwardIterator1 last,
                    ForwardIterator2 result, Predicate pred);
+template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
+         class Proj = identity, class T = projected_value_t<I, Proj>>
   requires indirectly_copyable<I, O> &&
            indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
   constexpr ranges::remove_copy_result<I, O>
     ranges::remove_copy(I first, S last, O result, const T& value, Proj proj = {});
+template<input_range R, weakly_incrementable O, class Proj = identity,
+         class T = projected_value_t<iterator_t<R>, Proj>>
   requires indirectly_copyable<iterator_t<R>, O> &&
            indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
   constexpr ranges::remove_copy_result<borrowed_iterator_t<R>, O>
     ranges::remove_copy(R&& r, O result, const T& value, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         random_access_iterator O, sized_sentinel_for<O> OutS,
+         class Proj = identity, class T = projected_value_t<I, Proj>>
+  requires indirectly_copyable<I, O> &&
+           indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
+  ranges::remove_copy_result<I, O>
+    ranges::remove_copy(Ep&& exec, I first, S last, O result, OutS result_last,
+                        const T& value, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR,
+         class Proj = identity, class T = projected_value_t<iterator_t<R>, Proj>>
+  requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>> &&
+           indirect_binary_predicate<ranges::equal_to,
+                                      projected<iterator_t<R>, Proj>, const T*>
+  ranges::remove_copy_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+    ranges::remove_copy(Ep&& exec, R&& r, OutR&& result_r, const T& value, Proj proj = {});
 template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
          class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
   requires indirectly_copyable<I, O>
   constexpr ranges::remove_copy_if_result<I, O>
     ranges::remove_copy_if(I first, S last, O result, Pred pred, Proj proj = {});
 template<input_range R, weakly_incrementable O, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   requires indirectly_copyable<iterator_t<R>, O>
   constexpr ranges::remove_copy_if_result<borrowed_iterator_t<R>, O>
     ranges::remove_copy_if(R&& r, O result, Pred pred, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         random_access_iterator O, sized_sentinel_for<O> OutS,
+         class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+  requires indirectly_copyable<I, O>
+  ranges::remove_copy_if_result<I, O>
+    ranges::remove_copy_if(Ep&& exec, I first, S last, O result, OutS result_last,
+                           Pred pred, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR,
+         class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>>
+  ranges::remove_copy_if_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+    ranges::remove_copy_if(Ep&& exec, R&& r, OutR&& result_r, Pred pred, Proj proj = {});
 ```
+Let E(`i`) be
 - `bool(*i == value)` for `remove_copy`;
 - `bool(pred(*i))` for `remove_copy_if`;
 - `bool(invoke(proj, *i) == value)` for `ranges::remove_copy`;
 - `bool(invoke(pred, invoke(proj, *i)))` for `ranges::remove_copy_if`.
+Let:
+- M be the number of iterators `i` in \[`first`, `last`) for which
+  E(`i`) is `false`;
+- `result_last` be `result + `M for the overloads with no parameter
+  `result_last` or `result_r`;
+- N be min(M,  `result_last - result`).
 *Mandates:* `*first` is writable [[iterator.requirements.general]] to
 `result`.
 *Preconditions:* The ranges \[`first`, `last`) and \[`result`,
+`result + `N) do not overlap.
+[*Note 2*: For the parallel algorithm overloads in namespace `std`,
+there can be a performance cost if
+`iterator_traits<ForwardIterator1>::value_type` does not meet the
+*Cpp17MoveConstructible* ([[cpp17.moveconstructible]]) requirements.
+For the parallel algorithm overloads in namespace `ranges`, there can be
+a performance cost if `iter_value_t<I>` does not model
+`move_constructible`. — *end note*]
+*Effects:* Copies the first N elements referred to by the iterator `i`
+in the range \[`first`, `last`) for which E(`i`) is `false` into the
+range \[`result`, `result + `N).
 *Returns:*
 - `result + `N, for the algorithms in namespace `std`.
+- `{last, result + `N`}`, for the algorithms in namespace `ranges`, if N
+  is equal to M.
+- Otherwise, `{j, result_last}`, for the algorithms in namespace
+  `ranges`, where `j` is the iterator in \[`first`, `last`) for which
+  E(`j`) is `false` and there are exactly N iterators `i` in \[`first`,
+  `j`) for which E(`i`) is `false`.
+*Complexity:* At most `last - first` applications of the corresponding
 predicate and any projection.
 *Remarks:* Stable [[algorithm.stable]].
 ### Unique <a id="alg.unique">[[alg.unique]]</a>
 template<forward_range R, class Proj = identity,
          indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
   requires permutable<iterator_t<R>>
   constexpr borrowed_subrange_t<R>
     ranges::unique(R&& r, C comp = {}, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity,
+         indirect_equivalence_relation<projected<I, Proj>> C = ranges::equal_to>
+  requires permutable<I>
+  subrange<I> ranges::unique(Ep&& exec, I first, S last, C comp = {}, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
+  requires permutable<iterator_t<R>>
+  borrowed_subrange_t<R> ranges::unique(Ep&& exec, R&& r, C comp = {}, Proj proj = {});
 ```
 Let `pred` be `equal_to{}` for the overloads with no parameter `pred`,
 and let E be
            (forward_iterator<iterator_t<R>> ||
             (input_iterator<O> && same_as<range_value_t<R>, iter_value_t<O>>) ||
             indirectly_copyable_storable<iterator_t<R>, O>)
   constexpr ranges::unique_copy_result<borrowed_iterator_t<R>, O>
     ranges::unique_copy(R&& r, O result, C comp = {}, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         random_access_iterator O, sized_sentinel_for<O> OutS, class Proj = identity,
+         indirect_equivalence_relation<projected<I, Proj>> C = ranges::equal_to>
+  requires indirectly_copyable<I, O>
+  ranges::unique_copy_result<I, O>
+    ranges::unique_copy(Ep&& exec, I first, S last, O result, OutS result_last,
+                        C comp = {}, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR,
+         class Proj = identity,
+         indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
+  requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>>
+  ranges::unique_copy_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+    ranges::unique_copy(Ep&& exec, R&& r, OutR&& result_r, C comp = {}, Proj proj = {});
 ```
 Let `pred` be `equal_to{}` for the overloads in namespace `std` with no
+parameter `pred`, and let E(`i`) be
 - `bool(pred(*i, *(i - 1)))` for the overloads in namespace `std`;
 - `bool(invoke(comp, invoke(proj, *i), invoke(proj, *(i - 1))))` for the
   overloads in namespace `ranges`.
+Let:
+- M be the number of iterators `i` in the range \[`first + 1`, `last`)
+  for which E(`i`) is `false`;
+- `result_last` be `result + `M` + 1` for the overloads with no
+  parameter `result_last` or `result_r`;
+- N be min(M + 1,  `result_last - result`).
 *Mandates:* `*first` is writable [[iterator.requirements.general]] to
 `result`.
 *Preconditions:*
+- The ranges \[`first`, `last`) and \[`result`, `result + `N) do not
+  overlap.
 - For the overloads in namespace `std`:
   - The comparison function is an equivalence relation.
   - For the overloads with no `ExecutionPolicy`, let `T` be the value
     type of `InputIterator`. If `InputIterator` models
     `forward_iterator` [[iterator.concept.forward]], then there are no
     additional requirements for `T`. Otherwise, if `OutputIterator`
     meets the *Cpp17ForwardIterator* requirements and its value type is
     the same as `T`, then `T` meets the *Cpp17CopyAssignable*
     ([[cpp17.copyassignable]]) requirements. Otherwise, `T` meets both
     the *Cpp17CopyConstructible* ([[cpp17.copyconstructible]]) and
+    *Cpp17CopyAssignable* requirements.
+[*Note 1*: For the parallel algorithm overloads in namespace `std`,
+there can be a performance cost if the value type of `ForwardIterator1`
+does not meet both the *Cpp17CopyConstructible* and
+*Cpp17CopyAssignable* requirements. For the parallel algorithm overloads
+in namespace `ranges`, there can be a performance cost if
+`iter_value_t<I>` does not model `copyable`. — *end note*]
+*Effects:* Copies only the first element from N consecutive groups of
+equivalent elements referred to by the iterator `i` in the range
+\[`first + 1`, `last`) for which E(`i`) holds into the range \[`result`,
+`result + `N).
 *Returns:*
 - `result + `N for the overloads in namespace `std`.
+- `{last, result + `N`}` for the overloads in namespace `ranges`, if N
+  is equal to M + 1.
+- Otherwise, `{j, result_last}` for the overloads in namespace `ranges`,
+  where `j` is the iterator in \[`first + 1`, `last`) for which E(`j`)
+  is `false` and there are exactly N - 1 iterators `i` in \[`first + 1`,
+  `j`) for which E(`i`) is `false`.
+*Complexity:* At most `last - first - 1` applications of the
 corresponding predicate and no more than twice as many applications of
 any projection.
 ### Reverse <a id="alg.reverse">[[alg.reverse]]</a>
   requires permutable<I>
   constexpr I ranges::reverse(I first, S last);
 template<bidirectional_range R>
   requires permutable<iterator_t<R>>
   constexpr borrowed_iterator_t<R> ranges::reverse(R&& r);
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S>
+  requires permutable<I>
+  I ranges::reverse(Ep&& exec, I first, S last);
+template<execution-policy Ep, sized-random-access-range R>
+  requires permutable<iterator_t<R>>
+  borrowed_iterator_t<R> ranges::reverse(Ep&& exec, R&& r);
 ```
 *Preconditions:* For the overloads in namespace `std`,
 `BidirectionalIterator` meets the *Cpp17ValueSwappable*
 requirements [[swappable.requirements]].
 - `result + `N for the overloads in namespace `std`.
 - `{last, result + `N`}` for the overloads in namespace `ranges`.
 *Complexity:* Exactly N assignments.
+``` cpp
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         random_access_iterator O, sized_sentinel_for<O> OutS>
+  requires indirectly_copyable<I, O>
+  ranges::reverse_copy_truncated_result<I, O>
+    ranges::reverse_copy(Ep&& exec, I first, S last, O result,
+                         OutS result_last);
+template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR>
+  requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>>
+  ranges::reverse_copy_truncated_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+    ranges::reverse_copy(Ep&& exec, R&& r, OutR&& result_r);
+```
+Let N be min(`last - first`,  `result_last - result`), and let
+*NEW_FIRST* be `first + (last - first) - `N.
+*Preconditions:* The ranges \[`first`, `last`) and \[`result`,
+`result + `N) do not overlap.
+*Effects:* Copies the range \[*`NEW_FIRST`*, `last`) to the range
+\[`result`, `result + `N) such that for every non-negative integer i < N
+the following assignment takes place:
+`*(result + `N` - 1 - `i`) = *(`*`NEW_FIRST`*` + `i`)`.
+*Returns:* `{last, `*`NEW_FIRST`*`, result + `N`}`.
+*Complexity:* Exactly N assignments.
 ### Rotate <a id="alg.rotate">[[alg.rotate]]</a>
 ``` cpp
 template<class ForwardIterator>
   constexpr ForwardIterator
     rotate(ExecutionPolicy&& exec,
            ForwardIterator first, ForwardIterator middle, ForwardIterator last);
 template<permutable I, sentinel_for<I> S>
   constexpr subrange<I> ranges::rotate(I first, I middle, S last);
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S>
+  requires permutable<I>
+  subrange<I> ranges::rotate(Ep&& exec, I first, I middle, S last);
 ```
 *Preconditions:* \[`first`, `middle`) and \[`middle`, `last`) are valid
 ranges. For the overloads in namespace `std`, `ForwardIterator` meets
 the *Cpp17ValueSwappable* requirements [[swappable.requirements]], and
 ```
 *Effects:* Equivalent to:
 `return ranges::rotate(ranges::begin(r), middle, ranges::end(r));`
+``` cpp
+template<execution-policy Ep, sized-random-access-range R>
+  requires permutable<iterator_t<R>>
+  borrowed_subrange_t<R> ranges::rotate(Ep&& exec, R&& r, iterator_t<R> middle);
+```
+*Effects:* Equivalent to:
+``` cpp
+return ranges::rotate(std::forward<Ep>(exec), ranges::begin(r), middle, ranges::end(r));
+```
 ``` cpp
 template<class ForwardIterator, class OutputIterator>
   constexpr OutputIterator
     rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last,
                 OutputIterator result);
 - `result + `N for the overloads in namespace `std`.
 - `{last, result + `N`}` for the overload in namespace `ranges`.
 *Complexity:* Exactly N assignments.
+``` cpp
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         random_access_iterator O, sized_sentinel_for<O> OutS>
+  requires indirectly_copyable<I, O>
+  ranges::rotate_copy_truncated_result<I, O>
+    ranges::rotate_copy(Ep&& exec, I first, I middle, S last, O result, OutS result_last);
+```
+Let M be `last - first` and N be min(M,  `result_last - result`).
+*Preconditions:* \[`first`, `middle`) and \[`middle`, `last`) are valid
+ranges. The ranges \[`first`, `last`) and \[`result`, `result + `N) do
+not overlap.
+*Effects:* Copies the range \[`first`, `last`) to the range \[`result`,
+`result + `N) such that for each non-negative integer i < N the
+following assignment takes place:
+`*(result + `i`) = *(first + (`i` + (middle - first)) % `M`)`.
+*Returns:*
+- `{middle + `N`, first, result + `N`}` if N is less than
+  `last - middle`.
+- Otherwise,
+  `{last, first + (`N` + (middle - first)) % `M`, result + `N`}`.
+*Complexity:* Exactly N assignments.
 ``` cpp
 template<forward_range R, weakly_incrementable O>
   requires indirectly_copyable<iterator_t<R>, O>
   constexpr ranges::rotate_copy_result<borrowed_iterator_t<R>, O>
     ranges::rotate_copy(R&& r, iterator_t<R> middle, O result);
 ``` cpp
 return ranges::rotate_copy(ranges::begin(r), middle, ranges::end(r), std::move(result));
 ```
+``` cpp
+template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR>
+  requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>>
+  ranges::rotate_copy_truncated_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+    ranges::rotate_copy(Ep&& exec, R&& r, iterator_t<R> middle, OutR&& result_r);
+```
+*Effects:* Equivalent to:
+``` cpp
+return ranges::rotate_copy(std::forward<Ep>(exec), ranges::begin(r), middle, ranges::end(r),
+                           ranges::begin(result_r), ranges::end(result_r));
+```
 ### Sample <a id="alg.random.sample">[[alg.random.sample]]</a>
 ``` cpp
 template<class PopulationIterator, class SampleIterator,
          class Distance, class UniformRandomBitGenerator>
 template<permutable I, sentinel_for<I> S>
   constexpr subrange<I> ranges::shift_left(I first, S last, iter_difference_t<I> n);
 template<forward_range R>
   requires permutable<iterator_t<R>>
+  constexpr borrowed_subrange_t<R> ranges::shift_left(R&& r, range_difference_t<R> n);
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S>
+  requires permutable<I>
+  subrange<I>
+    ranges::shift_left(Ep&& exec, I first, S last, iter_difference_t<I> n);
+template<execution-policy Ep, sized-random-access-range R>
+  requires permutable<iterator_t<R>>
+  borrowed_subrange_t<R>
+    ranges::shift_left(Ep&& exec, R&& r, range_difference_t<R> n);
 ```
 *Preconditions:* `n >= 0` is `true`. For the overloads in namespace
 `std`, the type of `*first` meets the *Cpp17MoveAssignable*
 requirements.
 *Effects:* If `n == 0` or `n >= last - first`, does nothing. Otherwise,
 moves the element from position `first + n + i` into position
 `first + i` for each non-negative integer `i < (last - first) - n`. For
+the non-parallel algorithm overloads, does so in order starting from
+`i = 0` and proceeding to `i = (last - first) - n - 1`.
 *Returns:* Let *NEW_LAST* be `first + (last - first - n)` if
+`n < last - first`, otherwise `first`. Returns:
 - *NEW_LAST* for the overloads in namespace `std`.
 - `{first, `*`NEW_LAST`*`}` for the overloads in namespace `ranges`.
 *Complexity:* At most `(last - first) - n` assignments.
 template<permutable I, sentinel_for<I> S>
   constexpr subrange<I> ranges::shift_right(I first, S last, iter_difference_t<I> n);
 template<forward_range R>
   requires permutable<iterator_t<R>>
   constexpr borrowed_subrange_t<R> ranges::shift_right(R&& r, range_difference_t<R> n);
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S>
+  requires permutable<I>
+  subrange<I>
+    ranges::shift_right(Ep&& exec, I first, S last, iter_difference_t<I> n);
+template<execution-policy Ep, sized-random-access-range R>
+  requires permutable<iterator_t<R>>
+  borrowed_subrange_t<R>
+    ranges::shift_right(Ep&& exec, R&& r, range_difference_t<R> n);
 ```
 *Preconditions:* `n >= 0` is `true`. For the overloads in namespace
 `std`, the type of `*first` meets the *Cpp17MoveAssignable*
 requirements, and `ForwardIterator` meets the
 *Effects:* If `n == 0` or `n >= last - first`, does nothing. Otherwise,
 moves the element from position `first + i` into position
 `first + n + i` for each non-negative integer `i < (last - first) - n`.
 Does so in order starting from `i = (last - first) - n - 1` and
+proceeding to `i = 0` if
+- for the non-parallel algorithm overload in namespace `std`,
+  `ForwardIterator` meets the *Cpp17BidirectionalIterator* requirements,
+- for the non-parallel algorithm overloads in namespace `ranges`, `I`
+  models `bidirectional_iterator`.
 *Returns:* Let *NEW_FIRST* be `first + n` if `n < last - first`,
+otherwise `last`. Returns:
 - *NEW_FIRST* for the overloads in namespace `std`.
 - `{`*`NEW_FIRST`*`, last}` for the overloads in namespace `ranges`.
 *Complexity:* At most `(last - first) - n` assignments or swaps.
     ranges::sort(I first, S last, Comp comp = {}, Proj proj = {});
 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
   requires sortable<iterator_t<R>, Comp, Proj>
   constexpr borrowed_iterator_t<R>
     ranges::sort(R&& r, Comp comp = {}, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Comp = ranges::less, class Proj = identity>
+  requires sortable<I, Comp, Proj>
+  I ranges::sort(Ep&& exec, I first, S last, Comp comp = {}, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Comp = ranges::less,
+         class Proj = identity>
+  requires sortable<iterator_t<R>, Comp, Proj>
+  borrowed_iterator_t<R> ranges::sort(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});
 ```
 Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
 no parameters by those names.
 #### `stable_sort` <a id="stable.sort">[[stable.sort]]</a>
 ``` cpp
 template<class RandomAccessIterator>
+ constexpr void stable_sort(RandomAccessIterator first, RandomAccessIterator last);
 template<class ExecutionPolicy, class RandomAccessIterator>
   void stable_sort(ExecutionPolicy&& exec,
                    RandomAccessIterator first, RandomAccessIterator last);
 template<class RandomAccessIterator, class Compare>
+ constexpr void stable_sort(RandomAccessIterator first, RandomAccessIterator last,
                              Compare comp);
 template<class ExecutionPolicy, class RandomAccessIterator, class Compare>
   void stable_sort(ExecutionPolicy&& exec,
                    RandomAccessIterator first, RandomAccessIterator last,
                    Compare comp);
 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
          class Proj = identity>
   requires sortable<I, Comp, Proj>
+ constexpr I ranges::stable_sort(I first, S last, Comp comp = {}, Proj proj = {});
 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
   requires sortable<iterator_t<R>, Comp, Proj>
+ constexpr borrowed_iterator_t<R>
     ranges::stable_sort(R&& r, Comp comp = {}, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Comp = ranges::less, class Proj = identity>
+  requires sortable<I, Comp, Proj>
+  I ranges::stable_sort(Ep&& exec, I first, S last, Comp comp = {}, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Comp = ranges::less,
+         class Proj = identity>
+  requires sortable<iterator_t<R>, Comp, Proj>
+  borrowed_iterator_t<R>
+    ranges::stable_sort(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});
 ```
 Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
 no parameters by those names.
 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
          class Proj = identity>
   requires sortable<I, Comp, Proj>
   constexpr I
     ranges::partial_sort(I first, I middle, S last, Comp comp = {}, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Comp = ranges::less, class Proj = identity>
+  requires sortable<I, Comp, Proj>
+  I ranges::partial_sort(Ep&& exec, I first, I middle, S last, Comp comp = {}, Proj proj = {});
 ```
 Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
 no parameters by those names.
 ``` cpp
 return ranges::partial_sort(ranges::begin(r), middle, ranges::end(r), comp, proj);
 ```
+``` cpp
+template<execution-policy Ep, sized-random-access-range R,
+         class Comp = ranges::less, class Proj = identity>
+  requires sortable<iterator_t<R>, Comp, Proj>
+  borrowed_iterator_t<R>
+    ranges::partial_sort(Ep&& exec, R&& r, iterator_t<R> middle, Comp comp = {},
+                         Proj proj = {});
+```
+*Effects:* Equivalent to:
+``` cpp
+return ranges::partial_sort(std::forward<Ep>(exec), ranges::begin(r), middle,
+                            ranges::end(r), comp, proj);
+```
 #### `partial_sort_copy` <a id="partial.sort.copy">[[partial.sort.copy]]</a>
 ``` cpp
 template<class InputIterator, class RandomAccessIterator>
   constexpr RandomAccessIterator
            indirect_strict_weak_order<Comp, projected<iterator_t<R1>, Proj1>,
                                       projected<iterator_t<R2>, Proj2>>
   constexpr ranges::partial_sort_copy_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
     ranges::partial_sort_copy(R1&& r, R2&& result_r, Comp comp = {},
                               Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+         random_access_iterator I2, sized_sentinel_for<I2> S2,
+         class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_copyable<I1, I2> && sortable<I2, Comp, Proj2> &&
+            indirect_strict_weak_order<Comp, projected<I1, Proj1>, projected<I2, Proj2>>
+  ranges::partial_sort_copy_result<I1, I2>
+    ranges::partial_sort_copy(Ep&& exec, I1 first, S1 last, I2 result_first, S2 result_last,
+                              Comp comp = {}, Proj1 proj1 = {},
+                              Proj2 proj2 = {});
+template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+         class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
+  requires indirectly_copyable<iterator_t<R1>, iterator_t<R2>> &&
+           sortable<iterator_t<R2>, Comp, Proj2> &&
+           indirect_strict_weak_order<Comp, projected<iterator_t<R1>, Proj1>,
+                                      projected<iterator_t<R2>, Proj2>>
+  ranges::partial_sort_copy_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
+    ranges::partial_sort_copy(Ep&& exec, R1&& r, R2&& result_r, Comp comp = {},
+                              Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
 Let N be min(`last - first`,  `result_last - result_first`). Let `comp`
 be `less{}`, and `proj1` and `proj2` be `identity{}` for the overloads
 with no parameters by those names.
 ```
 *Effects:* Equivalent to:
 `return ranges::is_sorted_until(first, last, comp, proj) == last;`
+``` cpp
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity,
+         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+  bool ranges::is_sorted(Ep&& exec, I first, S last, Comp comp = {}, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+  bool ranges::is_sorted(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});
+```
+*Effects:* Equivalent to:
+``` cpp
+return ranges::is_sorted_until(std::forward<Ep>(exec), first, last, comp, proj) == last;
+```
 ``` cpp
 template<class ForwardIterator>
   constexpr ForwardIterator
     is_sorted_until(ForwardIterator first, ForwardIterator last);
 template<class ExecutionPolicy, class ForwardIterator>
   constexpr I ranges::is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {});
 template<forward_range R, class Proj = identity,
          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
   constexpr borrowed_iterator_t<R>
     ranges::is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity,
+         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+  I ranges::is_sorted_until(Ep&& exec, I first, S last, Comp comp = {},
+                    Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+  borrowed_iterator_t<R>
+    ranges::is_sorted_until(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});
 ```
 Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
 no parameters by those names.
 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
          class Proj = identity>
   requires sortable<I, Comp, Proj>
   constexpr I
     ranges::nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Comp = ranges::less, class Proj = identity>
+  requires sortable<I, Comp, Proj>
+  I ranges::nth_element(Ep&& exec, I first, I nth, S last, Comp comp = {}, Proj proj = {});
 ```
 Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
 no parameters by those names.
 iterator `j` in the range \[`nth`, `last`) it holds that:
 `bool(invoke(comp, invoke(proj, *j), invoke(proj, *i)))` is `false`.
 *Returns:* `last` for the overload in namespace `ranges`.
+*Complexity:* For the non-parallel algorithm overloads, linear on
+average. For the parallel algorithm overloads, 𝑂(N) applications of the
+predicate, and 𝑂(N log N) swaps, where N = `last - first`.
 ``` cpp
 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
   requires sortable<iterator_t<R>, Comp, Proj>
   constexpr borrowed_iterator_t<R>
 ``` cpp
 return ranges::nth_element(ranges::begin(r), nth, ranges::end(r), comp, proj);
 ```
+``` cpp
+template<execution-policy Ep, sized-random-access-range R, class Comp = ranges::less,
+         class Proj = identity>
+  requires sortable<iterator_t<R>, Comp, Proj>
+  borrowed_iterator_t<R>
+    ranges::nth_element(Ep&& exec, R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {});
+```
+*Effects:* Equivalent to:
+``` cpp
+return ranges::nth_element(std::forward<Ep>(exec), ranges::begin(r), nth, ranges::end(r),
+                           comp, proj);
+```
 ### Binary search <a id="alg.binary.search">[[alg.binary.search]]</a>
 #### General <a id="alg.binary.search.general">[[alg.binary.search.general]]</a>
 All of the algorithms in [[alg.binary.search]] are versions of binary
 a linear number of steps.
 #### `lower_bound` <a id="lower.bound">[[lower.bound]]</a>
 ``` cpp
+template<class ForwardIterator, class T = iterator_traits<ForwardIterator>::value_type>
   constexpr ForwardIterator
     lower_bound(ForwardIterator first, ForwardIterator last,
                 const T& value);
+template<class ForwardIterator, class T = iterator_traits<ForwardIterator>::value_type,
+         class Compare>
   constexpr ForwardIterator
     lower_bound(ForwardIterator first, ForwardIterator last,
                 const T& value, Compare comp);
+template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+         class T = projected_value_t<I, Proj>,
          indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
   constexpr I ranges::lower_bound(I first, S last, const T& value, Comp comp = {},
                                   Proj proj = {});
+template<forward_range R, class Proj = identity,
+         class T = projected_value_t<iterator_t<R>, Proj>,
          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
            ranges::less>
   constexpr borrowed_iterator_t<R>
     ranges::lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
 ```
 projections.
 #### `upper_bound` <a id="upper.bound">[[upper.bound]]</a>
 ``` cpp
+template<class ForwardIterator, class T = iterator_traits<ForwardIterator>::value_type>
   constexpr ForwardIterator
     upper_bound(ForwardIterator first, ForwardIterator last,
                 const T& value);
+template<class ForwardIterator, class T = iterator_traits<ForwardIterator>::value_type,
+         class Compare>
   constexpr ForwardIterator
     upper_bound(ForwardIterator first, ForwardIterator last,
                 const T& value, Compare comp);
+template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+         class T = projected_value_t<I, Proj>,
          indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
   constexpr I ranges::upper_bound(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
+template<forward_range R, class Proj = identity,
+         class T = projected_value_t<iterator_t<R>, Proj>,
          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
            ranges::less>
   constexpr borrowed_iterator_t<R>
     ranges::upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
 ```
 projections.
 #### `equal_range` <a id="equal.range">[[equal.range]]</a>
 ``` cpp
+template<class ForwardIterator, class T = iterator_traits<ForwardIterator>::value_type>
   constexpr pair<ForwardIterator, ForwardIterator>
     equal_range(ForwardIterator first,
                 ForwardIterator last, const T& value);
+template<class ForwardIterator, class T = iterator_traits<ForwardIterator>::value_type,
+         class Compare>
   constexpr pair<ForwardIterator, ForwardIterator>
     equal_range(ForwardIterator first,
                 ForwardIterator last, const T& value,
                 Compare comp);
+template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+         class T = projected_value_t<I, Proj>,
          indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
   constexpr subrange<I>
     ranges::equal_range(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
+template<forward_range R, class Proj = identity,
+         class T = projected_value_t<iterator_t<R>, Proj>,
          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
            ranges::less>
   constexpr borrowed_subrange_t<R>
     ranges::equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {});
 ```
 *Preconditions:* The elements `e` of \[`first`, `last`) are partitioned
 with respect to the expressions
 `bool(invoke(comp, invoke(proj, e), value))` and
 `!bool(invoke(comp, value, invoke(proj, e)))`. Also, for all elements
+`e` of \[`first`, `last`), `bool(comp(e, value))` implies
 `!bool(comp(value, e))` for the overloads in namespace `std`.
 *Returns:*
 - For the overloads in namespace `std`:
 projections.
 #### `binary_search` <a id="binary.search">[[binary.search]]</a>
 ``` cpp
+template<class ForwardIterator, class T = iterator_traits<ForwardIterator>::value_type>
   constexpr bool
     binary_search(ForwardIterator first, ForwardIterator last,
                   const T& value);
+template<class ForwardIterator, class T = iterator_traits<ForwardIterator>::value_type,
+         class Compare>
   constexpr bool
     binary_search(ForwardIterator first, ForwardIterator last,
                   const T& value, Compare comp);
+template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+         class T = projected_value_t<I, Proj>,
          indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
   constexpr bool ranges::binary_search(I first, S last, const T& value, Comp comp = {},
                                        Proj proj = {});
+template<forward_range R, class Proj = identity,
+         class T = projected_value_t<iterator_t<R>, Proj>,
          indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
            ranges::less>
   constexpr bool ranges::binary_search(R&& r, const T& value, Comp comp = {},
                                        Proj proj = {});
 ```
 *Preconditions:* The elements `e` of \[`first`, `last`) are partitioned
 with respect to the expressions
 `bool(invoke(comp, invoke(proj, e), value))` and
 `!bool(invoke(comp, value, invoke(proj, e)))`. Also, for all elements
+`e` of \[`first`, `last`), `bool(comp(e, value))` implies
 `!bool(comp(value, e))` for the overloads in namespace `std`.
 *Returns:* `true` if and only if for some iterator `i` in the range
 \[`first`, `last`),
 `!bool(invoke(comp, invoke(proj, *i), value)) && !bool(invoke(comp, value, invoke(proj, *i)))`
          indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr bool ranges::is_partitioned(I first, S last, Pred pred, Proj proj = {});
 template<input_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   constexpr bool ranges::is_partitioned(R&& r, Pred pred, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+  bool ranges::is_partitioned(Ep&& exec, I first, S last, Pred pred, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  bool ranges::is_partitioned(Ep&& exec, R&& r, Pred pred, Proj proj = {});
 ```
 Let `proj` be `identity{}` for the overloads with no parameter named
 `proj`.
 template<class ForwardIterator, class Predicate>
   constexpr ForwardIterator
     partition(ForwardIterator first, ForwardIterator last, Predicate pred);
 template<class ExecutionPolicy, class ForwardIterator, class Predicate>
   ForwardIterator
+    partition(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last, Predicate pred);
 template<permutable I, sentinel_for<I> S, class Proj = identity,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   constexpr subrange<I>
     ranges::partition(I first, S last, Pred pred, Proj proj = {});
 template<forward_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   requires permutable<iterator_t<R>>
   constexpr borrowed_subrange_t<R>
     ranges::partition(R&& r, Pred pred, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+  subrange<I> ranges::partition(Ep&& exec, I first, S last, Pred pred, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  requires permutable<iterator_t<R>>
+  borrowed_subrange_t<R> ranges::partition(Ep&& exec, R&& r, Pred pred, Proj proj = {});
 ```
 Let `proj` be `identity{}` for the overloads with no parameter named
 `proj` and let E(x) be `bool(invoke(pred, invoke(proj, `x`)))`.
 - `i` for the overloads in namespace `std`.
 - `{i, last}` for the overloads in namespace `ranges`.
 *Complexity:* Let N = `last - first`:
+- For the non-parallel algorithm overloads, exactly N applications of
   the predicate and projection. At most N / 2 swaps if the type of
   `first` meets the *Cpp17BidirectionalIterator* requirements for the
   overloads in namespace `std` or models `bidirectional_iterator` for
   the overloads in namespace `ranges`, and at most N swaps otherwise.
+- For the parallel algorithm overloads, 𝑂(N log N) swaps and 𝑂(N)
   applications of the predicate.
 ``` cpp
 template<class BidirectionalIterator, class Predicate>
   BidirectionalIterator
+ constexpr stable_partition(BidirectionalIterator first, BidirectionalIterator last,
+                               Predicate pred);
 template<class ExecutionPolicy, class BidirectionalIterator, class Predicate>
   BidirectionalIterator
     stable_partition(ExecutionPolicy&& exec,
                      BidirectionalIterator first, BidirectionalIterator last, Predicate pred);
 template<bidirectional_iterator I, sentinel_for<I> S, class Proj = identity,
          indirect_unary_predicate<projected<I, Proj>> Pred>
   requires permutable<I>
+ constexpr subrange<I> ranges::stable_partition(I first, S last, Pred pred, Proj proj = {});
 template<bidirectional_range R, class Proj = identity,
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   requires permutable<iterator_t<R>>
+ constexpr borrowed_subrange_t<R> ranges::stable_partition(R&& r, Pred pred, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+  requires permutable<I>
+  subrange<I>
+    ranges::stable_partition(Ep&& exec, I first, S last, Pred pred, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  requires permutable<iterator_t<R>>
+  borrowed_subrange_t<R>
+    ranges::stable_partition(Ep&& exec, R&& r, Pred pred, Proj proj = {});
 ```
 Let `proj` be `identity{}` for the overloads with no parameter named
 `proj` and let E(x) be `bool(invoke(pred, invoke(proj, `x`)))`.
 - `i` for the overloads in namespace `std`.
 - `{i, last}` for the overloads in namespace `ranges`.
 *Complexity:* Let N = `last - first`:
+- For the non-parallel algorithm overloads, at most N log₂ N swaps, but
+  only 𝑂(N) swaps if there is enough extra memory. Exactly N
   applications of the predicate and projection.
+- For the parallel algorithm overloads, 𝑂(N log N) swaps and 𝑂(N)
   applications of the predicate.
 ``` cpp
 template<class InputIterator, class OutputIterator1, class OutputIterator2, class Predicate>
   constexpr pair<OutputIterator1, OutputIterator2>
          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
   requires indirectly_copyable<iterator_t<R>, O1> &&
            indirectly_copyable<iterator_t<R>, O2>
   constexpr ranges::partition_copy_result<borrowed_iterator_t<R>, O1, O2>
     ranges::partition_copy(R&& r, O1 out_true, O2 out_false, Pred pred, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         random_access_iterator O1, sized_sentinel_for<O1> OutS1,
+         random_access_iterator O2, sized_sentinel_for<O2> OutS2,
+         class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+  requires indirectly_copyable<I, O1> && indirectly_copyable<I, O2>
+  ranges::partition_copy_result<I, O1, O2>
+    ranges::partition_copy(Ep&& exec, I first, S last, O1 out_true, OutS1 last_true,
+                           O2 out_false, OutS2 last_false, Pred pred, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R,
+         sized-random-access-range OutR1, sized-random-access-range OutR2,
+         class Proj = identity,
+         indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+  requires indirectly_copyable<iterator_t<R>, iterator_t<OutR1>> &&
+            indirectly_copyable<iterator_t<R>, iterator_t<OutR2>>
+  ranges::partition_copy_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR1>,
+                                borrowed_iterator_t<OutR2>>
+    ranges::partition_copy(Ep&& exec, R&& r, OutR1&& out_true_r, OutR2&& out_false_r,
+                           Pred pred, Proj proj = {});
 ```
 Let `proj` be `identity{}` for the overloads with no parameter named
 `proj` and let E(x) be `bool(invoke(pred, invoke(proj, `x`)))`.
+For the overloads with no parameters `last_true`, `last_false`,
+`out_true_r`, or `out_false_r`, let
+- M be the number of iterators `i` in \[`first`, `last`) for which
+  E(`*i`) is `true`, and K be `last - first - `M;
+- `last_true` be `out_true + `M, and `last_false` be `out_false + `K.
+For the overloads with parameters `last_true`, `last_false`,
+`out_true_r`, or `out_false_r`, let M be `last_true - out_true` and K be
+`last_false - out_false`.
+Let:
+- `i1` be the iterator in \[`first`, `last`) for which E(`*i1`) is
+  `true` and there are exactly M iterators `j` in \[`first`, `i1`) for
+  which E(`*j`) is `true`, or `last` if no such iterator exists;
+- `i2` be the iterator in \[`first`, `last`) for which E(`*i2`) is
+  `false` and there are exactly K iterators `j` in \[`first`, `i2`) for
+  which E(`*j`) is `false`, or `last` if no such iterator exists;
+- N be min(`i1 - first`,  `i2 - first`).
 *Mandates:* For the overloads in namespace `std`, the expression
 `*first` is writable [[iterator.requirements.general]] to `out_true` and
 `out_false`.
 *Preconditions:* The input range and output ranges do not overlap.
+[*Note 1*: For the parallel algorithm overload in namespace `std`,
+there can be a performance cost if `first`’s value type does not meet
+the *Cpp17CopyConstructible* requirements. For the parallel algorithm
+overloads in namespace `ranges`, there can be a performance cost if
+`first`’s value type does not model `copy_constructible`. — *end note*]
+*Effects:* For each iterator `i` in \[`first`, `first + `N), copies `*i`
+to the output range \[`out_true`, `last_true`) if E(`*i`) is `true`, or
+to the output range \[`out_false`, `last_false`) otherwise.
+*Returns:* Let `o1` be the iterator past the last copied element in the
+output range \[`out_true`, `last_true`), and `o2` be the iterator past
+the last copied element in the output range \[`out_false`,
+`last_false`). Returns:
 - `{o1, o2}` for the overloads in namespace `std`.
+- `{first + `N`, o1, o2}` for the overloads in namespace `ranges`.
+*Complexity:* At most `last - first` applications of `pred` and `proj`.
 ``` cpp
 template<class ForwardIterator, class Predicate>
   constexpr ForwardIterator
     partition_point(ForwardIterator first, ForwardIterator last, Predicate pred);
          class Proj1 = identity, class Proj2 = identity>
   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
   constexpr ranges::merge_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
     ranges::merge(R1&& r1, R2&& r2, O result,
                   Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+         random_access_iterator I2, sized_sentinel_for<I2> S2,
+         random_access_iterator O, sized_sentinel_for<O> OutS, class Comp = ranges::less,
+         class Proj1 = identity, class Proj2 = identity>
+  requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
+  ranges::merge_result<I1, I2, O>
+    ranges::merge(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2, O result, OutS result_last,
+                  Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+         sized-random-access-range OutR, class Comp = ranges::less,
+         class Proj1 = identity, class Proj2 = identity>
+  requires mergeable<iterator_t<R1>, iterator_t<R2>, iterator_t<OutR>, Comp, Proj1, Proj2>
+  ranges::merge_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, borrowed_iterator_t<OutR>>
+    ranges::merge(Ep&& exec, R1&& r1, R2&& r2, OutR&& result_r,
+                  Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
+Let:
+- N be:
+  - `(last1 - first1) + (last2 - first2)` for the overloads with no
+    parameter `result_last` or `result_r`;
+  - min(`(last1 - first1) + (last2 - first2)`,  `result_last - result`)
+    for the overloads with parameters `result_last` or `result_r`;
+- `comp` be `less{}`, `proj1` be `identity{}`, and `proj2` be
+  `identity{}`, for the overloads with no parameters by those names;
+- E(`e1`, `e1`) be
+  `bool(invoke(comp, invoke(proj2, e2), invoke(proj1, e1)))`;
+- K be the smallest integer in \[`0`, `last1 - first1`) such that for
+  the element `e1` in the position `first1 + `K there are at least N - K
+  elements `e2` in \[`first2`, `last2`) for which E(`e1`, `e1`) holds,
+  and be equal to `last1 - first1` if no such integer exists.
+  \[*Note 1*: `first1 + `K points to the position past the last element
+  to be copied. — *end note*]
 *Preconditions:* The ranges \[`first1`, `last1`) and \[`first2`,
 `last2`) are sorted with respect to `comp` and `proj1` or `proj2`,
 respectively. The resulting range does not overlap with either of the
 original ranges.
+*Effects:* Copies the first K elements of the range \[`first1`, `last1`)
+and the first N - K elements of the range \[`first2`, `last2`) into the
+range \[`result`, `result + `N). If an element `a` precedes `b` in an
+input range, `a` is copied into the output range before `b`. If `e1` is
+an element of \[`first1`, `last1`) and `e2` of \[`first2`, `last2`),
+`e2` is copied into the output range before `e1` if and only if
+E(`e1`, `e1`) is `true`.
 *Returns:*
+- `result + `N for the overloads in namespace `std`.
+- `{first1 + `K`, first2 + `N` - `K`, result + `N`}` for the overloads
+  in namespace `ranges`.
 *Complexity:*
+- For the non-parallel algorithm overloads, at most N - 1 comparisons
   and applications of each projection.
+- For the parallel algorithm overloads, 𝑂(N) comparisons and
+  applications of each projection.
 *Remarks:* Stable [[algorithm.stable]].
 ``` cpp
 template<class BidirectionalIterator>
+ constexpr void inplace_merge(BidirectionalIterator first,
                                BidirectionalIterator middle,
                                BidirectionalIterator last);
 template<class ExecutionPolicy, class BidirectionalIterator>
   void inplace_merge(ExecutionPolicy&& exec,
                      BidirectionalIterator first,
                      BidirectionalIterator middle,
                      BidirectionalIterator last);
 template<class BidirectionalIterator, class Compare>
+ constexpr void inplace_merge(BidirectionalIterator first,
                                BidirectionalIterator middle,
                                BidirectionalIterator last, Compare comp);
 template<class ExecutionPolicy, class BidirectionalIterator, class Compare>
   void inplace_merge(ExecutionPolicy&& exec,
                      BidirectionalIterator first,
                      BidirectionalIterator last, Compare comp);
 template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
          class Proj = identity>
   requires sortable<I, Comp, Proj>
+ constexpr I ranges::inplace_merge(I first, I middle, S last, Comp comp = {}, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Comp = ranges::less, class Proj = identity>
+  requires sortable<I, Comp, Proj>
+  I ranges::inplace_merge(Ep&& exec, I first, I middle, S last, Comp comp = {}, Proj proj = {});
 ```
 Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
 no parameters by those names.
 *Returns:* `last` for the overload in namespace `ranges`.
 *Complexity:* Let N = `last - first`:
+- For the non-parallel algorithm overloads, and if enough additional
+  memory is available, at most N - 1 comparisons.
 - Otherwise, 𝑂(N log N) comparisons.
 In either case, twice as many projections as comparisons.
 *Remarks:* Stable [[algorithm.stable]].
 ``` cpp
 template<bidirectional_range R, class Comp = ranges::less, class Proj = identity>
   requires sortable<iterator_t<R>, Comp, Proj>
+ constexpr borrowed_iterator_t<R>
     ranges::inplace_merge(R&& r, iterator_t<R> middle, Comp comp = {}, Proj proj = {});
 ```
 *Effects:* Equivalent to:
 ``` cpp
 return ranges::inplace_merge(ranges::begin(r), middle, ranges::end(r), comp, proj);
 ```
+``` cpp
+template<execution-policy Ep, sized-random-access-range R, class Comp = ranges::less,
+         class Proj = identity>
+  requires sortable<iterator_t<R>, Comp, Proj>
+  borrowed_iterator_t<R>
+    ranges::inplace_merge(Ep&& exec, R&& r, iterator_t<R> middle, Comp comp = {},
+                          Proj proj = {});
+```
+*Effects:* Equivalent to:
+``` cpp
+return ranges::inplace_merge(std::forward<Ep>(exec), ranges::begin(r), middle,
+                             ranges::end(r), comp, proj);
+```
 ### Set operations on sorted structures <a id="alg.set.operations">[[alg.set.operations]]</a>
 #### General <a id="alg.set.operations.general">[[alg.set.operations.general]]</a>
 Subclause [[alg.set.operations]] defines all the basic set operations on
          class Proj2 = identity,
          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
   constexpr bool ranges::includes(R1&& r1, R2&& r2, Comp comp = {},
                                   Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+         random_access_iterator I2, sized_sentinel_for<I2> S2,
+         class Proj1 = identity, class Proj2 = identity,
+         indirect_strict_weak_order<projected<I1, Proj1>, projected<I2, Proj2>> Comp =
+           ranges::less>
+  bool ranges::includes(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2,
+                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+         class Proj1 = identity, class Proj2 = identity,
+         indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
+                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
+  bool ranges::includes(Ep&& exec, R1&& r1, R2&& r2,
+                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
 Let `comp` be `less{}`, `proj1` be `identity{}`, and `proj2` be
 `identity{}`, for the overloads with no parameters by those names.
          class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
   constexpr ranges::set_union_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
     ranges::set_union(R1&& r1, R2&& r2, O result, Comp comp = {},
                       Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+         random_access_iterator I2, sized_sentinel_for<I2> S2,
+         random_access_iterator O, sized_sentinel_for<O> OutS, class Comp = ranges::less,
+         class Proj1 = identity, class Proj2 = identity>
+  requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
+  ranges::set_union_result<I1, I2, O>
+    ranges::set_union(Ep&& exec, I1 first1, S1 last1,
+                      I2 first2, S2 last2, O result, OutS result_last,
+                      Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+         sized-random-access-range OutR, class Comp = ranges::less,
+         class Proj1 = identity, class Proj2 = identity>
+  requires mergeable<iterator_t<R1>, iterator_t<R2>, iterator_t<OutR>, Comp, Proj1, Proj2>
+  ranges::set_union_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>,
+                           borrowed_iterator_t<OutR>>
+    ranges::set_union(Ep&& exec, R1&& r1, R2&& r2, OutR&& result_r, Comp comp = {},
+                      Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
+Let:
+- `comp` be `less{}`, and `proj1` and `proj2` be `identity{}` for the
+  overloads with no parameters by those names;
+- M be `last1 - first1` plus the number of elements in \[`first2`,
+  `last2`) that are not present in \[`first1`, `last1`);
+- `result_last` be `result + `M for the overloads with no parameter
+  `result_last` or `result_r`;
+- N be min(M,  `result_last - result`).
 *Preconditions:* The ranges \[`first1`, `last1`) and \[`first2`,
 `last2`) are sorted with respect to `comp` and `proj1` or `proj2`,
 respectively. The resulting range does not overlap with either of the
 original ranges.
+*Effects:* Constructs a sorted union of N elements from the two ranges;
+that is, the set of elements that are present in one or both of the
+ranges.
+*Returns:*
 - `result_last` for the overloads in namespace `std`.
+- `{last1, last2, result + `N`}` for the overloads in namespace
+  `ranges`, if N is equal to M.
+- Otherwise, `{j1, j2, result_last}` for the overloads in namespace
+  `ranges`, where the iterators `j1` and `j2` point to positions past
+  the last copied or skipped elements in \[`first1`, `last1`) and
+  \[`first2`, `last2`), respectively.
 *Complexity:* At most `2 * ((last1 - first1) + (last2 - first2)) - 1`
 comparisons and applications of each projection.
 *Remarks:* Stable [[algorithm.stable]]. If \[`first1`, `last1`) contains
          class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
   constexpr ranges::set_intersection_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
     ranges::set_intersection(R1&& r1, R2&& r2, O result,
                              Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+         random_access_iterator I2, sized_sentinel_for<I2> S2,
+         random_access_iterator O, sized_sentinel_for<O> OutS, class Comp = ranges::less,
+         class Proj1 = identity, class Proj2 = identity>
+  requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
+  ranges::set_intersection_result<I1, I2, O>
+    ranges::set_intersection(Ep&& exec, I1 first1, S1 last1,
+                      I2 first2, S2 last2, O result, OutS result_last,
+                      Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+         sized-random-access-range OutR, class Comp = ranges::less,
+         class Proj1 = identity, class Proj2 = identity>
+  requires mergeable<iterator_t<R1>, iterator_t<R2>, iterator_t<OutR>, Comp, Proj1, Proj2>
+  ranges::set_intersection_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>,
+                                  borrowed_iterator_t<OutR>>
+    ranges::set_intersection(Ep&& exec, R1&& r1, R2&& r2, OutR&& result_r, Comp comp = {},
+                             Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
+Let:
+- `comp` be `less{}`, and `proj1` and `proj2` be `identity{}` for the
+  overloads with no parameters by those names;
+- M be the number of elements in \[`first1`, `last1`) that are present
+  in \[`first2`, `last2`);
+- `result_last` be `result + `M for the overloads with no parameter
+  `result_last` or `result_r`;
+- N be min(M,  `result_last - result`).
 *Preconditions:* The ranges \[`first1`, `last1`) and \[`first2`,
 `last2`) are sorted with respect to `comp` and `proj1` or `proj2`,
 respectively. The resulting range does not overlap with either of the
 original ranges.
+*Effects:* Constructs a sorted intersection of N elements from the two
 ranges; that is, the set of elements that are present in both of the
 ranges.
+*Returns:*
 - `result_last` for the overloads in namespace `std`.
+- `{last1, last2, result + `N`}` for the overloads in namespace
+  `ranges`, if N is equal to M.
+- Otherwise, `{j1, j2, result_last}` for the overloads in namespace
+  `ranges`, where the iterators `j1` and `j2` point to positions past
+  the last copied or skipped elements in \[`first1`, `last1`) and
+  \[`first2`, `last2`), respectively.
 *Complexity:* At most `2 * ((last1 - first1) + (last2 - first2)) - 1`
 comparisons and applications of each projection.
 *Remarks:* Stable [[algorithm.stable]]. If \[`first1`, `last1`) contains
          class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
   constexpr ranges::set_difference_result<borrowed_iterator_t<R1>, O>
     ranges::set_difference(R1&& r1, R2&& r2, O result,
                            Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+         random_access_iterator I2, sized_sentinel_for<I2> S2,
+         random_access_iterator O, sized_sentinel_for<O> OutS, class Comp = ranges::less,
+         class Proj1 = identity, class Proj2 = identity>
+  requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
+  ranges::set_difference_result<I1, O>
+    ranges::set_difference(Ep&& exec, I1 first1, S1 last1,
+                           I2 first2, S2 last2, O result, OutS result_last,
+                           Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+         sized-random-access-range OutR, class Comp = ranges::less,
+         class Proj1 = identity, class Proj2 = identity>
+  requires mergeable<iterator_t<R1>, iterator_t<R2>, iterator_t<OutR>, Comp, Proj1, Proj2>
+  ranges::set_difference_result<borrowed_iterator_t<R1>, borrowed_iterator_t<OutR>>
+    ranges::set_difference(Ep&& exec, R1&& r1, R2&& r2, OutR&& result_r, Comp comp = {},
+                           Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
+Let:
+- `comp` be `less{}`, and `proj1` and `proj2` be `identity{}` for the
+  overloads with no parameters by those names;
+- M be the number of elements in \[`first1`, `last1`) that are not
+  present in \[`first2`, `last2`);
+- `result_last` be `result + `M for the overloads with no parameter
+  `result_last` or `result_r`;
+- N be min(M,  `result_last - result`).
 *Preconditions:* The ranges \[`first1`, `last1`) and \[`first2`,
 `last2`) are sorted with respect to `comp` and `proj1` or `proj2`,
 respectively. The resulting range does not overlap with either of the
 original ranges.
+*Effects:* Copies N elements of the range \[`first1`, `last1`) which are
+not present in the range \[`first2`, `last2`) to the range \[`result`,
+`result + `N). The elements in the constructed range are sorted.
+*Returns:*
 - `result_last` for the overloads in namespace `std`.
+- `{last1, result + `N`}` for the overloads in namespace `ranges`, if N
+  is equal to M.
+- Otherwise, `{j1, result_last}` for the overloads in namespace
+  `ranges`, where the iterator `j1` points to the position past the last
+  copied or skipped element in \[`first1`, `last1`).
 *Complexity:* At most `2 * ((last1 - first1) + (last2 - first2)) - 1`
 comparisons and applications of each projection.
 *Remarks:* If \[`first1`, `last1`) contains m elements that are
   requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
   constexpr ranges::set_symmetric_difference_result<borrowed_iterator_t<R1>,
                                                     borrowed_iterator_t<R2>, O>
     ranges::set_symmetric_difference(R1&& r1, R2&& r2, O result, Comp comp = {},
                                      Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+         random_access_iterator I2, sized_sentinel_for<I2> S2,
+         random_access_iterator O, sized_sentinel_for<O> OutS, class Comp = ranges::less,
+         class Proj1 = identity, class Proj2 = identity>
+  requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
+  ranges::set_symmetric_difference_result<I1, I2, O>
+    ranges::set_symmetric_difference(Ep&& exec, I1 first1, S1 last1,
+                                     I2 first2, S2 last2, O result, OutS result_last,
+                                     Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+         sized-random-access-range OutR, class Comp = ranges::less,
+         class Proj1 = identity, class Proj2 = identity>
+  requires mergeable<iterator_t<R1>, iterator_t<R2>, iterator_t<OutR>, Comp, Proj1, Proj2>
+  ranges::set_symmetric_difference_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>,
+                                  borrowed_iterator_t<OutR>>
+    ranges::set_symmetric_difference(Ep&& exec, R1&& r1, R2&& r2, OutR&& result_r,
+                                     Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
+Let:
+- `comp` be `less{}`, and `proj1` and `proj2` be `identity{}` for the
+  overloads with no parameters by those names;
+- K be the number of elements in \[`first1`, `last1`) that are not
+  present in \[`first2`, `last2`).
+- M be the number of elements in \[`first2`, `last2`) that are not
+  present in \[`first1`, `last1`).
+- `result_last` be `result + `M` + `K for the overloads with no
+  parameter `result_last` or `result_r`;
+- N be min(K + M,  `result_last - result`).
 *Preconditions:* The ranges \[`first1`, `last1`) and \[`first2`,
 `last2`) are sorted with respect to `comp` and `proj1` or `proj2`,
 respectively. The resulting range does not overlap with either of the
 original ranges.
 *Effects:* Copies the elements of the range \[`first1`, `last1`) that
 are not present in the range \[`first2`, `last2`), and the elements of
 the range \[`first2`, `last2`) that are not present in the range
+\[`first1`, `last1`) to the range \[`result`, `result + `N). The
+elements in the constructed range are sorted.
+*Returns:*
 - `result_last` for the overloads in namespace `std`.
+- `{last1, last2, result + `N`}` for the overloads in namespace
+  `ranges`, if N is equal to M + K.
+- Otherwise, `{j1, j2, result_last}` for the overloads in namespace
+  `ranges`, where the iterators `j1` and `j2` point to positions past
+  the last copied or skipped elements in \[`first1`, `last1`) and
+  \[`first2`, `last2`), respectively.
 *Complexity:* At most `2 * ((last1 - first1) + (last2 - first2)) - 1`
 comparisons and applications of each projection.
 *Remarks:* Stable [[algorithm.stable]]. If \[`first1`, `last1`) contains
 ```
 *Effects:* Equivalent to:
 `return ranges::is_heap_until(first, last, comp, proj) == last;`
+``` cpp
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity,
+         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+  bool ranges::is_heap(Ep&& exec, I first, S last, Comp comp = {}, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+  bool ranges::is_heap(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});
+```
+*Effects:* Equivalent to:
+``` cpp
+return ranges::is_heap_until(std::forward<Ep>(exec), first, last, comp, proj) == last;
+```
 ``` cpp
 template<class RandomAccessIterator>
   constexpr RandomAccessIterator
     is_heap_until(RandomAccessIterator first, RandomAccessIterator last);
 template<class ExecutionPolicy, class RandomAccessIterator>
   constexpr I ranges::is_heap_until(I first, S last, Comp comp = {}, Proj proj = {});
 template<random_access_range R, class Proj = identity,
          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
   constexpr borrowed_iterator_t<R>
     ranges::is_heap_until(R&& r, Comp comp = {}, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity,
+         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+  I ranges::is_heap_until(Ep&& exec, I first, S last, Comp comp = {}, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+  borrowed_iterator_t<R>
+    ranges::is_heap_until(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});
 ```
 Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
 no parameters by those names.
 template<input_range R, class Proj = identity,
          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
   requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
   constexpr range_value_t<R>
     ranges::min(R&& r, Comp comp = {}, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+  requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
+  range_value_t<R>
+    ranges::min(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});
 ```
 *Preconditions:* `ranges::distance(r) > 0`. For the overloads in
 namespace `std`, `T` meets the *Cpp17CopyConstructible* requirements.
 For the first form, `T` meets the *Cpp17LessThanComparable* requirements
 template<input_range R, class Proj = identity,
          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
   requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
   constexpr range_value_t<R>
     ranges::max(R&& r, Comp comp = {}, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+  requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
+  range_value_t<R>
+    ranges::max(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});
 ```
 *Preconditions:* `ranges::distance(r) > 0`. For the overloads in
 namespace `std`, `T` meets the *Cpp17CopyConstructible* requirements.
 For the first form, `T` meets the *Cpp17LessThanComparable* requirements
 template<input_range R, class Proj = identity,
          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
   requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
   constexpr ranges::minmax_result<range_value_t<R>>
     ranges::minmax(R&& r, Comp comp = {}, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+  requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
+  ranges::minmax_result<range_value_t<R>>
+    ranges::minmax(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});
 ```
 *Preconditions:* `ranges::distance(r) > 0`. For the overloads in
 namespace `std`, `T` meets the *Cpp17CopyConstructible* requirements.
 For the first form, type `T` meets the *Cpp17LessThanComparable*
   constexpr I ranges::min_element(I first, S last, Comp comp = {}, Proj proj = {});
 template<forward_range R, class Proj = identity,
          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
   constexpr borrowed_iterator_t<R>
     ranges::min_element(R&& r, Comp comp = {}, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity,
+         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+  I ranges::min_element(Ep&& exec, I first, S last, Comp comp = {}, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R,
+         class Proj = identity,
+         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+  borrowed_iterator_t<R>
+    ranges::min_element(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});
 ```
 Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
 no parameters by those names.
   constexpr I ranges::max_element(I first, S last, Comp comp = {}, Proj proj = {});
 template<forward_range R, class Proj = identity,
          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
   constexpr borrowed_iterator_t<R>
     ranges::max_element(R&& r, Comp comp = {}, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity,
+         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+  I ranges::max_element(Ep&& exec, I first, S last, Comp comp = {}, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R,
+         class Proj = identity,
+         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+  borrowed_iterator_t<R>
+    ranges::max_element(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});
 ```
 Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
 no parameters by those names.
     ranges::minmax_element(I first, S last, Comp comp = {}, Proj proj = {});
 template<forward_range R, class Proj = identity,
          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
   constexpr ranges::minmax_element_result<borrowed_iterator_t<R>>
     ranges::minmax_element(R&& r, Comp comp = {}, Proj proj = {});
+template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
+         class Proj = identity,
+         indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+  ranges::minmax_element_result<I>
+    ranges::minmax_element(Ep&& exec, I first, S last, Comp comp = {}, Proj proj = {});
+template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
+         indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+  ranges::minmax_element_result<borrowed_iterator_t<R>>
+    ranges::minmax_element(Ep&& exec, R&& r, Comp comp = {}, Proj proj = {});
 ```
 *Returns:* `{first, first}` if \[`first`, `last`) is empty, otherwise
 `{m, M}`, where `m` is the first iterator in \[`first`, `last`) such
 that no iterator in the range refers to a smaller element, and where `M`
          indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
                                     projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
   constexpr bool
     ranges::lexicographical_compare(R1&& r1, R2&& r2, Comp comp = {},
                                     Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, random_access_iterator I1, sized_sentinel_for<I1> S1,
+         random_access_iterator I2, sized_sentinel_for<I2> S2,
+         class Proj1 = identity, class Proj2 = identity,
+         indirect_strict_weak_order<projected<I1, Proj1>,
+                                    projected<I2, Proj2>> Comp = ranges::less>
+  bool ranges::lexicographical_compare(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2,
+                                       Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
+template<execution-policy Ep, sized-random-access-range R1, sized-random-access-range R2,
+         class Proj1 = identity, class Proj2 = identity,
+         indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
+                                    projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
+  bool ranges::lexicographical_compare(Ep&& exec, R1&& r1, R2&& r2, Comp comp = {},
+                                       Proj1 proj1 = {}, Proj2 proj2 = {});
 ```
 *Returns:* `true` if and only if the sequence of elements defined by the
 range \[`first1`, `last1`) is lexicographically less than the sequence
 of elements defined by the range \[`first2`, `last2`).
 *Complexity:* At most `(last - first) / 2` swaps.
 ## Header `<numeric>` synopsis <a id="numeric.ops.overview">[[numeric.ops.overview]]</a>
 ``` cpp
+// mostly freestanding
 namespace std {
   // [accumulate], accumulate
   template<class InputIterator, class T>
     constexpr T accumulate(InputIterator first, InputIterator last, T init);
   template<class InputIterator, class T, class BinaryOperation>
   template<class InputIterator, class T, class BinaryOperation>
     constexpr T reduce(InputIterator first, InputIterator last, T init,
                        BinaryOperation binary_op);
   template<class ExecutionPolicy, class ForwardIterator>
     typename iterator_traits<ForwardIterator>::value_type
+      reduce(ExecutionPolicy&& exec,                            // freestanding-deleted, see [algorithms.parallel.overloads]
              ForwardIterator first, ForwardIterator last);
   template<class ExecutionPolicy, class ForwardIterator, class T>
+    T reduce(ExecutionPolicy&& exec,                            // freestanding-deleted, see [algorithms.parallel.overloads]
              ForwardIterator first, ForwardIterator last, T init);
   template<class ExecutionPolicy, class ForwardIterator, class T, class BinaryOperation>
+    T reduce(ExecutionPolicy&& exec,                            // freestanding-deleted, see [algorithms.parallel.overloads]
              ForwardIterator first, ForwardIterator last, T init, BinaryOperation binary_op);
   // [inner.product], inner product
   template<class InputIterator1, class InputIterator2, class T>
     constexpr T inner_product(InputIterator1 first1, InputIterator1 last1,
            class BinaryOperation, class UnaryOperation>
     constexpr T transform_reduce(InputIterator first, InputIterator last, T init,
                                  BinaryOperation binary_op, UnaryOperation unary_op);
   template<class ExecutionPolicy,
            class ForwardIterator1, class ForwardIterator2, class T>
+    T transform_reduce(ExecutionPolicy&& exec,                  // freestanding-deleted, see [algorithms.parallel.overloads]
                        ForwardIterator1 first1, ForwardIterator1 last1,
                        ForwardIterator2 first2, T init);
   template<class ExecutionPolicy,
            class ForwardIterator1, class ForwardIterator2, class T,
            class BinaryOperation1, class BinaryOperation2>
+    T transform_reduce(ExecutionPolicy&& exec,                  // freestanding-deleted, see [algorithms.parallel.overloads]
                        ForwardIterator1 first1, ForwardIterator1 last1,
                        ForwardIterator2 first2, T init,
                        BinaryOperation1 binary_op1, BinaryOperation2 binary_op2);
   template<class ExecutionPolicy, class ForwardIterator, class T,
            class BinaryOperation, class UnaryOperation>
+    T transform_reduce(ExecutionPolicy&& exec,                  // freestanding-deleted, see [algorithms.parallel.overloads]
                        ForwardIterator first, ForwardIterator last, T init,
                        BinaryOperation binary_op, UnaryOperation unary_op);
   // [partial.sum], partial sum
   template<class InputIterator, class OutputIterator>
     constexpr OutputIterator
       exclusive_scan(InputIterator first, InputIterator last,
                      OutputIterator result, T init, BinaryOperation binary_op);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class T>
     ForwardIterator2
+      exclusive_scan(ExecutionPolicy&& exec,                    // freestanding-deleted, see [algorithms.parallel.overloads]
                      ForwardIterator1 first, ForwardIterator1 last,
                      ForwardIterator2 result, T init);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class T,
            class BinaryOperation>
     ForwardIterator2
+      exclusive_scan(ExecutionPolicy&& exec,                    // freestanding-deleted, see [algorithms.parallel.overloads]
                      ForwardIterator1 first, ForwardIterator1 last,
                      ForwardIterator2 result, T init, BinaryOperation binary_op);
   // [inclusive.scan], inclusive scan
   template<class InputIterator, class OutputIterator>
     constexpr OutputIterator
       inclusive_scan(InputIterator first, InputIterator last,
                      OutputIterator result, BinaryOperation binary_op, T init);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
     ForwardIterator2
+      inclusive_scan(ExecutionPolicy&& exec,                    // freestanding-deleted, see [algorithms.parallel.overloads]
                      ForwardIterator1 first, ForwardIterator1 last,
                      ForwardIterator2 result);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class BinaryOperation>
     ForwardIterator2
+      inclusive_scan(ExecutionPolicy&& exec,                    // freestanding-deleted, see [algorithms.parallel.overloads]
                      ForwardIterator1 first, ForwardIterator1 last,
                      ForwardIterator2 result, BinaryOperation binary_op);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class BinaryOperation, class T>
     ForwardIterator2
+      inclusive_scan(ExecutionPolicy&& exec,                    // freestanding-deleted, see [algorithms.parallel.overloads]
                      ForwardIterator1 first, ForwardIterator1 last,
                      ForwardIterator2 result, BinaryOperation binary_op, T init);
   // [transform.exclusive.scan], transform exclusive scan
   template<class InputIterator, class OutputIterator, class T,
                                OutputIterator result, T init,
                                BinaryOperation binary_op, UnaryOperation unary_op);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class T,
            class BinaryOperation, class UnaryOperation>
     ForwardIterator2
+      transform_exclusive_scan(ExecutionPolicy&& exec,          // freestanding-deleted, see [algorithms.parallel.overloads]
                                ForwardIterator1 first, ForwardIterator1 last,
                                ForwardIterator2 result, T init,
                                BinaryOperation binary_op, UnaryOperation unary_op);
   // [transform.inclusive.scan], transform inclusive scan
                                OutputIterator result,
                                BinaryOperation binary_op, UnaryOperation unary_op, T init);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class BinaryOperation, class UnaryOperation>
     ForwardIterator2
+      transform_inclusive_scan(ExecutionPolicy&& exec,          // freestanding-deleted, see [algorithms.parallel.overloads]
                                ForwardIterator1 first, ForwardIterator1 last,
                                ForwardIterator2 result, BinaryOperation binary_op,
                                UnaryOperation unary_op);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class BinaryOperation, class UnaryOperation, class T>
     ForwardIterator2
+      transform_inclusive_scan(ExecutionPolicy&& exec,          // freestanding-deleted, see [algorithms.parallel.overloads]
                                ForwardIterator1 first, ForwardIterator1 last,
                                ForwardIterator2 result,
                                BinaryOperation binary_op, UnaryOperation unary_op, T init);
   // [adjacent.difference], adjacent difference
     constexpr OutputIterator
       adjacent_difference(InputIterator first, InputIterator last,
                           OutputIterator result, BinaryOperation binary_op);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
     ForwardIterator2
+      adjacent_difference(ExecutionPolicy&& exec,               // freestanding-deleted, see [algorithms.parallel.overloads]
                           ForwardIterator1 first, ForwardIterator1 last,
                           ForwardIterator2 result);
   template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
            class BinaryOperation>
     ForwardIterator2
+      adjacent_difference(ExecutionPolicy&& exec,               // freestanding-deleted, see [algorithms.parallel.overloads]
                           ForwardIterator1 first, ForwardIterator1 last,
                           ForwardIterator2 result, BinaryOperation binary_op);
   // [numeric.iota], iota
   template<class ForwardIterator, class T>
   // [numeric.ops.midpoint], midpoint
   template<class T>
     constexpr T midpoint(T a, T b) noexcept;
   template<class T>
     constexpr T* midpoint(T* a, T* b);
+  // [numeric.sat], saturation arithmetic
+  template<class T>
+    constexpr T add_sat(T x, T y) noexcept;
+  template<class T>
+    constexpr T sub_sat(T x, T y) noexcept;
+  template<class T>
+    constexpr T mul_sat(T x, T y) noexcept;
+  template<class T>
+    constexpr T div_sat(T x, T y) noexcept;
+  template<class T, class U>
+    constexpr T saturate_cast(U x) noexcept;
 }
 ```
 ## Generalized numeric operations <a id="numeric.ops">[[numeric.ops]]</a>
 specify requirements throughout [[numeric.ops]] is
 intentional. — *end note*]
 ### Definitions <a id="numerics.defns">[[numerics.defns]]</a>
+Define `GENERALIZED_NONCOMMUTATIVE_SUM(op, a1, …, aN)` as follows:
 - `a1` when `N` is `1`, otherwise
+- `op(GENERALIZED_NONCOMMUTATIVE_SUM(op, a1, …, aK),`
+  `\phantom{op(}GENERALIZED_NONCOMMUTATIVE_SUM(op, aM, …, aN))` for any
+  `K` where 1 < K+1 = M ≤ N.
+Define `GENERALIZED_SUM(op, a1, …, aN)` as
+`GENERALIZED_NONCOMMUTATIVE_SUM(op, b1, …, bN)`, where `b1, …, bN` may
+be any permutation of `a1, …, aN`.
 ### Accumulate <a id="accumulate">[[accumulate]]</a>
 ``` cpp
 template<class InputIterator, class T>
 - `T` meets the *Cpp17MoveConstructible* ([[cpp17.moveconstructible]])
   requirements.
 - `binary_op` neither invalidates iterators or subranges, nor modifies
   elements in the range \[`first`, `last`\].
+*Returns:* *GENERALIZED_SUM*(binary_op, init, \*i, …) for every `i` in
 \[`first`, `last`).
 *Complexity:* 𝑂(`last - first`) applications of `binary_op`.
 [*Note 1*: The difference between `reduce` and `accumulate` is that
   `first2 + (last1 - first1)`\].
 *Returns:*
 ``` cpp
+GENERALIZED_SUM(binary_op1, init, binary_op2(*i, *(first2 + (i - first1))), …)
 ```
 for every iterator `i` in \[`first1`, `last1`).
 *Complexity:* 𝑂(`last1 - first1`) applications each of `binary_op1` and
   elements in the range \[`first`, `last`\].
 *Returns:*
 ``` cpp
+GENERALIZED_SUM(binary_op, init, unary_op(*i), …)
 ```
 for every iterator `i` in \[`first`, `last`).
 *Complexity:* 𝑂(`last - first`) applications each of `unary_op` and
 *Effects:* For each integer `K` in \[`0`, `last - first`) assigns
 through `result + K` the value of:
 ``` cpp
 GENERALIZED_NONCOMMUTATIVE_SUM(
+    binary_op, init, *(first + 0), *(first + 1), …, *(first + K - 1))
 ```
 *Returns:* The end of the resulting range beginning at `result`.
 *Complexity:* 𝑂(`last - first`) applications of `binary_op`.
 *Effects:* For each integer `K` in \[`0`, `last - first`) assigns
 through `result + K` the value of
 - *GENERALIZED_NONCOMMUTATIVE_SUM*(
+      binary_op, init, \*(first + 0), \*(first + 1), …, \*(first + K))
   if `init` is provided, or
 - *GENERALIZED_NONCOMMUTATIVE_SUM*(
+      binary_op, \*(first + 0), \*(first + 1), …, \*(first + K))
   otherwise.
 *Returns:* The end of the resulting range beginning at `result`.
 *Complexity:* 𝑂(`last - first`) applications of `binary_op`.
 through `result + K` the value of:
 ``` cpp
 GENERALIZED_NONCOMMUTATIVE_SUM(
     binary_op, init,
+    unary_op(*(first + 0)), unary_op(*(first + 1)), …, unary_op(*(first + K - 1)))
 ```
 *Returns:* The end of the resulting range beginning at `result`.
 *Complexity:* 𝑂(`last - first`) applications each of `unary_op` and
 *Effects:* For each integer `K` in \[`0`, `last - first`) assigns
 through `result + K` the value of
 - *GENERALIZED_NONCOMMUTATIVE_SUM*(
       binary_op, init,
+      unary_op(\*(first + 0)), unary_op(\*(first + 1)), …,
   unary_op(\*(first + K)))
   if `init` is provided, or
 - *GENERALIZED_NONCOMMUTATIVE_SUM*(
       binary_op,
+      unary_op(\*(first + 0)), unary_op(\*(first + 1)), …,
   unary_op(\*(first + K)))
   otherwise.
 *Returns:* The end of the resulting range beginning at `result`.
 `val` whose type is `T`, initializes it with `*i`, computes
 `binary_op(val, std::move(acc))`, assigns the result to
 `*(result + (i - first))`, and move assigns from `val` to `acc`.
 For the overloads with an `ExecutionPolicy` and a non-empty range,
+performs `*result = *first`. Then, for every `d` in \[`1`,
+`last - first - 1`\], performs
 `*(result + d) = binary_op(*(first + d), *(first + (d - 1)))`.
 *Returns:* `result + (last - first)`.
 *Complexity:* Exactly `(last - first) - 1` applications of the binary
 n for this purpose. — *end note*]
 *Returns:* A pointer to array element $i+\frac{j-i}{2}$ of `x`, where
 the result of the division is truncated towards zero.
+### Saturation arithmetic <a id="numeric.sat">[[numeric.sat]]</a>
+#### Arithmetic functions <a id="numeric.sat.func">[[numeric.sat.func]]</a>
+In the following descriptions, an arithmetic operation is performed as a
+mathematical operation with infinite range and then it is determined
+whether the mathematical result fits into the result type.
+``` cpp
+template<class T>
+  constexpr T add_sat(T x, T y) noexcept;
+```
+*Constraints:* `T` is a signed or unsigned integer
+type [[basic.fundamental]].
+*Returns:* If `x` + `y` is representable as a value of type `T`,
+`x` + `y`; otherwise, either the largest or smallest representable value
+of type `T`, whichever is closer to the value of `x` + `y`.
+``` cpp
+template<class T>
+  constexpr T sub_sat(T x, T y) noexcept;
+```
+*Constraints:* `T` is a signed or unsigned integer
+type [[basic.fundamental]].
+*Returns:* If `x` - `y` is representable as a value of type `T`,
+`x` - `y`; otherwise, either the largest or smallest representable value
+of type `T`, whichever is closer to the value of `x` - `y`.
+``` cpp
+template<class T>
+  constexpr T mul_sat(T x, T y) noexcept;
+```
+*Constraints:* `T` is a signed or unsigned integer
+type [[basic.fundamental]].
+*Returns:* If `x` × `y` is representable as a value of type `T`,
+`x` × `y`; otherwise, either the largest or smallest representable value
+of type `T`, whichever is closer to the value of `x` × `y`.
+``` cpp
+template<class T>
+  constexpr T div_sat(T x, T y) noexcept;
+```
+*Constraints:* `T` is a signed or unsigned integer
+type [[basic.fundamental]].
+*Preconditions:* `y != 0` is `true`.
+*Returns:* If `T` is a signed integer type and
+`x == numeric_limits<T>::min() && y == -1` is `true`,
+`numeric_limits<T>::max()`, otherwise, `x / y`.
+*Remarks:* A function call expression that violates the precondition in
+the *Preconditions* element is not a core constant
+expression [[expr.const]].
+#### Casting <a id="numeric.sat.cast">[[numeric.sat.cast]]</a>
+``` cpp
+template<class R, class T>
+  constexpr R saturate_cast(T x) noexcept;
+```
+*Constraints:* `R` and `T` are signed or unsigned integer
+types [[basic.fundamental]].
+*Returns:* If `x` is representable as a value of type `R`, `x`;
+otherwise, either the largest or smallest representable value of type
+`R`, whichever is closer to the value of `x`.
 ## Specialized `<memory>` algorithms <a id="specialized.algorithms">[[specialized.algorithms]]</a>
 ### General <a id="specialized.algorithms.general">[[specialized.algorithms.general]]</a>
 The contents specified in [[specialized.algorithms]] are declared in the
 Unless otherwise specified, if an exception is thrown in the following
 algorithms, objects constructed by a placement *new-expression*
 [[expr.new]] are destroyed in an unspecified order before allowing the
 exception to propagate.
+[*Note 1*: When new objects are created by the algorithms specified in
+[[specialized.algorithms]], the lifetime ends for any existing objects
+(including potentially-overlapping subobjects [[intro.object]]) in
+storage that is reused [[basic.life]]. — *end note*]
 Some algorithms specified in [[specialized.algorithms]] make use of the
+following exposition-only function templates:
 ``` cpp
 template<class T>
   constexpr void* voidify(T& obj) noexcept {
     return addressof(obj);
   }
+template<class I>
+  decltype(auto) deref-move(I& it) {
+    if constexpr (is_lvalue_reference_v<decltype(*it)>)
+      return std::move(*it);
+    else
+      return *it;
+  }
 ```
 ### Special memory concepts <a id="special.mem.concepts">[[special.mem.concepts]]</a>
 Some algorithms in this subclause are constrained with the following
 [*Note 2*: This concept allows some `sentinel_for`
 [[iterator.concept.sentinel]] operations to throw
 exceptions. — *end note*]
+``` cpp
+template<class S, class I>
+concept nothrow-sized-sentinel-for = // exposition only
+  nothrow-sentinel-for<S, I> &&
+  sized_sentinel_for<S, I>;
+```
+Types `S` and `I` model `nothrow-sized-sentinel-for` only if no
+exceptions are thrown from the `-` operator for valid values of type `I`
+and `S`.
+[*Note 3*: This concept allows some `sized_sentinel_for`
+[[iterator.concept.sizedsentinel]] operations to throw
+exceptions. — *end note*]
 ``` cpp
 template<class R>
 concept nothrow-input-range = // exposition only
   range<R> &&
   nothrow-input-iterator<iterator_t<R>> &&
   nothrow-input-iterator<I> &&
   forward_iterator<I> &&
   nothrow-sentinel-for<I, I>;
 ```
+[*Note 4*: This concept allows some `forward_iterator`
 [[iterator.concept.forward]] operations to throw
 exceptions. — *end note*]
 ``` cpp
 template<class R>
 concept nothrow-forward-range = // exposition only
   nothrow-input-range<R> &&
   nothrow-forward-iterator<iterator_t<R>>;
 ```
+``` cpp
+template<class I>
+concept nothrow-bidirectional-iterator = // exposition only
+  nothrow-forward-iterator<I> &&
+  bidirectional_iterator<I>;
+```
+A type `I` models `nothrow-bidirectional-iterator` only if no exceptions
+are thrown from decrementing valid iterators.
+[*Note 5*: This concept allows some `bidirectional_iterator`
+[[iterator.concept.bidir]] operations to throw
+exceptions. — *end note*]
+``` cpp
+template<class R>
+concept nothrow-bidirectional-range = // exposition only
+  nothrow-forward-range<R> &&
+  nothrow-bidirectional-iterator<iterator_t<R>>;
+```
+``` cpp
+template<class I>
+concept nothrow-random-access-iterator = // exposition only
+  nothrow-bidirectional-iterator<I> &&
+  random_access_iterator<I> &&
+  nothrow-sized-sentinel-for<I, I>;
+```
+A type `I` models `nothrow-random-access-iterator` only if no exceptions
+are thrown from comparisons of valid iterators, or the `-`, `+`, `-=`,
+`+=`, `[]` operators on valid values of type `I` and
+`iter_difference_t<I>`.
+[*Note 6*: This concept allows some `random_access_iterator`
+[[iterator.concept.random.access]] operations to throw
+exceptions. — *end note*]
+``` cpp
+template<class R>
+concept nothrow-random-access-range = // exposition only
+  nothrow-bidirectional-range<R> &&
+  nothrow-random-access-iterator<iterator_t<R>>;
+template<class R>
+concept nothrow-sized-random-access-range = // exposition only
+  nothrow-random-access-range<R> && sized_range<R>;
+```
+A type `R` models `nothrow-sized-random-access-range` only if no
+exceptions are thrown from the call to `ranges::size` on an object of
+type `R`.
 ### `uninitialized_default_construct` <a id="uninitialized.construct.default">[[uninitialized.construct.default]]</a>
 ``` cpp
 template<class NoThrowForwardIterator>
+ constexpr void uninitialized_default_construct(NoThrowForwardIterator first,
+                                                 NoThrowForwardIterator last);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; ++first)
+  ::new (voidify(*first)) iterator_traits<NoThrowForwardIterator>::value_type;
 ```
 ``` cpp
 namespace ranges {
   template<nothrow-forward-iterator I, nothrow-sentinel-for<I> S>
     requires default_initializable<iter_value_t<I>>
+ constexpr I uninitialized_default_construct(I first, S last);
   template<nothrow-forward-range R>
     requires default_initializable<range_value_t<R>>
+ constexpr borrowed_iterator_t<R> uninitialized_default_construct(R&& r);
 }
 ```
 *Effects:* Equivalent to:
 return first;
 ```
 ``` cpp
 template<class NoThrowForwardIterator, class Size>
+ constexpr NoThrowForwardIterator
+    uninitialized_default_construct_n(NoThrowForwardIterator first, Size n);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; n > 0; (void)++first, --n)
+  ::new (voidify(*first)) iterator_traits<NoThrowForwardIterator>::value_type;
 return first;
 ```
 ``` cpp
 namespace ranges {
   template<nothrow-forward-iterator I>
     requires default_initializable<iter_value_t<I>>
+ constexpr I uninitialized_default_construct_n(I first, iter_difference_t<I> n);
 }
 ```
 *Effects:* Equivalent to:
 ### `uninitialized_value_construct` <a id="uninitialized.construct.value">[[uninitialized.construct.value]]</a>
 ``` cpp
 template<class NoThrowForwardIterator>
+ constexpr void uninitialized_value_construct(NoThrowForwardIterator first,
+                                               NoThrowForwardIterator last);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; ++first)
+  ::new (voidify(*first)) iterator_traits<NoThrowForwardIterator>::value_type();
 ```
 ``` cpp
 namespace ranges {
   template<nothrow-forward-iterator I, nothrow-sentinel-for<I> S>
     requires default_initializable<iter_value_t<I>>
+ constexpr I uninitialized_value_construct(I first, S last);
   template<nothrow-forward-range R>
     requires default_initializable<range_value_t<R>>
+ constexpr borrowed_iterator_t<R> uninitialized_value_construct(R&& r);
 }
 ```
 *Effects:* Equivalent to:
 return first;
 ```
 ``` cpp
 template<class NoThrowForwardIterator, class Size>
+ constexpr NoThrowForwardIterator
+    uninitialized_value_construct_n(NoThrowForwardIterator first, Size n);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; n > 0; (void)++first, --n)
+  ::new (voidify(*first)) iterator_traits<NoThrowForwardIterator>::value_type();
 return first;
 ```
 ``` cpp
 namespace ranges {
   template<nothrow-forward-iterator I>
     requires default_initializable<iter_value_t<I>>
+ constexpr I uninitialized_value_construct_n(I first, iter_difference_t<I> n);
 }
 ```
 *Effects:* Equivalent to:
 ### `uninitialized_copy` <a id="uninitialized.copy">[[uninitialized.copy]]</a>
 ``` cpp
 template<class InputIterator, class NoThrowForwardIterator>
+ constexpr NoThrowForwardIterator uninitialized_copy(InputIterator first, InputIterator last,
                                                       NoThrowForwardIterator result);
 ```
 *Preconditions:* `result`+\[0, `(last - first)`) does not overlap with
 \[`first`, `last`).
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; ++result, (void)++first)
+  ::new (voidify(*result)) iterator_traits<NoThrowForwardIterator>::value_type(*first);
 ```
 *Returns:* `result`.
 ``` cpp
 namespace ranges {
   template<input_iterator I, sentinel_for<I> S1,
            nothrow-forward-iterator O, nothrow-sentinel-for<O> S2>
     requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
+ constexpr uninitialized_copy_result<I, O>
       uninitialized_copy(I ifirst, S1 ilast, O ofirst, S2 olast);
   template<input_range IR, nothrow-forward-range OR>
     requires constructible_from<range_value_t<OR>, range_reference_t<IR>>
+ constexpr uninitialized_copy_result<borrowed_iterator_t<IR>, borrowed_iterator_t<OR>>
       uninitialized_copy(IR&& in_range, OR&& out_range);
 }
 ```
 *Preconditions:* \[`ofirst`, `olast`) does not overlap with \[`ifirst`,
 return {std::move(ifirst), ofirst};
 ```
 ``` cpp
 template<class InputIterator, class Size, class NoThrowForwardIterator>
+ constexpr NoThrowForwardIterator uninitialized_copy_n(InputIterator first, Size n,
                                                         NoThrowForwardIterator result);
 ```
 *Preconditions:* `result`+\[0, `n`) does not overlap with `first`+\[0,
 `n`).
 *Effects:* Equivalent to:
 ``` cpp
 for (; n > 0; ++result, (void)++first, --n)
+  ::new (voidify(*result)) iterator_traits<NoThrowForwardIterator>::value_type(*first);
 ```
 *Returns:* `result`.
 ``` cpp
 namespace ranges {
   template<input_iterator I, nothrow-forward-iterator O, nothrow-sentinel-for<O> S>
     requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
+ constexpr uninitialized_copy_n_result<I, O>
       uninitialized_copy_n(I ifirst, iter_difference_t<I> n, O ofirst, S olast);
 }
 ```
 *Preconditions:* \[`ofirst`, `olast`) does not overlap with
 ### `uninitialized_move` <a id="uninitialized.move">[[uninitialized.move]]</a>
 ``` cpp
 template<class InputIterator, class NoThrowForwardIterator>
+ constexpr NoThrowForwardIterator uninitialized_move(InputIterator first, InputIterator last,
                                                       NoThrowForwardIterator result);
 ```
 *Preconditions:* `result`+\[0, `(last - first)`) does not overlap with
 \[`first`, `last`).
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; (void)++result, ++first)
   ::new (voidify(*result))
+    iterator_traits<NoThrowForwardIterator>::value_type(deref-move(first));
 return result;
 ```
 ``` cpp
 namespace ranges {
   template<input_iterator I, sentinel_for<I> S1,
            nothrow-forward-iterator O, nothrow-sentinel-for<O> S2>
     requires constructible_from<iter_value_t<O>, iter_rvalue_reference_t<I>>
+ constexpr uninitialized_move_result<I, O>
       uninitialized_move(I ifirst, S1 ilast, O ofirst, S2 olast);
   template<input_range IR, nothrow-forward-range OR>
     requires constructible_from<range_value_t<OR>, range_rvalue_reference_t<IR>>
+ constexpr uninitialized_move_result<borrowed_iterator_t<IR>, borrowed_iterator_t<OR>>
       uninitialized_move(IR&& in_range, OR&& out_range);
 }
 ```
 *Preconditions:* \[`ofirst`, `olast`) does not overlap with \[`ifirst`,
 \[`ifirst`, `ilast`) are left in a valid, but unspecified
 state. — *end note*]
 ``` cpp
 template<class InputIterator, class Size, class NoThrowForwardIterator>
+ constexpr pair<InputIterator, NoThrowForwardIterator>
     uninitialized_move_n(InputIterator first, Size n, NoThrowForwardIterator result);
 ```
 *Preconditions:* `result`+\[0, `n`) does not overlap with `first`+\[0,
 `n`).
 *Effects:* Equivalent to:
 ``` cpp
 for (; n > 0; ++result, (void)++first, --n)
   ::new (voidify(*result))
+    iterator_traits<NoThrowForwardIterator>::value_type(deref-move(first));
 return {first, result};
 ```
 ``` cpp
 namespace ranges {
   template<input_iterator I, nothrow-forward-iterator O, nothrow-sentinel-for<O> S>
     requires constructible_from<iter_value_t<O>, iter_rvalue_reference_t<I>>
+ constexpr uninitialized_move_n_result<I, O>
       uninitialized_move_n(I ifirst, iter_difference_t<I> n, O ofirst, S olast);
 }
 ```
 *Preconditions:* \[`ofirst`, `olast`) does not overlap with
 ### `uninitialized_fill` <a id="uninitialized.fill">[[uninitialized.fill]]</a>
 ``` cpp
 template<class NoThrowForwardIterator, class T>
+ constexpr void uninitialized_fill(NoThrowForwardIterator first,
+                                    NoThrowForwardIterator last, const T& x);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; first != last; ++first)
+  ::new (voidify(*first)) iterator_traits<NoThrowForwardIterator>::value_type(x);
 ```
 ``` cpp
 namespace ranges {
   template<nothrow-forward-iterator I, nothrow-sentinel-for<I> S, class T>
     requires constructible_from<iter_value_t<I>, const T&>
+ constexpr I uninitialized_fill(I first, S last, const T& x);
   template<nothrow-forward-range R, class T>
     requires constructible_from<range_value_t<R>, const T&>
+ constexpr borrowed_iterator_t<R> uninitialized_fill(R&& r, const T& x);
 }
 ```
 *Effects:* Equivalent to:
 return first;
 ```
 ``` cpp
 template<class NoThrowForwardIterator, class Size, class T>
+ constexpr NoThrowForwardIterator
+    uninitialized_fill_n(NoThrowForwardIterator first, Size n, const T& x);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 for (; n--; ++first)
+  ::new (voidify(*first)) iterator_traits<NoThrowForwardIterator>::value_type(x);
 return first;
 ```
 ``` cpp
 namespace ranges {
   template<nothrow-forward-iterator I, class T>
     requires constructible_from<iter_value_t<I>, const T&>
+ constexpr I uninitialized_fill_n(I first, iter_difference_t<I> n, const T& x);
 }
 ```
 *Effects:* Equivalent to:
   template<class T, class... Args>
     constexpr T* construct_at(T* location, Args&&... args);
 }
 ```
+*Constraints:* `is_unbounded_array_v<T>` is `false`. The expression
 `::new (declval<void*>()) T(declval<Args>()...)` is well-formed when
 treated as an unevaluated operand [[term.unevaluated.operand]].
+*Mandates:* If `is_array_v<T>` is `true`, `sizeof...(Args)` is zero.
 *Effects:* Equivalent to:
 ``` cpp
+if constexpr (is_array_v<T>)
+  return ::new (voidify(*location)) T[1]();
+else
   return ::new (voidify(*location)) T(std::forward<Args>(args)...);
 ```
 ### `destroy` <a id="specialized.destroy">[[specialized.destroy]]</a>
 ``` cpp
 return destroy(counted_iterator(std::move(first), n), default_sentinel).base();
 ```
+## Specialized `<random>` algorithms <a id="alg.rand">[[alg.rand]]</a>
+### General <a id="alg.rand.general">[[alg.rand.general]]</a>
+The contents specified in [[alg.rand]] are declared in the header
+`<random>`.
+### `generate_random` <a id="alg.rand.generate">[[alg.rand.generate]]</a>
+``` cpp
+template<class R, class G>
+  requires output_range<R, invoke_result_t<G&>> && uniform_random_bit_generator<remove_cvref_t<G>>
+constexpr borrowed_iterator_t<R> ranges::generate_random(R&& r, G&& g);
+```
+*Effects:*
+- Calls `g.generate_random(std::forward<R>(r))` if this expression is
+  well-formed.
+- Otherwise, if `R` models `sized_range`, fills `r` with
+  `ranges::size(r)` values of type `invoke_result_t<G&>` by performing
+  an unspecified number of invocations of the form `g()` or
+  `g.generate_random(s)`, if such an expression is well-formed for a
+  value `N` and an object `s` of type `span<invoke_result_t<G&>, N>`.
+  \[*Note 1*: Values of `N` can differ between
+  invocations. — *end note*]
+- Otherwise, calls `ranges::generate(std::forward<R>(r), ref(g))`.
+*Returns:* `ranges::end(r)`.
+*Remarks:* The effects of `generate_random(r, g)` shall be equivalent to
+`ranges::generate(std::forward<R>(r), ref(g))`.
+[*Note 1*: This implies that `g.generate_random(a)` fills `a` with the
+same values as produced by invocation of `g()`. — *end note*]
+``` cpp
+template<class G, output_iterator<invoke_result_t<G&>> O, sentinel_for<O> S>
+  requires uniform_random_bit_generator<remove_cvref_t<G>>
+constexpr O ranges::generate_random(O first, S last, G&& g);
+```
+*Effects:* Equivalent to:
+``` cpp
+return generate_random(subrange<O, S>(std::move(first), last), g);
+```
+``` cpp
+template<class R, class G, class D>
+  requires output_range<R, invoke_result_t<D&, G&>> && invocable<D&, G&> &&
+           uniform_random_bit_generator<remove_cvref_t<G>> &&
+           is_arithmetic_v<invoke_result_t<D&, G&>>
+constexpr borrowed_iterator_t<R> ranges::generate_random(R&& r, G&& g, D&& d);
+```
+*Effects:*
+- Calls `d.generate_random(std::forward<R>(r), g)` if this expression is
+  well-formed.
+- Otherwise, if `R` models `sized_range`, fills `r` with
+  `ranges::size(r)` values of type `invoke_result_t<D&, G&>` by
+  performing an unspecified number of invocations of the form
+  `invoke(d, g)` or `d.generate_random(s, g)`, if such an expression is
+  well-formed for a value `N` and an object `s` of type
+  `span<invoke_result_t<D&, G&>, N>`. \[*Note 2*: Values of N can differ
+  between invocations. — *end note*]
+- Otherwise, calls
+  ``` cpp
+  ranges::generate(std::forward<R>(r), [&d, &g] { return invoke(d, g); });
+  ```
+*Returns:* `ranges::end(r)`.
+*Remarks:* The effects of `generate_random(r, g, d)` shall be equivalent
+to
+``` cpp
+ranges::generate(std::forward<R>(r), [&d, &g] { return invoke(d, g); })
+```
+[*Note 2*: This implies that `d.generate_random(a, g)` fills `a` with
+the values with the same random distribution as produced by invocation
+of `invoke(d, g)`. — *end note*]
+``` cpp
+template<class G, class D, output_iterator<invoke_result_t<D&, G&>> O, sentinel_for<O> S>
+  requires invocable<D&, G&> && uniform_random_bit_generator<remove_cvref_t<G>> &&
+           is_arithmetic_v<invoke_result_t<D&, G&>>
+constexpr O ranges::generate_random(O first, S last, G&& g, D&& d);
+```
+*Effects:* Equivalent to:
+``` cpp
+return generate_random(subrange<O, S>(std::move(first), last), g, d);
+```
 ## C library algorithms <a id="alg.c.library">[[alg.c.library]]</a>
 [*Note 1*: The header `<cstdlib>` declares the functions described in
 this subclause. — *end note*]
 ``` cpp
+void* bsearch(const void* key, void* base, size_t nmemb, size_t size,
               c-compare-pred* compar);
+void* bsearch(const void* key, void* base, size_t nmemb, size_t size,
+              compare-pred* compar);
+const void* bsearch(const void* key, const void* base, size_t nmemb, size_t size,
+                    c-compare-pred* compar);
+const void* bsearch(const void* key, const void* base, size_t nmemb, size_t size,
                     compare-pred* compar);
 void qsort(void* base, size_t nmemb, size_t size, c-compare-pred* compar);
 void qsort(void* base, size_t nmemb, size_t size, compare-pred* compar);
 ```
 standard library.
 *Throws:* Any exception thrown by `compar`
 [[res.on.exception.handling]].
+See also: ISO C 7.24.6
 <!-- Link reference definitions -->
 [accumulate]: #accumulate
 [adjacent.difference]: #adjacent.difference
 [alg.adjacent.find]: #alg.adjacent.find
 [alg.find.end]: #alg.find.end
 [alg.find.first.of]: #alg.find.first.of
 [alg.find.last]: #alg.find.last
 [alg.fold]: #alg.fold
 [alg.foreach]: #alg.foreach
+[alg.func.obj]: library.md#alg.func.obj
 [alg.generate]: #alg.generate
 [alg.heap.operations]: #alg.heap.operations
 [alg.heap.operations.general]: #alg.heap.operations.general
 [alg.is.permutation]: #alg.is.permutation
 [alg.lex.comparison]: #alg.lex.comparison
 [alg.merge]: #alg.merge
 [alg.min.max]: #alg.min.max
+[alg.mismatch]: #alg.mismatch
 [alg.modifying.operations]: #alg.modifying.operations
 [alg.move]: #alg.move
 [alg.none.of]: #alg.none.of
 [alg.nonmodifying]: #alg.nonmodifying
 [alg.nth.element]: #alg.nth.element
 [alg.partitions]: #alg.partitions
 [alg.permutation.generators]: #alg.permutation.generators
+[alg.rand]: #alg.rand
+[alg.rand.general]: #alg.rand.general
+[alg.rand.generate]: #alg.rand.generate
 [alg.random.sample]: #alg.random.sample
 [alg.random.shuffle]: #alg.random.shuffle
 [alg.remove]: #alg.remove
 [alg.replace]: #alg.replace
 [alg.reverse]: #alg.reverse
 [algorithms.parallel.overloads]: #algorithms.parallel.overloads
 [algorithms.parallel.user]: #algorithms.parallel.user
 [algorithms.requirements]: #algorithms.requirements
 [algorithms.results]: #algorithms.results
 [algorithms.summary]: #algorithms.summary
+[atomics.order]: thread.md#atomics.order
 [basic.compound]: basic.md#basic.compound
+[basic.fundamental]: basic.md#basic.fundamental
+[basic.life]: basic.md#basic.life
 [bidirectional.iterators]: iterators.md#bidirectional.iterators
 [binary.search]: #binary.search
 [class.conv]: class.md#class.conv
 [concept.booleantestable]: concepts.md#concept.booleantestable
 [containers]: containers.md#containers
 [cpp17.copyconstructible]: #cpp17.copyconstructible
 [cpp17.lessthancomparable]: #cpp17.lessthancomparable
 [cpp17.moveassignable]: #cpp17.moveassignable
 [cpp17.moveconstructible]: #cpp17.moveconstructible
 [equal.range]: #equal.range
+[except.terminate]: except.md#except.terminate
 [exclusive.scan]: #exclusive.scan
+[execpol]: #execpol
+[execpol.general]: #execpol.general
+[execpol.objects]: #execpol.objects
+[execpol.par]: #execpol.par
+[execpol.parunseq]: #execpol.parunseq
+[execpol.seq]: #execpol.seq
+[execpol.type]: #execpol.type
+[execpol.unseq]: #execpol.unseq
+[expr.const]: expr.md#expr.const
 [expr.new]: expr.md#expr.new
 [forward.iterators]: iterators.md#forward.iterators
 [function.objects]: utilities.md#function.objects
 [includes]: #includes
 [inclusive.scan]: #inclusive.scan
 [inner.product]: #inner.product
 [input.iterators]: iterators.md#input.iterators
 [intro.execution]: basic.md#intro.execution
+[intro.object]: basic.md#intro.object
 [intro.progress]: basic.md#intro.progress
 [is.heap]: #is.heap
 [is.sorted]: #is.sorted
 [iterator.concept.bidir]: iterators.md#iterator.concept.bidir
 [iterator.concept.forward]: iterators.md#iterator.concept.forward
 [iterator.concept.sizedsentinel]: iterators.md#iterator.concept.sizedsentinel
 [iterator.requirements]: iterators.md#iterator.requirements
 [iterator.requirements.general]: iterators.md#iterator.requirements.general
 [lower.bound]: #lower.bound
 [make.heap]: #make.heap
 [multiset]: containers.md#multiset
 [numeric.iota]: #numeric.iota
 [numeric.ops]: #numeric.ops
 [numeric.ops.gcd]: #numeric.ops.gcd
 [numeric.ops.general]: #numeric.ops.general
 [numeric.ops.lcm]: #numeric.ops.lcm
 [numeric.ops.midpoint]: #numeric.ops.midpoint
 [numeric.ops.overview]: #numeric.ops.overview
+[numeric.sat]: #numeric.sat
+[numeric.sat.cast]: #numeric.sat.cast
+[numeric.sat.func]: #numeric.sat.func
 [numerics.defns]: #numerics.defns
 [output.iterators]: iterators.md#output.iterators
 [partial.sort]: #partial.sort
 [partial.sort.copy]: #partial.sort.copy
 [partial.sum]: #partial.sum
 [specialized.algorithms.general]: #specialized.algorithms.general
 [specialized.construct]: #specialized.construct
 [specialized.destroy]: #specialized.destroy
 [stable.sort]: #stable.sort
 [swappable.requirements]: library.md#swappable.requirements
 [term.unevaluated.operand]: expr.md#term.unevaluated.operand
 [thread.jthread.class]: thread.md#thread.jthread.class
 [thread.thread.class]: thread.md#thread.thread.class
 [transform.exclusive.scan]: #transform.exclusive.scan
 [transform.inclusive.scan]: #transform.inclusive.scan

Diff to HTML by rtfpessoa