contrib/libc++/include/algorithm

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