[algorithms] - C++20 → C++23

Files changed (1) hide show

tmp/tmpdrs0e8n1/{from.md → to.md} +899 -329

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

@@ -14,11 +14,12 @@ operations, and algorithms from the ISO C library, as summarized in
 | Subclause                    |                                   | Header        |
 | ---------------------------- | --------------------------------- | ------------- |
 | [[algorithms.requirements]]  | Algorithms requirements           |               |
 | [[algorithms.parallel]]      | Parallel algorithms               |               |
-| [[alg.nonmodifying]] | Non-modifying sequence operations | `<algorithm>` |
 | [[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>`   |
@@ -63,94 +64,98 @@ the specification requires such modification.
 Throughout this Clause, where the template parameters are not
 constrained, the names of template parameters are used to express type
 requirements.
 - If an algorithm’s template parameter is named `InputIterator`,
   `InputIterator1`, or `InputIterator2`, the template argument shall
   meet the *Cpp17InputIterator* requirements [[input.iterators]].
 - If an algorithm’s template parameter is named `OutputIterator`,
   `OutputIterator1`, or `OutputIterator2`, the template argument shall
   meet the *Cpp17OutputIterator* requirements [[output.iterators]].
 - If an algorithm’s template parameter is named `ForwardIterator`,
-  `ForwardIterator1`, or `ForwardIterator2`, the template argument shall
-  meet the *Cpp17ForwardIterator* requirements [[forward.iterators]].
 - If an algorithm’s template parameter is named
-  `NoThrowForwardIterator`, the template argument shall meet the
- *Cpp17ForwardIterator* requirements [[forward.iterators]], and is
- required to have the property that no exceptions are thrown from
-  increment, assignment, or comparison of, or indirection through, valid
-  iterators.
 - If an algorithm’s template parameter is named `BidirectionalIterator`,
   `BidirectionalIterator1`, or `BidirectionalIterator2`, the template
   argument shall meet the *Cpp17BidirectionalIterator* requirements
-  [[bidirectional.iterators]].
 - If an algorithm’s template parameter is named `RandomAccessIterator`,
   `RandomAccessIterator1`, or `RandomAccessIterator2`, the template
   argument shall meet the *Cpp17RandomAccessIterator* requirements
-  [[random.access.iterators]].
-If an algorithm’s *Effects:* element specifies that a value pointed to
-by any iterator passed as an argument is modified, then that algorithm
-has an additional type requirement: The type of that argument shall meet
-the requirements of a mutable iterator [[iterator.requirements]].
-[*Note 1*: This requirement does not affect arguments that are named
-`OutputIterator`, `OutputIterator1`, or `OutputIterator2`, because
-output iterators must always be mutable, nor does it affect arguments
-that are constrained, for which mutability requirements are expressed
-explicitly. — *end note*]
-Both in-place and copying versions are provided for certain algorithms.
-[^1] When such a version is provided for *algorithm* it is called
 *algorithm`_copy`*. Algorithms that take predicates end with the suffix
 `_if` (which follows the suffix `_copy`).
 When not otherwise constrained, the `Predicate` parameter is used
 whenever an algorithm expects a function object [[function.objects]]
 that, when applied to the result of dereferencing the corresponding
-iterator, returns a value testable as `true`. In other words, if an
-algorithm takes `Predicate pred` as its argument and `first` as its
-iterator argument with value type `T`, it should work correctly in the
-construct `pred(*first)` contextually converted to `bool` [[conv]]. The
-function object `pred` shall not apply any non-constant function through
-the dereferenced iterator. Given a glvalue `u` of type (possibly
-`const`) `T` that designates the same object as `*first`, `pred(u)`
-shall be a valid expression that is equal to `pred(*first)`.
 When not otherwise constrained, the `BinaryPredicate` parameter is used
-whenever an algorithm expects a function object that when applied to the
-result of dereferencing two corresponding iterators or to dereferencing
-an iterator and type `T` when `T` is part of the signature returns a
-value testable as `true`. In other words, if an algorithm takes
 `BinaryPredicate binary_pred` as its argument and `first1` and `first2`
-as its iterator arguments with respective value types `T1` and `T2`, it
-should work correctly in the construct `binary_pred(*first1, *first2)`
-contextually converted to `bool` [[conv]]. Unless otherwise specified,
-`BinaryPredicate` always takes the first iterator’s `value_type` as its
-first argument, that is, in those cases when `T value` is part of the
-signature, it should work correctly in the construct
-`binary_pred(*first1, value)` contextually converted to `bool` [[conv]].
-`binary_pred` shall not apply any non-constant function through the
-dereferenced iterators. Given a glvalue `u` of type (possibly `const`)
-`T1` that designates the same object as `*first1`, and a glvalue `v` of
-type (possibly `const`) `T2` that designates the same object as
-`*first2`, `binary_pred(u, *first2)`, `binary_pred(*first1, v)`, and
 `binary_pred(u, v)` shall each be a valid expression that is equal to
 `binary_pred(*first1, *first2)`, and `binary_pred(u, value)` shall be a
 valid expression that is equal to `binary_pred(*first1, value)`.
 The parameters `UnaryOperation`, `BinaryOperation`, `BinaryOperation1`,
 and `BinaryOperation2` are used whenever an algorithm expects a function
 object [[function.objects]].
 [*Note 2*: Unless otherwise specified, algorithms that take function
-objects as arguments are permitted to copy those function objects
-freely. Programmers for whom object identity is important should
-consider using a wrapper class that points to a noncopied implementation
-object such as `reference_wrapper<T>` [[refwrap]], or some equivalent
-solution. — *end note*]
 When the description of an algorithm gives an expression such as
 `*first == value` for a condition, the expression shall evaluate to
 either `true` or `false` in boolean contexts.
@@ -182,25 +187,31 @@ 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 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 number and order of deducible template parameters for algorithm
-declarations are unspecified, except where explicitly stated otherwise.
-[*Note 3*: Consequently, the algorithms may not be called with
-explicitly-specified template argument lists. — *end note*]
 ## Parallel algorithms <a id="algorithms.parallel">[[algorithms.parallel]]</a>
 ### Preamble <a id="algorithms.parallel.defns">[[algorithms.parallel.defns]]</a>
@@ -273,13 +284,13 @@ different threads of execution.
 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 could be formed by the 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`
@@ -299,16 +310,16 @@ argument is modified. — *end note*]
 Unless otherwise stated, implementations may make arbitrary copies of
 elements (with type `T`) from sequences where
 `is_trivially_copy_constructible_v<T>` and
 `is_trivially_destructible_v<T>` are `true`.
-[*Note 2*: This implies that user-supplied function objects should not
-rely on object identity of arguments for such input sequences. Users for
-whom the object identity of the arguments to these function objects is
-important should consider using a wrapping iterator that returns a
-non-copied implementation object such as `reference_wrapper<T>`
-[[refwrap]] or some equivalent solution. — *end note*]
 The invocations of element access functions in parallel algorithms
 invoked with an execution policy object of type
 `execution::sequenced_policy` all occur in the calling thread of
 execution.
@@ -320,18 +331,18 @@ The invocations of element access functions in parallel algorithms
 invoked with an execution policy object of type
 `execution::unsequenced_policy` are permitted to execute in an unordered
 fashion in the calling thread of execution, unsequenced with respect to
 one another in the calling thread of execution.
-[*Note 4*: This means that multiple function object invocations may be
 interleaved on a single thread of execution, which overrides the usual
 guarantee from [[intro.execution]] that function executions do not
 overlap with one another. — *end note*]
 The behavior of a program is undefined if it invokes a
 vectorization-unsafe standard library function from user code called
-from a `execution::unsequenced_policy` algorithm.
 [*Note 5*: Because `execution::unsequenced_policy` allows the execution
 of element access functions to be interleaved on a single thread of
 execution, blocking synchronization, including the use of mutexes, risks
 deadlock. — *end note*]
@@ -410,18 +421,18 @@ unordered fashion in unspecified threads of execution, and unsequenced
 with respect to one another within each thread of execution. These
 threads of execution are either the invoking thread of execution or
 threads of execution implicitly created by the library; the latter will
 provide weakly parallel forward progress guarantees.
-[*Note 7*: This means that multiple function object invocations may be
 interleaved on a single thread of execution, which overrides the usual
 guarantee from [[intro.execution]] that function executions do not
 overlap with one another. — *end note*]
 The behavior of a program is undefined if it invokes a
 vectorization-unsafe standard library function from user code called
-from a `execution::parallel_unsequenced_policy` algorithm.
 [*Note 8*: Because `execution::parallel_unsequenced_policy` allows the
 execution of element access functions to be interleaved on a single
 thread of execution, blocking synchronization, including the use of
 mutexes, risks deadlock. — *end note*]
@@ -489,11 +500,11 @@ 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>
 namespace std {
   namespace ranges {
     // [algorithms.results], algorithm result types
     template<class I, class F>
@@ -514,10 +525,16 @@ namespace std {
     template<class T>
       struct min_max_result;
     template<class I>
       struct in_found_result;
   }
   // [alg.nonmodifying], non-modifying sequence operations
   // [alg.all.of], all of
   template<class InputIterator, class Predicate>
@@ -565,10 +582,33 @@ namespace std {
     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.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]
@@ -650,10 +690,33 @@ namespace std {
              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.end], find end
   template<class ForwardIterator1, class ForwardIterator2>
     constexpr ForwardIterator1
       find_end(ForwardIterator1 first1, ForwardIterator1 last1,
                ForwardIterator2 first2, ForwardIterator2 last2);
@@ -715,19 +778,17 @@ namespace std {
   namespace ranges {
     template<input_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 I1 find_first_of(I1 first1, S1 last1, I2 first2, S2 last2,
-                                 Pred pred = {},
                                  Proj1 proj1 = {}, Proj2 proj2 = {});
     template<input_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_iterator_t<R1>
-        find_first_of(R1&& r1, R2&& r2,
-                      Pred pred = {},
                       Proj1 proj1 = {}, Proj2 proj2 = {});
   }
   // [alg.adjacent.find], adjacent find
   template<class ForwardIterator>
@@ -980,12 +1041,11 @@ namespace std {
       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);
@@ -1014,10 +1074,125 @@ namespace std {
   template<class ForwardIterator, class Searcher>
     constexpr ForwardIterator
       search(ForwardIterator first, ForwardIterator last, const Searcher& searcher);
   // [alg.modifying.operations], mutating sequence operations
   // [alg.copy], copy
   template<class InputIterator, class OutputIterator>
     constexpr OutputIterator copy(InputIterator first, InputIterator last,
                                   OutputIterator result);
@@ -1661,20 +1836,37 @@ namespace std {
   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);
   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);
   // [alg.sorting], sorting and related operations
   // [alg.sort], sorting
   template<class RandomAccessIterator>
     constexpr void sort(RandomAccessIterator first, RandomAccessIterator last);
   template<class RandomAccessIterator, class Compare>
@@ -1723,26 +1915,22 @@ namespace std {
       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,
              class Proj = identity>
@@ -2886,10 +3074,46 @@ namespace std::ranges {
       requires convertible_to<I, I2>
     constexpr operator in_found_result<I2>() && {
       return {std::move(in), found};
     }
   };
 }
 ```
 ## Non-modifying sequence operations <a id="alg.nonmodifying">[[alg.nonmodifying]]</a>
@@ -2978,10 +3202,40 @@ Let E be:
 \[`first`, `last`), and `true` otherwise.
 *Complexity:* At most `last - first` applications of the predicate and
 any projection.
 ### For each <a id="alg.foreach">[[alg.foreach]]</a>
 ``` cpp
 template<class InputIterator, class Function>
   constexpr Function for_each(InputIterator first, InputIterator last, Function f);
@@ -2996,11 +3250,11 @@ requirements ([[cpp17.moveconstructible]]).
 *Effects:* Applies `f` to the result of dereferencing every iterator in
 the range \[`first`, `last`), starting from `first` and proceeding to
 `last - 1`.
 [*Note 2*: If the type of `first` meets the requirements of a mutable
-iterator, `f` may apply non-constant functions through the dereferenced
 iterator. — *end note*]
 *Returns:* `f`.
 *Complexity:* Applies `f` exactly `last - first` times.
@@ -3019,22 +3273,22 @@ requirements.
 *Effects:* Applies `f` to the result of dereferencing every iterator in
 the range \[`first`, `last`).
 [*Note 3*: If the type of `first` meets the requirements of a mutable
-iterator, `f` may apply non-constant functions through the dereferenced
 iterator. — *end note*]
 *Complexity:* Applies `f` 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.
 [*Note 4*: Does not return a copy of its `Function` parameter, since
-parallelization may not permit efficient state
 accumulation. — *end note*]
 ``` cpp
 template<input_iterator I, sentinel_for<I> S, class Proj = identity,
          indirectly_unary_invocable<projected<I, Proj>> Fun>
@@ -3049,11 +3303,11 @@ template<input_range R, class Proj = identity,
 *Effects:* Calls `invoke(f, invoke(proj, *i))` for every iterator `i` in
 the range \[`first`, `last`), starting from `first` and proceeding to
 `last - 1`.
 [*Note 5*: If the result of `invoke(proj, *i)` is a mutable reference,
-`f` may apply non-constant functions. — *end note*]
 *Returns:* `{last, std::move(f)}`.
 *Complexity:* Applies `f` and `proj` exactly `last - first` times.
@@ -3066,25 +3320,23 @@ the range \[`first`, `last`), starting from `first` and proceeding to
 template<class InputIterator, class Size, class Function>
   constexpr InputIterator for_each_n(InputIterator first, Size n, Function f);
 ```
 *Mandates:* The type `Size` is convertible to an integral
-type ([[conv.integral]], [[class.conv]]).
-*Preconditions:* `Function` meets the *Cpp17MoveConstructible*
-requirements.
 [*Note 7*: `Function` need not meet the requirements of
 *Cpp17CopyConstructible*. — *end note*]
-*Preconditions:* `n >= 0` is `true`.
 *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` may apply non-constant functions through the dereferenced
 iterator. — *end note*]
 *Returns:* `first + n`.
 *Remarks:* If `f` returns a result, the result is ignored.
@@ -3094,22 +3346,20 @@ template<class ExecutionPolicy, class ForwardIterator, class Size, class Functio
   ForwardIterator for_each_n(ExecutionPolicy&& exec, ForwardIterator first, Size n,
                              Function f);
 ```
 *Mandates:* The type `Size` is convertible to an integral
-type ([[conv.integral]], [[class.conv]]).
-*Preconditions:* `Function` meets the *Cpp17CopyConstructible*
-requirements.
-*Preconditions:* `n >= 0` is `true`.
 *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` may apply non-constant functions through the dereferenced
 iterator. — *end note*]
 *Returns:* `first + n`.
 *Remarks:* If `f` returns a result, the result is ignored.
@@ -3128,11 +3378,11 @@ template<input_iterator I, class Proj = identity,
 *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` may apply non-constant functions. — *end note*]
 *Returns:* `{first + n, std::move(f)}`.
 *Remarks:* If `f` returns a result, the result is ignored.
@@ -3200,10 +3450,47 @@ Let E be:
 which E is `true`. Returns `last` if no such iterator is found.
 *Complexity:* At most `last - first` applications of the corresponding
 predicate and any projection.
 ### Find end <a id="alg.find.end">[[alg.find.end]]</a>
 ``` cpp
 template<class ForwardIterator1, class ForwardIterator2>
   constexpr ForwardIterator1
@@ -3580,22 +3867,28 @@ Let:
   - `invoke(pred, invoke(proj1, *i), invoke(proj2, *(first2 + (i - first1))))`
     for the overloads with parameter `proj1`.
 *Returns:* If `last1 - first1 != last2 - first2`, return `false`.
 Otherwise return `true` if E holds for every iterator `i` in the range
-\[`first1`, `last1`) Otherwise, returns `false`.
-*Complexity:* If the types of `first1`, `last1`, `first2`, and `last2`:
-- meet the *Cpp17RandomAccessIterator*
-  requirements [[random.access.iterators]] for the overloads in
- namespace `std`;
-- pairwise model `sized_sentinel_for` [[iterator.concept.sizedsentinel]]
-  for the overloads in namespace `ranges`,
-and `last1 - first1 != last2 - first2`, 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`,
@@ -3619,34 +3912,32 @@ template<class ForwardIterator1, class ForwardIterator2,
   constexpr bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                                 ForwardIterator2 first2, ForwardIterator2 last2,
                                 BinaryPredicate pred);
 ```
 *Mandates:* `ForwardIterator1` and `ForwardIterator2` have the same
 value type.
 *Preconditions:* The comparison function is an equivalence relation.
-*Remarks:* If `last2` was not given in the argument list, it denotes
-`first2 + (last1 - first1)` below.
 *Returns:* If `last1 - first1 != last2 - first2`, return `false`.
 Otherwise return `true` if there exists a permutation of the elements in
-the range \[`first2`, `first2 + (last1 - first1)`), beginning with
-`ForwardIterator2 begin`, such that `equal(first1, last1, begin)`
-returns `true` or `equal(first1, last1, begin, pred)` returns `true`;
-otherwise, returns `false`.
 *Complexity:* No applications of the corresponding predicate if
 `ForwardIterator1` and `ForwardIterator2` meet the requirements of
 random access iterators and `last1 - first1 != last2 - first2`.
 Otherwise, exactly `last1 - first1` applications of the corresponding
-predicate if `equal(first1, last1, first2, last2)` would return `true`
-if `pred` was not given in the argument list or
-`equal(first1, last1, first2, last2, pred)` would return `true` if
-`pred` was given in the argument list; otherwise, at worst 𝑂(N^2), where
-N has the value `last1 - first1`.
 ``` cpp
 template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2,
          sentinel_for<I2> S2, class Proj1 = identity, class Proj2 = identity,
          indirect_equivalence_relation<projected<I1, Proj1>,
@@ -3669,13 +3960,16 @@ 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:
   - `S1` and `I1` model `sized_sentinel_for<S1, I1>`,
   - `S2` and `I2` model `sized_sentinel_for<S2, I2>`, and
-- `last1 - first1 != last2 - first2`.
 Otherwise, exactly `last1 - first1` applications of the corresponding
 predicate and projections if
 `ranges::equal(first1, last1, first2, last2, pred, proj1, proj2)` would
 return `true`; otherwise, at worst 𝑂(N^2), where N has the value
@@ -3775,17 +4069,17 @@ template<class ExecutionPolicy, class ForwardIterator, class Size, class T,
              Size count, const T& value,
              BinaryPredicate pred);
 ```
 *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
@@ -3821,10 +4115,207 @@ template<class ForwardIterator, class Searcher>
 *Effects:* Equivalent to: `return searcher(first, last).first;`
 *Remarks:* `Searcher` need not meet the *Cpp17CopyConstructible*
 requirements.
 ## Mutating sequence operations <a id="alg.modifying.operations">[[alg.modifying.operations]]</a>
 ### Copy <a id="alg.copy">[[alg.copy]]</a>
 ``` cpp
@@ -3890,14 +4381,14 @@ template<input_iterator I, weakly_incrementable O>
 ```
 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
-`*(result + i) = *(first + i)`.
 *Returns:*
 - `result + `N for the overloads in namespace `std`.
 - `{first + `N`, result + `N`}` for the overload in namespace `ranges`.
@@ -3936,11 +4427,11 @@ 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 may 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
@@ -3977,11 +4468,13 @@ Let N be `last - first`.
 *Preconditions:* `result` is not in the range (`first`, `last`).
 *Effects:* Copies elements in the range \[`first`, `last`) into the
 range \[`result - `N, `result`) starting from `last - 1` and proceeding
-to `first`. [^2] For each positive integer n ≤ N, performs
 `*(result - `n`) = *(last - `n`)`.
 *Returns:*
 - `result - `N for the overload in namespace `std`.
@@ -4074,12 +4567,13 @@ 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 - `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`.
@@ -4397,11 +4891,10 @@ 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>
@@ -4411,12 +4904,12 @@ template<class T, output_iterator<const T&> O>
 Let N be max(0, `n`) for the `fill_n` algorithms, and `last - first` for
 the `fill` algorithms.
 *Mandates:* The expression `value` is
 writable [[iterator.requirements.general]] to the output iterator. The
-type `Size` is convertible to an integral type ([[conv.integral]],
-[[class.conv]]).
 *Effects:* Assigns `value` through all the iterators in the range
 \[`first`, `first + `N).
 *Returns:* `first + `N.
@@ -4453,11 +4946,11 @@ template<input_or_output_iterator O, copy_constructible F>
 Let N be max(0, `n`) for the `generate_n` algorithms, and `last - first`
 for the `generate` algorithms.
 *Mandates:* `Size` is convertible to an integral
-type ([[conv.integral]], [[class.conv]]).
 *Effects:* Assigns the result of successive evaluations of `gen()`
 through each iterator in the range \[`first`, `first + `N).
 *Returns:* `first + `N.
@@ -4518,15 +5011,15 @@ the range \[`first`, `last`) for which E holds.
 *Returns:* Let j be the end of the resulting range. Returns:
 - j for the overloads in namespace `std`.
 - `{`j`, last}` for the overloads in namespace `ranges`.
-*Remarks:* Stable [[algorithm.stable]].
 *Complexity:* Exactly `last - first` applications of the corresponding
 predicate and any projection.
 [*Note 1*: Each element in the range \[`ret`, `last`), where `ret` is
 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*]
@@ -4590,14 +5083,14 @@ Let N be the number of elements in \[`first`, `last`) for which E is
 `result`.
 *Preconditions:* The ranges \[`first`, `last`) and \[`result`,
 `result + (last - first)`) do not overlap.
-[*Note 2*: For the overloads with an `ExecutionPolicy`, there may 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:*
@@ -4642,11 +5135,11 @@ and let E be
 - `bool(pred(*(i - 1), *i))` for the overloads in namespace `std`;
 - `bool(invoke(comp, invoke(proj, *(i - 1)), invoke(proj, *i)))` for the
   overloads in namespace `ranges`.
-*Preconditions:* For the overloads in namepace `std`, `pred` is an
 equivalence relation and the type of `*first` meets the
 *Cpp17MoveAssignable* requirements ([[cpp17.moveassignable]]).
 *Effects:* For a nonempty range, eliminates all but the first element
 from every consecutive group of equivalent elements referred to by the
@@ -4717,19 +5210,19 @@ parameter `pred`, and let E be
 - 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` meets the
- *Cpp17ForwardIterator* requirements, 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 may 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
@@ -4901,11 +5394,11 @@ template<forward_range R, weakly_incrementable O>
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return ranges::rotate_copy(ranges::begin(r), middle, ranges::end(r), result);
 ```
 ### Sample <a id="alg.random.sample">[[alg.random.sample]]</a>
 ``` cpp
@@ -4938,11 +5431,11 @@ overload in namespace `std`:
   requirements [[input.iterators]].
 - `SampleIterator` meets the *Cpp17OutputIterator*
   requirements [[output.iterators]].
 - `SampleIterator` meets the *Cpp17RandomAccessIterator*
   requirements [[random.access.iterators]] unless `PopulationIterator`
- meets the *Cpp17ForwardIterator* requirements [[forward.iterators]].
 - `remove_reference_t<UniformRandomBitGenerator>` meets the requirements
   of a uniform random bit generator type [[rand.req.urng]].
 *Effects:* Copies min(`last - first`,  `n`) elements (the *sample*) from
 \[`first`, `last`) (the *population*) to `out` such that each possible
@@ -4956,13 +5449,13 @@ sampling* and *reservoir sampling*. — *end note*]
 *Complexity:* 𝑂(`last - first`).
 *Remarks:*
 - For the overload in namespace `std`, stable if and only if
-  `PopulationIterator` meets the *Cpp17ForwardIterator* requirements.
- For the first overload in namespace `ranges`, stable if and only if
-  `I` models `forward_iterator`.
 - To the extent that the implementation of this function makes use of
   random numbers, the object `g` serves as the implementation’s source
   of randomness.
 ### Shuffle <a id="alg.random.shuffle">[[alg.random.shuffle]]</a>
@@ -5011,23 +5504,34 @@ template<class ForwardIterator>
                typename iterator_traits<ForwardIterator>::difference_type n);
 template<class ExecutionPolicy, class ForwardIterator>
   ForwardIterator
     shift_left(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
                typename iterator_traits<ForwardIterator>::difference_type n);
 ```
-*Preconditions:* `n >= 0` is `true`. 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`. In
-the first overload case, does so in order starting from `i = 0` and
-proceeding to `i = (last - first) - n - 1`.
-*Returns:* `first + (last - first - n)` if `n < last - first`, otherwise
-`first`.
 *Complexity:* At most `(last - first) - n` assignments.
 ``` cpp
 template<class ForwardIterator>
@@ -5036,41 +5540,59 @@ template<class ForwardIterator>
                 typename iterator_traits<ForwardIterator>::difference_type n);
 template<class ExecutionPolicy, class ForwardIterator>
   ForwardIterator
     shift_right(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
                 typename iterator_traits<ForwardIterator>::difference_type n);
 ```
-*Preconditions:* `n >= 0` is `true`. The type of `*first` meets the
-*Cpp17MoveAssignable* requirements. `ForwardIterator` meets the
 *Cpp17BidirectionalIterator* requirements [[bidirectional.iterators]] or
 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`.
-In the first overload case, if `ForwardIterator` meets the
-*Cpp17BidirectionalIterator* requirements, does so in order starting
-from `i = (last - first) - n - 1` and proceeding to `i = 0`.
-*Returns:* `first + n` if `n < last - first`, otherwise `last`.
 *Complexity:* At most `(last - first) - n` assignments or swaps.
 ## Sorting and related operations <a id="alg.sorting">[[alg.sorting]]</a>
 The operations in  [[alg.sorting]] defined directly in namespace `std`
 have two versions: one that takes a function object of type `Compare`
 and one that uses an `operator<`.
 `Compare` is a function object type [[function.objects]] that meets the
 requirements for a template parameter named `BinaryPredicate`
 [[algorithms.requirements]]. The return value of the function call
-operation applied to an object of type `Compare`, when contextually
-converted to `bool` [[conv]], yields `true` if the first argument of the
-call is less than the second, and `false` otherwise. `Compare comp` is
-used throughout for algorithms assuming an ordering relation.
 For all algorithms that take `Compare`, there is a version that uses
 `operator<` instead. That is, `comp(*i, *j) != false` defaults to
 `*i < *j != false`. For algorithms other than those described in
 [[alg.binary.search]], `comp` shall induce a strict weak ordering on the
@@ -5106,10 +5628,14 @@ pointing to the sequence and every non-negative integer `n` such that
 bool(invoke(comp, invoke(proj, *(i + n)), invoke(proj, *i)))
 ```
 is `false`.
 A sequence \[`start`, `finish`) is *partitioned with respect to an
 expression* `f(e)` if there exists an integer `n` such that for all
 `0 <= i < (finish - start)`, `f(*(start + i))` is `true` if and only if
 `i < n`.
@@ -5341,13 +5867,13 @@ with no parameters by those names.
 `RandomAccessIterator` meets the *Cpp17ValueSwappable*
 requirements [[swappable.requirements]], the type of `*result_first`
 meets the *Cpp17MoveConstructible* ([[cpp17.moveconstructible]]) and
 *Cpp17MoveAssignable* ([[cpp17.moveassignable]]) requirements.
-*Preconditions:* For iterators `a1` and `b1` in \[`first`, `last`), and
-iterators `x2` and `y2` in \[`result_first`, `result_last`), after
-evaluating the assignment `*y2 = *b1`, let E be the value of
 ``` cpp
 bool(invoke(comp, invoke(proj1, *a1), invoke(proj2, *y2))).
 ```
@@ -5525,19 +6051,21 @@ template<random_access_range R, class Comp = ranges::less, class Proj = identity
 return ranges::nth_element(ranges::begin(r), nth, ranges::end(r), comp, proj);
 ```
 ### Binary search <a id="alg.binary.search">[[alg.binary.search]]</a>
-All of the algorithms in this subclause are versions of binary search
-and assume that the sequence being searched is partitioned with respect
-to an expression formed by binding the search key to an argument of the
-comparison function. They work on non-random access iterators minimizing
-the number of comparisons, which will be logarithmic for all types of
-iterators. They are especially appropriate for random access iterators,
-because these algorithms do a logarithmic number of steps 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>
@@ -5817,19 +6345,18 @@ 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>
     partition_copy(InputIterator first, InputIterator last,
                    OutputIterator1 out_true, OutputIterator2 out_false, Predicate pred);
 template<class ExecutionPolicy, class ForwardIterator, class ForwardIterator1,
          class ForwardIterator2, class Predicate>
@@ -5860,11 +6387,11 @@ Let `proj` be `identity{}` for the overloads with no parameter named
 `*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 may 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
@@ -6049,16 +6576,18 @@ template<bidirectional_range R, class Comp = ranges::less, class Proj = identity
 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>
-This subclause defines all the basic set operations on sorted
-structures. They also work with `multiset`s [[multiset]] containing
-multiple copies of equivalent elements. The semantics of the set
-operations are generalized to `multiset`s in a standard way by defining
-`set_union` to contain the maximum number of occurrences of every
-element, `set_intersection` to contain the minimum, and so on.
 #### `includes` <a id="includes">[[includes]]</a>
 ``` cpp
 template<class InputIterator1, class InputIterator2>
@@ -6111,12 +6640,11 @@ keeping the remaining elements in the same order. — *end note*]
 comparisons and applications of each projection.
 #### `set_union` <a id="set.union">[[set.union]]</a>
 ``` cpp
-template<class InputIterator1, class InputIterator2,
-         class OutputIterator>
   constexpr OutputIterator
     set_union(InputIterator1 first1, InputIterator1 last1,
               InputIterator2 first2, InputIterator2 last2,
               OutputIterator result);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
@@ -6125,12 +6653,11 @@ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
     set_union(ExecutionPolicy&& exec,
               ForwardIterator1 first1, ForwardIterator1 last1,
               ForwardIterator2 first2, ForwardIterator2 last2,
               ForwardIterator result);
-template<class InputIterator1, class InputIterator2,
-         class OutputIterator, class Compare>
   constexpr OutputIterator
     set_union(InputIterator1 first1, InputIterator1 last1,
               InputIterator2 first2, InputIterator2 last2,
               OutputIterator result, Compare comp);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
@@ -6324,11 +6851,11 @@ Returns
 comparisons and applications of each projection.
 *Remarks:* If \[`first1`, `last1`) contains m elements that are
 equivalent to each other and \[`first2`, `last2`) contains n elements
 that are equivalent to them, the last max(m - n, 0) elements from
-\[`first1`, `last1`) is copied to the output range, in order.
 #### `set_symmetric_difference` <a id="set.symmetric.difference">[[set.symmetric.difference]]</a>
 ``` cpp
 template<class InputIterator1, class InputIterator2,
@@ -6407,10 +6934,12 @@ elements from \[`first1`, `last1`) if m > n, and the last n - m of these
 elements from \[`first2`, `last2`) if m < n. In either case, the
 elements are copied in order.
 ### Heap operations <a id="alg.heap.operations">[[alg.heap.operations]]</a>
 A random access range \[`a`, `b`) is a *heap with respect to `comp` and
 `proj`* for a comparator and projection `comp` and `proj` if its
 elements are organized such that:
 - With `N = b - a`, for all i, 0 < i < N,
@@ -6447,14 +6976,15 @@ template<random_access_range R, class Comp = ranges::less, class Proj = identity
 Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
 no parameters by those names.
 *Preconditions:* The range \[`first`, `last - 1`) is a valid heap with
-respect to `comp` and `proj`. For the overloads in namespace `std`, the
-type of `*first` meets the *Cpp17MoveConstructible* requirements
-([[cpp17.moveconstructible]]) and the *Cpp17MoveAssignable*
-requirements ([[cpp17.moveassignable]]).
 *Effects:* Places the value in the location `last - 1` into the
 resulting heap \[`first`, `last`).
 *Returns:* `last` for the overloads in namespace `ranges`.
@@ -6524,14 +7054,15 @@ template<random_access_range R, class Comp = ranges::less, class Proj = identity
 ```
 Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
 no parameters by those names.
-*Preconditions:* For the overloads in namespace `std`, the type of
-`*first` meets the *Cpp17MoveConstructible*
-([[cpp17.moveconstructible]]) and *Cpp17MoveAssignable*
-([[cpp17.moveassignable]]) requirements.
 *Effects:* Constructs a heap with respect to `comp` and `proj` out of
 the range \[`first`, `last`).
 *Returns:* `last` for the overloads in namespace `ranges`.
@@ -6683,19 +7214,19 @@ template<class T, class Proj = identity,
 ```
 *Preconditions:* For the first form, `T` meets the
 *Cpp17LessThanComparable* requirements ([[cpp17.lessthancomparable]]).
-*Returns:* The smaller value.
-*Remarks:* Returns the first argument when the arguments are equivalent.
-An invocation may explicitly specify an argument for the template
-parameter `T` of the overloads in namespace `std`.
 *Complexity:* Exactly one comparison and two applications of the
 projection, if any.
 ``` cpp
 template<class T>
   constexpr T min(initializer_list<T> r);
 template<class T, class Compare>
   constexpr T min(initializer_list<T> r, Compare comp);
@@ -6713,20 +7244,19 @@ template<input_range R, class Proj = identity,
 *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
 ([[cpp17.lessthancomparable]]).
-*Returns:* The smallest value in the input range.
-*Remarks:* Returns a copy of the leftmost element when several elements
-are equivalent to the smallest. An invocation may explicitly specify an
-argument for the template parameter `T` of the overloads in namespace
-`std`.
 *Complexity:* Exactly `ranges::distance(r) - 1` comparisons and twice as
 many applications of the projection, if any.
 ``` cpp
 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);
@@ -6737,19 +7267,19 @@ template<class T, class Proj = identity,
 ```
 *Preconditions:* For the first form, `T` meets the
 *Cpp17LessThanComparable* requirements ([[cpp17.lessthancomparable]]).
-*Returns:* The larger value.
-*Remarks:* Returns the first argument when the arguments are equivalent.
-An invocation may explicitly specify an argument for the template
-parameter `T` of the overloads in namespace `std`.
 *Complexity:* Exactly one comparison and two applications of the
 projection, if any.
 ``` cpp
 template<class T>
   constexpr T max(initializer_list<T> r);
 template<class T, class Compare>
   constexpr T max(initializer_list<T> r, Compare comp);
@@ -6767,20 +7297,19 @@ template<input_range R, class Proj = identity,
 *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
 ([[cpp17.lessthancomparable]]).
-*Returns:* The largest value in the input range.
-*Remarks:* Returns a copy of the leftmost element when several elements
-are equivalent to the largest. An invocation may explicitly specify an
-argument for the template parameter `T` of the overloads in namespace
-`std`.
 *Complexity:* Exactly `ranges::distance(r) - 1` comparisons and twice as
 many applications of the projection, if any.
 ``` cpp
 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);
@@ -6794,16 +7323,16 @@ template<class T, class Proj = identity,
 *Preconditions:* For the first form, `T` meets the
 *Cpp17LessThanComparable* requirements ([[cpp17.lessthancomparable]]).
 *Returns:* `{b, a}` if `b` is smaller than `a`, and `{a, b}` otherwise.
-*Remarks:* An invocation may explicitly specify an argument for the
-template parameter `T` of the overloads in namespace `std`.
 *Complexity:* Exactly one comparison and two applications of the
 projection, if any.
 ``` cpp
 template<class T>
   constexpr pair<T, T> minmax(initializer_list<T> t);
 template<class T, class Compare>
   constexpr pair<T, T> minmax(initializer_list<T> t, Compare comp);
@@ -6826,17 +7355,17 @@ requirements ([[cpp17.lessthancomparable]]).
 *Returns:* Let `X` be the return type. Returns `X{x, y}`, where `x` is a
 copy of the leftmost element with the smallest value and `y` a copy of
 the rightmost element with the largest value in the input range.
-*Remarks:* An invocation may explicitly specify an argument for the
-template parameter `T` of the overloads in namespace `std`.
 *Complexity:* At most (3/2)`ranges::distance(r)` applications of the
 corresponding predicate and twice as many applications of the
 projection, if any.
 ``` cpp
 template<class ForwardIterator>
   constexpr ForwardIterator min_element(ForwardIterator first, ForwardIterator last);
 template<class ExecutionPolicy, class ForwardIterator>
@@ -6846,12 +7375,11 @@ template<class ExecutionPolicy, class ForwardIterator>
 template<class ForwardIterator, class Compare>
   constexpr ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
                                         Compare comp);
 template<class ExecutionPolicy, class ForwardIterator, class Compare>
   ForwardIterator min_element(ExecutionPolicy&& exec,
-                              ForwardIterator first, ForwardIterator last,
-                              Compare comp);
 template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
          indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
   constexpr I ranges::min_element(I first, S last, Comp comp = {}, Proj proj = {});
 template<forward_range R, class Proj = identity,
@@ -6931,23 +7459,25 @@ template<class ExecutionPolicy, class ForwardIterator, class Compare>
     minmax_element(ExecutionPolicy&& exec,
                    ForwardIterator first, ForwardIterator last, Compare comp);
 template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
          indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
-  constexpr ranges::minmax_result<I>
     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_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`
-is the last iterator[^5] in \[`first`, `last`) such that no iterator in
-the range refers to a larger element.
 *Complexity:* Let N be `last - first`. At most
 $\max(\bigl\lfloor{\frac{3}{2}} (N-1)\bigr\rfloor, 0)$ comparisons and
 twice as many applications of the projection, if any.
@@ -6965,16 +7495,19 @@ template<class T, class Proj = identity,
 ```
 Let `comp` be `less{}` for the overloads with no parameter `comp`, and
 let `proj` be `identity{}` for the overloads with no parameter `proj`.
-*Preconditions:* `bool(comp(proj(hi), proj(lo)))` is `false`. For the
-first form, type `T` meets the *Cpp17LessThanComparable* requirements
-([[cpp17.lessthancomparable]]).
-*Returns:* `lo` if `bool(comp(proj(v), proj(lo)))` is `true`, `hi` if
-`bool(comp(proj(hi), proj(v)))` is `true`, otherwise `v`.
 [*Note 1*: If NaN is avoided, `T` can be a floating-point
 type. — *end note*]
 *Complexity:* At most two comparisons and three applications of the
@@ -7039,11 +7572,11 @@ the sequences yields the same result as the comparison of the first
 corresponding pair of elements that are not equivalent.
 [*Example 1*:
 `ranges::lexicographical_compare(I1, S1, I2, S2, Comp, Proj1, Proj2)`
-could be implemented as:
 ``` cpp
 for ( ; first1 != last1 && first2 != last2 ; ++first1, (void) ++first2) {
   if (invoke(comp, invoke(proj1, *first1), invoke(proj2, *first2))) return true;
   if (invoke(comp, invoke(proj2, *first2), invoke(proj1, *first1))) return false;
@@ -7065,23 +7598,20 @@ template<class InputIterator1, class InputIterator2, class Cmp>
                                       InputIterator2 b2, InputIterator2 e2,
                                       Cmp comp)
       -> decltype(comp(*b1, *b2));
 ```
 *Mandates:* `decltype(comp(*b1, *b2))` is a comparison category type.
-*Effects:* Lexicographically compares two ranges and produces a result
-of the strongest applicable comparison category type. Equivalent to:
-``` cpp
-for ( ; b1 != e1 && b2 != e2; void(++b1), void(++b2) )
-  if (auto cmp = comp(*b1,*b2); cmp != 0)
-    return cmp;
-return b1 != e1 ? strong_ordering::greater :
-       b2 != e2 ? strong_ordering::less :
-                  strong_ordering::equal;
-```
 ``` cpp
 template<class InputIterator1, class InputIterator2>
   constexpr auto
     lexicographical_compare_three_way(InputIterator1 b1, InputIterator1 e1,
@@ -7382,10 +7912,22 @@ namespace std {
   // [numeric.iota], iota
   template<class ForwardIterator, class T>
     constexpr void iota(ForwardIterator first, ForwardIterator last, T value);
   // [numeric.ops.gcd], greatest common divisor
   template<class M, class N>
     constexpr common_type_t<M, N> gcd(M m, N n);
   // [numeric.ops.lcm], least common multiple
@@ -7400,12 +7942,14 @@ namespace std {
 }
 ```
 ## Generalized numeric operations <a id="numeric.ops">[[numeric.ops]]</a>
 [*Note 1*: The use of closed ranges as well as semi-open ranges to
-specify requirements throughout this subclause is
 intentional. — *end note*]
 ### Definitions <a id="numerics.defns">[[numerics.defns]]</a>
 Define `GENERALIZED_NONCOMMUTATIVE_SUM(op, a1, ..., aN)` as follows:
@@ -7788,11 +8332,11 @@ GENERALIZED_NONCOMMUTATIVE_SUM(
 *Remarks:* `result` may be equal to `first`.
 [*Note 1*: The difference between `exclusive_scan` and `inclusive_scan`
 is that `exclusive_scan` excludes the iᵗʰ input element from the iᵗʰ
 sum. If `binary_op` is not mathematically associative, the behavior of
-`exclusive_scan` may be nondeterministic. — *end note*]
 ### Inclusive scan <a id="inclusive.scan">[[inclusive.scan]]</a>
 ``` cpp
 template<class InputIterator, class OutputIterator>
@@ -7883,11 +8427,11 @@ through `result + K` the value of
 *Remarks:* `result` may be equal to `first`.
 [*Note 1*: The difference between `exclusive_scan` and `inclusive_scan`
 is that `inclusive_scan` includes the iᵗʰ input element in the iᵗʰ sum.
 If `binary_op` is not mathematically associative, the behavior of
-`inclusive_scan` may be nondeterministic. — *end note*]
 ### Transform exclusive scan <a id="transform.exclusive.scan">[[transform.exclusive.scan]]</a>
 ``` cpp
 template<class InputIterator, class OutputIterator, class T,
@@ -7940,11 +8484,11 @@ GENERALIZED_NONCOMMUTATIVE_SUM(
 [*Note 1*: The difference between `transform_exclusive_scan` and
 `transform_inclusive_scan` is that `transform_exclusive_scan` excludes
 the iᵗʰ input element from the iᵗʰ sum. If `binary_op` is not
 mathematically associative, the behavior of `transform_exclusive_scan`
-may be nondeterministic. `transform_exclusive_scan` does not apply
 `unary_op` to `init`. — *end note*]
 ### Transform inclusive scan <a id="transform.inclusive.scan">[[transform.inclusive.scan]]</a>
 ``` cpp
@@ -8023,11 +8567,11 @@ through `result + K` the value of
 [*Note 1*: The difference between `transform_exclusive_scan` and
 `transform_inclusive_scan` is that `transform_inclusive_scan` includes
 the iᵗʰ input element in the iᵗʰ sum. If `binary_op` is not
 mathematically associative, the behavior of `transform_inclusive_scan`
-may be nondeterministic. `transform_inclusive_scan` does not apply
 `unary_op` to `init`. — *end note*]
 ### Adjacent difference <a id="adjacent.difference">[[adjacent.difference]]</a>
 ``` cpp
@@ -8071,11 +8615,11 @@ denotes an object of type `minus<>`.
 - For the overloads with no `ExecutionPolicy`, `T` meets the
   *Cpp17MoveAssignable* ([[cpp17.moveassignable]]) requirements.
 - For all overloads, in the ranges \[`first`, `last`\] and \[`result`,
   `result + (last - first)`\], `binary_op` neither modifies elements nor
- invalidate iterators or subranges. [^10]
 *Effects:* For the overloads with no `ExecutionPolicy` and a non-empty
 range, the function creates an accumulator `acc` of type `T`,
 initializes it with `*first`, and assigns the result to `*result`. For
 every iterator `i` in \[`first + 1`, `last`) in order, creates an object
@@ -8112,18 +8656,37 @@ expression `++val`, where `val` has type `T`, is well-formed.
 \[`first`, `last`), assigns `*i = value` and increments `value` as if by
 `++value`.
 *Complexity:* Exactly `last - first` increments and assignments.
 ### Greatest common divisor <a id="numeric.ops.gcd">[[numeric.ops.gcd]]</a>
 ``` cpp
 template<class M, class N>
   constexpr common_type_t<M, N> gcd(M m, N n);
 ```
-*Mandates:* `M` and `N` both are integer types and not cv `bool`.
 *Preconditions:* |`m`| and |`n`| are representable as a value of
 `common_type_t<M, N>`.
 [*Note 1*: These requirements ensure, for example, that
@@ -8140,11 +8703,11 @@ greatest common divisor of |`m`| and |`n`|.
 ``` cpp
 template<class M, class N>
   constexpr common_type_t<M, N> lcm(M m, N n);
 ```
-*Mandates:* `M` and `N` both are integer types and not cv `bool`.
 *Preconditions:* |`m`| and |`n`| are representable as a value of
 `common_type_t<M, N>`. The least common multiple of |`m`| and |`n`| is
 representable as a value of type `common_type_t<M, N>`.
@@ -8189,95 +8752,93 @@ 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>
-The contents specified in this subclause  [[specialized.algorithms]] are
-declared in the 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.
-[*Note 1*: When invoked on ranges of potentially-overlapping subobjects
-[[intro.object]], the algorithms specified in this subclause
-[[specialized.algorithms]] result in undefined behavior. — *end note*]
-Some algorithms specified in this clause make use of the exposition-only
-function `voidify`:
 ``` cpp
 template<class T>
   constexpr void* voidify(T& obj) noexcept {
-    return const_cast<void*>(static_cast<const volatile void*>(addressof(obj)));
   }
 ```
 ### Special memory concepts <a id="special.mem.concepts">[[special.mem.concepts]]</a>
 Some algorithms in this subclause are constrained with the following
 exposition-only concepts:
 ``` cpp
 template<class I>
-concept no-throw-input-iterator = // exposition only
   input_iterator<I> &&
   is_lvalue_reference_v<iter_reference_t<I>> &&
   same_as<remove_cvref_t<iter_reference_t<I>>, iter_value_t<I>>;
 ```
-A type `I` models *`no-throw-input-iterator`* only if no exceptions are
 thrown from increment, copy construction, move construction, copy
 assignment, move assignment, or indirection through valid iterators.
 [*Note 1*: This concept allows some `input_iterator`
 [[iterator.concept.input]] operations to throw
 exceptions. — *end note*]
 ``` cpp
 template<class S, class I>
-concept no-throw-sentinel = sentinel_for<S, I>; // exposition only
 ```
-Types `S` and `I` model *`no-throw-sentinel`* only if no exceptions are
 thrown from copy construction, move construction, copy assignment, move
 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 no-throw-input-range = // exposition only
   range<R> &&
- no-throw-input-iterator<iterator_t<R>> &&
- no-throw-sentinel<sentinel_t<R>, iterator_t<R>>;
 ```
-A type `R` models *`no-throw-input-range`* only if no exceptions are
-thrown from calls to `ranges::begin` and `ranges::end` on an object of
-type `R`.
 ``` cpp
 template<class I>
-concept no-throw-forward-iterator = // exposition only
- no-throw-input-iterator<I> &&
   forward_iterator<I> &&
- no-throw-sentinel<I, I>;
 ```
 [*Note 3*: This concept allows some `forward_iterator`
 [[iterator.concept.forward]] operations to throw
 exceptions. — *end note*]
 ``` cpp
 template<class R>
-concept no-throw-forward-range = // exposition only
- no-throw-input-range<R> &&
- no-throw-forward-iterator<iterator_t<R>>;
 ```
 ### `uninitialized_default_construct` <a id="uninitialized.construct.default">[[uninitialized.construct.default]]</a>
 ``` cpp
@@ -8293,14 +8854,14 @@ for (; first != last; ++first)
     typename iterator_traits<NoThrowForwardIterator>::value_type;
 ```
 ``` cpp
 namespace ranges {
-  template<no-throw-forward-iterator I, no-throw-sentinel<I> S>
     requires default_initializable<iter_value_t<I>>
     I uninitialized_default_construct(I first, S last);
-  template<no-throw-forward-range R>
     requires default_initializable<range_value_t<R>>
     borrowed_iterator_t<R> uninitialized_default_construct(R&& r);
 }
 ```
@@ -8326,11 +8887,11 @@ for (; n > 0; (void)++first, --n)
 return first;
 ```
 ``` cpp
 namespace ranges {
-  template<no-throw-forward-iterator I>
     requires default_initializable<iter_value_t<I>>
     I uninitialized_default_construct_n(I first, iter_difference_t<I> n);
 }
 ```
@@ -8356,14 +8917,14 @@ for (; first != last; ++first)
     typename iterator_traits<NoThrowForwardIterator>::value_type();
 ```
 ``` cpp
 namespace ranges {
-  template<no-throw-forward-iterator I, no-throw-sentinel<I> S>
     requires default_initializable<iter_value_t<I>>
     I uninitialized_value_construct(I first, S last);
-  template<no-throw-forward-range R>
     requires default_initializable<range_value_t<R>>
     borrowed_iterator_t<R> uninitialized_value_construct(R&& r);
 }
 ```
@@ -8389,11 +8950,11 @@ for (; n > 0; (void)++first, --n)
 return first;
 ```
 ``` cpp
 namespace ranges {
-  template<no-throw-forward-iterator I>
     requires default_initializable<iter_value_t<I>>
     I uninitialized_value_construct_n(I first, iter_difference_t<I> n);
 }
 ```
@@ -8426,15 +8987,15 @@ for (; first != last; ++result, (void) ++first)
 *Returns:* `result`.
 ``` cpp
 namespace ranges {
   template<input_iterator I, sentinel_for<I> S1,
- no-throw-forward-iterator O, no-throw-sentinel<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, no-throw-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);
 }
 ```
@@ -8443,13 +9004,12 @@ namespace ranges {
 `ilast`).
 *Effects:* Equivalent to:
 ``` cpp
-for (; ifirst != ilast && ofirst != olast; ++ofirst, (void)++ifirst) {
   ::new (voidify(*ofirst)) remove_reference_t<iter_reference_t<O>>(*ifirst);
-}
 return {std::move(ifirst), ofirst};
 ```
 ``` cpp
 template<class InputIterator, class Size, class NoThrowForwardIterator>
@@ -8461,21 +9021,20 @@ template<class InputIterator, class Size, class NoThrowForwardIterator>
 `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, no-throw-forward-iterator O, no-throw-sentinel<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);
 }
 ```
@@ -8484,11 +9043,11 @@ namespace ranges {
 `ifirst`+\[0, `n`).
 *Effects:* Equivalent to:
 ``` cpp
-auto t = uninitialized_copy(counted_iterator(ifirst, n),
                             default_sentinel, ofirst, olast);
 return {std::move(t.in).base(), t.out};
 ```
 ### `uninitialized_move` <a id="uninitialized.move">[[uninitialized.move]]</a>
@@ -8512,15 +9071,15 @@ return result;
 ```
 ``` cpp
 namespace ranges {
   template<input_iterator I, sentinel_for<I> S1,
- no-throw-forward-iterator O, no-throw-sentinel<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, no-throw-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);
 }
 ```
@@ -8529,19 +9088,18 @@ namespace ranges {
 `ilast`).
 *Effects:* Equivalent to:
 ``` cpp
-for (; ifirst != ilast && ofirst != olast; ++ofirst, (void)++ifirst) {
   ::new (voidify(*ofirst))
     remove_reference_t<iter_reference_t<O>>(ranges::iter_move(ifirst));
-}
 return {std::move(ifirst), ofirst};
 ```
 [*Note 1*: If an exception is thrown, some objects in the range
-\[`first`, `last`) are left in a valid, but unspecified
 state. — *end note*]
 ``` cpp
 template<class InputIterator, class Size, class NoThrowForwardIterator>
   pair<InputIterator, NoThrowForwardIterator>
@@ -8560,11 +9118,11 @@ for (; n > 0; ++result, (void) ++first, --n)
 return {first, result};
 ```
 ``` cpp
 namespace ranges {
-  template<input_iterator I, no-throw-forward-iterator O, no-throw-sentinel<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);
 }
 ```
@@ -8573,17 +9131,17 @@ namespace ranges {
 `ifirst`+\[0, `n`).
 *Effects:* Equivalent to:
 ``` cpp
-auto t = uninitialized_move(counted_iterator(ifirst, n),
                             default_sentinel, ofirst, olast);
 return {std::move(t.in).base(), t.out};
 ```
 [*Note 2*: If an exception is thrown, some objects in the range
-`first`+\[0, `n`) are left in a valid but unspecified
 state. — *end note*]
 ### `uninitialized_fill` <a id="uninitialized.fill">[[uninitialized.fill]]</a>
 ``` cpp
@@ -8599,25 +9157,24 @@ for (; first != last; ++first)
     typename iterator_traits<NoThrowForwardIterator>::value_type(x);
 ```
 ``` cpp
 namespace ranges {
-  template<no-throw-forward-iterator I, no-throw-sentinel<I> S, class T>
     requires constructible_from<iter_value_t<I>, const T&>
     I uninitialized_fill(I first, S last, const T& x);
-  template<no-throw-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:
 ``` cpp
-for (; first != last; ++first) {
   ::new (voidify(*first)) remove_reference_t<iter_reference_t<I>>(x);
-}
 return first;
 ```
 ``` cpp
 template<class NoThrowForwardIterator, class Size, class T>
@@ -8633,11 +9190,11 @@ for (; n--; ++first)
 return first;
 ```
 ``` cpp
 namespace ranges {
-  template<no-throw-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);
 }
 ```
@@ -8659,11 +9216,11 @@ namespace ranges {
 }
 ```
 *Constraints:* The expression
 `::new (declval<void*>()) T(declval<Args>()...)` is well-formed when
-treated as an unevaluated operand.
 *Effects:* Equivalent to:
 ``` cpp
 return ::new (voidify(*location)) T(std::forward<Args>(args)...);
@@ -8698,14 +9255,14 @@ for (; first != last; ++first)
   destroy_at(addressof(*first));
 ```
 ``` cpp
 namespace ranges {
-  template<no-throw-input-iterator I, no-throw-sentinel<I> S>
     requires destructible<iter_value_t<I>>
     constexpr I destroy(I first, S last) noexcept;
-  template<no-throw-input-range R>
     requires destructible<range_value_t<R>>
     constexpr borrowed_iterator_t<R> destroy(R&& r) noexcept;
 }
 ```
@@ -8730,20 +9287,20 @@ for (; n > 0; (void)++first, --n)
 return first;
 ```
 ``` cpp
 namespace ranges {
-  template<no-throw-input-iterator I>
     requires destructible<iter_value_t<I>>
     constexpr I destroy_n(I first, iter_difference_t<I> n) noexcept;
 }
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return destroy(counted_iterator(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
@@ -8756,40 +9313,46 @@ 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);
 ```
 *Effects:* These functions have the semantics specified in the C
 standard library.
-*Preconditions:* The objects in the array pointed to by `base` are of
-trivial type.
 *Throws:* Any exception thrown by `compar`
 [[res.on.exception.handling]].
-ISO C 7.22.5.
 <!-- Link reference definitions -->
 [accumulate]: #accumulate
 [adjacent.difference]: #adjacent.difference
 [alg.adjacent.find]: #alg.adjacent.find
 [alg.all.of]: #alg.all.of
 [alg.any.of]: #alg.any.of
 [alg.binary.search]: #alg.binary.search
 [alg.c.library]: #alg.c.library
 [alg.clamp]: #alg.clamp
 [alg.copy]: #alg.copy
 [alg.count]: #alg.count
 [alg.equal]: #alg.equal
 [alg.fill]: #alg.fill
 [alg.find]: #alg.find
 [alg.find.end]: #alg.find.end
 [alg.find.first.of]: #alg.find.first.of
 [alg.foreach]: #alg.foreach
 [alg.generate]: #alg.generate
 [alg.heap.operations]: #alg.heap.operations
 [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
@@ -8805,13 +9368,16 @@ ISO C 7.22.5.
 [alg.replace]: #alg.replace
 [alg.reverse]: #alg.reverse
 [alg.rotate]: #alg.rotate
 [alg.search]: #alg.search
 [alg.set.operations]: #alg.set.operations
 [alg.shift]: #alg.shift
 [alg.sort]: #alg.sort
 [alg.sorting]: #alg.sorting
 [alg.swap]: #alg.swap
 [alg.three.way]: #alg.three.way
 [alg.transform]: #alg.transform
 [alg.unique]: #alg.unique
 [algorithm.stable]: library.md#algorithm.stable
@@ -8831,12 +9397,12 @@ ISO C 7.22.5.
 [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
 [containers]: containers.md#containers
-[conv]: expr.md#conv
 [conv.integral]: expr.md#conv.integral
 [cpp17.copyassignable]: #cpp17.copyassignable
 [cpp17.copyconstructible]: #cpp17.copyconstructible
 [cpp17.lessthancomparable]: #cpp17.lessthancomparable
 [cpp17.moveassignable]: #cpp17.moveassignable
@@ -8851,16 +9417,17 @@ ISO C 7.22.5.
 [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.forward]: iterators.md#iterator.concept.forward
 [iterator.concept.input]: iterators.md#iterator.concept.input
 [iterator.concept.sentinel]: iterators.md#iterator.concept.sentinel
 [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
@@ -8868,10 +9435,11 @@ ISO C 7.22.5.
 [mismatch]: #mismatch
 [multiset]: containers.md#multiset
 [numeric.iota]: #numeric.iota
 [numeric.ops]: #numeric.ops
 [numeric.ops.gcd]: #numeric.ops.gcd
 [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
@@ -8892,15 +9460,17 @@ ISO C 7.22.5.
 [set.union]: #set.union
 [sort]: #sort
 [sort.heap]: #sort.heap
 [special.mem.concepts]: #special.mem.concepts
 [specialized.algorithms]: #specialized.algorithms
 [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
 [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
 [transform.reduce]: #transform.reduce
@@ -8913,17 +9483,17 @@ ISO C 7.22.5.
 [^1]: The decision whether to include a copying version was usually
     based on complexity considerations. When the cost of doing the
     operation dominates the cost of copy, the copying version is not
     included. For example, `sort_copy` is not included because the cost
-    of sorting is much more significant, and users might as well do
- `copy` followed by `sort`.
-[^2]: `copy_backward` should be used instead of copy when `last` is in
     the range \[`result - `N, `result`).
-[^3]: `move_backward` should be used instead of move when `last` is in
     the range \[`result - `N, `result`).
 [^4]: The use of fully closed ranges is intentional.
 [^5]: This behavior intentionally differs from `max_element`.

 | 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>`   |
 Throughout this Clause, where the template parameters are not
 constrained, the names of template parameters are used to express type
 requirements.
+- If an algorithm’s *Effects* element specifies that a value pointed to
+  by any iterator passed as an argument is modified, then the type of
+  that argument shall meet the requirements of a mutable iterator
+  [[iterator.requirements]].
 - If an algorithm’s template parameter is named `InputIterator`,
   `InputIterator1`, or `InputIterator2`, the template argument shall
   meet the *Cpp17InputIterator* requirements [[input.iterators]].
 - If an algorithm’s template parameter is named `OutputIterator`,
   `OutputIterator1`, or `OutputIterator2`, the template argument shall
   meet the *Cpp17OutputIterator* requirements [[output.iterators]].
 - If an algorithm’s template parameter is named `ForwardIterator`,
+  `ForwardIterator1`, `ForwardIterator2`, or `NoThrowForwardIterator`,
+ the template argument shall meet the *Cpp17ForwardIterator*
+  requirements [[forward.iterators]] if it is required to be a mutable
+  iterator, or model `forward_iterator` [[iterator.concept.forward]]
+  otherwise.
 - If an algorithm’s template parameter is named
+  `NoThrowForwardIterator`, the template argument is also required to
+ have the property that no exceptions are thrown from increment,
+ assignment, or comparison of, or indirection through, valid iterators.
 - If an algorithm’s template parameter is named `BidirectionalIterator`,
   `BidirectionalIterator1`, or `BidirectionalIterator2`, the template
   argument shall meet the *Cpp17BidirectionalIterator* requirements
+  [[bidirectional.iterators]] if it is required to be a mutable
+  iterator, or model `bidirectional_iterator` [[iterator.concept.bidir]]
+  otherwise.
 - If an algorithm’s template parameter is named `RandomAccessIterator`,
   `RandomAccessIterator1`, or `RandomAccessIterator2`, the template
   argument shall meet the *Cpp17RandomAccessIterator* requirements
+  [[random.access.iterators]] if it is required to be a mutable
+  iterator, or model `random_access_iterator`
+  [[iterator.concept.random.access]] otherwise.
+[*Note 1*: These requirements do not affect iterator arguments that are
+constrained, for which iterator category and mutability requirements are
+expressed explicitly. — *end note*]
+Both in-place and copying versions are provided for certain
+algorithms.[^1]
+When such a version is provided for *algorithm* it is called
 *algorithm`_copy`*. Algorithms that take predicates end with the suffix
 `_if` (which follows the suffix `_copy`).
 When not otherwise constrained, the `Predicate` parameter is used
 whenever an algorithm expects a function object [[function.objects]]
 that, when applied to the result of dereferencing the corresponding
+iterator, returns a value testable as `true`. If an algorithm takes
+`Predicate pred` as its argument and `first` as its iterator argument
+with value type `T`, the expression `pred(*first)` shall be well-formed
+and the type `decltype(pred(*first))` shall model `boolean-testable`
+[[concept.booleantestable]]. The function object `pred` shall not apply
+any non-constant function through its argument. Given a glvalue `u` of
+type (possibly const) `T` that designates the same object as `*first`,
+`pred(u)` shall be a valid expression that is equal to `pred(*first)`.
 When not otherwise constrained, the `BinaryPredicate` parameter is used
+whenever an algorithm expects a function object that, when applied to
+the result of dereferencing two corresponding iterators or to
+dereferencing an iterator and type `T` when `T` is part of the
+signature, returns a value testable as `true`. If an algorithm takes
 `BinaryPredicate binary_pred` as its argument and `first1` and `first2`
+as its iterator arguments with respective value types `T1` and `T2`, the
+expression `binary_pred(*first1, *first2)` shall be well-formed and the
+type `decltype(binary_pred(*first1, *first2))` shall model
+`boolean-testable`. Unless otherwise specified, `BinaryPredicate` always
+takes the first iterator’s `value_type` as its first argument, that is,
+in those cases when `T value` is part of the signature, the expression
+`binary_pred(*first1, value)` shall be well-formed and the type
+`decltype(binary_pred(*first1, value))` shall model `boolean-testable`.
+`binary_pred` shall not apply any non-constant function through any of
+its arguments. Given a glvalue `u` of type (possibly const) `T1` that
+designates the same object as `*first1`, and a glvalue `v` of type
+(possibly const) `T2` that designates the same object as `*first2`,
+`binary_pred(u, *first2)`, `binary_pred(*first1, v)`, and
 `binary_pred(u, v)` shall each be a valid expression that is equal to
 `binary_pred(*first1, *first2)`, and `binary_pred(u, value)` shall be a
 valid expression that is equal to `binary_pred(*first1, value)`.
 The parameters `UnaryOperation`, `BinaryOperation`, `BinaryOperation1`,
 and `BinaryOperation2` are used whenever an algorithm expects a function
 object [[function.objects]].
 [*Note 2*: Unless otherwise specified, algorithms that take function
+objects as arguments can copy those function objects freely. If object
+identity is important, a wrapper class that points to a non-copied
+implementation object such as `reference_wrapper<T>` [[refwrap]], or
+some equivalent solution, can be used. — *end note*]
 When the description of an algorithm gives an expression such as
 `*first == value` for a condition, the expression shall evaluate to
 either `true` or `false` in boolean contexts.
 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)`.
 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>
 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`
 Unless otherwise stated, implementations may make arbitrary copies of
 elements (with type `T`) from sequences where
 `is_trivially_copy_constructible_v<T>` and
 `is_trivially_destructible_v<T>` are `true`.
+[*Note 2*: This implies that user-supplied function objects cannot rely
+on object identity of arguments for such input sequences. If object
+identity of the arguments to these function objects is important, a
+wrapping iterator that returns a non-copied implementation object such
+as `reference_wrapper<T>` [[refwrap]], or some equivalent solution, can
+be used. — *end note*]
 The invocations of element access functions in parallel algorithms
 invoked with an execution policy object of type
 `execution::sequenced_policy` all occur in the calling thread of
 execution.
 invoked with an execution policy object of type
 `execution::unsequenced_policy` are permitted to execute in an unordered
 fashion in the calling thread of execution, unsequenced with respect to
 one another in the calling thread of execution.
+[*Note 4*: This means that multiple function object invocations can be
 interleaved on a single thread of execution, which overrides the usual
 guarantee from [[intro.execution]] that function executions do not
 overlap with one another. — *end note*]
 The behavior of a program is undefined if it invokes a
 vectorization-unsafe standard library function from user code called
+from an `execution::unsequenced_policy` algorithm.
 [*Note 5*: Because `execution::unsequenced_policy` allows the execution
 of element access functions to be interleaved on a single thread of
 execution, blocking synchronization, including the use of mutexes, risks
 deadlock. — *end note*]
 with respect to one another within each thread of execution. These
 threads of execution are either the invoking thread of execution or
 threads of execution implicitly created by the library; the latter will
 provide weakly parallel forward progress guarantees.
+[*Note 7*: This means that multiple function object invocations can be
 interleaved on a single thread of execution, which overrides the usual
 guarantee from [[intro.execution]] that function executions do not
 overlap with one another. — *end note*]
 The behavior of a program is undefined if it invokes a
 vectorization-unsafe standard library function from user code called
+from an `execution::parallel_unsequenced_policy` algorithm.
 [*Note 8*: Because `execution::parallel_unsequenced_policy` allows the
 execution of element access functions to be interleaved on a single
 thread of execution, blocking synchronization, including the use of
 mutexes, risks deadlock. — *end note*]
 `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
     template<class I, class F>
     template<class T>
       struct min_max_result;
     template<class I>
       struct in_found_result;
+    template<class I, class T>
+      struct in_value_result;
+    template<class O, class T>
+      struct out_value_result;
   }
   // [alg.nonmodifying], non-modifying sequence operations
   // [alg.all.of], all of
   template<class InputIterator, class Predicate>
     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,
+                                       Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
+    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]
              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
       find_end(ForwardIterator1 first1, ForwardIterator1 last1,
                ForwardIterator2 first2, ForwardIterator2 last2);
   namespace ranges {
     template<input_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 I1 find_first_of(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
                                  Proj1 proj1 = {}, Proj2 proj2 = {});
     template<input_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_iterator_t<R1>
+        find_first_of(R1&& r1, R2&& r2, Pred pred = {},
                       Proj1 proj1 = {}, Proj2 proj2 = {});
   }
   // [alg.adjacent.find], adjacent find
   template<class 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 ForwardIterator, class Searcher>
     constexpr ForwardIterator
       search(ForwardIterator first, ForwardIterator last, const Searcher& searcher);
+  namespace ranges {
+    // [alg.starts.with], starts 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 indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+      constexpr bool starts_with(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
+                                 Proj1 proj1 = {}, Proj2 proj2 = {});
+    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 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>) &&
+               indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+      constexpr bool ends_with(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
+                               Proj1 proj1 = {}, Proj2 proj2 = {});
+    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>) &&
+               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
+    public:
+      template<class T, class U> requires invocable<F&, U, T>
+      invoke_result_t<F&, U, T> operator()(T&&, U&&);
+    };
+    template<class F, class T, class I, class U>
+      concept indirectly-binary-left-foldable-impl =  // exposition only
+        movable<T> && movable<U> &&
+        convertible_to<T, U> && invocable<F&, U, iter_reference_t<I>> &&
+        assignable_from<U&, invoke_result_t<F&, U, iter_reference_t<I>>>;
+    template<class F, class T, class I>
+      concept indirectly-binary-left-foldable =      // exposition only
+        copy_constructible<F> && indirectly_readable<I> &&
+        invocable<F&, T, iter_reference_t<I>> &&
+        convertible_to<invoke_result_t<F&, T, iter_reference_t<I>>,
+               decay_t<invoke_result_t<F&, T, iter_reference_t<I>>>> &&
+        indirectly-binary-left-foldable-impl<F, T, I,
+                        decay_t<invoke_result_t<F&, T, iter_reference_t<I>>>>;
+    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>>
+      constexpr auto fold_left_first(I first, S last, F f);
+    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>
+      requires constructible_from<iter_value_t<I>, iter_reference_t<I>>
+    constexpr auto fold_right_last(I first, S last, F f);
+    template<bidirectional_range R,
+             indirectly-binary-right-foldable<range_value_t<R>, iterator_t<R>> F>
+      requires constructible_from<range_value_t<R>, range_reference_t<R>>
+      constexpr auto fold_right_last(R&& r, F 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,
+             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>>
+      constexpr see below fold_left_first_with_iter(I first, S last, F f);
+    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 see below fold_left_first_with_iter(R&& r, F f);
+  }
   // [alg.modifying.operations], mutating sequence operations
   // [alg.copy], copy
   template<class InputIterator, class OutputIterator>
     constexpr OutputIterator copy(InputIterator first, InputIterator last,
                                   OutputIterator result);
   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>
       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,
              class Proj = identity>
       requires convertible_to<I, I2>
     constexpr operator in_found_result<I2>() && {
       return {std::move(in), found};
     }
   };
+  template<class I, class T>
+  struct in_value_result {
+    [[no_unique_address]] I in;
+    [[no_unique_address]] T value;
+    template<class I2, class T2>
+      requires convertible_to<const I&, I2> && convertible_to<const T&, T2>
+    constexpr operator in_value_result<I2, T2>() const & {
+      return {in, value};
+    }
+    template<class I2, class T2>
+      requires convertible_to<I, I2> && convertible_to<T, T2>
+    constexpr operator in_value_result<I2, T2>() && {
+      return {std::move(in), std::move(value)};
+    }
+  };
+  template<class O, class T>
+  struct out_value_result {
+    [[no_unique_address]] O out;
+    [[no_unique_address]] T value;
+    template<class O2, class T2>
+      requires convertible_to<const O&, O2> && convertible_to<const T&, T2>
+    constexpr operator out_value_result<O2, T2>() const & {
+      return {out, value};
+    }
+    template<class O2, class T2>
+      requires convertible_to<O, O2> && convertible_to<T, T2>
+    constexpr operator out_value_result<O2, T2>() && {
+      return {std::move(out), std::move(value)};
+    }
+  };
 }
 ```
 ## Non-modifying sequence operations <a id="alg.nonmodifying">[[alg.nonmodifying]]</a>
 \[`first`, `last`), and `true` otherwise.
 *Complexity:* At most `last - first` applications of the predicate and
 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>
+  constexpr bool ranges::contains_subrange(I1 first1, S1 last1, I2 first2, S2 last2,
+                                           Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
+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 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>
   constexpr Function for_each(InputIterator first, InputIterator last, Function f);
 *Effects:* Applies `f` to the result of dereferencing every iterator in
 the range \[`first`, `last`), starting from `first` and proceeding to
 `last - 1`.
 [*Note 2*: 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:* `f`.
 *Complexity:* Applies `f` exactly `last - first` times.
 *Effects:* Applies `f` to the result of dereferencing every iterator in
 the range \[`first`, `last`).
 [*Note 3*: If the type of `first` meets the requirements of a mutable
+iterator, `f` can apply non-constant functions through the dereferenced
 iterator. — *end note*]
 *Complexity:* Applies `f` 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.
 [*Note 4*: Does not return a copy of its `Function` parameter, since
+parallelization often does not permit efficient state
 accumulation. — *end note*]
 ``` cpp
 template<input_iterator I, sentinel_for<I> S, class Proj = identity,
          indirectly_unary_invocable<projected<I, Proj>> Fun>
 *Effects:* Calls `invoke(f, invoke(proj, *i))` for every iterator `i` in
 the range \[`first`, `last`), starting from `first` and proceeding to
 `last - 1`.
 [*Note 5*: If the result of `invoke(proj, *i)` is a mutable reference,
+`f` can apply non-constant functions. — *end note*]
 *Returns:* `{last, std::move(f)}`.
 *Complexity:* Applies `f` and `proj` exactly `last - first` times.
 template<class InputIterator, class Size, class Function>
   constexpr InputIterator for_each_n(InputIterator first, Size n, Function f);
 ```
 *Mandates:* The type `Size` is convertible to an integral
+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`.
 *Remarks:* If `f` returns a result, the result is ignored.
   ForwardIterator for_each_n(ExecutionPolicy&& exec, ForwardIterator first, Size n,
                              Function f);
 ```
 *Mandates:* The type `Size` is convertible to an integral
+type [[conv.integral]], [[class.conv]].
+*Preconditions:* `n >= 0` is `true`. `Function` meets the
+*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`.
 *Remarks:* If `f` returns a result, the result is ignored.
 *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.
 which E is `true`. Returns `last` if no such iterator is found.
 *Complexity:* At most `last - first` applications of the corresponding
 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`;
+- `bool(invoke(pred, invoke(proj, *i)))` for `ranges::find_last_if`;
+- `bool(!invoke(pred, invoke(proj, *i)))` for
+  `ranges::find_last_if_not`.
+*Returns:* Let `i` be the last iterator in the range \[`first`, `last`)
+for which E is `true`. Returns `{i, last}`, or `{last, last}` if no such
+iterator is found.
+*Complexity:* At most `last - first` applications of the corresponding
+predicate and projection.
 ### Find end <a id="alg.find.end">[[alg.find.end]]</a>
 ``` cpp
 template<class ForwardIterator1, class ForwardIterator2>
   constexpr ForwardIterator1
   - `invoke(pred, invoke(proj1, *i), invoke(proj2, *(first2 + (i - first1))))`
     for the overloads with parameter `proj1`.
 *Returns:* If `last1 - first1 != last2 - first2`, return `false`.
 Otherwise return `true` if E holds for every iterator `i` in the range
+\[`first1`, `last1`). Otherwise, returns `false`.
+*Complexity:* If
+- the types of `first1`, `last1`, `first2`, and `last2` meet the
+ *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`,
   constexpr bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                                 ForwardIterator2 first2, ForwardIterator2 last2,
                                 BinaryPredicate pred);
 ```
+Let `last2` be `first2 + (last1 - first1)` for the overloads with no
+parameter named `last2`, and let `pred` be `equal_to{}` for the
+overloads with no parameter `pred`.
 *Mandates:* `ForwardIterator1` and `ForwardIterator2` have the same
 value type.
 *Preconditions:* The comparison function is an equivalence relation.
 *Returns:* If `last1 - first1 != last2 - first2`, return `false`.
 Otherwise return `true` if there exists a permutation of the elements in
+the range \[`first2`, `last2`), beginning with `ForwardIterator2 begin`,
+such that `equal(first1, last1, begin, pred)` returns `true`; otherwise,
+returns `false`.
 *Complexity:* No applications of the corresponding predicate if
 `ForwardIterator1` and `ForwardIterator2` meet the requirements of
 random access iterators and `last1 - first1 != last2 - first2`.
 Otherwise, exactly `last1 - first1` applications of the corresponding
+predicate if `equal(first1, last1, first2, last2, pred)` would return
+`true`; otherwise, at worst 𝑂(N^2), where N has the value
+`last1 - first1`.
 ``` cpp
 template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2,
          sentinel_for<I2> S2, class Proj1 = identity, class Proj2 = identity,
          indirect_equivalence_relation<projected<I1, Proj1>,
 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`;
+- for the second overload, `R1` and `R2` each model `sized_range`, and
+  `ranges::distance(r1) != ranges::distance(r2)`.
 Otherwise, exactly `last1 - first1` applications of the corresponding
 predicate and projections if
 `ranges::equal(first1, last1, first2, last2, pred, proj1, proj2)` would
 return `true`; otherwise, at worst 𝑂(N^2), where N has the value
              Size count, const T& value,
              BinaryPredicate pred);
 ```
 *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
 *Effects:* Equivalent to: `return searcher(first, last).first;`
 *Remarks:* `Searcher` need not meet the *Cpp17CopyConstructible*
 requirements.
+### Starts with <a id="alg.starts.with">[[alg.starts.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>
+  requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+  constexpr bool ranges::starts_with(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
+                                     Proj1 proj1 = {}, Proj2 proj2 = {});
+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::starts_with(R1&& r1, R2&& r2, Pred pred = {},
+                                     Proj1 proj1 = {}, Proj2 proj2 = {});
+```
+*Returns:*
+``` 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>
+  requires (forward_iterator<I1> || sized_sentinel_for<S1, I1>) &&
+           (forward_iterator<I2> || sized_sentinel_for<S2, I2>) &&
+           indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+  constexpr bool ranges::ends_with(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::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>) &&
+           indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+  constexpr bool ranges::ends_with(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(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:*
+``` cpp
+ranges::fold_left_with_iter(std::move(first), last, std::move(init), f).value
+```
+``` cpp
+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>>
+  constexpr auto ranges::fold_left_first(I first, S last, F f);
+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 ranges::fold_left_first(R&& r, 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,
+         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:
+``` cpp
+using U = decay_t<invoke_result_t<F&, iter_reference_t<I>, T>>;
+if (first == last)
+  return U(std::move(init));
+I tail = ranges::next(first, last);
+U accum = invoke(f, *--tail, std::move(init));
+while (first != tail)
+  accum = invoke(f, *--tail, std::move(accum));
+return accum;
+```
+``` cpp
+template<bidirectional_iterator I, sentinel_for<I> S,
+         indirectly-binary-right-foldable<iter_value_t<I>, I> F>
+  requires constructible_from<iter_value_t<I>, iter_reference_t<I>>
+  constexpr auto ranges::fold_right_last(I first, S last, F f);
+template<bidirectional_range R,
+         indirectly-binary-right-foldable<range_value_t<R>, iterator_t<R>> F>
+  requires constructible_from<range_value_t<R>, range_reference_t<R>>
+  constexpr auto ranges::fold_right_last(R&& r, F f);
+```
+Let `U` be
+`decltype(ranges::fold_right(first, last, iter_value_t<I>(*first), f))`.
+*Effects:* Equivalent to:
+``` cpp
+if (first == last)
+  return optional<U>();
+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>>>`.
+*Effects:* Equivalent to:
+``` cpp
+if (first == last)
+  return {std::move(first), U(std::move(init))};
+U accum = invoke(f, std::move(init), *first);
+for (++first; first != last; ++first)
+  accum = invoke(f, std::move(accum), *first);
+return {std::move(first), std::move(accum)};
+```
+*Remarks:* The return type is `fold_left_with_iter_result<I, U>` for the
+first overload and
+`fold_left_with_iter_result<borrowed_iterator_t<R>, U>` for the second
+overload.
+``` cpp
+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>>
+  constexpr see below ranges::fold_left_first_with_iter(I first, S last, F f);
+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 see below ranges::fold_left_first_with_iter(R&& r, F f);
+```
+Let `U` be
+``` cpp
+decltype(ranges::fold_left(std::move(first), last, iter_value_t<I>(*first), f))
+```
+*Effects:* Equivalent to:
+``` cpp
+if (first == last)
+  return {std::move(first), optional<U>()};
+optional<U> init(in_place, *first);
+for (++first; first != last; ++first)
+  *init = invoke(f, std::move(*init), *first);
+return {std::move(first), std::move(init)};
+```
+*Remarks:* The return type is
+`fold_left_first_with_iter_result<I, optional<U>>` for the first
+overload and
+`fold_left_first_with_iter_result<borrowed_iterator_t<R>, optional<U>>`
+for the second overload.
 ## Mutating sequence operations <a id="alg.modifying.operations">[[alg.modifying.operations]]</a>
 ### Copy <a id="alg.copy">[[alg.copy]]</a>
 ``` cpp
 ```
 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
+`*(result + `i`) = *(first + `i`)`.
 *Returns:*
 - `result + `N for the overloads in namespace `std`.
 - `{first + `N`, result + `N`}` for the overload in namespace `ranges`.
 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
 *Preconditions:* `result` is not in the range (`first`, `last`).
 *Effects:* Copies elements in the range \[`first`, `last`) into the
 range \[`result - `N, `result`) starting from `last - 1` and proceeding
+to `first`.[^2]
+For each positive integer n ≤ N, performs
 `*(result - `n`) = *(last - `n`)`.
 *Returns:*
 - `result - `N for the overload in namespace `std`.
 *Preconditions:* `result` is not in the range (`first`, `last`).
 *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`.
   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>
 Let N be max(0, `n`) for the `fill_n` algorithms, and `last - first` for
 the `fill` algorithms.
 *Mandates:* The expression `value` is
 writable [[iterator.requirements.general]] to the output iterator. The
+type `Size` is convertible to an integral
+type [[conv.integral]], [[class.conv]].
 *Effects:* Assigns `value` through all the iterators in the range
 \[`first`, `first + `N).
 *Returns:* `first + `N.
 Let N be max(0, `n`) for the `generate_n` algorithms, and `last - first`
 for the `generate` algorithms.
 *Mandates:* `Size` is convertible to an integral
+type [[conv.integral]], [[class.conv]].
 *Effects:* Assigns the result of successive evaluations of `gen()`
 through each iterator in the range \[`first`, `first + `N).
 *Returns:* `first + `N.
 *Returns:* Let j be the end of the resulting range. Returns:
 - j for the overloads in namespace `std`.
 - `{`j`, last}` for the overloads in namespace `ranges`.
 *Complexity:* Exactly `last - first` applications of the corresponding
 predicate and any projection.
+*Remarks:* Stable [[algorithm.stable]].
 [*Note 1*: Each element in the range \[`ret`, `last`), where `ret` is
 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*]
 `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:*
 - `bool(pred(*(i - 1), *i))` for the overloads in namespace `std`;
 - `bool(invoke(comp, invoke(proj, *(i - 1)), invoke(proj, *i)))` for the
   overloads in namespace `ranges`.
+*Preconditions:* For the overloads in namespace `std`, `pred` is an
 equivalence relation and the type of `*first` meets the
 *Cpp17MoveAssignable* requirements ([[cpp17.moveassignable]]).
 *Effects:* For a nonempty range, eliminates all but the first element
 from every consecutive group of equivalent elements referred to by the
 - 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
 ```
 *Effects:* Equivalent to:
 ``` 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
   requirements [[input.iterators]].
 - `SampleIterator` meets the *Cpp17OutputIterator*
   requirements [[output.iterators]].
 - `SampleIterator` meets the *Cpp17RandomAccessIterator*
   requirements [[random.access.iterators]] unless `PopulationIterator`
+ models `forward_iterator` [[iterator.concept.forward]].
 - `remove_reference_t<UniformRandomBitGenerator>` meets the requirements
   of a uniform random bit generator type [[rand.req.urng]].
 *Effects:* Copies min(`last - first`,  `n`) elements (the *sample*) from
 \[`first`, `last`) (the *population*) to `out` such that each possible
 *Complexity:* 𝑂(`last - first`).
 *Remarks:*
 - For the overload in namespace `std`, stable if and only if
+  `PopulationIterator` models `forward_iterator`. For the first overload
+  in namespace `ranges`, stable if and only if `I` models
+  `forward_iterator`.
 - To the extent that the implementation of this function makes use of
   random numbers, the object `g` serves as the implementation’s source
   of randomness.
 ### Shuffle <a id="alg.random.shuffle">[[alg.random.shuffle]]</a>
                typename iterator_traits<ForwardIterator>::difference_type n);
 template<class ExecutionPolicy, class ForwardIterator>
   ForwardIterator
     shift_left(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
                typename iterator_traits<ForwardIterator>::difference_type n);
+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.
 ``` cpp
 template<class ForwardIterator>
                 typename iterator_traits<ForwardIterator>::difference_type n);
 template<class ExecutionPolicy, class ForwardIterator>
   ForwardIterator
     shift_right(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
                 typename iterator_traits<ForwardIterator>::difference_type n);
+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
 *Cpp17BidirectionalIterator* requirements [[bidirectional.iterators]] or
 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.
 ## Sorting and related operations <a id="alg.sorting">[[alg.sorting]]</a>
+### General <a id="alg.sorting.general">[[alg.sorting.general]]</a>
 The operations in  [[alg.sorting]] defined directly in namespace `std`
 have two versions: one that takes a function object of type `Compare`
 and one that uses an `operator<`.
 `Compare` is a function object type [[function.objects]] that meets the
 requirements for a template parameter named `BinaryPredicate`
 [[algorithms.requirements]]. The return value of the function call
+operation applied to an object of type `Compare`, when converted to
+`bool`, yields `true` if the first argument of the call is less than the
+second, and `false` otherwise. `Compare comp` is used throughout for
+algorithms assuming an ordering relation.
 For all algorithms that take `Compare`, there is a version that uses
 `operator<` instead. That is, `comp(*i, *j) != false` defaults to
 `*i < *j != false`. For algorithms other than those described in
 [[alg.binary.search]], `comp` shall induce a strict weak ordering on the
 bool(invoke(comp, invoke(proj, *(i + n)), invoke(proj, *i)))
 ```
 is `false`.
+A sequence is *sorted with respect to a comparator `comp`* for a
+comparator `comp` if it is sorted with respect to `comp` and
+`identity{}` (the identity projection).
 A sequence \[`start`, `finish`) is *partitioned with respect to an
 expression* `f(e)` if there exists an integer `n` such that for all
 `0 <= i < (finish - start)`, `f(*(start + i))` is `true` if and only if
 `i < n`.
 `RandomAccessIterator` meets the *Cpp17ValueSwappable*
 requirements [[swappable.requirements]], the type of `*result_first`
 meets the *Cpp17MoveConstructible* ([[cpp17.moveconstructible]]) and
 *Cpp17MoveAssignable* ([[cpp17.moveassignable]]) requirements.
+For iterators `a1` and `b1` in \[`first`, `last`), and iterators `x2`
+and `y2` in \[`result_first`, `result_last`), after evaluating the
+assignment `*y2 = *b1`, let E be the value of
 ``` cpp
 bool(invoke(comp, invoke(proj1, *a1), invoke(proj2, *y2))).
 ```
 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
+search and assume that the sequence being searched is partitioned with
+respect to an expression formed by binding the search key to an argument
+of the comparison function. They work on non-random access iterators
+minimizing the number of comparisons, which will be logarithmic for all
+types of iterators. They are especially appropriate for random access
+iterators, because these algorithms do a logarithmic number of steps
+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>
 - `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>
     partition_copy(InputIterator first, InputIterator last,
                    OutputIterator1 out_true, OutputIterator2 out_false, Predicate pred);
 template<class ExecutionPolicy, class ForwardIterator, class ForwardIterator1,
          class ForwardIterator2, class Predicate>
 `*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
 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
+sorted structures. They also work with `multiset`s [[multiset]]
+containing multiple copies of equivalent elements. The semantics of the
+set operations are generalized to `multiset`s in a standard way by
+defining `set_union` to contain the maximum number of occurrences of
+every element, `set_intersection` to contain the minimum, and so on.
 #### `includes` <a id="includes">[[includes]]</a>
 ``` cpp
 template<class InputIterator1, class InputIterator2>
 comparisons and applications of each projection.
 #### `set_union` <a id="set.union">[[set.union]]</a>
 ``` cpp
+template<class InputIterator1, class InputIterator2, class OutputIterator>
   constexpr OutputIterator
     set_union(InputIterator1 first1, InputIterator1 last1,
               InputIterator2 first2, InputIterator2 last2,
               OutputIterator result);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
     set_union(ExecutionPolicy&& exec,
               ForwardIterator1 first1, ForwardIterator1 last1,
               ForwardIterator2 first2, ForwardIterator2 last2,
               ForwardIterator result);
+template<class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
   constexpr OutputIterator
     set_union(InputIterator1 first1, InputIterator1 last1,
               InputIterator2 first2, InputIterator2 last2,
               OutputIterator result, Compare comp);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
 comparisons and applications of each projection.
 *Remarks:* If \[`first1`, `last1`) contains m elements that are
 equivalent to each other and \[`first2`, `last2`) contains n elements
 that are equivalent to them, the last max(m - n, 0) elements from
+\[`first1`, `last1`) are copied to the output range, in order.
 #### `set_symmetric_difference` <a id="set.symmetric.difference">[[set.symmetric.difference]]</a>
 ``` cpp
 template<class InputIterator1, class InputIterator2,
 elements from \[`first2`, `last2`) if m < n. In either case, the
 elements are copied in order.
 ### Heap operations <a id="alg.heap.operations">[[alg.heap.operations]]</a>
+#### General <a id="alg.heap.operations.general">[[alg.heap.operations.general]]</a>
 A random access range \[`a`, `b`) is a *heap with respect to `comp` and
 `proj`* for a comparator and projection `comp` and `proj` if its
 elements are organized such that:
 - With `N = b - a`, for all i, 0 < i < N,
 Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
 no parameters by those names.
 *Preconditions:* The range \[`first`, `last - 1`) is a valid heap with
+respect to `comp` and `proj`. For the overloads in namespace `std`,
+`RandomAccessIterator` meets the *Cpp17ValueSwappable*
+requirements [[swappable.requirements]] and the type of `*first` meets
+the *Cpp17MoveConstructible* requirements ([[cpp17.moveconstructible]])
+and the *Cpp17MoveAssignable* requirements ([[cpp17.moveassignable]]).
 *Effects:* Places the value in the location `last - 1` into the
 resulting heap \[`first`, `last`).
 *Returns:* `last` for the overloads in namespace `ranges`.
 ```
 Let `comp` be `less{}` and `proj` be `identity{}` for the overloads with
 no parameters by those names.
+*Preconditions:* For the overloads in namespace `std`,
+`RandomAccessIterator` meets the *Cpp17ValueSwappable*
+requirements [[swappable.requirements]] and the type of `*first` meets
+the *Cpp17MoveConstructible* ([[cpp17.moveconstructible]]) and
+*Cpp17MoveAssignable* ([[cpp17.moveassignable]]) requirements.
 *Effects:* Constructs a heap with respect to `comp` and `proj` out of
 the range \[`first`, `last`).
 *Returns:* `last` for the overloads in namespace `ranges`.
 ```
 *Preconditions:* For the first form, `T` meets the
 *Cpp17LessThanComparable* requirements ([[cpp17.lessthancomparable]]).
+*Returns:* The smaller value. Returns the first argument when the
+arguments are equivalent.
 *Complexity:* Exactly one comparison and two applications of the
 projection, if any.
+*Remarks:* An invocation may explicitly specify an argument for the
+template parameter `T` of the overloads in namespace `std`.
 ``` cpp
 template<class T>
   constexpr T min(initializer_list<T> r);
 template<class T, class Compare>
   constexpr T min(initializer_list<T> r, Compare comp);
 *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
 ([[cpp17.lessthancomparable]]).
+*Returns:* The smallest value in the input range. Returns a copy of the
+leftmost element when several elements are equivalent to the smallest.
 *Complexity:* Exactly `ranges::distance(r) - 1` comparisons and twice as
 many applications of the projection, if any.
+*Remarks:* An invocation may explicitly specify an argument for the
+template parameter `T` of the overloads in namespace `std`.
 ``` cpp
 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);
 ```
 *Preconditions:* For the first form, `T` meets the
 *Cpp17LessThanComparable* requirements ([[cpp17.lessthancomparable]]).
+*Returns:* The larger value. Returns the first argument when the
+arguments are equivalent.
 *Complexity:* Exactly one comparison and two applications of the
 projection, if any.
+*Remarks:* An invocation may explicitly specify an argument for the
+template parameter `T` of the overloads in namespace `std`.
 ``` cpp
 template<class T>
   constexpr T max(initializer_list<T> r);
 template<class T, class Compare>
   constexpr T max(initializer_list<T> r, Compare comp);
 *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
 ([[cpp17.lessthancomparable]]).
+*Returns:* The largest value in the input range. Returns a copy of the
+leftmost element when several elements are equivalent to the largest.
 *Complexity:* Exactly `ranges::distance(r) - 1` comparisons and twice as
 many applications of the projection, if any.
+*Remarks:* An invocation may explicitly specify an argument for the
+template parameter `T` of the overloads in namespace `std`.
 ``` cpp
 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);
 *Preconditions:* For the first form, `T` meets the
 *Cpp17LessThanComparable* requirements ([[cpp17.lessthancomparable]]).
 *Returns:* `{b, a}` if `b` is smaller than `a`, and `{a, b}` otherwise.
 *Complexity:* Exactly one comparison and two applications of the
 projection, if any.
+*Remarks:* An invocation may explicitly specify an argument for the
+template parameter `T` of the overloads in namespace `std`.
 ``` cpp
 template<class T>
   constexpr pair<T, T> minmax(initializer_list<T> t);
 template<class T, class Compare>
   constexpr pair<T, T> minmax(initializer_list<T> t, Compare comp);
 *Returns:* Let `X` be the return type. Returns `X{x, y}`, where `x` is a
 copy of the leftmost element with the smallest value and `y` a copy of
 the rightmost element with the largest value in the input range.
 *Complexity:* At most (3/2)`ranges::distance(r)` applications of the
 corresponding predicate and twice as many applications of the
 projection, if any.
+*Remarks:* An invocation may explicitly specify an argument for the
+template parameter `T` of the overloads in namespace `std`.
 ``` cpp
 template<class ForwardIterator>
   constexpr ForwardIterator min_element(ForwardIterator first, ForwardIterator last);
 template<class ExecutionPolicy, class ForwardIterator>
 template<class ForwardIterator, class Compare>
   constexpr ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
                                         Compare comp);
 template<class ExecutionPolicy, class ForwardIterator, class Compare>
   ForwardIterator min_element(ExecutionPolicy&& exec,
+                              ForwardIterator first, ForwardIterator last, Compare comp);
 template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
          indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
   constexpr I ranges::min_element(I first, S last, Comp comp = {}, Proj proj = {});
 template<forward_range R, class Proj = identity,
     minmax_element(ExecutionPolicy&& exec,
                    ForwardIterator first, ForwardIterator last, Compare comp);
 template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
          indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+  constexpr ranges::minmax_element_result<I>
     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`
+is the last iterator[^5]
+in \[`first`, `last`) such that no iterator in the range refers to a
+larger element.
 *Complexity:* Let N be `last - first`. At most
 $\max(\bigl\lfloor{\frac{3}{2}} (N-1)\bigr\rfloor, 0)$ comparisons and
 twice as many applications of the projection, if any.
 ```
 Let `comp` be `less{}` for the overloads with no parameter `comp`, and
 let `proj` be `identity{}` for the overloads with no parameter `proj`.
+*Preconditions:*
+`bool(invoke(comp, invoke(proj, hi), invoke(proj, lo)))` is `false`. For
+the first form, type `T` meets the *Cpp17LessThanComparable*
+requirements ([[cpp17.lessthancomparable]]).
+*Returns:* `lo` if
+`bool(invoke(comp, invoke(proj, v), invoke(proj, lo)))` is `true`, `hi`
+if `bool(invoke(comp, invoke(proj, hi), invoke(proj, v)))` is `true`,
+otherwise `v`.
 [*Note 1*: If NaN is avoided, `T` can be a floating-point
 type. — *end note*]
 *Complexity:* At most two comparisons and three applications of the
 corresponding pair of elements that are not equivalent.
 [*Example 1*:
 `ranges::lexicographical_compare(I1, S1, I2, S2, Comp, Proj1, Proj2)`
+can be implemented as:
 ``` cpp
 for ( ; first1 != last1 && first2 != last2 ; ++first1, (void) ++first2) {
   if (invoke(comp, invoke(proj1, *first1), invoke(proj2, *first2))) return true;
   if (invoke(comp, invoke(proj2, *first2), invoke(proj1, *first1))) return false;
                                       InputIterator2 b2, InputIterator2 e2,
                                       Cmp comp)
       -> decltype(comp(*b1, *b2));
 ```
+Let N be min(`e1 - b1`, `e2 - b2`). Let E(n) be
+`comp(*(b1 + `n`), *(b2 + `n`))`.
 *Mandates:* `decltype(comp(*b1, *b2))` is a comparison category type.
+*Returns:* E(i), where i is the smallest integer in \[`0`, N) such that
+E(i)` != 0` is `true`, or `(e1 - b1) <=> (e2 - b2)` if no such integer
+exists.
+*Complexity:* At most N applications of `comp`.
 ``` cpp
 template<class InputIterator1, class InputIterator2>
   constexpr auto
     lexicographical_compare_three_way(InputIterator1 b1, InputIterator1 e1,
   // [numeric.iota], iota
   template<class ForwardIterator, class T>
     constexpr void iota(ForwardIterator first, ForwardIterator last, T value);
+  namespace ranges {
+    template<class O, class T>
+      using iota_result = out_value_result<O, T>;
+    template<input_or_output_iterator O, sentinel_for<O> S, weakly_incrementable T>
+      requires indirectly_writable<O, const T&>
+      constexpr iota_result<O, T> iota(O first, S last, T value);
+    template<weakly_incrementable T, output_range<const T&> R>
+      constexpr iota_result<borrowed_iterator_t<R>, T> iota(R&& r, T value);
+  }
   // [numeric.ops.gcd], greatest common divisor
   template<class M, class N>
     constexpr common_type_t<M, N> gcd(M m, N n);
   // [numeric.ops.lcm], least common multiple
 }
 ```
 ## Generalized numeric operations <a id="numeric.ops">[[numeric.ops]]</a>
+### General <a id="numeric.ops.general">[[numeric.ops.general]]</a>
 [*Note 1*: The use of closed ranges as well as semi-open ranges to
+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:
 *Remarks:* `result` may be equal to `first`.
 [*Note 1*: The difference between `exclusive_scan` and `inclusive_scan`
 is that `exclusive_scan` excludes the iᵗʰ input element from the iᵗʰ
 sum. If `binary_op` is not mathematically associative, the behavior of
+`exclusive_scan` can be nondeterministic. — *end note*]
 ### Inclusive scan <a id="inclusive.scan">[[inclusive.scan]]</a>
 ``` cpp
 template<class InputIterator, class OutputIterator>
 *Remarks:* `result` may be equal to `first`.
 [*Note 1*: The difference between `exclusive_scan` and `inclusive_scan`
 is that `inclusive_scan` includes the iᵗʰ input element in the iᵗʰ sum.
 If `binary_op` is not mathematically associative, the behavior of
+`inclusive_scan` can be nondeterministic. — *end note*]
 ### Transform exclusive scan <a id="transform.exclusive.scan">[[transform.exclusive.scan]]</a>
 ``` cpp
 template<class InputIterator, class OutputIterator, class T,
 [*Note 1*: The difference between `transform_exclusive_scan` and
 `transform_inclusive_scan` is that `transform_exclusive_scan` excludes
 the iᵗʰ input element from the iᵗʰ sum. If `binary_op` is not
 mathematically associative, the behavior of `transform_exclusive_scan`
+can be nondeterministic. `transform_exclusive_scan` does not apply
 `unary_op` to `init`. — *end note*]
 ### Transform inclusive scan <a id="transform.inclusive.scan">[[transform.inclusive.scan]]</a>
 ``` cpp
 [*Note 1*: The difference between `transform_exclusive_scan` and
 `transform_inclusive_scan` is that `transform_inclusive_scan` includes
 the iᵗʰ input element in the iᵗʰ sum. If `binary_op` is not
 mathematically associative, the behavior of `transform_inclusive_scan`
+can be nondeterministic. `transform_inclusive_scan` does not apply
 `unary_op` to `init`. — *end note*]
 ### Adjacent difference <a id="adjacent.difference">[[adjacent.difference]]</a>
 ``` cpp
 - For the overloads with no `ExecutionPolicy`, `T` meets the
   *Cpp17MoveAssignable* ([[cpp17.moveassignable]]) requirements.
 - For all overloads, in the ranges \[`first`, `last`\] and \[`result`,
   `result + (last - first)`\], `binary_op` neither modifies elements nor
+ invalidates iterators or subranges.[^10]
 *Effects:* For the overloads with no `ExecutionPolicy` and a non-empty
 range, the function creates an accumulator `acc` of type `T`,
 initializes it with `*first`, and assigns the result to `*result`. For
 every iterator `i` in \[`first + 1`, `last`) in order, creates an object
 \[`first`, `last`), assigns `*i = value` and increments `value` as if by
 `++value`.
 *Complexity:* Exactly `last - first` increments and assignments.
+``` cpp
+template<input_or_output_iterator O, sentinel_for<O> S, weakly_incrementable T>
+  requires indirectly_writable<O, const T&>
+  constexpr ranges::iota_result<O, T> ranges::iota(O first, S last, T value);
+template<weakly_incrementable T, output_range<const T&> R>
+  constexpr ranges::iota_result<borrowed_iterator_t<R>, T> ranges::iota(R&& r, T value);
+```
+*Effects:* Equivalent to:
+``` cpp
+while (first != last) {
+  *first = as_const(value);
+  ++first;
+  ++value;
+}
+return {std::move(first), std::move(value)};
+```
 ### Greatest common divisor <a id="numeric.ops.gcd">[[numeric.ops.gcd]]</a>
 ``` cpp
 template<class M, class N>
   constexpr common_type_t<M, N> gcd(M m, N n);
 ```
+*Mandates:* `M` and `N` both are integer types other than cv `bool`.
 *Preconditions:* |`m`| and |`n`| are representable as a value of
 `common_type_t<M, N>`.
 [*Note 1*: These requirements ensure, for example, that
 ``` cpp
 template<class M, class N>
   constexpr common_type_t<M, N> lcm(M m, N n);
 ```
+*Mandates:* `M` and `N` both are integer types other than cv `bool`.
 *Preconditions:* |`m`| and |`n`| are representable as a value of
 `common_type_t<M, N>`. The least common multiple of |`m`| and |`n`| is
 representable as a value of type `common_type_t<M, N>`.
 *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
+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
 exposition-only concepts:
 ``` cpp
 template<class I>
+concept nothrow-input-iterator = // exposition only
   input_iterator<I> &&
   is_lvalue_reference_v<iter_reference_t<I>> &&
   same_as<remove_cvref_t<iter_reference_t<I>>, iter_value_t<I>>;
 ```
+A type `I` models `nothrow-input-iterator` only if no exceptions are
 thrown from increment, copy construction, move construction, copy
 assignment, move assignment, or indirection through valid iterators.
 [*Note 1*: This concept allows some `input_iterator`
 [[iterator.concept.input]] operations to throw
 exceptions. — *end note*]
 ``` cpp
 template<class S, class I>
+concept nothrow-sentinel-for = sentinel_for<S, I>; // exposition only
 ```
+Types `S` and `I` model `nothrow-sentinel-for` only if no exceptions are
 thrown from copy construction, move construction, copy assignment, move
 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>> &&
+ nothrow-sentinel-for<sentinel_t<R>, iterator_t<R>>;
 ```
+A type `R` models `nothrow-input-range` only if no exceptions are thrown
+from calls to `ranges::begin` and `ranges::end` on an object of type
+`R`.
 ``` cpp
 template<class I>
+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
     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);
 }
 ```
 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);
 }
 ```
     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);
 }
 ```
 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);
 }
 ```
 *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);
 }
 ```
 `ilast`).
 *Effects:* Equivalent to:
 ``` cpp
+for (; ifirst != ilast && ofirst != olast; ++ofirst, (void)++ifirst)
   ::new (voidify(*ofirst)) remove_reference_t<iter_reference_t<O>>(*ifirst);
 return {std::move(ifirst), ofirst};
 ```
 ``` cpp
 template<class InputIterator, class Size, class NoThrowForwardIterator>
 `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);
 }
 ```
 `ifirst`+\[0, `n`).
 *Effects:* Equivalent to:
 ``` cpp
+auto t = uninitialized_copy(counted_iterator(std::move(ifirst), n),
                             default_sentinel, ofirst, olast);
 return {std::move(t.in).base(), t.out};
 ```
 ### `uninitialized_move` <a id="uninitialized.move">[[uninitialized.move]]</a>
 ```
 ``` 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);
 }
 ```
 `ilast`).
 *Effects:* Equivalent to:
 ``` cpp
+for (; ifirst != ilast && ofirst != olast; ++ofirst, (void)++ifirst)
   ::new (voidify(*ofirst))
     remove_reference_t<iter_reference_t<O>>(ranges::iter_move(ifirst));
 return {std::move(ifirst), ofirst};
 ```
 [*Note 1*: If an exception is thrown, some objects in the range
+\[`ifirst`, `ilast`) are left in a valid, but unspecified
 state. — *end note*]
 ``` cpp
 template<class InputIterator, class Size, class NoThrowForwardIterator>
   pair<InputIterator, NoThrowForwardIterator>
 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);
 }
 ```
 `ifirst`+\[0, `n`).
 *Effects:* Equivalent to:
 ``` cpp
+auto t = uninitialized_move(counted_iterator(std::move(ifirst), n),
                             default_sentinel, ofirst, olast);
 return {std::move(t.in).base(), t.out};
 ```
 [*Note 2*: If an exception is thrown, some objects in the range
+`ifirst`+\[0, `n`) are left in a valid but unspecified
 state. — *end note*]
 ### `uninitialized_fill` <a id="uninitialized.fill">[[uninitialized.fill]]</a>
 ``` cpp
     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:
 ``` cpp
+for (; first != last; ++first)
   ::new (voidify(*first)) remove_reference_t<iter_reference_t<I>>(x);
 return first;
 ```
 ``` cpp
 template<class NoThrowForwardIterator, class Size, class T>
 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);
 }
 ```
 }
 ```
 *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_at(addressof(*first));
 ```
 ``` cpp
 namespace ranges {
+  template<nothrow-input-iterator I, nothrow-sentinel-for<I> S>
     requires destructible<iter_value_t<I>>
     constexpr I destroy(I first, S last) noexcept;
+  template<nothrow-input-range R>
     requires destructible<range_value_t<R>>
     constexpr borrowed_iterator_t<R> destroy(R&& r) noexcept;
 }
 ```
 return first;
 ```
 ``` cpp
 namespace ranges {
+  template<nothrow-input-iterator I>
     requires destructible<iter_value_t<I>>
     constexpr I destroy_n(I first, iter_difference_t<I> n) noexcept;
 }
 ```
 *Effects:* Equivalent to:
 ``` 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
               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);
 ```
+*Preconditions:* For `qsort`, the objects in the array pointed to by
+`base` are of trivially copyable type.
 *Effects:* These functions have the semantics specified in the C
 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
 [alg.all.of]: #alg.all.of
 [alg.any.of]: #alg.any.of
 [alg.binary.search]: #alg.binary.search
+[alg.binary.search.general]: #alg.binary.search.general
 [alg.c.library]: #alg.c.library
 [alg.clamp]: #alg.clamp
+[alg.contains]: #alg.contains
 [alg.copy]: #alg.copy
 [alg.count]: #alg.count
+[alg.ends.with]: #alg.ends.with
 [alg.equal]: #alg.equal
 [alg.fill]: #alg.fill
 [alg.find]: #alg.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.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.replace]: #alg.replace
 [alg.reverse]: #alg.reverse
 [alg.rotate]: #alg.rotate
 [alg.search]: #alg.search
 [alg.set.operations]: #alg.set.operations
+[alg.set.operations.general]: #alg.set.operations.general
 [alg.shift]: #alg.shift
 [alg.sort]: #alg.sort
 [alg.sorting]: #alg.sorting
+[alg.sorting.general]: #alg.sorting.general
+[alg.starts.with]: #alg.starts.with
 [alg.swap]: #alg.swap
 [alg.three.way]: #alg.three.way
 [alg.transform]: #alg.transform
 [alg.unique]: #alg.unique
 [algorithm.stable]: library.md#algorithm.stable
 [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
 [conv.integral]: expr.md#conv.integral
 [cpp17.copyassignable]: #cpp17.copyassignable
 [cpp17.copyconstructible]: #cpp17.copyconstructible
 [cpp17.lessthancomparable]: #cpp17.lessthancomparable
 [cpp17.moveassignable]: #cpp17.moveassignable
 [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
 [iterator.concept.input]: iterators.md#iterator.concept.input
+[iterator.concept.random.access]: iterators.md#iterator.concept.random.access
 [iterator.concept.sentinel]: iterators.md#iterator.concept.sentinel
 [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
 [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
 [set.union]: #set.union
 [sort]: #sort
 [sort.heap]: #sort.heap
 [special.mem.concepts]: #special.mem.concepts
 [specialized.algorithms]: #specialized.algorithms
+[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
 [transform.reduce]: #transform.reduce
 [^1]: The decision whether to include a copying version was usually
     based on complexity considerations. When the cost of doing the
     operation dominates the cost of copy, the copying version is not
     included. For example, `sort_copy` is not included because the cost
+    of sorting is much more significant, and users can invoke `copy`
+    followed by `sort`.
+[^2]: `copy_backward` can be used instead of `copy` when `last` is in
     the range \[`result - `N, `result`).
+[^3]: `move_backward` can be used instead of `move` when `last` is in
     the range \[`result - `N, `result`).
 [^4]: The use of fully closed ranges is intentional.
 [^5]: This behavior intentionally differs from `max_element`.

Diff to HTML by rtfpessoa