libcxx/include/algorithm

   1 // -*- C++ -*-
   2 //===----------------------------------------------------------------------===//
   3 //
   4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   5 // See https://llvm.org/LICENSE.txt for license information.
   6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef _LIBCPP_ALGORITHM
  11 #define _LIBCPP_ALGORITHM
  12
  13 /*
  14     algorithm synopsis
  15
  16 #include <initializer_list>
  17
  18 namespace std
  19 {
  20
  21 namespace ranges {
  22
  23   // [algorithms.results], algorithm result types
  24   template <class I, class F>
  25     struct in_fun_result;                // since C++20
  26
  27   template <class I1, class I2>
  28     struct in_in_result;                 // since C++20
  29
  30   template <class I, class O>
  31     struct in_out_result;                // since C++20
  32
  33   template <class I1, class I2, class O>
  34     struct in_in_out_result;             // since C++20
  35
  36   template <class I, class O1, class O2>
  37     struct in_out_out_result;            // since C++20
  38
  39   template <class I1, class I2>
  40     struct min_max_result;               // since C++20
  41
  42   template <class I>
  43     struct in_found_result;              // since C++20
  44
  45   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
  46     indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>                                   // since C++20
  47   constexpr I min_element(I first, S last, Comp comp = {}, Proj proj = {});
  48
  49   template<forward_range R, class Proj = identity,
  50     indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>                       // since C++20
  51   constexpr borrowed_iterator_t<R> min_element(R&& r, Comp comp = {}, Proj proj = {});
  52
  53   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
  54     indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
  55   constexpr I ranges::max_element(I first, S last, Comp comp = {}, Proj proj = {});                       // since C++20
  56
  57   template<forward_range R, class Proj = identity,
  58     indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
  59   constexpr borrowed_iterator_t<R> ranges::max_element(R&& r, Comp comp = {}, Proj proj = {});            // since C++20
  60
  61   template<class I1, class I2>
  62     using mismatch_result = in_in_result<I1, I2>;
  63
  64   template <input_iterator I1, sentinel_for<_I1> S1, input_iterator I2, sentinel_for<_I2> S2,
  65           class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
  66     requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
  67   constexpr mismatch_result<_I1, _I2>                                                                     // since C++20
  68   mismatch()(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {})
  69
  70   template <input_range R1, input_range R2,
  71           class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
  72     requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
  73   constexpr mismatch_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
  74   mismatch(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {})                          // since C++20
  75
  76     requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
  77     constexpr I find(I first, S last, const T& value, Proj proj = {});                                    // since C++20
  78
  79   template<input_range R, class T, class Proj = identity>
  80     requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
  81     constexpr borrowed_iterator_t<R>
  82       find(R&& r, const T& value, Proj proj = {});                                                        // since C++20
  83
  84   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
  85            indirect_unary_predicate<projected<I, Proj>> Pred>
  86     constexpr I find_if(I first, S last, Pred pred, Proj proj = {});                                      // since C++20
  87
  88   template<input_range R, class Proj = identity,
  89            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
  90     constexpr borrowed_iterator_t<R>
  91       find_if(R&& r, Pred pred, Proj proj = {});                                                          // since C++20
  92
  93   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
  94            indirect_unary_predicate<projected<I, Proj>> Pred>
  95     constexpr I find_if_not(I first, S last, Pred pred, Proj proj = {});                                  // since C++20
  96
  97   template<input_range R, class Proj = identity,
  98            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
  99     constexpr borrowed_iterator_t<R>
 100       find_if_not(R&& r, Pred pred, Proj proj = {});                                                      // since C++20
 101
 102   template<class T, class Proj = identity,
 103            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
 104     constexpr const T& min(const T& a, const T& b, Comp comp = {}, Proj proj = {});                       // since C++20
 105
 106   template<copyable T, class Proj = identity,
 107            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
 108     constexpr T min(initializer_list<T> r, Comp comp = {}, Proj proj = {});                               // since C++20
 109
 110  template<input_range R, class Proj = identity,
 111           indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
 112    requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
 113    constexpr range_value_t<R>
 114      min(R&& r, Comp comp = {}, Proj proj = {});                                                          // since C++20
 115
 116   template<class T, class Proj = identity,
 117            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
 118     constexpr const T& max(const T& a, const T& b, Comp comp = {}, Proj proj = {});                       // since C++20
 119
 120   template<copyable T, class Proj = identity,
 121            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
 122     constexpr T max(initializer_list<T> r, Comp comp = {}, Proj proj = {});                               // since C++20
 123
 124   template<input_range R, class Proj = identity,
 125            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
 126     requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
 127     constexpr range_value_t<R>
 128       max(R&& r, Comp comp = {}, Proj proj = {});                                                         // since C++20
 129
 130   template<class I, class O>
 131     using unary_transform_result = in_out_result<I, O>;                                                   // since C++20
 132
 133   template<class I1, class I2, class O>
 134     using binary_transform_result = in_in_out_result<I1, I2, O>;                                          // since C++20
 135
 136   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
 137            copy_constructible F, class Proj = identity>
 138     requires indirectly_writable<O, indirect_result_t<F&, projected<I, Proj>>>
 139     constexpr ranges::unary_transform_result<I, O>
 140       transform(I first1, S last1, O result, F op, Proj proj = {});                                       // since C++20
 141
 142   template<input_range R, weakly_incrementable O, copy_constructible F,
 143            class Proj = identity>
 144     requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R>, Proj>>>
 145     constexpr ranges::unary_transform_result<borrowed_iterator_t<R>, O>
 146       transform(R&& r, O result, F op, Proj proj = {});                                                   // since C++20
 147
 148   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
 149            weakly_incrementable O, copy_constructible F, class Proj1 = identity,
 150            class Proj2 = identity>
 151     requires indirectly_writable<O, indirect_result_t<F&, projected<I1, Proj1>,
 152                                            projected<I2, Proj2>>>
 153     constexpr ranges::binary_transform_result<I1, I2, O>
 154       transform(I1 first1, S1 last1, I2 first2, S2 last2, O result,
 155                         F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});                                 // since C++20
 156
 157   template<input_range R1, input_range R2, weakly_incrementable O,
 158            copy_constructible F, class Proj1 = identity, class Proj2 = identity>
 159     requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R1>, Proj1>,
 160                                            projected<iterator_t<R2>, Proj2>>>
 161     constexpr ranges::binary_transform_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
 162       transform(R1&& r1, R2&& r2, O result,
 163                         F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});                                 // since C++20
 164
 165   template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
 166     requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
 167     constexpr iter_difference_t<I>
 168       count(I first, S last, const T& value, Proj proj = {});                                             // since C++20
 169
 170   template<input_range R, class T, class Proj = identity>
 171     requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
 172     constexpr range_difference_t<R>
 173       count(R&& r, const T& value, Proj proj = {});                                                       // since C++20
 174
 175   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
 176            indirect_unary_predicate<projected<I, Proj>> Pred>
 177     constexpr iter_difference_t<I>
 178       count_if(I first, S last, Pred pred, Proj proj = {});                                               // since C++20
 179
 180   template<input_range R, class Proj = identity,
 181            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
 182     constexpr range_difference_t<R>
 183       count_if(R&& r, Pred pred, Proj proj = {});                                                         // since C++20
 184
 185   template<class T>
 186   using minmax_result = min_max_result<T>;
 187
 188   template<class T, class Proj = identity,
 189            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
 190     constexpr ranges::minmax_result<const T&>
 191       minmax(const T& a, const T& b, Comp comp = {}, Proj proj = {});                                     // since C++20
 192
 193   template<copyable T, class Proj = identity,
 194            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
 195     constexpr ranges::minmax_result<T>
 196       minmax(initializer_list<T> r, Comp comp = {}, Proj proj = {});                                      // since C++20
 197
 198   template<input_range R, class Proj = identity,
 199            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
 200     requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
 201     constexpr ranges::minmax_result<range_value_t<R>>
 202       minmax(R&& r, Comp comp = {}, Proj proj = {});                                                      // since C++20
 203
 204   template<class I>
 205   using minmax_element_result = min_max_result<I>;
 206
 207   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
 208            indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
 209     constexpr ranges::minmax_element_result<I>
 210       minmax_element(I first, S last, Comp comp = {}, Proj proj = {});                                    // since C++20
 211
 212   template<forward_range R, class Proj = identity,
 213            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
 214     constexpr ranges::minmax_element_result<borrowed_iterator_t<R>>
 215       minmax_element(R&& r, Comp comp = {}, Proj proj = {});                                              // since C++20
 216
 217   template<class I, class O>
 218     using copy_result = in_out_result<I, O>;                                                // since C++20
 219
 220   template<class I, class O>
 221     using copy_n_result = in_out_result<I, O>;                                              // since C++20
 222
 223   template<class I, class O>
 224     using copy_if_result = in_out_result<I, O>;                                             // since C++20
 225
 226   template<class I1, class I2>
 227     using copy_backward_result = in_out_result<I1, I2>;                                     // since C++20
 228
 229   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
 230     requires indirectly_copyable<I, O>
 231     constexpr ranges::copy_result<I, O> ranges::copy(I first, S last, O result);            // since C++20
 232
 233   template<input_range R, weakly_incrementable O>
 234     requires indirectly_copyable<iterator_t<R>, O>
 235     constexpr ranges::copy_result<borrowed_iterator_t<R>, O> ranges::copy(R&& r, O result); // since C++20
 236
 237   template<input_iterator I, weakly_incrementable O>
 238     requires indirectly_copyable<I, O>
 239     constexpr ranges::copy_n_result<I, O>
 240       ranges::copy_n(I first, iter_difference_t<I> n, O result);                            // since C++20
 241
 242   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Proj = identity,
 243            indirect_unary_predicate<projected<I, Proj>> Pred>
 244     requires indirectly_copyable<I, O>
 245     constexpr ranges::copy_if_result<I, O>
 246       ranges::copy_if(I first, S last, O result, Pred pred, Proj proj = {});                // since C++20
 247
 248   template<input_range R, weakly_incrementable O, class Proj = identity,
 249            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
 250     requires indirectly_copyable<iterator_t<R>, O>
 251     constexpr ranges::copy_if_result<borrowed_iterator_t<R>, O>
 252       ranges::copy_if(R&& r, O result, Pred pred, Proj proj = {});                          // since C++20
 253
 254   template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
 255     requires indirectly_copyable<I1, I2>
 256     constexpr ranges::copy_backward_result<I1, I2>
 257       ranges::copy_backward(I1 first, S1 last, I2 result);                                  // since C++20
 258
 259   template<bidirectional_range R, bidirectional_iterator I>
 260     requires indirectly_copyable<iterator_t<R>, I>
 261     constexpr ranges::copy_backward_result<borrowed_iterator_t<R>, I>
 262       ranges::copy_backward(R&& r, I result);                                               // since C++20
 263
 264   template<class I, class F>
 265     using for_each_result = in_fun_result<I, F>;                                            // since C++20
 266
 267   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
 268            indirectly_unary_invocable<projected<I, Proj>> Fun>
 269     constexpr ranges::for_each_result<I, Fun>
 270       ranges::for_each(I first, S last, Fun f, Proj proj = {});                             // since C++20
 271
 272   template<input_range R, class Proj = identity,
 273            indirectly_unary_invocable<projected<iterator_t<R>, Proj>> Fun>
 274     constexpr ranges::for_each_result<borrowed_iterator_t<R>, Fun>
 275       ranges::for_each(R&& r, Fun f, Proj proj = {});                                       // since C++20
 276
 277   template<input_iterator I, class Proj = identity,
 278            indirectly_unary_invocable<projected<I, Proj>> Fun>
 279     constexpr ranges::for_each_n_result<I, Fun>
 280       ranges::for_each_n(I first, iter_difference_t<I> n, Fun f, Proj proj = {});           // since C++20
 281
 282   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
 283            indirect_unary_predicate<projected<I, Proj>> Pred>
 284     constexpr bool ranges::is_partitioned(I first, S last, Pred pred, Proj proj = {});      // since C++20
 285
 286   template<input_range R, class Proj = identity,
 287            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
 288     constexpr bool ranges::is_partitioned(R&& r, Pred pred, Proj proj = {});                // since C++20
 289
 290   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
 291           class Proj = identity>
 292     requires sortable<I, Comp, Proj>
 293     constexpr I
 294       ranges::push_heap(I first, S last, Comp comp = {}, Proj proj = {});                   // since C++20
 295
 296   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
 297     requires sortable<iterator_t<R>, Comp, Proj>
 298     constexpr borrowed_iterator_t<R>
 299       ranges::push_heap(R&& r, Comp comp = {}, Proj proj = {});                             // since C++20
 300
 301   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
 302           class Proj = identity>
 303     requires sortable<I, Comp, Proj>
 304     constexpr I
 305       ranges::pop_heap(I first, S last, Comp comp = {}, Proj proj = {});                    // since C++20
 306
 307   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
 308     requires sortable<iterator_t<R>, Comp, Proj>
 309     constexpr borrowed_iterator_t<R>
 310       ranges::pop_heap(R&& r, Comp comp = {}, Proj proj = {});                              // since C++20
 311
 312   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
 313           class Proj = identity>
 314     requires sortable<I, Comp, Proj>
 315     constexpr I
 316       ranges::make_heap(I first, S last, Comp comp = {}, Proj proj = {});                   // since C++20
 317
 318   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
 319     requires sortable<iterator_t<R>, Comp, Proj>
 320     constexpr borrowed_iterator_t<R>
 321       ranges::make_heap(R&& r, Comp comp = {}, Proj proj = {});                             // since C++20
 322
 323   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
 324           class Proj = identity>
 325     requires sortable<I, Comp, Proj>
 326     constexpr I
 327       ranges::sort_heap(I first, S last, Comp comp = {}, Proj proj = {});                   // since C++20
 328
 329   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
 330     requires sortable<iterator_t<R>, Comp, Proj>
 331     constexpr borrowed_iterator_t<R>
 332       ranges::sort_heap(R&& r, Comp comp = {}, Proj proj = {});                             // since C++20
 333
 334   template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
 335             indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
 336     constexpr bool is_heap(I first, S last, Comp comp = {}, Proj proj = {});                // since C++20
 337
 338   template<random_access_range R, class Proj = identity,
 339             indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
 340     constexpr bool is_heap(R&& r, Comp comp = {}, Proj proj = {});                          // since C++20
 341
 342   template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
 343            indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
 344     constexpr I is_heap_until(I first, S last, Comp comp = {}, Proj proj = {});             // since C++20
 345
 346   template<random_access_range R, class Proj = identity,
 347            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
 348     constexpr borrowed_iterator_t<R>
 349       is_heap_until(R&& r, Comp comp = {}, Proj proj = {});                                 // since C++20
 350
 351   template<bidirectional_iterator I, sentinel_for<I> S>
 352     requires permutable<I>
 353     constexpr I ranges::reverse(I first, S last);                                           // since C++20
 354
 355   template<bidirectional_range R>
 356     requires permutable<iterator_t<R>>
 357     constexpr borrowed_iterator_t<R> ranges::reverse(R&& r);                                // since C++20
 358
 359   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
 360             class Proj = identity>
 361     requires sortable<I, Comp, Proj>
 362     constexpr I
 363       ranges::sort(I first, S last, Comp comp = {}, Proj proj = {});                        // since C++20
 364
 365   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
 366     requires sortable<iterator_t<R>, Comp, Proj>
 367     constexpr borrowed_iterator_t<R>
 368       ranges::sort(R&& r, Comp comp = {}, Proj proj = {});                                  // since C++20
 369
 370   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
 371           class Proj = identity>
 372     requires sortable<I, Comp, Proj>
 373     I ranges::stable_sort(I first, S last, Comp comp = {}, Proj proj = {});                 // since C++20
 374
 375   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
 376     requires sortable<iterator_t<R>, Comp, Proj>
 377     borrowed_iterator_t<R>
 378       ranges::stable_sort(R&& r, Comp comp = {}, Proj proj = {});                           // since C++20
 379
 380   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
 381            class Proj = identity>
 382     requires sortable<I, Comp, Proj>
 383     constexpr I
 384       ranges::partial_sort(I first, I middle, S last, Comp comp = {}, Proj proj = {});      // since C++20
 385
 386   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
 387     requires sortable<iterator_t<R>, Comp, Proj>
 388     constexpr borrowed_iterator_t<R>
 389       ranges::partial_sort(R&& r, iterator_t<R> middle, Comp comp = {}, Proj proj = {});    // since C++20
 390
 391   template<class T, output_iterator<const T&> O, sentinel_for<O> S>
 392     constexpr O ranges::fill(O first, S last, const T& value);                              // since C++20
 393
 394   template<class T, output_range<const T&> R>
 395     constexpr borrowed_iterator_t<R> ranges::fill(R&& r, const T& value);                   // since C++20
 396
 397   template<class T, output_iterator<const T&> O>
 398     constexpr O ranges::fill_n(O first, iter_difference_t<O> n, const T& value);            // since C++20
 399
 400   template<input_or_output_iterator O, sentinel_for<O> S, copy_constructible F>
 401     requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
 402     constexpr O generate(O first, S last, F gen);                                           // since C++20
 403
 404   template<class ExecutionPolicy, class ForwardIterator, class Generator>
 405     void generate(ExecutionPolicy&& exec,
 406                   ForwardIterator first, ForwardIterator last,
 407                   Generator gen);                                                           // since C++17
 408
 409   template<class R, copy_constructible F>
 410     requires invocable<F&> && output_range<R, invoke_result_t<F&>>
 411     constexpr borrowed_iterator_t<R> generate(R&& r, F gen);                                // since C++20
 412
 413   template<input_or_output_iterator O, copy_constructible F>
 414     requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
 415     constexpr O generate_n(O first, iter_difference_t<O> n, F gen);                         // since C++20
 416
 417   template<class ExecutionPolicy, class ForwardIterator, class Size, class Generator>
 418     ForwardIterator generate_n(ExecutionPolicy&& exec,
 419                                ForwardIterator first, Size n, Generator gen);               // since C++17
 420
 421  template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
 422           class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
 423    requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
 424    constexpr bool ranges::equal(I1 first1, S1 last1, I2 first2, S2 last2,
 425                                 Pred pred = {},
 426                                 Proj1 proj1 = {}, Proj2 proj2 = {});                        // since C++20
 427
 428  template<input_range R1, input_range R2, class Pred = ranges::equal_to,
 429           class Proj1 = identity, class Proj2 = identity>
 430    requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
 431    constexpr bool ranges::equal(R1&& r1, R2&& r2, Pred pred = {},
 432                                 Proj1 proj1 = {}, Proj2 proj2 = {});                        // since C++20
 433
 434   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
 435            indirect_unary_predicate<projected<I, Proj>> Pred>
 436     constexpr bool ranges::all_of(I first, S last, Pred pred, Proj proj = {});              // since C++20
 437
 438   template<input_range R, class Proj = identity,
 439            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
 440     constexpr bool ranges::all_of(R&& r, Pred pred, Proj proj = {});                        // since C++20
 441
 442   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
 443            indirect_unary_predicate<projected<I, Proj>> Pred>
 444     constexpr bool ranges::any_of(I first, S last, Pred pred, Proj proj = {});              // since C++20
 445
 446   template<input_range R, class Proj = identity,
 447            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
 448     constexpr bool ranges::any_of(R&& r, Pred pred, Proj proj = {});                        // since C++20
 449
 450   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
 451           class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
 452     requires (forward_iterator<I1> || sized_sentinel_for<S1, I1>) &&
 453            (forward_iterator<I2> || sized_sentinel_for<S2, I2>) &&
 454            indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
 455     constexpr bool ranges::ends_with(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
 456                                    Proj1 proj1 = {}, Proj2 proj2 = {});                     // since C++23
 457
 458   template<input_range R1, input_range R2, class Pred = ranges::equal_to, class Proj1 = identity,
 459           class Proj2 = identity>
 460     requires (forward_range<R1> || sized_range<R1>) &&
 461            (forward_range<R2> || sized_range<R2>) &&
 462            indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
 463     constexpr bool ranges::ends_with(R1&& r1, R2&& r2, Pred pred = {},
 464                                    Proj1 proj1 = {}, Proj2 proj2 = {});                     // since C++23
 465
 466   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
 467            indirect_unary_predicate<projected<I, Proj>> Pred>
 468     constexpr bool ranges::none_of(I first, S last, Pred pred, Proj proj = {});             // since C++20
 469
 470   template<input_range R, class Proj = identity,
 471            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
 472     constexpr bool ranges::none_of(R&& r, Pred pred, Proj proj = {});                       // since C++20
 473
 474   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
 475           class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
 476     requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
 477     constexpr bool ranges::starts_with(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
 478                                       Proj1 proj1 = {}, Proj2 proj2 = {});                 // since C++23
 479
 480   template<input_range R1, input_range R2, class Pred = ranges::equal_to, class Proj1 = identity,
 481           class Proj2 = identity>
 482     requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
 483     constexpr bool ranges::starts_with(R1&& r1, R2&& r2, Pred pred = {},
 484                                       Proj1 proj1 = {}, Proj2 proj2 = {});                // since C++23
 485
 486   template<input_iterator I1, sentinel_for<I1> S1,
 487           random_access_iterator I2, sentinel_for<I2> S2,
 488           class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
 489     requires indirectly_copyable<I1, I2> && sortable<I2, Comp, Proj2> &&
 490             indirect_strict_weak_order<Comp, projected<I1, Proj1>, projected<I2, Proj2>>
 491     constexpr partial_sort_copy_result<I1, I2>
 492       partial_sort_copy(I1 first, S1 last, I2 result_first, S2 result_last,
 493                         Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});                // since C++20
 494
 495   template<input_range R1, random_access_range R2, class Comp = ranges::less,
 496           class Proj1 = identity, class Proj2 = identity>
 497     requires indirectly_copyable<iterator_t<R1>, iterator_t<R2>> &&
 498             sortable<iterator_t<R2>, Comp, Proj2> &&
 499             indirect_strict_weak_order<Comp, projected<iterator_t<R1>, Proj1>,
 500                                         projected<iterator_t<R2>, Proj2>>
 501     constexpr partial_sort_copy_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
 502       partial_sort_copy(R1&& r, R2&& result_r, Comp comp = {},
 503                         Proj1 proj1 = {}, Proj2 proj2 = {});                                // since C++20
 504
 505   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
 506            indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
 507     constexpr bool ranges::is_sorted(I first, S last, Comp comp = {}, Proj proj = {});      // since C++20
 508
 509   template<forward_range R, class Proj = identity,
 510            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
 511     constexpr bool ranges::is_sorted(R&& r, Comp comp = {}, Proj proj = {});                // since C++20
 512
 513   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
 514            indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
 515     constexpr I ranges::is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {});   // since C++20
 516
 517   template<forward_range R, class Proj = identity,
 518            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
 519     constexpr borrowed_iterator_t<R>
 520       ranges::is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});                       // since C++20
 521
 522   template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
 523           class Proj = identity>
 524     requires sortable<I, Comp, Proj>
 525     constexpr I
 526       ranges::nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {});          // since C++20
 527
 528   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
 529     requires sortable<iterator_t<R>, Comp, Proj>
 530     constexpr borrowed_iterator_t<R>
 531       ranges::nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {});        // since C++20
 532
 533   template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
 534            indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>    // since C++20
 535     constexpr I upper_bound(I first, S last, const T& value, Comp comp = {}, Proj proj = {});
 536
 537   template<forward_range R, class T, class Proj = identity,
 538            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
 539              ranges::less>
 540     constexpr borrowed_iterator_t<R>
 541       upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});                   // since C++20
 542
 543   template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
 544            indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
 545     constexpr I lower_bound(I first, S last, const T& value, Comp comp = {},
 546                                     Proj proj = {});                                        // since C++20
 547   template<forward_range R, class T, class Proj = identity,
 548            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
 549              ranges::less>
 550     constexpr borrowed_iterator_t<R>
 551       lower_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});                   // since C++20
 552
 553   template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
 554            indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
 555     constexpr bool binary_search(I first, S last, const T& value, Comp comp = {},
 556                                          Proj proj = {});                                   // since C++20
 557
 558   template<forward_range R, class T, class Proj = identity,
 559            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
 560              ranges::less>
 561     constexpr bool binary_search(R&& r, const T& value, Comp comp = {},
 562                                          Proj proj = {});                                   // since C++20
 563
 564   template<permutable I, sentinel_for<I> S, class Proj = identity,
 565            indirect_unary_predicate<projected<I, Proj>> Pred>
 566     constexpr subrange<I>
 567       partition(I first, S last, Pred pred, Proj proj = {});                                // since C++20
 568
 569   template<forward_range R, class Proj = identity,
 570            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
 571     requires permutable<iterator_t<R>>
 572     constexpr borrowed_subrange_t<R>
 573       partition(R&& r, Pred pred, Proj proj = {});                                          // since C++20
 574
 575   template<bidirectional_iterator I, sentinel_for<I> S, class Proj = identity,
 576            indirect_unary_predicate<projected<I, Proj>> Pred>
 577     requires permutable<I>
 578     subrange<I> stable_partition(I first, S last, Pred pred, Proj proj = {});               // since C++20
 579
 580   template<bidirectional_range R, class Proj = identity,
 581            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
 582     requires permutable<iterator_t<R>>
 583     borrowed_subrange_t<R> stable_partition(R&& r, Pred pred, Proj proj = {});              // since C++20
 584
 585   template<input_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2,
 586            class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
 587     requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
 588     constexpr I1 ranges::find_first_of(I1 first1, S1 last1, I2 first2, S2 last2,
 589                                        Pred pred = {},
 590                                        Proj1 proj1 = {}, Proj2 proj2 = {});                 // since C++20
 591
 592   template<input_range R1, forward_range R2,
 593            class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
 594     requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
 595     constexpr borrowed_iterator_t<R1>
 596       ranges::find_first_of(R1&& r1, R2&& r2,
 597                             Pred pred = {},
 598                             Proj1 proj1 = {}, Proj2 proj2 = {});                            // since C++20
 599
 600   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
 601            indirect_binary_predicate<projected<I, Proj>,
 602                                      projected<I, Proj>> Pred = ranges::equal_to>
 603     constexpr I ranges::adjacent_find(I first, S last, Pred pred = {}, Proj proj = {});     // since C++20
 604
 605   template<forward_range R, class Proj = identity,
 606            indirect_binary_predicate<projected<iterator_t<R>, Proj>,
 607                                      projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
 608     constexpr borrowed_iterator_t<R> ranges::adjacent_find(R&& r, Pred pred = {}, Proj proj = {});  // since C++20
 609
 610   template<input_iterator I, sentinel_for<I> S, class T1, class T2, class Proj = identity>
 611     requires indirectly_writable<I, const T2&> &&
 612              indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*>
 613     constexpr I
 614       ranges::replace(I first, S last, const T1& old_value, const T2& new_value, Proj proj = {});   // since C++20
 615
 616   template<input_range R, class T1, class T2, class Proj = identity>
 617     requires indirectly_writable<iterator_t<R>, const T2&> &&
 618              indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T1*>
 619     constexpr borrowed_iterator_t<R>
 620       ranges::replace(R&& r, const T1& old_value, const T2& new_value, Proj proj = {});             // since C++20
 621
 622   template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity,
 623            indirect_unary_predicate<projected<I, Proj>> Pred>
 624     requires indirectly_writable<I, const T&>
 625     constexpr I ranges::replace_if(I first, S last, Pred pred, const T& new_value, Proj proj = {}); // since C++20
 626
 627   template<input_range R, class T, class Proj = identity,
 628            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
 629     requires indirectly_writable<iterator_t<R>, const T&>
 630     constexpr borrowed_iterator_t<R>
 631       ranges::replace_if(R&& r, Pred pred, const T& new_value, Proj proj = {});                     // since C++20
 632
 633   template<class T, class Proj = identity,
 634            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
 635     constexpr const T&
 636       ranges::clamp(const T& v, const T& lo, const T& hi, Comp comp = {}, Proj proj = {});          // since C++20
 637
 638   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
 639            class Proj1 = identity, class Proj2 = identity,
 640            indirect_strict_weak_order<projected<I1, Proj1>,
 641                                       projected<I2, Proj2>> Comp = ranges::less>
 642     constexpr bool
 643       ranges::lexicographical_compare(I1 first1, S1 last1, I2 first2, S2 last2,
 644                                       Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});          // since C++20
 645
 646   template<input_range R1, input_range R2, class Proj1 = identity,
 647            class Proj2 = identity,
 648            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
 649                                       projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
 650     constexpr bool
 651       ranges::lexicographical_compare(R1&& r1, R2&& r2, Comp comp = {},
 652                                       Proj1 proj1 = {}, Proj2 proj2 = {});                          // since C++20
 653
 654   template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
 655     requires indirectly_movable<I1, I2>
 656     constexpr ranges::move_backward_result<I1, I2>
 657       ranges::move_backward(I1 first, S1 last, I2 result);                                          // since C++20
 658
 659   template<bidirectional_range R, bidirectional_iterator I>
 660     requires indirectly_movable<iterator_t<R>, I>
 661     constexpr ranges::move_backward_result<borrowed_iterator_t<R>, I>
 662       ranges::move_backward(R&& r, I result);                                                       // since C++20
 663
 664   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
 665     requires indirectly_movable<I, O>
 666     constexpr ranges::move_result<I, O>
 667       ranges::move(I first, S last, O result);                                                      // since C++20
 668
 669   template<input_range R, weakly_incrementable O>
 670     requires indirectly_movable<iterator_t<R>, O>
 671     constexpr ranges::move_result<borrowed_iterator_t<R>, O>
 672       ranges::move(R&& r, O result);                                                                // since C++20
 673
 674   template<class I, class O1, class O2>
 675       using partition_copy_result = in_out_out_result<I, O1, O2>;                                   // since C++20
 676
 677   template<input_iterator I, sentinel_for<I> S,
 678           weakly_incrementable O1, weakly_incrementable O2,
 679           class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
 680     requires indirectly_copyable<I, O1> && indirectly_copyable<I, O2>
 681     constexpr partition_copy_result<I, O1, O2>
 682       partition_copy(I first, S last, O1 out_true, O2 out_false, Pred pred,
 683                     Proj proj = {});                                                                // since C++20
 684
 685   template<input_range R, weakly_incrementable O1, weakly_incrementable O2,
 686           class Proj = identity,
 687           indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
 688     requires indirectly_copyable<iterator_t<R>, O1> &&
 689             indirectly_copyable<iterator_t<R>, O2>
 690     constexpr partition_copy_result<borrowed_iterator_t<R>, O1, O2>
 691       partition_copy(R&& r, O1 out_true, O2 out_false, Pred pred, Proj proj = {});                  // since C++20
 692
 693   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
 694            indirect_unary_predicate<projected<I, Proj>> Pred>
 695     constexpr I partition_point(I first, S last, Pred pred, Proj proj = {});                        // since C++20
 696
 697   template<forward_range R, class Proj = identity,
 698            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
 699     constexpr borrowed_iterator_t<R>
 700       partition_point(R&& r, Pred pred, Proj proj = {});                                            // since C++20
 701
 702   template<class I1, class I2, class O>
 703     using merge_result = in_in_out_result<I1, I2, O>;                                               // since C++20
 704
 705   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
 706            weakly_incrementable O, class Comp = ranges::less, class Proj1 = identity,
 707            class Proj2 = identity>
 708     requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
 709     constexpr merge_result<I1, I2, O>
 710       merge(I1 first1, S1 last1, I2 first2, S2 last2, O result,
 711             Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});                                    // since C++20
 712
 713   template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less,
 714            class Proj1 = identity, class Proj2 = identity>
 715     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
 716     constexpr merge_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
 717       merge(R1&& r1, R2&& r2, O result,
 718             Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});                                    // since C++20
 719
 720   template<permutable I, sentinel_for<I> S, class T, class Proj = identity>
 721     requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
 722     constexpr subrange<I> ranges::remove(I first, S last, const T& value, Proj proj = {});          // since C++20
 723
 724   template<forward_range R, class T, class Proj = identity>
 725     requires permutable<iterator_t<R>> &&
 726              indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
 727     constexpr borrowed_subrange_t<R>
 728       ranges::remove(R&& r, const T& value, Proj proj = {});                                        // since C++20
 729
 730   template<permutable I, sentinel_for<I> S, class Proj = identity,
 731            indirect_unary_predicate<projected<I, Proj>> Pred>
 732     constexpr subrange<I> ranges::remove_if(I first, S last, Pred pred, Proj proj = {});            // since C++20
 733
 734   template<forward_range R, class Proj = identity,
 735            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
 736     requires permutable<iterator_t<R>>
 737     constexpr borrowed_subrange_t<R>
 738       ranges::remove_if(R&& r, Pred pred, Proj proj = {});                                          // since C++20
 739
 740   template<class I, class O>
 741     using set_difference_result = in_out_result<I, O>;                                              // since C++20
 742
 743   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
 744            weakly_incrementable O, class Comp = ranges::less,
 745            class Proj1 = identity, class Proj2 = identity>
 746     requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
 747     constexpr set_difference_result<I1, O>
 748       set_difference(I1 first1, S1 last1, I2 first2, S2 last2, O result,
 749                      Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});                           // since C++20
 750
 751   template<input_range R1, input_range R2, weakly_incrementable O,
 752            class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
 753     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
 754     constexpr set_difference_result<borrowed_iterator_t<R1>, O>
 755       set_difference(R1&& r1, R2&& r2, O result,
 756                      Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});                           // since C++20
 757
 758   template<class I1, class I2, class O>
 759     using set_intersection_result = in_in_out_result<I1, I2, O>;                                    // since C++20
 760
 761   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
 762            weakly_incrementable O, class Comp = ranges::less,
 763            class Proj1 = identity, class Proj2 = identity>
 764     requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
 765     constexpr set_intersection_result<I1, I2, O>
 766       set_intersection(I1 first1, S1 last1, I2 first2, S2 last2, O result,
 767                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});                         // since C++20
 768
 769   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
 770            weakly_incrementable O, class Comp = ranges::less,
 771            class Proj1 = identity, class Proj2 = identity>
 772     requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
 773     constexpr set_intersection_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
 774       set_intersection(R1&& r1, R2&& r2, O result,
 775                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});                         // since C++20
 776
 777   template <class _InIter, class _OutIter>
 778   using reverse_copy_result = in_out_result<_InIter, _OutIter>;                                     // since C++20
 779
 780   template<bidirectional_iterator I, sentinel_for<I> S, weakly_incrementable O>
 781     requires indirectly_copyable<I, O>
 782     constexpr ranges::reverse_copy_result<I, O>
 783       ranges::reverse_copy(I first, S last, O result);                                              // since C++20
 784
 785   template<bidirectional_range R, weakly_incrementable O>
 786     requires indirectly_copyable<iterator_t<R>, O>
 787     constexpr ranges::reverse_copy_result<borrowed_iterator_t<R>, O>
 788       ranges::reverse_copy(R&& r, O result);                                                        // since C++20
 789
 790   template<permutable I, sentinel_for<I> S>
 791     constexpr subrange<I> rotate(I first, I middle, S last);                                        // since C++20
 792
 793   template<forward_range R>
 794     requires permutable<iterator_t<R>>
 795     constexpr borrowed_subrange_t<R> rotate(R&& r, iterator_t<R> middle);                           // since C++20
 796
 797   template <class _InIter, class _OutIter>
 798   using rotate_copy_result = in_out_result<_InIter, _OutIter>;                                      // since C++20
 799
 800   template<forward_iterator I, sentinel_for<I> S, weakly_incrementable O>
 801     requires indirectly_copyable<I, O>
 802     constexpr ranges::rotate_copy_result<I, O>
 803       ranges::rotate_copy(I first, I middle, S last, O result);                                     // since C++20
 804
 805   template<forward_range R, weakly_incrementable O>
 806     requires indirectly_copyable<iterator_t<R>, O>
 807     constexpr ranges::rotate_copy_result<borrowed_iterator_t<R>, O>
 808       ranges::rotate_copy(R&& r, iterator_t<R> middle, O result);                                   // since C++20
 809
 810   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Gen>
 811     requires (forward_iterator<I> || random_access_iterator<O>) &&
 812             indirectly_copyable<I, O> &&
 813             uniform_random_bit_generator<remove_reference_t<Gen>>
 814     O sample(I first, S last, O out, iter_difference_t<I> n, Gen&& g);                              // since C++20
 815
 816   template<input_range R, weakly_incrementable O, class Gen>
 817     requires (forward_range<R> || random_access_iterator<O>) &&
 818             indirectly_copyable<iterator_t<R>, O> &&
 819             uniform_random_bit_generator<remove_reference_t<Gen>>
 820     O sample(R&& r, O out, range_difference_t<R> n, Gen&& g);                                       // since C++20
 821
 822   template<random_access_iterator I, sentinel_for<I> S, class Gen>
 823     requires permutable<I> &&
 824             uniform_random_bit_generator<remove_reference_t<Gen>>
 825     I shuffle(I first, S last, Gen&& g);                                                            // since C++20
 826
 827   template<random_access_range R, class Gen>
 828     requires permutable<iterator_t<R>> &&
 829             uniform_random_bit_generator<remove_reference_t<Gen>>
 830     borrowed_iterator_t<R> shuffle(R&& r, Gen&& g);                                                 // since C++20
 831
 832   template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2,
 833          sentinel_for<I2> S2, class Proj1 = identity, class Proj2 = identity,
 834          indirect_equivalence_relation<projected<I1, Proj1>,
 835                                        projected<I2, Proj2>> Pred = ranges::equal_to>
 836   constexpr bool ranges::is_permutation(I1 first1, S1 last1, I2 first2, S2 last2,
 837                                         Pred pred = {},
 838                                         Proj1 proj1 = {}, Proj2 proj2 = {});                       // since C++20
 839
 840   template<forward_range R1, forward_range R2,
 841          class Proj1 = identity, class Proj2 = identity,
 842          indirect_equivalence_relation<projected<iterator_t<R1>, Proj1>,
 843                                        projected<iterator_t<R2>, Proj2>> Pred = ranges::equal_to>
 844   constexpr bool ranges::is_permutation(R1&& r1, R2&& r2, Pred pred = {},
 845                                         Proj1 proj1 = {}, Proj2 proj2 = {});                       // since C++20
 846
 847   template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2,
 848            sentinel_for<I2> S2, class Pred = ranges::equal_to,
 849            class Proj1 = identity, class Proj2 = identity>
 850     requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
 851     constexpr subrange<I1>
 852       ranges::search(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
 853                      Proj1 proj1 = {}, Proj2 proj2 = {});                                           // since C++20
 854
 855   template<forward_range R1, forward_range R2, class Pred = ranges::equal_to,
 856            class Proj1 = identity, class Proj2 = identity>
 857     requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
 858     constexpr borrowed_subrange_t<R1>
 859       ranges::search(R1&& r1, R2&& r2, Pred pred = {},
 860                      Proj1 proj1 = {}, Proj2 proj2 = {});                                           // since C++20
 861
 862   template<forward_iterator I, sentinel_for<I> S, class T,
 863            class Pred = ranges::equal_to, class Proj = identity>
 864     requires indirectly_comparable<I, const T*, Pred, Proj>
 865     constexpr subrange<I>
 866       ranges::search_n(I first, S last, iter_difference_t<I> count,
 867                        const T& value, Pred pred = {}, Proj proj = {});                             // since C++20
 868
 869   template<forward_range R, class T, class Pred = ranges::equal_to,
 870            class Proj = identity>
 871     requires indirectly_comparable<iterator_t<R>, const T*, Pred, Proj>
 872     constexpr borrowed_subrange_t<R>
 873       ranges::search_n(R&& r, range_difference_t<R> count,
 874                        const T& value, Pred pred = {}, Proj proj = {});                             // since C++20
 875
 876   template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2,
 877            class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
 878     requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
 879     constexpr subrange<I1>
 880       ranges::find_end(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
 881                        Proj1 proj1 = {}, Proj2 proj2 = {});                                         // since C++20
 882
 883   template<forward_range R1, forward_range R2,
 884            class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
 885     requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
 886     constexpr borrowed_subrange_t<R1>
 887       ranges::find_end(R1&& r1, R2&& r2, Pred pred = {},
 888                        Proj1 proj1 = {}, Proj2 proj2 = {});                                         // since C++20
 889
 890   template<class I1, class I2, class O>
 891     using set_symmetric_difference_result = in_in_out_result<I1, I2, O>;                            // since C++20
 892
 893   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
 894            weakly_incrementable O, class Comp = ranges::less,
 895            class Proj1 = identity, class Proj2 = identity>
 896     requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
 897     constexpr set_symmetric_difference_result<I1, I2, O>
 898       set_symmetric_difference(I1 first1, S1 last1, I2 first2, S2 last2, O result,
 899                                Comp comp = {}, Proj1 proj1 = {},
 900                                Proj2 proj2 = {});                                                   // since C++20
 901
 902   template<input_range R1, input_range R2, weakly_incrementable O,
 903            class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
 904     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
 905     constexpr set_symmetric_difference_result<borrowed_iterator_t<R1>,
 906                                                       borrowed_iterator_t<R2>, O>
 907       set_symmetric_difference(R1&& r1, R2&& r2, O result, Comp comp = {},
 908                                Proj1 proj1 = {}, Proj2 proj2 = {});                                 // since C++20
 909
 910   template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
 911            indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
 912     constexpr subrange<I>
 913       equal_range(I first, S last, const T& value, Comp comp = {}, Proj proj = {});                 // since C++20
 914
 915   template<forward_range R, class T, class Proj = identity,
 916            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
 917              ranges::less>
 918     constexpr borrowed_subrange_t<R>
 919       equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {});                           // since C++20
 920
 921   template<class I1, class I2, class O>
 922     using set_union_result = in_in_out_result<I1, I2, O>;                                           // since C++20
 923
 924   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
 925            weakly_incrementable O, class Comp = ranges::less,
 926            class Proj1 = identity, class Proj2 = identity>
 927     requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
 928     constexpr set_union_result<I1, I2, O>
 929       set_union(I1 first1, S1 last1, I2 first2, S2 last2, O result, Comp comp = {},
 930                 Proj1 proj1 = {}, Proj2 proj2 = {});                                                // since C++20
 931
 932   template<input_range R1, input_range R2, weakly_incrementable O,
 933            class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
 934     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
 935     constexpr set_union_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
 936       set_union(R1&& r1, R2&& r2, O result, Comp comp = {},
 937                 Proj1 proj1 = {}, Proj2 proj2 = {});                                                // since C++20
 938
 939   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
 940            class Proj1 = identity, class Proj2 = identity,
 941            indirect_strict_weak_order<projected<I1, Proj1>, projected<I2, Proj2>> Comp =
 942              ranges::less>
 943     constexpr bool includes(I1 first1, S1 last1, I2 first2, S2 last2, Comp comp = {},
 944                             Proj1 proj1 = {}, Proj2 proj2 = {});                                   // since C++20
 945
 946   template<input_range R1, input_range R2, class Proj1 = identity,
 947            class Proj2 = identity,
 948            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
 949                                       projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
 950     constexpr bool includes(R1&& r1, R2&& r2, Comp comp = {},
 951                             Proj1 proj1 = {}, Proj2 proj2 = {});                                   // since C++20
 952
 953   template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
 954            class Proj = identity>
 955     requires sortable<I, Comp, Proj>
 956     I inplace_merge(I first, I middle, S last, Comp comp = {}, Proj proj = {});                    // since C++20
 957
 958   template<bidirectional_range R, class Comp = ranges::less, class Proj = identity>
 959     requires sortable<iterator_t<R>, Comp, Proj>
 960     borrowed_iterator_t<R>
 961       inplace_merge(R&& r, iterator_t<R> middle, Comp comp = {},
 962                     Proj proj = {});                                                               // since C++20
 963
 964   template<permutable I, sentinel_for<I> S, class Proj = identity,
 965            indirect_equivalence_relation<projected<I, Proj>> C = ranges::equal_to>
 966     constexpr subrange<I> unique(I first, S last, C comp = {}, Proj proj = {});                    // since C++20
 967
 968   template<forward_range R, class Proj = identity,
 969            indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
 970     requires permutable<iterator_t<R>>
 971     constexpr borrowed_subrange_t<R>
 972       unique(R&& r, C comp = {}, Proj proj = {});                                                  // since C++20
 973
 974   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Proj = identity,
 975            indirect_equivalence_relation<projected<I, Proj>> C = ranges::equal_to>
 976     requires indirectly_copyable<I, O> &&
 977              (forward_iterator<I> ||
 978               (input_iterator<O> && same_as<iter_value_t<I>, iter_value_t<O>>) ||
 979               indirectly_copyable_storable<I, O>)
 980     constexpr unique_copy_result<I, O>
 981       unique_copy(I first, S last, O result, C comp = {}, Proj proj = {});                         // since C++20
 982
 983   template<input_range R, weakly_incrementable O, class Proj = identity,
 984            indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
 985     requires indirectly_copyable<iterator_t<R>, O> &&
 986              (forward_iterator<iterator_t<R>> ||
 987               (input_iterator<O> && same_as<range_value_t<R>, iter_value_t<O>>) ||
 988               indirectly_copyable_storable<iterator_t<R>, O>)
 989     constexpr unique_copy_result<borrowed_iterator_t<R>, O>
 990       unique_copy(R&& r, O result, C comp = {}, Proj proj = {});                                   // since C++20
 991
 992   template<class I, class O>
 993       using remove_copy_result = in_out_result<I, O>;                                              // since C++20
 994
 995   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class T,
 996            class Proj = identity>
 997              indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
 998     constexpr remove_copy_result<I, O>
 999       remove_copy(I first, S last, O result, const T& value, Proj proj = {});                      // since C++20
1000
1001   template<input_range R, weakly_incrementable O, class T, class Proj = identity>
1002     requires indirectly_copyable<iterator_t<R>, O> &&
1003              indirect_binary_predicate<ranges::equal_to,
1004                                        projected<iterator_t<R>, Proj>, const T*>
1005     constexpr remove_copy_result<borrowed_iterator_t<R>, O>
1006       remove_copy(R&& r, O result, const T& value, Proj proj = {});                                // since C++20
1007
1008   template<class I, class O>
1009       using remove_copy_if_result = in_out_result<I, O>;                                           // since C++20
1010
1011   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
1012            class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
1013     requires indirectly_copyable<I, O>
1014     constexpr remove_copy_if_result<I, O>
1015       remove_copy_if(I first, S last, O result, Pred pred, Proj proj = {});                        // since C++20
1016
1017   template<input_range R, weakly_incrementable O, class Proj = identity,
1018            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
1019     requires indirectly_copyable<iterator_t<R>, O>
1020     constexpr remove_copy_if_result<borrowed_iterator_t<R>, O>
1021       remove_copy_if(R&& r, O result, Pred pred, Proj proj = {});                                  // since C++20
1022
1023   template<class I, class O>
1024       using replace_copy_result = in_out_result<I, O>;                                             // since C++20
1025
1026   template<input_iterator I, sentinel_for<I> S, class T1, class T2,
1027            output_iterator<const T2&> O, class Proj = identity>
1028     requires indirectly_copyable<I, O> &&
1029              indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*>
1030     constexpr replace_copy_result<I, O>
1031       replace_copy(I first, S last, O result, const T1& old_value, const T2& new_value,
1032                    Proj proj = {});                                                                // since C++20
1033
1034   template<input_range R, class T1, class T2, output_iterator<const T2&> O,
1035            class Proj = identity>
1036     requires indirectly_copyable<iterator_t<R>, O> &&
1037              indirect_binary_predicate<ranges::equal_to,
1038                                        projected<iterator_t<R>, Proj>, const T1*>
1039     constexpr replace_copy_result<borrowed_iterator_t<R>, O>
1040       replace_copy(R&& r, O result, const T1& old_value, const T2& new_value,
1041                    Proj proj = {});                                                                // since C++20
1042
1043   template<class I, class O>
1044       using replace_copy_if_result = in_out_result<I, O>;                                          // since C++20
1045
1046   template<input_iterator I, sentinel_for<I> S, class T, output_iterator<const T&> O,
1047            class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
1048     requires indirectly_copyable<I, O>
1049     constexpr replace_copy_if_result<I, O>
1050       replace_copy_if(I first, S last, O result, Pred pred, const T& new_value,
1051                       Proj proj = {});                                                             // since C++20
1052
1053   template<input_range R, class T, output_iterator<const T&> O, class Proj = identity,
1054            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
1055     requires indirectly_copyable<iterator_t<R>, O>
1056     constexpr replace_copy_if_result<borrowed_iterator_t<R>, O>
1057       replace_copy_if(R&& r, O result, Pred pred, const T& new_value,
1058                       Proj proj = {});                                                             // since C++20
1059
1060   template<class I>
1061     using prev_permutation_result = in_found_result<I>;                                            // since C++20
1062
1063   template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
1064            class Proj = identity>
1065     requires sortable<I, Comp, Proj>
1066     constexpr ranges::prev_permutation_result<I>
1067       ranges::prev_permutation(I first, S last, Comp comp = {}, Proj proj = {});                   // since C++20
1068
1069   template<bidirectional_range R, class Comp = ranges::less,
1070            class Proj = identity>
1071     requires sortable<iterator_t<R>, Comp, Proj>
1072     constexpr ranges::prev_permutation_result<borrowed_iterator_t<R>>
1073       ranges::prev_permutation(R&& r, Comp comp = {}, Proj proj = {});                             // since C++20
1074
1075   template<class I>
1076     using next_permutation_result = in_found_result<I>;                                            // since C++20
1077
1078   template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
1079            class Proj = identity>
1080     requires sortable<I, Comp, Proj>
1081     constexpr ranges::next_permutation_result<I>
1082       ranges::next_permutation(I first, S last, Comp comp = {}, Proj proj = {});                   // since C++20
1083
1084   template<bidirectional_range R, class Comp = ranges::less,
1085            class Proj = identity>
1086     requires sortable<iterator_t<R>, Comp, Proj>
1087     constexpr ranges::next_permutation_result<borrowed_iterator_t<R>>
1088       ranges::next_permutation(R&& r, Comp comp = {}, Proj proj = {});                             // since C++20
1089
1090 }
1091
1092 template <class InputIterator, class Predicate>
1093     constexpr bool     // constexpr in C++20
1094     all_of(InputIterator first, InputIterator last, Predicate pred);
1095
1096 template <class InputIterator, class Predicate>
1097     constexpr bool     // constexpr in C++20
1098     any_of(InputIterator first, InputIterator last, Predicate pred);
1099
1100 template <class InputIterator, class Predicate>
1101     constexpr bool     // constexpr in C++20
1102     none_of(InputIterator first, InputIterator last, Predicate pred);
1103
1104 template <class InputIterator, class Function>
1105     constexpr Function          // constexpr in C++20
1106     for_each(InputIterator first, InputIterator last, Function f);
1107
1108 template<class InputIterator, class Size, class Function>
1109     constexpr InputIterator     // constexpr in C++20
1110     for_each_n(InputIterator first, Size n, Function f); // C++17
1111
1112 template <class InputIterator, class T>
1113     constexpr InputIterator     // constexpr in C++20
1114     find(InputIterator first, InputIterator last, const T& value);
1115
1116 template <class InputIterator, class Predicate>
1117     constexpr InputIterator     // constexpr in C++20
1118     find_if(InputIterator first, InputIterator last, Predicate pred);
1119
1120 template<class InputIterator, class Predicate>
1121     constexpr InputIterator     // constexpr in C++20
1122     find_if_not(InputIterator first, InputIterator last, Predicate pred);
1123
1124 template <class ForwardIterator1, class ForwardIterator2>
1125     constexpr ForwardIterator1  // constexpr in C++20
1126     find_end(ForwardIterator1 first1, ForwardIterator1 last1,
1127              ForwardIterator2 first2, ForwardIterator2 last2);
1128
1129 template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
1130     constexpr ForwardIterator1  // constexpr in C++20
1131     find_end(ForwardIterator1 first1, ForwardIterator1 last1,
1132              ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
1133
1134 template <class ForwardIterator1, class ForwardIterator2>
1135     constexpr ForwardIterator1  // constexpr in C++20
1136     find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
1137                   ForwardIterator2 first2, ForwardIterator2 last2);
1138
1139 template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
1140     constexpr ForwardIterator1  // constexpr in C++20
1141     find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
1142                   ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
1143
1144 template <class ForwardIterator>
1145     constexpr ForwardIterator   // constexpr in C++20
1146     adjacent_find(ForwardIterator first, ForwardIterator last);
1147
1148 template <class ForwardIterator, class BinaryPredicate>
1149     constexpr ForwardIterator   // constexpr in C++20
1150     adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate pred);
1151
1152 template <class InputIterator, class T>
1153     constexpr typename iterator_traits<InputIterator>::difference_type  // constexpr in C++20
1154     count(InputIterator first, InputIterator last, const T& value);
1155
1156 template <class InputIterator, class Predicate>
1157     constexpr typename iterator_traits<InputIterator>::difference_type // constexpr in C++20
1158     count_if(InputIterator first, InputIterator last, Predicate pred);
1159
1160 template <class InputIterator1, class InputIterator2>
1161     constexpr pair<InputIterator1, InputIterator2>   // constexpr in C++20
1162     mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
1163
1164 template <class InputIterator1, class InputIterator2>
1165     constexpr pair<InputIterator1, InputIterator2>   // constexpr in C++20
1166     mismatch(InputIterator1 first1, InputIterator1 last1,
1167              InputIterator2 first2, InputIterator2 last2); // **C++14**
1168
1169 template <class InputIterator1, class InputIterator2, class BinaryPredicate>
1170     constexpr pair<InputIterator1, InputIterator2>   // constexpr in C++20
1171     mismatch(InputIterator1 first1, InputIterator1 last1,
1172              InputIterator2 first2, BinaryPredicate pred);
1173
1174 template <class InputIterator1, class InputIterator2, class BinaryPredicate>
1175     constexpr pair<InputIterator1, InputIterator2>   // constexpr in C++20
1176     mismatch(InputIterator1 first1, InputIterator1 last1,
1177              InputIterator2 first2, InputIterator2 last2,
1178              BinaryPredicate pred); // **C++14**
1179
1180 template <class InputIterator1, class InputIterator2>
1181     constexpr bool      // constexpr in C++20
1182     equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
1183
1184 template <class InputIterator1, class InputIterator2>
1185     constexpr bool      // constexpr in C++20
1186     equal(InputIterator1 first1, InputIterator1 last1,
1187           InputIterator2 first2, InputIterator2 last2); // **C++14**
1188
1189 template <class InputIterator1, class InputIterator2, class BinaryPredicate>
1190     constexpr bool      // constexpr in C++20
1191     equal(InputIterator1 first1, InputIterator1 last1,
1192           InputIterator2 first2, BinaryPredicate pred);
1193
1194 template <class InputIterator1, class InputIterator2, class BinaryPredicate>
1195     constexpr bool      // constexpr in C++20
1196     equal(InputIterator1 first1, InputIterator1 last1,
1197           InputIterator2 first2, InputIterator2 last2,
1198           BinaryPredicate pred); // **C++14**
1199
1200 template<class ForwardIterator1, class ForwardIterator2>
1201     constexpr bool      // constexpr in C++20
1202     is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
1203                    ForwardIterator2 first2);
1204
1205 template<class ForwardIterator1, class ForwardIterator2>
1206     constexpr bool      // constexpr in C++20
1207     is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
1208                    ForwardIterator2 first2, ForwardIterator2 last2); // **C++14**
1209
1210 template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
1211     constexpr bool      // constexpr in C++20
1212     is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
1213                    ForwardIterator2 first2, BinaryPredicate pred);
1214
1215 template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
1216     constexpr bool      // constexpr in C++20
1217     is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
1218                    ForwardIterator2 first2, ForwardIterator2 last2,
1219                    BinaryPredicate pred);  // **C++14**
1220
1221 template <class ForwardIterator1, class ForwardIterator2>
1222     constexpr ForwardIterator1      // constexpr in C++20
1223     search(ForwardIterator1 first1, ForwardIterator1 last1,
1224            ForwardIterator2 first2, ForwardIterator2 last2);
1225
1226 template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
1227     constexpr ForwardIterator1      // constexpr in C++20
1228     search(ForwardIterator1 first1, ForwardIterator1 last1,
1229            ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
1230
1231 template <class ForwardIterator, class Size, class T>
1232     constexpr ForwardIterator       // constexpr in C++20
1233     search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value);
1234
1235 template <class ForwardIterator, class Size, class T, class BinaryPredicate>
1236     constexpr ForwardIterator       // constexpr in C++20
1237     search_n(ForwardIterator first, ForwardIterator last,
1238              Size count, const T& value, BinaryPredicate pred);
1239
1240 template <class InputIterator, class OutputIterator>
1241     constexpr OutputIterator      // constexpr in C++20
1242     copy(InputIterator first, InputIterator last, OutputIterator result);
1243
1244 template<class InputIterator, class OutputIterator, class Predicate>
1245     constexpr OutputIterator      // constexpr in C++20
1246     copy_if(InputIterator first, InputIterator last,
1247             OutputIterator result, Predicate pred);
1248
1249 template<class InputIterator, class Size, class OutputIterator>
1250     constexpr OutputIterator      // constexpr in C++20
1251     copy_n(InputIterator first, Size n, OutputIterator result);
1252
1253 template <class BidirectionalIterator1, class BidirectionalIterator2>
1254     constexpr BidirectionalIterator2      // constexpr in C++20
1255     copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
1256                   BidirectionalIterator2 result);
1257
1258 // [alg.move], move
1259 template<class InputIterator, class OutputIterator>
1260     constexpr OutputIterator move(InputIterator first, InputIterator last,
1261                                 OutputIterator result);
1262
1263 template<class BidirectionalIterator1, class BidirectionalIterator2>
1264     constexpr BidirectionalIterator2
1265     move_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
1266                   BidirectionalIterator2 result);
1267
1268 template <class ForwardIterator1, class ForwardIterator2>
1269     constexpr ForwardIterator2    // constexpr in C++20
1270     swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2);
1271
1272 namespace ranges {
1273     template<class I1, class I2>
1274     using swap_ranges_result = in_in_result<I1, I2>;
1275
1276 template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2>
1277         requires indirectly_swappable<I1, I2>
1278     constexpr ranges::swap_ranges_result<I1, I2>
1279         swap_ranges(I1 first1, S1 last1, I2 first2, S2 last2);
1280
1281 template<input_range R1, input_range R2>
1282         requires indirectly_swappable<iterator_t<R1>, iterator_t<R2>>
1283     constexpr ranges::swap_ranges_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
1284         swap_ranges(R1&& r1, R2&& r2);
1285 }
1286
1287 template <class ForwardIterator1, class ForwardIterator2>
1288     constexpr void                // constexpr in C++20
1289     iter_swap(ForwardIterator1 a, ForwardIterator2 b);
1290
1291 template <class InputIterator, class OutputIterator, class UnaryOperation>
1292     constexpr OutputIterator      // constexpr in C++20
1293     transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op);
1294
1295 template <class InputIterator1, class InputIterator2, class OutputIterator, class BinaryOperation>
1296     constexpr OutputIterator      // constexpr in C++20
1297     transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2,
1298               OutputIterator result, BinaryOperation binary_op);
1299
1300 template <class ForwardIterator, class T>
1301     constexpr void      // constexpr in C++20
1302     replace(ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value);
1303
1304 template <class ForwardIterator, class Predicate, class T>
1305     constexpr void      // constexpr in C++20
1306     replace_if(ForwardIterator first, ForwardIterator last, Predicate pred, const T& new_value);
1307
1308 template <class InputIterator, class OutputIterator, class T>
1309     constexpr OutputIterator      // constexpr in C++20
1310     replace_copy(InputIterator first, InputIterator last, OutputIterator result,
1311                  const T& old_value, const T& new_value);
1312
1313 template <class InputIterator, class OutputIterator, class Predicate, class T>
1314     constexpr OutputIterator      // constexpr in C++20
1315     replace_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred, const T& new_value);
1316
1317 template <class ForwardIterator, class T>
1318     constexpr void      // constexpr in C++20
1319     fill(ForwardIterator first, ForwardIterator last, const T& value);
1320
1321 template <class OutputIterator, class Size, class T>
1322     constexpr OutputIterator      // constexpr in C++20
1323     fill_n(OutputIterator first, Size n, const T& value);
1324
1325 template <class ForwardIterator, class Generator>
1326     constexpr void      // constexpr in C++20
1327     generate(ForwardIterator first, ForwardIterator last, Generator gen);
1328
1329 template <class OutputIterator, class Size, class Generator>
1330     constexpr OutputIterator      // constexpr in C++20
1331     generate_n(OutputIterator first, Size n, Generator gen);
1332
1333 template <class ForwardIterator, class T>
1334     constexpr ForwardIterator     // constexpr in C++20
1335     remove(ForwardIterator first, ForwardIterator last, const T& value);
1336
1337 template <class ForwardIterator, class Predicate>
1338     constexpr ForwardIterator     // constexpr in C++20
1339     remove_if(ForwardIterator first, ForwardIterator last, Predicate pred);
1340
1341 template <class InputIterator, class OutputIterator, class T>
1342     constexpr OutputIterator     // constexpr in C++20
1343     remove_copy(InputIterator first, InputIterator last, OutputIterator result, const T& value);
1344
1345 template <class InputIterator, class OutputIterator, class Predicate>
1346     constexpr OutputIterator     // constexpr in C++20
1347     remove_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred);
1348
1349 template <class ForwardIterator>
1350     constexpr ForwardIterator    // constexpr in C++20
1351     unique(ForwardIterator first, ForwardIterator last);
1352
1353 template <class ForwardIterator, class BinaryPredicate>
1354     constexpr ForwardIterator    // constexpr in C++20
1355     unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred);
1356
1357 template <class InputIterator, class OutputIterator>
1358     constexpr OutputIterator     // constexpr in C++20
1359     unique_copy(InputIterator first, InputIterator last, OutputIterator result);
1360
1361 template <class InputIterator, class OutputIterator, class BinaryPredicate>
1362     constexpr OutputIterator     // constexpr in C++20
1363     unique_copy(InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate pred);
1364
1365 template <class BidirectionalIterator>
1366     constexpr void               // constexpr in C++20
1367     reverse(BidirectionalIterator first, BidirectionalIterator last);
1368
1369 template <class BidirectionalIterator, class OutputIterator>
1370     constexpr OutputIterator       // constexpr in C++20
1371     reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator result);
1372
1373 template <class ForwardIterator>
1374     constexpr ForwardIterator      // constexpr in C++20
1375     rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last);
1376
1377 template <class ForwardIterator, class OutputIterator>
1378     constexpr OutputIterator       // constexpr in C++20
1379     rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator result);
1380
1381 template <class RandomAccessIterator>
1382     void
1383     random_shuffle(RandomAccessIterator first, RandomAccessIterator last); // deprecated in C++14, removed in C++17
1384
1385 template <class RandomAccessIterator, class RandomNumberGenerator>
1386     void
1387     random_shuffle(RandomAccessIterator first, RandomAccessIterator last,
1388                    RandomNumberGenerator& rand);  // deprecated in C++14, removed in C++17
1389
1390 template<class PopulationIterator, class SampleIterator,
1391          class Distance, class UniformRandomBitGenerator>
1392     SampleIterator sample(PopulationIterator first, PopulationIterator last,
1393                           SampleIterator out, Distance n,
1394                           UniformRandomBitGenerator&& g); // C++17
1395
1396 template<class RandomAccessIterator, class UniformRandomNumberGenerator>
1397     void shuffle(RandomAccessIterator first, RandomAccessIterator last,
1398                  UniformRandomNumberGenerator&& g);
1399
1400 template<class ForwardIterator>
1401   constexpr ForwardIterator
1402     shift_left(ForwardIterator first, ForwardIterator last,
1403                typename iterator_traits<ForwardIterator>::difference_type n); // C++20
1404
1405 template<class ForwardIterator>
1406   constexpr ForwardIterator
1407     shift_right(ForwardIterator first, ForwardIterator last,
1408                 typename iterator_traits<ForwardIterator>::difference_type n); // C++20
1409
1410 template <class InputIterator, class Predicate>
1411     constexpr bool  // constexpr in C++20
1412     is_partitioned(InputIterator first, InputIterator last, Predicate pred);
1413
1414 template <class ForwardIterator, class Predicate>
1415     constexpr ForwardIterator  // constexpr in C++20
1416     partition(ForwardIterator first, ForwardIterator last, Predicate pred);
1417
1418 template <class InputIterator, class OutputIterator1,
1419           class OutputIterator2, class Predicate>
1420     constexpr pair<OutputIterator1, OutputIterator2>   // constexpr in C++20
1421     partition_copy(InputIterator first, InputIterator last,
1422                    OutputIterator1 out_true, OutputIterator2 out_false,
1423                    Predicate pred);
1424
1425 template <class ForwardIterator, class Predicate>
1426     ForwardIterator
1427     stable_partition(ForwardIterator first, ForwardIterator last, Predicate pred);
1428
1429 template<class ForwardIterator, class Predicate>
1430     constexpr ForwardIterator  // constexpr in C++20
1431     partition_point(ForwardIterator first, ForwardIterator last, Predicate pred);
1432
1433 template <class ForwardIterator>
1434     constexpr bool  // constexpr in C++20
1435     is_sorted(ForwardIterator first, ForwardIterator last);
1436
1437 template <class ForwardIterator, class Compare>
1438     constexpr bool  // constexpr in C++20
1439     is_sorted(ForwardIterator first, ForwardIterator last, Compare comp);
1440
1441 template<class ForwardIterator>
1442     constexpr ForwardIterator    // constexpr in C++20
1443     is_sorted_until(ForwardIterator first, ForwardIterator last);
1444
1445 template <class ForwardIterator, class Compare>
1446     constexpr ForwardIterator    // constexpr in C++20
1447     is_sorted_until(ForwardIterator first, ForwardIterator last, Compare comp);
1448
1449 template <class RandomAccessIterator>
1450     constexpr void               // constexpr in C++20
1451     sort(RandomAccessIterator first, RandomAccessIterator last);
1452
1453 template <class RandomAccessIterator, class Compare>
1454     constexpr void               // constexpr in C++20
1455     sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
1456
1457 template <class RandomAccessIterator>
1458     void
1459     stable_sort(RandomAccessIterator first, RandomAccessIterator last);
1460
1461 template <class RandomAccessIterator, class Compare>
1462     void
1463     stable_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
1464
1465 template <class RandomAccessIterator>
1466     constexpr void                    // constexpr in C++20
1467     partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last);
1468
1469 template <class RandomAccessIterator, class Compare>
1470     constexpr void                    // constexpr in C++20
1471     partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last, Compare comp);
1472
1473 template <class InputIterator, class RandomAccessIterator>
1474     constexpr RandomAccessIterator    // constexpr in C++20
1475     partial_sort_copy(InputIterator first, InputIterator last,
1476                       RandomAccessIterator result_first, RandomAccessIterator result_last);
1477
1478 template <class InputIterator, class RandomAccessIterator, class Compare>
1479     constexpr RandomAccessIterator    // constexpr in C++20
1480     partial_sort_copy(InputIterator first, InputIterator last,
1481                       RandomAccessIterator result_first, RandomAccessIterator result_last, Compare comp);
1482
1483 template <class RandomAccessIterator>
1484     constexpr void                    // constexpr in C++20
1485     nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last);
1486
1487 template <class RandomAccessIterator, class Compare>
1488     constexpr void                    // constexpr in C++20
1489     nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last, Compare comp);
1490
1491 template <class ForwardIterator, class T>
1492     constexpr ForwardIterator                         // constexpr in C++20
1493     lower_bound(ForwardIterator first, ForwardIterator last, const T& value);
1494
1495 template <class ForwardIterator, class T, class Compare>
1496     constexpr ForwardIterator                         // constexpr in C++20
1497     lower_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
1498
1499 template <class ForwardIterator, class T>
1500     constexpr ForwardIterator                         // constexpr in C++20
1501     upper_bound(ForwardIterator first, ForwardIterator last, const T& value);
1502
1503 template <class ForwardIterator, class T, class Compare>
1504     constexpr ForwardIterator                         // constexpr in C++20
1505     upper_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
1506
1507 template <class ForwardIterator, class T>
1508     constexpr pair<ForwardIterator, ForwardIterator>  // constexpr in C++20
1509     equal_range(ForwardIterator first, ForwardIterator last, const T& value);
1510
1511 template <class ForwardIterator, class T, class Compare>
1512     constexpr pair<ForwardIterator, ForwardIterator>  // constexpr in C++20
1513     equal_range(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
1514
1515 template <class ForwardIterator, class T>
1516     constexpr bool                                    // constexpr in C++20
1517     binary_search(ForwardIterator first, ForwardIterator last, const T& value);
1518
1519 template <class ForwardIterator, class T, class Compare>
1520     constexpr bool                                    // constexpr in C++20
1521     binary_search(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
1522
1523 template <class InputIterator1, class InputIterator2, class OutputIterator>
1524     constexpr OutputIterator                          // constexpr in C++20
1525     merge(InputIterator1 first1, InputIterator1 last1,
1526           InputIterator2 first2, InputIterator2 last2, OutputIterator result);
1527
1528 template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
1529     constexpr OutputIterator                          // constexpr in C++20
1530     merge(InputIterator1 first1, InputIterator1 last1,
1531           InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
1532
1533 template <class BidirectionalIterator>
1534     void
1535     inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last);
1536
1537 template <class BidirectionalIterator, class Compare>
1538     void
1539     inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last, Compare comp);
1540
1541 template <class InputIterator1, class InputIterator2>
1542     constexpr bool                                    // constexpr in C++20
1543     includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);
1544
1545 template <class InputIterator1, class InputIterator2, class Compare>
1546     constexpr bool                                    // constexpr in C++20
1547     includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp);
1548
1549 template <class InputIterator1, class InputIterator2, class OutputIterator>
1550     constexpr OutputIterator                          // constexpr in C++20
1551     set_union(InputIterator1 first1, InputIterator1 last1,
1552               InputIterator2 first2, InputIterator2 last2, OutputIterator result);
1553
1554 template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
1555     constexpr OutputIterator                          // constexpr in C++20
1556     set_union(InputIterator1 first1, InputIterator1 last1,
1557               InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
1558
1559 template <class InputIterator1, class InputIterator2, class OutputIterator>
1560     constexpr OutputIterator                         // constexpr in C++20
1561     set_intersection(InputIterator1 first1, InputIterator1 last1,
1562                      InputIterator2 first2, InputIterator2 last2, OutputIterator result);
1563
1564 template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
1565     constexpr OutputIterator                         // constexpr in C++20
1566     set_intersection(InputIterator1 first1, InputIterator1 last1,
1567                      InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
1568
1569 template <class InputIterator1, class InputIterator2, class OutputIterator>
1570     constexpr OutputIterator                         // constexpr in C++20
1571     set_difference(InputIterator1 first1, InputIterator1 last1,
1572                    InputIterator2 first2, InputIterator2 last2, OutputIterator result);
1573
1574 template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
1575     constexpr OutputIterator                         // constexpr in C++20
1576     set_difference(InputIterator1 first1, InputIterator1 last1,
1577                    InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
1578
1579 template <class InputIterator1, class InputIterator2, class OutputIterator>
1580     constexpr OutputIterator                         // constexpr in C++20
1581     set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
1582                              InputIterator2 first2, InputIterator2 last2, OutputIterator result);
1583
1584 template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
1585     constexpr OutputIterator                         // constexpr in C++20
1586     set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
1587                              InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
1588
1589 template <class RandomAccessIterator>
1590     constexpr void                                   // constexpr in C++20
1591     push_heap(RandomAccessIterator first, RandomAccessIterator last);
1592
1593 template <class RandomAccessIterator, class Compare>
1594     constexpr void                                   // constexpr in C++20
1595     push_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
1596
1597 template <class RandomAccessIterator>
1598     constexpr void                                   // constexpr in C++20
1599     pop_heap(RandomAccessIterator first, RandomAccessIterator last);
1600
1601 template <class RandomAccessIterator, class Compare>
1602     constexpr void                                   // constexpr in C++20
1603     pop_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
1604
1605 template <class RandomAccessIterator>
1606     constexpr void                                   // constexpr in C++20
1607     make_heap(RandomAccessIterator first, RandomAccessIterator last);
1608
1609 template <class RandomAccessIterator, class Compare>
1610     constexpr void                                   // constexpr in C++20
1611     make_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
1612
1613 template <class RandomAccessIterator>
1614     constexpr void                                   // constexpr in C++20
1615     sort_heap(RandomAccessIterator first, RandomAccessIterator last);
1616
1617 template <class RandomAccessIterator, class Compare>
1618     constexpr void                                   // constexpr in C++20
1619     sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
1620
1621 template <class RandomAccessIterator>
1622     constexpr bool   // constexpr in C++20
1623     is_heap(RandomAccessIterator first, RandomAccessiterator last);
1624
1625 template <class RandomAccessIterator, class Compare>
1626     constexpr bool   // constexpr in C++20
1627     is_heap(RandomAccessIterator first, RandomAccessiterator last, Compare comp);
1628
1629 template <class RandomAccessIterator>
1630     constexpr RandomAccessIterator   // constexpr in C++20
1631     is_heap_until(RandomAccessIterator first, RandomAccessiterator last);
1632
1633 template <class RandomAccessIterator, class Compare>
1634     constexpr RandomAccessIterator   // constexpr in C++20
1635     is_heap_until(RandomAccessIterator first, RandomAccessiterator last, Compare comp);
1636
1637 template <class ForwardIterator>
1638     constexpr ForwardIterator        // constexpr in C++14
1639     min_element(ForwardIterator first, ForwardIterator last);
1640
1641 template <class ForwardIterator, class Compare>
1642     constexpr ForwardIterator        // constexpr in C++14
1643     min_element(ForwardIterator first, ForwardIterator last, Compare comp);
1644
1645 template <class T>
1646     constexpr const T&               // constexpr in C++14
1647     min(const T& a, const T& b);
1648
1649 template <class T, class Compare>
1650     constexpr const T&               // constexpr in C++14
1651     min(const T& a, const T& b, Compare comp);
1652
1653 template<class T>
1654     constexpr T                      // constexpr in C++14
1655     min(initializer_list<T> t);
1656
1657 template<class T, class Compare>
1658     constexpr T                      // constexpr in C++14
1659     min(initializer_list<T> t, Compare comp);
1660
1661 template<class T>
1662     constexpr const T& clamp(const T& v, const T& lo, const T& hi);               // C++17
1663
1664 template<class T, class Compare>
1665     constexpr const T& clamp(const T& v, const T& lo, const T& hi, Compare comp); // C++17
1666
1667 template <class ForwardIterator>
1668     constexpr ForwardIterator        // constexpr in C++14
1669     max_element(ForwardIterator first, ForwardIterator last);
1670
1671 template <class ForwardIterator, class Compare>
1672     constexpr ForwardIterator        // constexpr in C++14
1673     max_element(ForwardIterator first, ForwardIterator last, Compare comp);
1674
1675 template <class T>
1676     constexpr const T&               // constexpr in C++14
1677     max(const T& a, const T& b);
1678
1679 template <class T, class Compare>
1680     constexpr const T&               // constexpr in C++14
1681     max(const T& a, const T& b, Compare comp);
1682
1683 template<class T>
1684     constexpr T                      // constexpr in C++14
1685     max(initializer_list<T> t);
1686
1687 template<class T, class Compare>
1688     constexpr T                      // constexpr in C++14
1689     max(initializer_list<T> t, Compare comp);
1690
1691 template<class ForwardIterator>
1692     constexpr pair<ForwardIterator, ForwardIterator>  // constexpr in C++14
1693     minmax_element(ForwardIterator first, ForwardIterator last);
1694
1695 template<class ForwardIterator, class Compare>
1696     constexpr pair<ForwardIterator, ForwardIterator>  // constexpr in C++14
1697     minmax_element(ForwardIterator first, ForwardIterator last, Compare comp);
1698
1699 template<class T>
1700     constexpr pair<const T&, const T&>  // constexpr in C++14
1701     minmax(const T& a, const T& b);
1702
1703 template<class T, class Compare>
1704     constexpr pair<const T&, const T&>  // constexpr in C++14
1705     minmax(const T& a, const T& b, Compare comp);
1706
1707 template<class T>
1708     constexpr pair<T, T>                // constexpr in C++14
1709     minmax(initializer_list<T> t);
1710
1711 template<class T, class Compare>
1712     constexpr pair<T, T>                // constexpr in C++14
1713     minmax(initializer_list<T> t, Compare comp);
1714
1715 template <class InputIterator1, class InputIterator2>
1716     constexpr bool     // constexpr in C++20
1717     lexicographical_compare(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);
1718
1719 template <class InputIterator1, class InputIterator2, class Compare>
1720     constexpr bool     // constexpr in C++20
1721     lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
1722                             InputIterator2 first2, InputIterator2 last2, Compare comp);
1723
1724 template<class InputIterator1, class InputIterator2, class Cmp>
1725     constexpr auto
1726     lexicographical_compare_three_way(InputIterator1 first1, InputIterator1 last1,
1727                                       InputIterator2 first2, InputIterator2 last2,
1728                                       Cmp comp)
1729       -> decltype(comp(*b1, *b2));                                                        // since C++20
1730
1731 template<class InputIterator1, class InputIterator2>
1732     constexpr auto
1733     lexicographical_compare_three_way(InputIterator1 first1, InputIterator1 last1,
1734                                       InputIterator2 first2, InputIterator2 last2);      // since C++20
1735
1736 template <class BidirectionalIterator>
1737     constexpr bool     // constexpr in C++20
1738     next_permutation(BidirectionalIterator first, BidirectionalIterator last);
1739
1740 template <class BidirectionalIterator, class Compare>
1741     constexpr bool     // constexpr in C++20
1742     next_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);
1743
1744 template <class BidirectionalIterator>
1745     constexpr bool     // constexpr in C++20
1746     prev_permutation(BidirectionalIterator first, BidirectionalIterator last);
1747
1748 template <class BidirectionalIterator, class Compare>
1749     constexpr bool     // constexpr in C++20
1750     prev_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);
1751 }  // std
1752
1753 */
1754
1755 #include <__assert> // all public C++ headers provide the assertion handler
1756 #include <__config>
1757 #include <version>
1758
1759 #include <__algorithm/adjacent_find.h>
1760 #include <__algorithm/all_of.h>
1761 #include <__algorithm/any_of.h>
1762 #include <__algorithm/binary_search.h>
1763 #include <__algorithm/clamp.h>
1764 #include <__algorithm/comp.h>
1765 #include <__algorithm/comp_ref_type.h>
1766 #include <__algorithm/copy.h>
1767 #include <__algorithm/copy_backward.h>
1768 #include <__algorithm/copy_if.h>
1769 #include <__algorithm/copy_n.h>
1770 #include <__algorithm/count.h>
1771 #include <__algorithm/count_if.h>
1772 #include <__algorithm/equal.h>
1773 #include <__algorithm/equal_range.h>
1774 #include <__algorithm/fill.h>
1775 #include <__algorithm/fill_n.h>
1776 #include <__algorithm/find.h>
1777 #include <__algorithm/find_end.h>
1778 #include <__algorithm/find_first_of.h>
1779 #include <__algorithm/find_if.h>
1780 #include <__algorithm/find_if_not.h>
1781 #include <__algorithm/for_each.h>
1782 #include <__algorithm/for_each_n.h>
1783 #include <__algorithm/generate.h>
1784 #include <__algorithm/generate_n.h>
1785 #include <__algorithm/half_positive.h>
1786 #include <__algorithm/in_found_result.h>
1787 #include <__algorithm/in_fun_result.h>
1788 #include <__algorithm/in_in_out_result.h>
1789 #include <__algorithm/in_in_result.h>
1790 #include <__algorithm/in_out_out_result.h>
1791 #include <__algorithm/in_out_result.h>
1792 #include <__algorithm/includes.h>
1793 #include <__algorithm/inplace_merge.h>
1794 #include <__algorithm/is_heap.h>
1795 #include <__algorithm/is_heap_until.h>
1796 #include <__algorithm/is_partitioned.h>
1797 #include <__algorithm/is_permutation.h>
1798 #include <__algorithm/is_sorted.h>
1799 #include <__algorithm/is_sorted_until.h>
1800 #include <__algorithm/iter_swap.h>
1801 #include <__algorithm/lexicographical_compare.h>
1802 #include <__algorithm/lexicographical_compare_three_way.h>
1803 #include <__algorithm/lower_bound.h>
1804 #include <__algorithm/make_heap.h>
1805 #include <__algorithm/max.h>
1806 #include <__algorithm/max_element.h>
1807 #include <__algorithm/merge.h>
1808 #include <__algorithm/min.h>
1809 #include <__algorithm/min_element.h>
1810 #include <__algorithm/min_max_result.h>
1811 #include <__algorithm/minmax.h>
1812 #include <__algorithm/minmax_element.h>
1813 #include <__algorithm/mismatch.h>
1814 #include <__algorithm/move.h>
1815 #include <__algorithm/move_backward.h>
1816 #include <__algorithm/next_permutation.h>
1817 #include <__algorithm/none_of.h>
1818 #include <__algorithm/nth_element.h>
1819 #include <__algorithm/partial_sort.h>
1820 #include <__algorithm/partial_sort_copy.h>
1821 #include <__algorithm/partition.h>
1822 #include <__algorithm/partition_copy.h>
1823 #include <__algorithm/partition_point.h>
1824 #include <__algorithm/pop_heap.h>
1825 #include <__algorithm/prev_permutation.h>
1826 #include <__algorithm/pstl_any_all_none_of.h>
1827 #include <__algorithm/pstl_copy.h>
1828 #include <__algorithm/pstl_count.h>
1829 #include <__algorithm/pstl_equal.h>
1830 #include <__algorithm/pstl_fill.h>
1831 #include <__algorithm/pstl_find.h>
1832 #include <__algorithm/pstl_for_each.h>
1833 #include <__algorithm/pstl_generate.h>
1834 #include <__algorithm/pstl_is_partitioned.h>
1835 #include <__algorithm/pstl_merge.h>
1836 #include <__algorithm/pstl_move.h>
1837 #include <__algorithm/pstl_replace.h>
1838 #include <__algorithm/pstl_rotate_copy.h>
1839 #include <__algorithm/pstl_sort.h>
1840 #include <__algorithm/pstl_stable_sort.h>
1841 #include <__algorithm/pstl_transform.h>
1842 #include <__algorithm/push_heap.h>
1843 #include <__algorithm/ranges_adjacent_find.h>
1844 #include <__algorithm/ranges_all_of.h>
1845 #include <__algorithm/ranges_any_of.h>
1846 #include <__algorithm/ranges_binary_search.h>
1847 #include <__algorithm/ranges_clamp.h>
1848 #include <__algorithm/ranges_copy.h>
1849 #include <__algorithm/ranges_copy_backward.h>
1850 #include <__algorithm/ranges_copy_if.h>
1851 #include <__algorithm/ranges_copy_n.h>
1852 #include <__algorithm/ranges_count.h>
1853 #include <__algorithm/ranges_count_if.h>
1854 #include <__algorithm/ranges_ends_with.h>
1855 #include <__algorithm/ranges_equal.h>
1856 #include <__algorithm/ranges_equal_range.h>
1857 #include <__algorithm/ranges_fill.h>
1858 #include <__algorithm/ranges_fill_n.h>
1859 #include <__algorithm/ranges_find.h>
1860 #include <__algorithm/ranges_find_end.h>
1861 #include <__algorithm/ranges_find_first_of.h>
1862 #include <__algorithm/ranges_find_if.h>
1863 #include <__algorithm/ranges_find_if_not.h>
1864 #include <__algorithm/ranges_for_each.h>
1865 #include <__algorithm/ranges_for_each_n.h>
1866 #include <__algorithm/ranges_generate.h>
1867 #include <__algorithm/ranges_generate_n.h>
1868 #include <__algorithm/ranges_includes.h>
1869 #include <__algorithm/ranges_inplace_merge.h>
1870 #include <__algorithm/ranges_is_heap.h>
1871 #include <__algorithm/ranges_is_heap_until.h>
1872 #include <__algorithm/ranges_is_partitioned.h>
1873 #include <__algorithm/ranges_is_permutation.h>
1874 #include <__algorithm/ranges_is_sorted.h>
1875 #include <__algorithm/ranges_is_sorted_until.h>
1876 #include <__algorithm/ranges_lexicographical_compare.h>
1877 #include <__algorithm/ranges_lower_bound.h>
1878 #include <__algorithm/ranges_make_heap.h>
1879 #include <__algorithm/ranges_max.h>
1880 #include <__algorithm/ranges_max_element.h>
1881 #include <__algorithm/ranges_merge.h>
1882 #include <__algorithm/ranges_min.h>
1883 #include <__algorithm/ranges_min_element.h>
1884 #include <__algorithm/ranges_minmax.h>
1885 #include <__algorithm/ranges_minmax_element.h>
1886 #include <__algorithm/ranges_mismatch.h>
1887 #include <__algorithm/ranges_move.h>
1888 #include <__algorithm/ranges_move_backward.h>
1889 #include <__algorithm/ranges_next_permutation.h>
1890 #include <__algorithm/ranges_none_of.h>
1891 #include <__algorithm/ranges_nth_element.h>
1892 #include <__algorithm/ranges_partial_sort.h>
1893 #include <__algorithm/ranges_partial_sort_copy.h>
1894 #include <__algorithm/ranges_partition.h>
1895 #include <__algorithm/ranges_partition_copy.h>
1896 #include <__algorithm/ranges_partition_point.h>
1897 #include <__algorithm/ranges_pop_heap.h>
1898 #include <__algorithm/ranges_prev_permutation.h>
1899 #include <__algorithm/ranges_push_heap.h>
1900 #include <__algorithm/ranges_remove.h>
1901 #include <__algorithm/ranges_remove_copy.h>
1902 #include <__algorithm/ranges_remove_copy_if.h>
1903 #include <__algorithm/ranges_remove_if.h>
1904 #include <__algorithm/ranges_replace.h>
1905 #include <__algorithm/ranges_replace_copy.h>
1906 #include <__algorithm/ranges_replace_copy_if.h>
1907 #include <__algorithm/ranges_replace_if.h>
1908 #include <__algorithm/ranges_reverse.h>
1909 #include <__algorithm/ranges_reverse_copy.h>
1910 #include <__algorithm/ranges_rotate.h>
1911 #include <__algorithm/ranges_rotate_copy.h>
1912 #include <__algorithm/ranges_sample.h>
1913 #include <__algorithm/ranges_search.h>
1914 #include <__algorithm/ranges_search_n.h>
1915 #include <__algorithm/ranges_set_difference.h>
1916 #include <__algorithm/ranges_set_intersection.h>
1917 #include <__algorithm/ranges_set_symmetric_difference.h>
1918 #include <__algorithm/ranges_set_union.h>
1919 #include <__algorithm/ranges_shuffle.h>
1920 #include <__algorithm/ranges_sort.h>
1921 #include <__algorithm/ranges_sort_heap.h>
1922 #include <__algorithm/ranges_stable_partition.h>
1923 #include <__algorithm/ranges_stable_sort.h>
1924 #include <__algorithm/ranges_starts_with.h>
1925 #include <__algorithm/ranges_swap_ranges.h>
1926 #include <__algorithm/ranges_transform.h>
1927 #include <__algorithm/ranges_unique.h>
1928 #include <__algorithm/ranges_unique_copy.h>
1929 #include <__algorithm/ranges_upper_bound.h>
1930 #include <__algorithm/remove.h>
1931 #include <__algorithm/remove_copy.h>
1932 #include <__algorithm/remove_copy_if.h>
1933 #include <__algorithm/remove_if.h>
1934 #include <__algorithm/replace.h>
1935 #include <__algorithm/replace_copy.h>
1936 #include <__algorithm/replace_copy_if.h>
1937 #include <__algorithm/replace_if.h>
1938 #include <__algorithm/reverse.h>
1939 #include <__algorithm/reverse_copy.h>
1940 #include <__algorithm/rotate.h>
1941 #include <__algorithm/rotate_copy.h>
1942 #include <__algorithm/sample.h>
1943 #include <__algorithm/search.h>
1944 #include <__algorithm/search_n.h>
1945 #include <__algorithm/set_difference.h>
1946 #include <__algorithm/set_intersection.h>
1947 #include <__algorithm/set_symmetric_difference.h>
1948 #include <__algorithm/set_union.h>
1949 #include <__algorithm/shift_left.h>
1950 #include <__algorithm/shift_right.h>
1951 #include <__algorithm/shuffle.h>
1952 #include <__algorithm/sift_down.h>
1953 #include <__algorithm/sort.h>
1954 #include <__algorithm/sort_heap.h>
1955 #include <__algorithm/stable_partition.h>
1956 #include <__algorithm/stable_sort.h>
1957 #include <__algorithm/swap_ranges.h>
1958 #include <__algorithm/transform.h>
1959 #include <__algorithm/unique.h>
1960 #include <__algorithm/unique_copy.h>
1961 #include <__algorithm/unwrap_iter.h>
1962 #include <__algorithm/upper_bound.h>
1963
1964 // standard-mandated includes
1965
1966 // [algorithm.syn]
1967 #include <initializer_list>
1968
1969 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
1970 #  pragma GCC system_header
1971 #endif
1972
1973 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
1974 #  include <atomic>
1975 #  include <bit>
1976 #  include <concepts>
1977 #  include <cstdlib>
1978 #  include <cstring>
1979 #  include <iterator>
1980 #  include <memory>
1981 #  include <stdexcept>
1982 #  include <type_traits>
1983 #  include <utility>
1984 #endif
1985
1986 #endif // _LIBCPP_ALGORITHM