1// -*- C++ -*-
2//===-------------------------- algorithm ---------------------------------===//
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
21template <class InputIterator, class Predicate>
22 constexpr bool // constexpr in C++20
23 all_of(InputIterator first, InputIterator last, Predicate pred);
24
25template <class InputIterator, class Predicate>
26 constexpr bool // constexpr in C++20
27 any_of(InputIterator first, InputIterator last, Predicate pred);
28
29template <class InputIterator, class Predicate>
30 constexpr bool // constexpr in C++20
31 none_of(InputIterator first, InputIterator last, Predicate pred);
32
33template <class InputIterator, class Function>
34 constexpr Function // constexpr in C++20
35 for_each(InputIterator first, InputIterator last, Function f);
36
37template<class InputIterator, class Size, class Function>
38 constexpr InputIterator // constexpr in C++20
39 for_each_n(InputIterator first, Size n, Function f); // C++17
40
41template <class InputIterator, class T>
42 constexpr InputIterator // constexpr in C++20
43 find(InputIterator first, InputIterator last, const T& value);
44
45template <class InputIterator, class Predicate>
46 constexpr InputIterator // constexpr in C++20
47 find_if(InputIterator first, InputIterator last, Predicate pred);
48
49template<class InputIterator, class Predicate>
50 InputIterator // constexpr in C++20
51 find_if_not(InputIterator first, InputIterator last, Predicate pred);
52
53template <class ForwardIterator1, class ForwardIterator2>
54 ForwardIterator1 // constexpr in C++20
55 find_end(ForwardIterator1 first1, ForwardIterator1 last1,
56 ForwardIterator2 first2, ForwardIterator2 last2);
57
58template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
59 ForwardIterator1 // constexpr in C++20
60 find_end(ForwardIterator1 first1, ForwardIterator1 last1,
61 ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
62
63template <class ForwardIterator1, class ForwardIterator2>
64 constexpr ForwardIterator1 // constexpr in C++20
65 find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
66 ForwardIterator2 first2, ForwardIterator2 last2);
67
68template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
69 constexpr ForwardIterator1 // constexpr in C++20
70 find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
71 ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
72
73template <class ForwardIterator>
74 constexpr ForwardIterator // constexpr in C++20
75 adjacent_find(ForwardIterator first, ForwardIterator last);
76
77template <class ForwardIterator, class BinaryPredicate>
78 constexpr ForwardIterator // constexpr in C++20
79 adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate pred);
80
81template <class InputIterator, class T>
82 constexpr typename iterator_traits<InputIterator>::difference_type // constexpr in C++20
83 count(InputIterator first, InputIterator last, const T& value);
84
85template <class InputIterator, class Predicate>
86 constexpr typename iterator_traits<InputIterator>::difference_type // constexpr in C++20
87 count_if(InputIterator first, InputIterator last, Predicate pred);
88
89template <class InputIterator1, class InputIterator2>
90 constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
91 mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
92
93template <class InputIterator1, class InputIterator2>
94 constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
95 mismatch(InputIterator1 first1, InputIterator1 last1,
96 InputIterator2 first2, InputIterator2 last2); // **C++14**
97
98template <class InputIterator1, class InputIterator2, class BinaryPredicate>
99 constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
100 mismatch(InputIterator1 first1, InputIterator1 last1,
101 InputIterator2 first2, BinaryPredicate pred);
102
103template <class InputIterator1, class InputIterator2, class BinaryPredicate>
104 constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
105 mismatch(InputIterator1 first1, InputIterator1 last1,
106 InputIterator2 first2, InputIterator2 last2,
107 BinaryPredicate pred); // **C++14**
108
109template <class InputIterator1, class InputIterator2>
110 constexpr bool // constexpr in C++20
111 equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
112
113template <class InputIterator1, class InputIterator2>
114 constexpr bool // constexpr in C++20
115 equal(InputIterator1 first1, InputIterator1 last1,
116 InputIterator2 first2, InputIterator2 last2); // **C++14**
117
118template <class InputIterator1, class InputIterator2, class BinaryPredicate>
119 constexpr bool // constexpr in C++20
120 equal(InputIterator1 first1, InputIterator1 last1,
121 InputIterator2 first2, BinaryPredicate pred);
122
123template <class InputIterator1, class InputIterator2, class BinaryPredicate>
124 constexpr bool // constexpr in C++20
125 equal(InputIterator1 first1, InputIterator1 last1,
126 InputIterator2 first2, InputIterator2 last2,
127 BinaryPredicate pred); // **C++14**
128
129template<class ForwardIterator1, class ForwardIterator2>
130 constexpr bool // constexpr in C++20
131 is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
132 ForwardIterator2 first2);
133
134template<class ForwardIterator1, class ForwardIterator2>
135 constexpr bool // constexpr in C++20
136 is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
137 ForwardIterator2 first2, ForwardIterator2 last2); // **C++14**
138
139template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
140 constexpr bool // constexpr in C++20
141 is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
142 ForwardIterator2 first2, BinaryPredicate pred);
143
144template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
145 constexpr bool // constexpr in C++20
146 is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
147 ForwardIterator2 first2, ForwardIterator2 last2,
148 BinaryPredicate pred); // **C++14**
149
150template <class ForwardIterator1, class ForwardIterator2>
151 constexpr ForwardIterator1 // constexpr in C++20
152 search(ForwardIterator1 first1, ForwardIterator1 last1,
153 ForwardIterator2 first2, ForwardIterator2 last2);
154
155template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
156 constexpr ForwardIterator1 // constexpr in C++20
157 search(ForwardIterator1 first1, ForwardIterator1 last1,
158 ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
159
160template <class ForwardIterator, class Size, class T>
161 constexpr ForwardIterator // constexpr in C++20
162 search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value);
163
164template <class ForwardIterator, class Size, class T, class BinaryPredicate>
165 constexpr ForwardIterator // constexpr in C++20
166 search_n(ForwardIterator first, ForwardIterator last,
167 Size count, const T& value, BinaryPredicate pred);
168
169template <class InputIterator, class OutputIterator>
170 constexpr OutputIterator // constexpr in C++20
171 copy(InputIterator first, InputIterator last, OutputIterator result);
172
173template<class InputIterator, class OutputIterator, class Predicate>
174 constexpr OutputIterator // constexpr in C++20
175 copy_if(InputIterator first, InputIterator last,
176 OutputIterator result, Predicate pred);
177
178template<class InputIterator, class Size, class OutputIterator>
179 constexpr OutputIterator // constexpr in C++20
180 copy_n(InputIterator first, Size n, OutputIterator result);
181
182template <class BidirectionalIterator1, class BidirectionalIterator2>
183 constexpr BidirectionalIterator2 // constexpr in C++20
184 copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
185 BidirectionalIterator2 result);
186
187template <class ForwardIterator1, class ForwardIterator2>
188 ForwardIterator2
189 swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2);
190
191template <class ForwardIterator1, class ForwardIterator2>
192 void
193 iter_swap(ForwardIterator1 a, ForwardIterator2 b);
194
195template <class InputIterator, class OutputIterator, class UnaryOperation>
196 constexpr OutputIterator // constexpr in C++20
197 transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op);
198
199template <class InputIterator1, class InputIterator2, class OutputIterator, class BinaryOperation>
200 constexpr OutputIterator // constexpr in C++20
201 transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2,
202 OutputIterator result, BinaryOperation binary_op);
203
204template <class ForwardIterator, class T>
205 constexpr void // constexpr in C++20
206 replace(ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value);
207
208template <class ForwardIterator, class Predicate, class T>
209 constexpr void // constexpr in C++20
210 replace_if(ForwardIterator first, ForwardIterator last, Predicate pred, const T& new_value);
211
212template <class InputIterator, class OutputIterator, class T>
213 constexpr OutputIterator // constexpr in C++20
214 replace_copy(InputIterator first, InputIterator last, OutputIterator result,
215 const T& old_value, const T& new_value);
216
217template <class InputIterator, class OutputIterator, class Predicate, class T>
218 constexpr OutputIterator // constexpr in C++20
219 replace_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred, const T& new_value);
220
221template <class ForwardIterator, class T>
222 constexpr void // constexpr in C++20
223 fill(ForwardIterator first, ForwardIterator last, const T& value);
224
225template <class OutputIterator, class Size, class T>
226 constexpr OutputIterator // constexpr in C++20
227 fill_n(OutputIterator first, Size n, const T& value);
228
229template <class ForwardIterator, class Generator>
230 constexpr void // constexpr in C++20
231 generate(ForwardIterator first, ForwardIterator last, Generator gen);
232
233template <class OutputIterator, class Size, class Generator>
234 constexpr OutputIterator // constexpr in C++20
235 generate_n(OutputIterator first, Size n, Generator gen);
236
237template <class ForwardIterator, class T>
238 constexpr ForwardIterator // constexpr in C++20
239 remove(ForwardIterator first, ForwardIterator last, const T& value);
240
241template <class ForwardIterator, class Predicate>
242 constexpr ForwardIterator // constexpr in C++20
243 remove_if(ForwardIterator first, ForwardIterator last, Predicate pred);
244
245template <class InputIterator, class OutputIterator, class T>
246 constexpr OutputIterator // constexpr in C++20
247 remove_copy(InputIterator first, InputIterator last, OutputIterator result, const T& value);
248
249template <class InputIterator, class OutputIterator, class Predicate>
250 constexpr OutputIterator // constexpr in C++20
251 remove_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred);
252
253template <class ForwardIterator>
254 ForwardIterator
255 unique(ForwardIterator first, ForwardIterator last);
256
257template <class ForwardIterator, class BinaryPredicate>
258 ForwardIterator
259 unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred);
260
261template <class InputIterator, class OutputIterator>
262 OutputIterator
263 unique_copy(InputIterator first, InputIterator last, OutputIterator result);
264
265template <class InputIterator, class OutputIterator, class BinaryPredicate>
266 OutputIterator
267 unique_copy(InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate pred);
268
269template <class BidirectionalIterator>
270 void
271 reverse(BidirectionalIterator first, BidirectionalIterator last);
272
273template <class BidirectionalIterator, class OutputIterator>
274 constexpr OutputIterator // constexpr in C++20
275 reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator result);
276
277template <class ForwardIterator>
278 ForwardIterator
279 rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last);
280
281template <class ForwardIterator, class OutputIterator>
282 OutputIterator
283 rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator result);
284
285template <class RandomAccessIterator>
286 void
287 random_shuffle(RandomAccessIterator first, RandomAccessIterator last); // deprecated in C++14, removed in C++17
288
289template <class RandomAccessIterator, class RandomNumberGenerator>
290 void
291 random_shuffle(RandomAccessIterator first, RandomAccessIterator last,
292 RandomNumberGenerator& rand); // deprecated in C++14, removed in C++17
293
294template<class PopulationIterator, class SampleIterator,
295 class Distance, class UniformRandomBitGenerator>
296 SampleIterator sample(PopulationIterator first, PopulationIterator last,
297 SampleIterator out, Distance n,
298 UniformRandomBitGenerator&& g); // C++17
299
300template<class RandomAccessIterator, class UniformRandomNumberGenerator>
301 void shuffle(RandomAccessIterator first, RandomAccessIterator last,
302 UniformRandomNumberGenerator&& g);
303
304template <class InputIterator, class Predicate>
305 constexpr bool // constexpr in C++20
306 is_partitioned(InputIterator first, InputIterator last, Predicate pred);
307
308template <class ForwardIterator, class Predicate>
309 ForwardIterator
310 partition(ForwardIterator first, ForwardIterator last, Predicate pred);
311
312template <class InputIterator, class OutputIterator1,
313 class OutputIterator2, class Predicate>
314 constexpr pair<OutputIterator1, OutputIterator2> // constexpr in C++20
315 partition_copy(InputIterator first, InputIterator last,
316 OutputIterator1 out_true, OutputIterator2 out_false,
317 Predicate pred);
318
319template <class ForwardIterator, class Predicate>
320 ForwardIterator
321 stable_partition(ForwardIterator first, ForwardIterator last, Predicate pred);
322
323template<class ForwardIterator, class Predicate>
324 constexpr ForwardIterator // constexpr in C++20
325 partition_point(ForwardIterator first, ForwardIterator last, Predicate pred);
326
327template <class ForwardIterator>
328 constexpr bool // constexpr in C++20
329 is_sorted(ForwardIterator first, ForwardIterator last);
330
331template <class ForwardIterator, class Compare>
332 bool
333 is_sorted(ForwardIterator first, ForwardIterator last, Compare comp);
334
335template<class ForwardIterator>
336 constexpr ForwardIterator // constexpr in C++20
337 is_sorted_until(ForwardIterator first, ForwardIterator last);
338
339template <class ForwardIterator, class Compare>
340 constexpr ForwardIterator // constexpr in C++20
341 is_sorted_until(ForwardIterator first, ForwardIterator last, Compare comp);
342
343template <class RandomAccessIterator>
344 void
345 sort(RandomAccessIterator first, RandomAccessIterator last);
346
347template <class RandomAccessIterator, class Compare>
348 void
349 sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
350
351template <class RandomAccessIterator>
352 void
353 stable_sort(RandomAccessIterator first, RandomAccessIterator last);
354
355template <class RandomAccessIterator, class Compare>
356 void
357 stable_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
358
359template <class RandomAccessIterator>
360 void
361 partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last);
362
363template <class RandomAccessIterator, class Compare>
364 void
365 partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last, Compare comp);
366
367template <class InputIterator, class RandomAccessIterator>
368 RandomAccessIterator
369 partial_sort_copy(InputIterator first, InputIterator last,
370 RandomAccessIterator result_first, RandomAccessIterator result_last);
371
372template <class InputIterator, class RandomAccessIterator, class Compare>
373 RandomAccessIterator
374 partial_sort_copy(InputIterator first, InputIterator last,
375 RandomAccessIterator result_first, RandomAccessIterator result_last, Compare comp);
376
377template <class RandomAccessIterator>
378 void
379 nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last);
380
381template <class RandomAccessIterator, class Compare>
382 void
383 nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last, Compare comp);
384
385template <class ForwardIterator, class T>
386 constexpr ForwardIterator // constexpr in C++20
387 lower_bound(ForwardIterator first, ForwardIterator last, const T& value);
388
389template <class ForwardIterator, class T, class Compare>
390 constexpr ForwardIterator // constexpr in C++20
391 lower_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
392
393template <class ForwardIterator, class T>
394 constexpr ForwardIterator // constexpr in C++20
395 upper_bound(ForwardIterator first, ForwardIterator last, const T& value);
396
397template <class ForwardIterator, class T, class Compare>
398 constexpr ForwardIterator // constexpr in C++20
399 upper_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
400
401template <class ForwardIterator, class T>
402 constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++20
403 equal_range(ForwardIterator first, ForwardIterator last, const T& value);
404
405template <class ForwardIterator, class T, class Compare>
406 constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++20
407 equal_range(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
408
409template <class ForwardIterator, class T>
410 constexpr bool // constexpr in C++20
411 binary_search(ForwardIterator first, ForwardIterator last, const T& value);
412
413template <class ForwardIterator, class T, class Compare>
414 constexpr bool // constexpr in C++20
415 binary_search(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
416
417template <class InputIterator1, class InputIterator2, class OutputIterator>
418 OutputIterator
419 merge(InputIterator1 first1, InputIterator1 last1,
420 InputIterator2 first2, InputIterator2 last2, OutputIterator result);
421
422template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
423 OutputIterator
424 merge(InputIterator1 first1, InputIterator1 last1,
425 InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
426
427template <class BidirectionalIterator>
428 void
429 inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last);
430
431template <class BidirectionalIterator, class Compare>
432 void
433 inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last, Compare comp);
434
435template <class InputIterator1, class InputIterator2>
436 constexpr bool // constexpr in C++20
437 includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);
438
439template <class InputIterator1, class InputIterator2, class Compare>
440 constexpr bool // constexpr in C++20
441 includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp);
442
443template <class InputIterator1, class InputIterator2, class OutputIterator>
444 OutputIterator
445 set_union(InputIterator1 first1, InputIterator1 last1,
446 InputIterator2 first2, InputIterator2 last2, OutputIterator result);
447
448template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
449 OutputIterator
450 set_union(InputIterator1 first1, InputIterator1 last1,
451 InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
452
453template <class InputIterator1, class InputIterator2, class OutputIterator>
454 constexpr OutputIterator // constexpr in C++20
455 set_intersection(InputIterator1 first1, InputIterator1 last1,
456 InputIterator2 first2, InputIterator2 last2, OutputIterator result);
457
458template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
459 constexpr OutputIterator // constexpr in C++20
460 set_intersection(InputIterator1 first1, InputIterator1 last1,
461 InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
462
463template <class InputIterator1, class InputIterator2, class OutputIterator>
464 OutputIterator
465 set_difference(InputIterator1 first1, InputIterator1 last1,
466 InputIterator2 first2, InputIterator2 last2, OutputIterator result);
467
468template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
469 OutputIterator
470 set_difference(InputIterator1 first1, InputIterator1 last1,
471 InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
472
473template <class InputIterator1, class InputIterator2, class OutputIterator>
474 OutputIterator
475 set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
476 InputIterator2 first2, InputIterator2 last2, OutputIterator result);
477
478template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
479 OutputIterator
480 set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
481 InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
482
483template <class RandomAccessIterator>
484 void
485 push_heap(RandomAccessIterator first, RandomAccessIterator last);
486
487template <class RandomAccessIterator, class Compare>
488 void
489 push_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
490
491template <class RandomAccessIterator>
492 void
493 pop_heap(RandomAccessIterator first, RandomAccessIterator last);
494
495template <class RandomAccessIterator, class Compare>
496 void
497 pop_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
498
499template <class RandomAccessIterator>
500 void
501 make_heap(RandomAccessIterator first, RandomAccessIterator last);
502
503template <class RandomAccessIterator, class Compare>
504 void
505 make_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
506
507template <class RandomAccessIterator>
508 void
509 sort_heap(RandomAccessIterator first, RandomAccessIterator last);
510
511template <class RandomAccessIterator, class Compare>
512 void
513 sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
514
515template <class RandomAccessIterator>
516 constexpr bool // constexpr in C++20
517 is_heap(RandomAccessIterator first, RandomAccessiterator last);
518
519template <class RandomAccessIterator, class Compare>
520 constexpr bool // constexpr in C++20
521 is_heap(RandomAccessIterator first, RandomAccessiterator last, Compare comp);
522
523template <class RandomAccessIterator>
524 constexpr RandomAccessIterator // constexpr in C++20
525 is_heap_until(RandomAccessIterator first, RandomAccessiterator last);
526
527template <class RandomAccessIterator, class Compare>
528 constexpr RandomAccessIterator // constexpr in C++20
529 is_heap_until(RandomAccessIterator first, RandomAccessiterator last, Compare comp);
530
531template <class ForwardIterator>
532 ForwardIterator
533 min_element(ForwardIterator first, ForwardIterator last); // constexpr in C++14
534
535template <class ForwardIterator, class Compare>
536 ForwardIterator
537 min_element(ForwardIterator first, ForwardIterator last, Compare comp); // constexpr in C++14
538
539template <class T>
540 const T&
541 min(const T& a, const T& b); // constexpr in C++14
542
543template <class T, class Compare>
544 const T&
545 min(const T& a, const T& b, Compare comp); // constexpr in C++14
546
547template<class T>
548 T
549 min(initializer_list<T> t); // constexpr in C++14
550
551template<class T, class Compare>
552 T
553 min(initializer_list<T> t, Compare comp); // constexpr in C++14
554
555template<class T>
556 constexpr const T& clamp( const T& v, const T& lo, const T& hi ); // C++17
557
558template<class T, class Compare>
559 constexpr const T& clamp( const T& v, const T& lo, const T& hi, Compare comp ); // C++17
560
561template <class ForwardIterator>
562 ForwardIterator
563 max_element(ForwardIterator first, ForwardIterator last); // constexpr in C++14
564
565template <class ForwardIterator, class Compare>
566 ForwardIterator
567 max_element(ForwardIterator first, ForwardIterator last, Compare comp); // constexpr in C++14
568
569template <class T>
570 const T&
571 max(const T& a, const T& b); // constexpr in C++14
572
573template <class T, class Compare>
574 const T&
575 max(const T& a, const T& b, Compare comp); // constexpr in C++14
576
577template<class T>
578 T
579 max(initializer_list<T> t); // constexpr in C++14
580
581template<class T, class Compare>
582 T
583 max(initializer_list<T> t, Compare comp); // constexpr in C++14
584
585template<class ForwardIterator>
586 pair<ForwardIterator, ForwardIterator>
587 minmax_element(ForwardIterator first, ForwardIterator last); // constexpr in C++14
588
589template<class ForwardIterator, class Compare>
590 pair<ForwardIterator, ForwardIterator>
591 minmax_element(ForwardIterator first, ForwardIterator last, Compare comp); // constexpr in C++14
592
593template<class T>
594 pair<const T&, const T&>
595 minmax(const T& a, const T& b); // constexpr in C++14
596
597template<class T, class Compare>
598 pair<const T&, const T&>
599 minmax(const T& a, const T& b, Compare comp); // constexpr in C++14
600
601template<class T>
602 pair<T, T>
603 minmax(initializer_list<T> t); // constexpr in C++14
604
605template<class T, class Compare>
606 pair<T, T>
607 minmax(initializer_list<T> t, Compare comp); // constexpr in C++14
608
609template <class InputIterator1, class InputIterator2>
610 constexpr bool // constexpr in C++20
611 lexicographical_compare(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);
612
613template <class InputIterator1, class InputIterator2, class Compare>
614 constexpr bool // constexpr in C++20
615 lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
616 InputIterator2 first2, InputIterator2 last2, Compare comp);
617
618template <class BidirectionalIterator>
619 bool
620 next_permutation(BidirectionalIterator first, BidirectionalIterator last);
621
622template <class BidirectionalIterator, class Compare>
623 bool
624 next_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);
625
626template <class BidirectionalIterator>
627 bool
628 prev_permutation(BidirectionalIterator first, BidirectionalIterator last);
629
630template <class BidirectionalIterator, class Compare>
631 bool
632 prev_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);
633
634} // std
635
636*/
637
638#include <__config>
639#include <initializer_list>
640#include <type_traits>
641#include <cstring>
642#include <utility> // needed to provide swap_ranges.
643#include <memory>
644#include <functional>
645#include <iterator>
646#include <cstddef>
647#include <bit>
648#include <version>
649
650#include <__debug>
651
652#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
653#pragma GCC system_header
654#endif
655
656_LIBCPP_PUSH_MACROS
657#include <__undef_macros>
658
659
660_LIBCPP_BEGIN_NAMESPACE_STD
661
662// I'd like to replace these with _VSTD::equal_to<void>, but can't because:
663// * That only works with C++14 and later, and
664// * We haven't included <functional> here.
665template <class _T1, class _T2 = _T1>
666struct __equal_to
667{
668 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
669 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 bool operator()(const _T1& __x, const _T2& __y) const {return __x == __y;}
670 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 bool operator()(const _T2& __x, const _T1& __y) const {return __x == __y;}
671 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 bool operator()(const _T2& __x, const _T2& __y) const {return __x == __y;}
672};
673
674template <class _T1>
675struct __equal_to<_T1, _T1>
676{
677 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
678 bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
679};
680
681template <class _T1>
682struct __equal_to<const _T1, _T1>
683{
684 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
685 bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
686};
687
688template <class _T1>
689struct __equal_to<_T1, const _T1>
690{
691 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
692 bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
693};
694
695template <class _T1, class _T2 = _T1>
696struct __less
697{
698 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
699 bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
700
701 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
702 bool operator()(const _T1& __x, const _T2& __y) const {return __x < __y;}
703
704 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
705 bool operator()(const _T2& __x, const _T1& __y) const {return __x < __y;}
706
707 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
708 bool operator()(const _T2& __x, const _T2& __y) const {return __x < __y;}
709};
710
711template <class _T1>
712struct __less<_T1, _T1>
713{
714 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
715 bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
716};
717
718template <class _T1>
719struct __less<const _T1, _T1>
720{
721 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
722 bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
723};
724
725template <class _T1>
726struct __less<_T1, const _T1>
727{
728 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
729 bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
730};
731
732template <class _Predicate>
733class __invert // invert the sense of a comparison
734{
735private:
736 _Predicate __p_;
737public:
738 _LIBCPP_INLINE_VISIBILITY __invert() {}
739
740 _LIBCPP_INLINE_VISIBILITY
741 explicit __invert(_Predicate __p) : __p_(__p) {}
742
743 template <class _T1>
744 _LIBCPP_INLINE_VISIBILITY
745 bool operator()(const _T1& __x) {return !__p_(__x);}
746
747 template <class _T1, class _T2>
748 _LIBCPP_INLINE_VISIBILITY
749 bool operator()(const _T1& __x, const _T2& __y) {return __p_(__y, __x);}
750};
751
752// Perform division by two quickly for positive integers (llvm.org/PR39129)
753
754template <typename _Integral>
755_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
756typename enable_if
757<
758 is_integral<_Integral>::value,
759 _Integral
760>::type
761__half_positive(_Integral __value)
762{
763 return static_cast<_Integral>(static_cast<typename make_unsigned<_Integral>::type>(__value) / 2);
764}
765
766template <typename _Tp>
767_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
768typename enable_if
769<
770 !is_integral<_Tp>::value,
771 _Tp
772>::type
773__half_positive(_Tp __value)
774{
775 return __value / 2;
776}
777
778#ifdef _LIBCPP_DEBUG
779
780template <class _Compare>
781struct __debug_less
782{
783 _Compare &__comp_;
784 _LIBCPP_CONSTEXPR_AFTER_CXX17
785 __debug_less(_Compare& __c) : __comp_(__c) {}
786
787 template <class _Tp, class _Up>
788 _LIBCPP_CONSTEXPR_AFTER_CXX17
789 bool operator()(const _Tp& __x, const _Up& __y)
790 {
791 bool __r = __comp_(__x, __y);
792 if (__r)
793 __do_compare_assert(0, __y, __x);
794 return __r;
795 }
796
797 template <class _Tp, class _Up>
798 _LIBCPP_CONSTEXPR_AFTER_CXX17
799 bool operator()(_Tp& __x, _Up& __y)
800 {
801 bool __r = __comp_(__x, __y);
802 if (__r)
803 __do_compare_assert(0, __y, __x);
804 return __r;
805 }
806
807 template <class _LHS, class _RHS>
808 _LIBCPP_CONSTEXPR_AFTER_CXX17
809 inline _LIBCPP_INLINE_VISIBILITY
810 decltype((void)_VSTD::declval<_Compare&>()(
811 _VSTD::declval<_LHS &>(), _VSTD::declval<_RHS &>()))
812 __do_compare_assert(int, _LHS & __l, _RHS & __r) {
813 _LIBCPP_ASSERT(!__comp_(__l, __r),
814 "Comparator does not induce a strict weak ordering");
815 }
816
817 template <class _LHS, class _RHS>
818 _LIBCPP_CONSTEXPR_AFTER_CXX17
819 inline _LIBCPP_INLINE_VISIBILITY
820 void __do_compare_assert(long, _LHS &, _RHS &) {}
821};
822
823#endif // _LIBCPP_DEBUG
824
825template <class _Comp>
826struct __comp_ref_type {
827 // Pass the comparator by lvalue reference. Or in debug mode, using a
828 // debugging wrapper that stores a reference.
829#ifndef _LIBCPP_DEBUG
830 typedef typename add_lvalue_reference<_Comp>::type type;
831#else
832 typedef __debug_less<_Comp> type;
833#endif
834};
835
836// all_of
837
838template <class _InputIterator, class _Predicate>
839_LIBCPP_NODISCARD_EXT inline
840_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
841bool
842all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
843{
844 for (; __first != __last; ++__first)
845 if (!__pred(*__first))
846 return false;
847 return true;
848}
849
850// any_of
851
852template <class _InputIterator, class _Predicate>
853_LIBCPP_NODISCARD_EXT inline
854_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
855bool
856any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
857{
858 for (; __first != __last; ++__first)
859 if (__pred(*__first))
860 return true;
861 return false;
862}
863
864// none_of
865
866template <class _InputIterator, class _Predicate>
867_LIBCPP_NODISCARD_EXT inline
868_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
869bool
870none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
871{
872 for (; __first != __last; ++__first)
873 if (__pred(*__first))
874 return false;
875 return true;
876}
877
878// for_each
879
880template <class _InputIterator, class _Function>
881inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
882_Function
883for_each(_InputIterator __first, _InputIterator __last, _Function __f)
884{
885 for (; __first != __last; ++__first)
886 __f(*__first);
887 return __f;
888}
889
890#if _LIBCPP_STD_VER > 14
891// for_each_n
892
893template <class _InputIterator, class _Size, class _Function>
894inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
895_InputIterator
896for_each_n(_InputIterator __first, _Size __orig_n, _Function __f)
897{
898 typedef decltype(__convert_to_integral(__orig_n)) _IntegralSize;
899 _IntegralSize __n = __orig_n;
900 while (__n > 0)
901 {
902 __f(*__first);
903 ++__first;
904 --__n;
905 }
906 return __first;
907}
908#endif
909
910// find
911
912template <class _InputIterator, class _Tp>
913_LIBCPP_NODISCARD_EXT inline
914_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
915_InputIterator
916find(_InputIterator __first, _InputIterator __last, const _Tp& __value_)
917{
918 for (; __first != __last; ++__first)
919 if (*__first == __value_)
920 break;
921 return __first;
922}
923
924// find_if
925
926template <class _InputIterator, class _Predicate>
927_LIBCPP_NODISCARD_EXT inline
928_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
929_InputIterator
930find_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
931{
932 for (; __first != __last; ++__first)
933 if (__pred(*__first))
934 break;
935 return __first;
936}
937
938// find_if_not
939
940template<class _InputIterator, class _Predicate>
941_LIBCPP_NODISCARD_EXT inline
942_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
943_InputIterator
944find_if_not(_InputIterator __first, _InputIterator __last, _Predicate __pred)
945{
946 for (; __first != __last; ++__first)
947 if (!__pred(*__first))
948 break;
949 return __first;
950}
951
952// find_end
953
954template <class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2>
955_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator1
956__find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
957 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred,
958 forward_iterator_tag, forward_iterator_tag)
959{
960 // modeled after search algorithm
961 _ForwardIterator1 __r = __last1; // __last1 is the "default" answer
962 if (__first2 == __last2)
963 return __r;
964 while (true)
965 {
966 while (true)
967 {
968 if (__first1 == __last1) // if source exhausted return last correct answer
969 return __r; // (or __last1 if never found)
970 if (__pred(*__first1, *__first2))
971 break;
972 ++__first1;
973 }
974 // *__first1 matches *__first2, now match elements after here
975 _ForwardIterator1 __m1 = __first1;
976 _ForwardIterator2 __m2 = __first2;
977 while (true)
978 {
979 if (++__m2 == __last2)
980 { // Pattern exhaused, record answer and search for another one
981 __r = __first1;
982 ++__first1;
983 break;
984 }
985 if (++__m1 == __last1) // Source exhausted, return last answer
986 return __r;
987 if (!__pred(*__m1, *__m2)) // mismatch, restart with a new __first
988 {
989 ++__first1;
990 break;
991 } // else there is a match, check next elements
992 }
993 }
994}
995
996template <class _BinaryPredicate, class _BidirectionalIterator1, class _BidirectionalIterator2>
997_LIBCPP_CONSTEXPR_AFTER_CXX17 _BidirectionalIterator1
998__find_end(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1,
999 _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2, _BinaryPredicate __pred,
1000 bidirectional_iterator_tag, bidirectional_iterator_tag)
1001{
1002 // modeled after search algorithm (in reverse)
1003 if (__first2 == __last2)
1004 return __last1; // Everything matches an empty sequence
1005 _BidirectionalIterator1 __l1 = __last1;
1006 _BidirectionalIterator2 __l2 = __last2;
1007 --__l2;
1008 while (true)
1009 {
1010 // Find last element in sequence 1 that matchs *(__last2-1), with a mininum of loop checks
1011 while (true)
1012 {
1013 if (__first1 == __l1) // return __last1 if no element matches *__first2
1014 return __last1;
1015 if (__pred(*--__l1, *__l2))
1016 break;
1017 }
1018 // *__l1 matches *__l2, now match elements before here
1019 _BidirectionalIterator1 __m1 = __l1;
1020 _BidirectionalIterator2 __m2 = __l2;
1021 while (true)
1022 {
1023 if (__m2 == __first2) // If pattern exhausted, __m1 is the answer (works for 1 element pattern)
1024 return __m1;
1025 if (__m1 == __first1) // Otherwise if source exhaused, pattern not found
1026 return __last1;
1027 if (!__pred(*--__m1, *--__m2)) // if there is a mismatch, restart with a new __l1
1028 {
1029 break;
1030 } // else there is a match, check next elements
1031 }
1032 }
1033}
1034
1035template <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2>
1036_LIBCPP_CONSTEXPR_AFTER_CXX11 _RandomAccessIterator1
1037__find_end(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
1038 _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred,
1039 random_access_iterator_tag, random_access_iterator_tag)
1040{
1041 // Take advantage of knowing source and pattern lengths. Stop short when source is smaller than pattern
1042 typename iterator_traits<_RandomAccessIterator2>::difference_type __len2 = __last2 - __first2;
1043 if (__len2 == 0)
1044 return __last1;
1045 typename iterator_traits<_RandomAccessIterator1>::difference_type __len1 = __last1 - __first1;
1046 if (__len1 < __len2)
1047 return __last1;
1048 const _RandomAccessIterator1 __s = __first1 + (__len2 - 1); // End of pattern match can't go before here
1049 _RandomAccessIterator1 __l1 = __last1;
1050 _RandomAccessIterator2 __l2 = __last2;
1051 --__l2;
1052 while (true)
1053 {
1054 while (true)
1055 {
1056 if (__s == __l1)
1057 return __last1;
1058 if (__pred(*--__l1, *__l2))
1059 break;
1060 }
1061 _RandomAccessIterator1 __m1 = __l1;
1062 _RandomAccessIterator2 __m2 = __l2;
1063 while (true)
1064 {
1065 if (__m2 == __first2)
1066 return __m1;
1067 // no need to check range on __m1 because __s guarantees we have enough source
1068 if (!__pred(*--__m1, *--__m2))
1069 {
1070 break;
1071 }
1072 }
1073 }
1074}
1075
1076template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
1077_LIBCPP_NODISCARD_EXT inline
1078_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1079_ForwardIterator1
1080find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
1081 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred)
1082{
1083 return _VSTD::__find_end<typename add_lvalue_reference<_BinaryPredicate>::type>
1084 (__first1, __last1, __first2, __last2, __pred,
1085 typename iterator_traits<_ForwardIterator1>::iterator_category(),
1086 typename iterator_traits<_ForwardIterator2>::iterator_category());
1087}
1088
1089template <class _ForwardIterator1, class _ForwardIterator2>
1090_LIBCPP_NODISCARD_EXT inline
1091_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1092_ForwardIterator1
1093find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
1094 _ForwardIterator2 __first2, _ForwardIterator2 __last2)
1095{
1096 typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
1097 typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
1098 return _VSTD::find_end(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
1099}
1100
1101// find_first_of
1102
1103template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
1104_LIBCPP_CONSTEXPR_AFTER_CXX11 _ForwardIterator1
1105__find_first_of_ce(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
1106 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred)
1107{
1108 for (; __first1 != __last1; ++__first1)
1109 for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j)
1110 if (__pred(*__first1, *__j))
1111 return __first1;
1112 return __last1;
1113}
1114
1115
1116template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
1117_LIBCPP_NODISCARD_EXT inline
1118_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1119_ForwardIterator1
1120find_first_of(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
1121 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred)
1122{
1123 return _VSTD::__find_first_of_ce(__first1, __last1, __first2, __last2, __pred);
1124}
1125
1126template <class _ForwardIterator1, class _ForwardIterator2>
1127_LIBCPP_NODISCARD_EXT inline
1128_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1129_ForwardIterator1
1130find_first_of(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
1131 _ForwardIterator2 __first2, _ForwardIterator2 __last2)
1132{
1133 typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
1134 typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
1135 return _VSTD::__find_first_of_ce(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
1136}
1137
1138// adjacent_find
1139
1140template <class _ForwardIterator, class _BinaryPredicate>
1141_LIBCPP_NODISCARD_EXT inline
1142_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1143_ForwardIterator
1144adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred)
1145{
1146 if (__first != __last)
1147 {
1148 _ForwardIterator __i = __first;
1149 while (++__i != __last)
1150 {
1151 if (__pred(*__first, *__i))
1152 return __first;
1153 __first = __i;
1154 }
1155 }
1156 return __last;
1157}
1158
1159template <class _ForwardIterator>
1160_LIBCPP_NODISCARD_EXT inline
1161_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1162_ForwardIterator
1163adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
1164{
1165 typedef typename iterator_traits<_ForwardIterator>::value_type __v;
1166 return _VSTD::adjacent_find(__first, __last, __equal_to<__v>());
1167}
1168
1169// count
1170
1171template <class _InputIterator, class _Tp>
1172_LIBCPP_NODISCARD_EXT inline
1173_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1174typename iterator_traits<_InputIterator>::difference_type
1175count(_InputIterator __first, _InputIterator __last, const _Tp& __value_)
1176{
1177 typename iterator_traits<_InputIterator>::difference_type __r(0);
1178 for (; __first != __last; ++__first)
1179 if (*__first == __value_)
1180 ++__r;
1181 return __r;
1182}
1183
1184// count_if
1185
1186template <class _InputIterator, class _Predicate>
1187_LIBCPP_NODISCARD_EXT inline
1188_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1189typename iterator_traits<_InputIterator>::difference_type
1190count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
1191{
1192 typename iterator_traits<_InputIterator>::difference_type __r(0);
1193 for (; __first != __last; ++__first)
1194 if (__pred(*__first))
1195 ++__r;
1196 return __r;
1197}
1198
1199// mismatch
1200
1201template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
1202_LIBCPP_NODISCARD_EXT inline
1203_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1204pair<_InputIterator1, _InputIterator2>
1205mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
1206 _InputIterator2 __first2, _BinaryPredicate __pred)
1207{
1208 for (; __first1 != __last1; ++__first1, (void) ++__first2)
1209 if (!__pred(*__first1, *__first2))
1210 break;
1211 return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
1212}
1213
1214template <class _InputIterator1, class _InputIterator2>
1215_LIBCPP_NODISCARD_EXT inline
1216_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1217pair<_InputIterator1, _InputIterator2>
1218mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2)
1219{
1220 typedef typename iterator_traits<_InputIterator1>::value_type __v1;
1221 typedef typename iterator_traits<_InputIterator2>::value_type __v2;
1222 return _VSTD::mismatch(__first1, __last1, __first2, __equal_to<__v1, __v2>());
1223}
1224
1225#if _LIBCPP_STD_VER > 11
1226template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
1227_LIBCPP_NODISCARD_EXT inline
1228_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1229pair<_InputIterator1, _InputIterator2>
1230mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
1231 _InputIterator2 __first2, _InputIterator2 __last2,
1232 _BinaryPredicate __pred)
1233{
1234 for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void) ++__first2)
1235 if (!__pred(*__first1, *__first2))
1236 break;
1237 return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
1238}
1239
1240template <class _InputIterator1, class _InputIterator2>
1241_LIBCPP_NODISCARD_EXT inline
1242_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1243pair<_InputIterator1, _InputIterator2>
1244mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
1245 _InputIterator2 __first2, _InputIterator2 __last2)
1246{
1247 typedef typename iterator_traits<_InputIterator1>::value_type __v1;
1248 typedef typename iterator_traits<_InputIterator2>::value_type __v2;
1249 return _VSTD::mismatch(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
1250}
1251#endif
1252
1253// equal
1254
1255template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
1256_LIBCPP_NODISCARD_EXT inline
1257_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1258bool
1259equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __pred)
1260{
1261 for (; __first1 != __last1; ++__first1, (void) ++__first2)
1262 if (!__pred(*__first1, *__first2))
1263 return false;
1264 return true;
1265}
1266
1267template <class _InputIterator1, class _InputIterator2>
1268_LIBCPP_NODISCARD_EXT inline
1269_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1270bool
1271equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2)
1272{
1273 typedef typename iterator_traits<_InputIterator1>::value_type __v1;
1274 typedef typename iterator_traits<_InputIterator2>::value_type __v2;
1275 return _VSTD::equal(__first1, __last1, __first2, __equal_to<__v1, __v2>());
1276}
1277
1278#if _LIBCPP_STD_VER > 11
1279template <class _BinaryPredicate, class _InputIterator1, class _InputIterator2>
1280inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1281bool
1282__equal(_InputIterator1 __first1, _InputIterator1 __last1,
1283 _InputIterator2 __first2, _InputIterator2 __last2, _BinaryPredicate __pred,
1284 input_iterator_tag, input_iterator_tag )
1285{
1286 for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void) ++__first2)
1287 if (!__pred(*__first1, *__first2))
1288 return false;
1289 return __first1 == __last1 && __first2 == __last2;
1290}
1291
1292template <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2>
1293inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1294bool
1295__equal(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
1296 _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred,
1297 random_access_iterator_tag, random_access_iterator_tag )
1298{
1299 if ( _VSTD::distance(__first1, __last1) != _VSTD::distance(__first2, __last2))
1300 return false;
1301 return _VSTD::equal<_RandomAccessIterator1, _RandomAccessIterator2,
1302 typename add_lvalue_reference<_BinaryPredicate>::type>
1303 (__first1, __last1, __first2, __pred );
1304}
1305
1306template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
1307_LIBCPP_NODISCARD_EXT inline
1308_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1309bool
1310equal(_InputIterator1 __first1, _InputIterator1 __last1,
1311 _InputIterator2 __first2, _InputIterator2 __last2, _BinaryPredicate __pred )
1312{
1313 return _VSTD::__equal<typename add_lvalue_reference<_BinaryPredicate>::type>
1314 (__first1, __last1, __first2, __last2, __pred,
1315 typename iterator_traits<_InputIterator1>::iterator_category(),
1316 typename iterator_traits<_InputIterator2>::iterator_category());
1317}
1318
1319template <class _InputIterator1, class _InputIterator2>
1320_LIBCPP_NODISCARD_EXT inline
1321_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1322bool
1323equal(_InputIterator1 __first1, _InputIterator1 __last1,
1324 _InputIterator2 __first2, _InputIterator2 __last2)
1325{
1326 typedef typename iterator_traits<_InputIterator1>::value_type __v1;
1327 typedef typename iterator_traits<_InputIterator2>::value_type __v2;
1328 return _VSTD::__equal(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>(),
1329 typename iterator_traits<_InputIterator1>::iterator_category(),
1330 typename iterator_traits<_InputIterator2>::iterator_category());
1331}
1332#endif
1333
1334// is_permutation
1335
1336template<class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
1337_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_AFTER_CXX17 bool
1338is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
1339 _ForwardIterator2 __first2, _BinaryPredicate __pred)
1340{
1341// shorten sequences as much as possible by lopping of any equal prefix
1342 for (; __first1 != __last1; ++__first1, (void) ++__first2)
1343 if (!__pred(*__first1, *__first2))
1344 break;
1345 if (__first1 == __last1)
1346 return true;
1347
1348// __first1 != __last1 && *__first1 != *__first2
1349 typedef typename iterator_traits<_ForwardIterator1>::difference_type _D1;
1350 _D1 __l1 = _VSTD::distance(__first1, __last1);
1351 if (__l1 == _D1(1))
1352 return false;
1353 _ForwardIterator2 __last2 = _VSTD::next(__first2, __l1);
1354 // For each element in [f1, l1) see if there are the same number of
1355 // equal elements in [f2, l2)
1356 for (_ForwardIterator1 __i = __first1; __i != __last1; ++__i)
1357 {
1358 // Have we already counted the number of *__i in [f1, l1)?
1359 _ForwardIterator1 __match = __first1;
1360 for (; __match != __i; ++__match)
1361 if (__pred(*__match, *__i))
1362 break;
1363 if (__match == __i) {
1364 // Count number of *__i in [f2, l2)
1365 _D1 __c2 = 0;
1366 for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j)
1367 if (__pred(*__i, *__j))
1368 ++__c2;
1369 if (__c2 == 0)
1370 return false;
1371 // Count number of *__i in [__i, l1) (we can start with 1)
1372 _D1 __c1 = 1;
1373 for (_ForwardIterator1 __j = _VSTD::next(__i); __j != __last1; ++__j)
1374 if (__pred(*__i, *__j))
1375 ++__c1;
1376 if (__c1 != __c2)
1377 return false;
1378 }
1379 }
1380 return true;
1381}
1382
1383template<class _ForwardIterator1, class _ForwardIterator2>
1384_LIBCPP_NODISCARD_EXT inline
1385_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1386bool
1387is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
1388 _ForwardIterator2 __first2)
1389{
1390 typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
1391 typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
1392 return _VSTD::is_permutation(__first1, __last1, __first2, __equal_to<__v1, __v2>());
1393}
1394
1395#if _LIBCPP_STD_VER > 11
1396template<class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2>
1397_LIBCPP_CONSTEXPR_AFTER_CXX17 bool
1398__is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
1399 _ForwardIterator2 __first2, _ForwardIterator2 __last2,
1400 _BinaryPredicate __pred,
1401 forward_iterator_tag, forward_iterator_tag )
1402{
1403// shorten sequences as much as possible by lopping of any equal prefix
1404 for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void) ++__first2)
1405 if (!__pred(*__first1, *__first2))
1406 break;
1407 if (__first1 == __last1)
1408 return __first2 == __last2;
1409 else if (__first2 == __last2)
1410 return false;
1411
1412 typedef typename iterator_traits<_ForwardIterator1>::difference_type _D1;
1413 _D1 __l1 = _VSTD::distance(__first1, __last1);
1414
1415 typedef typename iterator_traits<_ForwardIterator2>::difference_type _D2;
1416 _D2 __l2 = _VSTD::distance(__first2, __last2);
1417 if (__l1 != __l2)
1418 return false;
1419
1420 // For each element in [f1, l1) see if there are the same number of
1421 // equal elements in [f2, l2)
1422 for (_ForwardIterator1 __i = __first1; __i != __last1; ++__i)
1423 {
1424 // Have we already counted the number of *__i in [f1, l1)?
1425 _ForwardIterator1 __match = __first1;
1426 for (; __match != __i; ++__match)
1427 if (__pred(*__match, *__i))
1428 break;
1429 if (__match == __i) {
1430 // Count number of *__i in [f2, l2)
1431 _D1 __c2 = 0;
1432 for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j)
1433 if (__pred(*__i, *__j))
1434 ++__c2;
1435 if (__c2 == 0)
1436 return false;
1437 // Count number of *__i in [__i, l1) (we can start with 1)
1438 _D1 __c1 = 1;
1439 for (_ForwardIterator1 __j = _VSTD::next(__i); __j != __last1; ++__j)
1440 if (__pred(*__i, *__j))
1441 ++__c1;
1442 if (__c1 != __c2)
1443 return false;
1444 }
1445 }
1446 return true;
1447}
1448
1449template<class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2>
1450_LIBCPP_CONSTEXPR_AFTER_CXX17 bool
1451__is_permutation(_RandomAccessIterator1 __first1, _RandomAccessIterator2 __last1,
1452 _RandomAccessIterator1 __first2, _RandomAccessIterator2 __last2,
1453 _BinaryPredicate __pred,
1454 random_access_iterator_tag, random_access_iterator_tag )
1455{
1456 if ( _VSTD::distance(__first1, __last1) != _VSTD::distance(__first2, __last2))
1457 return false;
1458 return _VSTD::is_permutation<_RandomAccessIterator1, _RandomAccessIterator2,
1459 typename add_lvalue_reference<_BinaryPredicate>::type>
1460 (__first1, __last1, __first2, __pred );
1461}
1462
1463template<class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
1464_LIBCPP_NODISCARD_EXT inline
1465_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1466bool
1467is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
1468 _ForwardIterator2 __first2, _ForwardIterator2 __last2,
1469 _BinaryPredicate __pred )
1470{
1471 return _VSTD::__is_permutation<typename add_lvalue_reference<_BinaryPredicate>::type>
1472 (__first1, __last1, __first2, __last2, __pred,
1473 typename iterator_traits<_ForwardIterator1>::iterator_category(),
1474 typename iterator_traits<_ForwardIterator2>::iterator_category());
1475}
1476
1477template<class _ForwardIterator1, class _ForwardIterator2>
1478_LIBCPP_NODISCARD_EXT inline
1479_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1480bool
1481is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
1482 _ForwardIterator2 __first2, _ForwardIterator2 __last2)
1483{
1484 typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
1485 typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
1486 return _VSTD::__is_permutation(__first1, __last1, __first2, __last2,
1487 __equal_to<__v1, __v2>(),
1488 typename iterator_traits<_ForwardIterator1>::iterator_category(),
1489 typename iterator_traits<_ForwardIterator2>::iterator_category());
1490}
1491#endif
1492
1493// search
1494// __search is in <functional>
1495
1496template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
1497_LIBCPP_NODISCARD_EXT inline
1498_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1499_ForwardIterator1
1500search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
1501 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred)
1502{
1503 return _VSTD::__search<typename add_lvalue_reference<_BinaryPredicate>::type>
1504 (__first1, __last1, __first2, __last2, __pred,
1505 typename iterator_traits<_ForwardIterator1>::iterator_category(),
1506 typename iterator_traits<_ForwardIterator2>::iterator_category())
1507 .first;
1508}
1509
1510template <class _ForwardIterator1, class _ForwardIterator2>
1511_LIBCPP_NODISCARD_EXT inline
1512_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1513_ForwardIterator1
1514search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
1515 _ForwardIterator2 __first2, _ForwardIterator2 __last2)
1516{
1517 typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
1518 typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
1519 return _VSTD::search(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
1520}
1521
1522
1523#if _LIBCPP_STD_VER > 14
1524template <class _ForwardIterator, class _Searcher>
1525_LIBCPP_NODISCARD_EXT _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1526_ForwardIterator search(_ForwardIterator __f, _ForwardIterator __l, const _Searcher &__s)
1527{ return __s(__f, __l).first; }
1528#endif
1529
1530// search_n
1531
1532template <class _BinaryPredicate, class _ForwardIterator, class _Size, class _Tp>
1533_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
1534__search_n(_ForwardIterator __first, _ForwardIterator __last,
1535 _Size __count, const _Tp& __value_, _BinaryPredicate __pred, forward_iterator_tag)
1536{
1537 if (__count <= 0)
1538 return __first;
1539 while (true)
1540 {
1541 // Find first element in sequence that matchs __value_, with a mininum of loop checks
1542 while (true)
1543 {
1544 if (__first == __last) // return __last if no element matches __value_
1545 return __last;
1546 if (__pred(*__first, __value_))
1547 break;
1548 ++__first;
1549 }
1550 // *__first matches __value_, now match elements after here
1551 _ForwardIterator __m = __first;
1552 _Size __c(0);
1553 while (true)
1554 {
1555 if (++__c == __count) // If pattern exhausted, __first is the answer (works for 1 element pattern)
1556 return __first;
1557 if (++__m == __last) // Otherwise if source exhaused, pattern not found
1558 return __last;
1559 if (!__pred(*__m, __value_)) // if there is a mismatch, restart with a new __first
1560 {
1561 __first = __m;
1562 ++__first;
1563 break;
1564 } // else there is a match, check next elements
1565 }
1566 }
1567}
1568
1569template <class _BinaryPredicate, class _RandomAccessIterator, class _Size, class _Tp>
1570_LIBCPP_CONSTEXPR_AFTER_CXX17 _RandomAccessIterator
1571__search_n(_RandomAccessIterator __first, _RandomAccessIterator __last,
1572 _Size __count, const _Tp& __value_, _BinaryPredicate __pred, random_access_iterator_tag)
1573{
1574 if (__count <= 0)
1575 return __first;
1576 _Size __len = static_cast<_Size>(__last - __first);
1577 if (__len < __count)
1578 return __last;
1579 const _RandomAccessIterator __s = __last - (__count - 1); // Start of pattern match can't go beyond here
1580 while (true)
1581 {
1582 // Find first element in sequence that matchs __value_, with a mininum of loop checks
1583 while (true)
1584 {
1585 if (__first >= __s) // return __last if no element matches __value_
1586 return __last;
1587 if (__pred(*__first, __value_))
1588 break;
1589 ++__first;
1590 }
1591 // *__first matches __value_, now match elements after here
1592 _RandomAccessIterator __m = __first;
1593 _Size __c(0);
1594 while (true)
1595 {
1596 if (++__c == __count) // If pattern exhausted, __first is the answer (works for 1 element pattern)
1597 return __first;
1598 ++__m; // no need to check range on __m because __s guarantees we have enough source
1599 if (!__pred(*__m, __value_)) // if there is a mismatch, restart with a new __first
1600 {
1601 __first = __m;
1602 ++__first;
1603 break;
1604 } // else there is a match, check next elements
1605 }
1606 }
1607}
1608
1609template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
1610_LIBCPP_NODISCARD_EXT inline
1611_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1612_ForwardIterator
1613search_n(_ForwardIterator __first, _ForwardIterator __last,
1614 _Size __count, const _Tp& __value_, _BinaryPredicate __pred)
1615{
1616 return _VSTD::__search_n<typename add_lvalue_reference<_BinaryPredicate>::type>
1617 (__first, __last, __convert_to_integral(__count), __value_, __pred,
1618 typename iterator_traits<_ForwardIterator>::iterator_category());
1619}
1620
1621template <class _ForwardIterator, class _Size, class _Tp>
1622_LIBCPP_NODISCARD_EXT inline
1623_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1624_ForwardIterator
1625search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value_)
1626{
1627 typedef typename iterator_traits<_ForwardIterator>::value_type __v;
1628 return _VSTD::search_n(__first, __last, __convert_to_integral(__count),
1629 __value_, __equal_to<__v, _Tp>());
1630}
1631
1632// copy
1633template <class _Iter>
1634inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1635_Iter
1636__unwrap_iter(_Iter __i)
1637{
1638 return __i;
1639}
1640
1641template <class _Tp>
1642inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1643typename enable_if
1644<
1645 is_trivially_copy_assignable<_Tp>::value,
1646 _Tp*
1647>::type
1648__unwrap_iter(move_iterator<_Tp*> __i)
1649{
1650 return __i.base();
1651}
1652
1653#if _LIBCPP_DEBUG_LEVEL < 2
1654
1655template <class _Tp>
1656inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
1657typename enable_if
1658<
1659 is_trivially_copy_assignable<_Tp>::value,
1660 _Tp*
1661>::type
1662__unwrap_iter(__wrap_iter<_Tp*> __i)
1663{
1664 return __i.base();
1665}
1666
1667template <class _Tp>
1668inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
1669typename enable_if
1670<
1671 is_trivially_copy_assignable<_Tp>::value,
1672 const _Tp*
1673>::type
1674__unwrap_iter(__wrap_iter<const _Tp*> __i)
1675{
1676 return __i.base();
1677}
1678
1679#else
1680
1681template <class _Tp>
1682inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
1683typename enable_if
1684<
1685 is_trivially_copy_assignable<_Tp>::value,
1686 __wrap_iter<_Tp*>
1687>::type
1688__unwrap_iter(__wrap_iter<_Tp*> __i)
1689{
1690 return __i;
1691}
1692
1693#endif // _LIBCPP_DEBUG_LEVEL < 2
1694
1695template <class _InputIterator, class _OutputIterator>
1696inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1697_OutputIterator
1698__copy_constexpr(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
1699{
1700 for (; __first != __last; ++__first, (void) ++__result)
1701 *__result = *__first;
1702 return __result;
1703}
1704
1705template <class _InputIterator, class _OutputIterator>
1706inline _LIBCPP_INLINE_VISIBILITY
1707_OutputIterator
1708__copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
1709{
1710 return __copy_constexpr(__first, __last, __result);
1711}
1712
1713template <class _Tp, class _Up>
1714inline _LIBCPP_INLINE_VISIBILITY
1715typename enable_if
1716<
1717 is_same<typename remove_const<_Tp>::type, _Up>::value &&
1718 is_trivially_copy_assignable<_Up>::value,
1719 _Up*
1720>::type
1721__copy(_Tp* __first, _Tp* __last, _Up* __result)
1722{
1723 const size_t __n = static_cast<size_t>(__last - __first);
1724 if (__n > 0)
1725 _VSTD::memmove(__result, __first, __n * sizeof(_Up));
1726 return __result + __n;
1727}
1728
1729template <class _InputIterator, class _OutputIterator>
1730inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17_WITH_IS_CONSTANT_EVALUATED
1731_OutputIterator
1732copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
1733{
1734 if (__libcpp_is_constant_evaluated()) {
1735 return _VSTD::__copy_constexpr(
1736 __unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
1737 } else {
1738 return _VSTD::__copy(
1739 __unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
1740 }
1741}
1742
1743// copy_backward
1744
1745template <class _BidirectionalIterator, class _OutputIterator>
1746inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1747_OutputIterator
1748__copy_backward_constexpr(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result)
1749{
1750 while (__first != __last)
1751 *--__result = *--__last;
1752 return __result;
1753}
1754
1755template <class _BidirectionalIterator, class _OutputIterator>
1756inline _LIBCPP_INLINE_VISIBILITY
1757_OutputIterator
1758__copy_backward(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result)
1759{
1760 return __copy_backward_constexpr(__first, __last, __result);
1761}
1762
1763template <class _Tp, class _Up>
1764inline _LIBCPP_INLINE_VISIBILITY
1765typename enable_if
1766<
1767 is_same<typename remove_const<_Tp>::type, _Up>::value &&
1768 is_trivially_copy_assignable<_Up>::value,
1769 _Up*
1770>::type
1771__copy_backward(_Tp* __first, _Tp* __last, _Up* __result)
1772{
1773 const size_t __n = static_cast<size_t>(__last - __first);
1774 if (__n > 0)
1775 {
1776 __result -= __n;
1777 _VSTD::memmove(__result, __first, __n * sizeof(_Up));
1778 }
1779 return __result;
1780}
1781
1782template <class _BidirectionalIterator1, class _BidirectionalIterator2>
1783inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17_WITH_IS_CONSTANT_EVALUATED
1784_BidirectionalIterator2
1785copy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
1786 _BidirectionalIterator2 __result)
1787{
1788 if (__libcpp_is_constant_evaluated()) {
1789 return _VSTD::__copy_backward_constexpr(__unwrap_iter(__first),
1790 __unwrap_iter(__last),
1791 __unwrap_iter(__result));
1792 } else {
1793 return _VSTD::__copy_backward(__unwrap_iter(__first),
1794 __unwrap_iter(__last),
1795 __unwrap_iter(__result));
1796 }
1797}
1798
1799// copy_if
1800
1801template<class _InputIterator, class _OutputIterator, class _Predicate>
1802inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1803_OutputIterator
1804copy_if(_InputIterator __first, _InputIterator __last,
1805 _OutputIterator __result, _Predicate __pred)
1806{
1807 for (; __first != __last; ++__first)
1808 {
1809 if (__pred(*__first))
1810 {
1811 *__result = *__first;
1812 ++__result;
1813 }
1814 }
1815 return __result;
1816}
1817
1818// copy_n
1819
1820template<class _InputIterator, class _Size, class _OutputIterator>
1821inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17_WITH_IS_CONSTANT_EVALUATED
1822typename enable_if
1823<
1824 __is_cpp17_input_iterator<_InputIterator>::value &&
1825 !__is_cpp17_random_access_iterator<_InputIterator>::value,
1826 _OutputIterator
1827>::type
1828copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result)
1829{
1830 typedef decltype(__convert_to_integral(__orig_n)) _IntegralSize;
1831 _IntegralSize __n = __orig_n;
1832 if (__n > 0)
1833 {
1834 *__result = *__first;
1835 ++__result;
1836 for (--__n; __n > 0; --__n)
1837 {
1838 ++__first;
1839 *__result = *__first;
1840 ++__result;
1841 }
1842 }
1843 return __result;
1844}
1845
1846template<class _InputIterator, class _Size, class _OutputIterator>
1847inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17_WITH_IS_CONSTANT_EVALUATED
1848typename enable_if
1849<
1850 __is_cpp17_random_access_iterator<_InputIterator>::value,
1851 _OutputIterator
1852>::type
1853copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result)
1854{
1855 typedef decltype(__convert_to_integral(__orig_n)) _IntegralSize;
1856 _IntegralSize __n = __orig_n;
1857 return _VSTD::copy(__first, __first + __n, __result);
1858}
1859
1860// move
1861
1862template <class _InputIterator, class _OutputIterator>
1863inline _LIBCPP_INLINE_VISIBILITY
1864_OutputIterator
1865__move(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
1866{
1867 for (; __first != __last; ++__first, (void) ++__result)
1868 *__result = _VSTD::move(*__first);
1869 return __result;
1870}
1871
1872template <class _Tp, class _Up>
1873inline _LIBCPP_INLINE_VISIBILITY
1874typename enable_if
1875<
1876 is_same<typename remove_const<_Tp>::type, _Up>::value &&
1877 is_trivially_copy_assignable<_Up>::value,
1878 _Up*
1879>::type
1880__move(_Tp* __first, _Tp* __last, _Up* __result)
1881{
1882 const size_t __n = static_cast<size_t>(__last - __first);
1883 if (__n > 0)
1884 _VSTD::memmove(__result, __first, __n * sizeof(_Up));
1885 return __result + __n;
1886}
1887
1888template <class _InputIterator, class _OutputIterator>
1889inline _LIBCPP_INLINE_VISIBILITY
1890_OutputIterator
1891move(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
1892{
1893 return _VSTD::__move(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
1894}
1895
1896// move_backward
1897
1898template <class _InputIterator, class _OutputIterator>
1899inline _LIBCPP_INLINE_VISIBILITY
1900_OutputIterator
1901__move_backward(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
1902{
1903 while (__first != __last)
1904 *--__result = _VSTD::move(*--__last);
1905 return __result;
1906}
1907
1908template <class _Tp, class _Up>
1909inline _LIBCPP_INLINE_VISIBILITY
1910typename enable_if
1911<
1912 is_same<typename remove_const<_Tp>::type, _Up>::value &&
1913 is_trivially_copy_assignable<_Up>::value,
1914 _Up*
1915>::type
1916__move_backward(_Tp* __first, _Tp* __last, _Up* __result)
1917{
1918 const size_t __n = static_cast<size_t>(__last - __first);
1919 if (__n > 0)
1920 {
1921 __result -= __n;
1922 _VSTD::memmove(__result, __first, __n * sizeof(_Up));
1923 }
1924 return __result;
1925}
1926
1927template <class _BidirectionalIterator1, class _BidirectionalIterator2>
1928inline _LIBCPP_INLINE_VISIBILITY
1929_BidirectionalIterator2
1930move_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
1931 _BidirectionalIterator2 __result)
1932{
1933 return _VSTD::__move_backward(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
1934}
1935
1936// iter_swap
1937
1938// moved to <type_traits> for better swap / noexcept support
1939
1940// transform
1941
1942template <class _InputIterator, class _OutputIterator, class _UnaryOperation>
1943inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1944_OutputIterator
1945transform(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _UnaryOperation __op)
1946{
1947 for (; __first != __last; ++__first, (void) ++__result)
1948 *__result = __op(*__first);
1949 return __result;
1950}
1951
1952template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _BinaryOperation>
1953inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1954_OutputIterator
1955transform(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2,
1956 _OutputIterator __result, _BinaryOperation __binary_op)
1957{
1958 for (; __first1 != __last1; ++__first1, (void) ++__first2, ++__result)
1959 *__result = __binary_op(*__first1, *__first2);
1960 return __result;
1961}
1962
1963// replace
1964
1965template <class _ForwardIterator, class _Tp>
1966inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1967void
1968replace(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value, const _Tp& __new_value)
1969{
1970 for (; __first != __last; ++__first)
1971 if (*__first == __old_value)
1972 *__first = __new_value;
1973}
1974
1975// replace_if
1976
1977template <class _ForwardIterator, class _Predicate, class _Tp>
1978inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1979void
1980replace_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, const _Tp& __new_value)
1981{
1982 for (; __first != __last; ++__first)
1983 if (__pred(*__first))
1984 *__first = __new_value;
1985}
1986
1987// replace_copy
1988
1989template <class _InputIterator, class _OutputIterator, class _Tp>
1990inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
1991_OutputIterator
1992replace_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
1993 const _Tp& __old_value, const _Tp& __new_value)
1994{
1995 for (; __first != __last; ++__first, (void) ++__result)
1996 if (*__first == __old_value)
1997 *__result = __new_value;
1998 else
1999 *__result = *__first;
2000 return __result;
2001}
2002
2003// replace_copy_if
2004
2005template <class _InputIterator, class _OutputIterator, class _Predicate, class _Tp>
2006inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
2007_OutputIterator
2008replace_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
2009 _Predicate __pred, const _Tp& __new_value)
2010{
2011 for (; __first != __last; ++__first, (void) ++__result)
2012 if (__pred(*__first))
2013 *__result = __new_value;
2014 else
2015 *__result = *__first;
2016 return __result;
2017}
2018
2019// fill_n
2020
2021template <class _OutputIterator, class _Size, class _Tp>
2022inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
2023_OutputIterator
2024__fill_n(_OutputIterator __first, _Size __n, const _Tp& __value_)
2025{
2026 for (; __n > 0; ++__first, (void) --__n)
2027 *__first = __value_;
2028 return __first;
2029}
2030
2031template <class _OutputIterator, class _Size, class _Tp>
2032inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
2033_OutputIterator
2034fill_n(_OutputIterator __first, _Size __n, const _Tp& __value_)
2035{
2036 return _VSTD::__fill_n(__first, __convert_to_integral(__n), __value_);
2037}
2038
2039// fill
2040
2041template <class _ForwardIterator, class _Tp>
2042inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
2043void
2044__fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, forward_iterator_tag)
2045{
2046 for (; __first != __last; ++__first)
2047 *__first = __value_;
2048}
2049
2050template <class _RandomAccessIterator, class _Tp>
2051inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
2052void
2053__fill(_RandomAccessIterator __first, _RandomAccessIterator __last, const _Tp& __value_, random_access_iterator_tag)
2054{
2055 _VSTD::fill_n(__first, __last - __first, __value_);
2056}
2057
2058template <class _ForwardIterator, class _Tp>
2059inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
2060void
2061fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
2062{
2063 _VSTD::__fill(__first, __last, __value_, typename iterator_traits<_ForwardIterator>::iterator_category());
2064}
2065
2066// generate
2067
2068template <class _ForwardIterator, class _Generator>
2069inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
2070void
2071generate(_ForwardIterator __first, _ForwardIterator __last, _Generator __gen)
2072{
2073 for (; __first != __last; ++__first)
2074 *__first = __gen();
2075}
2076
2077// generate_n
2078
2079template <class _OutputIterator, class _Size, class _Generator>
2080inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
2081_OutputIterator
2082generate_n(_OutputIterator __first, _Size __orig_n, _Generator __gen)
2083{
2084 typedef decltype(__convert_to_integral(__orig_n)) _IntegralSize;
2085 _IntegralSize __n = __orig_n;
2086 for (; __n > 0; ++__first, (void) --__n)
2087 *__first = __gen();
2088 return __first;
2089}
2090
2091// remove
2092
2093template <class _ForwardIterator, class _Tp>
2094_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
2095remove(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
2096{
2097 __first = _VSTD::find(__first, __last, __value_);
2098 if (__first != __last)
2099 {
2100 _ForwardIterator __i = __first;
2101 while (++__i != __last)
2102 {
2103 if (!(*__i == __value_))
2104 {
2105 *__first = _VSTD::move(*__i);
2106 ++__first;
2107 }
2108 }
2109 }
2110 return __first;
2111}
2112
2113// remove_if
2114
2115template <class _ForwardIterator, class _Predicate>
2116_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
2117remove_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
2118{
2119 __first = _VSTD::find_if<_ForwardIterator, typename add_lvalue_reference<_Predicate>::type>
2120 (__first, __last, __pred);
2121 if (__first != __last)
2122 {
2123 _ForwardIterator __i = __first;
2124 while (++__i != __last)
2125 {
2126 if (!__pred(*__i))
2127 {
2128 *__first = _VSTD::move(*__i);
2129 ++__first;
2130 }
2131 }
2132 }
2133 return __first;
2134}
2135
2136// remove_copy
2137
2138template <class _InputIterator, class _OutputIterator, class _Tp>
2139inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
2140_OutputIterator
2141remove_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, const _Tp& __value_)
2142{
2143 for (; __first != __last; ++__first)
2144 {
2145 if (!(*__first == __value_))
2146 {
2147 *__result = *__first;
2148 ++__result;
2149 }
2150 }
2151 return __result;
2152}
2153
2154// remove_copy_if
2155
2156template <class _InputIterator, class _OutputIterator, class _Predicate>
2157inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
2158_OutputIterator
2159remove_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred)
2160{
2161 for (; __first != __last; ++__first)
2162 {
2163 if (!__pred(*__first))
2164 {
2165 *__result = *__first;
2166 ++__result;
2167 }
2168 }
2169 return __result;
2170}
2171
2172// unique
2173
2174template <class _ForwardIterator, class _BinaryPredicate>
2175_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
2176unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred)
2177{
2178 __first = _VSTD::adjacent_find<_ForwardIterator, typename add_lvalue_reference<_BinaryPredicate>::type>
2179 (__first, __last, __pred);
2180 if (__first != __last)
2181 {
2182 // ... a a ? ...
2183 // f i
2184 _ForwardIterator __i = __first;
2185 for (++__i; ++__i != __last;)
2186 if (!__pred(*__first, *__i))
2187 *++__first = _VSTD::move(*__i);
2188 ++__first;
2189 }
2190 return __first;
2191}
2192
2193template <class _ForwardIterator>
2194_LIBCPP_NODISCARD_EXT inline
2195_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
2196_ForwardIterator
2197unique(_ForwardIterator __first, _ForwardIterator __last)
2198{
2199 typedef typename iterator_traits<_ForwardIterator>::value_type __v;
2200 return _VSTD::unique(__first, __last, __equal_to<__v>());
2201}
2202
2203// unique_copy
2204
2205template <class _BinaryPredicate, class _InputIterator, class _OutputIterator>
2206_LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator
2207__unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __pred,
2208 input_iterator_tag, output_iterator_tag)
2209{
2210 if (__first != __last)
2211 {
2212 typename iterator_traits<_InputIterator>::value_type __t(*__first);
2213 *__result = __t;
2214 ++__result;
2215 while (++__first != __last)
2216 {
2217 if (!__pred(__t, *__first))
2218 {
2219 __t = *__first;
2220 *__result = __t;
2221 ++__result;
2222 }
2223 }
2224 }
2225 return __result;
2226}
2227
2228template <class _BinaryPredicate, class _ForwardIterator, class _OutputIterator>
2229_LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator
2230__unique_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _BinaryPredicate __pred,
2231 forward_iterator_tag, output_iterator_tag)
2232{
2233 if (__first != __last)
2234 {
2235 _ForwardIterator __i = __first;
2236 *__result = *__i;
2237 ++__result;
2238 while (++__first != __last)
2239 {
2240 if (!__pred(*__i, *__first))
2241 {
2242 *__result = *__first;
2243 ++__result;
2244 __i = __first;
2245 }
2246 }
2247 }
2248 return __result;
2249}
2250
2251template <class _BinaryPredicate, class _InputIterator, class _ForwardIterator>
2252_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
2253__unique_copy(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _BinaryPredicate __pred,
2254 input_iterator_tag, forward_iterator_tag)
2255{
2256 if (__first != __last)
2257 {
2258 *__result = *__first;
2259 while (++__first != __last)
2260 if (!__pred(*__result, *__first))
2261 *++__result = *__first;
2262 ++__result;
2263 }
2264 return __result;
2265}
2266
2267template <class _InputIterator, class _OutputIterator, class _BinaryPredicate>
2268inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
2269_OutputIterator
2270unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __pred)
2271{
2272 return _VSTD::__unique_copy<typename add_lvalue_reference<_BinaryPredicate>::type>
2273 (__first, __last, __result, __pred,
2274 typename iterator_traits<_InputIterator>::iterator_category(),
2275 typename iterator_traits<_OutputIterator>::iterator_category());
2276}
2277
2278template <class _InputIterator, class _OutputIterator>
2279inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
2280_OutputIterator
2281unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
2282{
2283 typedef typename iterator_traits<_InputIterator>::value_type __v;
2284 return _VSTD::unique_copy(__first, __last, __result, __equal_to<__v>());
2285}
2286
2287// reverse
2288
2289template <class _BidirectionalIterator>
2290inline _LIBCPP_INLINE_VISIBILITY
2291void
2292__reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, bidirectional_iterator_tag)
2293{
2294 while (__first != __last)
2295 {
2296 if (__first == --__last)
2297 break;
2298 _VSTD::iter_swap(__first, __last);
2299 ++__first;
2300 }
2301}
2302
2303template <class _RandomAccessIterator>
2304inline _LIBCPP_INLINE_VISIBILITY
2305void
2306__reverse(_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag)
2307{
2308 if (__first != __last)
2309 for (; __first < --__last; ++__first)
2310 _VSTD::iter_swap(__first, __last);
2311}
2312
2313template <class _BidirectionalIterator>
2314inline _LIBCPP_INLINE_VISIBILITY
2315void
2316reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
2317{
2318 _VSTD::__reverse(__first, __last, typename iterator_traits<_BidirectionalIterator>::iterator_category());
2319}
2320
2321// reverse_copy
2322
2323template <class _BidirectionalIterator, class _OutputIterator>
2324inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
2325_OutputIterator
2326reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result)
2327{
2328 for (; __first != __last; ++__result)
2329 *__result = *--__last;
2330 return __result;
2331}
2332
2333// rotate
2334
2335template <class _ForwardIterator>
2336_ForwardIterator
2337__rotate_left(_ForwardIterator __first, _ForwardIterator __last)
2338{
2339 typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
2340 value_type __tmp = _VSTD::move(*__first);
2341 _ForwardIterator __lm1 = _VSTD::move(_VSTD::next(__first), __last, __first);
2342 *__lm1 = _VSTD::move(__tmp);
2343 return __lm1;
2344}
2345
2346template <class _BidirectionalIterator>
2347_BidirectionalIterator
2348__rotate_right(_BidirectionalIterator __first, _BidirectionalIterator __last)
2349{
2350 typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
2351 _BidirectionalIterator __lm1 = _VSTD::prev(__last);
2352 value_type __tmp = _VSTD::move(*__lm1);
2353 _BidirectionalIterator __fp1 = _VSTD::move_backward(__first, __lm1, __last);
2354 *__first = _VSTD::move(__tmp);
2355 return __fp1;
2356}
2357
2358template <class _ForwardIterator>
2359_ForwardIterator
2360__rotate_forward(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last)
2361{
2362 _ForwardIterator __i = __middle;
2363 while (true)
2364 {
2365 swap(*__first, *__i);
2366 ++__first;
2367 if (++__i == __last)
2368 break;
2369 if (__first == __middle)
2370 __middle = __i;
2371 }
2372 _ForwardIterator __r = __first;
2373 if (__first != __middle)
2374 {
2375 __i = __middle;
2376 while (true)
2377 {
2378 swap(*__first, *__i);
2379 ++__first;
2380 if (++__i == __last)
2381 {
2382 if (__first == __middle)
2383 break;
2384 __i = __middle;
2385 }
2386 else if (__first == __middle)
2387 __middle = __i;
2388 }
2389 }
2390 return __r;
2391}
2392
2393template<typename _Integral>
2394inline _LIBCPP_INLINE_VISIBILITY
2395_Integral
2396__algo_gcd(_Integral __x, _Integral __y)
2397{
2398 do
2399 {
2400 _Integral __t = __x % __y;
2401 __x = __y;
2402 __y = __t;
2403 } while (__y);
2404 return __x;
2405}
2406
2407template<typename _RandomAccessIterator>
2408_RandomAccessIterator
2409__rotate_gcd(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last)
2410{
2411 typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
2412 typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
2413
2414 const difference_type __m1 = __middle - __first;
2415 const difference_type __m2 = __last - __middle;
2416 if (__m1 == __m2)
2417 {
2418 _VSTD::swap_ranges(__first, __middle, __middle);
2419 return __middle;
2420 }
2421 const difference_type __g = _VSTD::__algo_gcd(__m1, __m2);
2422 for (_RandomAccessIterator __p = __first + __g; __p != __first;)
2423 {
2424 value_type __t(_VSTD::move(*--__p));
2425 _RandomAccessIterator __p1 = __p;
2426 _RandomAccessIterator __p2 = __p1 + __m1;
2427 do
2428 {
2429 *__p1 = _VSTD::move(*__p2);
2430 __p1 = __p2;
2431 const difference_type __d = __last - __p2;
2432 if (__m1 < __d)
2433 __p2 += __m1;
2434 else
2435 __p2 = __first + (__m1 - __d);
2436 } while (__p2 != __p);
2437 *__p1 = _VSTD::move(__t);
2438 }
2439 return __first + __m2;
2440}
2441
2442template <class _ForwardIterator>
2443inline _LIBCPP_INLINE_VISIBILITY
2444_ForwardIterator
2445__rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
2446 _VSTD::forward_iterator_tag)
2447{
2448 typedef typename _VSTD::iterator_traits<_ForwardIterator>::value_type value_type;
2449 if (_VSTD::is_trivially_move_assignable<value_type>::value)
2450 {
2451 if (_VSTD::next(__first) == __middle)
2452 return _VSTD::__rotate_left(__first, __last);
2453 }
2454 return _VSTD::__rotate_forward(__first, __middle, __last);
2455}
2456
2457template <class _BidirectionalIterator>
2458inline _LIBCPP_INLINE_VISIBILITY
2459_BidirectionalIterator
2460__rotate(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
2461 _VSTD::bidirectional_iterator_tag)
2462{
2463 typedef typename _VSTD::iterator_traits<_BidirectionalIterator>::value_type value_type;
2464 if (_VSTD::is_trivially_move_assignable<value_type>::value)
2465 {
2466 if (_VSTD::next(__first) == __middle)
2467 return _VSTD::__rotate_left(__first, __last);
2468 if (_VSTD::next(__middle) == __last)
2469 return _VSTD::__rotate_right(__first, __last);
2470 }
2471 return _VSTD::__rotate_forward(__first, __middle, __last);
2472}
2473
2474template <class _RandomAccessIterator>
2475inline _LIBCPP_INLINE_VISIBILITY
2476_RandomAccessIterator
2477__rotate(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last,
2478 _VSTD::random_access_iterator_tag)
2479{
2480 typedef typename _VSTD::iterator_traits<_RandomAccessIterator>::value_type value_type;
2481 if (_VSTD::is_trivially_move_assignable<value_type>::value)
2482 {
2483 if (_VSTD::next(__first) == __middle)
2484 return _VSTD::__rotate_left(__first, __last);
2485 if (_VSTD::next(__middle) == __last)
2486 return _VSTD::__rotate_right(__first, __last);
2487 return _VSTD::__rotate_gcd(__first, __middle, __last);
2488 }
2489 return _VSTD::__rotate_forward(__first, __middle, __last);
2490}
2491
2492template <class _ForwardIterator>
2493inline _LIBCPP_INLINE_VISIBILITY
2494_ForwardIterator
2495rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last)
2496{
2497 if (__first == __middle)
2498 return __last;
2499 if (__middle == __last)
2500 return __first;
2501 return _VSTD::__rotate(__first, __middle, __last,
2502 typename _VSTD::iterator_traits<_ForwardIterator>::iterator_category());
2503}
2504
2505// rotate_copy
2506
2507template <class _ForwardIterator, class _OutputIterator>
2508inline _LIBCPP_INLINE_VISIBILITY
2509_OutputIterator
2510rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, _OutputIterator __result)
2511{
2512 return _VSTD::copy(__first, __middle, _VSTD::copy(__middle, __last, __result));
2513}
2514
2515// min_element
2516
2517template <class _ForwardIterator, class _Compare>
2518_LIBCPP_NODISCARD_EXT inline
2519_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
2520_ForwardIterator
2521min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
2522{
2523 static_assert(__is_cpp17_forward_iterator<_ForwardIterator>::value,
2524 "std::min_element requires a ForwardIterator");
2525 if (__first != __last)
2526 {
2527 _ForwardIterator __i = __first;
2528 while (++__i != __last)
2529 if (__comp(*__i, *__first))
2530 __first = __i;
2531 }
2532 return __first;
2533}
2534
2535template <class _ForwardIterator>
2536_LIBCPP_NODISCARD_EXT inline
2537_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
2538_ForwardIterator
2539min_element(_ForwardIterator __first, _ForwardIterator __last)
2540{
2541 return _VSTD::min_element(__first, __last,
2542 __less<typename iterator_traits<_ForwardIterator>::value_type>());
2543}
2544
2545// min
2546
2547template <class _Tp, class _Compare>
2548_LIBCPP_NODISCARD_EXT inline
2549_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
2550const _Tp&
2551min(const _Tp& __a, const _Tp& __b, _Compare __comp)
2552{
2553 return __comp(__b, __a) ? __b : __a;
2554}
2555
2556template <class _Tp>
2557_LIBCPP_NODISCARD_EXT inline
2558_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
2559const _Tp&
2560min(const _Tp& __a, const _Tp& __b)
2561{
2562 return _VSTD::min(__a, __b, __less<_Tp>());
2563}
2564
2565#ifndef _LIBCPP_CXX03_LANG
2566
2567template<class _Tp, class _Compare>
2568_LIBCPP_NODISCARD_EXT inline
2569_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
2570_Tp
2571min(initializer_list<_Tp> __t, _Compare __comp)
2572{
2573 return *_VSTD::min_element(__t.begin(), __t.end(), __comp);
2574}
2575
2576template<class _Tp>
2577_LIBCPP_NODISCARD_EXT inline
2578_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
2579_Tp
2580min(initializer_list<_Tp> __t)
2581{
2582 return *_VSTD::min_element(__t.begin(), __t.end(), __less<_Tp>());
2583}
2584
2585#endif // _LIBCPP_CXX03_LANG
2586
2587// max_element
2588
2589template <class _ForwardIterator, class _Compare>
2590_LIBCPP_NODISCARD_EXT inline
2591_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
2592_ForwardIterator
2593max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
2594{
2595 static_assert(__is_cpp17_forward_iterator<_ForwardIterator>::value,
2596 "std::max_element requires a ForwardIterator");
2597 if (__first != __last)
2598 {
2599 _ForwardIterator __i = __first;
2600 while (++__i != __last)
2601 if (__comp(*__first, *__i))
2602 __first = __i;
2603 }
2604 return __first;
2605}
2606
2607
2608template <class _ForwardIterator>
2609_LIBCPP_NODISCARD_EXT inline
2610_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
2611_ForwardIterator
2612max_element(_ForwardIterator __first, _ForwardIterator __last)
2613{
2614 return _VSTD::max_element(__first, __last,
2615 __less<typename iterator_traits<_ForwardIterator>::value_type>());
2616}
2617
2618// max
2619
2620template <class _Tp, class _Compare>
2621_LIBCPP_NODISCARD_EXT inline
2622_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
2623const _Tp&
2624max(const _Tp& __a, const _Tp& __b, _Compare __comp)
2625{
2626 return __comp(__a, __b) ? __b : __a;
2627}
2628
2629template <class _Tp>
2630_LIBCPP_NODISCARD_EXT inline
2631_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
2632const _Tp&
2633max(const _Tp& __a, const _Tp& __b)
2634{
2635 return _VSTD::max(__a, __b, __less<_Tp>());
2636}
2637
2638#ifndef _LIBCPP_CXX03_LANG
2639
2640template<class _Tp, class _Compare>
2641_LIBCPP_NODISCARD_EXT inline
2642_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
2643_Tp
2644max(initializer_list<_Tp> __t, _Compare __comp)
2645{
2646 return *_VSTD::max_element(__t.begin(), __t.end(), __comp);
2647}
2648
2649template<class _Tp>
2650_LIBCPP_NODISCARD_EXT inline
2651_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
2652_Tp
2653max(initializer_list<_Tp> __t)
2654{
2655 return *_VSTD::max_element(__t.begin(), __t.end(), __less<_Tp>());
2656}
2657
2658#endif // _LIBCPP_CXX03_LANG
2659
2660#if _LIBCPP_STD_VER > 14
2661// clamp
2662template<class _Tp, class _Compare>
2663_LIBCPP_NODISCARD_EXT inline
2664_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
2665const _Tp&
2666clamp(const _Tp& __v, const _Tp& __lo, const _Tp& __hi, _Compare __comp)
2667{
2668 _LIBCPP_ASSERT(!__comp(__hi, __lo), "Bad bounds passed to std::clamp");
2669 return __comp(__v, __lo) ? __lo : __comp(__hi, __v) ? __hi : __v;
2670
2671}
2672
2673template<class _Tp>
2674_LIBCPP_NODISCARD_EXT inline
2675_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
2676const _Tp&
2677clamp(const _Tp& __v, const _Tp& __lo, const _Tp& __hi)
2678{
2679 return _VSTD::clamp(__v, __lo, __hi, __less<_Tp>());
2680}
2681#endif
2682
2683// minmax_element
2684
2685template <class _ForwardIterator, class _Compare>
2686_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_AFTER_CXX11
2687std::pair<_ForwardIterator, _ForwardIterator>
2688minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
2689{
2690 static_assert(__is_cpp17_forward_iterator<_ForwardIterator>::value,
2691 "std::minmax_element requires a ForwardIterator");
2692 std::pair<_ForwardIterator, _ForwardIterator> __result(__first, __first);
2693 if (__first != __last)
2694 {
2695 if (++__first != __last)
2696 {
2697 if (__comp(*__first, *__result.first))
2698 __result.first = __first;
2699 else
2700 __result.second = __first;
2701 while (++__first != __last)
2702 {
2703 _ForwardIterator __i = __first;
2704 if (++__first == __last)
2705 {
2706 if (__comp(*__i, *__result.first))
2707 __result.first = __i;
2708 else if (!__comp(*__i, *__result.second))
2709 __result.second = __i;
2710 break;
2711 }
2712 else
2713 {
2714 if (__comp(*__first, *__i))
2715 {
2716 if (__comp(*__first, *__result.first))
2717 __result.first = __first;
2718 if (!__comp(*__i, *__result.second))
2719 __result.second = __i;
2720 }
2721 else
2722 {
2723 if (__comp(*__i, *__result.first))
2724 __result.first = __i;
2725 if (!__comp(*__first, *__result.second))
2726 __result.second = __first;
2727 }
2728 }
2729 }
2730 }
2731 }
2732 return __result;
2733}
2734
2735template <class _ForwardIterator>
2736_LIBCPP_NODISCARD_EXT inline
2737_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
2738std::pair<_ForwardIterator, _ForwardIterator>
2739minmax_element(_ForwardIterator __first, _ForwardIterator __last)
2740{
2741 return _VSTD::minmax_element(__first, __last,
2742 __less<typename iterator_traits<_ForwardIterator>::value_type>());
2743}
2744
2745// minmax
2746
2747template<class _Tp, class _Compare>
2748_LIBCPP_NODISCARD_EXT inline
2749_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
2750pair<const _Tp&, const _Tp&>
2751minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
2752{
2753 return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a) :
2754 pair<const _Tp&, const _Tp&>(__a, __b);
2755}
2756
2757template<class _Tp>
2758_LIBCPP_NODISCARD_EXT inline
2759_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
2760pair<const _Tp&, const _Tp&>
2761minmax(const _Tp& __a, const _Tp& __b)
2762{
2763 return _VSTD::minmax(__a, __b, __less<_Tp>());
2764}
2765
2766#ifndef _LIBCPP_CXX03_LANG
2767
2768template<class _Tp, class _Compare>
2769_LIBCPP_NODISCARD_EXT inline
2770_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
2771pair<_Tp, _Tp>
2772minmax(initializer_list<_Tp> __t, _Compare __comp)
2773{
2774 typedef typename initializer_list<_Tp>::const_iterator _Iter;
2775 _Iter __first = __t.begin();
2776 _Iter __last = __t.end();
2777 std::pair<_Tp, _Tp> __result(*__first, *__first);
2778
2779 ++__first;
2780 if (__t.size() % 2 == 0)
2781 {
2782 if (__comp(*__first, __result.first))
2783 __result.first = *__first;
2784 else
2785 __result.second = *__first;
2786 ++__first;
2787 }
2788
2789 while (__first != __last)
2790 {
2791 _Tp __prev = *__first++;
2792 if (__comp(*__first, __prev)) {
2793 if ( __comp(*__first, __result.first)) __result.first = *__first;
2794 if (!__comp(__prev, __result.second)) __result.second = __prev;
2795 }
2796 else {
2797 if ( __comp(__prev, __result.first)) __result.first = __prev;
2798 if (!__comp(*__first, __result.second)) __result.second = *__first;
2799 }
2800
2801 __first++;
2802 }
2803 return __result;
2804}
2805
2806template<class _Tp>
2807_LIBCPP_NODISCARD_EXT inline
2808_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
2809pair<_Tp, _Tp>
2810minmax(initializer_list<_Tp> __t)
2811{
2812 return _VSTD::minmax(__t, __less<_Tp>());
2813}
2814
2815#endif // _LIBCPP_CXX03_LANG
2816
2817// random_shuffle
2818
2819// __independent_bits_engine
2820
2821template <unsigned long long _Xp, size_t _Rp>
2822struct __log2_imp
2823{
2824 static const size_t value = _Xp & ((unsigned long long)(1) << _Rp) ? _Rp
2825 : __log2_imp<_Xp, _Rp - 1>::value;
2826};
2827
2828template <unsigned long long _Xp>
2829struct __log2_imp<_Xp, 0>
2830{
2831 static const size_t value = 0;
2832};
2833
2834template <size_t _Rp>
2835struct __log2_imp<0, _Rp>
2836{
2837 static const size_t value = _Rp + 1;
2838};
2839
2840template <class _UIntType, _UIntType _Xp>
2841struct __log2
2842{
2843 static const size_t value = __log2_imp<_Xp,
2844 sizeof(_UIntType) * __CHAR_BIT__ - 1>::value;
2845};
2846
2847template<class _Engine, class _UIntType>
2848class __independent_bits_engine
2849{
2850public:
2851 // types
2852 typedef _UIntType result_type;
2853
2854private:
2855 typedef typename _Engine::result_type _Engine_result_type;
2856 typedef typename conditional
2857 <
2858 sizeof(_Engine_result_type) <= sizeof(result_type),
2859 result_type,
2860 _Engine_result_type
2861 >::type _Working_result_type;
2862
2863 _Engine& __e_;
2864 size_t __w_;
2865 size_t __w0_;
2866 size_t __n_;
2867 size_t __n0_;
2868 _Working_result_type __y0_;
2869 _Working_result_type __y1_;
2870 _Engine_result_type __mask0_;
2871 _Engine_result_type __mask1_;
2872
2873#ifdef _LIBCPP_CXX03_LANG
2874 static const _Working_result_type _Rp = _Engine::_Max - _Engine::_Min
2875 + _Working_result_type(1);
2876#else
2877 static _LIBCPP_CONSTEXPR const _Working_result_type _Rp = _Engine::max() - _Engine::min()
2878 + _Working_result_type(1);
2879#endif
2880 static _LIBCPP_CONSTEXPR const size_t __m = __log2<_Working_result_type, _Rp>::value;
2881 static _LIBCPP_CONSTEXPR const size_t _WDt = numeric_limits<_Working_result_type>::digits;
2882 static _LIBCPP_CONSTEXPR const size_t _EDt = numeric_limits<_Engine_result_type>::digits;
2883
2884public:
2885 // constructors and seeding functions
2886 __independent_bits_engine(_Engine& __e, size_t __w);
2887
2888 // generating functions
2889 result_type operator()() {return __eval(integral_constant<bool, _Rp != 0>());}
2890
2891private:
2892 result_type __eval(false_type);
2893 result_type __eval(true_type);
2894};
2895
2896template<class _Engine, class _UIntType>
2897__independent_bits_engine<_Engine, _UIntType>
2898 ::__independent_bits_engine(_Engine& __e, size_t __w)
2899 : __e_(__e),
2900 __w_(__w)
2901{
2902 __n_ = __w_ / __m + (__w_ % __m != 0);
2903 __w0_ = __w_ / __n_;
2904 if (_Rp == 0)
2905 __y0_ = _Rp;
2906 else if (__w0_ < _WDt)
2907 __y0_ = (_Rp >> __w0_) << __w0_;
2908 else
2909 __y0_ = 0;
2910 if (_Rp - __y0_ > __y0_ / __n_)
2911 {
2912 ++__n_;
2913 __w0_ = __w_ / __n_;
2914 if (__w0_ < _WDt)
2915 __y0_ = (_Rp >> __w0_) << __w0_;
2916 else
2917 __y0_ = 0;
2918 }
2919 __n0_ = __n_ - __w_ % __n_;
2920 if (__w0_ < _WDt - 1)
2921 __y1_ = (_Rp >> (__w0_ + 1)) << (__w0_ + 1);
2922 else
2923 __y1_ = 0;
2924 __mask0_ = __w0_ > 0 ? _Engine_result_type(~0) >> (_EDt - __w0_) :
2925 _Engine_result_type(0);
2926 __mask1_ = __w0_ < _EDt - 1 ?
2927 _Engine_result_type(~0) >> (_EDt - (__w0_ + 1)) :
2928 _Engine_result_type(~0);
2929}
2930
2931template<class _Engine, class _UIntType>
2932inline
2933_UIntType
2934__independent_bits_engine<_Engine, _UIntType>::__eval(false_type)
2935{
2936 return static_cast<result_type>(__e_() & __mask0_);
2937}
2938
2939template<class _Engine, class _UIntType>
2940_UIntType
2941__independent_bits_engine<_Engine, _UIntType>::__eval(true_type)
2942{
2943 const size_t _WRt = numeric_limits<result_type>::digits;
2944 result_type _Sp = 0;
2945 for (size_t __k = 0; __k < __n0_; ++__k)
2946 {
2947 _Engine_result_type __u;
2948 do
2949 {
2950 __u = __e_() - _Engine::min();
2951 } while (__u >= __y0_);
2952 if (__w0_ < _WRt)
2953 _Sp <<= __w0_;
2954 else
2955 _Sp = 0;
2956 _Sp += __u & __mask0_;
2957 }
2958 for (size_t __k = __n0_; __k < __n_; ++__k)
2959 {
2960 _Engine_result_type __u;
2961 do
2962 {
2963 __u = __e_() - _Engine::min();
2964 } while (__u >= __y1_);
2965 if (__w0_ < _WRt - 1)
2966 _Sp <<= __w0_ + 1;
2967 else
2968 _Sp = 0;
2969 _Sp += __u & __mask1_;
2970 }
2971 return _Sp;
2972}
2973
2974// uniform_int_distribution
2975
2976template<class _IntType = int>
2977class uniform_int_distribution
2978{
2979public:
2980 // types
2981 typedef _IntType result_type;
2982
2983 class param_type
2984 {
2985 result_type __a_;
2986 result_type __b_;
2987 public:
2988 typedef uniform_int_distribution distribution_type;
2989
2990 explicit param_type(result_type __a = 0,
2991 result_type __b = numeric_limits<result_type>::max())
2992 : __a_(__a), __b_(__b) {}
2993
2994 result_type a() const {return __a_;}
2995 result_type b() const {return __b_;}
2996
2997 friend bool operator==(const param_type& __x, const param_type& __y)
2998 {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
2999 friend bool operator!=(const param_type& __x, const param_type& __y)
3000 {return !(__x == __y);}
3001 };
3002
3003private:
3004 param_type __p_;
3005
3006public:
3007 // constructors and reset functions
3008 explicit uniform_int_distribution(result_type __a = 0,
3009 result_type __b = numeric_limits<result_type>::max())
3010 : __p_(param_type(__a, __b)) {}
3011 explicit uniform_int_distribution(const param_type& __p) : __p_(__p) {}
3012 void reset() {}
3013
3014 // generating functions
3015 template<class _URNG> result_type operator()(_URNG& __g)
3016 {return (*this)(__g, __p_);}
3017 template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
3018
3019 // property functions
3020 result_type a() const {return __p_.a();}
3021 result_type b() const {return __p_.b();}
3022
3023 param_type param() const {return __p_;}
3024 void param(const param_type& __p) {__p_ = __p;}
3025
3026 result_type min() const {return a();}
3027 result_type max() const {return b();}
3028
3029 friend bool operator==(const uniform_int_distribution& __x,
3030 const uniform_int_distribution& __y)
3031 {return __x.__p_ == __y.__p_;}
3032 friend bool operator!=(const uniform_int_distribution& __x,
3033 const uniform_int_distribution& __y)
3034 {return !(__x == __y);}
3035};
3036
3037template<class _IntType>
3038template<class _URNG>
3039typename uniform_int_distribution<_IntType>::result_type
3040uniform_int_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p)
3041_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
3042{
3043 typedef typename conditional<sizeof(result_type) <= sizeof(uint32_t),
3044 uint32_t, uint64_t>::type _UIntType;
3045 const _UIntType _Rp = _UIntType(__p.b()) - _UIntType(__p.a()) + _UIntType(1);
3046 if (_Rp == 1)
3047 return __p.a();
3048 const size_t _Dt = numeric_limits<_UIntType>::digits;
3049 typedef __independent_bits_engine<_URNG, _UIntType> _Eng;
3050 if (_Rp == 0)
3051 return static_cast<result_type>(_Eng(__g, _Dt)());
3052 size_t __w = _Dt - __libcpp_clz(_Rp) - 1;
3053 if ((_Rp & (std::numeric_limits<_UIntType>::max() >> (_Dt - __w))) != 0)
3054 ++__w;
3055 _Eng __e(__g, __w);
3056 _UIntType __u;
3057 do
3058 {
3059 __u = __e();
3060 } while (__u >= _Rp);
3061 return static_cast<result_type>(__u + __p.a());
3062}
3063
3064#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE) \
3065 || defined(_LIBCPP_BUILDING_LIBRARY)
3066class _LIBCPP_TYPE_VIS __rs_default;
3067
3068_LIBCPP_FUNC_VIS __rs_default __rs_get();
3069
3070class _LIBCPP_TYPE_VIS __rs_default
3071{
3072 static unsigned __c_;
3073
3074 __rs_default();
3075public:
3076 typedef uint_fast32_t result_type;
3077
3078 static const result_type _Min = 0;
3079 static const result_type _Max = 0xFFFFFFFF;
3080
3081 __rs_default(const __rs_default&);
3082 ~__rs_default();
3083
3084 result_type operator()();
3085
3086 static _LIBCPP_CONSTEXPR result_type min() {return _Min;}
3087 static _LIBCPP_CONSTEXPR result_type max() {return _Max;}
3088
3089 friend _LIBCPP_FUNC_VIS __rs_default __rs_get();
3090};
3091
3092_LIBCPP_FUNC_VIS __rs_default __rs_get();
3093
3094template <class _RandomAccessIterator>
3095_LIBCPP_DEPRECATED_IN_CXX14 void
3096random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
3097{
3098 typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
3099 typedef uniform_int_distribution<ptrdiff_t> _Dp;
3100 typedef typename _Dp::param_type _Pp;
3101 difference_type __d = __last - __first;
3102 if (__d > 1)
3103 {
3104 _Dp __uid;
3105 __rs_default __g = __rs_get();
3106 for (--__last, (void) --__d; __first < __last; ++__first, (void) --__d)
3107 {
3108 difference_type __i = __uid(__g, _Pp(0, __d));
3109 if (__i != difference_type(0))
3110 swap(*__first, *(__first + __i));
3111 }
3112 }
3113}
3114
3115template <class _RandomAccessIterator, class _RandomNumberGenerator>
3116_LIBCPP_DEPRECATED_IN_CXX14 void
3117random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
3118#ifndef _LIBCPP_CXX03_LANG
3119 _RandomNumberGenerator&& __rand)
3120#else
3121 _RandomNumberGenerator& __rand)
3122#endif
3123{
3124 typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
3125 difference_type __d = __last - __first;
3126 if (__d > 1)
3127 {
3128 for (--__last; __first < __last; ++__first, (void) --__d)
3129 {
3130 difference_type __i = __rand(__d);
3131 if (__i != difference_type(0))
3132 swap(*__first, *(__first + __i));
3133 }
3134 }
3135}
3136#endif
3137
3138template <class _PopulationIterator, class _SampleIterator, class _Distance,
3139 class _UniformRandomNumberGenerator>
3140_LIBCPP_INLINE_VISIBILITY
3141_SampleIterator __sample(_PopulationIterator __first,
3142 _PopulationIterator __last, _SampleIterator __output_iter,
3143 _Distance __n,
3144 _UniformRandomNumberGenerator & __g,
3145 input_iterator_tag) {
3146
3147 _Distance __k = 0;
3148 for (; __first != __last && __k < __n; ++__first, (void) ++__k)
3149 __output_iter[__k] = *__first;
3150 _Distance __sz = __k;
3151 for (; __first != __last; ++__first, (void) ++__k) {
3152 _Distance __r = _VSTD::uniform_int_distribution<_Distance>(0, __k)(__g);
3153 if (__r < __sz)
3154 __output_iter[__r] = *__first;
3155 }
3156 return __output_iter + _VSTD::min(__n, __k);
3157}
3158
3159template <class _PopulationIterator, class _SampleIterator, class _Distance,
3160 class _UniformRandomNumberGenerator>
3161_LIBCPP_INLINE_VISIBILITY
3162_SampleIterator __sample(_PopulationIterator __first,
3163 _PopulationIterator __last, _SampleIterator __output_iter,
3164 _Distance __n,
3165 _UniformRandomNumberGenerator& __g,
3166 forward_iterator_tag) {
3167 _Distance __unsampled_sz = _VSTD::distance(__first, __last);
3168 for (__n = _VSTD::min(__n, __unsampled_sz); __n != 0; ++__first) {
3169 _Distance __r =
3170 _VSTD::uniform_int_distribution<_Distance>(0, --__unsampled_sz)(__g);
3171 if (__r < __n) {
3172 *__output_iter++ = *__first;
3173 --__n;
3174 }
3175 }
3176 return __output_iter;
3177}
3178
3179template <class _PopulationIterator, class _SampleIterator, class _Distance,
3180 class _UniformRandomNumberGenerator>
3181_LIBCPP_INLINE_VISIBILITY
3182_SampleIterator __sample(_PopulationIterator __first,
3183 _PopulationIterator __last, _SampleIterator __output_iter,
3184 _Distance __n, _UniformRandomNumberGenerator& __g) {
3185 typedef typename iterator_traits<_PopulationIterator>::iterator_category
3186 _PopCategory;
3187 typedef typename iterator_traits<_PopulationIterator>::difference_type
3188 _Difference;
3189 static_assert(__is_cpp17_forward_iterator<_PopulationIterator>::value ||
3190 __is_cpp17_random_access_iterator<_SampleIterator>::value,
3191 "SampleIterator must meet the requirements of RandomAccessIterator");
3192 typedef typename common_type<_Distance, _Difference>::type _CommonType;
3193 _LIBCPP_ASSERT(__n >= 0, "N must be a positive number.");
3194 return _VSTD::__sample(
3195 __first, __last, __output_iter, _CommonType(__n),
3196 __g, _PopCategory());
3197}
3198
3199#if _LIBCPP_STD_VER > 14
3200template <class _PopulationIterator, class _SampleIterator, class _Distance,
3201 class _UniformRandomNumberGenerator>
3202inline _LIBCPP_INLINE_VISIBILITY
3203_SampleIterator sample(_PopulationIterator __first,
3204 _PopulationIterator __last, _SampleIterator __output_iter,
3205 _Distance __n, _UniformRandomNumberGenerator&& __g) {
3206 return _VSTD::__sample(__first, __last, __output_iter, __n, __g);
3207}
3208#endif // _LIBCPP_STD_VER > 14
3209
3210template<class _RandomAccessIterator, class _UniformRandomNumberGenerator>
3211 void shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
3212 _UniformRandomNumberGenerator&& __g)
3213{
3214 typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
3215 typedef uniform_int_distribution<ptrdiff_t> _Dp;
3216 typedef typename _Dp::param_type _Pp;
3217 difference_type __d = __last - __first;
3218 if (__d > 1)
3219 {
3220 _Dp __uid;
3221 for (--__last, (void) --__d; __first < __last; ++__first, (void) --__d)
3222 {
3223 difference_type __i = __uid(__g, _Pp(0, __d));
3224 if (__i != difference_type(0))
3225 swap(*__first, *(__first + __i));
3226 }
3227 }
3228}
3229
3230template <class _InputIterator, class _Predicate>
3231_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_AFTER_CXX17 bool
3232is_partitioned(_InputIterator __first, _InputIterator __last, _Predicate __pred)
3233{
3234 for (; __first != __last; ++__first)
3235 if (!__pred(*__first))
3236 break;
3237 if ( __first == __last )
3238 return true;
3239 ++__first;
3240 for (; __first != __last; ++__first)
3241 if (__pred(*__first))
3242 return false;
3243 return true;
3244}
3245
3246// partition
3247
3248template <class _Predicate, class _ForwardIterator>
3249_ForwardIterator
3250__partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, forward_iterator_tag)
3251{
3252 while (true)
3253 {
3254 if (__first == __last)
3255 return __first;
3256 if (!__pred(*__first))
3257 break;
3258 ++__first;
3259 }
3260 for (_ForwardIterator __p = __first; ++__p != __last;)
3261 {
3262 if (__pred(*__p))
3263 {
3264 swap(*__first, *__p);
3265 ++__first;
3266 }
3267 }
3268 return __first;
3269}
3270
3271template <class _Predicate, class _BidirectionalIterator>
3272_BidirectionalIterator
3273__partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred,
3274 bidirectional_iterator_tag)
3275{
3276 while (true)
3277 {
3278 while (true)
3279 {
3280 if (__first == __last)
3281 return __first;
3282 if (!__pred(*__first))
3283 break;
3284 ++__first;
3285 }
3286 do
3287 {
3288 if (__first == --__last)
3289 return __first;
3290 } while (!__pred(*__last));
3291 swap(*__first, *__last);
3292 ++__first;
3293 }
3294}
3295
3296template <class _ForwardIterator, class _Predicate>
3297inline _LIBCPP_INLINE_VISIBILITY
3298_ForwardIterator
3299partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
3300{
3301 return _VSTD::__partition<typename add_lvalue_reference<_Predicate>::type>
3302 (__first, __last, __pred, typename iterator_traits<_ForwardIterator>::iterator_category());
3303}
3304
3305// partition_copy
3306
3307template <class _InputIterator, class _OutputIterator1,
3308 class _OutputIterator2, class _Predicate>
3309_LIBCPP_CONSTEXPR_AFTER_CXX17 pair<_OutputIterator1, _OutputIterator2>
3310partition_copy(_InputIterator __first, _InputIterator __last,
3311 _OutputIterator1 __out_true, _OutputIterator2 __out_false,
3312 _Predicate __pred)
3313{
3314 for (; __first != __last; ++__first)
3315 {
3316 if (__pred(*__first))
3317 {
3318 *__out_true = *__first;
3319 ++__out_true;
3320 }
3321 else
3322 {
3323 *__out_false = *__first;
3324 ++__out_false;
3325 }
3326 }
3327 return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
3328}
3329
3330// partition_point
3331
3332template<class _ForwardIterator, class _Predicate>
3333_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
3334partition_point(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
3335{
3336 typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
3337 difference_type __len = _VSTD::distance(__first, __last);
3338 while (__len != 0)
3339 {
3340 difference_type __l2 = _VSTD::__half_positive(__len);
3341 _ForwardIterator __m = __first;
3342 _VSTD::advance(__m, __l2);
3343 if (__pred(*__m))
3344 {
3345 __first = ++__m;
3346 __len -= __l2 + 1;
3347 }
3348 else
3349 __len = __l2;
3350 }
3351 return __first;
3352}
3353
3354// stable_partition
3355
3356template <class _Predicate, class _ForwardIterator, class _Distance, class _Pair>
3357_ForwardIterator
3358__stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
3359 _Distance __len, _Pair __p, forward_iterator_tag __fit)
3360{
3361 // *__first is known to be false
3362 // __len >= 1
3363 if (__len == 1)
3364 return __first;
3365 if (__len == 2)
3366 {
3367 _ForwardIterator __m = __first;
3368 if (__pred(*++__m))
3369 {
3370 swap(*__first, *__m);
3371 return __m;
3372 }
3373 return __first;
3374 }
3375 if (__len <= __p.second)
3376 { // The buffer is big enough to use
3377 typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
3378 __destruct_n __d(0);
3379 unique_ptr<value_type, __destruct_n&> __h(__p.first, __d);
3380 // Move the falses into the temporary buffer, and the trues to the front of the line
3381 // Update __first to always point to the end of the trues
3382 value_type* __t = __p.first;
3383 ::new(__t) value_type(_VSTD::move(*__first));
3384 __d.__incr((value_type*)0);
3385 ++__t;
3386 _ForwardIterator __i = __first;
3387 while (++__i != __last)
3388 {
3389 if (__pred(*__i))
3390 {
3391 *__first = _VSTD::move(*__i);
3392 ++__first;
3393 }
3394 else
3395 {
3396 ::new(__t) value_type(_VSTD::move(*__i));
3397 __d.__incr((value_type*)0);
3398 ++__t;
3399 }
3400 }
3401 // All trues now at start of range, all falses in buffer
3402 // Move falses back into range, but don't mess up __first which points to first false
3403 __i = __first;
3404 for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, (void) ++__i)
3405 *__i = _VSTD::move(*__t2);
3406 // __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer
3407 return __first;
3408 }
3409 // Else not enough buffer, do in place
3410 // __len >= 3
3411 _ForwardIterator __m = __first;
3412 _Distance __len2 = __len / 2; // __len2 >= 2
3413 _VSTD::advance(__m, __len2);
3414 // recurse on [__first, __m), *__first know to be false
3415 // F?????????????????
3416 // f m l
3417 typedef typename add_lvalue_reference<_Predicate>::type _PredRef;
3418 _ForwardIterator __first_false = __stable_partition<_PredRef>(__first, __m, __pred, __len2, __p, __fit);
3419 // TTTFFFFF??????????
3420 // f ff m l
3421 // recurse on [__m, __last], except increase __m until *(__m) is false, *__last know to be true
3422 _ForwardIterator __m1 = __m;
3423 _ForwardIterator __second_false = __last;
3424 _Distance __len_half = __len - __len2;
3425 while (__pred(*__m1))
3426 {
3427 if (++__m1 == __last)
3428 goto __second_half_done;
3429 --__len_half;
3430 }
3431 // TTTFFFFFTTTF??????
3432 // f ff m m1 l
3433 __second_false = __stable_partition<_PredRef>(__m1, __last, __pred, __len_half, __p, __fit);
3434__second_half_done:
3435 // TTTFFFFFTTTTTFFFFF
3436 // f ff m sf l
3437 return _VSTD::rotate(__first_false, __m, __second_false);
3438 // TTTTTTTTFFFFFFFFFF
3439 // |
3440}
3441
3442struct __return_temporary_buffer
3443{
3444 template <class _Tp>
3445 _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) const {_VSTD::return_temporary_buffer(__p);}
3446};
3447
3448template <class _Predicate, class _ForwardIterator>
3449_ForwardIterator
3450__stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
3451 forward_iterator_tag)
3452{
3453 const unsigned __alloc_limit = 3; // might want to make this a function of trivial assignment
3454 // Either prove all true and return __first or point to first false
3455 while (true)
3456 {
3457 if (__first == __last)
3458 return __first;
3459 if (!__pred(*__first))
3460 break;
3461 ++__first;
3462 }
3463 // We now have a reduced range [__first, __last)
3464 // *__first is known to be false
3465 typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
3466 typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
3467 difference_type __len = _VSTD::distance(__first, __last);
3468 pair<value_type*, ptrdiff_t> __p(0, 0);
3469 unique_ptr<value_type, __return_temporary_buffer> __h;
3470 if (__len >= __alloc_limit)
3471 {
3472 __p = _VSTD::get_temporary_buffer<value_type>(__len);
3473 __h.reset(__p.first);
3474 }
3475 return __stable_partition<typename add_lvalue_reference<_Predicate>::type>
3476 (__first, __last, __pred, __len, __p, forward_iterator_tag());
3477}
3478
3479template <class _Predicate, class _BidirectionalIterator, class _Distance, class _Pair>
3480_BidirectionalIterator
3481__stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred,
3482 _Distance __len, _Pair __p, bidirectional_iterator_tag __bit)
3483{
3484 // *__first is known to be false
3485 // *__last is known to be true
3486 // __len >= 2
3487 if (__len == 2)
3488 {
3489 swap(*__first, *__last);
3490 return __last;
3491 }
3492 if (__len == 3)
3493 {
3494 _BidirectionalIterator __m = __first;
3495 if (__pred(*++__m))
3496 {
3497 swap(*__first, *__m);
3498 swap(*__m, *__last);
3499 return __last;
3500 }
3501 swap(*__m, *__last);
3502 swap(*__first, *__m);
3503 return __m;
3504 }
3505 if (__len <= __p.second)
3506 { // The buffer is big enough to use
3507 typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
3508 __destruct_n __d(0);
3509 unique_ptr<value_type, __destruct_n&> __h(__p.first, __d);
3510 // Move the falses into the temporary buffer, and the trues to the front of the line
3511 // Update __first to always point to the end of the trues
3512 value_type* __t = __p.first;
3513 ::new(__t) value_type(_VSTD::move(*__first));
3514 __d.__incr((value_type*)0);
3515 ++__t;
3516 _BidirectionalIterator __i = __first;
3517 while (++__i != __last)
3518 {
3519 if (__pred(*__i))
3520 {
3521 *__first = _VSTD::move(*__i);
3522 ++__first;
3523 }
3524 else
3525 {
3526 ::new(__t) value_type(_VSTD::move(*__i));
3527 __d.__incr((value_type*)0);
3528 ++__t;
3529 }
3530 }
3531 // move *__last, known to be true
3532 *__first = _VSTD::move(*__i);
3533 __i = ++__first;
3534 // All trues now at start of range, all falses in buffer
3535 // Move falses back into range, but don't mess up __first which points to first false
3536 for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, (void) ++__i)
3537 *__i = _VSTD::move(*__t2);
3538 // __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer
3539 return __first;
3540 }
3541 // Else not enough buffer, do in place
3542 // __len >= 4
3543 _BidirectionalIterator __m = __first;
3544 _Distance __len2 = __len / 2; // __len2 >= 2
3545 _VSTD::advance(__m, __len2);
3546 // recurse on [__first, __m-1], except reduce __m-1 until *(__m-1) is true, *__first know to be false
3547 // F????????????????T
3548 // f m l
3549 _BidirectionalIterator __m1 = __m;
3550 _BidirectionalIterator __first_false = __first;
3551 _Distance __len_half = __len2;
3552 while (!__pred(*--__m1))
3553 {
3554 if (__m1 == __first)
3555 goto __first_half_done;
3556 --__len_half;
3557 }
3558 // F???TFFF?????????T
3559 // f m1 m l
3560 typedef typename add_lvalue_reference<_Predicate>::type _PredRef;
3561 __first_false = __stable_partition<_PredRef>(__first, __m1, __pred, __len_half, __p, __bit);
3562__first_half_done:
3563 // TTTFFFFF?????????T
3564 // f ff m l
3565 // recurse on [__m, __last], except increase __m until *(__m) is false, *__last know to be true
3566 __m1 = __m;
3567 _BidirectionalIterator __second_false = __last;
3568 ++__second_false;
3569 __len_half = __len - __len2;
3570 while (__pred(*__m1))
3571 {
3572 if (++__m1 == __last)
3573 goto __second_half_done;
3574 --__len_half;
3575 }
3576 // TTTFFFFFTTTF?????T
3577 // f ff m m1 l
3578 __second_false = __stable_partition<_PredRef>(__m1, __last, __pred, __len_half, __p, __bit);
3579__second_half_done:
3580 // TTTFFFFFTTTTTFFFFF
3581 // f ff m sf l
3582 return _VSTD::rotate(__first_false, __m, __second_false);
3583 // TTTTTTTTFFFFFFFFFF
3584 // |
3585}
3586
3587template <class _Predicate, class _BidirectionalIterator>
3588_BidirectionalIterator
3589__stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred,
3590 bidirectional_iterator_tag)
3591{
3592 typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
3593 typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
3594 const difference_type __alloc_limit = 4; // might want to make this a function of trivial assignment
3595 // Either prove all true and return __first or point to first false
3596 while (true)
3597 {
3598 if (__first == __last)
3599 return __first;
3600 if (!__pred(*__first))
3601 break;
3602 ++__first;
3603 }
3604 // __first points to first false, everything prior to __first is already set.
3605 // Either prove [__first, __last) is all false and return __first, or point __last to last true
3606 do
3607 {
3608 if (__first == --__last)
3609 return __first;
3610 } while (!__pred(*__last));
3611 // We now have a reduced range [__first, __last]
3612 // *__first is known to be false
3613 // *__last is known to be true
3614 // __len >= 2
3615 difference_type __len = _VSTD::distance(__first, __last) + 1;
3616 pair<value_type*, ptrdiff_t> __p(0, 0);
3617 unique_ptr<value_type, __return_temporary_buffer> __h;
3618 if (__len >= __alloc_limit)
3619 {
3620 __p = _VSTD::get_temporary_buffer<value_type>(__len);
3621 __h.reset(__p.first);
3622 }
3623 return __stable_partition<typename add_lvalue_reference<_Predicate>::type>
3624 (__first, __last, __pred, __len, __p, bidirectional_iterator_tag());
3625}
3626
3627template <class _ForwardIterator, class _Predicate>
3628inline _LIBCPP_INLINE_VISIBILITY
3629_ForwardIterator
3630stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
3631{
3632 return __stable_partition<typename add_lvalue_reference<_Predicate>::type>
3633 (__first, __last, __pred, typename iterator_traits<_ForwardIterator>::iterator_category());
3634}
3635
3636// is_sorted_until
3637
3638template <class _ForwardIterator, class _Compare>
3639_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
3640is_sorted_until(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
3641{
3642 if (__first != __last)
3643 {
3644 _ForwardIterator __i = __first;
3645 while (++__i != __last)
3646 {
3647 if (__comp(*__i, *__first))
3648 return __i;
3649 __first = __i;
3650 }
3651 }
3652 return __last;
3653}
3654
3655template<class _ForwardIterator>
3656_LIBCPP_NODISCARD_EXT inline
3657_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
3658_ForwardIterator
3659is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
3660{
3661 return _VSTD::is_sorted_until(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
3662}
3663
3664// is_sorted
3665
3666template <class _ForwardIterator, class _Compare>
3667_LIBCPP_NODISCARD_EXT inline
3668_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
3669bool
3670is_sorted(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
3671{
3672 return _VSTD::is_sorted_until(__first, __last, __comp) == __last;
3673}
3674
3675template<class _ForwardIterator>
3676_LIBCPP_NODISCARD_EXT inline
3677_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
3678bool
3679is_sorted(_ForwardIterator __first, _ForwardIterator __last)
3680{
3681 return _VSTD::is_sorted(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
3682}
3683
3684// sort
3685
3686// stable, 2-3 compares, 0-2 swaps
3687
3688template <class _Compare, class _ForwardIterator>
3689unsigned
3690__sort3(_ForwardIterator __x, _ForwardIterator __y, _ForwardIterator __z, _Compare __c)
3691{
3692 unsigned __r = 0;
3693 if (!__c(*__y, *__x)) // if x <= y
3694 {
3695 if (!__c(*__z, *__y)) // if y <= z
3696 return __r; // x <= y && y <= z
3697 // x <= y && y > z
3698 swap(*__y, *__z); // x <= z && y < z
3699 __r = 1;
3700 if (__c(*__y, *__x)) // if x > y
3701 {
3702 swap(*__x, *__y); // x < y && y <= z
3703 __r = 2;
3704 }
3705 return __r; // x <= y && y < z
3706 }
3707 if (__c(*__z, *__y)) // x > y, if y > z
3708 {
3709 swap(*__x, *__z); // x < y && y < z
3710 __r = 1;
3711 return __r;
3712 }
3713 swap(*__x, *__y); // x > y && y <= z
3714 __r = 1; // x < y && x <= z
3715 if (__c(*__z, *__y)) // if y > z
3716 {
3717 swap(*__y, *__z); // x <= y && y < z
3718 __r = 2;
3719 }
3720 return __r;
3721} // x <= y && y <= z
3722
3723// stable, 3-6 compares, 0-5 swaps
3724
3725template <class _Compare, class _ForwardIterator>
3726unsigned
3727__sort4(_ForwardIterator __x1, _ForwardIterator __x2, _ForwardIterator __x3,
3728 _ForwardIterator __x4, _Compare __c)
3729{
3730 unsigned __r = __sort3<_Compare>(__x1, __x2, __x3, __c);
3731 if (__c(*__x4, *__x3))
3732 {
3733 swap(*__x3, *__x4);
3734 ++__r;
3735 if (__c(*__x3, *__x2))
3736 {
3737 swap(*__x2, *__x3);
3738 ++__r;
3739 if (__c(*__x2, *__x1))
3740 {
3741 swap(*__x1, *__x2);
3742 ++__r;
3743 }
3744 }
3745 }
3746 return __r;
3747}
3748
3749// stable, 4-10 compares, 0-9 swaps
3750
3751template <class _Compare, class _ForwardIterator>
3752_LIBCPP_HIDDEN
3753unsigned
3754__sort5(_ForwardIterator __x1, _ForwardIterator __x2, _ForwardIterator __x3,
3755 _ForwardIterator __x4, _ForwardIterator __x5, _Compare __c)
3756{
3757 unsigned __r = __sort4<_Compare>(__x1, __x2, __x3, __x4, __c);
3758 if (__c(*__x5, *__x4))
3759 {
3760 swap(*__x4, *__x5);
3761 ++__r;
3762 if (__c(*__x4, *__x3))
3763 {
3764 swap(*__x3, *__x4);
3765 ++__r;
3766 if (__c(*__x3, *__x2))
3767 {
3768 swap(*__x2, *__x3);
3769 ++__r;
3770 if (__c(*__x2, *__x1))
3771 {
3772 swap(*__x1, *__x2);
3773 ++__r;
3774 }
3775 }
3776 }
3777 }
3778 return __r;
3779}
3780
3781// Assumes size > 0
3782template <class _Compare, class _BirdirectionalIterator>
3783void
3784__selection_sort(_BirdirectionalIterator __first, _BirdirectionalIterator __last, _Compare __comp)
3785{
3786 _BirdirectionalIterator __lm1 = __last;
3787 for (--__lm1; __first != __lm1; ++__first)
3788 {
3789 _BirdirectionalIterator __i = _VSTD::min_element<_BirdirectionalIterator,
3790 typename add_lvalue_reference<_Compare>::type>
3791 (__first, __last, __comp);
3792 if (__i != __first)
3793 swap(*__first, *__i);
3794 }
3795}
3796
3797template <class _Compare, class _BirdirectionalIterator>
3798void
3799__insertion_sort(_BirdirectionalIterator __first, _BirdirectionalIterator __last, _Compare __comp)
3800{
3801 typedef typename iterator_traits<_BirdirectionalIterator>::value_type value_type;
3802 if (__first != __last)
3803 {
3804 _BirdirectionalIterator __i = __first;
3805 for (++__i; __i != __last; ++__i)
3806 {
3807 _BirdirectionalIterator __j = __i;
3808 value_type __t(_VSTD::move(*__j));
3809 for (_BirdirectionalIterator __k = __i; __k != __first && __comp(__t, *--__k); --__j)
3810 *__j = _VSTD::move(*__k);
3811 *__j = _VSTD::move(__t);
3812 }
3813 }
3814}
3815
3816template <class _Compare, class _RandomAccessIterator>
3817void
3818__insertion_sort_3(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
3819{
3820 typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
3821 _RandomAccessIterator __j = __first+2;
3822 __sort3<_Compare>(__first, __first+1, __j, __comp);
3823 for (_RandomAccessIterator __i = __j+1; __i != __last; ++__i)
3824 {
3825 if (__comp(*__i, *__j))
3826 {
3827 value_type __t(_VSTD::move(*__i));
3828 _RandomAccessIterator __k = __j;
3829 __j = __i;
3830 do
3831 {
3832 *__j = _VSTD::move(*__k);
3833 __j = __k;
3834 } while (__j != __first && __comp(__t, *--__k));
3835 *__j = _VSTD::move(__t);
3836 }
3837 __j = __i;
3838 }
3839}
3840
3841template <class _Compare, class _RandomAccessIterator>
3842bool
3843__insertion_sort_incomplete(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
3844{
3845 switch (__last - __first)
3846 {
3847 case 0:
3848 case 1:
3849 return true;
3850 case 2:
3851 if (__comp(*--__last, *__first))
3852 swap(*__first, *__last);
3853 return true;
3854 case 3:
3855 _VSTD::__sort3<_Compare>(__first, __first+1, --__last, __comp);
3856 return true;
3857 case 4:
3858 _VSTD::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp);
3859 return true;
3860 case 5:
3861 _VSTD::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp);
3862 return true;
3863 }
3864 typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
3865 _RandomAccessIterator __j = __first+2;
3866 __sort3<_Compare>(__first, __first+1, __j, __comp);
3867 const unsigned __limit = 8;
3868 unsigned __count = 0;
3869 for (_RandomAccessIterator __i = __j+1; __i != __last; ++__i)
3870 {
3871 if (__comp(*__i, *__j))
3872 {
3873 value_type __t(_VSTD::move(*__i));
3874 _RandomAccessIterator __k = __j;
3875 __j = __i;
3876 do
3877 {
3878 *__j = _VSTD::move(*__k);
3879 __j = __k;
3880 } while (__j != __first && __comp(__t, *--__k));
3881 *__j = _VSTD::move(__t);
3882 if (++__count == __limit)
3883 return ++__i == __last;
3884 }
3885 __j = __i;
3886 }
3887 return true;
3888}
3889
3890template <class _Compare, class _BirdirectionalIterator>
3891void
3892__insertion_sort_move(_BirdirectionalIterator __first1, _BirdirectionalIterator __last1,
3893 typename iterator_traits<_BirdirectionalIterator>::value_type* __first2, _Compare __comp)
3894{
3895 typedef typename iterator_traits<_BirdirectionalIterator>::value_type value_type;
3896 if (__first1 != __last1)
3897 {
3898 __destruct_n __d(0);
3899 unique_ptr<value_type, __destruct_n&> __h(__first2, __d);
3900 value_type* __last2 = __first2;
3901 ::new(__last2) value_type(_VSTD::move(*__first1));
3902 __d.__incr((value_type*)0);
3903 for (++__last2; ++__first1 != __last1; ++__last2)
3904 {
3905 value_type* __j2 = __last2;
3906 value_type* __i2 = __j2;
3907 if (__comp(*__first1, *--__i2))
3908 {
3909 ::new(__j2) value_type(_VSTD::move(*__i2));
3910 __d.__incr((value_type*)0);
3911 for (--__j2; __i2 != __first2 && __comp(*__first1, *--__i2); --__j2)
3912 *__j2 = _VSTD::move(*__i2);
3913 *__j2 = _VSTD::move(*__first1);
3914 }
3915 else
3916 {
3917 ::new(__j2) value_type(_VSTD::move(*__first1));
3918 __d.__incr((value_type*)0);
3919 }
3920 }
3921 __h.release();
3922 }
3923}
3924
3925template <class _Compare, class _RandomAccessIterator>
3926void
3927__sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
3928{
3929 // _Compare is known to be a reference type
3930 typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
3931 typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
3932 const difference_type __limit = is_trivially_copy_constructible<value_type>::value &&
3933 is_trivially_copy_assignable<value_type>::value ? 30 : 6;
3934 while (true)
3935 {
3936 __restart:
3937 difference_type __len = __last - __first;
3938 switch (__len)
3939 {
3940 case 0:
3941 case 1:
3942 return;
3943 case 2:
3944 if (__comp(*--__last, *__first))
3945 swap(*__first, *__last);
3946 return;
3947 case 3:
3948 _VSTD::__sort3<_Compare>(__first, __first+1, --__last, __comp);
3949 return;
3950 case 4:
3951 _VSTD::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp);
3952 return;
3953 case 5:
3954 _VSTD::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp);
3955 return;
3956 }
3957 if (__len <= __limit)
3958 {
3959 _VSTD::__insertion_sort_3<_Compare>(__first, __last, __comp);
3960 return;
3961 }
3962 // __len > 5
3963 _RandomAccessIterator __m = __first;
3964 _RandomAccessIterator __lm1 = __last;
3965 --__lm1;
3966 unsigned __n_swaps;
3967 {
3968 difference_type __delta;
3969 if (__len >= 1000)
3970 {
3971 __delta = __len/2;
3972 __m += __delta;
3973 __delta /= 2;
3974 __n_swaps = _VSTD::__sort5<_Compare>(__first, __first + __delta, __m, __m+__delta, __lm1, __comp);
3975 }
3976 else
3977 {
3978 __delta = __len/2;
3979 __m += __delta;
3980 __n_swaps = _VSTD::__sort3<_Compare>(__first, __m, __lm1, __comp);
3981 }
3982 }
3983 // *__m is median
3984 // partition [__first, __m) < *__m and *__m <= [__m, __last)
3985 // (this inhibits tossing elements equivalent to __m around unnecessarily)
3986 _RandomAccessIterator __i = __first;
3987 _RandomAccessIterator __j = __lm1;
3988 // j points beyond range to be tested, *__m is known to be <= *__lm1
3989 // The search going up is known to be guarded but the search coming down isn't.
3990 // Prime the downward search with a guard.
3991 if (!__comp(*__i, *__m)) // if *__first == *__m
3992 {
3993 // *__first == *__m, *__first doesn't go in first part
3994 // manually guard downward moving __j against __i
3995 while (true)
3996 {
3997 if (__i == --__j)
3998 {
3999 // *__first == *__m, *__m <= all other elements
4000 // Parition instead into [__first, __i) == *__first and *__first < [__i, __last)
4001 ++__i; // __first + 1
4002 __j = __last;
4003 if (!__comp(*__first, *--__j)) // we need a guard if *__first == *(__last-1)
4004 {
4005 while (true)
4006 {
4007 if (__i == __j)
4008 return; // [__first, __last) all equivalent elements
4009 if (__comp(*__first, *__i))
4010 {
4011 swap(*__i, *__j);
4012 ++__n_swaps;
4013 ++__i;
4014 break;
4015 }
4016 ++__i;
4017 }
4018 }
4019 // [__first, __i) == *__first and *__first < [__j, __last) and __j == __last - 1
4020 if (__i == __j)
4021 return;
4022 while (true)
4023 {
4024 while (!__comp(*__first, *__i))
4025 ++__i;
4026 while (__comp(*__first, *--__j))
4027 ;
4028 if (__i >= __j)
4029 break;
4030 swap(*__i, *__j);
4031 ++__n_swaps;
4032 ++__i;
4033 }
4034 // [__first, __i) == *__first and *__first < [__i, __last)
4035 // The first part is sorted, sort the secod part
4036 // _VSTD::__sort<_Compare>(__i, __last, __comp);
4037 __first = __i;
4038 goto __restart;
4039 }
4040 if (__comp(*__j, *__m))
4041 {
4042 swap(*__i, *__j);
4043 ++__n_swaps;
4044 break; // found guard for downward moving __j, now use unguarded partition
4045 }
4046 }
4047 }
4048 // It is known that *__i < *__m
4049 ++__i;
4050 // j points beyond range to be tested, *__m is known to be <= *__lm1
4051 // if not yet partitioned...
4052 if (__i < __j)
4053 {
4054 // known that *(__i - 1) < *__m
4055 // known that __i <= __m
4056 while (true)
4057 {
4058 // __m still guards upward moving __i
4059 while (__comp(*__i, *__m))
4060 ++__i;
4061 // It is now known that a guard exists for downward moving __j
4062 while (!__comp(*--__j, *__m))
4063 ;
4064 if (__i > __j)
4065 break;
4066 swap(*__i, *__j);
4067 ++__n_swaps;
4068 // It is known that __m != __j
4069 // If __m just moved, follow it
4070 if (__m == __i)
4071 __m = __j;
4072 ++__i;
4073 }
4074 }
4075 // [__first, __i) < *__m and *__m <= [__i, __last)
4076 if (__i != __m && __comp(*__m, *__i))
4077 {
4078 swap(*__i, *__m);
4079 ++__n_swaps;
4080 }
4081 // [__first, __i) < *__i and *__i <= [__i+1, __last)
4082 // If we were given a perfect partition, see if insertion sort is quick...
4083 if (__n_swaps == 0)
4084 {
4085 bool __fs = _VSTD::__insertion_sort_incomplete<_Compare>(__first, __i, __comp);
4086 if (_VSTD::__insertion_sort_incomplete<_Compare>(__i+1, __last, __comp))
4087 {
4088 if (__fs)
4089 return;
4090 __last = __i;
4091 continue;
4092 }
4093 else
4094 {
4095 if (__fs)
4096 {
4097 __first = ++__i;
4098 continue;
4099 }
4100 }
4101 }
4102 // sort smaller range with recursive call and larger with tail recursion elimination
4103 if (__i - __first < __last - __i)
4104 {
4105 _VSTD::__sort<_Compare>(__first, __i, __comp);
4106 // _VSTD::__sort<_Compare>(__i+1, __last, __comp);
4107 __first = ++__i;
4108 }
4109 else
4110 {
4111 _VSTD::__sort<_Compare>(__i+1, __last, __comp);
4112 // _VSTD::__sort<_Compare>(__first, __i, __comp);
4113 __last = __i;
4114 }
4115 }
4116}
4117
4118// This forwarder keeps the top call and the recursive calls using the same instantiation, forcing a reference _Compare
4119template <class _RandomAccessIterator, class _Compare>
4120inline _LIBCPP_INLINE_VISIBILITY
4121void
4122sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
4123{
4124 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
4125 _VSTD::__sort<_Comp_ref>(__first, __last, _Comp_ref(__comp));
4126}
4127
4128template <class _RandomAccessIterator>
4129inline _LIBCPP_INLINE_VISIBILITY
4130void
4131sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
4132{
4133 _VSTD::sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
4134}
4135
4136template <class _Tp>
4137inline _LIBCPP_INLINE_VISIBILITY
4138void
4139sort(_Tp** __first, _Tp** __last)
4140{
4141 _VSTD::sort((size_t*)__first, (size_t*)__last, __less<size_t>());
4142}
4143
4144template <class _Tp>
4145inline _LIBCPP_INLINE_VISIBILITY
4146void
4147sort(__wrap_iter<_Tp*> __first, __wrap_iter<_Tp*> __last)
4148{
4149 _VSTD::sort(__first.base(), __last.base());
4150}
4151
4152template <class _Tp, class _Compare>
4153inline _LIBCPP_INLINE_VISIBILITY
4154void
4155sort(__wrap_iter<_Tp*> __first, __wrap_iter<_Tp*> __last, _Compare __comp)
4156{
4157 typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
4158 _VSTD::sort<_Tp*, _Comp_ref>(__first.base(), __last.base(), __comp);
4159}
4160
4161_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<char>&, char*>(char*, char*, __less<char>&))
4162_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<wchar_t>&, wchar_t*>(wchar_t*, wchar_t*, __less<wchar_t>&))
4163_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<signed char>&, signed char*>(signed char*, signed char*, __less<signed char>&))
4164_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned char>&, unsigned char*>(unsigned char*, unsigned char*, __less<unsigned char>&))
4165_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<short>&, short*>(short*, short*, __less<short>&))
4166_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned short>&, unsigned short*>(unsigned short*, unsigned short*, __less<unsigned short>&))
4167_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<int>&, int*>(int*, int*, __less<int>&))
4168_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned>&, unsigned*>(unsigned*, unsigned*, __less<unsigned>&))
4169_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<long>&, long*>(long*, long*, __less<long>&))
4170_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned long>&, unsigned long*>(unsigned long*, unsigned long*, __less<unsigned long>&))
4171_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<long long>&, long long*>(long long*, long long*, __less<long long>&))
4172_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned long long>&, unsigned long long*>(unsigned long long*, unsigned long long*, __less<unsigned long long>&))
4173_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<float>&, float*>(float*, float*, __less<float>&))
4174_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<double>&, double*>(double*, double*, __less<double>&))
4175_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<long double>&, long double*>(long double*, long double*, __less<long double>&))
4176
4177_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<char>&, char*>(char*, char*, __less<char>&))
4178_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<wchar_t>&, wchar_t*>(wchar_t*, wchar_t*, __less<wchar_t>&))
4179_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<signed char>&, signed char*>(signed char*, signed char*, __less<signed char>&))
4180_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned char>&, unsigned char*>(unsigned char*, unsigned char*, __less<unsigned char>&))
4181_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<short>&, short*>(short*, short*, __less<short>&))
4182_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned short>&, unsigned short*>(unsigned short*, unsigned short*, __less<unsigned short>&))
4183_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<int>&, int*>(int*, int*, __less<int>&))
4184_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned>&, unsigned*>(unsigned*, unsigned*, __less<unsigned>&))
4185_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<long>&, long*>(long*, long*, __less<long>&))
4186_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned long>&, unsigned long*>(unsigned long*, unsigned long*, __less<unsigned long>&))
4187_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<long long>&, long long*>(long long*, long long*, __less<long long>&))
4188_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned long long>&, unsigned long long*>(unsigned long long*, unsigned long long*, __less<unsigned long long>&))
4189_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<float>&, float*>(float*, float*, __less<float>&))
4190_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<double>&, double*>(double*, double*, __less<double>&))
4191_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<long double>&, long double*>(long double*, long double*, __less<long double>&))
4192
4193_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS unsigned __sort5<__less<long double>&, long double*>(long double*, long double*, long double*, long double*, long double*, __less<long double>&))
4194
4195// lower_bound
4196
4197template <class _Compare, class _ForwardIterator, class _Tp>
4198_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
4199__lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
4200{
4201 typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
4202 difference_type __len = _VSTD::distance(__first, __last);
4203 while (__len != 0)
4204 {
4205 difference_type __l2 = _VSTD::__half_positive(__len);
4206 _ForwardIterator __m = __first;
4207 _VSTD::advance(__m, __l2);
4208 if (__comp(*__m, __value_))
4209 {
4210 __first = ++__m;
4211 __len -= __l2 + 1;
4212 }
4213 else
4214 __len = __l2;
4215 }
4216 return __first;
4217}
4218
4219template <class _ForwardIterator, class _Tp, class _Compare>
4220_LIBCPP_NODISCARD_EXT inline
4221_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
4222_ForwardIterator
4223lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
4224{
4225 typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
4226 return __lower_bound<_Comp_ref>(__first, __last, __value_, __comp);
4227}
4228
4229template <class _ForwardIterator, class _Tp>
4230_LIBCPP_NODISCARD_EXT inline
4231_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
4232_ForwardIterator
4233lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
4234{
4235 return _VSTD::lower_bound(__first, __last, __value_,
4236 __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
4237}
4238
4239// upper_bound
4240
4241template <class _Compare, class _ForwardIterator, class _Tp>
4242_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
4243__upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
4244{
4245 typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
4246 difference_type __len = _VSTD::distance(__first, __last);
4247 while (__len != 0)
4248 {
4249 difference_type __l2 = _VSTD::__half_positive(__len);
4250 _ForwardIterator __m = __first;
4251 _VSTD::advance(__m, __l2);
4252 if (__comp(__value_, *__m))
4253 __len = __l2;
4254 else
4255 {
4256 __first = ++__m;
4257 __len -= __l2 + 1;
4258 }
4259 }
4260 return __first;
4261}
4262
4263template <class _ForwardIterator, class _Tp, class _Compare>
4264_LIBCPP_NODISCARD_EXT inline
4265_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
4266_ForwardIterator
4267upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
4268{
4269 typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
4270 return __upper_bound<_Comp_ref>(__first, __last, __value_, __comp);
4271}
4272
4273template <class _ForwardIterator, class _Tp>
4274_LIBCPP_NODISCARD_EXT inline
4275_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
4276_ForwardIterator
4277upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
4278{
4279 return _VSTD::upper_bound(__first, __last, __value_,
4280 __less<_Tp, typename iterator_traits<_ForwardIterator>::value_type>());
4281}
4282
4283// equal_range
4284
4285template <class _Compare, class _ForwardIterator, class _Tp>
4286_LIBCPP_CONSTEXPR_AFTER_CXX17 pair<_ForwardIterator, _ForwardIterator>
4287__equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
4288{
4289 typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
4290 difference_type __len = _VSTD::distance(__first, __last);
4291 while (__len != 0)
4292 {
4293 difference_type __l2 = _VSTD::__half_positive(__len);
4294 _ForwardIterator __m = __first;
4295 _VSTD::advance(__m, __l2);
4296 if (__comp(*__m, __value_))
4297 {
4298 __first = ++__m;
4299 __len -= __l2 + 1;
4300 }
4301 else if (__comp(__value_, *__m))
4302 {
4303 __last = __m;
4304 __len = __l2;
4305 }
4306 else
4307 {
4308 _ForwardIterator __mp1 = __m;
4309 return pair<_ForwardIterator, _ForwardIterator>
4310 (
4311 __lower_bound<_Compare>(__first, __m, __value_, __comp),
4312 __upper_bound<_Compare>(++__mp1, __last, __value_, __comp)
4313 );
4314 }
4315 }
4316 return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
4317}
4318
4319template <class _ForwardIterator, class _Tp, class _Compare>
4320_LIBCPP_NODISCARD_EXT inline
4321_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
4322pair<_ForwardIterator, _ForwardIterator>
4323equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
4324{
4325 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
4326 return __equal_range<_Comp_ref>(__first, __last, __value_, __comp);
4327}
4328
4329template <class _ForwardIterator, class _Tp>
4330_LIBCPP_NODISCARD_EXT inline
4331_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
4332pair<_ForwardIterator, _ForwardIterator>
4333equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
4334{
4335 return _VSTD::equal_range(__first, __last, __value_,
4336 __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
4337}
4338
4339// binary_search
4340
4341template <class _Compare, class _ForwardIterator, class _Tp>
4342inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
4343bool
4344__binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
4345{
4346 __first = __lower_bound<_Compare>(__first, __last, __value_, __comp);
4347 return __first != __last && !__comp(__value_, *__first);
4348}
4349
4350template <class _ForwardIterator, class _Tp, class _Compare>
4351_LIBCPP_NODISCARD_EXT inline
4352_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
4353bool
4354binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
4355{
4356 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
4357 return __binary_search<_Comp_ref>(__first, __last, __value_, __comp);
4358}
4359
4360template <class _ForwardIterator, class _Tp>
4361_LIBCPP_NODISCARD_EXT inline
4362_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
4363bool
4364binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
4365{
4366 return _VSTD::binary_search(__first, __last, __value_,
4367 __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
4368}
4369
4370// merge
4371
4372template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
4373_OutputIterator
4374__merge(_InputIterator1 __first1, _InputIterator1 __last1,
4375 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
4376{
4377 for (; __first1 != __last1; ++__result)
4378 {
4379 if (__first2 == __last2)
4380 return _VSTD::copy(__first1, __last1, __result);
4381 if (__comp(*__first2, *__first1))
4382 {
4383 *__result = *__first2;
4384 ++__first2;
4385 }
4386 else
4387 {
4388 *__result = *__first1;
4389 ++__first1;
4390 }
4391 }
4392 return _VSTD::copy(__first2, __last2, __result);
4393}
4394
4395template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
4396inline _LIBCPP_INLINE_VISIBILITY
4397_OutputIterator
4398merge(_InputIterator1 __first1, _InputIterator1 __last1,
4399 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
4400{
4401 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
4402 return _VSTD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
4403}
4404
4405template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
4406inline _LIBCPP_INLINE_VISIBILITY
4407_OutputIterator
4408merge(_InputIterator1 __first1, _InputIterator1 __last1,
4409 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
4410{
4411 typedef typename iterator_traits<_InputIterator1>::value_type __v1;
4412 typedef typename iterator_traits<_InputIterator2>::value_type __v2;
4413 return _VSTD::merge(__first1, __last1, __first2, __last2, __result, __less<__v1, __v2>());
4414}
4415
4416// inplace_merge
4417
4418template <class _Compare, class _InputIterator1, class _InputIterator2,
4419 class _OutputIterator>
4420void __half_inplace_merge(_InputIterator1 __first1, _InputIterator1 __last1,
4421 _InputIterator2 __first2, _InputIterator2 __last2,
4422 _OutputIterator __result, _Compare __comp)
4423{
4424 for (; __first1 != __last1; ++__result)
4425 {
4426 if (__first2 == __last2)
4427 {
4428 _VSTD::move(__first1, __last1, __result);
4429 return;
4430 }
4431
4432 if (__comp(*__first2, *__first1))
4433 {
4434 *__result = _VSTD::move(*__first2);
4435 ++__first2;
4436 }
4437 else
4438 {
4439 *__result = _VSTD::move(*__first1);
4440 ++__first1;
4441 }
4442 }
4443 // __first2 through __last2 are already in the right spot.
4444}
4445
4446template <class _Compare, class _BidirectionalIterator>
4447void
4448__buffered_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
4449 _Compare __comp, typename iterator_traits<_BidirectionalIterator>::difference_type __len1,
4450 typename iterator_traits<_BidirectionalIterator>::difference_type __len2,
4451 typename iterator_traits<_BidirectionalIterator>::value_type* __buff)
4452{
4453 typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
4454 __destruct_n __d(0);
4455 unique_ptr<value_type, __destruct_n&> __h2(__buff, __d);
4456 if (__len1 <= __len2)
4457 {
4458 value_type* __p = __buff;
4459 for (_BidirectionalIterator __i = __first; __i != __middle; __d.__incr((value_type*)0), (void) ++__i, (void) ++__p)
4460 ::new(__p) value_type(_VSTD::move(*__i));
4461 __half_inplace_merge(__buff, __p, __middle, __last, __first, __comp);
4462 }
4463 else
4464 {
4465 value_type* __p = __buff;
4466 for (_BidirectionalIterator __i = __middle; __i != __last; __d.__incr((value_type*)0), (void) ++__i, (void) ++__p)
4467 ::new(__p) value_type(_VSTD::move(*__i));
4468 typedef reverse_iterator<_BidirectionalIterator> _RBi;
4469 typedef reverse_iterator<value_type*> _Rv;
4470 __half_inplace_merge(_Rv(__p), _Rv(__buff),
4471 _RBi(__middle), _RBi(__first),
4472 _RBi(__last), __invert<_Compare>(__comp));
4473 }
4474}
4475
4476template <class _Compare, class _BidirectionalIterator>
4477void
4478__inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
4479 _Compare __comp, typename iterator_traits<_BidirectionalIterator>::difference_type __len1,
4480 typename iterator_traits<_BidirectionalIterator>::difference_type __len2,
4481 typename iterator_traits<_BidirectionalIterator>::value_type* __buff, ptrdiff_t __buff_size)
4482{
4483 typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
4484 while (true)
4485 {
4486 // if __middle == __last, we're done
4487 if (__len2 == 0)
4488 return;
4489 if (__len1 <= __buff_size || __len2 <= __buff_size)
4490 return __buffered_inplace_merge<_Compare>
4491 (__first, __middle, __last, __comp, __len1, __len2, __buff);
4492 // shrink [__first, __middle) as much as possible (with no moves), returning if it shrinks to 0
4493 for (; true; ++__first, (void) --__len1)
4494 {
4495 if (__len1 == 0)
4496 return;
4497 if (__comp(*__middle, *__first))
4498 break;
4499 }
4500 // __first < __middle < __last
4501 // *__first > *__middle
4502 // partition [__first, __m1) [__m1, __middle) [__middle, __m2) [__m2, __last) such that
4503 // all elements in:
4504 // [__first, __m1) <= [__middle, __m2)
4505 // [__middle, __m2) < [__m1, __middle)
4506 // [__m1, __middle) <= [__m2, __last)
4507 // and __m1 or __m2 is in the middle of its range
4508 _BidirectionalIterator __m1; // "median" of [__first, __middle)
4509 _BidirectionalIterator __m2; // "median" of [__middle, __last)
4510 difference_type __len11; // distance(__first, __m1)
4511 difference_type __len21; // distance(__middle, __m2)
4512 // binary search smaller range
4513 if (__len1 < __len2)
4514 { // __len >= 1, __len2 >= 2
4515 __len21 = __len2 / 2;
4516 __m2 = __middle;
4517 _VSTD::advance(__m2, __len21);
4518 __m1 = __upper_bound<_Compare>(__first, __middle, *__m2, __comp);
4519 __len11 = _VSTD::distance(__first, __m1);
4520 }
4521 else
4522 {
4523 if (__len1 == 1)
4524 { // __len1 >= __len2 && __len2 > 0, therefore __len2 == 1
4525 // It is known *__first > *__middle
4526 swap(*__first, *__middle);
4527 return;
4528 }
4529 // __len1 >= 2, __len2 >= 1
4530 __len11 = __len1 / 2;
4531 __m1 = __first;
4532 _VSTD::advance(__m1, __len11);
4533 __m2 = __lower_bound<_Compare>(__middle, __last, *__m1, __comp);
4534 __len21 = _VSTD::distance(__middle, __m2);
4535 }
4536 difference_type __len12 = __len1 - __len11; // distance(__m1, __middle)
4537 difference_type __len22 = __len2 - __len21; // distance(__m2, __last)
4538 // [__first, __m1) [__m1, __middle) [__middle, __m2) [__m2, __last)
4539 // swap middle two partitions
4540 __middle = _VSTD::rotate(__m1, __middle, __m2);
4541 // __len12 and __len21 now have swapped meanings
4542 // merge smaller range with recurisve call and larger with tail recursion elimination
4543 if (__len11 + __len21 < __len12 + __len22)
4544 {
4545 __inplace_merge<_Compare>(__first, __m1, __middle, __comp, __len11, __len21, __buff, __buff_size);
4546// __inplace_merge<_Compare>(__middle, __m2, __last, __comp, __len12, __len22, __buff, __buff_size);
4547 __first = __middle;
4548 __middle = __m2;
4549 __len1 = __len12;
4550 __len2 = __len22;
4551 }
4552 else
4553 {
4554 __inplace_merge<_Compare>(__middle, __m2, __last, __comp, __len12, __len22, __buff, __buff_size);
4555// __inplace_merge<_Compare>(__first, __m1, __middle, __comp, __len11, __len21, __buff, __buff_size);
4556 __last = __middle;
4557 __middle = __m1;
4558 __len1 = __len11;
4559 __len2 = __len21;
4560 }
4561 }
4562}
4563
4564template <class _BidirectionalIterator, class _Compare>
4565inline _LIBCPP_INLINE_VISIBILITY
4566void
4567inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
4568 _Compare __comp)
4569{
4570 typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
4571 typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
4572 difference_type __len1 = _VSTD::distance(__first, __middle);
4573 difference_type __len2 = _VSTD::distance(__middle, __last);
4574 difference_type __buf_size = _VSTD::min(__len1, __len2);
4575 pair<value_type*, ptrdiff_t> __buf = _VSTD::get_temporary_buffer<value_type>(__buf_size);
4576 unique_ptr<value_type, __return_temporary_buffer> __h(__buf.first);
4577 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
4578 return _VSTD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __comp, __len1, __len2,
4579 __buf.first, __buf.second);
4580}
4581
4582template <class _BidirectionalIterator>
4583inline _LIBCPP_INLINE_VISIBILITY
4584void
4585inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last)
4586{
4587 _VSTD::inplace_merge(__first, __middle, __last,
4588 __less<typename iterator_traits<_BidirectionalIterator>::value_type>());
4589}
4590
4591// stable_sort
4592
4593template <class _Compare, class _InputIterator1, class _InputIterator2>
4594void
4595__merge_move_construct(_InputIterator1 __first1, _InputIterator1 __last1,
4596 _InputIterator2 __first2, _InputIterator2 __last2,
4597 typename iterator_traits<_InputIterator1>::value_type* __result, _Compare __comp)
4598{
4599 typedef typename iterator_traits<_InputIterator1>::value_type value_type;
4600 __destruct_n __d(0);
4601 unique_ptr<value_type, __destruct_n&> __h(__result, __d);
4602 for (; true; ++__result)
4603 {
4604 if (__first1 == __last1)
4605 {
4606 for (; __first2 != __last2; ++__first2, ++__result, (void) __d.__incr((value_type*)0))
4607 ::new (__result) value_type(_VSTD::move(*__first2));
4608 __h.release();
4609 return;
4610 }
4611 if (__first2 == __last2)
4612 {
4613 for (; __first1 != __last1; ++__first1, ++__result, (void) __d.__incr((value_type*)0))
4614 ::new (__result) value_type(_VSTD::move(*__first1));
4615 __h.release();
4616 return;
4617 }
4618 if (__comp(*__first2, *__first1))
4619 {
4620 ::new (__result) value_type(_VSTD::move(*__first2));
4621 __d.__incr((value_type*)0);
4622 ++__first2;
4623 }
4624 else
4625 {
4626 ::new (__result) value_type(_VSTD::move(*__first1));
4627 __d.__incr((value_type*)0);
4628 ++__first1;
4629 }
4630 }
4631}
4632
4633template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
4634void
4635__merge_move_assign(_InputIterator1 __first1, _InputIterator1 __last1,
4636 _InputIterator2 __first2, _InputIterator2 __last2,
4637 _OutputIterator __result, _Compare __comp)
4638{
4639 for (; __first1 != __last1; ++__result)
4640 {
4641 if (__first2 == __last2)
4642 {
4643 for (; __first1 != __last1; ++__first1, (void) ++__result)
4644 *__result = _VSTD::move(*__first1);
4645 return;
4646 }
4647 if (__comp(*__first2, *__first1))
4648 {
4649 *__result = _VSTD::move(*__first2);
4650 ++__first2;
4651 }
4652 else
4653 {
4654 *__result = _VSTD::move(*__first1);
4655 ++__first1;
4656 }
4657 }
4658 for (; __first2 != __last2; ++__first2, (void) ++__result)
4659 *__result = _VSTD::move(*__first2);
4660}
4661
4662template <class _Compare, class _RandomAccessIterator>
4663void
4664__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
4665 typename iterator_traits<_RandomAccessIterator>::difference_type __len,
4666 typename iterator_traits<_RandomAccessIterator>::value_type* __buff, ptrdiff_t __buff_size);
4667
4668template <class _Compare, class _RandomAccessIterator>
4669void
4670__stable_sort_move(_RandomAccessIterator __first1, _RandomAccessIterator __last1, _Compare __comp,
4671 typename iterator_traits<_RandomAccessIterator>::difference_type __len,
4672 typename iterator_traits<_RandomAccessIterator>::value_type* __first2)
4673{
4674 typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
4675 switch (__len)
4676 {
4677 case 0:
4678 return;
4679 case 1:
4680 ::new(__first2) value_type(_VSTD::move(*__first1));
4681 return;
4682 case 2:
4683 __destruct_n __d(0);
4684 unique_ptr<value_type, __destruct_n&> __h2(__first2, __d);
4685 if (__comp(*--__last1, *__first1))
4686 {
4687 ::new(__first2) value_type(_VSTD::move(*__last1));
4688 __d.__incr((value_type*)0);
4689 ++__first2;
4690 ::new(__first2) value_type(_VSTD::move(*__first1));
4691 }
4692 else
4693 {
4694 ::new(__first2) value_type(_VSTD::move(*__first1));
4695 __d.__incr((value_type*)0);
4696 ++__first2;
4697 ::new(__first2) value_type(_VSTD::move(*__last1));
4698 }
4699 __h2.release();
4700 return;
4701 }
4702 if (__len <= 8)
4703 {
4704 __insertion_sort_move<_Compare>(__first1, __last1, __first2, __comp);
4705 return;
4706 }
4707 typename iterator_traits<_RandomAccessIterator>::difference_type __l2 = __len / 2;
4708 _RandomAccessIterator __m = __first1 + __l2;
4709 __stable_sort<_Compare>(__first1, __m, __comp, __l2, __first2, __l2);
4710 __stable_sort<_Compare>(__m, __last1, __comp, __len - __l2, __first2 + __l2, __len - __l2);
4711 __merge_move_construct<_Compare>(__first1, __m, __m, __last1, __first2, __comp);
4712}
4713
4714template <class _Tp>
4715struct __stable_sort_switch
4716{
4717 static const unsigned value = 128*is_trivially_copy_assignable<_Tp>::value;
4718};
4719
4720template <class _Compare, class _RandomAccessIterator>
4721void
4722__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
4723 typename iterator_traits<_RandomAccessIterator>::difference_type __len,
4724 typename iterator_traits<_RandomAccessIterator>::value_type* __buff, ptrdiff_t __buff_size)
4725{
4726 typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
4727 typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
4728 switch (__len)
4729 {
4730 case 0:
4731 case 1:
4732 return;
4733 case 2:
4734 if (__comp(*--__last, *__first))
4735 swap(*__first, *__last);
4736 return;
4737 }
4738 if (__len <= static_cast<difference_type>(__stable_sort_switch<value_type>::value))
4739 {
4740 __insertion_sort<_Compare>(__first, __last, __comp);
4741 return;
4742 }
4743 typename iterator_traits<_RandomAccessIterator>::difference_type __l2 = __len / 2;
4744 _RandomAccessIterator __m = __first + __l2;
4745 if (__len <= __buff_size)
4746 {
4747 __destruct_n __d(0);
4748 unique_ptr<value_type, __destruct_n&> __h2(__buff, __d);
4749 __stable_sort_move<_Compare>(__first, __m, __comp, __l2, __buff);
4750 __d.__set(__l2, (value_type*)0);
4751 __stable_sort_move<_Compare>(__m, __last, __comp, __len - __l2, __buff + __l2);
4752 __d.__set(__len, (value_type*)0);
4753 __merge_move_assign<_Compare>(__buff, __buff + __l2, __buff + __l2, __buff + __len, __first, __comp);
4754// __merge<_Compare>(move_iterator<value_type*>(__buff),
4755// move_iterator<value_type*>(__buff + __l2),
4756// move_iterator<_RandomAccessIterator>(__buff + __l2),
4757// move_iterator<_RandomAccessIterator>(__buff + __len),
4758// __first, __comp);
4759 return;
4760 }
4761 __stable_sort<_Compare>(__first, __m, __comp, __l2, __buff, __buff_size);
4762 __stable_sort<_Compare>(__m, __last, __comp, __len - __l2, __buff, __buff_size);
4763 __inplace_merge<_Compare>(__first, __m, __last, __comp, __l2, __len - __l2, __buff, __buff_size);
4764}
4765
4766template <class _RandomAccessIterator, class _Compare>
4767inline _LIBCPP_INLINE_VISIBILITY
4768void
4769stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
4770{
4771 typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
4772 typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
4773 difference_type __len = __last - __first;
4774 pair<value_type*, ptrdiff_t> __buf(0, 0);
4775 unique_ptr<value_type, __return_temporary_buffer> __h;
4776 if (__len > static_cast<difference_type>(__stable_sort_switch<value_type>::value))
4777 {
4778 __buf = _VSTD::get_temporary_buffer<value_type>(__len);
4779 __h.reset(__buf.first);
4780 }
4781 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
4782 __stable_sort<_Comp_ref>(__first, __last, __comp, __len, __buf.first, __buf.second);
4783}
4784
4785template <class _RandomAccessIterator>
4786inline _LIBCPP_INLINE_VISIBILITY
4787void
4788stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
4789{
4790 _VSTD::stable_sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
4791}
4792
4793// is_heap_until
4794
4795template <class _RandomAccessIterator, class _Compare>
4796_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_AFTER_CXX17 _RandomAccessIterator
4797is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
4798{
4799 typedef typename _VSTD::iterator_traits<_RandomAccessIterator>::difference_type difference_type;
4800 difference_type __len = __last - __first;
4801 difference_type __p = 0;
4802 difference_type __c = 1;
4803 _RandomAccessIterator __pp = __first;
4804 while (__c < __len)
4805 {
4806 _RandomAccessIterator __cp = __first + __c;
4807 if (__comp(*__pp, *__cp))
4808 return __cp;
4809 ++__c;
4810 ++__cp;
4811 if (__c == __len)
4812 return __last;
4813 if (__comp(*__pp, *__cp))
4814 return __cp;
4815 ++__p;
4816 ++__pp;
4817 __c = 2 * __p + 1;
4818 }
4819 return __last;
4820}
4821
4822template<class _RandomAccessIterator>
4823_LIBCPP_NODISCARD_EXT inline
4824_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
4825_RandomAccessIterator
4826is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
4827{
4828 return _VSTD::is_heap_until(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
4829}
4830
4831// is_heap
4832
4833template <class _RandomAccessIterator, class _Compare>
4834_LIBCPP_NODISCARD_EXT inline
4835_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
4836bool
4837is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
4838{
4839 return _VSTD::is_heap_until(__first, __last, __comp) == __last;
4840}
4841
4842template<class _RandomAccessIterator>
4843_LIBCPP_NODISCARD_EXT inline
4844_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
4845bool
4846is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
4847{
4848 return _VSTD::is_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
4849}
4850
4851// push_heap
4852
4853template <class _Compare, class _RandomAccessIterator>
4854void
4855__sift_up(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
4856 typename iterator_traits<_RandomAccessIterator>::difference_type __len)
4857{
4858 typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
4859 if (__len > 1)
4860 {
4861 __len = (__len - 2) / 2;
4862 _RandomAccessIterator __ptr = __first + __len;
4863 if (__comp(*__ptr, *--__last))
4864 {
4865 value_type __t(_VSTD::move(*__last));
4866 do
4867 {
4868 *__last = _VSTD::move(*__ptr);
4869 __last = __ptr;
4870 if (__len == 0)
4871 break;
4872 __len = (__len - 1) / 2;
4873 __ptr = __first + __len;
4874 } while (__comp(*__ptr, __t));
4875 *__last = _VSTD::move(__t);
4876 }
4877 }
4878}
4879
4880template <class _RandomAccessIterator, class _Compare>
4881inline _LIBCPP_INLINE_VISIBILITY
4882void
4883push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
4884{
4885 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
4886 __sift_up<_Comp_ref>(__first, __last, __comp, __last - __first);
4887}
4888
4889template <class _RandomAccessIterator>
4890inline _LIBCPP_INLINE_VISIBILITY
4891void
4892push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
4893{
4894 _VSTD::push_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
4895}
4896
4897// pop_heap
4898
4899template <class _Compare, class _RandomAccessIterator>
4900void
4901__sift_down(_RandomAccessIterator __first, _RandomAccessIterator /*__last*/,
4902 _Compare __comp,
4903 typename iterator_traits<_RandomAccessIterator>::difference_type __len,
4904 _RandomAccessIterator __start)
4905{
4906 typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
4907 typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
4908 // left-child of __start is at 2 * __start + 1
4909 // right-child of __start is at 2 * __start + 2
4910 difference_type __child = __start - __first;
4911
4912 if (__len < 2 || (__len - 2) / 2 < __child)
4913 return;
4914
4915 __child = 2 * __child + 1;
4916 _RandomAccessIterator __child_i = __first + __child;
4917
4918 if ((__child + 1) < __len && __comp(*__child_i, *(__child_i + 1))) {
4919 // right-child exists and is greater than left-child
4920 ++__child_i;
4921 ++__child;
4922 }
4923
4924 // check if we are in heap-order
4925 if (__comp(*__child_i, *__start))
4926 // we are, __start is larger than it's largest child
4927 return;
4928
4929 value_type __top(_VSTD::move(*__start));
4930 do
4931 {
4932 // we are not in heap-order, swap the parent with it's largest child
4933 *__start = _VSTD::move(*__child_i);
4934 __start = __child_i;
4935
4936 if ((__len - 2) / 2 < __child)
4937 break;
4938
4939 // recompute the child based off of the updated parent
4940 __child = 2 * __child + 1;
4941 __child_i = __first + __child;
4942
4943 if ((__child + 1) < __len && __comp(*__child_i, *(__child_i + 1))) {
4944 // right-child exists and is greater than left-child
4945 ++__child_i;
4946 ++__child;
4947 }
4948
4949 // check if we are in heap-order
4950 } while (!__comp(*__child_i, __top));
4951 *__start = _VSTD::move(__top);
4952}
4953
4954template <class _Compare, class _RandomAccessIterator>
4955inline _LIBCPP_INLINE_VISIBILITY
4956void
4957__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
4958 typename iterator_traits<_RandomAccessIterator>::difference_type __len)
4959{
4960 if (__len > 1)
4961 {
4962 swap(*__first, *--__last);
4963 __sift_down<_Compare>(__first, __last, __comp, __len - 1, __first);
4964 }
4965}
4966
4967template <class _RandomAccessIterator, class _Compare>
4968inline _LIBCPP_INLINE_VISIBILITY
4969void
4970pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
4971{
4972 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
4973 __pop_heap<_Comp_ref>(__first, __last, __comp, __last - __first);
4974}
4975
4976template <class _RandomAccessIterator>
4977inline _LIBCPP_INLINE_VISIBILITY
4978void
4979pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
4980{
4981 _VSTD::pop_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
4982}
4983
4984// make_heap
4985
4986template <class _Compare, class _RandomAccessIterator>
4987void
4988__make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
4989{
4990 typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
4991 difference_type __n = __last - __first;
4992 if (__n > 1)
4993 {
4994 // start from the first parent, there is no need to consider children
4995 for (difference_type __start = (__n - 2) / 2; __start >= 0; --__start)
4996 {
4997 __sift_down<_Compare>(__first, __last, __comp, __n, __first + __start);
4998 }
4999 }
5000}
5001
5002template <class _RandomAccessIterator, class _Compare>
5003inline _LIBCPP_INLINE_VISIBILITY
5004void
5005make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
5006{
5007 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
5008 __make_heap<_Comp_ref>(__first, __last, __comp);
5009}
5010
5011template <class _RandomAccessIterator>
5012inline _LIBCPP_INLINE_VISIBILITY
5013void
5014make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
5015{
5016 _VSTD::make_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
5017}
5018
5019// sort_heap
5020
5021template <class _Compare, class _RandomAccessIterator>
5022void
5023__sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
5024{
5025 typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
5026 for (difference_type __n = __last - __first; __n > 1; --__last, (void) --__n)
5027 __pop_heap<_Compare>(__first, __last, __comp, __n);
5028}
5029
5030template <class _RandomAccessIterator, class _Compare>
5031inline _LIBCPP_INLINE_VISIBILITY
5032void
5033sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
5034{
5035 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
5036 __sort_heap<_Comp_ref>(__first, __last, __comp);
5037}
5038
5039template <class _RandomAccessIterator>
5040inline _LIBCPP_INLINE_VISIBILITY
5041void
5042sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
5043{
5044 _VSTD::sort_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
5045}
5046
5047// partial_sort
5048
5049template <class _Compare, class _RandomAccessIterator>
5050void
5051__partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last,
5052 _Compare __comp)
5053{
5054 __make_heap<_Compare>(__first, __middle, __comp);
5055 typename iterator_traits<_RandomAccessIterator>::difference_type __len = __middle - __first;
5056 for (_RandomAccessIterator __i = __middle; __i != __last; ++__i)
5057 {
5058 if (__comp(*__i, *__first))
5059 {
5060 swap(*__i, *__first);
5061 __sift_down<_Compare>(__first, __middle, __comp, __len, __first);
5062 }
5063 }
5064 __sort_heap<_Compare>(__first, __middle, __comp);
5065}
5066
5067template <class _RandomAccessIterator, class _Compare>
5068inline _LIBCPP_INLINE_VISIBILITY
5069void
5070partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last,
5071 _Compare __comp)
5072{
5073 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
5074 __partial_sort<_Comp_ref>(__first, __middle, __last, __comp);
5075}
5076
5077template <class _RandomAccessIterator>
5078inline _LIBCPP_INLINE_VISIBILITY
5079void
5080partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last)
5081{
5082 _VSTD::partial_sort(__first, __middle, __last,
5083 __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
5084}
5085
5086// partial_sort_copy
5087
5088template <class _Compare, class _InputIterator, class _RandomAccessIterator>
5089_RandomAccessIterator
5090__partial_sort_copy(_InputIterator __first, _InputIterator __last,
5091 _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp)
5092{
5093 _RandomAccessIterator __r = __result_first;
5094 if (__r != __result_last)
5095 {
5096 for (; __first != __last && __r != __result_last; ++__first, (void) ++__r)
5097 *__r = *__first;
5098 __make_heap<_Compare>(__result_first, __r, __comp);
5099 typename iterator_traits<_RandomAccessIterator>::difference_type __len = __r - __result_first;
5100 for (; __first != __last; ++__first)
5101 if (__comp(*__first, *__result_first))
5102 {
5103 *__result_first = *__first;
5104 __sift_down<_Compare>(__result_first, __r, __comp, __len, __result_first);
5105 }
5106 __sort_heap<_Compare>(__result_first, __r, __comp);
5107 }
5108 return __r;
5109}
5110
5111template <class _InputIterator, class _RandomAccessIterator, class _Compare>
5112inline _LIBCPP_INLINE_VISIBILITY
5113_RandomAccessIterator
5114partial_sort_copy(_InputIterator __first, _InputIterator __last,
5115 _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp)
5116{
5117 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
5118 return __partial_sort_copy<_Comp_ref>(__first, __last, __result_first, __result_last, __comp);
5119}
5120
5121template <class _InputIterator, class _RandomAccessIterator>
5122inline _LIBCPP_INLINE_VISIBILITY
5123_RandomAccessIterator
5124partial_sort_copy(_InputIterator __first, _InputIterator __last,
5125 _RandomAccessIterator __result_first, _RandomAccessIterator __result_last)
5126{
5127 return _VSTD::partial_sort_copy(__first, __last, __result_first, __result_last,
5128 __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
5129}
5130
5131// nth_element
5132
5133template <class _Compare, class _RandomAccessIterator>
5134void
5135__nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp)
5136{
5137 // _Compare is known to be a reference type
5138 typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
5139 const difference_type __limit = 7;
5140 while (true)
5141 {
5142 __restart:
5143 if (__nth == __last)
5144 return;
5145 difference_type __len = __last - __first;
5146 switch (__len)
5147 {
5148 case 0:
5149 case 1:
5150 return;
5151 case 2:
5152 if (__comp(*--__last, *__first))
5153 swap(*__first, *__last);
5154 return;
5155 case 3:
5156 {
5157 _RandomAccessIterator __m = __first;
5158 _VSTD::__sort3<_Compare>(__first, ++__m, --__last, __comp);
5159 return;
5160 }
5161 }
5162 if (__len <= __limit)
5163 {
5164 __selection_sort<_Compare>(__first, __last, __comp);
5165 return;
5166 }
5167 // __len > __limit >= 3
5168 _RandomAccessIterator __m = __first + __len/2;
5169 _RandomAccessIterator __lm1 = __last;
5170 unsigned __n_swaps = _VSTD::__sort3<_Compare>(__first, __m, --__lm1, __comp);
5171 // *__m is median
5172 // partition [__first, __m) < *__m and *__m <= [__m, __last)
5173 // (this inhibits tossing elements equivalent to __m around unnecessarily)
5174 _RandomAccessIterator __i = __first;
5175 _RandomAccessIterator __j = __lm1;
5176 // j points beyond range to be tested, *__lm1 is known to be <= *__m
5177 // The search going up is known to be guarded but the search coming down isn't.
5178 // Prime the downward search with a guard.
5179 if (!__comp(*__i, *__m)) // if *__first == *__m
5180 {
5181 // *__first == *__m, *__first doesn't go in first part
5182 // manually guard downward moving __j against __i
5183 while (true)
5184 {
5185 if (__i == --__j)
5186 {
5187 // *__first == *__m, *__m <= all other elements
5188 // Parition instead into [__first, __i) == *__first and *__first < [__i, __last)
5189 ++__i; // __first + 1
5190 __j = __last;
5191 if (!__comp(*__first, *--__j)) // we need a guard if *__first == *(__last-1)
5192 {
5193 while (true)
5194 {
5195 if (__i == __j)
5196 return; // [__first, __last) all equivalent elements
5197 if (__comp(*__first, *__i))
5198 {
5199 swap(*__i, *__j);
5200 ++__n_swaps;
5201 ++__i;
5202 break;
5203 }
5204 ++__i;
5205 }
5206 }
5207 // [__first, __i) == *__first and *__first < [__j, __last) and __j == __last - 1
5208 if (__i == __j)
5209 return;
5210 while (true)
5211 {
5212 while (!__comp(*__first, *__i))
5213 ++__i;
5214 while (__comp(*__first, *--__j))
5215 ;
5216 if (__i >= __j)
5217 break;
5218 swap(*__i, *__j);
5219 ++__n_swaps;
5220 ++__i;
5221 }
5222 // [__first, __i) == *__first and *__first < [__i, __last)
5223 // The first part is sorted,
5224 if (__nth < __i)
5225 return;
5226 // __nth_element the secod part
5227 // __nth_element<_Compare>(__i, __nth, __last, __comp);
5228 __first = __i;
5229 goto __restart;
5230 }
5231 if (__comp(*__j, *__m))
5232 {
5233 swap(*__i, *__j);
5234 ++__n_swaps;
5235 break; // found guard for downward moving __j, now use unguarded partition
5236 }
5237 }
5238 }
5239 ++__i;
5240 // j points beyond range to be tested, *__lm1 is known to be <= *__m
5241 // if not yet partitioned...
5242 if (__i < __j)
5243 {
5244 // known that *(__i - 1) < *__m
5245 while (true)
5246 {
5247 // __m still guards upward moving __i
5248 while (__comp(*__i, *__m))
5249 ++__i;
5250 // It is now known that a guard exists for downward moving __j
5251 while (!__comp(*--__j, *__m))
5252 ;
5253 if (__i >= __j)
5254 break;
5255 swap(*__i, *__j);
5256 ++__n_swaps;
5257 // It is known that __m != __j
5258 // If __m just moved, follow it
5259 if (__m == __i)
5260 __m = __j;
5261 ++__i;
5262 }
5263 }
5264 // [__first, __i) < *__m and *__m <= [__i, __last)
5265 if (__i != __m && __comp(*__m, *__i))
5266 {
5267 swap(*__i, *__m);
5268 ++__n_swaps;
5269 }
5270 // [__first, __i) < *__i and *__i <= [__i+1, __last)
5271 if (__nth == __i)
5272 return;
5273 if (__n_swaps == 0)
5274 {
5275 // We were given a perfectly partitioned sequence. Coincidence?
5276 if (__nth < __i)
5277 {
5278 // Check for [__first, __i) already sorted
5279 __j = __m = __first;
5280 while (++__j != __i)
5281 {
5282 if (__comp(*__j, *__m))
5283 // not yet sorted, so sort
5284 goto not_sorted;
5285 __m = __j;
5286 }
5287 // [__first, __i) sorted
5288 return;
5289 }
5290 else
5291 {
5292 // Check for [__i, __last) already sorted
5293 __j = __m = __i;
5294 while (++__j != __last)
5295 {
5296 if (__comp(*__j, *__m))
5297 // not yet sorted, so sort
5298 goto not_sorted;
5299 __m = __j;
5300 }
5301 // [__i, __last) sorted
5302 return;
5303 }
5304 }
5305not_sorted:
5306 // __nth_element on range containing __nth
5307 if (__nth < __i)
5308 {
5309 // __nth_element<_Compare>(__first, __nth, __i, __comp);
5310 __last = __i;
5311 }
5312 else
5313 {
5314 // __nth_element<_Compare>(__i+1, __nth, __last, __comp);
5315 __first = ++__i;
5316 }
5317 }
5318}
5319
5320template <class _RandomAccessIterator, class _Compare>
5321inline _LIBCPP_INLINE_VISIBILITY
5322void
5323nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp)
5324{
5325 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
5326 __nth_element<_Comp_ref>(__first, __nth, __last, __comp);
5327}
5328
5329template <class _RandomAccessIterator>
5330inline _LIBCPP_INLINE_VISIBILITY
5331void
5332nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last)
5333{
5334 _VSTD::nth_element(__first, __nth, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
5335}
5336
5337// includes
5338
5339template <class _Compare, class _InputIterator1, class _InputIterator2>
5340_LIBCPP_CONSTEXPR_AFTER_CXX17 bool
5341__includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2,
5342 _Compare __comp)
5343{
5344 for (; __first2 != __last2; ++__first1)
5345 {
5346 if (__first1 == __last1 || __comp(*__first2, *__first1))
5347 return false;
5348 if (!__comp(*__first1, *__first2))
5349 ++__first2;
5350 }
5351 return true;
5352}
5353
5354template <class _InputIterator1, class _InputIterator2, class _Compare>
5355_LIBCPP_NODISCARD_EXT inline
5356_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
5357bool
5358includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2,
5359 _Compare __comp)
5360{
5361 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
5362 return __includes<_Comp_ref>(__first1, __last1, __first2, __last2, __comp);
5363}
5364
5365template <class _InputIterator1, class _InputIterator2>
5366_LIBCPP_NODISCARD_EXT inline
5367_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
5368bool
5369includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2)
5370{
5371 return _VSTD::includes(__first1, __last1, __first2, __last2,
5372 __less<typename iterator_traits<_InputIterator1>::value_type,
5373 typename iterator_traits<_InputIterator2>::value_type>());
5374}
5375
5376// set_union
5377
5378template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
5379_OutputIterator
5380__set_union(_InputIterator1 __first1, _InputIterator1 __last1,
5381 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
5382{
5383 for (; __first1 != __last1; ++__result)
5384 {
5385 if (__first2 == __last2)
5386 return _VSTD::copy(__first1, __last1, __result);
5387 if (__comp(*__first2, *__first1))
5388 {
5389 *__result = *__first2;
5390 ++__first2;
5391 }
5392 else
5393 {
5394 if (!__comp(*__first1, *__first2))
5395 ++__first2;
5396 *__result = *__first1;
5397 ++__first1;
5398 }
5399 }
5400 return _VSTD::copy(__first2, __last2, __result);
5401}
5402
5403template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
5404inline _LIBCPP_INLINE_VISIBILITY
5405_OutputIterator
5406set_union(_InputIterator1 __first1, _InputIterator1 __last1,
5407 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
5408{
5409 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
5410 return __set_union<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
5411}
5412
5413template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
5414inline _LIBCPP_INLINE_VISIBILITY
5415_OutputIterator
5416set_union(_InputIterator1 __first1, _InputIterator1 __last1,
5417 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
5418{
5419 return _VSTD::set_union(__first1, __last1, __first2, __last2, __result,
5420 __less<typename iterator_traits<_InputIterator1>::value_type,
5421 typename iterator_traits<_InputIterator2>::value_type>());
5422}
5423
5424// set_intersection
5425
5426template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
5427_LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator
5428__set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
5429 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
5430{
5431 while (__first1 != __last1 && __first2 != __last2)
5432 {
5433 if (__comp(*__first1, *__first2))
5434 ++__first1;
5435 else
5436 {
5437 if (!__comp(*__first2, *__first1))
5438 {
5439 *__result = *__first1;
5440 ++__result;
5441 ++__first1;
5442 }
5443 ++__first2;
5444 }
5445 }
5446 return __result;
5447}
5448
5449template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
5450inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
5451_OutputIterator
5452set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
5453 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
5454{
5455 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
5456 return __set_intersection<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
5457}
5458
5459template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
5460inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
5461_OutputIterator
5462set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
5463 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
5464{
5465 return _VSTD::set_intersection(__first1, __last1, __first2, __last2, __result,
5466 __less<typename iterator_traits<_InputIterator1>::value_type,
5467 typename iterator_traits<_InputIterator2>::value_type>());
5468}
5469
5470// set_difference
5471
5472template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
5473_OutputIterator
5474__set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
5475 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
5476{
5477 while (__first1 != __last1)
5478 {
5479 if (__first2 == __last2)
5480 return _VSTD::copy(__first1, __last1, __result);
5481 if (__comp(*__first1, *__first2))
5482 {
5483 *__result = *__first1;
5484 ++__result;
5485 ++__first1;
5486 }
5487 else
5488 {
5489 if (!__comp(*__first2, *__first1))
5490 ++__first1;
5491 ++__first2;
5492 }
5493 }
5494 return __result;
5495}
5496
5497template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
5498inline _LIBCPP_INLINE_VISIBILITY
5499_OutputIterator
5500set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
5501 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
5502{
5503 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
5504 return __set_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
5505}
5506
5507template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
5508inline _LIBCPP_INLINE_VISIBILITY
5509_OutputIterator
5510set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
5511 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
5512{
5513 return _VSTD::set_difference(__first1, __last1, __first2, __last2, __result,
5514 __less<typename iterator_traits<_InputIterator1>::value_type,
5515 typename iterator_traits<_InputIterator2>::value_type>());
5516}
5517
5518// set_symmetric_difference
5519
5520template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
5521_OutputIterator
5522__set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
5523 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
5524{
5525 while (__first1 != __last1)
5526 {
5527 if (__first2 == __last2)
5528 return _VSTD::copy(__first1, __last1, __result);
5529 if (__comp(*__first1, *__first2))
5530 {
5531 *__result = *__first1;
5532 ++__result;
5533 ++__first1;
5534 }
5535 else
5536 {
5537 if (__comp(*__first2, *__first1))
5538 {
5539 *__result = *__first2;
5540 ++__result;
5541 }
5542 else
5543 ++__first1;
5544 ++__first2;
5545 }
5546 }
5547 return _VSTD::copy(__first2, __last2, __result);
5548}
5549
5550template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
5551inline _LIBCPP_INLINE_VISIBILITY
5552_OutputIterator
5553set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
5554 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
5555{
5556 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
5557 return __set_symmetric_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
5558}
5559
5560template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
5561inline _LIBCPP_INLINE_VISIBILITY
5562_OutputIterator
5563set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
5564 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
5565{
5566 return _VSTD::set_symmetric_difference(__first1, __last1, __first2, __last2, __result,
5567 __less<typename iterator_traits<_InputIterator1>::value_type,
5568 typename iterator_traits<_InputIterator2>::value_type>());
5569}
5570
5571// lexicographical_compare
5572
5573template <class _Compare, class _InputIterator1, class _InputIterator2>
5574_LIBCPP_CONSTEXPR_AFTER_CXX17 bool
5575__lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
5576 _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp)
5577{
5578 for (; __first2 != __last2; ++__first1, (void) ++__first2)
5579 {
5580 if (__first1 == __last1 || __comp(*__first1, *__first2))
5581 return true;
5582 if (__comp(*__first2, *__first1))
5583 return false;
5584 }
5585 return false;
5586}
5587
5588template <class _InputIterator1, class _InputIterator2, class _Compare>
5589_LIBCPP_NODISCARD_EXT inline
5590_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
5591bool
5592lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
5593 _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp)
5594{
5595 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
5596 return __lexicographical_compare<_Comp_ref>(__first1, __last1, __first2, __last2, __comp);
5597}
5598
5599template <class _InputIterator1, class _InputIterator2>
5600_LIBCPP_NODISCARD_EXT inline
5601_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
5602bool
5603lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
5604 _InputIterator2 __first2, _InputIterator2 __last2)
5605{
5606 return _VSTD::lexicographical_compare(__first1, __last1, __first2, __last2,
5607 __less<typename iterator_traits<_InputIterator1>::value_type,
5608 typename iterator_traits<_InputIterator2>::value_type>());
5609}
5610
5611// next_permutation
5612
5613template <class _Compare, class _BidirectionalIterator>
5614bool
5615__next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
5616{
5617 _BidirectionalIterator __i = __last;
5618 if (__first == __last || __first == --__i)
5619 return false;
5620 while (true)
5621 {
5622 _BidirectionalIterator __ip1 = __i;
5623 if (__comp(*--__i, *__ip1))
5624 {
5625 _BidirectionalIterator __j = __last;
5626 while (!__comp(*__i, *--__j))
5627 ;
5628 swap(*__i, *__j);
5629 _VSTD::reverse(__ip1, __last);
5630 return true;
5631 }
5632 if (__i == __first)
5633 {
5634 _VSTD::reverse(__first, __last);
5635 return false;
5636 }
5637 }
5638}
5639
5640template <class _BidirectionalIterator, class _Compare>
5641inline _LIBCPP_INLINE_VISIBILITY
5642bool
5643next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
5644{
5645 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
5646 return __next_permutation<_Comp_ref>(__first, __last, __comp);
5647}
5648
5649template <class _BidirectionalIterator>
5650inline _LIBCPP_INLINE_VISIBILITY
5651bool
5652next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
5653{
5654 return _VSTD::next_permutation(__first, __last,
5655 __less<typename iterator_traits<_BidirectionalIterator>::value_type>());
5656}
5657
5658// prev_permutation
5659
5660template <class _Compare, class _BidirectionalIterator>
5661bool
5662__prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
5663{
5664 _BidirectionalIterator __i = __last;
5665 if (__first == __last || __first == --__i)
5666 return false;
5667 while (true)
5668 {
5669 _BidirectionalIterator __ip1 = __i;
5670 if (__comp(*__ip1, *--__i))
5671 {
5672 _BidirectionalIterator __j = __last;
5673 while (!__comp(*--__j, *__i))
5674 ;
5675 swap(*__i, *__j);
5676 _VSTD::reverse(__ip1, __last);
5677 return true;
5678 }
5679 if (__i == __first)
5680 {
5681 _VSTD::reverse(__first, __last);
5682 return false;
5683 }
5684 }
5685}
5686
5687template <class _BidirectionalIterator, class _Compare>
5688inline _LIBCPP_INLINE_VISIBILITY
5689bool
5690prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
5691{
5692 typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
5693 return __prev_permutation<_Comp_ref>(__first, __last, __comp);
5694}
5695
5696template <class _BidirectionalIterator>
5697inline _LIBCPP_INLINE_VISIBILITY
5698bool
5699prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
5700{
5701 return _VSTD::prev_permutation(__first, __last,
5702 __less<typename iterator_traits<_BidirectionalIterator>::value_type>());
5703}
5704
5705_LIBCPP_END_NAMESPACE_STD
5706
5707_LIBCPP_POP_MACROS
5708
5709#if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
5710# include <__pstl_algorithm>
5711#endif
5712
5713#endif // _LIBCPP_ALGORITHM
5714