xref: /freebsd/contrib/llvm-project/libcxx/include/algorithm (revision 5f757f3ff9144b609b3c433dfd370cc6bdc191ad)
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
18namespace std
19{
20
21namespace 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
1092template <class InputIterator, class Predicate>
1093    constexpr bool     // constexpr in C++20
1094    all_of(InputIterator first, InputIterator last, Predicate pred);
1095
1096template <class InputIterator, class Predicate>
1097    constexpr bool     // constexpr in C++20
1098    any_of(InputIterator first, InputIterator last, Predicate pred);
1099
1100template <class InputIterator, class Predicate>
1101    constexpr bool     // constexpr in C++20
1102    none_of(InputIterator first, InputIterator last, Predicate pred);
1103
1104template <class InputIterator, class Function>
1105    constexpr Function          // constexpr in C++20
1106    for_each(InputIterator first, InputIterator last, Function f);
1107
1108template<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
1112template <class InputIterator, class T>
1113    constexpr InputIterator     // constexpr in C++20
1114    find(InputIterator first, InputIterator last, const T& value);
1115
1116template <class InputIterator, class Predicate>
1117    constexpr InputIterator     // constexpr in C++20
1118    find_if(InputIterator first, InputIterator last, Predicate pred);
1119
1120template<class InputIterator, class Predicate>
1121    constexpr InputIterator     // constexpr in C++20
1122    find_if_not(InputIterator first, InputIterator last, Predicate pred);
1123
1124template <class ForwardIterator1, class ForwardIterator2>
1125    constexpr ForwardIterator1  // constexpr in C++20
1126    find_end(ForwardIterator1 first1, ForwardIterator1 last1,
1127             ForwardIterator2 first2, ForwardIterator2 last2);
1128
1129template <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
1134template <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
1139template <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
1144template <class ForwardIterator>
1145    constexpr ForwardIterator   // constexpr in C++20
1146    adjacent_find(ForwardIterator first, ForwardIterator last);
1147
1148template <class ForwardIterator, class BinaryPredicate>
1149    constexpr ForwardIterator   // constexpr in C++20
1150    adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate pred);
1151
1152template <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
1156template <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
1160template <class InputIterator1, class InputIterator2>
1161    constexpr pair<InputIterator1, InputIterator2>   // constexpr in C++20
1162    mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
1163
1164template <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
1169template <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
1174template <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
1180template <class InputIterator1, class InputIterator2>
1181    constexpr bool      // constexpr in C++20
1182    equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
1183
1184template <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
1189template <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
1194template <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
1200template<class ForwardIterator1, class ForwardIterator2>
1201    constexpr bool      // constexpr in C++20
1202    is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
1203                   ForwardIterator2 first2);
1204
1205template<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
1210template<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
1215template<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
1221template <class ForwardIterator1, class ForwardIterator2>
1222    constexpr ForwardIterator1      // constexpr in C++20
1223    search(ForwardIterator1 first1, ForwardIterator1 last1,
1224           ForwardIterator2 first2, ForwardIterator2 last2);
1225
1226template <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
1231template <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
1235template <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
1240template <class InputIterator, class OutputIterator>
1241    constexpr OutputIterator      // constexpr in C++20
1242    copy(InputIterator first, InputIterator last, OutputIterator result);
1243
1244template<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
1249template<class InputIterator, class Size, class OutputIterator>
1250    constexpr OutputIterator      // constexpr in C++20
1251    copy_n(InputIterator first, Size n, OutputIterator result);
1252
1253template <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
1259template<class InputIterator, class OutputIterator>
1260    constexpr OutputIterator move(InputIterator first, InputIterator last,
1261                                OutputIterator result);
1262
1263template<class BidirectionalIterator1, class BidirectionalIterator2>
1264    constexpr BidirectionalIterator2
1265    move_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
1266                  BidirectionalIterator2 result);
1267
1268template <class ForwardIterator1, class ForwardIterator2>
1269    constexpr ForwardIterator2    // constexpr in C++20
1270    swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2);
1271
1272namespace ranges {
1273    template<class I1, class I2>
1274    using swap_ranges_result = in_in_result<I1, I2>;
1275
1276template<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
1281template<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
1287template <class ForwardIterator1, class ForwardIterator2>
1288    constexpr void                // constexpr in C++20
1289    iter_swap(ForwardIterator1 a, ForwardIterator2 b);
1290
1291template <class InputIterator, class OutputIterator, class UnaryOperation>
1292    constexpr OutputIterator      // constexpr in C++20
1293    transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op);
1294
1295template <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
1300template <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
1304template <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
1308template <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
1313template <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
1317template <class ForwardIterator, class T>
1318    constexpr void      // constexpr in C++20
1319    fill(ForwardIterator first, ForwardIterator last, const T& value);
1320
1321template <class OutputIterator, class Size, class T>
1322    constexpr OutputIterator      // constexpr in C++20
1323    fill_n(OutputIterator first, Size n, const T& value);
1324
1325template <class ForwardIterator, class Generator>
1326    constexpr void      // constexpr in C++20
1327    generate(ForwardIterator first, ForwardIterator last, Generator gen);
1328
1329template <class OutputIterator, class Size, class Generator>
1330    constexpr OutputIterator      // constexpr in C++20
1331    generate_n(OutputIterator first, Size n, Generator gen);
1332
1333template <class ForwardIterator, class T>
1334    constexpr ForwardIterator     // constexpr in C++20
1335    remove(ForwardIterator first, ForwardIterator last, const T& value);
1336
1337template <class ForwardIterator, class Predicate>
1338    constexpr ForwardIterator     // constexpr in C++20
1339    remove_if(ForwardIterator first, ForwardIterator last, Predicate pred);
1340
1341template <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
1345template <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
1349template <class ForwardIterator>
1350    constexpr ForwardIterator    // constexpr in C++20
1351    unique(ForwardIterator first, ForwardIterator last);
1352
1353template <class ForwardIterator, class BinaryPredicate>
1354    constexpr ForwardIterator    // constexpr in C++20
1355    unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred);
1356
1357template <class InputIterator, class OutputIterator>
1358    constexpr OutputIterator     // constexpr in C++20
1359    unique_copy(InputIterator first, InputIterator last, OutputIterator result);
1360
1361template <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
1365template <class BidirectionalIterator>
1366    constexpr void               // constexpr in C++20
1367    reverse(BidirectionalIterator first, BidirectionalIterator last);
1368
1369template <class BidirectionalIterator, class OutputIterator>
1370    constexpr OutputIterator       // constexpr in C++20
1371    reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator result);
1372
1373template <class ForwardIterator>
1374    constexpr ForwardIterator      // constexpr in C++20
1375    rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last);
1376
1377template <class ForwardIterator, class OutputIterator>
1378    constexpr OutputIterator       // constexpr in C++20
1379    rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator result);
1380
1381template <class RandomAccessIterator>
1382    void
1383    random_shuffle(RandomAccessIterator first, RandomAccessIterator last); // deprecated in C++14, removed in C++17
1384
1385template <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
1390template<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
1396template<class RandomAccessIterator, class UniformRandomNumberGenerator>
1397    void shuffle(RandomAccessIterator first, RandomAccessIterator last,
1398                 UniformRandomNumberGenerator&& g);
1399
1400template<class ForwardIterator>
1401  constexpr ForwardIterator
1402    shift_left(ForwardIterator first, ForwardIterator last,
1403               typename iterator_traits<ForwardIterator>::difference_type n); // C++20
1404
1405template<class ForwardIterator>
1406  constexpr ForwardIterator
1407    shift_right(ForwardIterator first, ForwardIterator last,
1408                typename iterator_traits<ForwardIterator>::difference_type n); // C++20
1409
1410template <class InputIterator, class Predicate>
1411    constexpr bool  // constexpr in C++20
1412    is_partitioned(InputIterator first, InputIterator last, Predicate pred);
1413
1414template <class ForwardIterator, class Predicate>
1415    constexpr ForwardIterator  // constexpr in C++20
1416    partition(ForwardIterator first, ForwardIterator last, Predicate pred);
1417
1418template <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
1425template <class ForwardIterator, class Predicate>
1426    ForwardIterator
1427    stable_partition(ForwardIterator first, ForwardIterator last, Predicate pred);
1428
1429template<class ForwardIterator, class Predicate>
1430    constexpr ForwardIterator  // constexpr in C++20
1431    partition_point(ForwardIterator first, ForwardIterator last, Predicate pred);
1432
1433template <class ForwardIterator>
1434    constexpr bool  // constexpr in C++20
1435    is_sorted(ForwardIterator first, ForwardIterator last);
1436
1437template <class ForwardIterator, class Compare>
1438    constexpr bool  // constexpr in C++20
1439    is_sorted(ForwardIterator first, ForwardIterator last, Compare comp);
1440
1441template<class ForwardIterator>
1442    constexpr ForwardIterator    // constexpr in C++20
1443    is_sorted_until(ForwardIterator first, ForwardIterator last);
1444
1445template <class ForwardIterator, class Compare>
1446    constexpr ForwardIterator    // constexpr in C++20
1447    is_sorted_until(ForwardIterator first, ForwardIterator last, Compare comp);
1448
1449template <class RandomAccessIterator>
1450    constexpr void               // constexpr in C++20
1451    sort(RandomAccessIterator first, RandomAccessIterator last);
1452
1453template <class RandomAccessIterator, class Compare>
1454    constexpr void               // constexpr in C++20
1455    sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
1456
1457template <class RandomAccessIterator>
1458    void
1459    stable_sort(RandomAccessIterator first, RandomAccessIterator last);
1460
1461template <class RandomAccessIterator, class Compare>
1462    void
1463    stable_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
1464
1465template <class RandomAccessIterator>
1466    constexpr void                    // constexpr in C++20
1467    partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last);
1468
1469template <class RandomAccessIterator, class Compare>
1470    constexpr void                    // constexpr in C++20
1471    partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last, Compare comp);
1472
1473template <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
1478template <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
1483template <class RandomAccessIterator>
1484    constexpr void                    // constexpr in C++20
1485    nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last);
1486
1487template <class RandomAccessIterator, class Compare>
1488    constexpr void                    // constexpr in C++20
1489    nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last, Compare comp);
1490
1491template <class ForwardIterator, class T>
1492    constexpr ForwardIterator                         // constexpr in C++20
1493    lower_bound(ForwardIterator first, ForwardIterator last, const T& value);
1494
1495template <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
1499template <class ForwardIterator, class T>
1500    constexpr ForwardIterator                         // constexpr in C++20
1501    upper_bound(ForwardIterator first, ForwardIterator last, const T& value);
1502
1503template <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
1507template <class ForwardIterator, class T>
1508    constexpr pair<ForwardIterator, ForwardIterator>  // constexpr in C++20
1509    equal_range(ForwardIterator first, ForwardIterator last, const T& value);
1510
1511template <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
1515template <class ForwardIterator, class T>
1516    constexpr bool                                    // constexpr in C++20
1517    binary_search(ForwardIterator first, ForwardIterator last, const T& value);
1518
1519template <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
1523template <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
1528template <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
1533template <class BidirectionalIterator>
1534    void
1535    inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last);
1536
1537template <class BidirectionalIterator, class Compare>
1538    void
1539    inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last, Compare comp);
1540
1541template <class InputIterator1, class InputIterator2>
1542    constexpr bool                                    // constexpr in C++20
1543    includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);
1544
1545template <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
1549template <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
1554template <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
1559template <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
1564template <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
1569template <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
1574template <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
1579template <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
1584template <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
1589template <class RandomAccessIterator>
1590    constexpr void                                   // constexpr in C++20
1591    push_heap(RandomAccessIterator first, RandomAccessIterator last);
1592
1593template <class RandomAccessIterator, class Compare>
1594    constexpr void                                   // constexpr in C++20
1595    push_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
1596
1597template <class RandomAccessIterator>
1598    constexpr void                                   // constexpr in C++20
1599    pop_heap(RandomAccessIterator first, RandomAccessIterator last);
1600
1601template <class RandomAccessIterator, class Compare>
1602    constexpr void                                   // constexpr in C++20
1603    pop_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
1604
1605template <class RandomAccessIterator>
1606    constexpr void                                   // constexpr in C++20
1607    make_heap(RandomAccessIterator first, RandomAccessIterator last);
1608
1609template <class RandomAccessIterator, class Compare>
1610    constexpr void                                   // constexpr in C++20
1611    make_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
1612
1613template <class RandomAccessIterator>
1614    constexpr void                                   // constexpr in C++20
1615    sort_heap(RandomAccessIterator first, RandomAccessIterator last);
1616
1617template <class RandomAccessIterator, class Compare>
1618    constexpr void                                   // constexpr in C++20
1619    sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
1620
1621template <class RandomAccessIterator>
1622    constexpr bool   // constexpr in C++20
1623    is_heap(RandomAccessIterator first, RandomAccessiterator last);
1624
1625template <class RandomAccessIterator, class Compare>
1626    constexpr bool   // constexpr in C++20
1627    is_heap(RandomAccessIterator first, RandomAccessiterator last, Compare comp);
1628
1629template <class RandomAccessIterator>
1630    constexpr RandomAccessIterator   // constexpr in C++20
1631    is_heap_until(RandomAccessIterator first, RandomAccessiterator last);
1632
1633template <class RandomAccessIterator, class Compare>
1634    constexpr RandomAccessIterator   // constexpr in C++20
1635    is_heap_until(RandomAccessIterator first, RandomAccessiterator last, Compare comp);
1636
1637template <class ForwardIterator>
1638    constexpr ForwardIterator        // constexpr in C++14
1639    min_element(ForwardIterator first, ForwardIterator last);
1640
1641template <class ForwardIterator, class Compare>
1642    constexpr ForwardIterator        // constexpr in C++14
1643    min_element(ForwardIterator first, ForwardIterator last, Compare comp);
1644
1645template <class T>
1646    constexpr const T&               // constexpr in C++14
1647    min(const T& a, const T& b);
1648
1649template <class T, class Compare>
1650    constexpr const T&               // constexpr in C++14
1651    min(const T& a, const T& b, Compare comp);
1652
1653template<class T>
1654    constexpr T                      // constexpr in C++14
1655    min(initializer_list<T> t);
1656
1657template<class T, class Compare>
1658    constexpr T                      // constexpr in C++14
1659    min(initializer_list<T> t, Compare comp);
1660
1661template<class T>
1662    constexpr const T& clamp(const T& v, const T& lo, const T& hi);               // C++17
1663
1664template<class T, class Compare>
1665    constexpr const T& clamp(const T& v, const T& lo, const T& hi, Compare comp); // C++17
1666
1667template <class ForwardIterator>
1668    constexpr ForwardIterator        // constexpr in C++14
1669    max_element(ForwardIterator first, ForwardIterator last);
1670
1671template <class ForwardIterator, class Compare>
1672    constexpr ForwardIterator        // constexpr in C++14
1673    max_element(ForwardIterator first, ForwardIterator last, Compare comp);
1674
1675template <class T>
1676    constexpr const T&               // constexpr in C++14
1677    max(const T& a, const T& b);
1678
1679template <class T, class Compare>
1680    constexpr const T&               // constexpr in C++14
1681    max(const T& a, const T& b, Compare comp);
1682
1683template<class T>
1684    constexpr T                      // constexpr in C++14
1685    max(initializer_list<T> t);
1686
1687template<class T, class Compare>
1688    constexpr T                      // constexpr in C++14
1689    max(initializer_list<T> t, Compare comp);
1690
1691template<class ForwardIterator>
1692    constexpr pair<ForwardIterator, ForwardIterator>  // constexpr in C++14
1693    minmax_element(ForwardIterator first, ForwardIterator last);
1694
1695template<class ForwardIterator, class Compare>
1696    constexpr pair<ForwardIterator, ForwardIterator>  // constexpr in C++14
1697    minmax_element(ForwardIterator first, ForwardIterator last, Compare comp);
1698
1699template<class T>
1700    constexpr pair<const T&, const T&>  // constexpr in C++14
1701    minmax(const T& a, const T& b);
1702
1703template<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
1707template<class T>
1708    constexpr pair<T, T>                // constexpr in C++14
1709    minmax(initializer_list<T> t);
1710
1711template<class T, class Compare>
1712    constexpr pair<T, T>                // constexpr in C++14
1713    minmax(initializer_list<T> t, Compare comp);
1714
1715template <class InputIterator1, class InputIterator2>
1716    constexpr bool     // constexpr in C++20
1717    lexicographical_compare(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);
1718
1719template <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
1724template<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
1731template<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
1736template <class BidirectionalIterator>
1737    constexpr bool     // constexpr in C++20
1738    next_permutation(BidirectionalIterator first, BidirectionalIterator last);
1739
1740template <class BidirectionalIterator, class Compare>
1741    constexpr bool     // constexpr in C++20
1742    next_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);
1743
1744template <class BidirectionalIterator>
1745    constexpr bool     // constexpr in C++20
1746    prev_permutation(BidirectionalIterator first, BidirectionalIterator last);
1747
1748template <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
1987