# Standard library header <algorithm>

From cppreference.com
< cpp‎ | header

This header is part of the algorithm library.

### Functions

##### Non-modifying sequence operations
all_of any_of none_of (C++11)(C++11)(C++11) | checks if a predicate is true for all, any or none of the elements in a range (function template)
for_each | applies a function to a range of elements (function template)
for_each_n (C++17) | applies a function object to the first n elements of a sequence (function template)
count count_if | returns the number of elements satisfying specific criteria (function template)
mismatch | finds the first position where two ranges differ (function template)
find find_if find_if_not (C++11) | finds the first element satisfying specific criteria (function template)
find_end | finds the last sequence of elements in a certain range (function template)
find_first_of | searches for any one of a set of elements (function template)
adjacent_find | finds the first two adjacent items that are equal (or satisfy a given predicate) (function template)
search | searches for a range of elements (function template)
search_n | searches a range for a number of consecutive copies of an element (function template)
##### Modifying sequence operations
copy copy_if (C++11) | copies a range of elements to a new location (function template)
copy_n (C++11) | copies a number of elements to a new location (function template)
copy_backward | copies a range of elements in backwards order (function template)
move (C++11) | moves a range of elements to a new location (function template)
move_backward (C++11) | moves a range of elements to a new location in backwards order (function template)
fill | copy-assigns the given value to every element in a range (function template)
fill_n | copy-assigns the given value to N elements in a range (function template)
transform | applies a function to a range of elements (function template)
generate | assigns the results of successive function calls to every element in a range (function template)
generate_n | assigns the results of successive function calls to N elements in a range (function template)
remove remove_if | removes elements satisfying specific criteria (function template)
remove_copy remove_copy_if | copies a range of elements omitting those that satisfy specific criteria (function template)
replace replace_if | replaces all values satisfying specific criteria with another value (function template)
replace_copy replace_copy_if | copies a range, replacing elements satisfying specific criteria with another value (function template)
swap | swaps the values of two objects (function template)
swap_ranges | swaps two ranges of elements (function template)
iter_swap | swaps the elements pointed to by two iterators (function template)
reverse | reverses the order of elements in a range (function template)
reverse_copy | creates a copy of a range that is reversed (function template)
rotate | rotates the order of elements in a range (function template)
rotate_copy | copies and rotate a range of elements (function template)
shift_left shift_right (C++20) | shifts elements in a range (function template)
random_shuffle shuffle (until C++17)(C++11) | randomly re-orders elements in a range (function template)
sample (C++17) | selects n random elements from a sequence (function template)
unique | removes consecutive duplicate elements in a range (function template)
unique_copy | creates a copy of some range of elements that contains no consecutive duplicates (function template)
##### Partitioning operations
is_partitioned (C++11) | determines if the range is partitioned by the given predicate (function template)
partition | divides a range of elements into two groups (function template)
partition_copy (C++11) | copies a range dividing the elements into two groups (function template)
stable_partition | divides elements into two groups while preserving their relative order (function template)
partition_point (C++11) | locates the partition point of a partitioned range (function template)
##### Sorting operations
is_sorted (C++11) | checks whether a range is sorted into ascending order (function template)
is_sorted_until (C++11) | finds the largest sorted subrange (function template)
sort | sorts a range into ascending order (function template)
partial_sort | sorts the first N elements of a range (function template)
partial_sort_copy | copies and partially sorts a range of elements (function template)
stable_sort | sorts a range of elements while preserving order between equal elements (function template)
nth_element | partially sorts the given range making sure that it is partitioned by the given element (function template)
##### Binary search operations (on sorted ranges)
lower_bound | returns an iterator to the first element not less than the given value (function template)
upper_bound | returns an iterator to the first element greater than a certain value (function template)
binary_search | determines if an element exists in a certain range (function template)
equal_range | returns range of elements matching a specific key (function template)
##### Other operations on sorted ranges
merge | merges two sorted ranges (function template)
inplace_merge | merges two ordered ranges in-place (function template)
##### Set operations (on sorted ranges)
includes | returns true if one set is a subset of another (function template)
set_difference | computes the difference between two sets (function template)
set_intersection | computes the intersection of two sets (function template)
set_symmetric_difference | computes the symmetric difference between two sets (function template)
set_union | computes the union of two sets (function template)
##### Heap operations
is_heap (C++11) | checks if the given range is a max heap (function template)
is_heap_until (C++11) | finds the largest subrange that is a max heap (function template)
make_heap | creates a max heap out of a range of elements (function template)
push_heap | adds an element to a max heap (function template)
pop_heap | removes the largest element from a max heap (function template)
sort_heap | turns a max heap into a range of elements sorted in ascending order (function template)
##### Minimum/maximum operations
max | returns the greater of the given values (function template)
max_element | returns the largest element in a range (function template)
min | returns the smaller of the given values (function template)
min_element | returns the smallest element in a range (function template)
minmax (C++11) | returns the smaller and larger of two elements (function template)
minmax_element (C++11) | returns the smallest and the largest elements in a range (function template)
clamp (C++17) | clamps a value between a pair of boundary values (function template)
##### Comparison operations
equal | determines if two sets of elements are the same (function template)
lexicographical_compare | returns true if one range is lexicographically less than another (function template)
compare_3way (C++20) | compares two values using three-way comparison (function template)
lexicographical_compare_3way (C++20) | compares two ranges using three-way comparison (function template)
##### Permutation operations
is_permutation (C++11) | determines if a sequence is a permutation of another sequence (function template)
next_permutation | generates the next greater lexicographic permutation of a range of elements (function template)
prev_permutation | generates the next smaller lexicographic permutation of a range of elements (function template)

### Niebloids

Defined in namespace `std::ranges`
##### Non-modifying sequence operations
all_of any_of none_of | checks if a predicate is true for all, any or none of the elements in a range (niebloid)
for_each | applies a function to a range of elements (niebloid)
count count_if | returns the number of elements satisfying specific criteria (niebloid)
mismatch | finds the first position where two ranges differ (niebloid)
find find_if find_if_not | finds the first element satisfying specific criteria (niebloid)
find_end | finds the last sequence of elements in a certain range (niebloid)
find_first_of | searches for any one of a set of elements (niebloid)
adjacent_find | finds the first two adjacent items that are equal (or satisfy a given predicate) (niebloid)
search | searches for a range of elements (niebloid)
search_n | searches for a number consecutive copies of an element in a range (niebloid)
##### Modifying sequence operations
copy copy_if | copies a range of elements to a new location (niebloid)
copy_n | copies a number of elements to a new location (niebloid)
copy_backward | copies a range of elements in backwards order (niebloid)
move | moves a range of elements to a new location (niebloid)
move_backward | moves a range of elements to a new location in backwards order (niebloid)
fill | assigns a range of elements a certain value (niebloid)
fill_n | assigns a value to a number of elements (niebloid)
transform | applies a function to a range of elements (niebloid)
generate | saves the result of a function in a range (niebloid)
generate_n | saves the result of N applications of a function (niebloid)
remove remove_if | removes elements satisfying specific criteria (niebloid)
remove_copy remove_copy_if | copies a range of elements omitting those that satisfy specific criteria (niebloid)
replace replace_if | replaces all values satisfying specific criteria with another value (niebloid)
replace_copy replace_copy_if | copies a range, replacing elements satisfying specific criteria with another value (niebloid)
swap_ranges | swaps two ranges of elements (niebloid)
reverse | reverses the order of elements in a range (niebloid)
reverse_copy | creates a copy of a range that is reversed (niebloid)
rotate | rotates the order of elements in a range (niebloid)
rotate_copy | copies and rotate a range of elements (niebloid)
shuffle | randomly re-orders elements in a range (niebloid)
unique | removes consecutive duplicate elements in a range (niebloid)
unique_copy | creates a copy of some range of elements that contains no consecutive duplicates (niebloid)
##### Partitioning operations
is_partitioned | determines if the range is partitioned by the given predicate (niebloid)
partition | divides a range of elements into two groups (niebloid)
partition_copy | copies a range dividing the elements into two groups (niebloid)
stable_partition | divides elements into two groups while preserving their relative order (niebloid)
partition_point | locates the partition point of a partitioned range (niebloid)
##### Sorting operations
is_sorted | checks whether a range is sorted into ascending order (niebloid)
is_sorted_until | finds the largest sorted subrange (niebloid)
sort | sorts a range into ascending order (niebloid)
partial_sort | sorts the first N elements of a range (niebloid)
partial_sort_copy | copies and partially sorts a range of elements (niebloid)
stable_sort | sorts a range of elements while preserving order between equal elements (niebloid)
nth_element | partially sorts the given range making sure that it is partitioned by the given element (niebloid)
##### Binary search operations (on sorted ranges)
lower_bound | returns an iterator to the first element not less than the given value (niebloid)
upper_bound | returns an iterator to the first element greater than a certain value (niebloid)
binary_search | determines if an element exists in a certain range (niebloid)
equal_range | returns range of elements matching a specific key (niebloid)
##### Other operations on sorted ranges
merge | merges two sorted ranges (niebloid)
inplace_merge | merges two ordered ranges in-place (niebloid)
##### Set operations (on sorted ranges)
includes | returns true if one set is a subset of another (niebloid)
set_difference | computes the difference between two sets (niebloid)
set_intersection | computes the intersection of two sets (niebloid)
set_symmetric_difference | computes the symmetric difference between two sets (niebloid)
set_union | computes the union of two sets (niebloid)
##### Heap operations
is_heap | checks if the given range is a max heap (niebloid)
is_heap_until | finds the largest subrange that is a max heap (niebloid)
make_heap | creates a max heap out of a range of elements (niebloid)
push_heap | adds an element to a max heap (niebloid)
pop_heap | removes the largest element from a max heap (niebloid)
sort_heap | turns a max heap into a range of elements sorted in ascending order (niebloid)
##### Minimum/maximum operations
max | returns the greater of the given values (niebloid)
max_element | returns the largest element in a range (niebloid)
min | returns the smaller of the given values (niebloid)
min_element | returns the smallest element in a range (niebloid)
minmax | returns the smaller and larger of two elements (niebloid)
minmax_element | returns the smallest and the largest elements in a range (niebloid)
##### Comparison operations
equal | determines if two sets of elements are the same (niebloid)
lexicographical_compare | returns true if one range is lexicographically less than another (niebloid)
##### Permutation operations
is_permutation | determines if a sequence is a permutation of another sequence (niebloid)
next_permutation | generates the next greater lexicographic permutation of a range of elements (niebloid)
prev_permutation | generates the next smaller lexicographic permutation of a range of elements (niebloid)

### Synopsis

    #include <initializer_list>

    namespace std {
      // non-modifying sequence operations:
      // all of:
      template<class InputIt, class Pred>
        constexpr bool all_of(InputIt first, InputIt last, Pred pred);
      template<class ExecutionPolicy, class ForwardIt, class Pred>
        bool all_of(ExecutionPolicy&& exec,
                    ForwardIt first, ForwardIt last, Pred pred);

      namespace ranges {
        template<InputIterator I, Sentinel<I> S, class Proj = identity,
                 IndirectUnaryPredicate<projected<I, Proj>> Pred>
          constexpr bool all_of(I first, S last, Pred pred, Proj proj = {});
        template<InputRange R, class Proj = identity,
                 IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
          constexpr bool all_of(R&& r, Pred pred, Proj proj = {});
      }

      // any of:
      template<class InputIt, class Pred>
        constexpr bool any_of(InputIt first, InputIt last, Pred pred);
      template<class ExecutionPolicy, class ForwardIt, class Pred>
        bool any_of(ExecutionPolicy&& exec,
                    ForwardIt first, ForwardIt last, Pred pred);

      namespace ranges {
        template<InputIterator I, Sentinel<I> S, class Proj = identity,
                 IndirectUnaryPredicate<projected<I, Proj>> Pred>
          constexpr bool any_of(I first, S last, Pred pred, Proj proj = {});
        template<InputRange R, class Proj = identity,
                 IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
          constexpr bool any_of(R&& r, Pred pred, Proj proj = {});
      }

      // none of:
      template<class InputIt, class Pred>
        constexpr bool none_of(InputIt first, InputIt last, Pred pred);
      template<class ExecutionPolicy, class ForwardIt, class Pred>
        bool none_of(ExecutionPolicy&& exec,
                     ForwardIt first, ForwardIt last, Pred pred);

      namespace ranges {
        template<InputIterator I, Sentinel<I> S, class Proj = identity,
                 IndirectUnaryPredicate<projected<I, Proj>> Pred>
          constexpr bool none_of(I first, S last, Pred pred, Proj proj = {});
        template<InputRange R, class Proj = identity,
                 IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
          constexpr bool none_of(R&& r, Pred pred, Proj proj = {});
      }

      // for each:
      template<class InputIt, class Function>
        constexpr Function for_each(InputIt first, InputIt last, Function f);
      template<class ExecutionPolicy, class ForwardIt, class Function>
        void for_each(ExecutionPolicy&& exec,
                      ForwardIt first, ForwardIt last, Function f);

      namespace ranges {
        template<class I, class F>
        struct for_each_result {
          [[no_unique_address]] I in;
          [[no_unique_address]] F fun;

          template<class I2, class F2>
            requires ConvertibleTo<const I&, I2> && ConvertibleTo<const F&, F2>
            operator for_each_result<I2, F2>() const & {
              return {in, fun};
            }

          template<class I2, class F2>
            requires ConvertibleTo<I, I2> && ConvertibleTo<F, F2>
            operator for_each_result<I2, F2>() && {
              return {std::move(in), std::move(fun)};
            }
        };

        template<InputIterator I, Sentinel<I> S, class Proj = identity,
                 IndirectUnaryInvocable<projected<I, Proj>> Fun>
          constexpr for_each_result<I, Fun>
            for_each(I first, S last, Fun f, Proj proj = {});
        template<InputRange R, class Proj = identity,
                 IndirectUnaryInvocable<projected<iterator_t<R>, Proj>> Fun>
          constexpr for_each_result<safe_iterator_t<R>, Fun>
            for_each(R&& r, Fun f, Proj proj = {});
      }

      template<class InputIt, class Size, class Function>
        constexpr InputIt for_each_n(InputIt first, Size n, Function f);
      template<class ExecutionPolicy, class ForwardIt, class Size, class Function>
        ForwardIt for_each_n(ExecutionPolicy&& exec,
                             ForwardIt first, Size n, Function f);

      // find:
      template<class InputIt, class T>
        constexpr InputIt find(InputIt first, InputIt last,
                               const T& value);
      template<class ExecutionPolicy, class ForwardIt, class T>
        ForwardIt find(ExecutionPolicy&& exec,
                       ForwardIt first, ForwardIt last, const T& value);
      template<class InputIt, class Pred>
        constexpr InputIt find_if(InputIt first, InputIt last, Pred pred);
      template<class ExecutionPolicy, class ForwardIt, class Pred>
        ForwardIt find_if(ExecutionPolicy&& exec,
                          ForwardIt first, ForwardIt last, Pred pred);
      template<class InputIt, class Pred>
        constexpr InputIt find_if_not(InputIt first, InputIt last, Pred pred);
      template<class ExecutionPolicy, class ForwardIt, class Pred>
        ForwardIt find_if_not(ExecutionPolicy&& exec,
                              ForwardIt first, ForwardIt last, Pred pred);

      namespace ranges {
        template<InputIterator I, Sentinel<I> S, class T, class Proj = identity>
          requires IndirectRelation<ranges::equal_to, projected<I, Proj>, const T*>
          constexpr I find(I first, S last, const T& value, Proj proj = {});
        template<InputRange R, class T, class Proj = identity>
          requires IndirectRelation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
          constexpr safe_iterator_t<R>
            find(R&& r, const T& value, Proj proj = {});
        template<InputIterator I, Sentinel<I> S, class Proj = identity,
                 IndirectUnaryPredicate<projected<I, Proj>> Pred>
          constexpr I find_if(I first, S last, Pred pred, Proj proj = {});
        template<InputRange R, class Proj = identity,
                 IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
          constexpr safe_iterator_t<R>
            find_if(R&& r, Pred pred, Proj proj = {});
        template<InputIterator I, Sentinel<I> S, class Proj = identity,
                 IndirectUnaryPredicate<projected<I, Proj>> Pred>
          constexpr I find_if_not(I first, S last, Pred pred, Proj proj = {});
        template<InputRange R, class Proj = identity,
                 IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
          constexpr safe_iterator_t<R>
            find_if_not(R&& r, Pred pred, Proj proj = {});
      }

      // find end:
      template<class ForwardIt1, class ForwardIt2>
        constexpr ForwardIt1
          find_end(ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2);
      template<class ForwardIt1, class ForwardIt2, class BinaryPred>
        constexpr ForwardIt1
          find_end(ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2,
                   BinaryPred pred);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2>
        ForwardIt1
          find_end(ExecutionPolicy&& exec,
                   ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2);
      template<class ExecutionPolicy, class ForwardIt1,
               class ForwardIt2, class BinaryPred>
        ForwardIt1
          find_end(ExecutionPolicy&& exec,
                   ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2,
                   BinaryPred pred);

      namespace ranges {
        template<ForwardIterator I1, Sentinel<I1> S1, ForwardIterator I2, Sentinel<I2> S2,
                 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
          requires IndirectlyComparable<I1, I2, Pred, Proj1, Proj2>
          constexpr subrange<I1>
            find_end(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
                     Proj1 proj1 = {}, Proj2 proj2 = {});
        template<ForwardRange R1, ForwardRange R2,
                 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
          requires IndirectlyComparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
          constexpr safe_subrange_t<R1>
            find_end(R1&& r1, R2&& r2, Pred pred = {},
                     Proj1 proj1 = {}, Proj2 proj2 = {});
      }

      // find first:
      template<class InputIt, class ForwardIt>
        constexpr InputIt
          find_first_of(InputIt first1, InputIt last1, ForwardIt first2, ForwardIt last2);
      template<class InputIt, class ForwardIt, class BinaryPred>
        constexpr InputIt
          find_first_of(InputIt first1, InputIt last1, ForwardIt first2, ForwardIt last2,
                        BinaryPred pred);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2>
        ForwardIt1
          find_first_of(ExecutionPolicy&& exec,
                        ForwardIt1 first1, ForwardIt1 last1,
                        ForwardIt2 first2, ForwardIt2 last2);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class BinaryPred>
        ForwardIt1
          find_first_of(ExecutionPolicy&& exec,
                        ForwardIt1 first1, ForwardIt1 last1,
                        ForwardIt2 first2, ForwardIt2 last2,
                        BinaryPred pred);

      namespace ranges {
        template<InputIterator I1, Sentinel<I1> S1, ForwardIterator I2, Sentinel<I2> S2,
                 class Proj1 = identity, class Proj2 = identity,
                 IndirectRelation<projected<I1, Proj1>,
                                  projected<I2, Proj2>> Pred = ranges::equal_to>
          constexpr I1 find_first_of(I1 first1, S1 last1, I2 first2, S2 last2,
                                     Pred pred = {},
                                     Proj1 proj1 = {}, Proj2 proj2 = {});
        template<InputRange R1, ForwardRange R2,
                 class Proj1 = identity, class Proj2 = identity,
                 IndirectRelation<projected<iterator_t<R1>, Proj1>,
                                  projected<iterator_t<R2>, Proj2>> Pred = ranges::equal_to>
          constexpr safe_iterator_t<R1>
            find_first_of(R1&& r1, R2&& r2,
                          Pred pred = {},
                          Proj1 proj1 = {}, Proj2 proj2 = {});
      }

      // adjacent find:
      template<class ForwardIt>
        constexpr ForwardIt
          adjacent_find(ForwardIt first, ForwardIt last);
      template<class ForwardIt, class BinaryPred>
        constexpr ForwardIt
          adjacent_find(ForwardIt first, ForwardIt last, BinaryPred pred);
      template<class ExecutionPolicy, class ForwardIt>
        ForwardIt
          adjacent_find(ExecutionPolicy&& exec,
                        ForwardIt first, ForwardIt last);
      template<class ExecutionPolicy, class ForwardIt, class BinaryPred>
        ForwardIt
          adjacent_find(ExecutionPolicy&& exec,
                        ForwardIt first, ForwardIt last, BinaryPred pred);

      namespace ranges {
        template<ForwardIterator I, Sentinel<I> S, class Proj = identity,
                 IndirectRelation<projected<I, Proj>> Pred = ranges::equal_to>
          constexpr I adjacent_find(I first, S last, Pred pred = {},
                                    Proj proj = {});
        template<ForwardRange R, class Proj = identity,
                 IndirectRelation<projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
          constexpr safe_iterator_t<R>
            adjacent_find(R&& r, Pred pred = {}, Proj proj = {});
      }

      // count:
      template<class InputIt, class T>
        constexpr typename iterator_traits<InputIt>::difference_type
          count(InputIt first, InputIt last, const T& value);
      template<class ExecutionPolicy, class ForwardIt, class T>
        typename iterator_traits<ForwardIt>::difference_type
          count(ExecutionPolicy&& exec,
                ForwardIt first, ForwardIt last, const T& value);
      template<class InputIt, class Pred>
        constexpr typename iterator_traits<InputIt>::difference_type
          count_if(InputIt first, InputIt last, Pred pred);
      template<class ExecutionPolicy, class ForwardIt, class Pred>
        typename iterator_traits<ForwardIt>::difference_type
          count_if(ExecutionPolicy&& exec,
                   ForwardIt first, ForwardIt last, Pred pred);

      namespace ranges {
        template<InputIterator I, Sentinel<I> S, class T, class Proj = identity>
          requires IndirectRelation<ranges::equal_to, projected<I, Proj>, const T*>
          constexpr iter_difference_t<I>
            count(I first, S last, const T& value, Proj proj = {});
        template<InputRange R, class T, class Proj = identity>
          requires IndirectRelation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
          constexpr iter_difference_t<iterator_t<R>>
            count(R&& r, const T& value, Proj proj = {});
        template<InputIterator I, Sentinel<I> S, class Proj = identity,
                 IndirectUnaryPredicate<projected<I, Proj>> Pred>
          constexpr iter_difference_t<I>
            count_if(I first, S last, Pred pred, Proj proj = {});
        template<InputRange R, class Proj = identity,
                 IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
          constexpr iter_difference_t<iterator_t<R>>
            count_if(R&& r, Pred pred, Proj proj = {});
      }

      // mismatch:
      template<class InputIt1, class InputIt2>
        constexpr pair<InputIt1, InputIt2>
          mismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2);
      template<class InputIt1, class InputIt2, class BinaryPred>
        constexpr pair<InputIt1, InputIt2>
          mismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2, BinaryPred pred);
      template<class InputIt1, class InputIt2>
        constexpr pair<InputIt1, InputIt2>
          mismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2);
      template<class InputIt1, class InputIt2, class BinaryPred>
        constexpr pair<InputIt1, InputIt2>
          mismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2,
                   BinaryPred pred);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2>
        pair<ForwardIt1, ForwardIt2>
          mismatch(ExecutionPolicy&& exec,
                   ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2,
               class BinaryPred>
        pair<ForwardIt1, ForwardIt2>
          mismatch(ExecutionPolicy&& exec,
                   ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, BinaryPred pred);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2>
        pair<ForwardIt1, ForwardIt2>
          mismatch(ExecutionPolicy&& exec,
                   ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class BinaryPred>
        pair<ForwardIt1, ForwardIt2>
          mismatch(ExecutionPolicy&& exec,
                   ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2,
                   BinaryPred pred);

      namespace ranges {
        template<class I1, class I2>
        struct mismatch_result {
          [[no_unique_address]] I1 in1;
          [[no_unique_address]] I2 in2;

          template<class II1, class II2>
            requires ConvertibleTo<const I1&, II1> && ConvertibleTo<const I2&, II2>
            operator mismatch_result<II1, II2>() const & {
              return {in1, in2};
            }

          template<class II1, class II2>
            requires ConvertibleTo<I1, II1> && ConvertibleTo<I2, II2>
            operator mismatch_result<II1, II2>() && {
              return {std::move(in1), std::move(in2)};
            }
        };

        template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
                 class Proj1 = identity, class Proj2 = identity,
                 IndirectRelation<projected<I1, Proj1>,
                                  projected<I2, Proj2>> Pred = ranges::equal_to>
          constexpr mismatch_result<I1, I2>
            mismatch(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
                     Proj1 proj1 = {}, Proj2 proj2 = {});
        template<InputRange R1, InputRange R2,
                 class Proj1 = identity, class Proj2 = identity,
                 IndirectRelation<projected<iterator_t<R1>, Proj1>,
                                  projected<iterator_t<R2>, Proj2>> Pred = ranges::equal_to>
          constexpr mismatch_result<safe_iterator_t<R1>, safe_iterator_t<R2>>
            mismatch(R1&& r1, R2&& r2, Pred pred = {},
                     Proj1 proj1 = {}, Proj2 proj2 = {});
      }

      // equal:
      template<class InputIt1, class InputIt2>
        constexpr bool equal(InputIt1 first1, InputIt1 last1, InputIt2 first2);
      template<class InputIt1, class InputIt2, class BinaryPred>
        constexpr bool equal(InputIt1 first1, InputIt1 last1, InputIt2 first2,
                             BinaryPred pred);
      template<class InputIt1, class InputIt2>
        constexpr bool equal(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2);
      template<class InputIt1, class InputIt2, class BinaryPred>
        constexpr bool equal(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2,
                             BinaryPred pred);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2>
        bool equal(ExecutionPolicy&& exec,
                   ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class BinaryPred>
        bool equal(ExecutionPolicy&& exec,
                   ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, BinaryPred pred);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2>
        bool equal(ExecutionPolicy&& exec,
                   ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class BinaryPred>
        bool equal(ExecutionPolicy&& exec,
                   ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2,
                   BinaryPred pred);

      namespace ranges {
        template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
                 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
          requires IndirectlyComparable<I1, I2, Pred, Proj1, Proj2>
          constexpr bool equal(I1 first1, S1 last1, I2 first2, S2 last2,
                               Pred pred = {},
                               Proj1 proj1 = {}, Proj2 proj2 = {});
        template<InputRange R1, InputRange R2, class Pred = ranges::equal_to,
                 class Proj1 = identity, class Proj2 = identity>
          requires IndirectlyComparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
          constexpr bool equal(R1&& r1, R2&& r2, Pred pred = {},
                               Proj1 proj1 = {}, Proj2 proj2 = {});
      }

      // is permutation:
      template<class ForwardIt1, class ForwardIt2>
        constexpr bool is_permutation(ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2);
      template<class ForwardIt1, class ForwardIt2, class BinaryPred>
        constexpr bool is_permutation(ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2,
                                      BinaryPred pred);
      template<class ForwardIt1, class ForwardIt2>
        constexpr bool is_permutation(ForwardIt1 first1, ForwardIt1 last1,
                                      ForwardIt2 first2, ForwardIt2 last2);
      template<class ForwardIt1, class ForwardIt2, class BinaryPred>
        constexpr bool is_permutation(ForwardIt1 first1, ForwardIt1 last1,
                                      ForwardIt2 first2, ForwardIt2 last2,
                                      BinaryPred pred);

      namespace ranges {
        template<ForwardIterator I1, Sentinel<I1> S1, ForwardIterator I2,
                 Sentinel<I2> S2, class Pred = ranges::equal_to, class Proj1 = identity,
                 class Proj2 = identity>
          requires IndirectlyComparable<I1, I2, Pred, Proj1, Proj2>
          constexpr bool is_permutation(I1 first1, S1 last1, I2 first2, S2 last2,
                                        Pred pred = {},
                                        Proj1 proj1 = {}, Proj2 proj2 = {});
        template<ForwardRange R1, ForwardRange R2, class Pred = ranges::equal_to,
                 class Proj1 = identity, class Proj2 = identity>
          requires IndirectlyComparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
          constexpr bool is_permutation(R1&& r1, R2&& r2, Pred pred = {},
                                        Proj1 proj1 = {}, Proj2 proj2 = {});
      }

      // search:
      template<class ForwardIt1, class ForwardIt2>
        constexpr ForwardIt1
          search(ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2);
      template<class ForwardIt1, class ForwardIt2, class BinaryPred>
        constexpr ForwardIt1
          search(ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2,
                 BinaryPred pred);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2>
        ForwardIt1
          search(ExecutionPolicy&& exec,
                 ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class BinaryPred>
        ForwardIt1
          search(ExecutionPolicy&& exec,
                 ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2,
                 BinaryPred pred);

      namespace ranges {
        template<ForwardIterator I1, Sentinel<I1> S1, ForwardIterator I2,
                 Sentinel<I2> S2, class Pred = ranges::equal_to,
                 class Proj1 = identity, class Proj2 = identity>
          requires IndirectlyComparable<I1, I2, Pred, Proj1, Proj2>
          constexpr subrange<I1>
            search(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
                   Proj1 proj1 = {}, Proj2 proj2 = {});
        template<ForwardRange R1, ForwardRange R2, class Pred = ranges::equal_to,
                 class Proj1 = identity, class Proj2 = identity>
          requires IndirectlyComparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
          constexpr safe_subrange_t<R1>
            search(R1&& r1, R2&& r2, Pred pred = {},
                   Proj1 proj1 = {}, Proj2 proj2 = {});
      }

      template<class ForwardIt, class Size, class T>
        constexpr ForwardIt
          search_n(ForwardIt first, ForwardIt last, Size count, const T& value);
      template<class ForwardIt, class Size, class T, class BinaryPred>
        constexpr ForwardIt
          search_n(ForwardIt first, ForwardIt last,
                   Size count, const T& value, BinaryPred pred);
      template<class ExecutionPolicy, class ForwardIt, class Size, class T>
        ForwardIt
          search_n(ExecutionPolicy&& exec,
                   ForwardIt first, ForwardIt last, Size count, const T& value);
      template<class ExecutionPolicy, class ForwardIt, class Size, class T, class BinaryPred>
        ForwardIt
          search_n(ExecutionPolicy&& exec,
                   ForwardIt first, ForwardIt last,
                   Size count, const T& value, BinaryPred pred);

      namespace ranges {
        template<ForwardIterator I, Sentinel<I> S, class T,
                 class Pred = ranges::equal_to, class Proj = identity>
          requires IndirectlyComparable<I, const T*, Pred, Proj>
          constexpr subrange<I>
            search_n(I first, S last, iter_difference_t<I> count,
                     const T& value, Pred pred = {}, Proj proj = {});
        template<ForwardRange R, class T, class Pred = ranges::equal_to,
                 class Proj = identity>
          requires IndirectlyComparable<iterator_t<R>, const T*, Pred, Proj>
          constexpr safe_subrange_t<R>
            search_n(R&& r, iter_difference_t<iterator_t<R>> count,
                     const T& value, Pred pred = {}, Proj proj = {});
      }

      template<class ForwardIt, class Searcher>
        constexpr ForwardIt
          search(ForwardIt first, ForwardIt last, const Searcher& searcher);

      // mutating sequence operations:
      // copy:
      template<class InputIt, class OutputIt>
        constexpr OutputIt copy(InputIt first, InputIt last, OutputIt result);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2>
        ForwardIt2 copy(ExecutionPolicy&& exec,
                        ForwardIt1 first, ForwardIt1 last, ForwardIt2 result);

      namespace ranges {
        template<class I, class O>
        struct copy_result {
          [[no_unique_address]] I in;
          [[no_unique_address]] O out;

          template<class I2, class O2>
            requires ConvertibleTo<const I&, I2> && ConvertibleTo<const O&, O2>
            operator copy_result<I2, O2>() const & {
              return {in, out};
            }

          template<class I2, class O2>
            requires ConvertibleTo<I, I2> && ConvertibleTo<O, O2>
            operator copy_result<I2, O2>() && {
              return {std::move(in), std::move(out)};
            }
        };

        template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O>
          requires IndirectlyCopyable<I, O>
          constexpr copy_result<I, O>
            copy(I first, S last, O result);
        template<InputRange R, WeaklyIncrementable O>
          requires IndirectlyCopyable<iterator_t<R>, O>
          constexpr copy_result<safe_iterator_t<R>, O>
            copy(R&& r, O result);
      }

      template<class InputIt, class Size, class OutputIt>
        constexpr OutputIt copy_n(InputIt first, Size n, OutputIt result);
      template<class ExecutionPolicy, class ForwardIt1, class Size, class ForwardIt2>
        ForwardIt2 copy_n(ExecutionPolicy&& exec,
                          ForwardIt1 first, Size n, ForwardIt2 result);

      namespace ranges {
        template<class I, class O>
        using copy_n_result = copy_result<I, O>;

        template<InputIterator I, WeaklyIncrementable O>
          requires IndirectlyCopyable<I, O>
          constexpr copy_n_result<I, O>
            copy_n(I first, iter_difference_t<I> n, O result);
      }

      template<class InputIt, class OutputIt, class Pred>
        constexpr OutputIt copy_if(InputIt first, InputIt last, OutputIt result, Pred pred);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class Pred>
        ForwardIt2 copy_if(ExecutionPolicy&& exec,
                           ForwardIt1 first, ForwardIt1 last, ForwardIt2 result, Pred pred);

      namespace ranges {
        template<class I, class O>
        using copy_if_result = copy_result<I, O>;

        template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O, class Proj = identity,
                 IndirectUnaryPredicate<projected<I, Proj>> Pred>
          requires IndirectlyCopyable<I, O>
          constexpr copy_if_result<I, O>
            copy_if(I first, S last, O result, Pred pred, Proj proj = {});
        template<InputRange R, WeaklyIncrementable O, class Proj = identity,
                 IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
          requires IndirectlyCopyable<iterator_t<R>, O>
          constexpr copy_if_result<safe_iterator_t<R>, O>
            copy_if(R&& r, O result, Pred pred, Proj proj = {});
      }

      template<class BidirectionalIt1, class BidirectionalIt2>
        constexpr BidirectionalIt2
          copy_backward(BidirectionalIt1 first, BidirectionalIt1 last,
                        BidirectionalIt2 result);

      namespace ranges {
        template<class I1, class I2>
        using copy_backward_result = copy_result<I1, I2>;

        template<BidirectionalIterator I1, Sentinel<I1> S1, BidirectionalIterator I2>
          requires IndirectlyCopyable<I1, I2>
          constexpr copy_backward_result<I1, I2>
            copy_backward(I1 first, S1 last, I2 result);
        template<BidirectionalRange R, BidirectionalIterator I>
          requires IndirectlyCopyable<iterator_t<R>, I>
          constexpr copy_backward_result<safe_iterator_t<R>, I>
            copy_backward(R&& r, I result);
      }

      // move:
      template<class InputIt, class OutputIt>
        constexpr OutputIt move(InputIt first, InputIt last, OutputIt result);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2>
        ForwardIt2 move(ExecutionPolicy&& exec,
                        ForwardIt1 first, ForwardIt1 last, ForwardIt2 result);

      namespace ranges {
        template<class I, class O>
        using move_result = copy_result<I, O>;

        template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O>
          requires IndirectlyMovable<I, O>
          constexpr move_result<I, O>
            move(I first, S last, O result);
        template<InputRange R, WeaklyIncrementable O>
          requires IndirectlyMovable<iterator_t<R>, O>
          constexpr move_result<safe_iterator_t<R>, O>
            move(R&& r, O result);
      }

      template<class BidirectionalIt1, class BidirectionalIt2>
        constexpr BidirectionalIt2
          move_backward(BidirectionalIt1 first, BidirectionalIt1 last,
                        BidirectionalIt2 result);

      namespace ranges {
        template<class I1, class I2>
        using move_backward_result = copy_result<I1, I2>;

        template<BidirectionalIterator I1, Sentinel<I1> S1, BidirectionalIterator I2>
          requires IndirectlyMovable<I1, I2>
          constexpr move_backward_result<I1, I2>
            move_backward(I1 first, S1 last, I2 result);
        template<BidirectionalRange R, BidirectionalIterator I>
          requires IndirectlyMovable<iterator_t<R>, I>
          constexpr move_backward_result<safe_iterator_t<R>, I>
            move_backward(R&& r, I result);
      }

      // swap:
      template<class ForwardIt1, class ForwardIt2>
        constexpr ForwardIt2 swap_ranges(ForwardIt1 first1, ForwardIt1 last1,
                                         ForwardIt2 first2);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2>
        ForwardIt2 swap_ranges(ExecutionPolicy&& exec,
                               ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2);

      namespace ranges {
        template<class I1, class I2>
        using swap_ranges_result = mismatch_result<I1, I2>;

        template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2>
          requires IndirectlySwappable<I1, I2>
          constexpr swap_ranges_result<I1, I2>
            swap_ranges(I1 first1, S1 last1, I2 first2, S2 last2);
        template<InputRange R1, InputRange R2>
          requires IndirectlySwappable<iterator_t<R1>, iterator_t<R2>>
          constexpr swap_ranges_result<safe_iterator_t<R1>, safe_iterator_t<R2>>
            swap_ranges(R1&& r1, R2&& r2);
      }

      template<class ForwardIt1, class ForwardIt2>
        constexpr void iter_swap(ForwardIt1 a, ForwardIt2 b);

      // transform:
      template<class InputIt, class OutputIt, class UnaryOperation>
        constexpr OutputIt
          transform(InputIt first1, InputIt last1, OutputIt result, UnaryOperation op);
      template<class InputIt1, class InputIt2, class OutputIt, class BinaryOperation>
        constexpr OutputIt
          transform(InputIt1 first1, InputIt1 last1, InputIt2 first2, OutputIt result,
                    BinaryOperation binary_op);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class UnaryOperation>
        ForwardIt2
          transform(ExecutionPolicy&& exec,
                    ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 result, UnaryOperation op);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2,
               class ForwardIt, class BinaryOperation>
        ForwardIt
          transform(ExecutionPolicy&& exec,
                    ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt result,
                    BinaryOperation binary_op);

      namespace ranges {
        template<class I, class O>
        using unary_transform_result = copy_result<I, O>;

        template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O,
                 CopyConstructible F, class Proj = identity>
          requires Writable<O, indirect_result_t<F&, projected<I, Proj>>>
          constexpr unary_transform_result<I, O>
            transform(I first1, S last1, O result, F op, Proj proj = {});
        template<InputRange R, WeaklyIncrementable O, CopyConstructible F,
                 class Proj = identity>
          requires Writable<O, indirect_result_t<F&, projected<iterator_t<R>, Proj>>>
          constexpr unary_transform_result<safe_iterator_t<R>, O>
            transform(R&& r, O result, F op, Proj proj = {});

        template<class I1, class I2, class O>
        struct binary_transform_result {
          [[no_unique_address]] I1 in1;
          [[no_unique_address]] I2 in2;
          [[no_unique_address]] O  out;

          template<class II1, class II2, class OO>
            requires ConvertibleTo<const I1&, II1> &&
              ConvertibleTo<const I2&, II2> && ConvertibleTo<const O&, OO>
            operator binary_transform_result<II1, II2, OO>() const & {
              return {in1, in2, out};
            }

          template<class II1, class II2, class OO>
            requires ConvertibleTo<I1, II1> &&
              ConvertibleTo<I2, II2> && ConvertibleTo<O, OO>
            operator binary_transform_result<II1, II2, OO>() && {
              return {std::move(in1), std::move(in2), std::move(out)};
            }
        };

        template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
                 WeaklyIncrementable O, CopyConstructible F, class Proj1 = identity,
                 class Proj2 = identity>
          requires Writable<O, indirect_result_t<F&, projected<I1, Proj1>,
                                                 projected<I2, Proj2>>>
          constexpr binary_transform_result<I1, I2, O>
            transform(I1 first1, S1 last1, I2 first2, S2 last2, O result,
                      F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});
        template<InputRange R1, InputRange R2, WeaklyIncrementable O,
                 CopyConstructible F, class Proj1 = identity, class Proj2 = identity>
          requires Writable<O, indirect_result_t<F&, projected<iterator_t<R1>, Proj1>,
                                                 projected<iterator_t<R2>, Proj2>>>
          constexpr binary_transform_result<safe_iterator_t<R1>, safe_iterator_t<R2>, O>
            transform(R1&& r1, R2&& r2, O result,
                      F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});
      }

      // replace:
      template<class ForwardIt, class T>
        constexpr void replace(ForwardIt first, ForwardIt last,
                               const T& old_value, const T& new_value);
      template<class ExecutionPolicy, class ForwardIt, class T>
        void replace(ExecutionPolicy&& exec,
                     ForwardIt first, ForwardIt last,
                     const T& old_value, const T& new_value);
      template<class ForwardIt, class Pred, class T>
        constexpr void replace_if(ForwardIt first, ForwardIt last,
                                  Pred pred, const T& new_value);
      template<class ExecutionPolicy, class ForwardIt, class Pred, class T>
        void replace_if(ExecutionPolicy&& exec,
                        ForwardIt first, ForwardIt last,
                        Pred pred, const T& new_value);

      namespace ranges {
        template<InputIterator I, Sentinel<I> S, class T1, class T2, class Proj = identity>
          requires Writable<I, const T2&> &&
                   IndirectRelation<ranges::equal_to, projected<I, Proj>, const T1*>
          constexpr I
            replace(I first, S last, const T1& old_value, const T2& new_value, Proj proj = {});
        template<InputRange R, class T1, class T2, class Proj = identity>
          requires Writable<iterator_t<R>, const T2&> &&
                   IndirectRelation<ranges::equal_to, projected<iterator_t<R>, Proj>,
                     const T1*>
          constexpr safe_iterator_t<R>
            replace(R&& r, const T1& old_value, const T2& new_value, Proj proj = {});
        template<InputIterator I, Sentinel<I> S, class T, class Proj = identity,
                 IndirectUnaryPredicate<projected<I, Proj>> Pred>
          requires Writable<I, const T&>
          constexpr I replace_if(I first, S last,
                                 Pred pred, const T& new_value, Proj proj = {});
        template<InputRange R, class T, class Proj = identity,
                 IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
          requires Writable<iterator_t<R>, const T&>
          constexpr safe_iterator_t<R>
            replace_if(R&& r, Pred pred, const T& new_value, Proj proj = {});
      }

      template<class InputIt, class OutputIt, class T>
        constexpr OutputIt replace_copy(InputIt first, InputIt last, OutputIt result,
                                        const T& old_value, const T& new_value);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class T>
        ForwardIt2 replace_copy(ExecutionPolicy&& exec,
                                ForwardIt1 first, ForwardIt1 last, ForwardIt2 result,
                                const T& old_value, const T& new_value);
      template<class InputIt, class OutputIt, class Pred, class T>
        constexpr OutputIt replace_copy_if(InputIt first, InputIt last, OutputIt result,
                                           Pred pred, const T& new_value);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class Pred, class T>
        ForwardIt2 replace_copy_if(ExecutionPolicy&& exec,
                                   ForwardIt1 first, ForwardIt1 last, ForwardIt2 result,
                                   Pred pred, const T& new_value);

      namespace ranges {
        template<class I, class O>
        using replace_copy_result = copy_result<I, O>;

        template<InputIterator I, Sentinel<I> S, class T1, class T2,
                 OutputIterator<const T2&> O, class Proj = identity>
          requires IndirectlyCopyable<I, O> &&
                   IndirectRelation<ranges::equal_to, projected<I, Proj>, const T1*>
          constexpr replace_copy_result<I, O>
            replace_copy(I first, S last, O result, const T1& old_value, const T2& new_value,
                         Proj proj = {});
        template<InputRange R, class T1, class T2, OutputIterator<const T2&> O,
                 class Proj = identity>
          requires IndirectlyCopyable<iterator_t<R>, O> &&
                   IndirectRelation<ranges::equal_to, projected<iterator_t<R>, Proj>,
                     const T1*>
          constexpr replace_copy_result<safe_iterator_t<R>, O>
            replace_copy(R&& r, O result, const T1& old_value, const T2& new_value,
                         Proj proj = {});

        template<class I, class O>
        using replace_copy_if_result = copy_result<I, O>;

        template<InputIterator I, Sentinel<I> S, class T, OutputIterator<const T&> O,
                 class Proj = identity, IndirectUnaryPredicate<projected<I, Proj>> Pred>
          requires IndirectlyCopyable<I, O>
          constexpr replace_copy_if_result<I, O>
            replace_copy_if(I first, S last, O result, Pred pred, const T& new_value,
                            Proj proj = {});
        template<InputRange R, class T, OutputIterator<const T&> O, class Proj = identity,
                 IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
          requires IndirectlyCopyable<iterator_t<R>, O>
          constexpr replace_copy_if_result<safe_iterator_t<R>, O>
            replace_copy_if(R&& r, O result, Pred pred, const T& new_value,
                            Proj proj = {});
      }

      // fill:
      template<class ForwardIt, class T>
        constexpr void fill(ForwardIt first, ForwardIt last, const T& value);
      template<class ExecutionPolicy, class ForwardIt, class T>
        void fill(ExecutionPolicy&& exec,
                  ForwardIt first, ForwardIt last, const T& value);
      template<class OutputIt, class Size, class T>
        constexpr OutputIt fill_n(OutputIt first, Size n, const T& value);
      template<class ExecutionPolicy, class ForwardIt, class Size, class T>
        ForwardIt fill_n(ExecutionPolicy&& exec,
                         ForwardIt first, Size n, const T& value);

      namespace ranges {
        template<class T, OutputIterator<const T&> O, Sentinel<O> S>
          constexpr O fill(O first, S last, const T& value);
        template<class T, OutputRange<const T&> R>
          constexpr safe_iterator_t<R> fill(R&& r, const T& value);
        template<class T, OutputIterator<const T&> O>
          constexpr O fill_n(O first, iter_difference_t<O> n, const T& value);
      }

      // generate:
      template<class ForwardIt, class Generator>
        constexpr void generate(ForwardIt first, ForwardIt last, Generator gen);
      template<class ExecutionPolicy, class ForwardIt, class Generator>
        void generate(ExecutionPolicy&& exec,
                      ForwardIt first, ForwardIt last, Generator gen);
      template<class OutputIt, class Size, class Generator>
        constexpr OutputIt generate_n(OutputIt first, Size n, Generator gen);
      template<class ExecutionPolicy, class ForwardIt, class Size, class Generator>
        ForwardIt generate_n(ExecutionPolicy&& exec,
                             ForwardIt first, Size n, Generator gen);

      namespace ranges {
        template<Iterator O, Sentinel<O> S, CopyConstructible F>
          requires Invocable<F&> && Writable<O, invoke_result_t<F&>>
          constexpr O generate(O first, S last, F gen);
        template<class R, CopyConstructible F>
          requires Invocable<F&> && OutputRange<R, invoke_result_t<F&>>
          constexpr safe_iterator_t<R> generate(R&& r, F gen);
        template<Iterator O, CopyConstructible F>
          requires Invocable<F&> && Writable<O, invoke_result_t<F&>>
          constexpr O generate_n(O first, iter_difference_t<O> n, F gen);
      }

      // remove:
      template<class ForwardIt, class T>
        constexpr ForwardIt remove(ForwardIt first, ForwardIt last, const T& value);
      template<class ExecutionPolicy, class ForwardIt, class T>
        ForwardIt remove(ExecutionPolicy&& exec,
                         ForwardIt first, ForwardIt last, const T& value);
      template<class ForwardIt, class Pred>
        constexpr ForwardIt remove_if(ForwardIt first, ForwardIt last, Pred pred);
      template<class ExecutionPolicy, class ForwardIt, class Pred>
        ForwardIt remove_if(ExecutionPolicy&& exec,
                            ForwardIt first, ForwardIt last, Pred pred);

      namespace ranges {
        template<Permutable I, Sentinel<I> S, class T, class Proj = identity>
          requires IndirectRelation<ranges::equal_to, projected<I, Proj>, const T*>
          constexpr I remove(I first, S last, const T& value, Proj proj = {});
        template<ForwardRange R, class T, class Proj = identity>
          requires Permutable<iterator_t<R>> &&
                   IndirectRelation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
          constexpr safe_iterator_t<R>
            remove(R&& r, const T& value, Proj proj = {});
        template<Permutable I, Sentinel<I> S, class Proj = identity,
                 IndirectUnaryPredicate<projected<I, Proj>> Pred>
          constexpr I remove_if(I first, S last, Pred pred, Proj proj = {});
        template<ForwardRange R, class Proj = identity,
                 IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
          requires Permutable<iterator_t<R>>
          constexpr safe_iterator_t<R>
            remove_if(R&& r, Pred pred, Proj proj = {});
      }

      template<class InputIt, class OutputIt, class T>
        constexpr OutputIt
          remove_copy(InputIt first, InputIt last, OutputIt result, const T& value);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class T>
        ForwardIt2
          remove_copy(ExecutionPolicy&& exec,
                      ForwardIt1 first, ForwardIt1 last, ForwardIt2 result, const T& value);
      template<class InputIt, class OutputIt, class Pred>
        constexpr OutputIt
          remove_copy_if(InputIt first, InputIt last, OutputIt result, Pred pred);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class Pred>
        ForwardIt2
          remove_copy_if(ExecutionPolicy&& exec,
                         ForwardIt1 first, ForwardIt1 last, ForwardIt2 result, Pred pred);

      namespace ranges {
        template<class I, class O>
        using remove_copy_result = copy_result<I, O>;

        template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O, class T,
                 class Proj = identity>
          requires IndirectlyCopyable<I, O> &&
                   IndirectRelation<ranges::equal_to, projected<I, Proj>, const T*>
          constexpr remove_copy_result<I, O>
            remove_copy(I first, S last, O result, const T& value, Proj proj = {});
        template<InputRange R, WeaklyIncrementable O, class T, class Proj = identity>
          requires IndirectlyCopyable<iterator_t<R>, O> &&
                   IndirectRelation<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
          constexpr remove_copy_result<safe_iterator_t<R>, O>
            remove_copy(R&& r, O result, const T& value, Proj proj = {});

        template<class I, class O>
        using remove_copy_if_result = copy_result<I, O>;

        template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O,
                 class Proj = identity, IndirectUnaryPredicate<projected<I, Proj>> Pred>
          requires IndirectlyCopyable<I, O>
          constexpr remove_copy_if_result<I, O>
            remove_copy_if(I first, S last, O result, Pred pred, Proj proj = {});
        template<InputRange R, WeaklyIncrementable O, class Proj = identity,
                 IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
          requires IndirectlyCopyable<iterator_t<R>, O>
          constexpr remove_copy_if_result<safe_iterator_t<R>, O>
            remove_copy_if(R&& r, O result, Pred pred, Proj proj = {});
      }

      // unique:
      template<class ForwardIt>
        constexpr ForwardIt unique(ForwardIt first, ForwardIt last);
      template<class ForwardIt, class BinaryPred>
        constexpr ForwardIt unique(ForwardIt first, ForwardIt last, BinaryPred pred);
      template<class ExecutionPolicy, class ForwardIt>
        ForwardIt unique(ExecutionPolicy&& exec,
                         ForwardIt first, ForwardIt last);
      template<class ExecutionPolicy, class ForwardIt, class BinaryPred>
        ForwardIt unique(ExecutionPolicy&& exec,
                         ForwardIt first, ForwardIt last, BinaryPred pred);

      namespace ranges {
        template<Permutable I, Sentinel<I> S, class Proj = identity,
                 IndirectRelation<projected<I, Proj>> C = ranges::equal_to>
          constexpr I unique(I first, S last, C comp = {}, Proj proj = {});
        template<ForwardRange R, class Proj = identity,
                 IndirectRelation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
          requires Permutable<iterator_t<R>>
          constexpr safe_iterator_t<R>
            unique(R&& r, C comp = {}, Proj proj = {});
      }

      template<class InputIt, class OutputIt>
        constexpr OutputIt
          unique_copy(InputIt first, InputIt last, OutputIt result);
      template<class InputIt, class OutputIt, class BinaryPred>
        constexpr OutputIt
          unique_copy(InputIt first, InputIt last, OutputIt result, BinaryPred pred);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2>
        ForwardIt2
          unique_copy(ExecutionPolicy&& exec,
                      ForwardIt1 first, ForwardIt1 last, ForwardIt2 result);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class BinaryPred>
        ForwardIt2
          unique_copy(ExecutionPolicy&& exec,
                      ForwardIt1 first, ForwardIt1 last, ForwardIt2 result, BinaryPred pred);

      namespace ranges {
        template<class I, class O>
        using unique_copy_result = copy_result<I, O>;

        template<InputIterator I, Sentinel<I> S, WeaklyIncrementable O,
                 class Proj = identity,
                 IndirectRelation<projected<I, Proj>> C = ranges::equal_to>
          requires IndirectlyCopyable<I, O> &&
                   (ForwardIterator<I> ||
                    (InputIterator<O> && Same<iter_value_t<I>, iter_value_t<O>>) ||
                    IndirectlyCopyableStorable<I, O>)
          constexpr unique_copy_result<I, O>
            unique_copy(I first, S last, O result, C comp = {}, Proj proj = {});
        template<InputRange R, WeaklyIncrementable O, class Proj = identity,
                 IndirectRelation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
          requires IndirectlyCopyable<iterator_t<R>, O> &&
                   (ForwardIterator<iterator_t<R>> ||
                    (InputIterator<O> && Same<iter_value_t<iterator_t<R>>, iter_value_t<O>>) ||
                    IndirectlyCopyableStorable<iterator_t<R>, O>)
          constexpr unique_copy_result<safe_iterator_t<R>, O>
            unique_copy(R&& r, O result, C comp = {}, Proj proj = {});
      }

      // reverse:
      template<class BidirectionalIt>
        constexpr void reverse(BidirectionalIt first, BidirectionalIt last);
      template<class ExecutionPolicy, class BidirectionalIt>
        void reverse(ExecutionPolicy&& exec,
                     BidirectionalIt first, BidirectionalIt last);

      namespace ranges {
        template<BidirectionalIterator I, Sentinel<I> S>
          requires Permutable<I>
          constexpr I reverse(I first, S last);
        template<BidirectionalRange R>
          requires Permutable<iterator_t<R>>
          constexpr safe_iterator_t<R> reverse(R&& r);
      }

      template<class BidirectionalIt, class OutputIt>
        constexpr OutputIt
          reverse_copy(BidirectionalIt first, BidirectionalIt last, OutputIt result);
      template<class ExecutionPolicy, class BidirectionalIt, class ForwardIt>
        ForwardIt
          reverse_copy(ExecutionPolicy&& exec,
                       BidirectionalIt first, BidirectionalIt last, ForwardIt result);

      namespace ranges {
        template<class I, class O>
        using reverse_copy_result = copy_result<I, O>;

        template<BidirectionalIterator I, Sentinel<I> S, WeaklyIncrementable O>
          requires IndirectlyCopyable<I, O>
          constexpr reverse_copy_result<I, O>
            reverse_copy(I first, S last, O result);
        template<BidirectionalRange R, WeaklyIncrementable O>
          requires IndirectlyCopyable<iterator_t<R>, O>
          constexpr reverse_copy_result<safe_iterator_t<R>, O>
            reverse_copy(R&& r, O result);
      }

      // rotate:
      template<class ForwardIt>
        constexpr ForwardIt rotate(ForwardIt first, ForwardIt middle, ForwardIt last);
      template<class ExecutionPolicy, class ForwardIt>
        ForwardIt rotate(ExecutionPolicy&& exec,
                         ForwardIt first, ForwardIt middle, ForwardIt last);

      namespace ranges {
        template<Permutable I, Sentinel<I> S>
          constexpr subrange<I> rotate(I first, I middle, S last);
        template<ForwardRange R>
          requires Permutable<iterator_t<R>>
          constexpr safe_subrange_t<R> rotate(R&& r, iterator_t<R> middle);
      }

      template<class ForwardIt, class OutputIt>
        constexpr OutputIt
          rotate_copy(ForwardIt first, ForwardIt middle, ForwardIt last, OutputIt result);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2>
        ForwardIt2
          rotate_copy(ExecutionPolicy&& exec,
                      ForwardIt1 first, ForwardIt1 middle, ForwardIt1 last, ForwardIt2 result);

      namespace ranges {
        template<class I, class O>
        using rotate_copy_result = copy_result<I, O>;

        template<ForwardIterator I, Sentinel<I> S, WeaklyIncrementable O>
          requires IndirectlyCopyable<I, O>
          constexpr rotate_copy_result<I, O>
            rotate_copy(I first, I middle, S last, O result);
        template<ForwardRange R, WeaklyIncrementable O>
          requires IndirectlyCopyable<iterator_t<R>, O>
          constexpr rotate_copy_result<safe_iterator_t<R>, O>
            rotate_copy(R&& r, iterator_t<R> middle, O result);
      }

      // sample:
      template<class PopulationIt, class SampleIt,
               class Distance, class UniformRndBitGen>
        SampleIt sample(PopulationIt first, PopulationIt last, SampleIt out, Distance n,
                        UniformRndBitGen&& g);

      // shuffle:
      template<class RandomAccessIt, class UniformRndBitGen>
        void shuffle(RandomAccessIt first, RandomAccessIt last, UniformRndBitGen&& g);

      namespace ranges {
        template<RandomAccessIterator I, Sentinel<I> S, class Gen>
          requires Permutable<I> &&
                   UniformRandomBitGenerator<remove_reference_t<Gen>> &&
                   ConvertibleTo<invoke_result_t<Gen&>, iter_difference_t<I>>
          I shuffle(I first, S last, Gen&& g);
        template<RandomAccessRange R, class Gen>
          requires Permutable<iterator_t<R>> &&
                   UniformRandomBitGenerator<remove_reference_t<Gen>> &&
                   ConvertibleTo<invoke_result_t<Gen&>, iter_difference_t<iterator_t<R>>>
          safe_iterator_t<R> shuffle(R&& r, Gen&& g);
      }

      // shift:
      template<class ForwardIt>
        constexpr ForwardIt
          shift_left(ForwardIt first, ForwardIt last,
                     typename iterator_traits<ForwardIt>::difference_type n);
      template<class ExecutionPolicy, class ForwardIt>
        ForwardIt
          shift_left(ExecutionPolicy&& exec,
                     ForwardIt first, ForwardIt last,
                     typename iterator_traits<ForwardIt>::difference_type n);
      template<class ForwardIt>
        constexpr ForwardIt
          shift_right(ForwardIt first, ForwardIt last,
                      typename iterator_traits<ForwardIt>::difference_type n);
      template<class ExecutionPolicy, class ForwardIt>
        ForwardIt
          shift_right(ExecutionPolicy&& exec,
                      ForwardIt first, ForwardIt last,
                      typename iterator_traits<ForwardIt>::difference_type n);

      // sorting and related operations:
      // sorting:
      template<class RandomAccessIt>
        constexpr void sort(RandomAccessIt first, RandomAccessIt last);
      template<class RandomAccessIt, class Compare>
        constexpr void sort(RandomAccessIt first, RandomAccessIt last, Compare comp);
      template<class ExecutionPolicy, class RandomAccessIt>
        void sort(ExecutionPolicy&& exec,
                  RandomAccessIt first, RandomAccessIt last);
      template<class ExecutionPolicy, class RandomAccessIt, class Compare>
        void sort(ExecutionPolicy&& exec,
                  RandomAccessIt first, RandomAccessIt last, Compare comp);

      namespace ranges {
        template<RandomAccessIterator I, Sentinel<I> S, class Comp = ranges::less,
                 class Proj = identity>
          requires Sortable<I, Comp, Proj>
          constexpr I
            sort(I first, S last, Comp comp = {}, Proj proj = {});
        template<RandomAccessRange R, class Comp = ranges::less, class Proj = identity>
          requires Sortable<iterator_t<R>, Comp, Proj>
          constexpr safe_iterator_t<R>
            sort(R&& r, Comp comp = {}, Proj proj = {});
      }

      template<class RandomAccessIt>
        void stable_sort(RandomAccessIt first, RandomAccessIt last);
      template<class RandomAccessIt, class Compare>
        void stable_sort(RandomAccessIt first, RandomAccessIt last, Compare comp);
      template<class ExecutionPolicy, class RandomAccessIt>
        void stable_sort(ExecutionPolicy&& exec,
                         RandomAccessIt first, RandomAccessIt last);
      template<class ExecutionPolicy, class RandomAccessIt, class Compare>
        void stable_sort(ExecutionPolicy&& exec,
                         RandomAccessIt first, RandomAccessIt last, Compare comp);

      namespace ranges {
        template<RandomAccessIterator I, Sentinel<I> S, class Comp = ranges::less,
                 class Proj = identity>
          requires Sortable<I, Comp, Proj>
          I stable_sort(I first, S last, Comp comp = {}, Proj proj = {});
        template<RandomAccessRange R, class Comp = ranges::less, class Proj = identity>
          requires Sortable<iterator_t<R>, Comp, Proj>
          safe_iterator_t<R>
            stable_sort(R&& r, Comp comp = {}, Proj proj = {});
      }

      template<class RandomAccessIt>
        constexpr void partial_sort(RandomAccessIt first, RandomAccessIt middle,
                                    RandomAccessIt last);
      template<class RandomAccessIt, class Compare>
        constexpr void partial_sort(RandomAccessIt first, RandomAccessIt middle,
                                    RandomAccessIt last, Compare comp);
      template<class ExecutionPolicy, class RandomAccessIt>
        void partial_sort(ExecutionPolicy&& exec,
                          RandomAccessIt first, RandomAccessIt middle, RandomAccessIt last);
      template<class ExecutionPolicy, class RandomAccessIt, class Compare>
        void partial_sort(ExecutionPolicy&& exec,
                          RandomAccessIt first, RandomAccessIt middle, RandomAccessIt last,
                          Compare comp);

      namespace ranges {
        template<RandomAccessIterator I, Sentinel<I> S, class Comp = ranges::less,
                 class Proj = identity>
          requires Sortable<I, Comp, Proj>
          constexpr I
            partial_sort(I first, I middle, S last, Comp comp = {}, Proj proj = {});
        template<RandomAccessRange R, class Comp = ranges::less, class Proj = identity>
          requires Sortable<iterator_t<R>, Comp, Proj>
          constexpr safe_iterator_t<R>
            partial_sort(R&& r, iterator_t<R> middle, Comp comp = {},
                         Proj proj = {});
      }

      template<class InputIt, class RandomAccessIt>
        constexpr RandomAccessIt
          partial_sort_copy(InputIt first, InputIt last,
                            RandomAccessIt result_first, RandomAccessIt result_last);
      template<class InputIt, class RandomAccessIt, class Compare>
        constexpr RandomAccessIt
          partial_sort_copy(InputIt first, InputIt last,
                            RandomAccessIt result_first, RandomAccessIt result_last,
                            Compare comp);
      template<class ExecutionPolicy, class ForwardIt, class RandomAccessIt>
        RandomAccessIt
          partial_sort_copy(ExecutionPolicy&& exec,
                            ForwardIt first, ForwardIt last,
                            RandomAccessIt result_first, RandomAccessIt result_last);
      template<class ExecutionPolicy, class ForwardIt, class RandomAccessIt, class Compare>
        RandomAccessIt
          partial_sort_copy(ExecutionPolicy&& exec,
                            ForwardIt first, ForwardIt last,
                            RandomAccessIt result_first, RandomAccessIt result_last,
                            Compare comp);

      namespace ranges {
        template<InputIterator I1, Sentinel<I1> S1, RandomAccessIterator I2, Sentinel<I2> S2,
                 class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
          requires IndirectlyCopyable<I1, I2> && Sortable<I2, Comp, Proj2> &&
                   IndirectStrictWeakOrder<Comp, projected<I1, Proj1>, projected<I2, Proj2>>
          constexpr I2
            partial_sort_copy(I1 first, S1 last, I2 result_first, S2 result_last,
                              Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
        template<InputRange R1, RandomAccessRange R2, class Comp = ranges::less,
                 class Proj1 = identity, class Proj2 = identity>
          requires IndirectlyCopyable<iterator_t<R1>, iterator_t<R2>> &&
                   Sortable<iterator_t<R2>, Comp, Proj2> &&
                   IndirectStrictWeakOrder<Comp, projected<iterator_t<R1>, Proj1>,
                                           projected<iterator_t<R2>, Proj2>>
          constexpr safe_iterator_t<R2>
            partial_sort_copy(R1&& r, R2&& result_r, Comp comp = {},
                              Proj1 proj1 = {}, Proj2 proj2 = {});
      }

      template<class ForwardIt>
        constexpr bool is_sorted(ForwardIt first, ForwardIt last);
      template<class ForwardIt, class Compare>
        constexpr bool is_sorted(ForwardIt first, ForwardIt last, Compare comp);
      template<class ExecutionPolicy, class ForwardIt>
        bool is_sorted(ExecutionPolicy&& exec,
                       ForwardIt first, ForwardIt last);
      template<class ExecutionPolicy, class ForwardIt, class Compare>
        bool is_sorted(ExecutionPolicy&& exec,
                       ForwardIt first, ForwardIt last, Compare comp);

      namespace ranges {
        template<ForwardIterator I, Sentinel<I> S, class Proj = identity,
                 IndirectStrictWeakOrder<projected<I, Proj>> Comp = ranges::less>
          constexpr bool is_sorted(I first, S last, Comp comp = {}, Proj proj = {});
        template<ForwardRange R, class Proj = identity,
                 IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
          constexpr bool is_sorted(R&& r, Comp comp = {}, Proj proj = {});
      }

      template<class ForwardIt>
        constexpr ForwardIt
          is_sorted_until(ForwardIt first, ForwardIt last);
      template<class ForwardIt, class Compare>
        constexpr ForwardIt
          is_sorted_until(ForwardIt first, ForwardIt last, Compare comp);
      template<class ExecutionPolicy, class ForwardIt>
        ForwardIt
          is_sorted_until(ExecutionPolicy&& exec,
                          ForwardIt first, ForwardIt last);
      template<class ExecutionPolicy, class ForwardIt, class Compare>
        ForwardIt
          is_sorted_until(ExecutionPolicy&& exec,
                          ForwardIt first, ForwardIt last, Compare comp);

      namespace ranges {
        template<ForwardIterator I, Sentinel<I> S, class Proj = identity,
                 IndirectStrictWeakOrder<projected<I, Proj>> Comp = ranges::less>
          constexpr I is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {});
        template<ForwardRange R, class Proj = identity,
                 IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
          constexpr safe_iterator_t<R>
            is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});
      }

      // Nth element:
      template<class RandomAccessIt>
        constexpr void nth_element(RandomAccessIt first, RandomAccessIt nth,
                                   RandomAccessIt last);
      template<class RandomAccessIt, class Compare>
        constexpr void nth_element(RandomAccessIt first, RandomAccessIt nth,
                                   RandomAccessIt last, Compare comp);
      template<class ExecutionPolicy, class RandomAccessIt>
        void nth_element(ExecutionPolicy&& exec,
                         RandomAccessIt first, RandomAccessIt nth,
                         RandomAccessIt last);
      template<class ExecutionPolicy, class RandomAccessIt, class Compare>
        void nth_element(ExecutionPolicy&& exec,
                         RandomAccessIt first, RandomAccessIt nth,
                         RandomAccessIt last, Compare comp);

      namespace ranges {
        template<RandomAccessIterator I, Sentinel<I> S, class Comp = ranges::less,
                 class Proj = identity>
          requires Sortable<I, Comp, Proj>
          constexpr I
            nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {});
        template<RandomAccessRange R, class Comp = ranges::less, class Proj = identity>
          requires Sortable<iterator_t<R>, Comp, Proj>
          constexpr safe_iterator_t<R>
            nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {});
      }

      // binary search:
      template<class ForwardIt, class T>
        constexpr ForwardIt
          lower_bound(ForwardIt first, ForwardIt last, const T& value);
      template<class ForwardIt, class T, class Compare>
        constexpr ForwardIt
          lower_bound(ForwardIt first, ForwardIt last, const T& value, Compare comp);

      namespace ranges {
        template<ForwardIterator I, Sentinel<I> S, class T, class Proj = identity,
                 IndirectStrictWeakOrder<const T*, projected<I, Proj>> Comp = ranges::less>
          constexpr I lower_bound(I first, S last, const T& value, Comp comp = {},
                                  Proj proj = {});
        template<ForwardRange R, class T, class Proj = identity,
                 IndirectStrictWeakOrder<const T*, projected<iterator_t<R>, Proj>> Comp =
                   ranges::less>
          constexpr safe_iterator_t<R>
            lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      }

      template<class ForwardIt, class T>
        constexpr ForwardIt
          upper_bound(ForwardIt first, ForwardIt last, const T& value);
      template<class ForwardIt, class T, class Compare>
        constexpr ForwardIt
          upper_bound(ForwardIt first, ForwardIt last, const T& value, Compare comp);

      namespace ranges {
        template<ForwardIterator I, Sentinel<I> S, class T, class Proj = identity,
                 IndirectStrictWeakOrder<const T*, projected<I, Proj>> Comp = ranges::less>
          constexpr I upper_bound(I first, S last,
                                  const T& value, Comp comp = {}, Proj proj = {});
        template<ForwardRange R, class T, class Proj = identity,
                 IndirectStrictWeakOrder<const T*, projected<iterator_t<R>, Proj>> Comp =
                   ranges::less>
          constexpr safe_iterator_t<R>
            upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      }

      template<class ForwardIt, class T>
        constexpr pair<ForwardIt, ForwardIt>
          equal_range(ForwardIt first, ForwardIt last, const T& value);
      template<class ForwardIt, class T, class Compare>
        constexpr pair<ForwardIt, ForwardIt>
          equal_range(ForwardIt first, ForwardIt last, const T& value, Compare comp);

      namespace ranges {
        template<ForwardIterator I, Sentinel<I> S, class T, class Proj = identity,
                 IndirectStrictWeakOrder<const T*, projected<I, Proj>> Comp = ranges::less>
          constexpr subrange<I>
            equal_range(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
        template<ForwardRange R, class T, class Proj = identity,
                 IndirectStrictWeakOrder<const T*, projected<iterator_t<R>, Proj>> Comp =
                   ranges::less>
          constexpr safe_subrange_t<R>
            equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {});
      }

      template<class ForwardIt, class T>
        constexpr bool
          binary_search(ForwardIt first, ForwardIt last, const T& value);
      template<class ForwardIt, class T, class Compare>
        constexpr bool
          binary_search(ForwardIt first, ForwardIt last, const T& value, Compare comp);

      namespace ranges {
        template<ForwardIterator I, Sentinel<I> S, class T, class Proj = identity,
                 IndirectStrictWeakOrder<const T*, projected<I, Proj>> Comp = ranges::less>
          constexpr bool binary_search(I first, S last, const T& value, Comp comp = {},
                                       Proj proj = {});
        template<ForwardRange R, class T, class Proj = identity,
                 IndirectStrictWeakOrder<const T*, projected<iterator_t<R>, Proj>> Comp =
                   ranges::less>
          constexpr bool binary_search(R&& r, const T& value, Comp comp = {},
                                       Proj proj = {});
      }

      // partitions:
      template<class InputIt, class Pred>
        constexpr bool is_partitioned(InputIt first, InputIt last, Pred pred);
      template<class ExecutionPolicy, class ForwardIt, class Pred>
        bool is_partitioned(ExecutionPolicy&& exec,
                            ForwardIt first, ForwardIt last, Pred pred);

      namespace ranges {
        template<InputIterator I, Sentinel<I> S, class Proj = identity,
                 IndirectUnaryPredicate<projected<I, Proj>> Pred>
          constexpr bool is_partitioned(I first, S last, Pred pred, Proj proj = {});
        template<InputRange R, class Proj = identity,
                 IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
          constexpr bool is_partitioned(R&& r, Pred pred, Proj proj = {});
      }

      template<class ForwardIt, class Pred>
        constexpr ForwardIt partition(ForwardIt first, ForwardIt last, Pred pred);
      template<class ExecutionPolicy, class ForwardIt, class Pred>
        ForwardIt partition(ExecutionPolicy&& exec,
                            ForwardIt first, ForwardIt last, Pred pred);

      namespace ranges {
        template<Permutable I, Sentinel<I> S, class Proj = identity,
                 IndirectUnaryPredicate<projected<I, Proj>> Pred>
          constexpr I
            partition(I first, S last, Pred pred, Proj proj = {});
        template<ForwardRange R, class Proj = identity,
                 IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
          requires Permutable<iterator_t<R>>
          constexpr safe_iterator_t<R>
            partition(R&& r, Pred pred, Proj proj = {});
      }

      template<class BidirectionalIt, class Pred>
        BidirectionalIt stable_partition(BidirectionalIt first, BidirectionalIt last,
                                         Pred pred);
      template<class ExecutionPolicy, class BidirectionalIt, class Pred>
        BidirectionalIt stable_partition(ExecutionPolicy&& exec,
                                         BidirectionalIt first, BidirectionalIt last,
                                         Pred pred);

      namespace ranges {
        template<BidirectionalIterator I, Sentinel<I> S, class Proj = identity,
                 IndirectUnaryPredicate<projected<I, Proj>> Pred>
          requires Permutable<I>
          I stable_partition(I first, S last, Pred pred, Proj proj = {});
        template<BidirectionalRange R, class Proj = identity,
                 IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
          requires Permutable<iterator_t<R>>
          safe_iterator_t<R> stable_partition(R&& r, Pred pred, Proj proj = {});
      }

      template<class InputIt, class OutputIt1, class OutputIt2, class Pred>
        constexpr pair<OutputIt1, OutputIt2>
          partition_copy(InputIt first, InputIt last, OutputIt1 out_true, OutputIt2 out_false,
                         Pred pred);
      template<class ExecutionPolicy, class ForwardIt, class ForwardIt1,
               class ForwardIt2, class Pred>
        pair<ForwardIt1, ForwardIt2>
          partition_copy(ExecutionPolicy&& exec,
                         ForwardIt first, ForwardIt last,
                         ForwardIt1 out_true, ForwardIt2 out_false,
                         Pred pred);

      namespace ranges {
        template<class I, class O1, class O2>
        struct partition_copy_result {
          [[no_unique_address]] I  in;
          [[no_unique_address]] O1 out1;
          [[no_unique_address]] O2 out2;

          template<class II, class OO1, class OO2>
            requires ConvertibleTo<const I&, II> &&
              ConvertibleTo<const O1&, OO1> && ConvertibleTo<const O2&, OO2>
            operator partition_copy_result<II, OO1, OO2>() const & {
              return {in, out1, out2};
            }

          template<class II, class OO1, class OO2>
            requires ConvertibleTo<I, II> &&
              ConvertibleTo<O1, OO1> && ConvertibleTo<O2, OO2>
            operator partition_copy_result<II, OO1, OO2>() && {
              return {std::move(in), std::move(out1), std::move(out2)};
            }
        };

        template<InputIterator I, Sentinel<I> S,
                 WeaklyIncrementable O1, WeaklyIncrementable O2,
                 class Proj = identity, IndirectUnaryPredicate<projected<I, Proj>> Pred>
          requires IndirectlyCopyable<I, O1> && IndirectlyCopyable<I, O2>
          constexpr partition_copy_result<I, O1, O2>
            partition_copy(I first, S last, O1 out_true, O2 out_false, Pred pred,
                           Proj proj = {});
        template<InputRange R, WeaklyIncrementable O1, WeaklyIncrementable O2,
                 class Proj = identity,
                 IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
          requires IndirectlyCopyable<iterator_t<R>, O1> &&
                   IndirectlyCopyable<iterator_t<R>, O2>
          constexpr partition_copy_result<safe_iterator_t<R>, O1, O2>
            partition_copy(R&& r, O1 out_true, O2 out_false, Pred pred, Proj proj = {});
      }

      template<class ForwardIt, class Pred>
        constexpr ForwardIt
          partition_point(ForwardIt first, ForwardIt last, Pred pred);

      namespace ranges {
        template<ForwardIterator I, Sentinel<I> S, class Proj = identity,
                 IndirectUnaryPredicate<projected<I, Proj>> Pred>
          constexpr I partition_point(I first, S last, Pred pred, Proj proj = {});
        template<ForwardRange R, class Proj = identity,
                 IndirectUnaryPredicate<projected<iterator_t<R>, Proj>> Pred>
          constexpr safe_iterator_t<R>
            partition_point(R&& r, Pred pred, Proj proj = {});
      }

      // merge:
      template<class InputIt1, class InputIt2, class OutputIt>
        constexpr OutputIt
          merge(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2,
                OutputIt result);
      template<class InputIt1, class InputIt2, class OutputIt, class Compare>
        constexpr OutputIt
          merge(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2,
                OutputIt result, Compare comp);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class ForwardIt>
        ForwardIt
          merge(ExecutionPolicy&& exec,
                ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2,
                ForwardIt result);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2,
               class ForwardIt, class Compare>
        ForwardIt
          merge(ExecutionPolicy&& exec,
                ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2,
                ForwardIt result, Compare comp);

      namespace ranges {
        template<class I1, class I2, class O>
        using merge_result = binary_transform_result<I1, I2, O>;

        template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
                 WeaklyIncrementable O, class Comp = ranges::less, class Proj1 = identity,
                 class Proj2 = identity>
          requires Mergeable<I1, I2, O, Comp, Proj1, Proj2>
          constexpr merge_result<I1, I2, O>
            merge(I1 first1, S1 last1, I2 first2, S2 last2, O result,
                  Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
        template<InputRange R1, InputRange R2, WeaklyIncrementable O,
                 class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
          requires Mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
          constexpr merge_result<safe_iterator_t<R1>, safe_iterator_t<R2>, O>
            merge(R1&& r1, R2&& r2, O result,
                  Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      }

      template<class BidirectionalIt>
        void inplace_merge(BidirectionalIt first,
                           BidirectionalIt middle,
                           BidirectionalIt last);
      template<class BidirectionalIt, class Compare>
        void inplace_merge(BidirectionalIt first,
                           BidirectionalIt middle,
                           BidirectionalIt last, Compare comp);
      template<class ExecutionPolicy, class BidirectionalIt>
        void inplace_merge(ExecutionPolicy&& exec,
                           BidirectionalIt first,
                           BidirectionalIt middle,
                           BidirectionalIt last);
      template<class ExecutionPolicy, class BidirectionalIt, class Compare>
        void inplace_merge(ExecutionPolicy&& exec,
                           BidirectionalIt first,
                           BidirectionalIt middle,
                           BidirectionalIt last, Compare comp);

      namespace ranges {
        template<BidirectionalIterator I, Sentinel<I> S, class Comp = ranges::less,
                 class Proj = identity>
          requires Sortable<I, Comp, Proj>
          I inplace_merge(I first, I middle, S last, Comp comp = {}, Proj proj = {});
        template<BidirectionalRange R, class Comp = ranges::less, class Proj = identity>
          requires Sortable<iterator_t<R>, Comp, Proj>
          safe_iterator_t<R>
            inplace_merge(R&& r, iterator_t<R> middle, Comp comp = {},
                          Proj proj = {});
      }

      // set operations:
      template<class InputIt1, class InputIt2>
        constexpr bool includes(InputIt1 first1, InputIt1 last1,
                                InputIt2 first2, InputIt2 last2);
      template<class InputIt1, class InputIt2, class Compare>
        constexpr bool includes(InputIt1 first1, InputIt1 last1,
                                InputIt2 first2, InputIt2 last2,
                                Compare comp);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2>
        bool includes(ExecutionPolicy&& exec,
                      ForwardIt1 first1, ForwardIt1 last1,
                      ForwardIt2 first2, ForwardIt2 last2);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2,
               class Compare>
        bool includes(ExecutionPolicy&& exec,
                      ForwardIt1 first1, ForwardIt1 last1,
                      ForwardIt2 first2, ForwardIt2 last2,
                      Compare comp);

      namespace ranges {
        template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
                 class Proj1 = identity, class Proj2 = identity,
                 IndirectStrictWeakOrder<projected<I1, Proj1>, projected<I2, Proj2>> Comp =
                   ranges::less>
          constexpr bool includes(I1 first1, S1 last1, I2 first2, S2 last2, Comp comp = {},
                                  Proj1 proj1 = {}, Proj2 proj2 = {});
        template<InputRange R1, InputRange R2, class Proj1 = identity,
                 class Proj2 = identity,
                 IndirectStrictWeakOrder<projected<iterator_t<R1>, Proj1>,
                                         projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
          constexpr bool includes(R1&& r1, R2&& r2, Comp comp = {},
                                  Proj1 proj1 = {}, Proj2 proj2 = {});
      }

      template<class InputIt1, class InputIt2, class OutputIt>
        constexpr OutputIt
          set_union(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2,
                    OutputIt result);
      template<class InputIt1, class InputIt2, class OutputIt, class Compare>
        constexpr OutputIt
                    set_union(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2,
                    OutputIt result, Compare comp);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2,
               class ForwardIt>
        ForwardIt
          set_union(ExecutionPolicy&& exec,
                    ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2,
                    ForwardIt result);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2,
               class ForwardIt, class Compare>
        ForwardIt
          set_union(ExecutionPolicy&& exec,
                    ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2,
                    ForwardIt result, Compare comp);

      namespace ranges {
        template<class I1, class I2, class O>
        using set_union_result = binary_transform_result<I1, I2, O>;

        template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
                 WeaklyIncrementable O, class Comp = ranges::less,
                 class Proj1 = identity, class Proj2 = identity>
          requires Mergeable<I1, I2, O, Comp, Proj1, Proj2>
          constexpr set_union_result<I1, I2, O>
            set_union(I1 first1, S1 last1, I2 first2, S2 last2, O result, Comp comp = {},
                      Proj1 proj1 = {}, Proj2 proj2 = {});
        template<InputRange R1, InputRange R2, WeaklyIncrementable O,
                 class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
          requires Mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
          constexpr set_union_result<safe_iterator_t<R1>, safe_iterator_t<R2>, O>
            set_union(R1&& r1, R2&& r2, O result, Comp comp = {},
                      Proj1 proj1 = {}, Proj2 proj2 = {});
      }

      template<class InputIt1, class InputIt2, class OutputIt>
        constexpr OutputIt
          set_intersection(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2,
                           OutputIt result);
      template<class InputIt1, class InputIt2, class OutputIt, class Compare>
        constexpr OutputIt
          set_intersection(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2,
                           OutputIt result, Compare comp);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2,
               class ForwardIt>
        ForwardIt
          set_intersection(ExecutionPolicy&& exec,
                           ForwardIt1 first1, ForwardIt1 last1,
                           ForwardIt2 first2, ForwardIt2 last2,
                           ForwardIt result);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2,
               class ForwardIt, class Compare>
        ForwardIt
          set_intersection(ExecutionPolicy&& exec,
                           ForwardIt1 first1, ForwardIt1 last1,
                           ForwardIt2 first2, ForwardIt2 last2,
                           ForwardIt result, Compare comp);

      namespace ranges {
        template<class I1, class I2, class O>
        using set_intersection_result = binary_transform_result<I1, I2, O>;

        template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
                 WeaklyIncrementable O, class Comp = ranges::less,
                 class Proj1 = identity, class Proj2 = identity>
          requires Mergeable<I1, I2, O, Comp, Proj1, Proj2>
          constexpr set_intersection_result<I1, I2, O>
            set_intersection(I1 first1, S1 last1, I2 first2, S2 last2, O result,
                             Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
        template<InputRange R1, InputRange R2, WeaklyIncrementable O,
                 class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
          requires Mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
          constexpr set_intersection_result<safe_iterator_t<R1>, safe_iterator_t<R2>, O>
            set_intersection(R1&& r1, R2&& r2, O result,
                             Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      }

      template<class InputIt1, class InputIt2, class OutputIt>
        constexpr OutputIt
          set_difference(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2,
                         OutputIt result);
      template<class InputIt1, class InputIt2, class OutputIt, class Compare>
        constexpr OutputIt
          set_difference(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2,
                         OutputIt result, Compare comp);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2,
               class ForwardIt>
        ForwardIt
          set_difference(ExecutionPolicy&& exec,
                         ForwardIt1 first1, ForwardIt1 last1,
                         ForwardIt2 first2, ForwardIt2 last2,
                         ForwardIt result);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2,
               class ForwardIt, class Compare>
        ForwardIt
          set_difference(ExecutionPolicy&& exec,
                         ForwardIt1 first1, ForwardIt1 last1,
                         ForwardIt2 first2, ForwardIt2 last2,
                         ForwardIt result, Compare comp);

      namespace ranges {
        template<class I, class O>
        using set_difference_result = copy_result<I, O>;

        template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
                 WeaklyIncrementable O, class Comp = ranges::less,
                 class Proj1 = identity, class Proj2 = identity>
          requires Mergeable<I1, I2, O, Comp, Proj1, Proj2>
          constexpr set_difference_result<I1, O>
            set_difference(I1 first1, S1 last1, I2 first2, S2 last2, O result,
                           Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
        template<InputRange R1, InputRange R2, WeaklyIncrementable O,
                 class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
          requires Mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
          constexpr set_difference_result<safe_iterator_t<R1>, O>
            set_difference(R1&& r1, R2&& r2, O result,
                           Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
      }

      template<class InputIt1, class InputIt2, class OutputIt>
        constexpr OutputIt
          set_symmetric_difference(InputIt1 first1, InputIt1 last1,
                                   InputIt2 first2, InputIt2 last2,
                                   OutputIt result);
      template<class InputIt1, class InputIt2, class OutputIt, class Compare>
        constexpr OutputIt
          set_symmetric_difference(InputIt1 first1, InputIt1 last1,
                                   InputIt2 first2, InputIt2 last2,
                                   OutputIt result, Compare comp);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2,
               class ForwardIt>
        ForwardIt
          set_symmetric_difference(ExecutionPolicy&& exec,
                                   ForwardIt1 first1, ForwardIt1 last1,
                                   ForwardIt2 first2, ForwardIt2 last2,
                                   ForwardIt result);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2,
               class ForwardIt, class Compare>
        ForwardIt
          set_symmetric_difference(ExecutionPolicy&& exec,
                                   ForwardIt1 first1, ForwardIt1 last1,
                                   ForwardIt2 first2, ForwardIt2 last2,
                                   ForwardIt result, Compare comp);

      namespace ranges {
        template<class I1, class I2, class O>
        using set_symmetric_difference_result = binary_transform_result<I1, I2, O>;

        template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
                 WeaklyIncrementable O, class Comp = ranges::less,
                 class Proj1 = identity, class Proj2 = identity>
          requires Mergeable<I1, I2, O, Comp, Proj1, Proj2>
          constexpr set_symmetric_difference_result<I1, I2, O>
            set_symmetric_difference(I1 first1, S1 last1, I2 first2, S2 last2, O result,
                                     Comp comp = {}, Proj1 proj1 = {},
                                     Proj2 proj2 = {});
        template<InputRange R1, InputRange R2, WeaklyIncrementable O,
                 class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
          requires Mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
          constexpr
            set_symmetric_difference_result<safe_iterator_t<R1>, safe_iterator_t<R2>, O>
            set_symmetric_difference(R1&& r1, R2&& r2, O result, Comp comp = {},
                                     Proj1 proj1 = {}, Proj2 proj2 = {});
      }

      // heap operations:
      template<class RandomAccessIt>
        constexpr void push_heap(RandomAccessIt first, RandomAccessIt last);
      template<class RandomAccessIt, class Compare>
        constexpr void push_heap(RandomAccessIt first, RandomAccessIt last, Compare comp);

      namespace ranges {
        template<RandomAccessIterator I, Sentinel<I> S, class Comp = ranges::less,
                 class Proj = identity>
          requires Sortable<I, Comp, Proj>
          constexpr I
            push_heap(I first, S last, Comp comp = {}, Proj proj = {});
        template<RandomAccessRange R, class Comp = ranges::less, class Proj = identity>
          requires Sortable<iterator_t<R>, Comp, Proj>
          constexpr safe_iterator_t<R>
            push_heap(R&& r, Comp comp = {}, Proj proj = {});
      }

      template<class RandomAccessIt>
        constexpr void pop_heap(RandomAccessIt first, RandomAccessIt last);
      template<class RandomAccessIt, class Compare>
        constexpr void pop_heap(RandomAccessIt first, RandomAccessIt last, Compare comp);

      namespace ranges {
        template<RandomAccessIterator I, Sentinel<I> S, class Comp = ranges::less,
                 class Proj = identity>
          requires Sortable<I, Comp, Proj>
          constexpr I
            pop_heap(I first, S last, Comp comp = {}, Proj proj = {});
        template<RandomAccessRange R, class Comp = ranges::less, class Proj = identity>
          requires Sortable<iterator_t<R>, Comp, Proj>
          constexpr safe_iterator_t<R>
            pop_heap(R&& r, Comp comp = {}, Proj proj = {});
      }

      template<class RandomAccessIt>
        constexpr void make_heap(RandomAccessIt first, RandomAccessIt last);
      template<class RandomAccessIt, class Compare>
        constexpr void make_heap(RandomAccessIt first, RandomAccessIt last, Compare comp);

      namespace ranges {
        template<RandomAccessIterator I, Sentinel<I> S, class Comp = ranges::less,
                 class Proj = identity>
          requires Sortable<I, Comp, Proj>
          constexpr I
            make_heap(I first, S last, Comp comp = {}, Proj proj = {});
        template<RandomAccessRange R, class Comp = ranges::less, class Proj = identity>
          requires Sortable<iterator_t<R>, Comp, Proj>
          constexpr safe_iterator_t<R>
            make_heap(R&& r, Comp comp = {}, Proj proj = {});
      }

      template<class RandomAccessIt>
        constexpr void sort_heap(RandomAccessIt first, RandomAccessIt last);
      template<class RandomAccessIt, class Compare>
        constexpr void sort_heap(RandomAccessIt first, RandomAccessIt last, Compare comp);

      namespace ranges {
        template<RandomAccessIterator I, Sentinel<I> S, class Comp = ranges::less,
                 class Proj = identity>
          requires Sortable<I, Comp, Proj>
          constexpr I
            sort_heap(I first, S last, Comp comp = {}, Proj proj = {});
        template<RandomAccessRange R, class Comp = ranges::less, class Proj = identity>
          requires Sortable<iterator_t<R>, Comp, Proj>
          constexpr safe_iterator_t<R>
            sort_heap(R&& r, Comp comp = {}, Proj proj = {});
      }

      template<class RandomAccessIt>
        constexpr bool is_heap(RandomAccessIt first, RandomAccessIt last);
      template<class RandomAccessIt, class Compare>
        constexpr bool is_heap(RandomAccessIt first, RandomAccessIt last, Compare comp);
      template<class ExecutionPolicy, class RandomAccessIt>
        bool is_heap(ExecutionPolicy&& exec,
                     RandomAccessIt first, RandomAccessIt last);
      template<class ExecutionPolicy, class RandomAccessIt, class Compare>
        bool is_heap(ExecutionPolicy&& exec,
                     RandomAccessIt first, RandomAccessIt last, Compare comp);

      namespace ranges {
        template<RandomAccessIterator I, Sentinel<I> S, class Proj = identity,
                 IndirectStrictWeakOrder<projected<I, Proj>> Comp = ranges::less>
          constexpr bool is_heap(I first, S last, Comp comp = {}, Proj proj = {});
        template<RandomAccessRange R, class Proj = identity,
                 IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
          constexpr bool is_heap(R&& r, Comp comp = {}, Proj proj = {});
      }

      template<class RandomAccessIt>
        constexpr RandomAccessIt
          is_heap_until(RandomAccessIt first, RandomAccessIt last);
      template<class RandomAccessIt, class Compare>
        constexpr RandomAccessIt
          is_heap_until(RandomAccessIt first, RandomAccessIt last, Compare comp);
      template<class ExecutionPolicy, class RandomAccessIt>
        RandomAccessIt
          is_heap_until(ExecutionPolicy&& exec,
                        RandomAccessIt first, RandomAccessIt last);
      template<class ExecutionPolicy, class RandomAccessIt, class Compare>
        RandomAccessIt
          is_heap_until(ExecutionPolicy&& exec,
                        RandomAccessIt first, RandomAccessIt last, Compare comp);

      namespace ranges {
        template<RandomAccessIterator I, Sentinel<I> S, class Proj = identity,
                 IndirectStrictWeakOrder<projected<I, Proj>> Comp = ranges::less>
          constexpr I is_heap_until(I first, S last, Comp comp = {}, Proj proj = {});
        template<RandomAccessRange R, class Proj = identity,
                 IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
          constexpr safe_iterator_t<R>
            is_heap_until(R&& r, Comp comp = {}, Proj proj = {});
      }

      // minimum and maximum:
      template<class T> constexpr const T& min(const T& a, const T& b);
      template<class T, class Compare>
        constexpr const T& min(const T& a, const T& b, Compare comp);
      template<class T>
        constexpr T min(initializer_list<T> t);
      template<class T, class Compare>
        constexpr T min(initializer_list<T> t, Compare comp);

      namespace ranges {
        template<class T, class Proj = identity,
                 IndirectStrictWeakOrder<projected<const T*, Proj>> Comp = ranges::less>
          constexpr const T& min(const T& a, const T& b, Comp comp = {}, Proj proj = {});
        template<Copyable T, class Proj = identity,
                 IndirectStrictWeakOrder<projected<const T*, Proj>> Comp = ranges::less>
          constexpr T min(initializer_list<T> r, Comp comp = {}, Proj proj = {});
        template<InputRange R, class Proj = identity,
                 IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
          requires IndirectlyCopyableStorable<iterator_t<R>, iter_value_t<iterator_t<R>>*>
          constexpr iter_value_t<iterator_t<R>>
            min(R&& r, Comp comp = {}, Proj proj = {});
      }

      template<class T> constexpr const T& max(const T& a, const T& b);
      template<class T, class Compare>
        constexpr const T& max(const T& a, const T& b, Compare comp);
      template<class T>
        constexpr T max(initializer_list<T> t);
      template<class T, class Compare>
        constexpr T max(initializer_list<T> t, Compare comp);

      namespace ranges {
        template<class T, class Proj = identity,
                 IndirectStrictWeakOrder<projected<const T*, Proj>> Comp = ranges::less>
          constexpr const T& max(const T& a, const T& b, Comp comp = {}, Proj proj = {});
        template<Copyable T, class Proj = identity,
                 IndirectStrictWeakOrder<projected<const T*, Proj>> Comp = ranges::less>
          constexpr T max(initializer_list<T> r, Comp comp = {}, Proj proj = {});
        template<InputRange R, class Proj = identity,
                 IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
          requires IndirectlyCopyableStorable<iterator_t<R>, iter_value_t<iterator_t<R>>*>
          constexpr iter_value_t<iterator_t<R>>
            max(R&& r, Comp comp = {}, Proj proj = {});
      }

      template<class T> constexpr pair<const T&, const T&> minmax(const T& a, const T& b);
      template<class T, class Compare>
        constexpr pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp);
      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);

      namespace ranges {
        template<class T>
        struct minmax_result {
          [[no_unique_address]] T min;
          [[no_unique_address]] T max;

          template<class T2>
            requires ConvertibleTo<const T&, T2>
            operator minmax_result<T2>() const & {
              return {min, max};
            }

          template<class T2>
            requires ConvertibleTo<T, T2>
            operator minmax_result<T2>() && {
              return {std::move(min), std::move(max)};
            }
        };

        template<class T, class Proj = identity,
                 IndirectStrictWeakOrder<projected<const T*, Proj>> Comp = ranges::less>
          constexpr minmax_result<const T&>
            minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {});
        template<Copyable T, class Proj = identity,
                 IndirectStrictWeakOrder<projected<const T*, Proj>> Comp = ranges::less>
          constexpr minmax_result<T>
            minmax(initializer_list<T> r, Comp comp = {}, Proj proj = {});
        template<InputRange R, class Proj = identity,
                 IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
          requires IndirectlyCopyableStorable<iterator_t<R>, iter_value_t<iterator_t<R>>*>
          constexpr minmax_result<iter_value_t<iterator_t<R>>>
            minmax(R&& r, Comp comp = {}, Proj proj = {});
      }

      template<class ForwardIt>
        constexpr ForwardIt min_element(ForwardIt first, ForwardIt last);
      template<class ForwardIt, class Compare>
        constexpr ForwardIt min_element(ForwardIt first, ForwardIt last,
                                              Compare comp);
      template<class ExecutionPolicy, class ForwardIt>
        ForwardIt min_element(ExecutionPolicy&& exec,
                              ForwardIt first, ForwardIt last);
      template<class ExecutionPolicy, class ForwardIt, class Compare>
        ForwardIt min_element(ExecutionPolicy&& exec,
                              ForwardIt first, ForwardIt last, Compare comp);

      namespace ranges {
        template<ForwardIterator I, Sentinel<I> S, class Proj = identity,
                 IndirectStrictWeakOrder<projected<I, Proj>> Comp = ranges::less>
          constexpr I min_element(I first, S last, Comp comp = {}, Proj proj = {});
        template<ForwardRange R, class Proj = identity,
                 IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
          constexpr safe_iterator_t<R>
            min_element(R&& r, Comp comp = {}, Proj proj = {});
      }

      template<class ForwardIt>
        constexpr ForwardIt max_element(ForwardIt first, ForwardIt last);
      template<class ForwardIt, class Compare>
        constexpr ForwardIt max_element(ForwardIt first, ForwardIt last, Compare comp);
      template<class ExecutionPolicy, class ForwardIt>
        ForwardIt max_element(ExecutionPolicy&& exec,
                              ForwardIt first, ForwardIt last);
      template<class ExecutionPolicy, class ForwardIt, class Compare>
        ForwardIt max_element(ExecutionPolicy&& exec,
                              ForwardIt first, ForwardIt last, Compare comp);

     namespace ranges {
        template<ForwardIterator I, Sentinel<I> S, class Proj = identity,
                 IndirectStrictWeakOrder<projected<I, Proj>> Comp = ranges::less>
          constexpr I max_element(I first, S last, Comp comp = {}, Proj proj = {});
        template<ForwardRange R, class Proj = identity,
                 IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
          constexpr safe_iterator_t<R>
            max_element(R&& r, Comp comp = {}, Proj proj = {});
      }

      template<class ForwardIt>
        constexpr pair<ForwardIt, ForwardIt>
          minmax_element(ForwardIt first, ForwardIt last);
      template<class ForwardIt, class Compare>
        constexpr pair<ForwardIt, ForwardIt>
          minmax_element(ForwardIt first, ForwardIt last, Compare comp);
      template<class ExecutionPolicy, class ForwardIt>
        pair<ForwardIt, ForwardIt>
          minmax_element(ExecutionPolicy&& exec,
                         ForwardIt first, ForwardIt last);
      template<class ExecutionPolicy, class ForwardIt, class Compare>
        pair<ForwardIt, ForwardIt>
          minmax_element(ExecutionPolicy&& exec,
                         ForwardIt first, ForwardIt last, Compare comp);

      namespace ranges {
        template<class I>
        using minmax_element_result = minmax_result<I>;

        template<ForwardIterator I, Sentinel<I> S, class Proj = identity,
                 IndirectStrictWeakOrder<projected<I, Proj>> Comp = ranges::less>
          constexpr minmax_element_result<I>
            minmax_element(I first, S last, Comp comp = {}, Proj proj = {});
        template<ForwardRange R, class Proj = identity,
                 IndirectStrictWeakOrder<projected<iterator_t<R>, Proj>> Comp = ranges::less>
          constexpr minmax_element_result<safe_iterator_t<R>>
            minmax_element(R&& r, Comp comp = {}, Proj proj = {});
      }

      // bounded value:
      template<class T>
        constexpr const T& clamp(const T& v, const T& lo, const T& hi);
      template<class T, class Compare>
        constexpr const T& clamp(const T& v, const T& lo, const T& hi, Compare comp);

      // lexicographical comparison:
      template<class InputIt1, class InputIt2>
        constexpr bool
          lexicographical_compare(InputIt1 first1, InputIt1 last1,
                                  InputIt2 first2, InputIt2 last2);
      template<class InputIt1, class InputIt2, class Compare>
        constexpr bool
          lexicographical_compare(InputIt1 first1, InputIt1 last1,
                                  InputIt2 first2, InputIt2 last2,
                                  Compare comp);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2>
        bool
          lexicographical_compare(ExecutionPolicy&& exec,
                                  ForwardIt1 first1, ForwardIt1 last1,
                                  ForwardIt2 first2, ForwardIt2 last2);
      template<class ExecutionPolicy, class ForwardIt1, class ForwardIt2,
               class Compare>
        bool
          lexicographical_compare(ExecutionPolicy&& exec,
                                  ForwardIt1 first1, ForwardIt1 last1,
                                  ForwardIt2 first2, ForwardIt2 last2,
                                  Compare comp);

      namespace ranges {
        template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
                 class Proj1 = identity, class Proj2 = identity,
                 IndirectStrictWeakOrder<projected<I1, Proj1>, projected<I2, Proj2>> Comp =
                   ranges::less>
          constexpr bool
            lexicographical_compare(I1 first1, S1 last1, I2 first2, S2 last2,
                                    Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});
        template<InputRange R1, InputRange R2, class Proj1 = identity,
                 class Proj2 = identity,
                 IndirectStrictWeakOrder<projected<iterator_t<R1>, Proj1>,
                                         projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
          constexpr bool
            lexicographical_compare(R1&& r1, R2&& r2, Comp comp = {},
                                    Proj1 proj1 = {}, Proj2 proj2 = {});
      }

      // three-way comparison algorithms:
      template<class T, class U>
        constexpr auto compare_3way(const T& a, const U& b);
      template<class InputIt1, class InputIt2, class Cmp>
        constexpr auto
          lexicographical_compare_3way(InputIt1 b1, InputIt1 e1, InputIt2 b2, InputIt2 e2,
                                       Cmp comp)
            -> common_comparison_category_t<decltype(comp(*b1, *b2)), strong_ordering>;
      template<class InputIt1, class InputIt2>
        constexpr auto
          lexicographical_compare_3way(InputIt1 b1, InputIt1 e1, InputIt2 b2, InputIt2 e2);

      // permutations:
      template<class BidirectionalIt>
        constexpr bool next_permutation(BidirectionalIt first, BidirectionalIt last);
      template<class BidirectionalIt, class Compare>
        constexpr bool next_permutation(BidirectionalIt first, BidirectionalIt last,
                                        Compare comp);

      namespace ranges {
        template<BidirectionalIterator I, Sentinel<I> S, class Comp = ranges::less,
                 class Proj = identity>
          requires Sortable<I, Comp, Proj>
          constexpr bool
            next_permutation(I first, S last, Comp comp = {}, Proj proj = {});
        template<BidirectionalRange R, class Comp = ranges::less,
                 class Proj = identity>
          requires Sortable<iterator_t<R>, Comp, Proj>
          constexpr bool
            next_permutation(R&& r, Comp comp = {}, Proj proj = {});
      }

      template<class BidirectionalIt>
        constexpr bool prev_permutation(BidirectionalIt first, BidirectionalIt last);
      template<class BidirectionalIt, class Compare>
        constexpr bool prev_permutation(BidirectionalIt first, BidirectionalIt last,
                                        Compare comp);

      namespace ranges {
        template<BidirectionalIterator I, Sentinel<I> S, class Comp = ranges::less,
                 class Proj = identity>
          requires Sortable<I, Comp, Proj>
          constexpr bool
            prev_permutation(I first, S last, Comp comp = {}, Proj proj = {});
        template<BidirectionalRange R, class Comp = ranges::less,
                 class Proj = identity>
          requires Sortable<iterator_t<R>, Comp, Proj>
          constexpr bool
            prev_permutation(R&& r, Comp comp = {}, Proj proj = {});
      }
    }

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/header/algorithm&oldid=110650"