17a984708SDavid Chisnall// -*- C++ -*-
27a984708SDavid Chisnall//===-------------------------- algorithm ---------------------------------===//
37a984708SDavid Chisnall//
47a984708SDavid Chisnall//                     The LLVM Compiler Infrastructure
57a984708SDavid Chisnall//
67a984708SDavid Chisnall// This file is dual licensed under the MIT and the University of Illinois Open
77a984708SDavid Chisnall// Source Licenses. See LICENSE.TXT for details.
87a984708SDavid Chisnall//
97a984708SDavid Chisnall//===----------------------------------------------------------------------===//
107a984708SDavid Chisnall
117a984708SDavid Chisnall#ifndef _LIBCPP_ALGORITHM
127a984708SDavid Chisnall#define _LIBCPP_ALGORITHM
137a984708SDavid Chisnall
147a984708SDavid Chisnall/*
157a984708SDavid Chisnall    algorithm synopsis
167a984708SDavid Chisnall
177a984708SDavid Chisnall#include <initializer_list>
187a984708SDavid Chisnall
197a984708SDavid Chisnallnamespace std
207a984708SDavid Chisnall{
217a984708SDavid Chisnall
227a984708SDavid Chisnalltemplate <class InputIterator, class Predicate>
237a984708SDavid Chisnall    bool
247a984708SDavid Chisnall    all_of(InputIterator first, InputIterator last, Predicate pred);
257a984708SDavid Chisnall
267a984708SDavid Chisnalltemplate <class InputIterator, class Predicate>
277a984708SDavid Chisnall    bool
287a984708SDavid Chisnall    any_of(InputIterator first, InputIterator last, Predicate pred);
297a984708SDavid Chisnall
307a984708SDavid Chisnalltemplate <class InputIterator, class Predicate>
317a984708SDavid Chisnall    bool
327a984708SDavid Chisnall    none_of(InputIterator first, InputIterator last, Predicate pred);
337a984708SDavid Chisnall
347a984708SDavid Chisnalltemplate <class InputIterator, class Function>
357a984708SDavid Chisnall    Function
367a984708SDavid Chisnall    for_each(InputIterator first, InputIterator last, Function f);
377a984708SDavid Chisnall
387a984708SDavid Chisnalltemplate <class InputIterator, class T>
397a984708SDavid Chisnall    InputIterator
407a984708SDavid Chisnall    find(InputIterator first, InputIterator last, const T& value);
417a984708SDavid Chisnall
427a984708SDavid Chisnalltemplate <class InputIterator, class Predicate>
437a984708SDavid Chisnall    InputIterator
447a984708SDavid Chisnall    find_if(InputIterator first, InputIterator last, Predicate pred);
457a984708SDavid Chisnall
467a984708SDavid Chisnalltemplate<class InputIterator, class Predicate>
477a984708SDavid Chisnall    InputIterator
487a984708SDavid Chisnall    find_if_not(InputIterator first, InputIterator last, Predicate pred);
497a984708SDavid Chisnall
507a984708SDavid Chisnalltemplate <class ForwardIterator1, class ForwardIterator2>
517a984708SDavid Chisnall    ForwardIterator1
527a984708SDavid Chisnall    find_end(ForwardIterator1 first1, ForwardIterator1 last1,
537a984708SDavid Chisnall             ForwardIterator2 first2, ForwardIterator2 last2);
547a984708SDavid Chisnall
557a984708SDavid Chisnalltemplate <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
567a984708SDavid Chisnall    ForwardIterator1
577a984708SDavid Chisnall    find_end(ForwardIterator1 first1, ForwardIterator1 last1,
587a984708SDavid Chisnall             ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
597a984708SDavid Chisnall
607a984708SDavid Chisnalltemplate <class ForwardIterator1, class ForwardIterator2>
617a984708SDavid Chisnall    ForwardIterator1
627a984708SDavid Chisnall    find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
637a984708SDavid Chisnall                  ForwardIterator2 first2, ForwardIterator2 last2);
647a984708SDavid Chisnall
657a984708SDavid Chisnalltemplate <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
667a984708SDavid Chisnall    ForwardIterator1
677a984708SDavid Chisnall    find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
687a984708SDavid Chisnall                  ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
697a984708SDavid Chisnall
707a984708SDavid Chisnalltemplate <class ForwardIterator>
717a984708SDavid Chisnall    ForwardIterator
727a984708SDavid Chisnall    adjacent_find(ForwardIterator first, ForwardIterator last);
737a984708SDavid Chisnall
747a984708SDavid Chisnalltemplate <class ForwardIterator, class BinaryPredicate>
757a984708SDavid Chisnall    ForwardIterator
767a984708SDavid Chisnall    adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate pred);
777a984708SDavid Chisnall
787a984708SDavid Chisnalltemplate <class InputIterator, class T>
797a984708SDavid Chisnall    typename iterator_traits<InputIterator>::difference_type
807a984708SDavid Chisnall    count(InputIterator first, InputIterator last, const T& value);
817a984708SDavid Chisnall
827a984708SDavid Chisnalltemplate <class InputIterator, class Predicate>
837a984708SDavid Chisnall    typename iterator_traits<InputIterator>::difference_type
847a984708SDavid Chisnall    count_if(InputIterator first, InputIterator last, Predicate pred);
857a984708SDavid Chisnall
867a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2>
877a984708SDavid Chisnall    pair<InputIterator1, InputIterator2>
887a984708SDavid Chisnall    mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
897a984708SDavid Chisnall
907a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class BinaryPredicate>
917a984708SDavid Chisnall    pair<InputIterator1, InputIterator2>
927a984708SDavid Chisnall    mismatch(InputIterator1 first1, InputIterator1 last1,
937a984708SDavid Chisnall             InputIterator2 first2, BinaryPredicate pred);
947a984708SDavid Chisnall
957a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2>
967a984708SDavid Chisnall    bool
977a984708SDavid Chisnall    equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
987a984708SDavid Chisnall
997a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class BinaryPredicate>
1007a984708SDavid Chisnall    bool
1017a984708SDavid Chisnall    equal(InputIterator1 first1, InputIterator1 last1,
1027a984708SDavid Chisnall          InputIterator2 first2, BinaryPredicate pred);
1037a984708SDavid Chisnall
1047a984708SDavid Chisnalltemplate<class ForwardIterator1, class ForwardIterator2>
1057a984708SDavid Chisnall    bool
1067a984708SDavid Chisnall    is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
1077a984708SDavid Chisnall                   ForwardIterator2 first2);
1087a984708SDavid Chisnall
1097a984708SDavid Chisnalltemplate<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
1107a984708SDavid Chisnall    bool
1117a984708SDavid Chisnall    is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
1127a984708SDavid Chisnall                   ForwardIterator2 first2, BinaryPredicate pred);
1137a984708SDavid Chisnall
1147a984708SDavid Chisnalltemplate <class ForwardIterator1, class ForwardIterator2>
1157a984708SDavid Chisnall    ForwardIterator1
1167a984708SDavid Chisnall    search(ForwardIterator1 first1, ForwardIterator1 last1,
1177a984708SDavid Chisnall           ForwardIterator2 first2, ForwardIterator2 last2);
1187a984708SDavid Chisnall
1197a984708SDavid Chisnalltemplate <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
1207a984708SDavid Chisnall    ForwardIterator1
1217a984708SDavid Chisnall    search(ForwardIterator1 first1, ForwardIterator1 last1,
1227a984708SDavid Chisnall           ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
1237a984708SDavid Chisnall
1247a984708SDavid Chisnalltemplate <class ForwardIterator, class Size, class T>
1257a984708SDavid Chisnall    ForwardIterator
1267a984708SDavid Chisnall    search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value);
1277a984708SDavid Chisnall
1287a984708SDavid Chisnalltemplate <class ForwardIterator, class Size, class T, class BinaryPredicate>
1297a984708SDavid Chisnall    ForwardIterator
1307a984708SDavid Chisnall    search_n(ForwardIterator first, ForwardIterator last,
1317a984708SDavid Chisnall             Size count, const T& value, BinaryPredicate pred);
1327a984708SDavid Chisnall
1337a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator>
1347a984708SDavid Chisnall    OutputIterator
1357a984708SDavid Chisnall    copy(InputIterator first, InputIterator last, OutputIterator result);
1367a984708SDavid Chisnall
1377a984708SDavid Chisnalltemplate<class InputIterator, class OutputIterator, class Predicate>
1387a984708SDavid Chisnall    OutputIterator
1397a984708SDavid Chisnall    copy_if(InputIterator first, InputIterator last,
1407a984708SDavid Chisnall            OutputIterator result, Predicate pred);
1417a984708SDavid Chisnall
1427a984708SDavid Chisnalltemplate<class InputIterator, class Size, class OutputIterator>
1437a984708SDavid Chisnall    OutputIterator
1447a984708SDavid Chisnall    copy_n(InputIterator first, Size n, OutputIterator result);
1457a984708SDavid Chisnall
1467a984708SDavid Chisnalltemplate <class BidirectionalIterator1, class BidirectionalIterator2>
1477a984708SDavid Chisnall    BidirectionalIterator2
1487a984708SDavid Chisnall    copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
1497a984708SDavid Chisnall                  BidirectionalIterator2 result);
1507a984708SDavid Chisnall
1517a984708SDavid Chisnalltemplate <class ForwardIterator1, class ForwardIterator2>
1527a984708SDavid Chisnall    ForwardIterator2
1537a984708SDavid Chisnall    swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2);
1547a984708SDavid Chisnall
1557a984708SDavid Chisnalltemplate <class ForwardIterator1, class ForwardIterator2>
1567a984708SDavid Chisnall    void
1577a984708SDavid Chisnall    iter_swap(ForwardIterator1 a, ForwardIterator2 b);
1587a984708SDavid Chisnall
1597a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator, class UnaryOperation>
1607a984708SDavid Chisnall    OutputIterator
1617a984708SDavid Chisnall    transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op);
1627a984708SDavid Chisnall
1637a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator, class BinaryOperation>
1647a984708SDavid Chisnall    OutputIterator
1657a984708SDavid Chisnall    transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2,
1667a984708SDavid Chisnall              OutputIterator result, BinaryOperation binary_op);
1677a984708SDavid Chisnall
1687a984708SDavid Chisnalltemplate <class ForwardIterator, class T>
1697a984708SDavid Chisnall    void
1707a984708SDavid Chisnall    replace(ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value);
1717a984708SDavid Chisnall
1727a984708SDavid Chisnalltemplate <class ForwardIterator, class Predicate, class T>
1737a984708SDavid Chisnall    void
1747a984708SDavid Chisnall    replace_if(ForwardIterator first, ForwardIterator last, Predicate pred, const T& new_value);
1757a984708SDavid Chisnall
1767a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator, class T>
1777a984708SDavid Chisnall    OutputIterator
1787a984708SDavid Chisnall    replace_copy(InputIterator first, InputIterator last, OutputIterator result,
1797a984708SDavid Chisnall                 const T& old_value, const T& new_value);
1807a984708SDavid Chisnall
1817a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator, class Predicate, class T>
1827a984708SDavid Chisnall    OutputIterator
1837a984708SDavid Chisnall    replace_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred, const T& new_value);
1847a984708SDavid Chisnall
1857a984708SDavid Chisnalltemplate <class ForwardIterator, class T>
1867a984708SDavid Chisnall    void
1877a984708SDavid Chisnall    fill(ForwardIterator first, ForwardIterator last, const T& value);
1887a984708SDavid Chisnall
1897a984708SDavid Chisnalltemplate <class OutputIterator, class Size, class T>
1907a984708SDavid Chisnall    OutputIterator
1917a984708SDavid Chisnall    fill_n(OutputIterator first, Size n, const T& value);
1927a984708SDavid Chisnall
1937a984708SDavid Chisnalltemplate <class ForwardIterator, class Generator>
1947a984708SDavid Chisnall    void
1957a984708SDavid Chisnall    generate(ForwardIterator first, ForwardIterator last, Generator gen);
1967a984708SDavid Chisnall
1977a984708SDavid Chisnalltemplate <class OutputIterator, class Size, class Generator>
1987a984708SDavid Chisnall    OutputIterator
1997a984708SDavid Chisnall    generate_n(OutputIterator first, Size n, Generator gen);
2007a984708SDavid Chisnall
2017a984708SDavid Chisnalltemplate <class ForwardIterator, class T>
2027a984708SDavid Chisnall    ForwardIterator
2037a984708SDavid Chisnall    remove(ForwardIterator first, ForwardIterator last, const T& value);
2047a984708SDavid Chisnall
2057a984708SDavid Chisnalltemplate <class ForwardIterator, class Predicate>
2067a984708SDavid Chisnall    ForwardIterator
2077a984708SDavid Chisnall    remove_if(ForwardIterator first, ForwardIterator last, Predicate pred);
2087a984708SDavid Chisnall
2097a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator, class T>
2107a984708SDavid Chisnall    OutputIterator
2117a984708SDavid Chisnall    remove_copy(InputIterator first, InputIterator last, OutputIterator result, const T& value);
2127a984708SDavid Chisnall
2137a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator, class Predicate>
2147a984708SDavid Chisnall    OutputIterator
2157a984708SDavid Chisnall    remove_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred);
2167a984708SDavid Chisnall
2177a984708SDavid Chisnalltemplate <class ForwardIterator>
2187a984708SDavid Chisnall    ForwardIterator
2197a984708SDavid Chisnall    unique(ForwardIterator first, ForwardIterator last);
2207a984708SDavid Chisnall
2217a984708SDavid Chisnalltemplate <class ForwardIterator, class BinaryPredicate>
2227a984708SDavid Chisnall    ForwardIterator
2237a984708SDavid Chisnall    unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred);
2247a984708SDavid Chisnall
2257a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator>
2267a984708SDavid Chisnall    OutputIterator
2277a984708SDavid Chisnall    unique_copy(InputIterator first, InputIterator last, OutputIterator result);
2287a984708SDavid Chisnall
2297a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator, class BinaryPredicate>
2307a984708SDavid Chisnall    OutputIterator
2317a984708SDavid Chisnall    unique_copy(InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate pred);
2327a984708SDavid Chisnall
2337a984708SDavid Chisnalltemplate <class BidirectionalIterator>
2347a984708SDavid Chisnall    void
2357a984708SDavid Chisnall    reverse(BidirectionalIterator first, BidirectionalIterator last);
2367a984708SDavid Chisnall
2377a984708SDavid Chisnalltemplate <class BidirectionalIterator, class OutputIterator>
2387a984708SDavid Chisnall    OutputIterator
2397a984708SDavid Chisnall    reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator result);
2407a984708SDavid Chisnall
2417a984708SDavid Chisnalltemplate <class ForwardIterator>
2427a984708SDavid Chisnall    ForwardIterator
2437a984708SDavid Chisnall    rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last);
2447a984708SDavid Chisnall
2457a984708SDavid Chisnalltemplate <class ForwardIterator, class OutputIterator>
2467a984708SDavid Chisnall    OutputIterator
2477a984708SDavid Chisnall    rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator result);
2487a984708SDavid Chisnall
2497a984708SDavid Chisnalltemplate <class RandomAccessIterator>
2507a984708SDavid Chisnall    void
2517a984708SDavid Chisnall    random_shuffle(RandomAccessIterator first, RandomAccessIterator last);
2527a984708SDavid Chisnall
2537a984708SDavid Chisnalltemplate <class RandomAccessIterator, class RandomNumberGenerator>
2547a984708SDavid Chisnall    void
2557a984708SDavid Chisnall    random_shuffle(RandomAccessIterator first, RandomAccessIterator last, RandomNumberGenerator& rand);
2567a984708SDavid Chisnall
2577a984708SDavid Chisnalltemplate<class RandomAccessIterator, class UniformRandomNumberGenerator>
2587a984708SDavid Chisnall    void shuffle(RandomAccessIterator first, RandomAccessIterator last,
2597a984708SDavid Chisnall                 UniformRandomNumberGenerator&& g);
2607a984708SDavid Chisnall
2617a984708SDavid Chisnalltemplate <class InputIterator, class Predicate>
2627a984708SDavid Chisnall    bool
2637a984708SDavid Chisnall    is_partitioned(InputIterator first, InputIterator last, Predicate pred);
2647a984708SDavid Chisnall
2657a984708SDavid Chisnalltemplate <class ForwardIterator, class Predicate>
2667a984708SDavid Chisnall    ForwardIterator
2677a984708SDavid Chisnall    partition(ForwardIterator first, ForwardIterator last, Predicate pred);
2687a984708SDavid Chisnall
2697a984708SDavid Chisnalltemplate <class InputIterator, class OutputIterator1,
2707a984708SDavid Chisnall          class OutputIterator2, class Predicate>
2717a984708SDavid Chisnall    pair<OutputIterator1, OutputIterator2>
2727a984708SDavid Chisnall    partition_copy(InputIterator first, InputIterator last,
2737a984708SDavid Chisnall                   OutputIterator1 out_true, OutputIterator2 out_false,
2747a984708SDavid Chisnall                   Predicate pred);
2757a984708SDavid Chisnall
2767a984708SDavid Chisnalltemplate <class ForwardIterator, class Predicate>
2777a984708SDavid Chisnall    ForwardIterator
2787a984708SDavid Chisnall    stable_partition(ForwardIterator first, ForwardIterator last, Predicate pred);
2797a984708SDavid Chisnall
2807a984708SDavid Chisnalltemplate<class ForwardIterator, class Predicate>
2817a984708SDavid Chisnall    ForwardIterator
2827a984708SDavid Chisnall    partition_point(ForwardIterator first, ForwardIterator last, Predicate pred);
2837a984708SDavid Chisnall
2847a984708SDavid Chisnalltemplate <class ForwardIterator>
2857a984708SDavid Chisnall    bool
2867a984708SDavid Chisnall    is_sorted(ForwardIterator first, ForwardIterator last);
2877a984708SDavid Chisnall
2887a984708SDavid Chisnalltemplate <class ForwardIterator, class Compare>
2897a984708SDavid Chisnall    bool
2907a984708SDavid Chisnall    is_sorted(ForwardIterator first, ForwardIterator last, Compare comp);
2917a984708SDavid Chisnall
2927a984708SDavid Chisnalltemplate<class ForwardIterator>
2937a984708SDavid Chisnall    ForwardIterator
2947a984708SDavid Chisnall    is_sorted_until(ForwardIterator first, ForwardIterator last);
2957a984708SDavid Chisnall
2967a984708SDavid Chisnalltemplate <class ForwardIterator, class Compare>
2977a984708SDavid Chisnall    ForwardIterator
2987a984708SDavid Chisnall    is_sorted_until(ForwardIterator first, ForwardIterator last, Compare comp);
2997a984708SDavid Chisnall
3007a984708SDavid Chisnalltemplate <class RandomAccessIterator>
3017a984708SDavid Chisnall    void
3027a984708SDavid Chisnall    sort(RandomAccessIterator first, RandomAccessIterator last);
3037a984708SDavid Chisnall
3047a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare>
3057a984708SDavid Chisnall    void
3067a984708SDavid Chisnall    sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
3077a984708SDavid Chisnall
3087a984708SDavid Chisnalltemplate <class RandomAccessIterator>
3097a984708SDavid Chisnall    void
3107a984708SDavid Chisnall    stable_sort(RandomAccessIterator first, RandomAccessIterator last);
3117a984708SDavid Chisnall
3127a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare>
3137a984708SDavid Chisnall    void
3147a984708SDavid Chisnall    stable_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
3157a984708SDavid Chisnall
3167a984708SDavid Chisnalltemplate <class RandomAccessIterator>
3177a984708SDavid Chisnall    void
3187a984708SDavid Chisnall    partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last);
3197a984708SDavid Chisnall
3207a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare>
3217a984708SDavid Chisnall    void
3227a984708SDavid Chisnall    partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last, Compare comp);
3237a984708SDavid Chisnall
3247a984708SDavid Chisnalltemplate <class InputIterator, class RandomAccessIterator>
3257a984708SDavid Chisnall    RandomAccessIterator
3267a984708SDavid Chisnall    partial_sort_copy(InputIterator first, InputIterator last,
3277a984708SDavid Chisnall                      RandomAccessIterator result_first, RandomAccessIterator result_last);
3287a984708SDavid Chisnall
3297a984708SDavid Chisnalltemplate <class InputIterator, class RandomAccessIterator, class Compare>
3307a984708SDavid Chisnall    RandomAccessIterator
3317a984708SDavid Chisnall    partial_sort_copy(InputIterator first, InputIterator last,
3327a984708SDavid Chisnall                      RandomAccessIterator result_first, RandomAccessIterator result_last, Compare comp);
3337a984708SDavid Chisnall
3347a984708SDavid Chisnalltemplate <class RandomAccessIterator>
3357a984708SDavid Chisnall    void
3367a984708SDavid Chisnall    nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last);
3377a984708SDavid Chisnall
3387a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare>
3397a984708SDavid Chisnall    void
3407a984708SDavid Chisnall    nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last, Compare comp);
3417a984708SDavid Chisnall
3427a984708SDavid Chisnalltemplate <class ForwardIterator, class T>
3437a984708SDavid Chisnall    ForwardIterator
3447a984708SDavid Chisnall    lower_bound(ForwardIterator first, ForwardIterator last, const T& value);
3457a984708SDavid Chisnall
3467a984708SDavid Chisnalltemplate <class ForwardIterator, class T, class Compare>
3477a984708SDavid Chisnall    ForwardIterator
3487a984708SDavid Chisnall    lower_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
3497a984708SDavid Chisnall
3507a984708SDavid Chisnalltemplate <class ForwardIterator, class T>
3517a984708SDavid Chisnall    ForwardIterator
3527a984708SDavid Chisnall    upper_bound(ForwardIterator first, ForwardIterator last, const T& value);
3537a984708SDavid Chisnall
3547a984708SDavid Chisnalltemplate <class ForwardIterator, class T, class Compare>
3557a984708SDavid Chisnall    ForwardIterator
3567a984708SDavid Chisnall    upper_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
3577a984708SDavid Chisnall
3587a984708SDavid Chisnalltemplate <class ForwardIterator, class T>
3597a984708SDavid Chisnall    pair<ForwardIterator, ForwardIterator>
3607a984708SDavid Chisnall    equal_range(ForwardIterator first, ForwardIterator last, const T& value);
3617a984708SDavid Chisnall
3627a984708SDavid Chisnalltemplate <class ForwardIterator, class T, class Compare>
3637a984708SDavid Chisnall    pair<ForwardIterator, ForwardIterator>
3647a984708SDavid Chisnall    equal_range(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
3657a984708SDavid Chisnall
3667a984708SDavid Chisnalltemplate <class ForwardIterator, class T>
3677a984708SDavid Chisnall    bool
3687a984708SDavid Chisnall    binary_search(ForwardIterator first, ForwardIterator last, const T& value);
3697a984708SDavid Chisnall
3707a984708SDavid Chisnalltemplate <class ForwardIterator, class T, class Compare>
3717a984708SDavid Chisnall    bool
3727a984708SDavid Chisnall    binary_search(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
3737a984708SDavid Chisnall
3747a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator>
3757a984708SDavid Chisnall    OutputIterator
3767a984708SDavid Chisnall    merge(InputIterator1 first1, InputIterator1 last1,
3777a984708SDavid Chisnall          InputIterator2 first2, InputIterator2 last2, OutputIterator result);
3787a984708SDavid Chisnall
3797a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
3807a984708SDavid Chisnall    OutputIterator
3817a984708SDavid Chisnall    merge(InputIterator1 first1, InputIterator1 last1,
3827a984708SDavid Chisnall          InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
3837a984708SDavid Chisnall
3847a984708SDavid Chisnalltemplate <class BidirectionalIterator>
3857a984708SDavid Chisnall    void
3867a984708SDavid Chisnall    inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last);
3877a984708SDavid Chisnall
3887a984708SDavid Chisnalltemplate <class BidirectionalIterator, class Compare>
3897a984708SDavid Chisnall    void
3907a984708SDavid Chisnall    inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last, Compare comp);
3917a984708SDavid Chisnall
3927a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2>
3937a984708SDavid Chisnall    bool
3947a984708SDavid Chisnall    includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);
3957a984708SDavid Chisnall
3967a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class Compare>
3977a984708SDavid Chisnall    bool
3987a984708SDavid Chisnall    includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp);
3997a984708SDavid Chisnall
4007a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator>
4017a984708SDavid Chisnall    OutputIterator
4027a984708SDavid Chisnall    set_union(InputIterator1 first1, InputIterator1 last1,
4037a984708SDavid Chisnall              InputIterator2 first2, InputIterator2 last2, OutputIterator result);
4047a984708SDavid Chisnall
4057a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
4067a984708SDavid Chisnall    OutputIterator
4077a984708SDavid Chisnall    set_union(InputIterator1 first1, InputIterator1 last1,
4087a984708SDavid Chisnall              InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
4097a984708SDavid Chisnall
4107a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator>
4117a984708SDavid Chisnall    OutputIterator
4127a984708SDavid Chisnall    set_intersection(InputIterator1 first1, InputIterator1 last1,
4137a984708SDavid Chisnall                     InputIterator2 first2, InputIterator2 last2, OutputIterator result);
4147a984708SDavid Chisnall
4157a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
4167a984708SDavid Chisnall    OutputIterator
4177a984708SDavid Chisnall    set_intersection(InputIterator1 first1, InputIterator1 last1,
4187a984708SDavid Chisnall                     InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
4197a984708SDavid Chisnall
4207a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator>
4217a984708SDavid Chisnall    OutputIterator
4227a984708SDavid Chisnall    set_difference(InputIterator1 first1, InputIterator1 last1,
4237a984708SDavid Chisnall                   InputIterator2 first2, InputIterator2 last2, OutputIterator result);
4247a984708SDavid Chisnall
4257a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
4267a984708SDavid Chisnall    OutputIterator
4277a984708SDavid Chisnall    set_difference(InputIterator1 first1, InputIterator1 last1,
4287a984708SDavid Chisnall                   InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
4297a984708SDavid Chisnall
4307a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator>
4317a984708SDavid Chisnall    OutputIterator
4327a984708SDavid Chisnall    set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
4337a984708SDavid Chisnall                             InputIterator2 first2, InputIterator2 last2, OutputIterator result);
4347a984708SDavid Chisnall
4357a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
4367a984708SDavid Chisnall    OutputIterator
4377a984708SDavid Chisnall    set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
4387a984708SDavid Chisnall                             InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
4397a984708SDavid Chisnall
4407a984708SDavid Chisnalltemplate <class RandomAccessIterator>
4417a984708SDavid Chisnall    void
4427a984708SDavid Chisnall    push_heap(RandomAccessIterator first, RandomAccessIterator last);
4437a984708SDavid Chisnall
4447a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare>
4457a984708SDavid Chisnall    void
4467a984708SDavid Chisnall    push_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
4477a984708SDavid Chisnall
4487a984708SDavid Chisnalltemplate <class RandomAccessIterator>
4497a984708SDavid Chisnall    void
4507a984708SDavid Chisnall    pop_heap(RandomAccessIterator first, RandomAccessIterator last);
4517a984708SDavid Chisnall
4527a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare>
4537a984708SDavid Chisnall    void
4547a984708SDavid Chisnall    pop_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
4557a984708SDavid Chisnall
4567a984708SDavid Chisnalltemplate <class RandomAccessIterator>
4577a984708SDavid Chisnall    void
4587a984708SDavid Chisnall    make_heap(RandomAccessIterator first, RandomAccessIterator last);
4597a984708SDavid Chisnall
4607a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare>
4617a984708SDavid Chisnall    void
4627a984708SDavid Chisnall    make_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
4637a984708SDavid Chisnall
4647a984708SDavid Chisnalltemplate <class RandomAccessIterator>
4657a984708SDavid Chisnall    void
4667a984708SDavid Chisnall    sort_heap(RandomAccessIterator first, RandomAccessIterator last);
4677a984708SDavid Chisnall
4687a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare>
4697a984708SDavid Chisnall    void
4707a984708SDavid Chisnall    sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
4717a984708SDavid Chisnall
4727a984708SDavid Chisnalltemplate <class RandomAccessIterator>
4737a984708SDavid Chisnall    bool
4747a984708SDavid Chisnall    is_heap(RandomAccessIterator first, RandomAccessiterator last);
4757a984708SDavid Chisnall
4767a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare>
4777a984708SDavid Chisnall    bool
4787a984708SDavid Chisnall    is_heap(RandomAccessIterator first, RandomAccessiterator last, Compare comp);
4797a984708SDavid Chisnall
4807a984708SDavid Chisnalltemplate <class RandomAccessIterator>
4817a984708SDavid Chisnall    RandomAccessIterator
4827a984708SDavid Chisnall    is_heap_until(RandomAccessIterator first, RandomAccessiterator last);
4837a984708SDavid Chisnall
4847a984708SDavid Chisnalltemplate <class RandomAccessIterator, class Compare>
4857a984708SDavid Chisnall    RandomAccessIterator
4867a984708SDavid Chisnall    is_heap_until(RandomAccessIterator first, RandomAccessiterator last, Compare comp);
4877a984708SDavid Chisnall
4887a984708SDavid Chisnalltemplate <class ForwardIterator>
4897a984708SDavid Chisnall    ForwardIterator
4907a984708SDavid Chisnall    min_element(ForwardIterator first, ForwardIterator last);
4917a984708SDavid Chisnall
4927a984708SDavid Chisnalltemplate <class ForwardIterator, class Compare>
4937a984708SDavid Chisnall    ForwardIterator
4947a984708SDavid Chisnall    min_element(ForwardIterator first, ForwardIterator last, Compare comp);
4957a984708SDavid Chisnall
4967a984708SDavid Chisnalltemplate <class T>
4977a984708SDavid Chisnall    const T&
4987a984708SDavid Chisnall    min(const T& a, const T& b);
4997a984708SDavid Chisnall
5007a984708SDavid Chisnalltemplate <class T, class Compare>
5017a984708SDavid Chisnall    const T&
5027a984708SDavid Chisnall    min(const T& a, const T& b, Compare comp);
5037a984708SDavid Chisnall
5047a984708SDavid Chisnalltemplate<class T>
5057a984708SDavid Chisnall    T
5067a984708SDavid Chisnall    min(initializer_list<T> t);
5077a984708SDavid Chisnall
5087a984708SDavid Chisnalltemplate<class T, class Compare>
5097a984708SDavid Chisnall    T
5107a984708SDavid Chisnall    min(initializer_list<T> t, Compare comp);
5117a984708SDavid Chisnall
5127a984708SDavid Chisnalltemplate <class ForwardIterator>
5137a984708SDavid Chisnall    ForwardIterator
5147a984708SDavid Chisnall    max_element(ForwardIterator first, ForwardIterator last);
5157a984708SDavid Chisnall
5167a984708SDavid Chisnalltemplate <class ForwardIterator, class Compare>
5177a984708SDavid Chisnall    ForwardIterator
5187a984708SDavid Chisnall    max_element(ForwardIterator first, ForwardIterator last, Compare comp);
5197a984708SDavid Chisnall
5207a984708SDavid Chisnalltemplate <class T>
5217a984708SDavid Chisnall    const T&
5227a984708SDavid Chisnall    max(const T& a, const T& b);
5237a984708SDavid Chisnall
5247a984708SDavid Chisnalltemplate <class T, class Compare>
5257a984708SDavid Chisnall    const T&
5267a984708SDavid Chisnall    max(const T& a, const T& b, Compare comp);
5277a984708SDavid Chisnall
5287a984708SDavid Chisnalltemplate<class T>
5297a984708SDavid Chisnall    T
5307a984708SDavid Chisnall    max(initializer_list<T> t);
5317a984708SDavid Chisnall
5327a984708SDavid Chisnalltemplate<class T, class Compare>
5337a984708SDavid Chisnall    T
5347a984708SDavid Chisnall    max(initializer_list<T> t, Compare comp);
5357a984708SDavid Chisnall
5367a984708SDavid Chisnalltemplate<class ForwardIterator>
5377a984708SDavid Chisnall    pair<ForwardIterator, ForwardIterator>
5387a984708SDavid Chisnall    minmax_element(ForwardIterator first, ForwardIterator last);
5397a984708SDavid Chisnall
5407a984708SDavid Chisnalltemplate<class ForwardIterator, class Compare>
5417a984708SDavid Chisnall    pair<ForwardIterator, ForwardIterator>
5427a984708SDavid Chisnall    minmax_element(ForwardIterator first, ForwardIterator last, Compare comp);
5437a984708SDavid Chisnall
5447a984708SDavid Chisnalltemplate<class T>
5457a984708SDavid Chisnall    pair<const T&, const T&>
5467a984708SDavid Chisnall    minmax(const T& a, const T& b);
5477a984708SDavid Chisnall
5487a984708SDavid Chisnalltemplate<class T, class Compare>
5497a984708SDavid Chisnall    pair<const T&, const T&>
5507a984708SDavid Chisnall    minmax(const T& a, const T& b, Compare comp);
5517a984708SDavid Chisnall
5527a984708SDavid Chisnalltemplate<class T>
5537a984708SDavid Chisnall    pair<T, T>
5547a984708SDavid Chisnall    minmax(initializer_list<T> t);
5557a984708SDavid Chisnall
5567a984708SDavid Chisnalltemplate<class T, class Compare>
5577a984708SDavid Chisnall    pair<T, T>
5587a984708SDavid Chisnall    minmax(initializer_list<T> t, Compare comp);
5597a984708SDavid Chisnall
5607a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2>
5617a984708SDavid Chisnall    bool
5627a984708SDavid Chisnall    lexicographical_compare(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);
5637a984708SDavid Chisnall
5647a984708SDavid Chisnalltemplate <class InputIterator1, class InputIterator2, class Compare>
5657a984708SDavid Chisnall    bool
5667a984708SDavid Chisnall    lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
5677a984708SDavid Chisnall                            InputIterator2 first2, InputIterator2 last2, Compare comp);
5687a984708SDavid Chisnall
5697a984708SDavid Chisnalltemplate <class BidirectionalIterator>
5707a984708SDavid Chisnall    bool
5717a984708SDavid Chisnall    next_permutation(BidirectionalIterator first, BidirectionalIterator last);
5727a984708SDavid Chisnall
5737a984708SDavid Chisnalltemplate <class BidirectionalIterator, class Compare>
5747a984708SDavid Chisnall    bool
5757a984708SDavid Chisnall    next_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);
5767a984708SDavid Chisnall
5777a984708SDavid Chisnalltemplate <class BidirectionalIterator>
5787a984708SDavid Chisnall    bool
5797a984708SDavid Chisnall    prev_permutation(BidirectionalIterator first, BidirectionalIterator last);
5807a984708SDavid Chisnall
5817a984708SDavid Chisnalltemplate <class BidirectionalIterator, class Compare>
5827a984708SDavid Chisnall    bool
5837a984708SDavid Chisnall    prev_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);
5847a984708SDavid Chisnall
5857a984708SDavid Chisnall}  // std
5867a984708SDavid Chisnall
5877a984708SDavid Chisnall*/
5887a984708SDavid Chisnall
5897a984708SDavid Chisnall#include <__config>
5907a984708SDavid Chisnall#include <initializer_list>
5917a984708SDavid Chisnall#include <type_traits>
5927a984708SDavid Chisnall#include <cstring>
5937a984708SDavid Chisnall#include <utility>
5947a984708SDavid Chisnall#include <memory>
5957a984708SDavid Chisnall#include <iterator>
596936e9439SDimitry Andric#include <cstddef>
5977a984708SDavid Chisnall
59894e3ee44SDavid Chisnall#include <__undef_min_max>
59994e3ee44SDavid Chisnall
6007a984708SDavid Chisnall#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
6017a984708SDavid Chisnall#pragma GCC system_header
6027a984708SDavid Chisnall#endif
6037a984708SDavid Chisnall
6047a984708SDavid Chisnall_LIBCPP_BEGIN_NAMESPACE_STD
6057a984708SDavid Chisnall
6067a984708SDavid Chisnalltemplate <class _T1, class _T2 = _T1>
6077a984708SDavid Chisnallstruct __equal_to
6087a984708SDavid Chisnall{
6097a984708SDavid Chisnall    _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
6107a984708SDavid Chisnall    _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T2& __y) const {return __x == __y;}
6117a984708SDavid Chisnall    _LIBCPP_INLINE_VISIBILITY bool operator()(const _T2& __x, const _T1& __y) const {return __x == __y;}
6127a984708SDavid Chisnall    _LIBCPP_INLINE_VISIBILITY bool operator()(const _T2& __x, const _T2& __y) const {return __x == __y;}
6137a984708SDavid Chisnall};
6147a984708SDavid Chisnall
6157a984708SDavid Chisnalltemplate <class _T1>
6167a984708SDavid Chisnallstruct __equal_to<_T1, _T1>
6177a984708SDavid Chisnall{
6187a984708SDavid Chisnall    _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
6197a984708SDavid Chisnall};
6207a984708SDavid Chisnall
6217a984708SDavid Chisnalltemplate <class _T1>
6227a984708SDavid Chisnallstruct __equal_to<const _T1, _T1>
6237a984708SDavid Chisnall{
6247a984708SDavid Chisnall    _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
6257a984708SDavid Chisnall};
6267a984708SDavid Chisnall
6277a984708SDavid Chisnalltemplate <class _T1>
6287a984708SDavid Chisnallstruct __equal_to<_T1, const _T1>
6297a984708SDavid Chisnall{
6307a984708SDavid Chisnall    _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
6317a984708SDavid Chisnall};
6327a984708SDavid Chisnall
6337a984708SDavid Chisnalltemplate <class _T1, class _T2 = _T1>
6347a984708SDavid Chisnallstruct __less
6357a984708SDavid Chisnall{
6367a984708SDavid Chisnall    _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
6377a984708SDavid Chisnall    _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T2& __y) const {return __x < __y;}
6387a984708SDavid Chisnall    _LIBCPP_INLINE_VISIBILITY bool operator()(const _T2& __x, const _T1& __y) const {return __x < __y;}
6397a984708SDavid Chisnall    _LIBCPP_INLINE_VISIBILITY bool operator()(const _T2& __x, const _T2& __y) const {return __x < __y;}
6407a984708SDavid Chisnall};
6417a984708SDavid Chisnall
6427a984708SDavid Chisnalltemplate <class _T1>
6437a984708SDavid Chisnallstruct __less<_T1, _T1>
6447a984708SDavid Chisnall{
6457a984708SDavid Chisnall    _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
6467a984708SDavid Chisnall};
6477a984708SDavid Chisnall
6487a984708SDavid Chisnalltemplate <class _T1>
6497a984708SDavid Chisnallstruct __less<const _T1, _T1>
6507a984708SDavid Chisnall{
6517a984708SDavid Chisnall    _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
6527a984708SDavid Chisnall};
6537a984708SDavid Chisnall
6547a984708SDavid Chisnalltemplate <class _T1>
6557a984708SDavid Chisnallstruct __less<_T1, const _T1>
6567a984708SDavid Chisnall{
6577a984708SDavid Chisnall    _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
6587a984708SDavid Chisnall};
6597a984708SDavid Chisnall
6607a984708SDavid Chisnalltemplate <class _Predicate>
6617a984708SDavid Chisnallclass __negate
6627a984708SDavid Chisnall{
6637a984708SDavid Chisnallprivate:
6647a984708SDavid Chisnall    _Predicate __p_;
6657a984708SDavid Chisnallpublic:
6667a984708SDavid Chisnall    _LIBCPP_INLINE_VISIBILITY __negate() {}
6677a984708SDavid Chisnall
6687a984708SDavid Chisnall    _LIBCPP_INLINE_VISIBILITY
6697a984708SDavid Chisnall    explicit __negate(_Predicate __p) : __p_(__p) {}
6707a984708SDavid Chisnall
6717a984708SDavid Chisnall    template <class _T1>
6727a984708SDavid Chisnall    _LIBCPP_INLINE_VISIBILITY
6737a984708SDavid Chisnall    bool operator()(const _T1& __x) {return !__p_(__x);}
6747a984708SDavid Chisnall
6757a984708SDavid Chisnall    template <class _T1, class _T2>
6767a984708SDavid Chisnall    _LIBCPP_INLINE_VISIBILITY
6777a984708SDavid Chisnall    bool operator()(const _T1& __x, const _T2& __y) {return !__p_(__x, __y);}
6787a984708SDavid Chisnall};
6797a984708SDavid Chisnall
6807a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2
6817a984708SDavid Chisnall
6827a984708SDavid Chisnalltemplate <class _Compare>
6837a984708SDavid Chisnallstruct __debug_less
6847a984708SDavid Chisnall{
6857a984708SDavid Chisnall    _Compare __comp_;
6867a984708SDavid Chisnall    __debug_less(_Compare& __c) : __comp_(__c) {}
6877a984708SDavid Chisnall    template <class _Tp, class _Up>
6887a984708SDavid Chisnall    bool operator()(const _Tp& __x, const _Up& __y)
6897a984708SDavid Chisnall    {
6907a984708SDavid Chisnall        bool __r = __comp_(__x, __y);
6917a984708SDavid Chisnall        if (__r)
6927a984708SDavid Chisnall            _LIBCPP_ASSERT(!__comp_(__y, __x), "Comparator does not induce a strict weak ordering");
6937a984708SDavid Chisnall        return __r;
6947a984708SDavid Chisnall    }
6957a984708SDavid Chisnall};
6967a984708SDavid Chisnall
6977a984708SDavid Chisnall#endif  // _LIBCPP_DEBUG2
6987a984708SDavid Chisnall
6997a984708SDavid Chisnall// Precondition:  __x != 0
70094e3ee44SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
70194e3ee44SDavid Chisnallunsigned
70294e3ee44SDavid Chisnall__ctz(unsigned __x)
70394e3ee44SDavid Chisnall{
70494e3ee44SDavid Chisnall    return static_cast<unsigned>(__builtin_ctz(__x));
70594e3ee44SDavid Chisnall}
70694e3ee44SDavid Chisnall
70794e3ee44SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
70894e3ee44SDavid Chisnallunsigned long
70994e3ee44SDavid Chisnall__ctz(unsigned long __x)
71094e3ee44SDavid Chisnall{
71194e3ee44SDavid Chisnall    return static_cast<unsigned long>(__builtin_ctzl(__x));
71294e3ee44SDavid Chisnall}
71394e3ee44SDavid Chisnall
71494e3ee44SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
71594e3ee44SDavid Chisnallunsigned long long
71694e3ee44SDavid Chisnall__ctz(unsigned long long __x)
71794e3ee44SDavid Chisnall{
71894e3ee44SDavid Chisnall    return static_cast<unsigned long long>(__builtin_ctzll(__x));
71994e3ee44SDavid Chisnall}
7207a984708SDavid Chisnall
7217a984708SDavid Chisnall// Precondition:  __x != 0
72294e3ee44SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
72394e3ee44SDavid Chisnallunsigned
72494e3ee44SDavid Chisnall__clz(unsigned __x)
72594e3ee44SDavid Chisnall{
72694e3ee44SDavid Chisnall    return static_cast<unsigned>(__builtin_clz(__x));
72794e3ee44SDavid Chisnall}
72894e3ee44SDavid Chisnall
72994e3ee44SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
73094e3ee44SDavid Chisnallunsigned long
73194e3ee44SDavid Chisnall__clz(unsigned long __x)
73294e3ee44SDavid Chisnall{
73394e3ee44SDavid Chisnall    return static_cast<unsigned long>(__builtin_clzl (__x));
73494e3ee44SDavid Chisnall}
73594e3ee44SDavid Chisnall
73694e3ee44SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
73794e3ee44SDavid Chisnallunsigned long long
73894e3ee44SDavid Chisnall__clz(unsigned long long __x)
73994e3ee44SDavid Chisnall{
74094e3ee44SDavid Chisnall    return static_cast<unsigned long long>(__builtin_clzll(__x));
74194e3ee44SDavid Chisnall}
7427a984708SDavid Chisnall
7437a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY int __pop_count(unsigned           __x) {return __builtin_popcount  (__x);}
7447a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY int __pop_count(unsigned      long __x) {return __builtin_popcountl (__x);}
7457a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY int __pop_count(unsigned long long __x) {return __builtin_popcountll(__x);}
7467a984708SDavid Chisnall
7477a984708SDavid Chisnall// all_of
7487a984708SDavid Chisnall
7497a984708SDavid Chisnalltemplate <class _InputIterator, class _Predicate>
7507a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
7517a984708SDavid Chisnallbool
7527a984708SDavid Chisnallall_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
7537a984708SDavid Chisnall{
7547a984708SDavid Chisnall    for (; __first != __last; ++__first)
7557a984708SDavid Chisnall        if (!__pred(*__first))
7567a984708SDavid Chisnall            return false;
7577a984708SDavid Chisnall    return true;
7587a984708SDavid Chisnall}
7597a984708SDavid Chisnall
7607a984708SDavid Chisnall// any_of
7617a984708SDavid Chisnall
7627a984708SDavid Chisnalltemplate <class _InputIterator, class _Predicate>
7637a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
7647a984708SDavid Chisnallbool
7657a984708SDavid Chisnallany_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
7667a984708SDavid Chisnall{
7677a984708SDavid Chisnall    for (; __first != __last; ++__first)
7687a984708SDavid Chisnall        if (__pred(*__first))
7697a984708SDavid Chisnall            return true;
7707a984708SDavid Chisnall    return false;
7717a984708SDavid Chisnall}
7727a984708SDavid Chisnall
7737a984708SDavid Chisnall// none_of
7747a984708SDavid Chisnall
7757a984708SDavid Chisnalltemplate <class _InputIterator, class _Predicate>
7767a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
7777a984708SDavid Chisnallbool
7787a984708SDavid Chisnallnone_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
7797a984708SDavid Chisnall{
7807a984708SDavid Chisnall    for (; __first != __last; ++__first)
7817a984708SDavid Chisnall        if (__pred(*__first))
7827a984708SDavid Chisnall            return false;
7837a984708SDavid Chisnall    return true;
7847a984708SDavid Chisnall}
7857a984708SDavid Chisnall
7867a984708SDavid Chisnall// for_each
7877a984708SDavid Chisnall
7887a984708SDavid Chisnalltemplate <class _InputIterator, class _Function>
7897a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
7907a984708SDavid Chisnall_Function
7917a984708SDavid Chisnallfor_each(_InputIterator __first, _InputIterator __last, _Function __f)
7927a984708SDavid Chisnall{
7937a984708SDavid Chisnall    for (; __first != __last; ++__first)
7947a984708SDavid Chisnall        __f(*__first);
7957a984708SDavid Chisnall    return _VSTD::move(__f);
7967a984708SDavid Chisnall}
7977a984708SDavid Chisnall
7987a984708SDavid Chisnall// find
7997a984708SDavid Chisnall
8007a984708SDavid Chisnalltemplate <class _InputIterator, class _Tp>
8017a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
8027a984708SDavid Chisnall_InputIterator
8037a984708SDavid Chisnallfind(_InputIterator __first, _InputIterator __last, const _Tp& __value_)
8047a984708SDavid Chisnall{
8057a984708SDavid Chisnall    for (; __first != __last; ++__first)
8067a984708SDavid Chisnall        if (*__first == __value_)
8077a984708SDavid Chisnall            break;
8087a984708SDavid Chisnall    return __first;
8097a984708SDavid Chisnall}
8107a984708SDavid Chisnall
8117a984708SDavid Chisnall// find_if
8127a984708SDavid Chisnall
8137a984708SDavid Chisnalltemplate <class _InputIterator, class _Predicate>
8147a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
8157a984708SDavid Chisnall_InputIterator
8167a984708SDavid Chisnallfind_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
8177a984708SDavid Chisnall{
8187a984708SDavid Chisnall    for (; __first != __last; ++__first)
8197a984708SDavid Chisnall        if (__pred(*__first))
8207a984708SDavid Chisnall            break;
8217a984708SDavid Chisnall    return __first;
8227a984708SDavid Chisnall}
8237a984708SDavid Chisnall
8247a984708SDavid Chisnall// find_if_not
8257a984708SDavid Chisnall
8267a984708SDavid Chisnalltemplate<class _InputIterator, class _Predicate>
8277a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
8287a984708SDavid Chisnall_InputIterator
8297a984708SDavid Chisnallfind_if_not(_InputIterator __first, _InputIterator __last, _Predicate __pred)
8307a984708SDavid Chisnall{
8317a984708SDavid Chisnall    for (; __first != __last; ++__first)
8327a984708SDavid Chisnall        if (!__pred(*__first))
8337a984708SDavid Chisnall            break;
8347a984708SDavid Chisnall    return __first;
8357a984708SDavid Chisnall}
8367a984708SDavid Chisnall
8377a984708SDavid Chisnall// find_end
8387a984708SDavid Chisnall
8397a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2>
8407a984708SDavid Chisnall_ForwardIterator1
8417a984708SDavid Chisnall__find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
8427a984708SDavid Chisnall           _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred,
8437a984708SDavid Chisnall           forward_iterator_tag, forward_iterator_tag)
8447a984708SDavid Chisnall{
8457a984708SDavid Chisnall    // modeled after search algorithm
8467a984708SDavid Chisnall    _ForwardIterator1 __r = __last1;  // __last1 is the "default" answer
8477a984708SDavid Chisnall    if (__first2 == __last2)
8487a984708SDavid Chisnall        return __r;
8497a984708SDavid Chisnall    while (true)
8507a984708SDavid Chisnall    {
8517a984708SDavid Chisnall        while (true)
8527a984708SDavid Chisnall        {
8537a984708SDavid Chisnall            if (__first1 == __last1)         // if source exhausted return last correct answer
8547a984708SDavid Chisnall                return __r;                  //    (or __last1 if never found)
8557a984708SDavid Chisnall            if (__pred(*__first1, *__first2))
8567a984708SDavid Chisnall                break;
8577a984708SDavid Chisnall            ++__first1;
8587a984708SDavid Chisnall        }
8597a984708SDavid Chisnall        // *__first1 matches *__first2, now match elements after here
8607a984708SDavid Chisnall        _ForwardIterator1 __m1 = __first1;
8617a984708SDavid Chisnall        _ForwardIterator2 __m2 = __first2;
8627a984708SDavid Chisnall        while (true)
8637a984708SDavid Chisnall        {
8647a984708SDavid Chisnall            if (++__m2 == __last2)
8657a984708SDavid Chisnall            {                         // Pattern exhaused, record answer and search for another one
8667a984708SDavid Chisnall                __r = __first1;
8677a984708SDavid Chisnall                ++__first1;
8687a984708SDavid Chisnall                break;
8697a984708SDavid Chisnall            }
8707a984708SDavid Chisnall            if (++__m1 == __last1)     // Source exhausted, return last answer
8717a984708SDavid Chisnall                return __r;
8727a984708SDavid Chisnall            if (!__pred(*__m1, *__m2))  // mismatch, restart with a new __first
8737a984708SDavid Chisnall            {
8747a984708SDavid Chisnall                ++__first1;
8757a984708SDavid Chisnall                break;
8767a984708SDavid Chisnall            }  // else there is a match, check next elements
8777a984708SDavid Chisnall        }
8787a984708SDavid Chisnall    }
8797a984708SDavid Chisnall}
8807a984708SDavid Chisnall
8817a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _BidirectionalIterator1, class _BidirectionalIterator2>
8827a984708SDavid Chisnall_BidirectionalIterator1
8837a984708SDavid Chisnall__find_end(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1,
8847a984708SDavid Chisnall           _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2, _BinaryPredicate __pred,
8857a984708SDavid Chisnall           bidirectional_iterator_tag, bidirectional_iterator_tag)
8867a984708SDavid Chisnall{
8877a984708SDavid Chisnall    // modeled after search algorithm (in reverse)
8887a984708SDavid Chisnall    if (__first2 == __last2)
8897a984708SDavid Chisnall        return __last1;  // Everything matches an empty sequence
8907a984708SDavid Chisnall    _BidirectionalIterator1 __l1 = __last1;
8917a984708SDavid Chisnall    _BidirectionalIterator2 __l2 = __last2;
8927a984708SDavid Chisnall    --__l2;
8937a984708SDavid Chisnall    while (true)
8947a984708SDavid Chisnall    {
8957a984708SDavid Chisnall        // Find last element in sequence 1 that matchs *(__last2-1), with a mininum of loop checks
8967a984708SDavid Chisnall        while (true)
8977a984708SDavid Chisnall        {
8987a984708SDavid Chisnall            if (__first1 == __l1)  // return __last1 if no element matches *__first2
8997a984708SDavid Chisnall                return __last1;
9007a984708SDavid Chisnall            if (__pred(*--__l1, *__l2))
9017a984708SDavid Chisnall                break;
9027a984708SDavid Chisnall        }
9037a984708SDavid Chisnall        // *__l1 matches *__l2, now match elements before here
9047a984708SDavid Chisnall        _BidirectionalIterator1 __m1 = __l1;
9057a984708SDavid Chisnall        _BidirectionalIterator2 __m2 = __l2;
9067a984708SDavid Chisnall        while (true)
9077a984708SDavid Chisnall        {
9087a984708SDavid Chisnall            if (__m2 == __first2)  // If pattern exhausted, __m1 is the answer (works for 1 element pattern)
9097a984708SDavid Chisnall                return __m1;
9107a984708SDavid Chisnall            if (__m1 == __first1)  // Otherwise if source exhaused, pattern not found
9117a984708SDavid Chisnall                return __last1;
9127a984708SDavid Chisnall            if (!__pred(*--__m1, *--__m2))  // if there is a mismatch, restart with a new __l1
9137a984708SDavid Chisnall            {
9147a984708SDavid Chisnall                break;
9157a984708SDavid Chisnall            }  // else there is a match, check next elements
9167a984708SDavid Chisnall        }
9177a984708SDavid Chisnall    }
9187a984708SDavid Chisnall}
9197a984708SDavid Chisnall
9207a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2>
9217a984708SDavid Chisnall_RandomAccessIterator1
9227a984708SDavid Chisnall__find_end(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
9237a984708SDavid Chisnall           _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred,
9247a984708SDavid Chisnall           random_access_iterator_tag, random_access_iterator_tag)
9257a984708SDavid Chisnall{
9267a984708SDavid Chisnall    // Take advantage of knowing source and pattern lengths.  Stop short when source is smaller than pattern
9277a984708SDavid Chisnall    typename iterator_traits<_RandomAccessIterator2>::difference_type __len2 = __last2 - __first2;
9287a984708SDavid Chisnall    if (__len2 == 0)
9297a984708SDavid Chisnall        return __last1;
9307a984708SDavid Chisnall    typename iterator_traits<_RandomAccessIterator1>::difference_type __len1 = __last1 - __first1;
9317a984708SDavid Chisnall    if (__len1 < __len2)
9327a984708SDavid Chisnall        return __last1;
9337a984708SDavid Chisnall    const _RandomAccessIterator1 __s = __first1 + (__len2 - 1);  // End of pattern match can't go before here
9347a984708SDavid Chisnall    _RandomAccessIterator1 __l1 = __last1;
9357a984708SDavid Chisnall    _RandomAccessIterator2 __l2 = __last2;
9367a984708SDavid Chisnall    --__l2;
9377a984708SDavid Chisnall    while (true)
9387a984708SDavid Chisnall    {
9397a984708SDavid Chisnall        while (true)
9407a984708SDavid Chisnall        {
9417a984708SDavid Chisnall            if (__s == __l1)
9427a984708SDavid Chisnall                return __last1;
9437a984708SDavid Chisnall            if (__pred(*--__l1, *__l2))
9447a984708SDavid Chisnall                break;
9457a984708SDavid Chisnall        }
9467a984708SDavid Chisnall        _RandomAccessIterator1 __m1 = __l1;
9477a984708SDavid Chisnall        _RandomAccessIterator2 __m2 = __l2;
9487a984708SDavid Chisnall        while (true)
9497a984708SDavid Chisnall        {
9507a984708SDavid Chisnall            if (__m2 == __first2)
9517a984708SDavid Chisnall                return __m1;
9527a984708SDavid Chisnall                                 // no need to check range on __m1 because __s guarantees we have enough source
9537a984708SDavid Chisnall            if (!__pred(*--__m1, *--__m2))
9547a984708SDavid Chisnall            {
9557a984708SDavid Chisnall                break;
9567a984708SDavid Chisnall            }
9577a984708SDavid Chisnall        }
9587a984708SDavid Chisnall    }
9597a984708SDavid Chisnall}
9607a984708SDavid Chisnall
9617a984708SDavid Chisnalltemplate <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
9627a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
9637a984708SDavid Chisnall_ForwardIterator1
9647a984708SDavid Chisnallfind_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
9657a984708SDavid Chisnall         _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred)
9667a984708SDavid Chisnall{
9677a984708SDavid Chisnall    return _VSTD::__find_end<typename add_lvalue_reference<_BinaryPredicate>::type>
9687a984708SDavid Chisnall                         (__first1, __last1, __first2, __last2, __pred,
9697a984708SDavid Chisnall                          typename iterator_traits<_ForwardIterator1>::iterator_category(),
9707a984708SDavid Chisnall                          typename iterator_traits<_ForwardIterator2>::iterator_category());
9717a984708SDavid Chisnall}
9727a984708SDavid Chisnall
9737a984708SDavid Chisnalltemplate <class _ForwardIterator1, class _ForwardIterator2>
9747a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
9757a984708SDavid Chisnall_ForwardIterator1
9767a984708SDavid Chisnallfind_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
9777a984708SDavid Chisnall         _ForwardIterator2 __first2, _ForwardIterator2 __last2)
9787a984708SDavid Chisnall{
9797a984708SDavid Chisnall    typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
9807a984708SDavid Chisnall    typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
9817a984708SDavid Chisnall    return _VSTD::find_end(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
9827a984708SDavid Chisnall}
9837a984708SDavid Chisnall
9847a984708SDavid Chisnall// find_first_of
9857a984708SDavid Chisnall
9867a984708SDavid Chisnalltemplate <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
9877a984708SDavid Chisnall_ForwardIterator1
9887a984708SDavid Chisnallfind_first_of(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
9897a984708SDavid Chisnall              _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred)
9907a984708SDavid Chisnall{
9917a984708SDavid Chisnall    for (; __first1 != __last1; ++__first1)
9927a984708SDavid Chisnall        for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j)
9937a984708SDavid Chisnall            if (__pred(*__first1, *__j))
9947a984708SDavid Chisnall                return __first1;
9957a984708SDavid Chisnall    return __last1;
9967a984708SDavid Chisnall}
9977a984708SDavid Chisnall
9987a984708SDavid Chisnalltemplate <class _ForwardIterator1, class _ForwardIterator2>
9997a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
10007a984708SDavid Chisnall_ForwardIterator1
10017a984708SDavid Chisnallfind_first_of(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
10027a984708SDavid Chisnall              _ForwardIterator2 __first2, _ForwardIterator2 __last2)
10037a984708SDavid Chisnall{
10047a984708SDavid Chisnall    typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
10057a984708SDavid Chisnall    typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
10067a984708SDavid Chisnall    return _VSTD::find_first_of(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
10077a984708SDavid Chisnall}
10087a984708SDavid Chisnall
10097a984708SDavid Chisnall// adjacent_find
10107a984708SDavid Chisnall
10117a984708SDavid Chisnalltemplate <class _ForwardIterator, class _BinaryPredicate>
10127a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
10137a984708SDavid Chisnall_ForwardIterator
10147a984708SDavid Chisnalladjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred)
10157a984708SDavid Chisnall{
10167a984708SDavid Chisnall    if (__first != __last)
10177a984708SDavid Chisnall    {
10187a984708SDavid Chisnall        _ForwardIterator __i = __first;
10197a984708SDavid Chisnall        while (++__i != __last)
10207a984708SDavid Chisnall        {
10217a984708SDavid Chisnall            if (__pred(*__first, *__i))
10227a984708SDavid Chisnall                return __first;
10237a984708SDavid Chisnall            __first = __i;
10247a984708SDavid Chisnall        }
10257a984708SDavid Chisnall    }
10267a984708SDavid Chisnall    return __last;
10277a984708SDavid Chisnall}
10287a984708SDavid Chisnall
10297a984708SDavid Chisnalltemplate <class _ForwardIterator>
10307a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
10317a984708SDavid Chisnall_ForwardIterator
10327a984708SDavid Chisnalladjacent_find(_ForwardIterator __first, _ForwardIterator __last)
10337a984708SDavid Chisnall{
10347a984708SDavid Chisnall    typedef typename iterator_traits<_ForwardIterator>::value_type __v;
10357a984708SDavid Chisnall    return _VSTD::adjacent_find(__first, __last, __equal_to<__v>());
10367a984708SDavid Chisnall}
10377a984708SDavid Chisnall
10387a984708SDavid Chisnall// count
10397a984708SDavid Chisnall
10407a984708SDavid Chisnalltemplate <class _InputIterator, class _Tp>
10417a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
10427a984708SDavid Chisnalltypename iterator_traits<_InputIterator>::difference_type
10437a984708SDavid Chisnallcount(_InputIterator __first, _InputIterator __last, const _Tp& __value_)
10447a984708SDavid Chisnall{
10457a984708SDavid Chisnall    typename iterator_traits<_InputIterator>::difference_type __r(0);
10467a984708SDavid Chisnall    for (; __first != __last; ++__first)
10477a984708SDavid Chisnall        if (*__first == __value_)
10487a984708SDavid Chisnall            ++__r;
10497a984708SDavid Chisnall    return __r;
10507a984708SDavid Chisnall}
10517a984708SDavid Chisnall
10527a984708SDavid Chisnall// count_if
10537a984708SDavid Chisnall
10547a984708SDavid Chisnalltemplate <class _InputIterator, class _Predicate>
10557a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
10567a984708SDavid Chisnalltypename iterator_traits<_InputIterator>::difference_type
10577a984708SDavid Chisnallcount_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
10587a984708SDavid Chisnall{
10597a984708SDavid Chisnall    typename iterator_traits<_InputIterator>::difference_type __r(0);
10607a984708SDavid Chisnall    for (; __first != __last; ++__first)
10617a984708SDavid Chisnall        if (__pred(*__first))
10627a984708SDavid Chisnall            ++__r;
10637a984708SDavid Chisnall    return __r;
10647a984708SDavid Chisnall}
10657a984708SDavid Chisnall
10667a984708SDavid Chisnall// mismatch
10677a984708SDavid Chisnall
10687a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
10697a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
10707a984708SDavid Chisnallpair<_InputIterator1, _InputIterator2>
10717a984708SDavid Chisnallmismatch(_InputIterator1 __first1, _InputIterator1 __last1,
10727a984708SDavid Chisnall         _InputIterator2 __first2, _BinaryPredicate __pred)
10737a984708SDavid Chisnall{
10747a984708SDavid Chisnall    for (; __first1 != __last1; ++__first1, ++__first2)
10757a984708SDavid Chisnall        if (!__pred(*__first1, *__first2))
10767a984708SDavid Chisnall            break;
10777a984708SDavid Chisnall    return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
10787a984708SDavid Chisnall}
10797a984708SDavid Chisnall
10807a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2>
10817a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
10827a984708SDavid Chisnallpair<_InputIterator1, _InputIterator2>
10837a984708SDavid Chisnallmismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2)
10847a984708SDavid Chisnall{
10857a984708SDavid Chisnall    typedef typename iterator_traits<_InputIterator1>::value_type __v1;
10867a984708SDavid Chisnall    typedef typename iterator_traits<_InputIterator2>::value_type __v2;
10877a984708SDavid Chisnall    return _VSTD::mismatch(__first1, __last1, __first2, __equal_to<__v1, __v2>());
10887a984708SDavid Chisnall}
10897a984708SDavid Chisnall
10907a984708SDavid Chisnall// equal
10917a984708SDavid Chisnall
10927a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
10937a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
10947a984708SDavid Chisnallbool
10957a984708SDavid Chisnallequal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __pred)
10967a984708SDavid Chisnall{
10977a984708SDavid Chisnall    for (; __first1 != __last1; ++__first1, ++__first2)
10987a984708SDavid Chisnall        if (!__pred(*__first1, *__first2))
10997a984708SDavid Chisnall            return false;
11007a984708SDavid Chisnall    return true;
11017a984708SDavid Chisnall}
11027a984708SDavid Chisnall
11037a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2>
11047a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
11057a984708SDavid Chisnallbool
11067a984708SDavid Chisnallequal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2)
11077a984708SDavid Chisnall{
11087a984708SDavid Chisnall    typedef typename iterator_traits<_InputIterator1>::value_type __v1;
11097a984708SDavid Chisnall    typedef typename iterator_traits<_InputIterator2>::value_type __v2;
11107a984708SDavid Chisnall    return _VSTD::equal(__first1, __last1, __first2, __equal_to<__v1, __v2>());
11117a984708SDavid Chisnall}
11127a984708SDavid Chisnall
11137a984708SDavid Chisnall// is_permutation
11147a984708SDavid Chisnall
11157a984708SDavid Chisnalltemplate<class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
11167a984708SDavid Chisnallbool
11177a984708SDavid Chisnallis_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
11187a984708SDavid Chisnall               _ForwardIterator2 __first2, _BinaryPredicate __pred)
11197a984708SDavid Chisnall{
11207a984708SDavid Chisnall    // shorten sequences as much as possible by lopping of any equal parts
11217a984708SDavid Chisnall    for (; __first1 != __last1; ++__first1, ++__first2)
11227a984708SDavid Chisnall        if (!__pred(*__first1, *__first2))
11237a984708SDavid Chisnall            goto __not_done;
11247a984708SDavid Chisnall    return true;
11257a984708SDavid Chisnall__not_done:
11267a984708SDavid Chisnall    // __first1 != __last1 && *__first1 != *__first2
11277a984708SDavid Chisnall    typedef typename iterator_traits<_ForwardIterator1>::difference_type _D1;
11287a984708SDavid Chisnall    _D1 __l1 = _VSTD::distance(__first1, __last1);
11297a984708SDavid Chisnall    if (__l1 == _D1(1))
11307a984708SDavid Chisnall        return false;
11317a984708SDavid Chisnall    _ForwardIterator2 __last2 = _VSTD::next(__first2, __l1);
11327a984708SDavid Chisnall    // For each element in [f1, l1) see if there are the same number of
11337a984708SDavid Chisnall    //    equal elements in [f2, l2)
11347a984708SDavid Chisnall    for (_ForwardIterator1 __i = __first1; __i != __last1; ++__i)
11357a984708SDavid Chisnall    {
11367a984708SDavid Chisnall        // Have we already counted the number of *__i in [f1, l1)?
11377a984708SDavid Chisnall        for (_ForwardIterator1 __j = __first1; __j != __i; ++__j)
11387a984708SDavid Chisnall            if (__pred(*__j, *__i))
11397a984708SDavid Chisnall                goto __next_iter;
11407a984708SDavid Chisnall        {
11417a984708SDavid Chisnall            // Count number of *__i in [f2, l2)
11427a984708SDavid Chisnall            _D1 __c2 = 0;
11437a984708SDavid Chisnall            for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j)
11447a984708SDavid Chisnall                if (__pred(*__i, *__j))
11457a984708SDavid Chisnall                    ++__c2;
11467a984708SDavid Chisnall            if (__c2 == 0)
11477a984708SDavid Chisnall                return false;
11487a984708SDavid Chisnall            // Count number of *__i in [__i, l1) (we can start with 1)
11497a984708SDavid Chisnall            _D1 __c1 = 1;
11507a984708SDavid Chisnall            for (_ForwardIterator1 __j = _VSTD::next(__i); __j != __last1; ++__j)
11517a984708SDavid Chisnall                if (__pred(*__i, *__j))
11527a984708SDavid Chisnall                    ++__c1;
11537a984708SDavid Chisnall            if (__c1 != __c2)
11547a984708SDavid Chisnall                return false;
11557a984708SDavid Chisnall        }
11567a984708SDavid Chisnall__next_iter:;
11577a984708SDavid Chisnall    }
11587a984708SDavid Chisnall    return true;
11597a984708SDavid Chisnall}
11607a984708SDavid Chisnall
11617a984708SDavid Chisnalltemplate<class _ForwardIterator1, class _ForwardIterator2>
11627a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
11637a984708SDavid Chisnallbool
11647a984708SDavid Chisnallis_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
11657a984708SDavid Chisnall               _ForwardIterator2 __first2)
11667a984708SDavid Chisnall{
11677a984708SDavid Chisnall    typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
11687a984708SDavid Chisnall    typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
11697a984708SDavid Chisnall    return _VSTD::is_permutation(__first1, __last1, __first2, __equal_to<__v1, __v2>());
11707a984708SDavid Chisnall}
11717a984708SDavid Chisnall
11727a984708SDavid Chisnall// search
11737a984708SDavid Chisnall
11747a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2>
11757a984708SDavid Chisnall_ForwardIterator1
11767a984708SDavid Chisnall__search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
11777a984708SDavid Chisnall         _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred,
11787a984708SDavid Chisnall         forward_iterator_tag, forward_iterator_tag)
11797a984708SDavid Chisnall{
11807a984708SDavid Chisnall    if (__first2 == __last2)
11817a984708SDavid Chisnall        return __first1;  // Everything matches an empty sequence
11827a984708SDavid Chisnall    while (true)
11837a984708SDavid Chisnall    {
11847a984708SDavid Chisnall        // Find first element in sequence 1 that matchs *__first2, with a mininum of loop checks
11857a984708SDavid Chisnall        while (true)
11867a984708SDavid Chisnall        {
11877a984708SDavid Chisnall            if (__first1 == __last1)  // return __last1 if no element matches *__first2
11887a984708SDavid Chisnall                return __last1;
11897a984708SDavid Chisnall            if (__pred(*__first1, *__first2))
11907a984708SDavid Chisnall                break;
11917a984708SDavid Chisnall            ++__first1;
11927a984708SDavid Chisnall        }
11937a984708SDavid Chisnall        // *__first1 matches *__first2, now match elements after here
11947a984708SDavid Chisnall        _ForwardIterator1 __m1 = __first1;
11957a984708SDavid Chisnall        _ForwardIterator2 __m2 = __first2;
11967a984708SDavid Chisnall        while (true)
11977a984708SDavid Chisnall        {
11987a984708SDavid Chisnall            if (++__m2 == __last2)  // If pattern exhausted, __first1 is the answer (works for 1 element pattern)
11997a984708SDavid Chisnall                return __first1;
12007a984708SDavid Chisnall            if (++__m1 == __last1)  // Otherwise if source exhaused, pattern not found
12017a984708SDavid Chisnall                return __last1;
12027a984708SDavid Chisnall            if (!__pred(*__m1, *__m2))  // if there is a mismatch, restart with a new __first1
12037a984708SDavid Chisnall            {
12047a984708SDavid Chisnall                ++__first1;
12057a984708SDavid Chisnall                break;
12067a984708SDavid Chisnall            }  // else there is a match, check next elements
12077a984708SDavid Chisnall        }
12087a984708SDavid Chisnall    }
12097a984708SDavid Chisnall}
12107a984708SDavid Chisnall
12117a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2>
12127a984708SDavid Chisnall_RandomAccessIterator1
12137a984708SDavid Chisnall__search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
12147a984708SDavid Chisnall           _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred,
12157a984708SDavid Chisnall           random_access_iterator_tag, random_access_iterator_tag)
12167a984708SDavid Chisnall{
12177a984708SDavid Chisnall    typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _D1;
12187a984708SDavid Chisnall    typedef typename std::iterator_traits<_RandomAccessIterator2>::difference_type _D2;
12197a984708SDavid Chisnall    // Take advantage of knowing source and pattern lengths.  Stop short when source is smaller than pattern
12207a984708SDavid Chisnall    _D2 __len2 = __last2 - __first2;
12217a984708SDavid Chisnall    if (__len2 == 0)
12227a984708SDavid Chisnall        return __first1;
12237a984708SDavid Chisnall    _D1 __len1 = __last1 - __first1;
12247a984708SDavid Chisnall    if (__len1 < __len2)
12257a984708SDavid Chisnall        return __last1;
12267a984708SDavid Chisnall    const _RandomAccessIterator1 __s = __last1 - (__len2 - 1);  // Start of pattern match can't go beyond here
12277a984708SDavid Chisnall    while (true)
12287a984708SDavid Chisnall    {
12297a984708SDavid Chisnall#if !_LIBCPP_UNROLL_LOOPS
12307a984708SDavid Chisnall        while (true)
12317a984708SDavid Chisnall        {
12327a984708SDavid Chisnall            if (__first1 == __s)
12337a984708SDavid Chisnall                return __last1;
12347a984708SDavid Chisnall            if (__pred(*__first1, *__first2))
12357a984708SDavid Chisnall                break;
12367a984708SDavid Chisnall            ++__first1;
12377a984708SDavid Chisnall        }
12387a984708SDavid Chisnall#else  // !_LIBCPP_UNROLL_LOOPS
12397a984708SDavid Chisnall        for (_D1 __loop_unroll = (__s - __first1) / 4; __loop_unroll > 0; --__loop_unroll)
12407a984708SDavid Chisnall        {
12417a984708SDavid Chisnall            if (__pred(*__first1, *__first2))
12427a984708SDavid Chisnall                goto __phase2;
12437a984708SDavid Chisnall            if (__pred(*++__first1, *__first2))
12447a984708SDavid Chisnall                goto __phase2;
12457a984708SDavid Chisnall            if (__pred(*++__first1, *__first2))
12467a984708SDavid Chisnall                goto __phase2;
12477a984708SDavid Chisnall            if (__pred(*++__first1, *__first2))
12487a984708SDavid Chisnall                goto __phase2;
12497a984708SDavid Chisnall            ++__first1;
12507a984708SDavid Chisnall        }
12517a984708SDavid Chisnall        switch (__s - __first1)
12527a984708SDavid Chisnall        {
12537a984708SDavid Chisnall        case 3:
12547a984708SDavid Chisnall            if (__pred(*__first1, *__first2))
12557a984708SDavid Chisnall                break;
12567a984708SDavid Chisnall            ++__first1;
12577a984708SDavid Chisnall        case 2:
12587a984708SDavid Chisnall            if (__pred(*__first1, *__first2))
12597a984708SDavid Chisnall                break;
12607a984708SDavid Chisnall            ++__first1;
12617a984708SDavid Chisnall        case 1:
12627a984708SDavid Chisnall            if (__pred(*__first1, *__first2))
12637a984708SDavid Chisnall                break;
12647a984708SDavid Chisnall        case 0:
12657a984708SDavid Chisnall            return __last1;
12667a984708SDavid Chisnall        }
12677a984708SDavid Chisnall    __phase2:
12687a984708SDavid Chisnall#endif  // !_LIBCPP_UNROLL_LOOPS
12697a984708SDavid Chisnall        _RandomAccessIterator1 __m1 = __first1;
12707a984708SDavid Chisnall        _RandomAccessIterator2 __m2 = __first2;
12717a984708SDavid Chisnall#if !_LIBCPP_UNROLL_LOOPS
12727a984708SDavid Chisnall         while (true)
12737a984708SDavid Chisnall         {
12747a984708SDavid Chisnall             if (++__m2 == __last2)
12757a984708SDavid Chisnall                 return __first1;
12767a984708SDavid Chisnall             ++__m1;          // no need to check range on __m1 because __s guarantees we have enough source
12777a984708SDavid Chisnall             if (!__pred(*__m1, *__m2))
12787a984708SDavid Chisnall             {
12797a984708SDavid Chisnall                 ++__first1;
12807a984708SDavid Chisnall                 break;
12817a984708SDavid Chisnall             }
12827a984708SDavid Chisnall         }
12837a984708SDavid Chisnall#else  // !_LIBCPP_UNROLL_LOOPS
12847a984708SDavid Chisnall        ++__m2;
12857a984708SDavid Chisnall        ++__m1;
12867a984708SDavid Chisnall        for (_D2 __loop_unroll = (__last2 - __m2) / 4; __loop_unroll > 0; --__loop_unroll)
12877a984708SDavid Chisnall        {
12887a984708SDavid Chisnall            if (!__pred(*__m1, *__m2))
12897a984708SDavid Chisnall                goto __continue;
12907a984708SDavid Chisnall            if (!__pred(*++__m1, *++__m2))
12917a984708SDavid Chisnall                goto __continue;
12927a984708SDavid Chisnall            if (!__pred(*++__m1, *++__m2))
12937a984708SDavid Chisnall                goto __continue;
12947a984708SDavid Chisnall            if (!__pred(*++__m1, *++__m2))
12957a984708SDavid Chisnall                goto __continue;
12967a984708SDavid Chisnall            ++__m1;
12977a984708SDavid Chisnall            ++__m2;
12987a984708SDavid Chisnall        }
12997a984708SDavid Chisnall        switch (__last2 - __m2)
13007a984708SDavid Chisnall        {
13017a984708SDavid Chisnall        case 3:
13027a984708SDavid Chisnall            if (!__pred(*__m1, *__m2))
13037a984708SDavid Chisnall                break;
13047a984708SDavid Chisnall            ++__m1;
13057a984708SDavid Chisnall            ++__m2;
13067a984708SDavid Chisnall        case 2:
13077a984708SDavid Chisnall            if (!__pred(*__m1, *__m2))
13087a984708SDavid Chisnall                break;
13097a984708SDavid Chisnall            ++__m1;
13107a984708SDavid Chisnall            ++__m2;
13117a984708SDavid Chisnall        case 1:
13127a984708SDavid Chisnall            if (!__pred(*__m1, *__m2))
13137a984708SDavid Chisnall                break;
13147a984708SDavid Chisnall        case 0:
13157a984708SDavid Chisnall            return __first1;
13167a984708SDavid Chisnall        }
13177a984708SDavid Chisnall    __continue:
13187a984708SDavid Chisnall        ++__first1;
13197a984708SDavid Chisnall#endif  // !_LIBCPP_UNROLL_LOOPS
13207a984708SDavid Chisnall    }
13217a984708SDavid Chisnall}
13227a984708SDavid Chisnall
13237a984708SDavid Chisnalltemplate <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
13247a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
13257a984708SDavid Chisnall_ForwardIterator1
13267a984708SDavid Chisnallsearch(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
13277a984708SDavid Chisnall       _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred)
13287a984708SDavid Chisnall{
13297a984708SDavid Chisnall    return _VSTD::__search<typename add_lvalue_reference<_BinaryPredicate>::type>
13307a984708SDavid Chisnall                         (__first1, __last1, __first2, __last2, __pred,
13317a984708SDavid Chisnall                          typename std::iterator_traits<_ForwardIterator1>::iterator_category(),
13327a984708SDavid Chisnall                          typename std::iterator_traits<_ForwardIterator2>::iterator_category());
13337a984708SDavid Chisnall}
13347a984708SDavid Chisnall
13357a984708SDavid Chisnalltemplate <class _ForwardIterator1, class _ForwardIterator2>
13367a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
13377a984708SDavid Chisnall_ForwardIterator1
13387a984708SDavid Chisnallsearch(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
13397a984708SDavid Chisnall       _ForwardIterator2 __first2, _ForwardIterator2 __last2)
13407a984708SDavid Chisnall{
13417a984708SDavid Chisnall    typedef typename std::iterator_traits<_ForwardIterator1>::value_type __v1;
13427a984708SDavid Chisnall    typedef typename std::iterator_traits<_ForwardIterator2>::value_type __v2;
13437a984708SDavid Chisnall    return _VSTD::search(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
13447a984708SDavid Chisnall}
13457a984708SDavid Chisnall
13467a984708SDavid Chisnall// search_n
13477a984708SDavid Chisnall
13487a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _ForwardIterator, class _Size, class _Tp>
13497a984708SDavid Chisnall_ForwardIterator
13507a984708SDavid Chisnall__search_n(_ForwardIterator __first, _ForwardIterator __last,
13517a984708SDavid Chisnall           _Size __count, const _Tp& __value_, _BinaryPredicate __pred, forward_iterator_tag)
13527a984708SDavid Chisnall{
13537a984708SDavid Chisnall    if (__count <= 0)
13547a984708SDavid Chisnall        return __first;
13557a984708SDavid Chisnall    while (true)
13567a984708SDavid Chisnall    {
13577a984708SDavid Chisnall        // Find first element in sequence that matchs __value_, with a mininum of loop checks
13587a984708SDavid Chisnall        while (true)
13597a984708SDavid Chisnall        {
13607a984708SDavid Chisnall            if (__first == __last)  // return __last if no element matches __value_
13617a984708SDavid Chisnall                return __last;
13627a984708SDavid Chisnall            if (__pred(*__first, __value_))
13637a984708SDavid Chisnall                break;
13647a984708SDavid Chisnall            ++__first;
13657a984708SDavid Chisnall        }
13667a984708SDavid Chisnall        // *__first matches __value_, now match elements after here
13677a984708SDavid Chisnall        _ForwardIterator __m = __first;
13687a984708SDavid Chisnall        _Size __c(0);
13697a984708SDavid Chisnall        while (true)
13707a984708SDavid Chisnall        {
13717a984708SDavid Chisnall            if (++__c == __count)  // If pattern exhausted, __first is the answer (works for 1 element pattern)
13727a984708SDavid Chisnall                return __first;
13737a984708SDavid Chisnall            if (++__m == __last)  // Otherwise if source exhaused, pattern not found
13747a984708SDavid Chisnall                return __last;
13757a984708SDavid Chisnall            if (!__pred(*__m, __value_))  // if there is a mismatch, restart with a new __first
13767a984708SDavid Chisnall            {
13777a984708SDavid Chisnall                __first = __m;
13787a984708SDavid Chisnall                ++__first;
13797a984708SDavid Chisnall                break;
13807a984708SDavid Chisnall            }  // else there is a match, check next elements
13817a984708SDavid Chisnall        }
13827a984708SDavid Chisnall    }
13837a984708SDavid Chisnall}
13847a984708SDavid Chisnall
13857a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _RandomAccessIterator, class _Size, class _Tp>
13867a984708SDavid Chisnall_RandomAccessIterator
13877a984708SDavid Chisnall__search_n(_RandomAccessIterator __first, _RandomAccessIterator __last,
13887a984708SDavid Chisnall           _Size __count, const _Tp& __value_, _BinaryPredicate __pred, random_access_iterator_tag)
13897a984708SDavid Chisnall{
13907a984708SDavid Chisnall    if (__count <= 0)
13917a984708SDavid Chisnall        return __first;
13927a984708SDavid Chisnall    _Size __len = static_cast<_Size>(__last - __first);
13937a984708SDavid Chisnall    if (__len < __count)
13947a984708SDavid Chisnall        return __last;
13957a984708SDavid Chisnall    const _RandomAccessIterator __s = __last - (__count - 1);  // Start of pattern match can't go beyond here
13967a984708SDavid Chisnall    while (true)
13977a984708SDavid Chisnall    {
13987a984708SDavid Chisnall        // Find first element in sequence that matchs __value_, with a mininum of loop checks
13997a984708SDavid Chisnall        while (true)
14007a984708SDavid Chisnall        {
14017a984708SDavid Chisnall            if (__first == __s)  // return __last if no element matches __value_
14027a984708SDavid Chisnall                return __last;
14037a984708SDavid Chisnall            if (__pred(*__first, __value_))
14047a984708SDavid Chisnall                break;
14057a984708SDavid Chisnall            ++__first;
14067a984708SDavid Chisnall        }
14077a984708SDavid Chisnall        // *__first matches __value_, now match elements after here
14087a984708SDavid Chisnall        _RandomAccessIterator __m = __first;
14097a984708SDavid Chisnall        _Size __c(0);
14107a984708SDavid Chisnall        while (true)
14117a984708SDavid Chisnall        {
14127a984708SDavid Chisnall            if (++__c == __count)  // If pattern exhausted, __first is the answer (works for 1 element pattern)
14137a984708SDavid Chisnall                return __first;
14147a984708SDavid Chisnall             ++__m;          // no need to check range on __m because __s guarantees we have enough source
14157a984708SDavid Chisnall            if (!__pred(*__m, __value_))  // if there is a mismatch, restart with a new __first
14167a984708SDavid Chisnall            {
14177a984708SDavid Chisnall                __first = __m;
14187a984708SDavid Chisnall                ++__first;
14197a984708SDavid Chisnall                break;
14207a984708SDavid Chisnall            }  // else there is a match, check next elements
14217a984708SDavid Chisnall        }
14227a984708SDavid Chisnall    }
14237a984708SDavid Chisnall}
14247a984708SDavid Chisnall
14257a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
14267a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
14277a984708SDavid Chisnall_ForwardIterator
14287a984708SDavid Chisnallsearch_n(_ForwardIterator __first, _ForwardIterator __last,
14297a984708SDavid Chisnall         _Size __count, const _Tp& __value_, _BinaryPredicate __pred)
14307a984708SDavid Chisnall{
14317a984708SDavid Chisnall    return _VSTD::__search_n<typename add_lvalue_reference<_BinaryPredicate>::type>
14327a984708SDavid Chisnall           (__first, __last, __count, __value_, __pred, typename iterator_traits<_ForwardIterator>::iterator_category());
14337a984708SDavid Chisnall}
14347a984708SDavid Chisnall
14357a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Size, class _Tp>
14367a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
14377a984708SDavid Chisnall_ForwardIterator
14387a984708SDavid Chisnallsearch_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value_)
14397a984708SDavid Chisnall{
14407a984708SDavid Chisnall    typedef typename iterator_traits<_ForwardIterator>::value_type __v;
14417a984708SDavid Chisnall    return _VSTD::search_n(__first, __last, __count, __value_, __equal_to<__v, _Tp>());
14427a984708SDavid Chisnall}
14437a984708SDavid Chisnall
14447a984708SDavid Chisnall// copy
14457a984708SDavid Chisnall
14467a984708SDavid Chisnalltemplate <class _Iter>
14477a984708SDavid Chisnallstruct __libcpp_is_trivial_iterator
14487a984708SDavid Chisnall{
14497a984708SDavid Chisnall    static const bool value = is_pointer<_Iter>::value;
14507a984708SDavid Chisnall};
14517a984708SDavid Chisnall
14527a984708SDavid Chisnalltemplate <class _Iter>
14537a984708SDavid Chisnallstruct __libcpp_is_trivial_iterator<move_iterator<_Iter> >
14547a984708SDavid Chisnall{
14557a984708SDavid Chisnall    static const bool value = is_pointer<_Iter>::value;
14567a984708SDavid Chisnall};
14577a984708SDavid Chisnall
14587a984708SDavid Chisnalltemplate <class _Iter>
14597a984708SDavid Chisnallstruct __libcpp_is_trivial_iterator<__wrap_iter<_Iter> >
14607a984708SDavid Chisnall{
14617a984708SDavid Chisnall    static const bool value = is_pointer<_Iter>::value;
14627a984708SDavid Chisnall};
14637a984708SDavid Chisnall
14647a984708SDavid Chisnalltemplate <class _Iter>
14657a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
14667a984708SDavid Chisnall_Iter
14677a984708SDavid Chisnall__unwrap_iter(_Iter __i)
14687a984708SDavid Chisnall{
14697a984708SDavid Chisnall    return __i;
14707a984708SDavid Chisnall}
14717a984708SDavid Chisnall
14727a984708SDavid Chisnalltemplate <class _Tp>
14737a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
14747a984708SDavid Chisnalltypename enable_if
14757a984708SDavid Chisnall<
14767a984708SDavid Chisnall    is_trivially_copy_assignable<_Tp>::value,
14777a984708SDavid Chisnall    _Tp*
14787a984708SDavid Chisnall>::type
14797a984708SDavid Chisnall__unwrap_iter(move_iterator<_Tp*> __i)
14807a984708SDavid Chisnall{
14817a984708SDavid Chisnall    return __i.base();
14827a984708SDavid Chisnall}
14837a984708SDavid Chisnall
14847a984708SDavid Chisnalltemplate <class _Tp>
14857a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
14867a984708SDavid Chisnalltypename enable_if
14877a984708SDavid Chisnall<
14887a984708SDavid Chisnall    is_trivially_copy_assignable<_Tp>::value,
14897a984708SDavid Chisnall    _Tp*
14907a984708SDavid Chisnall>::type
14917a984708SDavid Chisnall__unwrap_iter(__wrap_iter<_Tp*> __i)
14927a984708SDavid Chisnall{
14937a984708SDavid Chisnall    return __i.base();
14947a984708SDavid Chisnall}
14957a984708SDavid Chisnall
14967a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator>
14977a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
14987a984708SDavid Chisnall_OutputIterator
14997a984708SDavid Chisnall__copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
15007a984708SDavid Chisnall{
15017a984708SDavid Chisnall    for (; __first != __last; ++__first, ++__result)
15027a984708SDavid Chisnall        *__result = *__first;
15037a984708SDavid Chisnall    return __result;
15047a984708SDavid Chisnall}
15057a984708SDavid Chisnall
15067a984708SDavid Chisnalltemplate <class _Tp, class _Up>
15077a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
15087a984708SDavid Chisnalltypename enable_if
15097a984708SDavid Chisnall<
15107a984708SDavid Chisnall    is_same<typename remove_const<_Tp>::type, _Up>::value &&
15117a984708SDavid Chisnall    is_trivially_copy_assignable<_Up>::value,
15127a984708SDavid Chisnall    _Up*
15137a984708SDavid Chisnall>::type
15147a984708SDavid Chisnall__copy(_Tp* __first, _Tp* __last, _Up* __result)
15157a984708SDavid Chisnall{
15167a984708SDavid Chisnall    const size_t __n = static_cast<size_t>(__last - __first);
15177a984708SDavid Chisnall    _VSTD::memmove(__result, __first, __n * sizeof(_Up));
15187a984708SDavid Chisnall    return __result + __n;
15197a984708SDavid Chisnall}
15207a984708SDavid Chisnall
15217a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator>
15227a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
15237a984708SDavid Chisnall_OutputIterator
15247a984708SDavid Chisnallcopy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
15257a984708SDavid Chisnall{
15267a984708SDavid Chisnall    return _VSTD::__copy(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
15277a984708SDavid Chisnall}
15287a984708SDavid Chisnall
15297a984708SDavid Chisnall// copy_backward
15307a984708SDavid Chisnall
1531cfdf2879SDavid Chisnalltemplate <class _BidirectionalIterator, class _OutputIterator>
15327a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
15337a984708SDavid Chisnall_OutputIterator
1534cfdf2879SDavid Chisnall__copy_backward(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result)
15357a984708SDavid Chisnall{
15367a984708SDavid Chisnall    while (__first != __last)
15377a984708SDavid Chisnall        *--__result = *--__last;
15387a984708SDavid Chisnall    return __result;
15397a984708SDavid Chisnall}
15407a984708SDavid Chisnall
15417a984708SDavid Chisnalltemplate <class _Tp, class _Up>
15427a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
15437a984708SDavid Chisnalltypename enable_if
15447a984708SDavid Chisnall<
15457a984708SDavid Chisnall    is_same<typename remove_const<_Tp>::type, _Up>::value &&
15467a984708SDavid Chisnall    is_trivially_copy_assignable<_Up>::value,
15477a984708SDavid Chisnall    _Up*
15487a984708SDavid Chisnall>::type
15497a984708SDavid Chisnall__copy_backward(_Tp* __first, _Tp* __last, _Up* __result)
15507a984708SDavid Chisnall{
15517a984708SDavid Chisnall    const size_t __n = static_cast<size_t>(__last - __first);
15527a984708SDavid Chisnall    __result -= __n;
15537a984708SDavid Chisnall    _VSTD::memmove(__result, __first, __n * sizeof(_Up));
15547a984708SDavid Chisnall    return __result;
15557a984708SDavid Chisnall}
15567a984708SDavid Chisnall
15577a984708SDavid Chisnalltemplate <class _BidirectionalIterator1, class _BidirectionalIterator2>
15587a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
15597a984708SDavid Chisnall_BidirectionalIterator2
15607a984708SDavid Chisnallcopy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
15617a984708SDavid Chisnall              _BidirectionalIterator2 __result)
15627a984708SDavid Chisnall{
15637a984708SDavid Chisnall    return _VSTD::__copy_backward(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
15647a984708SDavid Chisnall}
15657a984708SDavid Chisnall
15667a984708SDavid Chisnall// copy_if
15677a984708SDavid Chisnall
15687a984708SDavid Chisnalltemplate<class _InputIterator, class _OutputIterator, class _Predicate>
15697a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
15707a984708SDavid Chisnall_OutputIterator
15717a984708SDavid Chisnallcopy_if(_InputIterator __first, _InputIterator __last,
15727a984708SDavid Chisnall        _OutputIterator __result, _Predicate __pred)
15737a984708SDavid Chisnall{
15747a984708SDavid Chisnall    for (; __first != __last; ++__first)
15757a984708SDavid Chisnall    {
15767a984708SDavid Chisnall        if (__pred(*__first))
15777a984708SDavid Chisnall        {
15787a984708SDavid Chisnall            *__result = *__first;
15797a984708SDavid Chisnall            ++__result;
15807a984708SDavid Chisnall        }
15817a984708SDavid Chisnall    }
15827a984708SDavid Chisnall    return __result;
15837a984708SDavid Chisnall}
15847a984708SDavid Chisnall
15857a984708SDavid Chisnall// copy_n
15867a984708SDavid Chisnall
15877a984708SDavid Chisnalltemplate<class _InputIterator, class _Size, class _OutputIterator>
15887a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
15897a984708SDavid Chisnalltypename enable_if
15907a984708SDavid Chisnall<
15917a984708SDavid Chisnall    __is_input_iterator<_InputIterator>::value &&
15927a984708SDavid Chisnall   !__is_random_access_iterator<_InputIterator>::value,
15937a984708SDavid Chisnall    _OutputIterator
15947a984708SDavid Chisnall>::type
15957a984708SDavid Chisnallcopy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
15967a984708SDavid Chisnall{
15977a984708SDavid Chisnall    if (__n > 0)
15987a984708SDavid Chisnall    {
15997a984708SDavid Chisnall        *__result = *__first;
16007a984708SDavid Chisnall        ++__result;
16017a984708SDavid Chisnall        for (--__n; __n > 0; --__n)
16027a984708SDavid Chisnall        {
16037a984708SDavid Chisnall            ++__first;
16047a984708SDavid Chisnall            *__result = *__first;
16057a984708SDavid Chisnall            ++__result;
16067a984708SDavid Chisnall        }
16077a984708SDavid Chisnall    }
16087a984708SDavid Chisnall    return __result;
16097a984708SDavid Chisnall}
16107a984708SDavid Chisnall
16117a984708SDavid Chisnalltemplate<class _InputIterator, class _Size, class _OutputIterator>
16127a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
16137a984708SDavid Chisnalltypename enable_if
16147a984708SDavid Chisnall<
16157a984708SDavid Chisnall    __is_random_access_iterator<_InputIterator>::value,
16167a984708SDavid Chisnall    _OutputIterator
16177a984708SDavid Chisnall>::type
16187a984708SDavid Chisnallcopy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
16197a984708SDavid Chisnall{
16207a984708SDavid Chisnall    return _VSTD::copy(__first, __first + __n, __result);
16217a984708SDavid Chisnall}
16227a984708SDavid Chisnall
16237a984708SDavid Chisnall// move
16247a984708SDavid Chisnall
16257a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator>
16267a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
16277a984708SDavid Chisnall_OutputIterator
16287a984708SDavid Chisnall__move(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
16297a984708SDavid Chisnall{
16307a984708SDavid Chisnall    for (; __first != __last; ++__first, ++__result)
16317a984708SDavid Chisnall        *__result = _VSTD::move(*__first);
16327a984708SDavid Chisnall    return __result;
16337a984708SDavid Chisnall}
16347a984708SDavid Chisnall
16357a984708SDavid Chisnalltemplate <class _Tp, class _Up>
16367a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
16377a984708SDavid Chisnalltypename enable_if
16387a984708SDavid Chisnall<
16397a984708SDavid Chisnall    is_same<typename remove_const<_Tp>::type, _Up>::value &&
16407a984708SDavid Chisnall    is_trivially_copy_assignable<_Up>::value,
16417a984708SDavid Chisnall    _Up*
16427a984708SDavid Chisnall>::type
16437a984708SDavid Chisnall__move(_Tp* __first, _Tp* __last, _Up* __result)
16447a984708SDavid Chisnall{
16457a984708SDavid Chisnall    const size_t __n = static_cast<size_t>(__last - __first);
16467a984708SDavid Chisnall    _VSTD::memmove(__result, __first, __n * sizeof(_Up));
16477a984708SDavid Chisnall    return __result + __n;
16487a984708SDavid Chisnall}
16497a984708SDavid Chisnall
16507a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator>
16517a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
16527a984708SDavid Chisnall_OutputIterator
16537a984708SDavid Chisnallmove(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
16547a984708SDavid Chisnall{
16557a984708SDavid Chisnall    return _VSTD::__move(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
16567a984708SDavid Chisnall}
16577a984708SDavid Chisnall
16587a984708SDavid Chisnall// move_backward
16597a984708SDavid Chisnall
16607a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator>
16617a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
16627a984708SDavid Chisnall_OutputIterator
16637a984708SDavid Chisnall__move_backward(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
16647a984708SDavid Chisnall{
16657a984708SDavid Chisnall    while (__first != __last)
16667a984708SDavid Chisnall        *--__result = _VSTD::move(*--__last);
16677a984708SDavid Chisnall    return __result;
16687a984708SDavid Chisnall}
16697a984708SDavid Chisnall
16707a984708SDavid Chisnalltemplate <class _Tp, class _Up>
16717a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
16727a984708SDavid Chisnalltypename enable_if
16737a984708SDavid Chisnall<
16747a984708SDavid Chisnall    is_same<typename remove_const<_Tp>::type, _Up>::value &&
16757a984708SDavid Chisnall    is_trivially_copy_assignable<_Up>::value,
16767a984708SDavid Chisnall    _Up*
16777a984708SDavid Chisnall>::type
16787a984708SDavid Chisnall__move_backward(_Tp* __first, _Tp* __last, _Up* __result)
16797a984708SDavid Chisnall{
16807a984708SDavid Chisnall    const size_t __n = static_cast<size_t>(__last - __first);
16817a984708SDavid Chisnall    __result -= __n;
16827a984708SDavid Chisnall    _VSTD::memmove(__result, __first, __n * sizeof(_Up));
16837a984708SDavid Chisnall    return __result;
16847a984708SDavid Chisnall}
16857a984708SDavid Chisnall
16867a984708SDavid Chisnalltemplate <class _BidirectionalIterator1, class _BidirectionalIterator2>
16877a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
16887a984708SDavid Chisnall_BidirectionalIterator2
16897a984708SDavid Chisnallmove_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
16907a984708SDavid Chisnall              _BidirectionalIterator2 __result)
16917a984708SDavid Chisnall{
16927a984708SDavid Chisnall    return _VSTD::__move_backward(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
16937a984708SDavid Chisnall}
16947a984708SDavid Chisnall
16957a984708SDavid Chisnall// iter_swap
16967a984708SDavid Chisnall
16977a984708SDavid Chisnall// moved to <type_traits> for better swap / noexcept support
16987a984708SDavid Chisnall
16997a984708SDavid Chisnall// transform
17007a984708SDavid Chisnall
17017a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator, class _UnaryOperation>
17027a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
17037a984708SDavid Chisnall_OutputIterator
17047a984708SDavid Chisnalltransform(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _UnaryOperation __op)
17057a984708SDavid Chisnall{
17067a984708SDavid Chisnall    for (; __first != __last; ++__first, ++__result)
17077a984708SDavid Chisnall        *__result = __op(*__first);
17087a984708SDavid Chisnall    return __result;
17097a984708SDavid Chisnall}
17107a984708SDavid Chisnall
17117a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _BinaryOperation>
17127a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
17137a984708SDavid Chisnall_OutputIterator
17147a984708SDavid Chisnalltransform(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2,
17157a984708SDavid Chisnall          _OutputIterator __result, _BinaryOperation __binary_op)
17167a984708SDavid Chisnall{
17177a984708SDavid Chisnall    for (; __first1 != __last1; ++__first1, ++__first2, ++__result)
17187a984708SDavid Chisnall        *__result = __binary_op(*__first1, *__first2);
17197a984708SDavid Chisnall    return __result;
17207a984708SDavid Chisnall}
17217a984708SDavid Chisnall
17227a984708SDavid Chisnall// replace
17237a984708SDavid Chisnall
17247a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp>
17257a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
17267a984708SDavid Chisnallvoid
17277a984708SDavid Chisnallreplace(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value, const _Tp& __new_value)
17287a984708SDavid Chisnall{
17297a984708SDavid Chisnall    for (; __first != __last; ++__first)
17307a984708SDavid Chisnall        if (*__first == __old_value)
17317a984708SDavid Chisnall            *__first = __new_value;
17327a984708SDavid Chisnall}
17337a984708SDavid Chisnall
17347a984708SDavid Chisnall// replace_if
17357a984708SDavid Chisnall
17367a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Predicate, class _Tp>
17377a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
17387a984708SDavid Chisnallvoid
17397a984708SDavid Chisnallreplace_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, const _Tp& __new_value)
17407a984708SDavid Chisnall{
17417a984708SDavid Chisnall    for (; __first != __last; ++__first)
17427a984708SDavid Chisnall        if (__pred(*__first))
17437a984708SDavid Chisnall            *__first = __new_value;
17447a984708SDavid Chisnall}
17457a984708SDavid Chisnall
17467a984708SDavid Chisnall// replace_copy
17477a984708SDavid Chisnall
17487a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator, class _Tp>
17497a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
17507a984708SDavid Chisnall_OutputIterator
17517a984708SDavid Chisnallreplace_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
17527a984708SDavid Chisnall             const _Tp& __old_value, const _Tp& __new_value)
17537a984708SDavid Chisnall{
17547a984708SDavid Chisnall    for (; __first != __last; ++__first, ++__result)
17557a984708SDavid Chisnall        if (*__first == __old_value)
17567a984708SDavid Chisnall            *__result = __new_value;
17577a984708SDavid Chisnall        else
17587a984708SDavid Chisnall            *__result = *__first;
17597a984708SDavid Chisnall    return __result;
17607a984708SDavid Chisnall}
17617a984708SDavid Chisnall
17627a984708SDavid Chisnall// replace_copy_if
17637a984708SDavid Chisnall
17647a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator, class _Predicate, class _Tp>
17657a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
17667a984708SDavid Chisnall_OutputIterator
17677a984708SDavid Chisnallreplace_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
17687a984708SDavid Chisnall                _Predicate __pred, const _Tp& __new_value)
17697a984708SDavid Chisnall{
17707a984708SDavid Chisnall    for (; __first != __last; ++__first, ++__result)
17717a984708SDavid Chisnall        if (__pred(*__first))
17727a984708SDavid Chisnall            *__result = __new_value;
17737a984708SDavid Chisnall        else
17747a984708SDavid Chisnall            *__result = *__first;
17757a984708SDavid Chisnall    return __result;
17767a984708SDavid Chisnall}
17777a984708SDavid Chisnall
17787a984708SDavid Chisnall// fill_n
17797a984708SDavid Chisnall
17807a984708SDavid Chisnalltemplate <class _OutputIterator, class _Size, class _Tp>
17817a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
17827a984708SDavid Chisnall_OutputIterator
17837a984708SDavid Chisnall__fill_n(_OutputIterator __first, _Size __n, const _Tp& __value_, false_type)
17847a984708SDavid Chisnall{
17857a984708SDavid Chisnall    for (; __n > 0; ++__first, --__n)
17867a984708SDavid Chisnall        *__first = __value_;
17877a984708SDavid Chisnall    return __first;
17887a984708SDavid Chisnall}
17897a984708SDavid Chisnall
17907a984708SDavid Chisnalltemplate <class _OutputIterator, class _Size, class _Tp>
17917a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
17927a984708SDavid Chisnall_OutputIterator
17937a984708SDavid Chisnall__fill_n(_OutputIterator __first, _Size __n, const _Tp& __value_, true_type)
17947a984708SDavid Chisnall{
17957a984708SDavid Chisnall    if (__n > 0)
17967a984708SDavid Chisnall        _VSTD::memset(__first, (unsigned char)__value_, (size_t)(__n));
17977a984708SDavid Chisnall    return __first + __n;
17987a984708SDavid Chisnall}
17997a984708SDavid Chisnall
18007a984708SDavid Chisnalltemplate <class _OutputIterator, class _Size, class _Tp>
18017a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
18027a984708SDavid Chisnall_OutputIterator
18037a984708SDavid Chisnallfill_n(_OutputIterator __first, _Size __n, const _Tp& __value_)
18047a984708SDavid Chisnall{
18057a984708SDavid Chisnall   return _VSTD::__fill_n(__first, __n, __value_, integral_constant<bool,
18067a984708SDavid Chisnall                                              is_pointer<_OutputIterator>::value &&
18077a984708SDavid Chisnall                                              is_trivially_copy_assignable<_Tp>::value     &&
18087a984708SDavid Chisnall                                              sizeof(_Tp) == 1>());
18097a984708SDavid Chisnall}
18107a984708SDavid Chisnall
18117a984708SDavid Chisnall// fill
18127a984708SDavid Chisnall
18137a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp>
18147a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
18157a984708SDavid Chisnallvoid
18167a984708SDavid Chisnall__fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, forward_iterator_tag)
18177a984708SDavid Chisnall{
18187a984708SDavid Chisnall    for (; __first != __last; ++__first)
18197a984708SDavid Chisnall        *__first = __value_;
18207a984708SDavid Chisnall}
18217a984708SDavid Chisnall
18227a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Tp>
18237a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
18247a984708SDavid Chisnallvoid
18257a984708SDavid Chisnall__fill(_RandomAccessIterator __first, _RandomAccessIterator __last, const _Tp& __value_, random_access_iterator_tag)
18267a984708SDavid Chisnall{
18277a984708SDavid Chisnall    _VSTD::fill_n(__first, __last - __first, __value_);
18287a984708SDavid Chisnall}
18297a984708SDavid Chisnall
18307a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp>
18317a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
18327a984708SDavid Chisnallvoid
18337a984708SDavid Chisnallfill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
18347a984708SDavid Chisnall{
18357a984708SDavid Chisnall    _VSTD::__fill(__first, __last, __value_, typename iterator_traits<_ForwardIterator>::iterator_category());
18367a984708SDavid Chisnall}
18377a984708SDavid Chisnall
18387a984708SDavid Chisnall// generate
18397a984708SDavid Chisnall
18407a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Generator>
18417a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
18427a984708SDavid Chisnallvoid
18437a984708SDavid Chisnallgenerate(_ForwardIterator __first, _ForwardIterator __last, _Generator __gen)
18447a984708SDavid Chisnall{
18457a984708SDavid Chisnall    for (; __first != __last; ++__first)
18467a984708SDavid Chisnall        *__first = __gen();
18477a984708SDavid Chisnall}
18487a984708SDavid Chisnall
18497a984708SDavid Chisnall// generate_n
18507a984708SDavid Chisnall
18517a984708SDavid Chisnalltemplate <class _OutputIterator, class _Size, class _Generator>
18527a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
18537a984708SDavid Chisnall_OutputIterator
18547a984708SDavid Chisnallgenerate_n(_OutputIterator __first, _Size __n, _Generator __gen)
18557a984708SDavid Chisnall{
18567a984708SDavid Chisnall    for (; __n > 0; ++__first, --__n)
18577a984708SDavid Chisnall        *__first = __gen();
18587a984708SDavid Chisnall    return __first;
18597a984708SDavid Chisnall}
18607a984708SDavid Chisnall
18617a984708SDavid Chisnall// remove
18627a984708SDavid Chisnall
18637a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp>
18647a984708SDavid Chisnall_ForwardIterator
18657a984708SDavid Chisnallremove(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
18667a984708SDavid Chisnall{
18677a984708SDavid Chisnall    __first = _VSTD::find(__first, __last, __value_);
18687a984708SDavid Chisnall    if (__first != __last)
18697a984708SDavid Chisnall    {
18707a984708SDavid Chisnall        _ForwardIterator __i = __first;
18717a984708SDavid Chisnall        while (++__i != __last)
18727a984708SDavid Chisnall        {
18737a984708SDavid Chisnall            if (!(*__i == __value_))
18747a984708SDavid Chisnall            {
18757a984708SDavid Chisnall                *__first = _VSTD::move(*__i);
18767a984708SDavid Chisnall                ++__first;
18777a984708SDavid Chisnall            }
18787a984708SDavid Chisnall        }
18797a984708SDavid Chisnall    }
18807a984708SDavid Chisnall    return __first;
18817a984708SDavid Chisnall}
18827a984708SDavid Chisnall
18837a984708SDavid Chisnall// remove_if
18847a984708SDavid Chisnall
18857a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Predicate>
18867a984708SDavid Chisnall_ForwardIterator
18877a984708SDavid Chisnallremove_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
18887a984708SDavid Chisnall{
18897a984708SDavid Chisnall    __first = _VSTD::find_if<_ForwardIterator, typename add_lvalue_reference<_Predicate>::type>
18907a984708SDavid Chisnall                           (__first, __last, __pred);
18917a984708SDavid Chisnall    if (__first != __last)
18927a984708SDavid Chisnall    {
18937a984708SDavid Chisnall        _ForwardIterator __i = __first;
18947a984708SDavid Chisnall        while (++__i != __last)
18957a984708SDavid Chisnall        {
18967a984708SDavid Chisnall            if (!__pred(*__i))
18977a984708SDavid Chisnall            {
18987a984708SDavid Chisnall                *__first = _VSTD::move(*__i);
18997a984708SDavid Chisnall                ++__first;
19007a984708SDavid Chisnall            }
19017a984708SDavid Chisnall        }
19027a984708SDavid Chisnall    }
19037a984708SDavid Chisnall    return __first;
19047a984708SDavid Chisnall}
19057a984708SDavid Chisnall
19067a984708SDavid Chisnall// remove_copy
19077a984708SDavid Chisnall
19087a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator, class _Tp>
19097a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
19107a984708SDavid Chisnall_OutputIterator
19117a984708SDavid Chisnallremove_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, const _Tp& __value_)
19127a984708SDavid Chisnall{
19137a984708SDavid Chisnall    for (; __first != __last; ++__first)
19147a984708SDavid Chisnall    {
19157a984708SDavid Chisnall        if (!(*__first == __value_))
19167a984708SDavid Chisnall        {
19177a984708SDavid Chisnall            *__result = *__first;
19187a984708SDavid Chisnall            ++__result;
19197a984708SDavid Chisnall        }
19207a984708SDavid Chisnall    }
19217a984708SDavid Chisnall    return __result;
19227a984708SDavid Chisnall}
19237a984708SDavid Chisnall
19247a984708SDavid Chisnall// remove_copy_if
19257a984708SDavid Chisnall
19267a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator, class _Predicate>
19277a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
19287a984708SDavid Chisnall_OutputIterator
19297a984708SDavid Chisnallremove_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred)
19307a984708SDavid Chisnall{
19317a984708SDavid Chisnall    for (; __first != __last; ++__first)
19327a984708SDavid Chisnall    {
19337a984708SDavid Chisnall        if (!__pred(*__first))
19347a984708SDavid Chisnall        {
19357a984708SDavid Chisnall            *__result = *__first;
19367a984708SDavid Chisnall            ++__result;
19377a984708SDavid Chisnall        }
19387a984708SDavid Chisnall    }
19397a984708SDavid Chisnall    return __result;
19407a984708SDavid Chisnall}
19417a984708SDavid Chisnall
19427a984708SDavid Chisnall// unique
19437a984708SDavid Chisnall
19447a984708SDavid Chisnalltemplate <class _ForwardIterator, class _BinaryPredicate>
19457a984708SDavid Chisnall_ForwardIterator
19467a984708SDavid Chisnallunique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred)
19477a984708SDavid Chisnall{
19487a984708SDavid Chisnall    __first = _VSTD::adjacent_find<_ForwardIterator, typename add_lvalue_reference<_BinaryPredicate>::type>
19497a984708SDavid Chisnall                                 (__first, __last, __pred);
19507a984708SDavid Chisnall    if (__first != __last)
19517a984708SDavid Chisnall    {
19527a984708SDavid Chisnall        // ...  a  a  ?  ...
19537a984708SDavid Chisnall        //      f     i
19547a984708SDavid Chisnall        _ForwardIterator __i = __first;
19557a984708SDavid Chisnall        for (++__i; ++__i != __last;)
19567a984708SDavid Chisnall            if (!__pred(*__first, *__i))
19577a984708SDavid Chisnall                *++__first = _VSTD::move(*__i);
19587a984708SDavid Chisnall        ++__first;
19597a984708SDavid Chisnall    }
19607a984708SDavid Chisnall    return __first;
19617a984708SDavid Chisnall}
19627a984708SDavid Chisnall
19637a984708SDavid Chisnalltemplate <class _ForwardIterator>
19647a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
19657a984708SDavid Chisnall_ForwardIterator
19667a984708SDavid Chisnallunique(_ForwardIterator __first, _ForwardIterator __last)
19677a984708SDavid Chisnall{
19687a984708SDavid Chisnall    typedef typename iterator_traits<_ForwardIterator>::value_type __v;
19697a984708SDavid Chisnall    return _VSTD::unique(__first, __last, __equal_to<__v>());
19707a984708SDavid Chisnall}
19717a984708SDavid Chisnall
19727a984708SDavid Chisnall// unique_copy
19737a984708SDavid Chisnall
19747a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _InputIterator, class _OutputIterator>
19757a984708SDavid Chisnall_OutputIterator
19767a984708SDavid Chisnall__unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __pred,
19777a984708SDavid Chisnall              input_iterator_tag, output_iterator_tag)
19787a984708SDavid Chisnall{
19797a984708SDavid Chisnall    if (__first != __last)
19807a984708SDavid Chisnall    {
19817a984708SDavid Chisnall        typename iterator_traits<_InputIterator>::value_type __t(*__first);
19827a984708SDavid Chisnall        *__result = __t;
19837a984708SDavid Chisnall        ++__result;
19847a984708SDavid Chisnall        while (++__first != __last)
19857a984708SDavid Chisnall        {
19867a984708SDavid Chisnall            if (!__pred(__t, *__first))
19877a984708SDavid Chisnall            {
19887a984708SDavid Chisnall                __t = *__first;
19897a984708SDavid Chisnall                *__result = __t;
19907a984708SDavid Chisnall                ++__result;
19917a984708SDavid Chisnall            }
19927a984708SDavid Chisnall        }
19937a984708SDavid Chisnall    }
19947a984708SDavid Chisnall    return __result;
19957a984708SDavid Chisnall}
19967a984708SDavid Chisnall
19977a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _ForwardIterator, class _OutputIterator>
19987a984708SDavid Chisnall_OutputIterator
19997a984708SDavid Chisnall__unique_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _BinaryPredicate __pred,
20007a984708SDavid Chisnall              forward_iterator_tag, output_iterator_tag)
20017a984708SDavid Chisnall{
20027a984708SDavid Chisnall    if (__first != __last)
20037a984708SDavid Chisnall    {
20047a984708SDavid Chisnall        _ForwardIterator __i = __first;
20057a984708SDavid Chisnall        *__result = *__i;
20067a984708SDavid Chisnall        ++__result;
20077a984708SDavid Chisnall        while (++__first != __last)
20087a984708SDavid Chisnall        {
20097a984708SDavid Chisnall            if (!__pred(*__i, *__first))
20107a984708SDavid Chisnall            {
20117a984708SDavid Chisnall                *__result = *__first;
20127a984708SDavid Chisnall                ++__result;
20137a984708SDavid Chisnall                __i = __first;
20147a984708SDavid Chisnall            }
20157a984708SDavid Chisnall        }
20167a984708SDavid Chisnall    }
20177a984708SDavid Chisnall    return __result;
20187a984708SDavid Chisnall}
20197a984708SDavid Chisnall
20207a984708SDavid Chisnalltemplate <class _BinaryPredicate, class _InputIterator, class _ForwardIterator>
20217a984708SDavid Chisnall_ForwardIterator
20227a984708SDavid Chisnall__unique_copy(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _BinaryPredicate __pred,
20237a984708SDavid Chisnall              input_iterator_tag, forward_iterator_tag)
20247a984708SDavid Chisnall{
20257a984708SDavid Chisnall    if (__first != __last)
20267a984708SDavid Chisnall    {
20277a984708SDavid Chisnall        *__result = *__first;
20287a984708SDavid Chisnall        while (++__first != __last)
20297a984708SDavid Chisnall            if (!__pred(*__result, *__first))
20307a984708SDavid Chisnall                *++__result = *__first;
20317a984708SDavid Chisnall        ++__result;
20327a984708SDavid Chisnall    }
20337a984708SDavid Chisnall    return __result;
20347a984708SDavid Chisnall}
20357a984708SDavid Chisnall
20367a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator, class _BinaryPredicate>
20377a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
20387a984708SDavid Chisnall_OutputIterator
20397a984708SDavid Chisnallunique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __pred)
20407a984708SDavid Chisnall{
20417a984708SDavid Chisnall    return _VSTD::__unique_copy<typename add_lvalue_reference<_BinaryPredicate>::type>
20427a984708SDavid Chisnall                              (__first, __last, __result, __pred,
20437a984708SDavid Chisnall                               typename iterator_traits<_InputIterator>::iterator_category(),
20447a984708SDavid Chisnall                               typename iterator_traits<_OutputIterator>::iterator_category());
20457a984708SDavid Chisnall}
20467a984708SDavid Chisnall
20477a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator>
20487a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
20497a984708SDavid Chisnall_OutputIterator
20507a984708SDavid Chisnallunique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
20517a984708SDavid Chisnall{
20527a984708SDavid Chisnall    typedef typename iterator_traits<_InputIterator>::value_type __v;
20537a984708SDavid Chisnall    return _VSTD::unique_copy(__first, __last, __result, __equal_to<__v>());
20547a984708SDavid Chisnall}
20557a984708SDavid Chisnall
20567a984708SDavid Chisnall// reverse
20577a984708SDavid Chisnall
20587a984708SDavid Chisnalltemplate <class _BidirectionalIterator>
20597a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
20607a984708SDavid Chisnallvoid
20617a984708SDavid Chisnall__reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, bidirectional_iterator_tag)
20627a984708SDavid Chisnall{
20637a984708SDavid Chisnall    while (__first != __last)
20647a984708SDavid Chisnall    {
20657a984708SDavid Chisnall        if (__first == --__last)
20667a984708SDavid Chisnall            break;
20677a984708SDavid Chisnall        swap(*__first, *__last);
20687a984708SDavid Chisnall        ++__first;
20697a984708SDavid Chisnall    }
20707a984708SDavid Chisnall}
20717a984708SDavid Chisnall
20727a984708SDavid Chisnalltemplate <class _RandomAccessIterator>
20737a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
20747a984708SDavid Chisnallvoid
20757a984708SDavid Chisnall__reverse(_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag)
20767a984708SDavid Chisnall{
20777a984708SDavid Chisnall    if (__first != __last)
20787a984708SDavid Chisnall        for (; __first < --__last; ++__first)
20797a984708SDavid Chisnall            swap(*__first, *__last);
20807a984708SDavid Chisnall}
20817a984708SDavid Chisnall
20827a984708SDavid Chisnalltemplate <class _BidirectionalIterator>
20837a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
20847a984708SDavid Chisnallvoid
20857a984708SDavid Chisnallreverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
20867a984708SDavid Chisnall{
20877a984708SDavid Chisnall    _VSTD::__reverse(__first, __last, typename iterator_traits<_BidirectionalIterator>::iterator_category());
20887a984708SDavid Chisnall}
20897a984708SDavid Chisnall
20907a984708SDavid Chisnall// reverse_copy
20917a984708SDavid Chisnall
20927a984708SDavid Chisnalltemplate <class _BidirectionalIterator, class _OutputIterator>
20937a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
20947a984708SDavid Chisnall_OutputIterator
20957a984708SDavid Chisnallreverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result)
20967a984708SDavid Chisnall{
20977a984708SDavid Chisnall    for (; __first != __last; ++__result)
20987a984708SDavid Chisnall        *__result = *--__last;
20997a984708SDavid Chisnall    return __result;
21007a984708SDavid Chisnall}
21017a984708SDavid Chisnall
21027a984708SDavid Chisnall// rotate
21037a984708SDavid Chisnall
21047a984708SDavid Chisnalltemplate <class _ForwardIterator>
21057a984708SDavid Chisnall_ForwardIterator
2106936e9439SDimitry Andric__rotate_left(_ForwardIterator __first, _ForwardIterator __last)
21077a984708SDavid Chisnall{
2108936e9439SDimitry Andric    typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
2109936e9439SDimitry Andric    value_type __tmp = _VSTD::move(*__first);
2110936e9439SDimitry Andric    _ForwardIterator __lm1 = _VSTD::move(_VSTD::next(__first), __last, __first);
2111936e9439SDimitry Andric    *__lm1 = _VSTD::move(__tmp);
2112936e9439SDimitry Andric    return __lm1;
2113936e9439SDimitry Andric}
2114936e9439SDimitry Andric
2115936e9439SDimitry Andrictemplate <class _BidirectionalIterator>
2116936e9439SDimitry Andric_BidirectionalIterator
2117936e9439SDimitry Andric__rotate_right(_BidirectionalIterator __first, _BidirectionalIterator __last)
2118936e9439SDimitry Andric{
2119936e9439SDimitry Andric    typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
2120936e9439SDimitry Andric    _BidirectionalIterator __lm1 = _VSTD::prev(__last);
2121936e9439SDimitry Andric    value_type __tmp = _VSTD::move(*__lm1);
2122936e9439SDimitry Andric    _BidirectionalIterator __fp1 = _VSTD::move_backward(__first, __lm1, __last);
2123936e9439SDimitry Andric    *__first = _VSTD::move(__tmp);
2124936e9439SDimitry Andric    return __fp1;
2125936e9439SDimitry Andric}
2126936e9439SDimitry Andric
2127936e9439SDimitry Andrictemplate <class _ForwardIterator>
2128936e9439SDimitry Andric_ForwardIterator
2129936e9439SDimitry Andric__rotate_forward(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last)
2130936e9439SDimitry Andric{
21317a984708SDavid Chisnall    _ForwardIterator __i = __middle;
21327a984708SDavid Chisnall    while (true)
21337a984708SDavid Chisnall    {
21347a984708SDavid Chisnall        swap(*__first, *__i);
21357a984708SDavid Chisnall        ++__first;
21367a984708SDavid Chisnall        if (++__i == __last)
21377a984708SDavid Chisnall            break;
21387a984708SDavid Chisnall        if (__first == __middle)
21397a984708SDavid Chisnall            __middle = __i;
21407a984708SDavid Chisnall    }
21417a984708SDavid Chisnall    _ForwardIterator __r = __first;
21427a984708SDavid Chisnall    if (__first != __middle)
21437a984708SDavid Chisnall    {
21447a984708SDavid Chisnall        __i = __middle;
21457a984708SDavid Chisnall        while (true)
21467a984708SDavid Chisnall        {
21477a984708SDavid Chisnall            swap(*__first, *__i);
21487a984708SDavid Chisnall            ++__first;
21497a984708SDavid Chisnall            if (++__i == __last)
21507a984708SDavid Chisnall            {
21517a984708SDavid Chisnall                if (__first == __middle)
21527a984708SDavid Chisnall                    break;
21537a984708SDavid Chisnall                __i = __middle;
21547a984708SDavid Chisnall            }
21557a984708SDavid Chisnall            else if (__first == __middle)
21567a984708SDavid Chisnall                __middle = __i;
21577a984708SDavid Chisnall        }
21587a984708SDavid Chisnall    }
21597a984708SDavid Chisnall    return __r;
21607a984708SDavid Chisnall}
21617a984708SDavid Chisnall
21627a984708SDavid Chisnalltemplate<typename _Integral>
21637a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
21647a984708SDavid Chisnall_Integral
21657a984708SDavid Chisnall__gcd(_Integral __x, _Integral __y)
21667a984708SDavid Chisnall{
21677a984708SDavid Chisnall    do
21687a984708SDavid Chisnall    {
21697a984708SDavid Chisnall        _Integral __t = __x % __y;
21707a984708SDavid Chisnall        __x = __y;
21717a984708SDavid Chisnall        __y = __t;
21727a984708SDavid Chisnall    } while (__y);
21737a984708SDavid Chisnall    return __x;
21747a984708SDavid Chisnall}
21757a984708SDavid Chisnall
21767a984708SDavid Chisnalltemplate<typename _RandomAccessIterator>
21777a984708SDavid Chisnall_RandomAccessIterator
2178936e9439SDimitry Andric__rotate_gcd(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last)
21797a984708SDavid Chisnall{
21807a984708SDavid Chisnall    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
21817a984708SDavid Chisnall    typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
21827a984708SDavid Chisnall
21837a984708SDavid Chisnall    const difference_type __m1 = __middle - __first;
21847a984708SDavid Chisnall    const difference_type __m2 = __last - __middle;
21857a984708SDavid Chisnall    if (__m1 == __m2)
21867a984708SDavid Chisnall    {
21877a984708SDavid Chisnall        _VSTD::swap_ranges(__first, __middle, __middle);
21887a984708SDavid Chisnall        return __middle;
21897a984708SDavid Chisnall    }
2190936e9439SDimitry Andric    const difference_type __g = _VSTD::__gcd(__m1, __m2);
21917a984708SDavid Chisnall    for (_RandomAccessIterator __p = __first + __g; __p != __first;)
21927a984708SDavid Chisnall    {
2193936e9439SDimitry Andric        value_type __t(_VSTD::move(*--__p));
21947a984708SDavid Chisnall        _RandomAccessIterator __p1 = __p;
21957a984708SDavid Chisnall        _RandomAccessIterator __p2 = __p1 + __m1;
21967a984708SDavid Chisnall        do
21977a984708SDavid Chisnall        {
2198936e9439SDimitry Andric            *__p1 = _VSTD::move(*__p2);
21997a984708SDavid Chisnall            __p1 = __p2;
22007a984708SDavid Chisnall            const difference_type __d = __last - __p2;
22017a984708SDavid Chisnall            if (__m1 < __d)
22027a984708SDavid Chisnall                __p2 += __m1;
22037a984708SDavid Chisnall            else
22047a984708SDavid Chisnall                __p2 = __first + (__m1 - __d);
22057a984708SDavid Chisnall        } while (__p2 != __p);
2206936e9439SDimitry Andric        *__p1 = _VSTD::move(__t);
22077a984708SDavid Chisnall    }
22087a984708SDavid Chisnall    return __first + __m2;
22097a984708SDavid Chisnall}
22107a984708SDavid Chisnall
22117a984708SDavid Chisnalltemplate <class _ForwardIterator>
22127a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
22137a984708SDavid Chisnall_ForwardIterator
2214936e9439SDimitry Andric__rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
2215936e9439SDimitry Andric         _VSTD::forward_iterator_tag)
2216936e9439SDimitry Andric{
2217936e9439SDimitry Andric    typedef typename _VSTD::iterator_traits<_ForwardIterator>::value_type value_type;
2218936e9439SDimitry Andric    if (_VSTD::is_trivially_move_assignable<value_type>::value)
2219936e9439SDimitry Andric    {
2220936e9439SDimitry Andric        if (_VSTD::next(__first) == __middle)
2221936e9439SDimitry Andric            return _VSTD::__rotate_left(__first, __last);
2222936e9439SDimitry Andric    }
2223936e9439SDimitry Andric    return _VSTD::__rotate_forward(__first, __middle, __last);
2224936e9439SDimitry Andric}
2225936e9439SDimitry Andric
2226936e9439SDimitry Andrictemplate <class _BidirectionalIterator>
2227936e9439SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY
2228936e9439SDimitry Andric_BidirectionalIterator
2229936e9439SDimitry Andric__rotate(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
2230936e9439SDimitry Andric         _VSTD::bidirectional_iterator_tag)
2231936e9439SDimitry Andric{
2232936e9439SDimitry Andric    typedef typename _VSTD::iterator_traits<_BidirectionalIterator>::value_type value_type;
2233936e9439SDimitry Andric    if (_VSTD::is_trivially_move_assignable<value_type>::value)
2234936e9439SDimitry Andric    {
2235936e9439SDimitry Andric        if (_VSTD::next(__first) == __middle)
2236936e9439SDimitry Andric            return _VSTD::__rotate_left(__first, __last);
2237936e9439SDimitry Andric        if (_VSTD::next(__middle) == __last)
2238936e9439SDimitry Andric            return _VSTD::__rotate_right(__first, __last);
2239936e9439SDimitry Andric    }
2240936e9439SDimitry Andric    return _VSTD::__rotate_forward(__first, __middle, __last);
2241936e9439SDimitry Andric}
2242936e9439SDimitry Andric
2243936e9439SDimitry Andrictemplate <class _RandomAccessIterator>
2244936e9439SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY
2245936e9439SDimitry Andric_RandomAccessIterator
2246936e9439SDimitry Andric__rotate(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last,
2247936e9439SDimitry Andric         _VSTD::random_access_iterator_tag)
2248936e9439SDimitry Andric{
2249936e9439SDimitry Andric    typedef typename _VSTD::iterator_traits<_RandomAccessIterator>::value_type value_type;
2250936e9439SDimitry Andric    if (_VSTD::is_trivially_move_assignable<value_type>::value)
2251936e9439SDimitry Andric    {
2252936e9439SDimitry Andric        if (_VSTD::next(__first) == __middle)
2253936e9439SDimitry Andric            return _VSTD::__rotate_left(__first, __last);
2254936e9439SDimitry Andric        if (_VSTD::next(__middle) == __last)
2255936e9439SDimitry Andric            return _VSTD::__rotate_right(__first, __last);
2256936e9439SDimitry Andric        return _VSTD::__rotate_gcd(__first, __middle, __last);
2257936e9439SDimitry Andric    }
2258936e9439SDimitry Andric    return _VSTD::__rotate_forward(__first, __middle, __last);
2259936e9439SDimitry Andric}
2260936e9439SDimitry Andric
2261936e9439SDimitry Andrictemplate <class _ForwardIterator>
2262936e9439SDimitry Andricinline _LIBCPP_INLINE_VISIBILITY
2263936e9439SDimitry Andric_ForwardIterator
22647a984708SDavid Chisnallrotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last)
22657a984708SDavid Chisnall{
2266936e9439SDimitry Andric    if (__first == __middle)
2267936e9439SDimitry Andric        return __last;
2268936e9439SDimitry Andric    if (__middle == __last)
2269936e9439SDimitry Andric        return __first;
22707a984708SDavid Chisnall    return _VSTD::__rotate(__first, __middle, __last,
2271936e9439SDimitry Andric                           typename _VSTD::iterator_traits<_ForwardIterator>::iterator_category());
22727a984708SDavid Chisnall}
22737a984708SDavid Chisnall
22747a984708SDavid Chisnall// rotate_copy
22757a984708SDavid Chisnall
22767a984708SDavid Chisnalltemplate <class _ForwardIterator, class _OutputIterator>
22777a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
22787a984708SDavid Chisnall_OutputIterator
22797a984708SDavid Chisnallrotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, _OutputIterator __result)
22807a984708SDavid Chisnall{
22817a984708SDavid Chisnall    return _VSTD::copy(__first, __middle, _VSTD::copy(__middle, __last, __result));
22827a984708SDavid Chisnall}
22837a984708SDavid Chisnall
22847a984708SDavid Chisnall// min_element
22857a984708SDavid Chisnall
22867a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Compare>
22877a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
22887a984708SDavid Chisnall_ForwardIterator
22897a984708SDavid Chisnallmin_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
22907a984708SDavid Chisnall{
22917a984708SDavid Chisnall    if (__first != __last)
22927a984708SDavid Chisnall    {
22937a984708SDavid Chisnall        _ForwardIterator __i = __first;
22947a984708SDavid Chisnall        while (++__i != __last)
22957a984708SDavid Chisnall            if (__comp(*__i, *__first))
22967a984708SDavid Chisnall                __first = __i;
22977a984708SDavid Chisnall    }
22987a984708SDavid Chisnall    return __first;
22997a984708SDavid Chisnall}
23007a984708SDavid Chisnall
23017a984708SDavid Chisnalltemplate <class _ForwardIterator>
23027a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
23037a984708SDavid Chisnall_ForwardIterator
23047a984708SDavid Chisnallmin_element(_ForwardIterator __first, _ForwardIterator __last)
23057a984708SDavid Chisnall{
23067a984708SDavid Chisnall    return _VSTD::min_element(__first, __last,
23077a984708SDavid Chisnall              __less<typename iterator_traits<_ForwardIterator>::value_type>());
23087a984708SDavid Chisnall}
23097a984708SDavid Chisnall
23107a984708SDavid Chisnall// min
23117a984708SDavid Chisnall
23127a984708SDavid Chisnalltemplate <class _Tp, class _Compare>
23137a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
23147a984708SDavid Chisnallconst _Tp&
23157a984708SDavid Chisnallmin(const _Tp& __a, const _Tp& __b, _Compare __comp)
23167a984708SDavid Chisnall{
23177a984708SDavid Chisnall    return __comp(__b, __a) ? __b : __a;
23187a984708SDavid Chisnall}
23197a984708SDavid Chisnall
23207a984708SDavid Chisnalltemplate <class _Tp>
23217a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
23227a984708SDavid Chisnallconst _Tp&
23237a984708SDavid Chisnallmin(const _Tp& __a, const _Tp& __b)
23247a984708SDavid Chisnall{
23257a984708SDavid Chisnall    return _VSTD::min(__a, __b, __less<_Tp>());
23267a984708SDavid Chisnall}
23277a984708SDavid Chisnall
23287a984708SDavid Chisnall#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
23297a984708SDavid Chisnall
23307a984708SDavid Chisnalltemplate<class _Tp, class _Compare>
23317a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
23327a984708SDavid Chisnall_Tp
23337a984708SDavid Chisnallmin(initializer_list<_Tp> __t, _Compare __comp)
23347a984708SDavid Chisnall{
23357a984708SDavid Chisnall    return *_VSTD::min_element(__t.begin(), __t.end(), __comp);
23367a984708SDavid Chisnall}
23377a984708SDavid Chisnall
23387a984708SDavid Chisnalltemplate<class _Tp>
23397a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
23407a984708SDavid Chisnall_Tp
23417a984708SDavid Chisnallmin(initializer_list<_Tp> __t)
23427a984708SDavid Chisnall{
23437a984708SDavid Chisnall    return *_VSTD::min_element(__t.begin(), __t.end());
23447a984708SDavid Chisnall}
23457a984708SDavid Chisnall
23467a984708SDavid Chisnall#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
23477a984708SDavid Chisnall
23487a984708SDavid Chisnall// max_element
23497a984708SDavid Chisnall
23507a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Compare>
23517a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
23527a984708SDavid Chisnall_ForwardIterator
23537a984708SDavid Chisnallmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
23547a984708SDavid Chisnall{
23557a984708SDavid Chisnall    if (__first != __last)
23567a984708SDavid Chisnall    {
23577a984708SDavid Chisnall        _ForwardIterator __i = __first;
23587a984708SDavid Chisnall        while (++__i != __last)
23597a984708SDavid Chisnall            if (__comp(*__first, *__i))
23607a984708SDavid Chisnall                __first = __i;
23617a984708SDavid Chisnall    }
23627a984708SDavid Chisnall    return __first;
23637a984708SDavid Chisnall}
23647a984708SDavid Chisnall
23657a984708SDavid Chisnalltemplate <class _ForwardIterator>
23667a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
23677a984708SDavid Chisnall_ForwardIterator
23687a984708SDavid Chisnallmax_element(_ForwardIterator __first, _ForwardIterator __last)
23697a984708SDavid Chisnall{
23707a984708SDavid Chisnall    return _VSTD::max_element(__first, __last,
23717a984708SDavid Chisnall              __less<typename iterator_traits<_ForwardIterator>::value_type>());
23727a984708SDavid Chisnall}
23737a984708SDavid Chisnall
23747a984708SDavid Chisnall// max
23757a984708SDavid Chisnall
23767a984708SDavid Chisnalltemplate <class _Tp, class _Compare>
23777a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
23787a984708SDavid Chisnallconst _Tp&
23797a984708SDavid Chisnallmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
23807a984708SDavid Chisnall{
23817a984708SDavid Chisnall    return __comp(__a, __b) ? __b : __a;
23827a984708SDavid Chisnall}
23837a984708SDavid Chisnall
23847a984708SDavid Chisnalltemplate <class _Tp>
23857a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
23867a984708SDavid Chisnallconst _Tp&
23877a984708SDavid Chisnallmax(const _Tp& __a, const _Tp& __b)
23887a984708SDavid Chisnall{
23897a984708SDavid Chisnall    return _VSTD::max(__a, __b, __less<_Tp>());
23907a984708SDavid Chisnall}
23917a984708SDavid Chisnall
23927a984708SDavid Chisnall#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
23937a984708SDavid Chisnall
23947a984708SDavid Chisnalltemplate<class _Tp, class _Compare>
23957a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
23967a984708SDavid Chisnall_Tp
23977a984708SDavid Chisnallmax(initializer_list<_Tp> __t, _Compare __comp)
23987a984708SDavid Chisnall{
23997a984708SDavid Chisnall    return *_VSTD::max_element(__t.begin(), __t.end(), __comp);
24007a984708SDavid Chisnall}
24017a984708SDavid Chisnall
24027a984708SDavid Chisnalltemplate<class _Tp>
24037a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
24047a984708SDavid Chisnall_Tp
24057a984708SDavid Chisnallmax(initializer_list<_Tp> __t)
24067a984708SDavid Chisnall{
24077a984708SDavid Chisnall    return *_VSTD::max_element(__t.begin(), __t.end());
24087a984708SDavid Chisnall}
24097a984708SDavid Chisnall
24107a984708SDavid Chisnall#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
24117a984708SDavid Chisnall
24127a984708SDavid Chisnall// minmax_element
24137a984708SDavid Chisnall
24147a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Compare>
24157a984708SDavid Chisnallstd::pair<_ForwardIterator, _ForwardIterator>
24167a984708SDavid Chisnallminmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
24177a984708SDavid Chisnall{
24187a984708SDavid Chisnall  std::pair<_ForwardIterator, _ForwardIterator> __result(__first, __first);
24197a984708SDavid Chisnall  if (__first != __last)
24207a984708SDavid Chisnall  {
24217a984708SDavid Chisnall      if (++__first != __last)
24227a984708SDavid Chisnall      {
24237a984708SDavid Chisnall          if (__comp(*__first, *__result.first))
24247a984708SDavid Chisnall              __result.first = __first;
24257a984708SDavid Chisnall          else
24267a984708SDavid Chisnall              __result.second = __first;
24277a984708SDavid Chisnall          while (++__first != __last)
24287a984708SDavid Chisnall          {
24297a984708SDavid Chisnall              _ForwardIterator __i = __first;
24307a984708SDavid Chisnall              if (++__first == __last)
24317a984708SDavid Chisnall              {
24327a984708SDavid Chisnall                  if (__comp(*__i, *__result.first))
24337a984708SDavid Chisnall                      __result.first = __i;
24347a984708SDavid Chisnall                  else if (!__comp(*__i, *__result.second))
24357a984708SDavid Chisnall                      __result.second = __i;
24367a984708SDavid Chisnall                  break;
24377a984708SDavid Chisnall              }
24387a984708SDavid Chisnall              else
24397a984708SDavid Chisnall              {
24407a984708SDavid Chisnall                  if (__comp(*__first, *__i))
24417a984708SDavid Chisnall                  {
24427a984708SDavid Chisnall                      if (__comp(*__first, *__result.first))
24437a984708SDavid Chisnall                          __result.first = __first;
24447a984708SDavid Chisnall                      if (!__comp(*__i, *__result.second))
24457a984708SDavid Chisnall                          __result.second = __i;
24467a984708SDavid Chisnall                  }
24477a984708SDavid Chisnall                  else
24487a984708SDavid Chisnall                  {
24497a984708SDavid Chisnall                      if (__comp(*__i, *__result.first))
24507a984708SDavid Chisnall                          __result.first = __i;
24517a984708SDavid Chisnall                      if (!__comp(*__first, *__result.second))
24527a984708SDavid Chisnall                          __result.second = __first;
24537a984708SDavid Chisnall                  }
24547a984708SDavid Chisnall              }
24557a984708SDavid Chisnall          }
24567a984708SDavid Chisnall      }
24577a984708SDavid Chisnall  }
24587a984708SDavid Chisnall  return __result;
24597a984708SDavid Chisnall}
24607a984708SDavid Chisnall
24617a984708SDavid Chisnalltemplate <class _ForwardIterator>
24627a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
24637a984708SDavid Chisnallstd::pair<_ForwardIterator, _ForwardIterator>
24647a984708SDavid Chisnallminmax_element(_ForwardIterator __first, _ForwardIterator __last)
24657a984708SDavid Chisnall{
24667a984708SDavid Chisnall    return _VSTD::minmax_element(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
24677a984708SDavid Chisnall}
24687a984708SDavid Chisnall
24697a984708SDavid Chisnall// minmax
24707a984708SDavid Chisnall
24717a984708SDavid Chisnalltemplate<class _Tp, class _Compare>
24727a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
24737a984708SDavid Chisnallpair<const _Tp&, const _Tp&>
24747a984708SDavid Chisnallminmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
24757a984708SDavid Chisnall{
24767a984708SDavid Chisnall    return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a) :
24777a984708SDavid Chisnall                              pair<const _Tp&, const _Tp&>(__a, __b);
24787a984708SDavid Chisnall}
24797a984708SDavid Chisnall
24807a984708SDavid Chisnalltemplate<class _Tp>
24817a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
24827a984708SDavid Chisnallpair<const _Tp&, const _Tp&>
24837a984708SDavid Chisnallminmax(const _Tp& __a, const _Tp& __b)
24847a984708SDavid Chisnall{
24857a984708SDavid Chisnall    return _VSTD::minmax(__a, __b, __less<_Tp>());
24867a984708SDavid Chisnall}
24877a984708SDavid Chisnall
24887a984708SDavid Chisnall#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
24897a984708SDavid Chisnall
24907a984708SDavid Chisnalltemplate<class _Tp>
24917a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
24927a984708SDavid Chisnallpair<_Tp, _Tp>
24937a984708SDavid Chisnallminmax(initializer_list<_Tp> __t)
24947a984708SDavid Chisnall{
24957a984708SDavid Chisnall    pair<const _Tp*, const _Tp*> __p =
24967a984708SDavid Chisnall                                   _VSTD::minmax_element(__t.begin(), __t.end());
24977a984708SDavid Chisnall    return pair<_Tp, _Tp>(*__p.first, *__p.second);
24987a984708SDavid Chisnall}
24997a984708SDavid Chisnall
25007a984708SDavid Chisnalltemplate<class _Tp, class _Compare>
25017a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
25027a984708SDavid Chisnallpair<_Tp, _Tp>
25037a984708SDavid Chisnallminmax(initializer_list<_Tp> __t, _Compare __comp)
25047a984708SDavid Chisnall{
25057a984708SDavid Chisnall    pair<const _Tp*, const _Tp*> __p =
25067a984708SDavid Chisnall                           _VSTD::minmax_element(__t.begin(), __t.end(), __comp);
25077a984708SDavid Chisnall    return pair<_Tp, _Tp>(*__p.first, *__p.second);
25087a984708SDavid Chisnall}
25097a984708SDavid Chisnall
25107a984708SDavid Chisnall#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
25117a984708SDavid Chisnall
25127a984708SDavid Chisnall// random_shuffle
25137a984708SDavid Chisnall
25147a984708SDavid Chisnall// __independent_bits_engine
25157a984708SDavid Chisnall
251694e3ee44SDavid Chisnalltemplate <unsigned long long _Xp, size_t _Rp>
25177a984708SDavid Chisnallstruct __log2_imp
25187a984708SDavid Chisnall{
251994e3ee44SDavid Chisnall    static const size_t value = _Xp & ((unsigned long long)(1) << _Rp) ? _Rp
252094e3ee44SDavid Chisnall                                           : __log2_imp<_Xp, _Rp - 1>::value;
25217a984708SDavid Chisnall};
25227a984708SDavid Chisnall
252394e3ee44SDavid Chisnalltemplate <unsigned long long _Xp>
252494e3ee44SDavid Chisnallstruct __log2_imp<_Xp, 0>
25257a984708SDavid Chisnall{
25267a984708SDavid Chisnall    static const size_t value = 0;
25277a984708SDavid Chisnall};
25287a984708SDavid Chisnall
252994e3ee44SDavid Chisnalltemplate <size_t _Rp>
253094e3ee44SDavid Chisnallstruct __log2_imp<0, _Rp>
25317a984708SDavid Chisnall{
253294e3ee44SDavid Chisnall    static const size_t value = _Rp + 1;
25337a984708SDavid Chisnall};
25347a984708SDavid Chisnall
253594e3ee44SDavid Chisnalltemplate <class _UI, _UI _Xp>
25367a984708SDavid Chisnallstruct __log2
25377a984708SDavid Chisnall{
253894e3ee44SDavid Chisnall    static const size_t value = __log2_imp<_Xp,
25397a984708SDavid Chisnall                                         sizeof(_UI) * __CHAR_BIT__ - 1>::value;
25407a984708SDavid Chisnall};
25417a984708SDavid Chisnall
25427a984708SDavid Chisnalltemplate<class _Engine, class _UIntType>
25437a984708SDavid Chisnallclass __independent_bits_engine
25447a984708SDavid Chisnall{
25457a984708SDavid Chisnallpublic:
25467a984708SDavid Chisnall    // types
25477a984708SDavid Chisnall    typedef _UIntType result_type;
25487a984708SDavid Chisnall
25497a984708SDavid Chisnallprivate:
25507a984708SDavid Chisnall    typedef typename _Engine::result_type _Engine_result_type;
25517a984708SDavid Chisnall    typedef typename conditional
25527a984708SDavid Chisnall        <
25537a984708SDavid Chisnall            sizeof(_Engine_result_type) <= sizeof(result_type),
25547a984708SDavid Chisnall                result_type,
25557a984708SDavid Chisnall                _Engine_result_type
25567a984708SDavid Chisnall        >::type _Working_result_type;
25577a984708SDavid Chisnall
25587a984708SDavid Chisnall    _Engine& __e_;
25597a984708SDavid Chisnall    size_t __w_;
25607a984708SDavid Chisnall    size_t __w0_;
25617a984708SDavid Chisnall    size_t __n_;
25627a984708SDavid Chisnall    size_t __n0_;
25637a984708SDavid Chisnall    _Working_result_type __y0_;
25647a984708SDavid Chisnall    _Working_result_type __y1_;
25657a984708SDavid Chisnall    _Engine_result_type __mask0_;
25667a984708SDavid Chisnall    _Engine_result_type __mask1_;
25677a984708SDavid Chisnall
2568b03f91a8SDavid Chisnall#ifdef _LIBCPP_HAS_NO_CONSTEXPR
256994e3ee44SDavid Chisnall    static const _Working_result_type _Rp = _Engine::_Max - _Engine::_Min
25707a984708SDavid Chisnall                                          + _Working_result_type(1);
2571b03f91a8SDavid Chisnall#else
2572b03f91a8SDavid Chisnall    static _LIBCPP_CONSTEXPR const _Working_result_type _Rp = _Engine::max() - _Engine::min()
2573b03f91a8SDavid Chisnall                                                      + _Working_result_type(1);
2574b03f91a8SDavid Chisnall#endif
2575b03f91a8SDavid Chisnall    static _LIBCPP_CONSTEXPR const size_t __m = __log2<_Working_result_type, _Rp>::value;
2576b03f91a8SDavid Chisnall    static _LIBCPP_CONSTEXPR const size_t _WDt = numeric_limits<_Working_result_type>::digits;
2577b03f91a8SDavid Chisnall    static _LIBCPP_CONSTEXPR const size_t _EDt = numeric_limits<_Engine_result_type>::digits;
25787a984708SDavid Chisnall
25797a984708SDavid Chisnallpublic:
25807a984708SDavid Chisnall    // constructors and seeding functions
25817a984708SDavid Chisnall    __independent_bits_engine(_Engine& __e, size_t __w);
25827a984708SDavid Chisnall
25837a984708SDavid Chisnall    // generating functions
258494e3ee44SDavid Chisnall    result_type operator()() {return __eval(integral_constant<bool, _Rp != 0>());}
25857a984708SDavid Chisnall
25867a984708SDavid Chisnallprivate:
25877a984708SDavid Chisnall    result_type __eval(false_type);
25887a984708SDavid Chisnall    result_type __eval(true_type);
25897a984708SDavid Chisnall};
25907a984708SDavid Chisnall
25917a984708SDavid Chisnalltemplate<class _Engine, class _UIntType>
25927a984708SDavid Chisnall__independent_bits_engine<_Engine, _UIntType>
25937a984708SDavid Chisnall    ::__independent_bits_engine(_Engine& __e, size_t __w)
25947a984708SDavid Chisnall        : __e_(__e),
25957a984708SDavid Chisnall          __w_(__w)
25967a984708SDavid Chisnall{
25977a984708SDavid Chisnall    __n_ = __w_ / __m + (__w_ % __m != 0);
25987a984708SDavid Chisnall    __w0_ = __w_ / __n_;
259994e3ee44SDavid Chisnall    if (_Rp == 0)
260094e3ee44SDavid Chisnall        __y0_ = _Rp;
26017a984708SDavid Chisnall    else if (__w0_ < _WDt)
260294e3ee44SDavid Chisnall        __y0_ = (_Rp >> __w0_) << __w0_;
26037a984708SDavid Chisnall    else
26047a984708SDavid Chisnall        __y0_ = 0;
260594e3ee44SDavid Chisnall    if (_Rp - __y0_ > __y0_ / __n_)
26067a984708SDavid Chisnall    {
26077a984708SDavid Chisnall        ++__n_;
26087a984708SDavid Chisnall        __w0_ = __w_ / __n_;
26097a984708SDavid Chisnall        if (__w0_ < _WDt)
261094e3ee44SDavid Chisnall            __y0_ = (_Rp >> __w0_) << __w0_;
26117a984708SDavid Chisnall        else
26127a984708SDavid Chisnall            __y0_ = 0;
26137a984708SDavid Chisnall    }
26147a984708SDavid Chisnall    __n0_ = __n_ - __w_ % __n_;
26157a984708SDavid Chisnall    if (__w0_ < _WDt - 1)
261694e3ee44SDavid Chisnall        __y1_ = (_Rp >> (__w0_ + 1)) << (__w0_ + 1);
26177a984708SDavid Chisnall    else
26187a984708SDavid Chisnall        __y1_ = 0;
26197a984708SDavid Chisnall    __mask0_ = __w0_ > 0 ? _Engine_result_type(~0) >> (_EDt - __w0_) :
26207a984708SDavid Chisnall                          _Engine_result_type(0);
26217a984708SDavid Chisnall    __mask1_ = __w0_ < _EDt - 1 ?
26227a984708SDavid Chisnall                               _Engine_result_type(~0) >> (_EDt - (__w0_ + 1)) :
26237a984708SDavid Chisnall                               _Engine_result_type(~0);
26247a984708SDavid Chisnall}
26257a984708SDavid Chisnall
26267a984708SDavid Chisnalltemplate<class _Engine, class _UIntType>
26277a984708SDavid Chisnallinline
26287a984708SDavid Chisnall_UIntType
26297a984708SDavid Chisnall__independent_bits_engine<_Engine, _UIntType>::__eval(false_type)
26307a984708SDavid Chisnall{
26317a984708SDavid Chisnall    return static_cast<result_type>(__e_() & __mask0_);
26327a984708SDavid Chisnall}
26337a984708SDavid Chisnall
26347a984708SDavid Chisnalltemplate<class _Engine, class _UIntType>
26357a984708SDavid Chisnall_UIntType
26367a984708SDavid Chisnall__independent_bits_engine<_Engine, _UIntType>::__eval(true_type)
26377a984708SDavid Chisnall{
263894e3ee44SDavid Chisnall    result_type _Sp = 0;
26397a984708SDavid Chisnall    for (size_t __k = 0; __k < __n0_; ++__k)
26407a984708SDavid Chisnall    {
26417a984708SDavid Chisnall        _Engine_result_type __u;
26427a984708SDavid Chisnall        do
26437a984708SDavid Chisnall        {
26447a984708SDavid Chisnall            __u = __e_() - _Engine::min();
26457a984708SDavid Chisnall        } while (__u >= __y0_);
26467a984708SDavid Chisnall        if (__w0_ < _WDt)
264794e3ee44SDavid Chisnall            _Sp <<= __w0_;
26487a984708SDavid Chisnall        else
264994e3ee44SDavid Chisnall            _Sp = 0;
265094e3ee44SDavid Chisnall        _Sp += __u & __mask0_;
26517a984708SDavid Chisnall    }
26527a984708SDavid Chisnall    for (size_t __k = __n0_; __k < __n_; ++__k)
26537a984708SDavid Chisnall    {
26547a984708SDavid Chisnall        _Engine_result_type __u;
26557a984708SDavid Chisnall        do
26567a984708SDavid Chisnall        {
26577a984708SDavid Chisnall            __u = __e_() - _Engine::min();
26587a984708SDavid Chisnall        } while (__u >= __y1_);
26597a984708SDavid Chisnall        if (__w0_ < _WDt - 1)
266094e3ee44SDavid Chisnall            _Sp <<= __w0_ + 1;
26617a984708SDavid Chisnall        else
266294e3ee44SDavid Chisnall            _Sp = 0;
266394e3ee44SDavid Chisnall        _Sp += __u & __mask1_;
26647a984708SDavid Chisnall    }
266594e3ee44SDavid Chisnall    return _Sp;
26667a984708SDavid Chisnall}
26677a984708SDavid Chisnall
26687a984708SDavid Chisnall// uniform_int_distribution
26697a984708SDavid Chisnall
26707a984708SDavid Chisnalltemplate<class _IntType = int>
26717a984708SDavid Chisnallclass uniform_int_distribution
26727a984708SDavid Chisnall{
26737a984708SDavid Chisnallpublic:
26747a984708SDavid Chisnall    // types
26757a984708SDavid Chisnall    typedef _IntType result_type;
26767a984708SDavid Chisnall
26777a984708SDavid Chisnall    class param_type
26787a984708SDavid Chisnall    {
26797a984708SDavid Chisnall        result_type __a_;
26807a984708SDavid Chisnall        result_type __b_;
26817a984708SDavid Chisnall    public:
26827a984708SDavid Chisnall        typedef uniform_int_distribution distribution_type;
26837a984708SDavid Chisnall
26847a984708SDavid Chisnall        explicit param_type(result_type __a = 0,
26857a984708SDavid Chisnall                            result_type __b = numeric_limits<result_type>::max())
26867a984708SDavid Chisnall            : __a_(__a), __b_(__b) {}
26877a984708SDavid Chisnall
26887a984708SDavid Chisnall        result_type a() const {return __a_;}
26897a984708SDavid Chisnall        result_type b() const {return __b_;}
26907a984708SDavid Chisnall
26917a984708SDavid Chisnall        friend bool operator==(const param_type& __x, const param_type& __y)
26927a984708SDavid Chisnall            {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
26937a984708SDavid Chisnall        friend bool operator!=(const param_type& __x, const param_type& __y)
26947a984708SDavid Chisnall            {return !(__x == __y);}
26957a984708SDavid Chisnall    };
26967a984708SDavid Chisnall
26977a984708SDavid Chisnallprivate:
26987a984708SDavid Chisnall    param_type __p_;
26997a984708SDavid Chisnall
27007a984708SDavid Chisnallpublic:
27017a984708SDavid Chisnall    // constructors and reset functions
27027a984708SDavid Chisnall    explicit uniform_int_distribution(result_type __a = 0,
27037a984708SDavid Chisnall                                      result_type __b = numeric_limits<result_type>::max())
27047a984708SDavid Chisnall        : __p_(param_type(__a, __b)) {}
27057a984708SDavid Chisnall    explicit uniform_int_distribution(const param_type& __p) : __p_(__p) {}
27067a984708SDavid Chisnall    void reset() {}
27077a984708SDavid Chisnall
27087a984708SDavid Chisnall    // generating functions
27097a984708SDavid Chisnall    template<class _URNG> result_type operator()(_URNG& __g)
27107a984708SDavid Chisnall        {return (*this)(__g, __p_);}
27117a984708SDavid Chisnall    template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
27127a984708SDavid Chisnall
27137a984708SDavid Chisnall    // property functions
27147a984708SDavid Chisnall    result_type a() const {return __p_.a();}
27157a984708SDavid Chisnall    result_type b() const {return __p_.b();}
27167a984708SDavid Chisnall
27177a984708SDavid Chisnall    param_type param() const {return __p_;}
27187a984708SDavid Chisnall    void param(const param_type& __p) {__p_ = __p;}
27197a984708SDavid Chisnall
27207a984708SDavid Chisnall    result_type min() const {return a();}
27217a984708SDavid Chisnall    result_type max() const {return b();}
27227a984708SDavid Chisnall
27237a984708SDavid Chisnall    friend bool operator==(const uniform_int_distribution& __x,
27247a984708SDavid Chisnall                           const uniform_int_distribution& __y)
27257a984708SDavid Chisnall        {return __x.__p_ == __y.__p_;}
27267a984708SDavid Chisnall    friend bool operator!=(const uniform_int_distribution& __x,
27277a984708SDavid Chisnall                           const uniform_int_distribution& __y)
27287a984708SDavid Chisnall            {return !(__x == __y);}
27297a984708SDavid Chisnall};
27307a984708SDavid Chisnall
27317a984708SDavid Chisnalltemplate<class _IntType>
27327a984708SDavid Chisnalltemplate<class _URNG>
27337a984708SDavid Chisnalltypename uniform_int_distribution<_IntType>::result_type
27347a984708SDavid Chisnalluniform_int_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p)
27357a984708SDavid Chisnall{
27367a984708SDavid Chisnall    typedef typename conditional<sizeof(result_type) <= sizeof(uint32_t),
27377a984708SDavid Chisnall                                            uint32_t, uint64_t>::type _UIntType;
273894e3ee44SDavid Chisnall    const _UIntType _Rp = __p.b() - __p.a() + _UIntType(1);
273994e3ee44SDavid Chisnall    if (_Rp == 1)
27407a984708SDavid Chisnall        return __p.a();
27417a984708SDavid Chisnall    const size_t _Dt = numeric_limits<_UIntType>::digits;
27427a984708SDavid Chisnall    typedef __independent_bits_engine<_URNG, _UIntType> _Eng;
274394e3ee44SDavid Chisnall    if (_Rp == 0)
27447a984708SDavid Chisnall        return static_cast<result_type>(_Eng(__g, _Dt)());
274594e3ee44SDavid Chisnall    size_t __w = _Dt - __clz(_Rp) - 1;
274694e3ee44SDavid Chisnall    if ((_Rp & (_UIntType(~0) >> (_Dt - __w))) != 0)
27477a984708SDavid Chisnall        ++__w;
27487a984708SDavid Chisnall    _Eng __e(__g, __w);
27497a984708SDavid Chisnall    _UIntType __u;
27507a984708SDavid Chisnall    do
27517a984708SDavid Chisnall    {
27527a984708SDavid Chisnall        __u = __e();
275394e3ee44SDavid Chisnall    } while (__u >= _Rp);
27547a984708SDavid Chisnall    return static_cast<result_type>(__u + __p.a());
27557a984708SDavid Chisnall}
27567a984708SDavid Chisnall
27577a984708SDavid Chisnallclass __rs_default;
27587a984708SDavid Chisnall
27597a984708SDavid Chisnall__rs_default __rs_get();
27607a984708SDavid Chisnall
27617a984708SDavid Chisnallclass __rs_default
27627a984708SDavid Chisnall{
27637a984708SDavid Chisnall    static unsigned __c_;
27647a984708SDavid Chisnall
27657a984708SDavid Chisnall    __rs_default();
27667a984708SDavid Chisnallpublic:
27677a984708SDavid Chisnall    typedef unsigned result_type;
27687a984708SDavid Chisnall
27697a984708SDavid Chisnall    static const result_type _Min = 0;
27707a984708SDavid Chisnall    static const result_type _Max = 0xFFFFFFFF;
27717a984708SDavid Chisnall
27727a984708SDavid Chisnall    __rs_default(const __rs_default&);
27737a984708SDavid Chisnall    ~__rs_default();
27747a984708SDavid Chisnall
27757a984708SDavid Chisnall    result_type operator()();
27767a984708SDavid Chisnall
2777b03f91a8SDavid Chisnall    static _LIBCPP_CONSTEXPR result_type min() {return _Min;}
2778b03f91a8SDavid Chisnall    static _LIBCPP_CONSTEXPR result_type max() {return _Max;}
27797a984708SDavid Chisnall
27807a984708SDavid Chisnall    friend __rs_default __rs_get();
27817a984708SDavid Chisnall};
27827a984708SDavid Chisnall
27837a984708SDavid Chisnall__rs_default __rs_get();
27847a984708SDavid Chisnall
27857a984708SDavid Chisnalltemplate <class _RandomAccessIterator>
27867a984708SDavid Chisnallvoid
27877a984708SDavid Chisnallrandom_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
27887a984708SDavid Chisnall{
27897a984708SDavid Chisnall    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
279094e3ee44SDavid Chisnall    typedef uniform_int_distribution<ptrdiff_t> _Dp;
279194e3ee44SDavid Chisnall    typedef typename _Dp::param_type _Pp;
27927a984708SDavid Chisnall    difference_type __d = __last - __first;
27937a984708SDavid Chisnall    if (__d > 1)
27947a984708SDavid Chisnall    {
279594e3ee44SDavid Chisnall        _Dp __uid;
27967a984708SDavid Chisnall        __rs_default __g = __rs_get();
27977a984708SDavid Chisnall        for (--__last, --__d; __first < __last; ++__first, --__d)
27987a984708SDavid Chisnall        {
279994e3ee44SDavid Chisnall            difference_type __i = __uid(__g, _Pp(0, __d));
28007a984708SDavid Chisnall            if (__i != difference_type(0))
28017a984708SDavid Chisnall                swap(*__first, *(__first + __i));
28027a984708SDavid Chisnall        }
28037a984708SDavid Chisnall    }
28047a984708SDavid Chisnall}
28057a984708SDavid Chisnall
28067a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _RandomNumberGenerator>
28077a984708SDavid Chisnallvoid
28087a984708SDavid Chisnallrandom_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
28097a984708SDavid Chisnall#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
28107a984708SDavid Chisnall               _RandomNumberGenerator&& __rand)
28117a984708SDavid Chisnall#else
28127a984708SDavid Chisnall               _RandomNumberGenerator& __rand)
28137a984708SDavid Chisnall#endif
28147a984708SDavid Chisnall{
28157a984708SDavid Chisnall    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
28167a984708SDavid Chisnall    difference_type __d = __last - __first;
28177a984708SDavid Chisnall    if (__d > 1)
28187a984708SDavid Chisnall    {
28197a984708SDavid Chisnall        for (--__last; __first < __last; ++__first, --__d)
28207a984708SDavid Chisnall        {
28217a984708SDavid Chisnall            difference_type __i = __rand(__d);
28227a984708SDavid Chisnall            swap(*__first, *(__first + __i));
28237a984708SDavid Chisnall        }
28247a984708SDavid Chisnall    }
28257a984708SDavid Chisnall}
28267a984708SDavid Chisnall
28277a984708SDavid Chisnalltemplate<class _RandomAccessIterator, class _UniformRandomNumberGenerator>
28287a984708SDavid Chisnall    void shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
28297a984708SDavid Chisnall#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
28307a984708SDavid Chisnall                 _UniformRandomNumberGenerator&& __g)
28317a984708SDavid Chisnall#else
28327a984708SDavid Chisnall                 _UniformRandomNumberGenerator& __g)
28337a984708SDavid Chisnall#endif
28347a984708SDavid Chisnall{
28357a984708SDavid Chisnall    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
283694e3ee44SDavid Chisnall    typedef uniform_int_distribution<ptrdiff_t> _Dp;
283794e3ee44SDavid Chisnall    typedef typename _Dp::param_type _Pp;
28387a984708SDavid Chisnall    difference_type __d = __last - __first;
28397a984708SDavid Chisnall    if (__d > 1)
28407a984708SDavid Chisnall    {
284194e3ee44SDavid Chisnall        _Dp __uid;
28427a984708SDavid Chisnall        for (--__last, --__d; __first < __last; ++__first, --__d)
28437a984708SDavid Chisnall        {
284494e3ee44SDavid Chisnall            difference_type __i = __uid(__g, _Pp(0, __d));
28457a984708SDavid Chisnall            if (__i != difference_type(0))
28467a984708SDavid Chisnall                swap(*__first, *(__first + __i));
28477a984708SDavid Chisnall        }
28487a984708SDavid Chisnall    }
28497a984708SDavid Chisnall}
28507a984708SDavid Chisnall
28517a984708SDavid Chisnalltemplate <class _InputIterator, class _Predicate>
28527a984708SDavid Chisnallbool
28537a984708SDavid Chisnallis_partitioned(_InputIterator __first, _InputIterator __last, _Predicate __pred)
28547a984708SDavid Chisnall{
28557a984708SDavid Chisnall    for (; __first != __last; ++__first)
28567a984708SDavid Chisnall        if (!__pred(*__first))
28577a984708SDavid Chisnall            break;
28587a984708SDavid Chisnall    for (; __first != __last; ++__first)
28597a984708SDavid Chisnall        if (__pred(*__first))
28607a984708SDavid Chisnall            return false;
28617a984708SDavid Chisnall    return true;
28627a984708SDavid Chisnall}
28637a984708SDavid Chisnall
28647a984708SDavid Chisnall// partition
28657a984708SDavid Chisnall
28667a984708SDavid Chisnalltemplate <class _Predicate, class _ForwardIterator>
28677a984708SDavid Chisnall_ForwardIterator
28687a984708SDavid Chisnall__partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, forward_iterator_tag)
28697a984708SDavid Chisnall{
28707a984708SDavid Chisnall    while (true)
28717a984708SDavid Chisnall    {
28727a984708SDavid Chisnall        if (__first == __last)
28737a984708SDavid Chisnall            return __first;
28747a984708SDavid Chisnall        if (!__pred(*__first))
28757a984708SDavid Chisnall            break;
28767a984708SDavid Chisnall        ++__first;
28777a984708SDavid Chisnall    }
28787a984708SDavid Chisnall    for (_ForwardIterator __p = __first; ++__p != __last;)
28797a984708SDavid Chisnall    {
28807a984708SDavid Chisnall        if (__pred(*__p))
28817a984708SDavid Chisnall        {
28827a984708SDavid Chisnall            swap(*__first, *__p);
28837a984708SDavid Chisnall            ++__first;
28847a984708SDavid Chisnall        }
28857a984708SDavid Chisnall    }
28867a984708SDavid Chisnall    return __first;
28877a984708SDavid Chisnall}
28887a984708SDavid Chisnall
28897a984708SDavid Chisnalltemplate <class _Predicate, class _BidirectionalIterator>
28907a984708SDavid Chisnall_BidirectionalIterator
28917a984708SDavid Chisnall__partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred,
28927a984708SDavid Chisnall            bidirectional_iterator_tag)
28937a984708SDavid Chisnall{
28947a984708SDavid Chisnall    while (true)
28957a984708SDavid Chisnall    {
28967a984708SDavid Chisnall        while (true)
28977a984708SDavid Chisnall        {
28987a984708SDavid Chisnall            if (__first == __last)
28997a984708SDavid Chisnall                return __first;
29007a984708SDavid Chisnall            if (!__pred(*__first))
29017a984708SDavid Chisnall                break;
29027a984708SDavid Chisnall            ++__first;
29037a984708SDavid Chisnall        }
29047a984708SDavid Chisnall        do
29057a984708SDavid Chisnall        {
29067a984708SDavid Chisnall            if (__first == --__last)
29077a984708SDavid Chisnall                return __first;
29087a984708SDavid Chisnall        } while (!__pred(*__last));
29097a984708SDavid Chisnall        swap(*__first, *__last);
29107a984708SDavid Chisnall        ++__first;
29117a984708SDavid Chisnall    }
29127a984708SDavid Chisnall}
29137a984708SDavid Chisnall
29147a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Predicate>
29157a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
29167a984708SDavid Chisnall_ForwardIterator
29177a984708SDavid Chisnallpartition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
29187a984708SDavid Chisnall{
29197a984708SDavid Chisnall    return _VSTD::__partition<typename add_lvalue_reference<_Predicate>::type>
29207a984708SDavid Chisnall                            (__first, __last, __pred, typename iterator_traits<_ForwardIterator>::iterator_category());
29217a984708SDavid Chisnall}
29227a984708SDavid Chisnall
29237a984708SDavid Chisnall// partition_copy
29247a984708SDavid Chisnall
29257a984708SDavid Chisnalltemplate <class _InputIterator, class _OutputIterator1,
29267a984708SDavid Chisnall          class _OutputIterator2, class _Predicate>
29277a984708SDavid Chisnallpair<_OutputIterator1, _OutputIterator2>
29287a984708SDavid Chisnallpartition_copy(_InputIterator __first, _InputIterator __last,
29297a984708SDavid Chisnall               _OutputIterator1 __out_true, _OutputIterator2 __out_false,
29307a984708SDavid Chisnall               _Predicate __pred)
29317a984708SDavid Chisnall{
29327a984708SDavid Chisnall    for (; __first != __last; ++__first)
29337a984708SDavid Chisnall    {
29347a984708SDavid Chisnall        if (__pred(*__first))
29357a984708SDavid Chisnall        {
29367a984708SDavid Chisnall            *__out_true = *__first;
29377a984708SDavid Chisnall            ++__out_true;
29387a984708SDavid Chisnall        }
29397a984708SDavid Chisnall        else
29407a984708SDavid Chisnall        {
29417a984708SDavid Chisnall            *__out_false = *__first;
29427a984708SDavid Chisnall            ++__out_false;
29437a984708SDavid Chisnall        }
29447a984708SDavid Chisnall    }
29457a984708SDavid Chisnall    return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
29467a984708SDavid Chisnall}
29477a984708SDavid Chisnall
29487a984708SDavid Chisnall// partition_point
29497a984708SDavid Chisnall
29507a984708SDavid Chisnalltemplate<class _ForwardIterator, class _Predicate>
29517a984708SDavid Chisnall_ForwardIterator
29527a984708SDavid Chisnallpartition_point(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
29537a984708SDavid Chisnall{
29547a984708SDavid Chisnall    typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
29557a984708SDavid Chisnall    difference_type __len = _VSTD::distance(__first, __last);
29567a984708SDavid Chisnall    while (__len != 0)
29577a984708SDavid Chisnall    {
29587a984708SDavid Chisnall        difference_type __l2 = __len / 2;
29597a984708SDavid Chisnall        _ForwardIterator __m = __first;
29607a984708SDavid Chisnall        _VSTD::advance(__m, __l2);
29617a984708SDavid Chisnall        if (__pred(*__m))
29627a984708SDavid Chisnall        {
29637a984708SDavid Chisnall            __first = ++__m;
29647a984708SDavid Chisnall            __len -= __l2 + 1;
29657a984708SDavid Chisnall        }
29667a984708SDavid Chisnall        else
29677a984708SDavid Chisnall            __len = __l2;
29687a984708SDavid Chisnall    }
29697a984708SDavid Chisnall    return __first;
29707a984708SDavid Chisnall}
29717a984708SDavid Chisnall
29727a984708SDavid Chisnall// stable_partition
29737a984708SDavid Chisnall
29747a984708SDavid Chisnalltemplate <class _Predicate, class _ForwardIterator, class _Distance, class _Pair>
29757a984708SDavid Chisnall_ForwardIterator
29767a984708SDavid Chisnall__stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
29777a984708SDavid Chisnall                   _Distance __len, _Pair __p, forward_iterator_tag __fit)
29787a984708SDavid Chisnall{
29797a984708SDavid Chisnall    // *__first is known to be false
29807a984708SDavid Chisnall    // __len >= 1
29817a984708SDavid Chisnall    if (__len == 1)
29827a984708SDavid Chisnall        return __first;
29837a984708SDavid Chisnall    if (__len == 2)
29847a984708SDavid Chisnall    {
29857a984708SDavid Chisnall        _ForwardIterator __m = __first;
29867a984708SDavid Chisnall        if (__pred(*++__m))
29877a984708SDavid Chisnall        {
29887a984708SDavid Chisnall            swap(*__first, *__m);
29897a984708SDavid Chisnall            return __m;
29907a984708SDavid Chisnall        }
29917a984708SDavid Chisnall        return __first;
29927a984708SDavid Chisnall    }
29937a984708SDavid Chisnall    if (__len <= __p.second)
29947a984708SDavid Chisnall    {   // The buffer is big enough to use
29957a984708SDavid Chisnall        typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
29967a984708SDavid Chisnall        __destruct_n __d(0);
29977a984708SDavid Chisnall        unique_ptr<value_type, __destruct_n&> __h(__p.first, __d);
29987a984708SDavid Chisnall        // Move the falses into the temporary buffer, and the trues to the front of the line
29997a984708SDavid Chisnall        // Update __first to always point to the end of the trues
30007a984708SDavid Chisnall        value_type* __t = __p.first;
30017a984708SDavid Chisnall        ::new(__t) value_type(_VSTD::move(*__first));
30027a984708SDavid Chisnall        __d.__incr((value_type*)0);
30037a984708SDavid Chisnall        ++__t;
30047a984708SDavid Chisnall        _ForwardIterator __i = __first;
30057a984708SDavid Chisnall        while (++__i != __last)
30067a984708SDavid Chisnall        {
30077a984708SDavid Chisnall            if (__pred(*__i))
30087a984708SDavid Chisnall            {
30097a984708SDavid Chisnall                *__first = _VSTD::move(*__i);
30107a984708SDavid Chisnall                ++__first;
30117a984708SDavid Chisnall            }
30127a984708SDavid Chisnall            else
30137a984708SDavid Chisnall            {
30147a984708SDavid Chisnall                ::new(__t) value_type(_VSTD::move(*__i));
30157a984708SDavid Chisnall                __d.__incr((value_type*)0);
30167a984708SDavid Chisnall                ++__t;
30177a984708SDavid Chisnall            }
30187a984708SDavid Chisnall        }
30197a984708SDavid Chisnall        // All trues now at start of range, all falses in buffer
30207a984708SDavid Chisnall        // Move falses back into range, but don't mess up __first which points to first false
30217a984708SDavid Chisnall        __i = __first;
30227a984708SDavid Chisnall        for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, ++__i)
30237a984708SDavid Chisnall            *__i = _VSTD::move(*__t2);
30247a984708SDavid Chisnall        // __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer
30257a984708SDavid Chisnall        return __first;
30267a984708SDavid Chisnall    }
30277a984708SDavid Chisnall    // Else not enough buffer, do in place
30287a984708SDavid Chisnall    // __len >= 3
30297a984708SDavid Chisnall    _ForwardIterator __m = __first;
30307a984708SDavid Chisnall    _Distance __len2 = __len / 2;  // __len2 >= 2
30317a984708SDavid Chisnall    _VSTD::advance(__m, __len2);
30327a984708SDavid Chisnall    // recurse on [__first, __m), *__first know to be false
30337a984708SDavid Chisnall    // F?????????????????
30347a984708SDavid Chisnall    // f       m         l
30357a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Predicate>::type _PredRef;
30367a984708SDavid Chisnall    _ForwardIterator __first_false = __stable_partition<_PredRef>(__first, __m, __pred, __len2, __p, __fit);
30377a984708SDavid Chisnall    // TTTFFFFF??????????
30387a984708SDavid Chisnall    // f  ff   m         l
30397a984708SDavid Chisnall    // recurse on [__m, __last], except increase __m until *(__m) is false, *__last know to be true
30407a984708SDavid Chisnall    _ForwardIterator __m1 = __m;
30417a984708SDavid Chisnall    _ForwardIterator __second_false = __last;
30427a984708SDavid Chisnall    _Distance __len_half = __len - __len2;
30437a984708SDavid Chisnall    while (__pred(*__m1))
30447a984708SDavid Chisnall    {
30457a984708SDavid Chisnall        if (++__m1 == __last)
30467a984708SDavid Chisnall            goto __second_half_done;
30477a984708SDavid Chisnall        --__len_half;
30487a984708SDavid Chisnall    }
30497a984708SDavid Chisnall    // TTTFFFFFTTTF??????
30507a984708SDavid Chisnall    // f  ff   m  m1     l
30517a984708SDavid Chisnall    __second_false = __stable_partition<_PredRef>(__m1, __last, __pred, __len_half, __p, __fit);
30527a984708SDavid Chisnall__second_half_done:
30537a984708SDavid Chisnall    // TTTFFFFFTTTTTFFFFF
30547a984708SDavid Chisnall    // f  ff   m    sf   l
30557a984708SDavid Chisnall    return _VSTD::rotate(__first_false, __m, __second_false);
30567a984708SDavid Chisnall    // TTTTTTTTFFFFFFFFFF
30577a984708SDavid Chisnall    //         |
30587a984708SDavid Chisnall}
30597a984708SDavid Chisnall
30607a984708SDavid Chisnallstruct __return_temporary_buffer
30617a984708SDavid Chisnall{
30627a984708SDavid Chisnall    template <class _Tp>
30637a984708SDavid Chisnall    _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) const {_VSTD::return_temporary_buffer(__p);}
30647a984708SDavid Chisnall};
30657a984708SDavid Chisnall
30667a984708SDavid Chisnalltemplate <class _Predicate, class _ForwardIterator>
30677a984708SDavid Chisnall_ForwardIterator
30687a984708SDavid Chisnall__stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
30697a984708SDavid Chisnall                   forward_iterator_tag)
30707a984708SDavid Chisnall{
30717a984708SDavid Chisnall    const unsigned __alloc_limit = 3;  // might want to make this a function of trivial assignment
30727a984708SDavid Chisnall    // Either prove all true and return __first or point to first false
30737a984708SDavid Chisnall    while (true)
30747a984708SDavid Chisnall    {
30757a984708SDavid Chisnall        if (__first == __last)
30767a984708SDavid Chisnall            return __first;
30777a984708SDavid Chisnall        if (!__pred(*__first))
30787a984708SDavid Chisnall            break;
30797a984708SDavid Chisnall        ++__first;
30807a984708SDavid Chisnall    }
30817a984708SDavid Chisnall    // We now have a reduced range [__first, __last)
30827a984708SDavid Chisnall    // *__first is known to be false
30837a984708SDavid Chisnall    typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
30847a984708SDavid Chisnall    typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
30857a984708SDavid Chisnall    difference_type __len = _VSTD::distance(__first, __last);
30867a984708SDavid Chisnall    pair<value_type*, ptrdiff_t> __p(0, 0);
30877a984708SDavid Chisnall    unique_ptr<value_type, __return_temporary_buffer> __h;
30887a984708SDavid Chisnall    if (__len >= __alloc_limit)
30897a984708SDavid Chisnall    {
30907a984708SDavid Chisnall        __p = _VSTD::get_temporary_buffer<value_type>(__len);
30917a984708SDavid Chisnall        __h.reset(__p.first);
30927a984708SDavid Chisnall    }
30937a984708SDavid Chisnall    return __stable_partition<typename add_lvalue_reference<_Predicate>::type>
30947a984708SDavid Chisnall                             (__first, __last, __pred, __len, __p, forward_iterator_tag());
30957a984708SDavid Chisnall}
30967a984708SDavid Chisnall
30977a984708SDavid Chisnalltemplate <class _Predicate, class _BidirectionalIterator, class _Distance, class _Pair>
30987a984708SDavid Chisnall_BidirectionalIterator
30997a984708SDavid Chisnall__stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred,
31007a984708SDavid Chisnall                   _Distance __len, _Pair __p, bidirectional_iterator_tag __bit)
31017a984708SDavid Chisnall{
31027a984708SDavid Chisnall    // *__first is known to be false
31037a984708SDavid Chisnall    // *__last is known to be true
31047a984708SDavid Chisnall    // __len >= 2
31057a984708SDavid Chisnall    if (__len == 2)
31067a984708SDavid Chisnall    {
31077a984708SDavid Chisnall        swap(*__first, *__last);
31087a984708SDavid Chisnall        return __last;
31097a984708SDavid Chisnall    }
31107a984708SDavid Chisnall    if (__len == 3)
31117a984708SDavid Chisnall    {
31127a984708SDavid Chisnall        _BidirectionalIterator __m = __first;
31137a984708SDavid Chisnall        if (__pred(*++__m))
31147a984708SDavid Chisnall        {
31157a984708SDavid Chisnall            swap(*__first, *__m);
31167a984708SDavid Chisnall            swap(*__m, *__last);
31177a984708SDavid Chisnall            return __last;
31187a984708SDavid Chisnall        }
31197a984708SDavid Chisnall        swap(*__m, *__last);
31207a984708SDavid Chisnall        swap(*__first, *__m);
31217a984708SDavid Chisnall        return __m;
31227a984708SDavid Chisnall    }
31237a984708SDavid Chisnall    if (__len <= __p.second)
31247a984708SDavid Chisnall    {   // The buffer is big enough to use
31257a984708SDavid Chisnall        typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
31267a984708SDavid Chisnall        __destruct_n __d(0);
31277a984708SDavid Chisnall        unique_ptr<value_type, __destruct_n&> __h(__p.first, __d);
31287a984708SDavid Chisnall        // Move the falses into the temporary buffer, and the trues to the front of the line
31297a984708SDavid Chisnall        // Update __first to always point to the end of the trues
31307a984708SDavid Chisnall        value_type* __t = __p.first;
31317a984708SDavid Chisnall        ::new(__t) value_type(_VSTD::move(*__first));
31327a984708SDavid Chisnall        __d.__incr((value_type*)0);
31337a984708SDavid Chisnall        ++__t;
31347a984708SDavid Chisnall        _BidirectionalIterator __i = __first;
31357a984708SDavid Chisnall        while (++__i != __last)
31367a984708SDavid Chisnall        {
31377a984708SDavid Chisnall            if (__pred(*__i))
31387a984708SDavid Chisnall            {
31397a984708SDavid Chisnall                *__first = _VSTD::move(*__i);
31407a984708SDavid Chisnall                ++__first;
31417a984708SDavid Chisnall            }
31427a984708SDavid Chisnall            else
31437a984708SDavid Chisnall            {
31447a984708SDavid Chisnall                ::new(__t) value_type(_VSTD::move(*__i));
31457a984708SDavid Chisnall                __d.__incr((value_type*)0);
31467a984708SDavid Chisnall                ++__t;
31477a984708SDavid Chisnall            }
31487a984708SDavid Chisnall        }
31497a984708SDavid Chisnall        // move *__last, known to be true
31507a984708SDavid Chisnall        *__first = _VSTD::move(*__i);
31517a984708SDavid Chisnall        __i = ++__first;
31527a984708SDavid Chisnall        // All trues now at start of range, all falses in buffer
31537a984708SDavid Chisnall        // Move falses back into range, but don't mess up __first which points to first false
31547a984708SDavid Chisnall        for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, ++__i)
31557a984708SDavid Chisnall            *__i = _VSTD::move(*__t2);
31567a984708SDavid Chisnall        // __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer
31577a984708SDavid Chisnall        return __first;
31587a984708SDavid Chisnall    }
31597a984708SDavid Chisnall    // Else not enough buffer, do in place
31607a984708SDavid Chisnall    // __len >= 4
31617a984708SDavid Chisnall    _BidirectionalIterator __m = __first;
31627a984708SDavid Chisnall    _Distance __len2 = __len / 2;  // __len2 >= 2
31637a984708SDavid Chisnall    _VSTD::advance(__m, __len2);
31647a984708SDavid Chisnall    // recurse on [__first, __m-1], except reduce __m-1 until *(__m-1) is true, *__first know to be false
31657a984708SDavid Chisnall    // F????????????????T
31667a984708SDavid Chisnall    // f       m        l
31677a984708SDavid Chisnall    _BidirectionalIterator __m1 = __m;
31687a984708SDavid Chisnall    _BidirectionalIterator __first_false = __first;
31697a984708SDavid Chisnall    _Distance __len_half = __len2;
31707a984708SDavid Chisnall    while (!__pred(*--__m1))
31717a984708SDavid Chisnall    {
31727a984708SDavid Chisnall        if (__m1 == __first)
31737a984708SDavid Chisnall            goto __first_half_done;
31747a984708SDavid Chisnall        --__len_half;
31757a984708SDavid Chisnall    }
31767a984708SDavid Chisnall    // F???TFFF?????????T
31777a984708SDavid Chisnall    // f   m1  m        l
31787a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Predicate>::type _PredRef;
31797a984708SDavid Chisnall    __first_false = __stable_partition<_PredRef>(__first, __m1, __pred, __len_half, __p, __bit);
31807a984708SDavid Chisnall__first_half_done:
31817a984708SDavid Chisnall    // TTTFFFFF?????????T
31827a984708SDavid Chisnall    // f  ff   m        l
31837a984708SDavid Chisnall    // recurse on [__m, __last], except increase __m until *(__m) is false, *__last know to be true
31847a984708SDavid Chisnall    __m1 = __m;
31857a984708SDavid Chisnall    _BidirectionalIterator __second_false = __last;
31867a984708SDavid Chisnall    ++__second_false;
31877a984708SDavid Chisnall    __len_half = __len - __len2;
31887a984708SDavid Chisnall    while (__pred(*__m1))
31897a984708SDavid Chisnall    {
31907a984708SDavid Chisnall        if (++__m1 == __last)
31917a984708SDavid Chisnall            goto __second_half_done;
31927a984708SDavid Chisnall        --__len_half;
31937a984708SDavid Chisnall    }
31947a984708SDavid Chisnall    // TTTFFFFFTTTF?????T
31957a984708SDavid Chisnall    // f  ff   m  m1    l
31967a984708SDavid Chisnall    __second_false = __stable_partition<_PredRef>(__m1, __last, __pred, __len_half, __p, __bit);
31977a984708SDavid Chisnall__second_half_done:
31987a984708SDavid Chisnall    // TTTFFFFFTTTTTFFFFF
31997a984708SDavid Chisnall    // f  ff   m    sf  l
32007a984708SDavid Chisnall    return _VSTD::rotate(__first_false, __m, __second_false);
32017a984708SDavid Chisnall    // TTTTTTTTFFFFFFFFFF
32027a984708SDavid Chisnall    //         |
32037a984708SDavid Chisnall}
32047a984708SDavid Chisnall
32057a984708SDavid Chisnalltemplate <class _Predicate, class _BidirectionalIterator>
32067a984708SDavid Chisnall_BidirectionalIterator
32077a984708SDavid Chisnall__stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred,
32087a984708SDavid Chisnall                   bidirectional_iterator_tag)
32097a984708SDavid Chisnall{
32107a984708SDavid Chisnall    typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
32117a984708SDavid Chisnall    typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
32127a984708SDavid Chisnall    const difference_type __alloc_limit = 4;  // might want to make this a function of trivial assignment
32137a984708SDavid Chisnall    // Either prove all true and return __first or point to first false
32147a984708SDavid Chisnall    while (true)
32157a984708SDavid Chisnall    {
32167a984708SDavid Chisnall        if (__first == __last)
32177a984708SDavid Chisnall            return __first;
32187a984708SDavid Chisnall        if (!__pred(*__first))
32197a984708SDavid Chisnall            break;
32207a984708SDavid Chisnall        ++__first;
32217a984708SDavid Chisnall    }
32227a984708SDavid Chisnall    // __first points to first false, everything prior to __first is already set.
32237a984708SDavid Chisnall    // Either prove [__first, __last) is all false and return __first, or point __last to last true
32247a984708SDavid Chisnall    do
32257a984708SDavid Chisnall    {
32267a984708SDavid Chisnall        if (__first == --__last)
32277a984708SDavid Chisnall            return __first;
32287a984708SDavid Chisnall    } while (!__pred(*__last));
32297a984708SDavid Chisnall    // We now have a reduced range [__first, __last]
32307a984708SDavid Chisnall    // *__first is known to be false
32317a984708SDavid Chisnall    // *__last is known to be true
32327a984708SDavid Chisnall    // __len >= 2
32337a984708SDavid Chisnall    difference_type __len = _VSTD::distance(__first, __last) + 1;
32347a984708SDavid Chisnall    pair<value_type*, ptrdiff_t> __p(0, 0);
32357a984708SDavid Chisnall    unique_ptr<value_type, __return_temporary_buffer> __h;
32367a984708SDavid Chisnall    if (__len >= __alloc_limit)
32377a984708SDavid Chisnall    {
32387a984708SDavid Chisnall        __p = _VSTD::get_temporary_buffer<value_type>(__len);
32397a984708SDavid Chisnall        __h.reset(__p.first);
32407a984708SDavid Chisnall    }
32417a984708SDavid Chisnall    return __stable_partition<typename add_lvalue_reference<_Predicate>::type>
32427a984708SDavid Chisnall                             (__first, __last, __pred, __len, __p, bidirectional_iterator_tag());
32437a984708SDavid Chisnall}
32447a984708SDavid Chisnall
32457a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Predicate>
32467a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
32477a984708SDavid Chisnall_ForwardIterator
32487a984708SDavid Chisnallstable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
32497a984708SDavid Chisnall{
32507a984708SDavid Chisnall    return __stable_partition<typename add_lvalue_reference<_Predicate>::type>
32517a984708SDavid Chisnall                             (__first, __last, __pred, typename iterator_traits<_ForwardIterator>::iterator_category());
32527a984708SDavid Chisnall}
32537a984708SDavid Chisnall
32547a984708SDavid Chisnall// is_sorted_until
32557a984708SDavid Chisnall
32567a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Compare>
32577a984708SDavid Chisnall_ForwardIterator
32587a984708SDavid Chisnallis_sorted_until(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
32597a984708SDavid Chisnall{
32607a984708SDavid Chisnall    if (__first != __last)
32617a984708SDavid Chisnall    {
32627a984708SDavid Chisnall        _ForwardIterator __i = __first;
32637a984708SDavid Chisnall        while (++__i != __last)
32647a984708SDavid Chisnall        {
32657a984708SDavid Chisnall            if (__comp(*__i, *__first))
32667a984708SDavid Chisnall                return __i;
32677a984708SDavid Chisnall            __first = __i;
32687a984708SDavid Chisnall        }
32697a984708SDavid Chisnall    }
32707a984708SDavid Chisnall    return __last;
32717a984708SDavid Chisnall}
32727a984708SDavid Chisnall
32737a984708SDavid Chisnalltemplate<class _ForwardIterator>
32747a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
32757a984708SDavid Chisnall_ForwardIterator
32767a984708SDavid Chisnallis_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
32777a984708SDavid Chisnall{
32787a984708SDavid Chisnall    return _VSTD::is_sorted_until(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
32797a984708SDavid Chisnall}
32807a984708SDavid Chisnall
32817a984708SDavid Chisnall// is_sorted
32827a984708SDavid Chisnall
32837a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Compare>
32847a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
32857a984708SDavid Chisnallbool
32867a984708SDavid Chisnallis_sorted(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
32877a984708SDavid Chisnall{
32887a984708SDavid Chisnall    return _VSTD::is_sorted_until(__first, __last, __comp) == __last;
32897a984708SDavid Chisnall}
32907a984708SDavid Chisnall
32917a984708SDavid Chisnalltemplate<class _ForwardIterator>
32927a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
32937a984708SDavid Chisnallbool
32947a984708SDavid Chisnallis_sorted(_ForwardIterator __first, _ForwardIterator __last)
32957a984708SDavid Chisnall{
32967a984708SDavid Chisnall    return _VSTD::is_sorted(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
32977a984708SDavid Chisnall}
32987a984708SDavid Chisnall
32997a984708SDavid Chisnall// sort
33007a984708SDavid Chisnall
33017a984708SDavid Chisnall// stable, 2-3 compares, 0-2 swaps
33027a984708SDavid Chisnall
33037a984708SDavid Chisnalltemplate <class _Compare, class _ForwardIterator>
33047a984708SDavid Chisnallunsigned
33057a984708SDavid Chisnall__sort3(_ForwardIterator __x, _ForwardIterator __y, _ForwardIterator __z, _Compare __c)
33067a984708SDavid Chisnall{
33077a984708SDavid Chisnall    unsigned __r = 0;
33087a984708SDavid Chisnall    if (!__c(*__y, *__x))          // if x <= y
33097a984708SDavid Chisnall    {
33107a984708SDavid Chisnall        if (!__c(*__z, *__y))      // if y <= z
33117a984708SDavid Chisnall            return __r;            // x <= y && y <= z
33127a984708SDavid Chisnall                                   // x <= y && y > z
33137a984708SDavid Chisnall        swap(*__y, *__z);          // x <= z && y < z
33147a984708SDavid Chisnall        __r = 1;
33157a984708SDavid Chisnall        if (__c(*__y, *__x))       // if x > y
33167a984708SDavid Chisnall        {
33177a984708SDavid Chisnall            swap(*__x, *__y);      // x < y && y <= z
33187a984708SDavid Chisnall            __r = 2;
33197a984708SDavid Chisnall        }
33207a984708SDavid Chisnall        return __r;                // x <= y && y < z
33217a984708SDavid Chisnall    }
33227a984708SDavid Chisnall    if (__c(*__z, *__y))           // x > y, if y > z
33237a984708SDavid Chisnall    {
33247a984708SDavid Chisnall        swap(*__x, *__z);          // x < y && y < z
33257a984708SDavid Chisnall        __r = 1;
33267a984708SDavid Chisnall        return __r;
33277a984708SDavid Chisnall    }
33287a984708SDavid Chisnall    swap(*__x, *__y);              // x > y && y <= z
33297a984708SDavid Chisnall    __r = 1;                       // x < y && x <= z
33307a984708SDavid Chisnall    if (__c(*__z, *__y))           // if y > z
33317a984708SDavid Chisnall    {
33327a984708SDavid Chisnall        swap(*__y, *__z);          // x <= y && y < z
33337a984708SDavid Chisnall        __r = 2;
33347a984708SDavid Chisnall    }
33357a984708SDavid Chisnall    return __r;
33367a984708SDavid Chisnall}                                  // x <= y && y <= z
33377a984708SDavid Chisnall
33387a984708SDavid Chisnall// stable, 3-6 compares, 0-5 swaps
33397a984708SDavid Chisnall
33407a984708SDavid Chisnalltemplate <class _Compare, class _ForwardIterator>
33417a984708SDavid Chisnallunsigned
33427a984708SDavid Chisnall__sort4(_ForwardIterator __x1, _ForwardIterator __x2, _ForwardIterator __x3,
33437a984708SDavid Chisnall            _ForwardIterator __x4, _Compare __c)
33447a984708SDavid Chisnall{
33457a984708SDavid Chisnall    unsigned __r = __sort3<_Compare>(__x1, __x2, __x3, __c);
33467a984708SDavid Chisnall    if (__c(*__x4, *__x3))
33477a984708SDavid Chisnall    {
33487a984708SDavid Chisnall        swap(*__x3, *__x4);
33497a984708SDavid Chisnall        ++__r;
33507a984708SDavid Chisnall        if (__c(*__x3, *__x2))
33517a984708SDavid Chisnall        {
33527a984708SDavid Chisnall            swap(*__x2, *__x3);
33537a984708SDavid Chisnall            ++__r;
33547a984708SDavid Chisnall            if (__c(*__x2, *__x1))
33557a984708SDavid Chisnall            {
33567a984708SDavid Chisnall                swap(*__x1, *__x2);
33577a984708SDavid Chisnall                ++__r;
33587a984708SDavid Chisnall            }
33597a984708SDavid Chisnall        }
33607a984708SDavid Chisnall    }
33617a984708SDavid Chisnall    return __r;
33627a984708SDavid Chisnall}
33637a984708SDavid Chisnall
33647a984708SDavid Chisnall// stable, 4-10 compares, 0-9 swaps
33657a984708SDavid Chisnall
33667a984708SDavid Chisnalltemplate <class _Compare, class _ForwardIterator>
33677a984708SDavid Chisnallunsigned
33687a984708SDavid Chisnall__sort5(_ForwardIterator __x1, _ForwardIterator __x2, _ForwardIterator __x3,
33697a984708SDavid Chisnall            _ForwardIterator __x4, _ForwardIterator __x5, _Compare __c)
33707a984708SDavid Chisnall{
33717a984708SDavid Chisnall    unsigned __r = __sort4<_Compare>(__x1, __x2, __x3, __x4, __c);
33727a984708SDavid Chisnall    if (__c(*__x5, *__x4))
33737a984708SDavid Chisnall    {
33747a984708SDavid Chisnall        swap(*__x4, *__x5);
33757a984708SDavid Chisnall        ++__r;
33767a984708SDavid Chisnall        if (__c(*__x4, *__x3))
33777a984708SDavid Chisnall        {
33787a984708SDavid Chisnall            swap(*__x3, *__x4);
33797a984708SDavid Chisnall            ++__r;
33807a984708SDavid Chisnall            if (__c(*__x3, *__x2))
33817a984708SDavid Chisnall            {
33827a984708SDavid Chisnall                swap(*__x2, *__x3);
33837a984708SDavid Chisnall                ++__r;
33847a984708SDavid Chisnall                if (__c(*__x2, *__x1))
33857a984708SDavid Chisnall                {
33867a984708SDavid Chisnall                    swap(*__x1, *__x2);
33877a984708SDavid Chisnall                    ++__r;
33887a984708SDavid Chisnall                }
33897a984708SDavid Chisnall            }
33907a984708SDavid Chisnall        }
33917a984708SDavid Chisnall    }
33927a984708SDavid Chisnall    return __r;
33937a984708SDavid Chisnall}
33947a984708SDavid Chisnall
33957a984708SDavid Chisnall// Assumes size > 0
33967a984708SDavid Chisnalltemplate <class _Compare, class _BirdirectionalIterator>
33977a984708SDavid Chisnallvoid
33987a984708SDavid Chisnall__selection_sort(_BirdirectionalIterator __first, _BirdirectionalIterator __last, _Compare __comp)
33997a984708SDavid Chisnall{
34007a984708SDavid Chisnall    _BirdirectionalIterator __lm1 = __last;
34017a984708SDavid Chisnall    for (--__lm1; __first != __lm1; ++__first)
34027a984708SDavid Chisnall    {
34037a984708SDavid Chisnall        _BirdirectionalIterator __i = _VSTD::min_element<_BirdirectionalIterator,
34047a984708SDavid Chisnall                                                        typename add_lvalue_reference<_Compare>::type>
34057a984708SDavid Chisnall                                                       (__first, __last, __comp);
34067a984708SDavid Chisnall        if (__i != __first)
34077a984708SDavid Chisnall            swap(*__first, *__i);
34087a984708SDavid Chisnall    }
34097a984708SDavid Chisnall}
34107a984708SDavid Chisnall
34117a984708SDavid Chisnalltemplate <class _Compare, class _BirdirectionalIterator>
34127a984708SDavid Chisnallvoid
34137a984708SDavid Chisnall__insertion_sort(_BirdirectionalIterator __first, _BirdirectionalIterator __last, _Compare __comp)
34147a984708SDavid Chisnall{
34157a984708SDavid Chisnall    typedef typename iterator_traits<_BirdirectionalIterator>::value_type value_type;
34167a984708SDavid Chisnall    if (__first != __last)
34177a984708SDavid Chisnall    {
34187a984708SDavid Chisnall        _BirdirectionalIterator __i = __first;
34197a984708SDavid Chisnall        for (++__i; __i != __last; ++__i)
34207a984708SDavid Chisnall        {
34217a984708SDavid Chisnall            _BirdirectionalIterator __j = __i;
34227a984708SDavid Chisnall            value_type __t(_VSTD::move(*__j));
34237a984708SDavid Chisnall            for (_BirdirectionalIterator __k = __i; __k != __first && __comp(__t,  *--__k); --__j)
34247a984708SDavid Chisnall                *__j = _VSTD::move(*__k);
34257a984708SDavid Chisnall            *__j = _VSTD::move(__t);
34267a984708SDavid Chisnall        }
34277a984708SDavid Chisnall    }
34287a984708SDavid Chisnall}
34297a984708SDavid Chisnall
34307a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator>
34317a984708SDavid Chisnallvoid
34327a984708SDavid Chisnall__insertion_sort_3(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
34337a984708SDavid Chisnall{
34347a984708SDavid Chisnall    typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
34357a984708SDavid Chisnall    _RandomAccessIterator __j = __first+2;
34367a984708SDavid Chisnall    __sort3<_Compare>(__first, __first+1, __j, __comp);
34377a984708SDavid Chisnall    for (_RandomAccessIterator __i = __j+1; __i != __last; ++__i)
34387a984708SDavid Chisnall    {
34397a984708SDavid Chisnall        if (__comp(*__i, *__j))
34407a984708SDavid Chisnall        {
34417a984708SDavid Chisnall            value_type __t(_VSTD::move(*__i));
34427a984708SDavid Chisnall            _RandomAccessIterator __k = __j;
34437a984708SDavid Chisnall            __j = __i;
34447a984708SDavid Chisnall            do
34457a984708SDavid Chisnall            {
34467a984708SDavid Chisnall                *__j = _VSTD::move(*__k);
34477a984708SDavid Chisnall                __j = __k;
34487a984708SDavid Chisnall            } while (__j != __first && __comp(__t, *--__k));
34497a984708SDavid Chisnall            *__j = _VSTD::move(__t);
34507a984708SDavid Chisnall        }
34517a984708SDavid Chisnall        __j = __i;
34527a984708SDavid Chisnall    }
34537a984708SDavid Chisnall}
34547a984708SDavid Chisnall
34557a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator>
34567a984708SDavid Chisnallbool
34577a984708SDavid Chisnall__insertion_sort_incomplete(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
34587a984708SDavid Chisnall{
34597a984708SDavid Chisnall    switch (__last - __first)
34607a984708SDavid Chisnall    {
34617a984708SDavid Chisnall    case 0:
34627a984708SDavid Chisnall    case 1:
34637a984708SDavid Chisnall        return true;
34647a984708SDavid Chisnall    case 2:
34657a984708SDavid Chisnall        if (__comp(*--__last, *__first))
34667a984708SDavid Chisnall            swap(*__first, *__last);
34677a984708SDavid Chisnall        return true;
34687a984708SDavid Chisnall    case 3:
34697a984708SDavid Chisnall        _VSTD::__sort3<_Compare>(__first, __first+1, --__last, __comp);
34707a984708SDavid Chisnall        return true;
34717a984708SDavid Chisnall    case 4:
34727a984708SDavid Chisnall        _VSTD::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp);
34737a984708SDavid Chisnall        return true;
34747a984708SDavid Chisnall    case 5:
34757a984708SDavid Chisnall        _VSTD::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp);
34767a984708SDavid Chisnall        return true;
34777a984708SDavid Chisnall    }
34787a984708SDavid Chisnall    typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
34797a984708SDavid Chisnall    _RandomAccessIterator __j = __first+2;
34807a984708SDavid Chisnall    __sort3<_Compare>(__first, __first+1, __j, __comp);
34817a984708SDavid Chisnall    const unsigned __limit = 8;
34827a984708SDavid Chisnall    unsigned __count = 0;
34837a984708SDavid Chisnall    for (_RandomAccessIterator __i = __j+1; __i != __last; ++__i)
34847a984708SDavid Chisnall    {
34857a984708SDavid Chisnall        if (__comp(*__i, *__j))
34867a984708SDavid Chisnall        {
34877a984708SDavid Chisnall            value_type __t(_VSTD::move(*__i));
34887a984708SDavid Chisnall            _RandomAccessIterator __k = __j;
34897a984708SDavid Chisnall            __j = __i;
34907a984708SDavid Chisnall            do
34917a984708SDavid Chisnall            {
34927a984708SDavid Chisnall                *__j = _VSTD::move(*__k);
34937a984708SDavid Chisnall                __j = __k;
34947a984708SDavid Chisnall            } while (__j != __first && __comp(__t, *--__k));
34957a984708SDavid Chisnall            *__j = _VSTD::move(__t);
34967a984708SDavid Chisnall            if (++__count == __limit)
34977a984708SDavid Chisnall                return ++__i == __last;
34987a984708SDavid Chisnall        }
34997a984708SDavid Chisnall        __j = __i;
35007a984708SDavid Chisnall    }
35017a984708SDavid Chisnall    return true;
35027a984708SDavid Chisnall}
35037a984708SDavid Chisnall
35047a984708SDavid Chisnalltemplate <class _Compare, class _BirdirectionalIterator>
35057a984708SDavid Chisnallvoid
35067a984708SDavid Chisnall__insertion_sort_move(_BirdirectionalIterator __first1, _BirdirectionalIterator __last1,
35077a984708SDavid Chisnall                      typename iterator_traits<_BirdirectionalIterator>::value_type* __first2, _Compare __comp)
35087a984708SDavid Chisnall{
35097a984708SDavid Chisnall    typedef typename iterator_traits<_BirdirectionalIterator>::value_type value_type;
35107a984708SDavid Chisnall    if (__first1 != __last1)
35117a984708SDavid Chisnall    {
35127a984708SDavid Chisnall        __destruct_n __d(0);
35137a984708SDavid Chisnall        unique_ptr<value_type, __destruct_n&> __h(__first2, __d);
35147a984708SDavid Chisnall        value_type* __last2 = __first2;
35157a984708SDavid Chisnall        ::new(__last2) value_type(_VSTD::move(*__first1));
35167a984708SDavid Chisnall        __d.__incr((value_type*)0);
35177a984708SDavid Chisnall        for (++__last2; ++__first1 != __last1; ++__last2)
35187a984708SDavid Chisnall        {
35197a984708SDavid Chisnall            value_type* __j2 = __last2;
35207a984708SDavid Chisnall            value_type* __i2 = __j2;
35217a984708SDavid Chisnall            if (__comp(*__first1, *--__i2))
35227a984708SDavid Chisnall            {
35237a984708SDavid Chisnall                ::new(__j2) value_type(_VSTD::move(*__i2));
35247a984708SDavid Chisnall                __d.__incr((value_type*)0);
35257a984708SDavid Chisnall                for (--__j2; __i2 != __first2 && __comp(*__first1,  *--__i2); --__j2)
35267a984708SDavid Chisnall                    *__j2 = _VSTD::move(*__i2);
35277a984708SDavid Chisnall                *__j2 = _VSTD::move(*__first1);
35287a984708SDavid Chisnall            }
35297a984708SDavid Chisnall            else
35307a984708SDavid Chisnall            {
35317a984708SDavid Chisnall                ::new(__j2) value_type(_VSTD::move(*__first1));
35327a984708SDavid Chisnall                __d.__incr((value_type*)0);
35337a984708SDavid Chisnall            }
35347a984708SDavid Chisnall        }
35357a984708SDavid Chisnall        __h.release();
35367a984708SDavid Chisnall    }
35377a984708SDavid Chisnall}
35387a984708SDavid Chisnall
35397a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator>
35407a984708SDavid Chisnallvoid
35417a984708SDavid Chisnall__sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
35427a984708SDavid Chisnall{
35437a984708SDavid Chisnall    // _Compare is known to be a reference type
35447a984708SDavid Chisnall    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
35457a984708SDavid Chisnall    typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
35467a984708SDavid Chisnall    const difference_type __limit = is_trivially_copy_constructible<value_type>::value &&
35477a984708SDavid Chisnall                                    is_trivially_copy_assignable<value_type>::value ? 30 : 6;
35487a984708SDavid Chisnall    while (true)
35497a984708SDavid Chisnall    {
35507a984708SDavid Chisnall    __restart:
35517a984708SDavid Chisnall        difference_type __len = __last - __first;
35527a984708SDavid Chisnall        switch (__len)
35537a984708SDavid Chisnall        {
35547a984708SDavid Chisnall        case 0:
35557a984708SDavid Chisnall        case 1:
35567a984708SDavid Chisnall            return;
35577a984708SDavid Chisnall        case 2:
35587a984708SDavid Chisnall            if (__comp(*--__last, *__first))
35597a984708SDavid Chisnall                swap(*__first, *__last);
35607a984708SDavid Chisnall            return;
35617a984708SDavid Chisnall        case 3:
35627a984708SDavid Chisnall            _VSTD::__sort3<_Compare>(__first, __first+1, --__last, __comp);
35637a984708SDavid Chisnall            return;
35647a984708SDavid Chisnall        case 4:
35657a984708SDavid Chisnall            _VSTD::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp);
35667a984708SDavid Chisnall            return;
35677a984708SDavid Chisnall        case 5:
35687a984708SDavid Chisnall            _VSTD::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp);
35697a984708SDavid Chisnall            return;
35707a984708SDavid Chisnall        }
35717a984708SDavid Chisnall        if (__len <= __limit)
35727a984708SDavid Chisnall        {
35737a984708SDavid Chisnall            _VSTD::__insertion_sort_3<_Compare>(__first, __last, __comp);
35747a984708SDavid Chisnall            return;
35757a984708SDavid Chisnall        }
35767a984708SDavid Chisnall        // __len > 5
35777a984708SDavid Chisnall        _RandomAccessIterator __m = __first;
35787a984708SDavid Chisnall        _RandomAccessIterator __lm1 = __last;
35797a984708SDavid Chisnall        --__lm1;
35807a984708SDavid Chisnall        unsigned __n_swaps;
35817a984708SDavid Chisnall        {
35827a984708SDavid Chisnall        difference_type __delta;
35837a984708SDavid Chisnall        if (__len >= 1000)
35847a984708SDavid Chisnall        {
35857a984708SDavid Chisnall            __delta = __len/2;
35867a984708SDavid Chisnall            __m += __delta;
35877a984708SDavid Chisnall            __delta /= 2;
35887a984708SDavid Chisnall            __n_swaps = _VSTD::__sort5<_Compare>(__first, __first + __delta, __m, __m+__delta, __lm1, __comp);
35897a984708SDavid Chisnall        }
35907a984708SDavid Chisnall        else
35917a984708SDavid Chisnall        {
35927a984708SDavid Chisnall            __delta = __len/2;
35937a984708SDavid Chisnall            __m += __delta;
35947a984708SDavid Chisnall            __n_swaps = _VSTD::__sort3<_Compare>(__first, __m, __lm1, __comp);
35957a984708SDavid Chisnall        }
35967a984708SDavid Chisnall        }
35977a984708SDavid Chisnall        // *__m is median
35987a984708SDavid Chisnall        // partition [__first, __m) < *__m and *__m <= [__m, __last)
35997a984708SDavid Chisnall        // (this inhibits tossing elements equivalent to __m around unnecessarily)
36007a984708SDavid Chisnall        _RandomAccessIterator __i = __first;
36017a984708SDavid Chisnall        _RandomAccessIterator __j = __lm1;
36027a984708SDavid Chisnall        // j points beyond range to be tested, *__m is known to be <= *__lm1
36037a984708SDavid Chisnall        // The search going up is known to be guarded but the search coming down isn't.
36047a984708SDavid Chisnall        // Prime the downward search with a guard.
36057a984708SDavid Chisnall        if (!__comp(*__i, *__m))  // if *__first == *__m
36067a984708SDavid Chisnall        {
36077a984708SDavid Chisnall            // *__first == *__m, *__first doesn't go in first part
36087a984708SDavid Chisnall            // manually guard downward moving __j against __i
36097a984708SDavid Chisnall            while (true)
36107a984708SDavid Chisnall            {
36117a984708SDavid Chisnall                if (__i == --__j)
36127a984708SDavid Chisnall                {
36137a984708SDavid Chisnall                    // *__first == *__m, *__m <= all other elements
36147a984708SDavid Chisnall                    // Parition instead into [__first, __i) == *__first and *__first < [__i, __last)
36157a984708SDavid Chisnall                    ++__i;  // __first + 1
36167a984708SDavid Chisnall                    __j = __last;
36177a984708SDavid Chisnall                    if (!__comp(*__first, *--__j))  // we need a guard if *__first == *(__last-1)
36187a984708SDavid Chisnall                    {
36197a984708SDavid Chisnall                        while (true)
36207a984708SDavid Chisnall                        {
36217a984708SDavid Chisnall                            if (__i == __j)
36227a984708SDavid Chisnall                                return;  // [__first, __last) all equivalent elements
36237a984708SDavid Chisnall                            if (__comp(*__first, *__i))
36247a984708SDavid Chisnall                            {
36257a984708SDavid Chisnall                                swap(*__i, *__j);
36267a984708SDavid Chisnall                                ++__n_swaps;
36277a984708SDavid Chisnall                                ++__i;
36287a984708SDavid Chisnall                                break;
36297a984708SDavid Chisnall                            }
36307a984708SDavid Chisnall                            ++__i;
36317a984708SDavid Chisnall                        }
36327a984708SDavid Chisnall                    }
36337a984708SDavid Chisnall                    // [__first, __i) == *__first and *__first < [__j, __last) and __j == __last - 1
36347a984708SDavid Chisnall                    if (__i == __j)
36357a984708SDavid Chisnall                        return;
36367a984708SDavid Chisnall                    while (true)
36377a984708SDavid Chisnall                    {
36387a984708SDavid Chisnall                        while (!__comp(*__first, *__i))
36397a984708SDavid Chisnall                            ++__i;
36407a984708SDavid Chisnall                        while (__comp(*__first, *--__j))
36417a984708SDavid Chisnall                            ;
36427a984708SDavid Chisnall                        if (__i >= __j)
36437a984708SDavid Chisnall                            break;
36447a984708SDavid Chisnall                        swap(*__i, *__j);
36457a984708SDavid Chisnall                        ++__n_swaps;
36467a984708SDavid Chisnall                        ++__i;
36477a984708SDavid Chisnall                    }
36487a984708SDavid Chisnall                    // [__first, __i) == *__first and *__first < [__i, __last)
36497a984708SDavid Chisnall                    // The first part is sorted, sort the secod part
36507a984708SDavid Chisnall                    // _VSTD::__sort<_Compare>(__i, __last, __comp);
36517a984708SDavid Chisnall                    __first = __i;
36527a984708SDavid Chisnall                    goto __restart;
36537a984708SDavid Chisnall                }
36547a984708SDavid Chisnall                if (__comp(*__j, *__m))
36557a984708SDavid Chisnall                {
36567a984708SDavid Chisnall                    swap(*__i, *__j);
36577a984708SDavid Chisnall                    ++__n_swaps;
36587a984708SDavid Chisnall                    break;  // found guard for downward moving __j, now use unguarded partition
36597a984708SDavid Chisnall                }
36607a984708SDavid Chisnall            }
36617a984708SDavid Chisnall        }
36627a984708SDavid Chisnall        // It is known that *__i < *__m
36637a984708SDavid Chisnall        ++__i;
36647a984708SDavid Chisnall        // j points beyond range to be tested, *__m is known to be <= *__lm1
36657a984708SDavid Chisnall        // if not yet partitioned...
36667a984708SDavid Chisnall        if (__i < __j)
36677a984708SDavid Chisnall        {
36687a984708SDavid Chisnall            // known that *(__i - 1) < *__m
36697a984708SDavid Chisnall            // known that __i <= __m
36707a984708SDavid Chisnall            while (true)
36717a984708SDavid Chisnall            {
36727a984708SDavid Chisnall                // __m still guards upward moving __i
36737a984708SDavid Chisnall                while (__comp(*__i, *__m))
36747a984708SDavid Chisnall                    ++__i;
36757a984708SDavid Chisnall                // It is now known that a guard exists for downward moving __j
36767a984708SDavid Chisnall                while (!__comp(*--__j, *__m))
36777a984708SDavid Chisnall                    ;
36787a984708SDavid Chisnall                if (__i > __j)
36797a984708SDavid Chisnall                    break;
36807a984708SDavid Chisnall                swap(*__i, *__j);
36817a984708SDavid Chisnall                ++__n_swaps;
36827a984708SDavid Chisnall                // It is known that __m != __j
36837a984708SDavid Chisnall                // If __m just moved, follow it
36847a984708SDavid Chisnall                if (__m == __i)
36857a984708SDavid Chisnall                    __m = __j;
36867a984708SDavid Chisnall                ++__i;
36877a984708SDavid Chisnall            }
36887a984708SDavid Chisnall        }
36897a984708SDavid Chisnall        // [__first, __i) < *__m and *__m <= [__i, __last)
36907a984708SDavid Chisnall        if (__i != __m && __comp(*__m, *__i))
36917a984708SDavid Chisnall        {
36927a984708SDavid Chisnall            swap(*__i, *__m);
36937a984708SDavid Chisnall            ++__n_swaps;
36947a984708SDavid Chisnall        }
36957a984708SDavid Chisnall        // [__first, __i) < *__i and *__i <= [__i+1, __last)
36967a984708SDavid Chisnall        // If we were given a perfect partition, see if insertion sort is quick...
36977a984708SDavid Chisnall        if (__n_swaps == 0)
36987a984708SDavid Chisnall        {
36997a984708SDavid Chisnall            bool __fs = _VSTD::__insertion_sort_incomplete<_Compare>(__first, __i, __comp);
37007a984708SDavid Chisnall            if (_VSTD::__insertion_sort_incomplete<_Compare>(__i+1, __last, __comp))
37017a984708SDavid Chisnall            {
37027a984708SDavid Chisnall                if (__fs)
37037a984708SDavid Chisnall                    return;
37047a984708SDavid Chisnall                __last = __i;
37057a984708SDavid Chisnall                continue;
37067a984708SDavid Chisnall            }
37077a984708SDavid Chisnall            else
37087a984708SDavid Chisnall            {
37097a984708SDavid Chisnall                if (__fs)
37107a984708SDavid Chisnall                {
37117a984708SDavid Chisnall                    __first = ++__i;
37127a984708SDavid Chisnall                    continue;
37137a984708SDavid Chisnall                }
37147a984708SDavid Chisnall            }
37157a984708SDavid Chisnall        }
37167a984708SDavid Chisnall        // sort smaller range with recursive call and larger with tail recursion elimination
37177a984708SDavid Chisnall        if (__i - __first < __last - __i)
37187a984708SDavid Chisnall        {
37197a984708SDavid Chisnall            _VSTD::__sort<_Compare>(__first, __i, __comp);
37207a984708SDavid Chisnall            // _VSTD::__sort<_Compare>(__i+1, __last, __comp);
37217a984708SDavid Chisnall            __first = ++__i;
37227a984708SDavid Chisnall        }
37237a984708SDavid Chisnall        else
37247a984708SDavid Chisnall        {
37257a984708SDavid Chisnall            _VSTD::__sort<_Compare>(__i+1, __last, __comp);
37267a984708SDavid Chisnall            // _VSTD::__sort<_Compare>(__first, __i, __comp);
37277a984708SDavid Chisnall            __last = __i;
37287a984708SDavid Chisnall        }
37297a984708SDavid Chisnall    }
37307a984708SDavid Chisnall}
37317a984708SDavid Chisnall
37327a984708SDavid Chisnall// This forwarder keeps the top call and the recursive calls using the same instantiation, forcing a reference _Compare
37337a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare>
37347a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
37357a984708SDavid Chisnallvoid
37367a984708SDavid Chisnallsort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
37377a984708SDavid Chisnall{
37387a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2
37397a984708SDavid Chisnall    typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
37407a984708SDavid Chisnall    __debug_less<_Compare> __c(__comp);
37417a984708SDavid Chisnall    __sort<_Comp_ref>(__first, __last, __c);
37427a984708SDavid Chisnall#else  // _LIBCPP_DEBUG2
37437a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
37447a984708SDavid Chisnall    __sort<_Comp_ref>(__first, __last, __comp);
37457a984708SDavid Chisnall#endif  // _LIBCPP_DEBUG2
37467a984708SDavid Chisnall}
37477a984708SDavid Chisnall
37487a984708SDavid Chisnalltemplate <class _RandomAccessIterator>
37497a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
37507a984708SDavid Chisnallvoid
37517a984708SDavid Chisnallsort(_RandomAccessIterator __first, _RandomAccessIterator __last)
37527a984708SDavid Chisnall{
37537a984708SDavid Chisnall    _VSTD::sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
37547a984708SDavid Chisnall}
37557a984708SDavid Chisnall
37567a984708SDavid Chisnalltemplate <class _Tp>
37577a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
37587a984708SDavid Chisnallvoid
37597a984708SDavid Chisnallsort(_Tp** __first, _Tp** __last)
37607a984708SDavid Chisnall{
37617a984708SDavid Chisnall    _VSTD::sort((size_t*)__first, (size_t*)__last, __less<size_t>());
37627a984708SDavid Chisnall}
37637a984708SDavid Chisnall
37647a984708SDavid Chisnalltemplate <class _Tp>
37657a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
37667a984708SDavid Chisnallvoid
37677a984708SDavid Chisnallsort(__wrap_iter<_Tp*> __first, __wrap_iter<_Tp*> __last)
37687a984708SDavid Chisnall{
37697a984708SDavid Chisnall    _VSTD::sort(__first.base(), __last.base());
37707a984708SDavid Chisnall}
37717a984708SDavid Chisnall
37727a984708SDavid Chisnalltemplate <class _Tp, class _Compare>
37737a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
37747a984708SDavid Chisnallvoid
37757a984708SDavid Chisnallsort(__wrap_iter<_Tp*> __first, __wrap_iter<_Tp*> __last, _Compare __comp)
37767a984708SDavid Chisnall{
37777a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
37787a984708SDavid Chisnall    _VSTD::sort<_Tp*, _Comp_ref>(__first.base(), __last.base(), __comp);
37797a984708SDavid Chisnall}
37807a984708SDavid Chisnall
37817a984708SDavid Chisnall#ifdef _MSC_VER
37827a984708SDavid Chisnall#pragma warning( push )
37837a984708SDavid Chisnall#pragma warning( disable: 4231)
37847a984708SDavid Chisnall#endif // _MSC_VER
37851e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<char>&, char*>(char*, char*, __less<char>&))
37861e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<wchar_t>&, wchar_t*>(wchar_t*, wchar_t*, __less<wchar_t>&))
37871e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<signed char>&, signed char*>(signed char*, signed char*, __less<signed char>&))
37881e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<unsigned char>&, unsigned char*>(unsigned char*, unsigned char*, __less<unsigned char>&))
37891e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<short>&, short*>(short*, short*, __less<short>&))
37901e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<unsigned short>&, unsigned short*>(unsigned short*, unsigned short*, __less<unsigned short>&))
37911e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<int>&, int*>(int*, int*, __less<int>&))
37921e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<unsigned>&, unsigned*>(unsigned*, unsigned*, __less<unsigned>&))
37931e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<long>&, long*>(long*, long*, __less<long>&))
37941e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<unsigned long>&, unsigned long*>(unsigned long*, unsigned long*, __less<unsigned long>&))
37951e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<long long>&, long long*>(long long*, long long*, __less<long long>&))
37961e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<unsigned long long>&, unsigned long long*>(unsigned long long*, unsigned long long*, __less<unsigned long long>&))
37971e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<float>&, float*>(float*, float*, __less<float>&))
37981e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<double>&, double*>(double*, double*, __less<double>&))
37991e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(void __sort<__less<long double>&, long double*>(long double*, long double*, __less<long double>&))
38007a984708SDavid Chisnall
38011e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<char>&, char*>(char*, char*, __less<char>&))
38021e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<wchar_t>&, wchar_t*>(wchar_t*, wchar_t*, __less<wchar_t>&))
38031e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<signed char>&, signed char*>(signed char*, signed char*, __less<signed char>&))
38041e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<unsigned char>&, unsigned char*>(unsigned char*, unsigned char*, __less<unsigned char>&))
38051e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<short>&, short*>(short*, short*, __less<short>&))
38061e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<unsigned short>&, unsigned short*>(unsigned short*, unsigned short*, __less<unsigned short>&))
38071e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<int>&, int*>(int*, int*, __less<int>&))
38081e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<unsigned>&, unsigned*>(unsigned*, unsigned*, __less<unsigned>&))
38091e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<long>&, long*>(long*, long*, __less<long>&))
38101e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<unsigned long>&, unsigned long*>(unsigned long*, unsigned long*, __less<unsigned long>&))
38111e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<long long>&, long long*>(long long*, long long*, __less<long long>&))
38121e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<unsigned long long>&, unsigned long long*>(unsigned long long*, unsigned long long*, __less<unsigned long long>&))
38131e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<float>&, float*>(float*, float*, __less<float>&))
38141e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<double>&, double*>(double*, double*, __less<double>&))
38151e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(bool __insertion_sort_incomplete<__less<long double>&, long double*>(long double*, long double*, __less<long double>&))
38167a984708SDavid Chisnall
38171e0896acSDavid Chisnall_LIBCPP_EXTERN_TEMPLATE(unsigned __sort5<__less<long double>&, long double*>(long double*, long double*, long double*, long double*, long double*, __less<long double>&))
38187a984708SDavid Chisnall#ifdef _MSC_VER
38197a984708SDavid Chisnall#pragma warning( pop )
382094e3ee44SDavid Chisnall#endif  // _MSC_VER
38217a984708SDavid Chisnall
38227a984708SDavid Chisnall// lower_bound
38237a984708SDavid Chisnall
38247a984708SDavid Chisnalltemplate <class _Compare, class _ForwardIterator, class _Tp>
38257a984708SDavid Chisnall_ForwardIterator
38267a984708SDavid Chisnall__lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
38277a984708SDavid Chisnall{
38287a984708SDavid Chisnall    typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
38297a984708SDavid Chisnall    difference_type __len = _VSTD::distance(__first, __last);
38307a984708SDavid Chisnall    while (__len != 0)
38317a984708SDavid Chisnall    {
38327a984708SDavid Chisnall        difference_type __l2 = __len / 2;
38337a984708SDavid Chisnall        _ForwardIterator __m = __first;
38347a984708SDavid Chisnall        _VSTD::advance(__m, __l2);
38357a984708SDavid Chisnall        if (__comp(*__m, __value_))
38367a984708SDavid Chisnall        {
38377a984708SDavid Chisnall            __first = ++__m;
38387a984708SDavid Chisnall            __len -= __l2 + 1;
38397a984708SDavid Chisnall        }
38407a984708SDavid Chisnall        else
38417a984708SDavid Chisnall            __len = __l2;
38427a984708SDavid Chisnall    }
38437a984708SDavid Chisnall    return __first;
38447a984708SDavid Chisnall}
38457a984708SDavid Chisnall
38467a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp, class _Compare>
38477a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
38487a984708SDavid Chisnall_ForwardIterator
38497a984708SDavid Chisnalllower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
38507a984708SDavid Chisnall{
38517a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2
38527a984708SDavid Chisnall    typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
38537a984708SDavid Chisnall    __debug_less<_Compare> __c(__comp);
38547a984708SDavid Chisnall    return __lower_bound<_Comp_ref>(__first, __last, __value_, __c);
38557a984708SDavid Chisnall#else  // _LIBCPP_DEBUG2
38567a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
38577a984708SDavid Chisnall    return __lower_bound<_Comp_ref>(__first, __last, __value_, __comp);
38587a984708SDavid Chisnall#endif  // _LIBCPP_DEBUG2
38597a984708SDavid Chisnall}
38607a984708SDavid Chisnall
38617a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp>
38627a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
38637a984708SDavid Chisnall_ForwardIterator
38647a984708SDavid Chisnalllower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
38657a984708SDavid Chisnall{
38667a984708SDavid Chisnall    return _VSTD::lower_bound(__first, __last, __value_,
38677a984708SDavid Chisnall                             __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
38687a984708SDavid Chisnall}
38697a984708SDavid Chisnall
38707a984708SDavid Chisnall// upper_bound
38717a984708SDavid Chisnall
38727a984708SDavid Chisnalltemplate <class _Compare, class _ForwardIterator, class _Tp>
38737a984708SDavid Chisnall_ForwardIterator
38747a984708SDavid Chisnall__upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
38757a984708SDavid Chisnall{
38767a984708SDavid Chisnall    typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
38777a984708SDavid Chisnall    difference_type __len = _VSTD::distance(__first, __last);
38787a984708SDavid Chisnall    while (__len != 0)
38797a984708SDavid Chisnall    {
38807a984708SDavid Chisnall        difference_type __l2 = __len / 2;
38817a984708SDavid Chisnall        _ForwardIterator __m = __first;
38827a984708SDavid Chisnall        _VSTD::advance(__m, __l2);
38837a984708SDavid Chisnall        if (__comp(__value_, *__m))
38847a984708SDavid Chisnall            __len = __l2;
38857a984708SDavid Chisnall        else
38867a984708SDavid Chisnall        {
38877a984708SDavid Chisnall            __first = ++__m;
38887a984708SDavid Chisnall            __len -= __l2 + 1;
38897a984708SDavid Chisnall        }
38907a984708SDavid Chisnall    }
38917a984708SDavid Chisnall    return __first;
38927a984708SDavid Chisnall}
38937a984708SDavid Chisnall
38947a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp, class _Compare>
38957a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
38967a984708SDavid Chisnall_ForwardIterator
38977a984708SDavid Chisnallupper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
38987a984708SDavid Chisnall{
38997a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2
39007a984708SDavid Chisnall    typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
39017a984708SDavid Chisnall    __debug_less<_Compare> __c(__comp);
39027a984708SDavid Chisnall    return __upper_bound<_Comp_ref>(__first, __last, __value_, __c);
39037a984708SDavid Chisnall#else  // _LIBCPP_DEBUG2
39047a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
39057a984708SDavid Chisnall    return __upper_bound<_Comp_ref>(__first, __last, __value_, __comp);
39067a984708SDavid Chisnall#endif  // _LIBCPP_DEBUG2
39077a984708SDavid Chisnall}
39087a984708SDavid Chisnall
39097a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp>
39107a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
39117a984708SDavid Chisnall_ForwardIterator
39127a984708SDavid Chisnallupper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
39137a984708SDavid Chisnall{
39147a984708SDavid Chisnall    return _VSTD::upper_bound(__first, __last, __value_,
39157a984708SDavid Chisnall                             __less<_Tp, typename iterator_traits<_ForwardIterator>::value_type>());
39167a984708SDavid Chisnall}
39177a984708SDavid Chisnall
39187a984708SDavid Chisnall// equal_range
39197a984708SDavid Chisnall
39207a984708SDavid Chisnalltemplate <class _Compare, class _ForwardIterator, class _Tp>
39217a984708SDavid Chisnallpair<_ForwardIterator, _ForwardIterator>
39227a984708SDavid Chisnall__equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
39237a984708SDavid Chisnall{
39247a984708SDavid Chisnall    typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
39257a984708SDavid Chisnall    difference_type __len = _VSTD::distance(__first, __last);
39267a984708SDavid Chisnall    while (__len != 0)
39277a984708SDavid Chisnall    {
39287a984708SDavid Chisnall        difference_type __l2 = __len / 2;
39297a984708SDavid Chisnall        _ForwardIterator __m = __first;
39307a984708SDavid Chisnall        _VSTD::advance(__m, __l2);
39317a984708SDavid Chisnall        if (__comp(*__m, __value_))
39327a984708SDavid Chisnall        {
39337a984708SDavid Chisnall            __first = ++__m;
39347a984708SDavid Chisnall            __len -= __l2 + 1;
39357a984708SDavid Chisnall        }
39367a984708SDavid Chisnall        else if (__comp(__value_, *__m))
39377a984708SDavid Chisnall        {
39387a984708SDavid Chisnall            __last = __m;
39397a984708SDavid Chisnall            __len = __l2;
39407a984708SDavid Chisnall        }
39417a984708SDavid Chisnall        else
39427a984708SDavid Chisnall        {
39437a984708SDavid Chisnall            _ForwardIterator __mp1 = __m;
39447a984708SDavid Chisnall            return pair<_ForwardIterator, _ForwardIterator>
39457a984708SDavid Chisnall                   (
39467a984708SDavid Chisnall                      __lower_bound<_Compare>(__first, __m, __value_, __comp),
39477a984708SDavid Chisnall                      __upper_bound<_Compare>(++__mp1, __last, __value_, __comp)
39487a984708SDavid Chisnall                   );
39497a984708SDavid Chisnall        }
39507a984708SDavid Chisnall    }
39517a984708SDavid Chisnall    return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
39527a984708SDavid Chisnall}
39537a984708SDavid Chisnall
39547a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp, class _Compare>
39557a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
39567a984708SDavid Chisnallpair<_ForwardIterator, _ForwardIterator>
39577a984708SDavid Chisnallequal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
39587a984708SDavid Chisnall{
39597a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2
39607a984708SDavid Chisnall    typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
39617a984708SDavid Chisnall    __debug_less<_Compare> __c(__comp);
39627a984708SDavid Chisnall    return __equal_range<_Comp_ref>(__first, __last, __value_, __c);
39637a984708SDavid Chisnall#else  // _LIBCPP_DEBUG2
39647a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
39657a984708SDavid Chisnall    return __equal_range<_Comp_ref>(__first, __last, __value_, __comp);
39667a984708SDavid Chisnall#endif  // _LIBCPP_DEBUG2
39677a984708SDavid Chisnall}
39687a984708SDavid Chisnall
39697a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp>
39707a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
39717a984708SDavid Chisnallpair<_ForwardIterator, _ForwardIterator>
39727a984708SDavid Chisnallequal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
39737a984708SDavid Chisnall{
39747a984708SDavid Chisnall    return _VSTD::equal_range(__first, __last, __value_,
39757a984708SDavid Chisnall                             __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
39767a984708SDavid Chisnall}
39777a984708SDavid Chisnall
39787a984708SDavid Chisnall// binary_search
39797a984708SDavid Chisnall
39807a984708SDavid Chisnalltemplate <class _Compare, class _ForwardIterator, class _Tp>
39817a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
39827a984708SDavid Chisnallbool
39837a984708SDavid Chisnall__binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
39847a984708SDavid Chisnall{
39857a984708SDavid Chisnall    __first = __lower_bound<_Compare>(__first, __last, __value_, __comp);
39867a984708SDavid Chisnall    return __first != __last && !__comp(__value_, *__first);
39877a984708SDavid Chisnall}
39887a984708SDavid Chisnall
39897a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp, class _Compare>
39907a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
39917a984708SDavid Chisnallbool
39927a984708SDavid Chisnallbinary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
39937a984708SDavid Chisnall{
39947a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2
39957a984708SDavid Chisnall    typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
39967a984708SDavid Chisnall    __debug_less<_Compare> __c(__comp);
39977a984708SDavid Chisnall    return __binary_search<_Comp_ref>(__first, __last, __value_, __c);
39987a984708SDavid Chisnall#else  // _LIBCPP_DEBUG2
39997a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
40007a984708SDavid Chisnall    return __binary_search<_Comp_ref>(__first, __last, __value_, __comp);
40017a984708SDavid Chisnall#endif  // _LIBCPP_DEBUG2
40027a984708SDavid Chisnall}
40037a984708SDavid Chisnall
40047a984708SDavid Chisnalltemplate <class _ForwardIterator, class _Tp>
40057a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
40067a984708SDavid Chisnallbool
40077a984708SDavid Chisnallbinary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
40087a984708SDavid Chisnall{
40097a984708SDavid Chisnall    return _VSTD::binary_search(__first, __last, __value_,
40107a984708SDavid Chisnall                             __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
40117a984708SDavid Chisnall}
40127a984708SDavid Chisnall
40137a984708SDavid Chisnall// merge
40147a984708SDavid Chisnall
40157a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
40167a984708SDavid Chisnall_OutputIterator
40177a984708SDavid Chisnall__merge(_InputIterator1 __first1, _InputIterator1 __last1,
40187a984708SDavid Chisnall        _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
40197a984708SDavid Chisnall{
40207a984708SDavid Chisnall    for (; __first1 != __last1; ++__result)
40217a984708SDavid Chisnall    {
40227a984708SDavid Chisnall        if (__first2 == __last2)
40237a984708SDavid Chisnall            return _VSTD::copy(__first1, __last1, __result);
40247a984708SDavid Chisnall        if (__comp(*__first2, *__first1))
40257a984708SDavid Chisnall        {
40267a984708SDavid Chisnall            *__result = *__first2;
40277a984708SDavid Chisnall            ++__first2;
40287a984708SDavid Chisnall        }
40297a984708SDavid Chisnall        else
40307a984708SDavid Chisnall        {
40317a984708SDavid Chisnall            *__result = *__first1;
40327a984708SDavid Chisnall            ++__first1;
40337a984708SDavid Chisnall        }
40347a984708SDavid Chisnall    }
40357a984708SDavid Chisnall    return _VSTD::copy(__first2, __last2, __result);
40367a984708SDavid Chisnall}
40377a984708SDavid Chisnall
40387a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
40397a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
40407a984708SDavid Chisnall_OutputIterator
40417a984708SDavid Chisnallmerge(_InputIterator1 __first1, _InputIterator1 __last1,
40427a984708SDavid Chisnall      _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
40437a984708SDavid Chisnall{
40447a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2
40457a984708SDavid Chisnall    typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
40467a984708SDavid Chisnall    __debug_less<_Compare> __c(__comp);
40477a984708SDavid Chisnall    return _VSTD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c);
40487a984708SDavid Chisnall#else  // _LIBCPP_DEBUG2
40497a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
40507a984708SDavid Chisnall    return _VSTD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
40517a984708SDavid Chisnall#endif  // _LIBCPP_DEBUG2
40527a984708SDavid Chisnall}
40537a984708SDavid Chisnall
40547a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator>
40557a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
40567a984708SDavid Chisnall_OutputIterator
40577a984708SDavid Chisnallmerge(_InputIterator1 __first1, _InputIterator1 __last1,
40587a984708SDavid Chisnall      _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
40597a984708SDavid Chisnall{
40607a984708SDavid Chisnall    typedef typename iterator_traits<_InputIterator1>::value_type __v1;
40617a984708SDavid Chisnall    typedef typename iterator_traits<_InputIterator2>::value_type __v2;
40627a984708SDavid Chisnall    return merge(__first1, __last1, __first2, __last2, __result, __less<__v1, __v2>());
40637a984708SDavid Chisnall}
40647a984708SDavid Chisnall
40657a984708SDavid Chisnall// inplace_merge
40667a984708SDavid Chisnall
40677a984708SDavid Chisnalltemplate <class _Compare, class _BidirectionalIterator>
40687a984708SDavid Chisnallvoid
40697a984708SDavid Chisnall__buffered_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
40707a984708SDavid Chisnall                _Compare __comp, typename iterator_traits<_BidirectionalIterator>::difference_type __len1,
40717a984708SDavid Chisnall                                 typename iterator_traits<_BidirectionalIterator>::difference_type __len2,
40727a984708SDavid Chisnall                typename iterator_traits<_BidirectionalIterator>::value_type* __buff)
40737a984708SDavid Chisnall{
40747a984708SDavid Chisnall    typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
40757a984708SDavid Chisnall    typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
40767a984708SDavid Chisnall    typedef typename iterator_traits<_BidirectionalIterator>::pointer pointer;
40777a984708SDavid Chisnall    __destruct_n __d(0);
40787a984708SDavid Chisnall    unique_ptr<value_type, __destruct_n&> __h2(__buff, __d);
40797a984708SDavid Chisnall    if (__len1 <= __len2)
40807a984708SDavid Chisnall    {
40817a984708SDavid Chisnall        value_type* __p = __buff;
40827a984708SDavid Chisnall        for (_BidirectionalIterator __i = __first; __i != __middle; __d.__incr((value_type*)0), ++__i, ++__p)
40837a984708SDavid Chisnall            ::new(__p) value_type(_VSTD::move(*__i));
40847a984708SDavid Chisnall        __merge<_Compare>(move_iterator<value_type*>(__buff),
40857a984708SDavid Chisnall                          move_iterator<value_type*>(__p),
40867a984708SDavid Chisnall                          move_iterator<_BidirectionalIterator>(__middle),
40877a984708SDavid Chisnall                          move_iterator<_BidirectionalIterator>(__last),
40887a984708SDavid Chisnall                          __first, __comp);
40897a984708SDavid Chisnall    }
40907a984708SDavid Chisnall    else
40917a984708SDavid Chisnall    {
40927a984708SDavid Chisnall        value_type* __p = __buff;
40937a984708SDavid Chisnall        for (_BidirectionalIterator __i = __middle; __i != __last; __d.__incr((value_type*)0), ++__i, ++__p)
40947a984708SDavid Chisnall            ::new(__p) value_type(_VSTD::move(*__i));
40957a984708SDavid Chisnall        typedef reverse_iterator<_BidirectionalIterator> _RBi;
40967a984708SDavid Chisnall        typedef reverse_iterator<value_type*> _Rv;
40977a984708SDavid Chisnall        __merge(move_iterator<_RBi>(_RBi(__middle)), move_iterator<_RBi>(_RBi(__first)),
40987a984708SDavid Chisnall                move_iterator<_Rv>(_Rv(__p)), move_iterator<_Rv>(_Rv(__buff)),
40997a984708SDavid Chisnall                _RBi(__last), __negate<_Compare>(__comp));
41007a984708SDavid Chisnall    }
41017a984708SDavid Chisnall}
41027a984708SDavid Chisnall
41037a984708SDavid Chisnalltemplate <class _Compare, class _BidirectionalIterator>
41047a984708SDavid Chisnallvoid
41057a984708SDavid Chisnall__inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
41067a984708SDavid Chisnall                _Compare __comp, typename iterator_traits<_BidirectionalIterator>::difference_type __len1,
41077a984708SDavid Chisnall                                 typename iterator_traits<_BidirectionalIterator>::difference_type __len2,
41087a984708SDavid Chisnall                typename iterator_traits<_BidirectionalIterator>::value_type* __buff, ptrdiff_t __buff_size)
41097a984708SDavid Chisnall{
41107a984708SDavid Chisnall    typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
41117a984708SDavid Chisnall    typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
41127a984708SDavid Chisnall    while (true)
41137a984708SDavid Chisnall    {
41147a984708SDavid Chisnall        // if __middle == __last, we're done
41157a984708SDavid Chisnall        if (__len2 == 0)
41167a984708SDavid Chisnall            return;
41177a984708SDavid Chisnall        // shrink [__first, __middle) as much as possible (with no moves), returning if it shrinks to 0
41187a984708SDavid Chisnall        for (; true; ++__first, --__len1)
41197a984708SDavid Chisnall        {
41207a984708SDavid Chisnall            if (__len1 == 0)
41217a984708SDavid Chisnall                return;
41227a984708SDavid Chisnall            if (__comp(*__middle, *__first))
41237a984708SDavid Chisnall                break;
41247a984708SDavid Chisnall        }
41257a984708SDavid Chisnall        if (__len1 <= __buff_size || __len2 <= __buff_size)
41267a984708SDavid Chisnall        {
41277a984708SDavid Chisnall            __buffered_inplace_merge<_Compare>(__first, __middle, __last, __comp, __len1, __len2, __buff);
41287a984708SDavid Chisnall            return;
41297a984708SDavid Chisnall        }
41307a984708SDavid Chisnall        // __first < __middle < __last
41317a984708SDavid Chisnall        // *__first > *__middle
41327a984708SDavid Chisnall        // partition [__first, __m1) [__m1, __middle) [__middle, __m2) [__m2, __last) such that
41337a984708SDavid Chisnall        //     all elements in:
41347a984708SDavid Chisnall        //         [__first, __m1)  <= [__middle, __m2)
41357a984708SDavid Chisnall        //         [__middle, __m2) <  [__m1, __middle)
41367a984708SDavid Chisnall        //         [__m1, __middle) <= [__m2, __last)
41377a984708SDavid Chisnall        //     and __m1 or __m2 is in the middle of its range
41387a984708SDavid Chisnall        _BidirectionalIterator __m1;  // "median" of [__first, __middle)
41397a984708SDavid Chisnall        _BidirectionalIterator __m2;  // "median" of [__middle, __last)
41407a984708SDavid Chisnall        difference_type __len11;      // distance(__first, __m1)
41417a984708SDavid Chisnall        difference_type __len21;      // distance(__middle, __m2)
41427a984708SDavid Chisnall        // binary search smaller range
41437a984708SDavid Chisnall        if (__len1 < __len2)
41447a984708SDavid Chisnall        {   // __len >= 1, __len2 >= 2
41457a984708SDavid Chisnall            __len21 = __len2 / 2;
41467a984708SDavid Chisnall            __m2 = __middle;
41477a984708SDavid Chisnall            _VSTD::advance(__m2, __len21);
41487a984708SDavid Chisnall            __m1 = __upper_bound<_Compare>(__first, __middle, *__m2, __comp);
41497a984708SDavid Chisnall            __len11 = _VSTD::distance(__first, __m1);
41507a984708SDavid Chisnall        }
41517a984708SDavid Chisnall        else
41527a984708SDavid Chisnall        {
41537a984708SDavid Chisnall            if (__len1 == 1)
41547a984708SDavid Chisnall            {   // __len1 >= __len2 && __len2 > 0, therefore __len2 == 1
41557a984708SDavid Chisnall                // It is known *__first > *__middle
41567a984708SDavid Chisnall                swap(*__first, *__middle);
41577a984708SDavid Chisnall                return;
41587a984708SDavid Chisnall            }
41597a984708SDavid Chisnall            // __len1 >= 2, __len2 >= 1
41607a984708SDavid Chisnall            __len11 = __len1 / 2;
41617a984708SDavid Chisnall            __m1 = __first;
41627a984708SDavid Chisnall            _VSTD::advance(__m1, __len11);
41637a984708SDavid Chisnall            __m2 = __lower_bound<_Compare>(__middle, __last, *__m1, __comp);
41647a984708SDavid Chisnall            __len21 = _VSTD::distance(__middle, __m2);
41657a984708SDavid Chisnall        }
41667a984708SDavid Chisnall        difference_type __len12 = __len1 - __len11;  // distance(__m1, __middle)
41677a984708SDavid Chisnall        difference_type __len22 = __len2 - __len21;  // distance(__m2, __last)
41687a984708SDavid Chisnall        // [__first, __m1) [__m1, __middle) [__middle, __m2) [__m2, __last)
41697a984708SDavid Chisnall        // swap middle two partitions
41707a984708SDavid Chisnall        __middle = _VSTD::rotate(__m1, __middle, __m2);
41717a984708SDavid Chisnall        // __len12 and __len21 now have swapped meanings
41727a984708SDavid Chisnall        // merge smaller range with recurisve call and larger with tail recursion elimination
41737a984708SDavid Chisnall        if (__len11 + __len21 < __len12 + __len22)
41747a984708SDavid Chisnall        {
41757a984708SDavid Chisnall            __inplace_merge<_Compare>(__first, __m1, __middle, __comp, __len11, __len21, __buff, __buff_size);
41767a984708SDavid Chisnall//          __inplace_merge<_Compare>(__middle, __m2, __last, __comp, __len12, __len22, __buff, __buff_size);
41777a984708SDavid Chisnall            __first = __middle;
41787a984708SDavid Chisnall            __middle = __m2;
41797a984708SDavid Chisnall            __len1 = __len12;
41807a984708SDavid Chisnall            __len2 = __len22;
41817a984708SDavid Chisnall        }
41827a984708SDavid Chisnall        else
41837a984708SDavid Chisnall        {
41847a984708SDavid Chisnall            __inplace_merge<_Compare>(__middle, __m2, __last, __comp, __len12, __len22, __buff, __buff_size);
41857a984708SDavid Chisnall//          __inplace_merge<_Compare>(__first, __m1, __middle, __comp, __len11, __len21, __buff, __buff_size);
41867a984708SDavid Chisnall            __last = __middle;
41877a984708SDavid Chisnall            __middle = __m1;
41887a984708SDavid Chisnall            __len1 = __len11;
41897a984708SDavid Chisnall            __len2 = __len21;
41907a984708SDavid Chisnall        }
41917a984708SDavid Chisnall    }
41927a984708SDavid Chisnall}
41937a984708SDavid Chisnall
41947a984708SDavid Chisnalltemplate <class _Tp>
41957a984708SDavid Chisnallstruct __inplace_merge_switch
41967a984708SDavid Chisnall{
41977a984708SDavid Chisnall    static const unsigned value = is_trivially_copy_assignable<_Tp>::value;
41987a984708SDavid Chisnall};
41997a984708SDavid Chisnall
42007a984708SDavid Chisnalltemplate <class _BidirectionalIterator, class _Compare>
42017a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
42027a984708SDavid Chisnallvoid
42037a984708SDavid Chisnallinplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
42047a984708SDavid Chisnall              _Compare __comp)
42057a984708SDavid Chisnall{
42067a984708SDavid Chisnall    typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
42077a984708SDavid Chisnall    typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
42087a984708SDavid Chisnall    difference_type __len1 = _VSTD::distance(__first, __middle);
42097a984708SDavid Chisnall    difference_type __len2 = _VSTD::distance(__middle, __last);
42107a984708SDavid Chisnall    difference_type __buf_size = _VSTD::min(__len1, __len2);
42117a984708SDavid Chisnall    pair<value_type*, ptrdiff_t> __buf(0, 0);
42127a984708SDavid Chisnall    unique_ptr<value_type, __return_temporary_buffer> __h;
42137a984708SDavid Chisnall    if (__inplace_merge_switch<value_type>::value && __buf_size > 8)
42147a984708SDavid Chisnall    {
42157a984708SDavid Chisnall        __buf = _VSTD::get_temporary_buffer<value_type>(__buf_size);
42167a984708SDavid Chisnall        __h.reset(__buf.first);
42177a984708SDavid Chisnall    }
42187a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2
42197a984708SDavid Chisnall    typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
42207a984708SDavid Chisnall    __debug_less<_Compare> __c(__comp);
42217a984708SDavid Chisnall    return _VSTD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __c, __len1, __len2,
42227a984708SDavid Chisnall                                            __buf.first, __buf.second);
42237a984708SDavid Chisnall#else  // _LIBCPP_DEBUG2
42247a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
42257a984708SDavid Chisnall    return _VSTD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __comp, __len1, __len2,
42267a984708SDavid Chisnall                                            __buf.first, __buf.second);
42277a984708SDavid Chisnall#endif  // _LIBCPP_DEBUG2
42287a984708SDavid Chisnall}
42297a984708SDavid Chisnall
42307a984708SDavid Chisnalltemplate <class _BidirectionalIterator>
42317a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
42327a984708SDavid Chisnallvoid
42337a984708SDavid Chisnallinplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last)
42347a984708SDavid Chisnall{
42357a984708SDavid Chisnall    _VSTD::inplace_merge(__first, __middle, __last,
42367a984708SDavid Chisnall                        __less<typename iterator_traits<_BidirectionalIterator>::value_type>());
42377a984708SDavid Chisnall}
42387a984708SDavid Chisnall
42397a984708SDavid Chisnall// stable_sort
42407a984708SDavid Chisnall
42417a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2>
42427a984708SDavid Chisnallvoid
42437a984708SDavid Chisnall__merge_move_construct(_InputIterator1 __first1, _InputIterator1 __last1,
42447a984708SDavid Chisnall        _InputIterator2 __first2, _InputIterator2 __last2,
42457a984708SDavid Chisnall        typename iterator_traits<_InputIterator1>::value_type* __result, _Compare __comp)
42467a984708SDavid Chisnall{
42477a984708SDavid Chisnall    typedef typename iterator_traits<_InputIterator1>::value_type value_type;
42487a984708SDavid Chisnall    __destruct_n __d(0);
42497a984708SDavid Chisnall    unique_ptr<value_type, __destruct_n&> __h(__result, __d);
42507a984708SDavid Chisnall    for (; true; ++__result)
42517a984708SDavid Chisnall    {
42527a984708SDavid Chisnall        if (__first1 == __last1)
42537a984708SDavid Chisnall        {
42547a984708SDavid Chisnall            for (; __first2 != __last2; ++__first2, ++__result, __d.__incr((value_type*)0))
42557a984708SDavid Chisnall                ::new (__result) value_type(_VSTD::move(*__first2));
42567a984708SDavid Chisnall            __h.release();
42577a984708SDavid Chisnall            return;
42587a984708SDavid Chisnall        }
42597a984708SDavid Chisnall        if (__first2 == __last2)
42607a984708SDavid Chisnall        {
42617a984708SDavid Chisnall            for (; __first1 != __last1; ++__first1, ++__result, __d.__incr((value_type*)0))
42627a984708SDavid Chisnall                ::new (__result) value_type(_VSTD::move(*__first1));
42637a984708SDavid Chisnall            __h.release();
42647a984708SDavid Chisnall            return;
42657a984708SDavid Chisnall        }
42667a984708SDavid Chisnall        if (__comp(*__first2, *__first1))
42677a984708SDavid Chisnall        {
42687a984708SDavid Chisnall            ::new (__result) value_type(_VSTD::move(*__first2));
42697a984708SDavid Chisnall            __d.__incr((value_type*)0);
42707a984708SDavid Chisnall            ++__first2;
42717a984708SDavid Chisnall        }
42727a984708SDavid Chisnall        else
42737a984708SDavid Chisnall        {
42747a984708SDavid Chisnall            ::new (__result) value_type(_VSTD::move(*__first1));
42757a984708SDavid Chisnall            __d.__incr((value_type*)0);
42767a984708SDavid Chisnall            ++__first1;
42777a984708SDavid Chisnall        }
42787a984708SDavid Chisnall    }
42797a984708SDavid Chisnall}
42807a984708SDavid Chisnall
42817a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
42827a984708SDavid Chisnallvoid
42837a984708SDavid Chisnall__merge_move_assign(_InputIterator1 __first1, _InputIterator1 __last1,
42847a984708SDavid Chisnall        _InputIterator2 __first2, _InputIterator2 __last2,
42857a984708SDavid Chisnall        _OutputIterator __result, _Compare __comp)
42867a984708SDavid Chisnall{
42877a984708SDavid Chisnall    for (; __first1 != __last1; ++__result)
42887a984708SDavid Chisnall    {
42897a984708SDavid Chisnall        if (__first2 == __last2)
42907a984708SDavid Chisnall        {
42917a984708SDavid Chisnall            for (; __first1 != __last1; ++__first1, ++__result)
42927a984708SDavid Chisnall                *__result = _VSTD::move(*__first1);
42937a984708SDavid Chisnall            return;
42947a984708SDavid Chisnall        }
42957a984708SDavid Chisnall        if (__comp(*__first2, *__first1))
42967a984708SDavid Chisnall        {
42977a984708SDavid Chisnall            *__result = _VSTD::move(*__first2);
42987a984708SDavid Chisnall            ++__first2;
42997a984708SDavid Chisnall        }
43007a984708SDavid Chisnall        else
43017a984708SDavid Chisnall        {
43027a984708SDavid Chisnall            *__result = _VSTD::move(*__first1);
43037a984708SDavid Chisnall            ++__first1;
43047a984708SDavid Chisnall        }
43057a984708SDavid Chisnall    }
43067a984708SDavid Chisnall    for (; __first2 != __last2; ++__first2, ++__result)
43077a984708SDavid Chisnall        *__result = _VSTD::move(*__first2);
43087a984708SDavid Chisnall}
43097a984708SDavid Chisnall
43107a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator>
43117a984708SDavid Chisnallvoid
43127a984708SDavid Chisnall__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
43137a984708SDavid Chisnall              typename iterator_traits<_RandomAccessIterator>::difference_type __len,
43147a984708SDavid Chisnall              typename iterator_traits<_RandomAccessIterator>::value_type* __buff, ptrdiff_t __buff_size);
43157a984708SDavid Chisnall
43167a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator>
43177a984708SDavid Chisnallvoid
43187a984708SDavid Chisnall__stable_sort_move(_RandomAccessIterator __first1, _RandomAccessIterator __last1, _Compare __comp,
43197a984708SDavid Chisnall                   typename iterator_traits<_RandomAccessIterator>::difference_type __len,
43207a984708SDavid Chisnall                   typename iterator_traits<_RandomAccessIterator>::value_type* __first2)
43217a984708SDavid Chisnall{
43227a984708SDavid Chisnall    typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
43237a984708SDavid Chisnall    switch (__len)
43247a984708SDavid Chisnall    {
43257a984708SDavid Chisnall    case 0:
43267a984708SDavid Chisnall        return;
43277a984708SDavid Chisnall    case 1:
43287a984708SDavid Chisnall        ::new(__first2) value_type(_VSTD::move(*__first1));
43297a984708SDavid Chisnall        return;
43307a984708SDavid Chisnall    case 2:
43317a984708SDavid Chisnall       __destruct_n __d(0);
43327a984708SDavid Chisnall        unique_ptr<value_type, __destruct_n&> __h2(__first2, __d);
43337a984708SDavid Chisnall         if (__comp(*--__last1, *__first1))
43347a984708SDavid Chisnall        {
43357a984708SDavid Chisnall            ::new(__first2) value_type(_VSTD::move(*__last1));
43367a984708SDavid Chisnall            __d.__incr((value_type*)0);
43377a984708SDavid Chisnall            ++__first2;
43387a984708SDavid Chisnall            ::new(__first2) value_type(_VSTD::move(*__first1));
43397a984708SDavid Chisnall        }
43407a984708SDavid Chisnall        else
43417a984708SDavid Chisnall        {
43427a984708SDavid Chisnall            ::new(__first2) value_type(_VSTD::move(*__first1));
43437a984708SDavid Chisnall            __d.__incr((value_type*)0);
43447a984708SDavid Chisnall            ++__first2;
43457a984708SDavid Chisnall            ::new(__first2) value_type(_VSTD::move(*__last1));
43467a984708SDavid Chisnall        }
43477a984708SDavid Chisnall        __h2.release();
43487a984708SDavid Chisnall        return;
43497a984708SDavid Chisnall    }
43507a984708SDavid Chisnall    if (__len <= 8)
43517a984708SDavid Chisnall    {
43527a984708SDavid Chisnall        __insertion_sort_move<_Compare>(__first1, __last1, __first2, __comp);
43537a984708SDavid Chisnall        return;
43547a984708SDavid Chisnall    }
43557a984708SDavid Chisnall    typename iterator_traits<_RandomAccessIterator>::difference_type __l2 = __len / 2;
43567a984708SDavid Chisnall    _RandomAccessIterator __m = __first1 + __l2;
43577a984708SDavid Chisnall    __stable_sort<_Compare>(__first1, __m, __comp, __l2, __first2, __l2);
43587a984708SDavid Chisnall    __stable_sort<_Compare>(__m, __last1, __comp, __len - __l2, __first2 + __l2, __len - __l2);
43597a984708SDavid Chisnall    __merge_move_construct<_Compare>(__first1, __m, __m, __last1, __first2, __comp);
43607a984708SDavid Chisnall}
43617a984708SDavid Chisnall
43627a984708SDavid Chisnalltemplate <class _Tp>
43637a984708SDavid Chisnallstruct __stable_sort_switch
43647a984708SDavid Chisnall{
43657a984708SDavid Chisnall    static const unsigned value = 128*is_trivially_copy_assignable<_Tp>::value;
43667a984708SDavid Chisnall};
43677a984708SDavid Chisnall
43687a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator>
43697a984708SDavid Chisnallvoid
43707a984708SDavid Chisnall__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
43717a984708SDavid Chisnall              typename iterator_traits<_RandomAccessIterator>::difference_type __len,
43727a984708SDavid Chisnall              typename iterator_traits<_RandomAccessIterator>::value_type* __buff, ptrdiff_t __buff_size)
43737a984708SDavid Chisnall{
43747a984708SDavid Chisnall    typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
43757a984708SDavid Chisnall    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
43767a984708SDavid Chisnall    switch (__len)
43777a984708SDavid Chisnall    {
43787a984708SDavid Chisnall    case 0:
43797a984708SDavid Chisnall    case 1:
43807a984708SDavid Chisnall        return;
43817a984708SDavid Chisnall    case 2:
43827a984708SDavid Chisnall        if (__comp(*--__last, *__first))
43837a984708SDavid Chisnall            swap(*__first, *__last);
43847a984708SDavid Chisnall        return;
43857a984708SDavid Chisnall    }
43867a984708SDavid Chisnall    if (__len <= static_cast<difference_type>(__stable_sort_switch<value_type>::value))
43877a984708SDavid Chisnall    {
43887a984708SDavid Chisnall        __insertion_sort<_Compare>(__first, __last, __comp);
43897a984708SDavid Chisnall        return;
43907a984708SDavid Chisnall    }
43917a984708SDavid Chisnall    typename iterator_traits<_RandomAccessIterator>::difference_type __l2 = __len / 2;
43927a984708SDavid Chisnall    _RandomAccessIterator __m = __first + __l2;
43937a984708SDavid Chisnall    if (__len <= __buff_size)
43947a984708SDavid Chisnall    {
43957a984708SDavid Chisnall        __destruct_n __d(0);
43967a984708SDavid Chisnall        unique_ptr<value_type, __destruct_n&> __h2(__buff, __d);
43977a984708SDavid Chisnall        __stable_sort_move<_Compare>(__first, __m, __comp, __l2, __buff);
43987a984708SDavid Chisnall        __d.__set(__l2, (value_type*)0);
43997a984708SDavid Chisnall        __stable_sort_move<_Compare>(__m, __last, __comp, __len - __l2, __buff + __l2);
44007a984708SDavid Chisnall        __d.__set(__len, (value_type*)0);
44017a984708SDavid Chisnall        __merge_move_assign<_Compare>(__buff, __buff + __l2, __buff + __l2, __buff + __len, __first, __comp);
44027a984708SDavid Chisnall//         __merge<_Compare>(move_iterator<value_type*>(__buff),
44037a984708SDavid Chisnall//                           move_iterator<value_type*>(__buff + __l2),
44047a984708SDavid Chisnall//                           move_iterator<_RandomAccessIterator>(__buff + __l2),
44057a984708SDavid Chisnall//                           move_iterator<_RandomAccessIterator>(__buff + __len),
44067a984708SDavid Chisnall//                           __first, __comp);
44077a984708SDavid Chisnall        return;
44087a984708SDavid Chisnall    }
44097a984708SDavid Chisnall    __stable_sort<_Compare>(__first, __m, __comp, __l2, __buff, __buff_size);
44107a984708SDavid Chisnall    __stable_sort<_Compare>(__m, __last, __comp, __len - __l2, __buff, __buff_size);
44117a984708SDavid Chisnall    __inplace_merge<_Compare>(__first, __m, __last, __comp, __l2, __len - __l2, __buff, __buff_size);
44127a984708SDavid Chisnall}
44137a984708SDavid Chisnall
44147a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare>
44157a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
44167a984708SDavid Chisnallvoid
44177a984708SDavid Chisnallstable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
44187a984708SDavid Chisnall{
44197a984708SDavid Chisnall    typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
44207a984708SDavid Chisnall    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
44217a984708SDavid Chisnall    difference_type __len = __last - __first;
44227a984708SDavid Chisnall    pair<value_type*, ptrdiff_t> __buf(0, 0);
44237a984708SDavid Chisnall    unique_ptr<value_type, __return_temporary_buffer> __h;
44247a984708SDavid Chisnall    if (__len > static_cast<difference_type>(__stable_sort_switch<value_type>::value))
44257a984708SDavid Chisnall    {
44267a984708SDavid Chisnall        __buf = _VSTD::get_temporary_buffer<value_type>(__len);
44277a984708SDavid Chisnall        __h.reset(__buf.first);
44287a984708SDavid Chisnall    }
44297a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2
44307a984708SDavid Chisnall    typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
44317a984708SDavid Chisnall    __debug_less<_Compare> __c(__comp);
44327a984708SDavid Chisnall    __stable_sort<_Comp_ref>(__first, __last, __c, __len, __buf.first, __buf.second);
44337a984708SDavid Chisnall#else  // _LIBCPP_DEBUG2
44347a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
44357a984708SDavid Chisnall    __stable_sort<_Comp_ref>(__first, __last, __comp, __len, __buf.first, __buf.second);
44367a984708SDavid Chisnall#endif  // _LIBCPP_DEBUG2
44377a984708SDavid Chisnall}
44387a984708SDavid Chisnall
44397a984708SDavid Chisnalltemplate <class _RandomAccessIterator>
44407a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
44417a984708SDavid Chisnallvoid
44427a984708SDavid Chisnallstable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
44437a984708SDavid Chisnall{
44447a984708SDavid Chisnall    _VSTD::stable_sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
44457a984708SDavid Chisnall}
44467a984708SDavid Chisnall
44477a984708SDavid Chisnall// is_heap_until
44487a984708SDavid Chisnall
44497a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare>
44507a984708SDavid Chisnall_RandomAccessIterator
44517a984708SDavid Chisnallis_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
44527a984708SDavid Chisnall{
44537a984708SDavid Chisnall    typedef typename _VSTD::iterator_traits<_RandomAccessIterator>::difference_type difference_type;
44547a984708SDavid Chisnall    difference_type __len = __last - __first;
44557a984708SDavid Chisnall    difference_type __p = 0;
44567a984708SDavid Chisnall    difference_type __c = 1;
44577a984708SDavid Chisnall    _RandomAccessIterator __pp = __first;
44587a984708SDavid Chisnall    while (__c < __len)
44597a984708SDavid Chisnall    {
44607a984708SDavid Chisnall        _RandomAccessIterator __cp = __first + __c;
44617a984708SDavid Chisnall        if (__comp(*__pp, *__cp))
44627a984708SDavid Chisnall            return __cp;
44637a984708SDavid Chisnall        ++__c;
44647a984708SDavid Chisnall        ++__cp;
44657a984708SDavid Chisnall        if (__c == __len)
44667a984708SDavid Chisnall            return __last;
44677a984708SDavid Chisnall        if (__comp(*__pp, *__cp))
44687a984708SDavid Chisnall            return __cp;
44697a984708SDavid Chisnall        ++__p;
44707a984708SDavid Chisnall        ++__pp;
44717a984708SDavid Chisnall        __c = 2 * __p + 1;
44727a984708SDavid Chisnall    }
44737a984708SDavid Chisnall    return __last;
44747a984708SDavid Chisnall}
44757a984708SDavid Chisnall
44767a984708SDavid Chisnalltemplate<class _RandomAccessIterator>
44777a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
44787a984708SDavid Chisnall_RandomAccessIterator
44797a984708SDavid Chisnallis_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
44807a984708SDavid Chisnall{
44817a984708SDavid Chisnall    return _VSTD::is_heap_until(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
44827a984708SDavid Chisnall}
44837a984708SDavid Chisnall
44847a984708SDavid Chisnall// is_heap
44857a984708SDavid Chisnall
44867a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare>
44877a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
44887a984708SDavid Chisnallbool
44897a984708SDavid Chisnallis_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
44907a984708SDavid Chisnall{
44917a984708SDavid Chisnall    return _VSTD::is_heap_until(__first, __last, __comp) == __last;
44927a984708SDavid Chisnall}
44937a984708SDavid Chisnall
44947a984708SDavid Chisnalltemplate<class _RandomAccessIterator>
44957a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
44967a984708SDavid Chisnallbool
44977a984708SDavid Chisnallis_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
44987a984708SDavid Chisnall{
44997a984708SDavid Chisnall    return _VSTD::is_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
45007a984708SDavid Chisnall}
45017a984708SDavid Chisnall
45027a984708SDavid Chisnall// push_heap
45037a984708SDavid Chisnall
45047a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator>
45057a984708SDavid Chisnallvoid
45067a984708SDavid Chisnall__push_heap_front(_RandomAccessIterator __first, _RandomAccessIterator, _Compare __comp,
45077a984708SDavid Chisnall                  typename iterator_traits<_RandomAccessIterator>::difference_type __len)
45087a984708SDavid Chisnall{
45097a984708SDavid Chisnall    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
45107a984708SDavid Chisnall    typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
45117a984708SDavid Chisnall    if (__len > 1)
45127a984708SDavid Chisnall    {
45137a984708SDavid Chisnall        difference_type __p = 0;
45147a984708SDavid Chisnall        _RandomAccessIterator __pp = __first;
45157a984708SDavid Chisnall        difference_type __c = 2;
45167a984708SDavid Chisnall        _RandomAccessIterator __cp = __first + __c;
45177a984708SDavid Chisnall        if (__c == __len || __comp(*__cp, *(__cp - 1)))
45187a984708SDavid Chisnall        {
45197a984708SDavid Chisnall            --__c;
45207a984708SDavid Chisnall            --__cp;
45217a984708SDavid Chisnall        }
45227a984708SDavid Chisnall        if (__comp(*__pp, *__cp))
45237a984708SDavid Chisnall        {
45247a984708SDavid Chisnall            value_type __t(_VSTD::move(*__pp));
45257a984708SDavid Chisnall            do
45267a984708SDavid Chisnall            {
45277a984708SDavid Chisnall                *__pp = _VSTD::move(*__cp);
45287a984708SDavid Chisnall                __pp = __cp;
45297a984708SDavid Chisnall                __p = __c;
45307a984708SDavid Chisnall                __c = (__p + 1) * 2;
45317a984708SDavid Chisnall                if (__c > __len)
45327a984708SDavid Chisnall                    break;
45337a984708SDavid Chisnall                __cp = __first + __c;
45347a984708SDavid Chisnall                if (__c == __len || __comp(*__cp, *(__cp - 1)))
45357a984708SDavid Chisnall                {
45367a984708SDavid Chisnall                    --__c;
45377a984708SDavid Chisnall                    --__cp;
45387a984708SDavid Chisnall                }
45397a984708SDavid Chisnall            } while (__comp(__t, *__cp));
45407a984708SDavid Chisnall            *__pp = _VSTD::move(__t);
45417a984708SDavid Chisnall        }
45427a984708SDavid Chisnall    }
45437a984708SDavid Chisnall}
45447a984708SDavid Chisnall
45457a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator>
45467a984708SDavid Chisnallvoid
45477a984708SDavid Chisnall__push_heap_back(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
45487a984708SDavid Chisnall                 typename iterator_traits<_RandomAccessIterator>::difference_type __len)
45497a984708SDavid Chisnall{
45507a984708SDavid Chisnall    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
45517a984708SDavid Chisnall    typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
45527a984708SDavid Chisnall    if (__len > 1)
45537a984708SDavid Chisnall    {
45547a984708SDavid Chisnall        __len = (__len - 2) / 2;
45557a984708SDavid Chisnall        _RandomAccessIterator __ptr = __first + __len;
45567a984708SDavid Chisnall        if (__comp(*__ptr, *--__last))
45577a984708SDavid Chisnall        {
45587a984708SDavid Chisnall            value_type __t(_VSTD::move(*__last));
45597a984708SDavid Chisnall            do
45607a984708SDavid Chisnall            {
45617a984708SDavid Chisnall                *__last = _VSTD::move(*__ptr);
45627a984708SDavid Chisnall                __last = __ptr;
45637a984708SDavid Chisnall                if (__len == 0)
45647a984708SDavid Chisnall                    break;
45657a984708SDavid Chisnall                __len = (__len - 1) / 2;
45667a984708SDavid Chisnall                __ptr = __first + __len;
45677a984708SDavid Chisnall            } while (__comp(*__ptr, __t));
45687a984708SDavid Chisnall            *__last = _VSTD::move(__t);
45697a984708SDavid Chisnall        }
45707a984708SDavid Chisnall    }
45717a984708SDavid Chisnall}
45727a984708SDavid Chisnall
45737a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare>
45747a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
45757a984708SDavid Chisnallvoid
45767a984708SDavid Chisnallpush_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
45777a984708SDavid Chisnall{
45787a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2
45797a984708SDavid Chisnall    typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
45807a984708SDavid Chisnall    __debug_less<_Compare> __c(__comp);
45817a984708SDavid Chisnall    __push_heap_back<_Comp_ref>(__first, __last, __c, __last - __first);
45827a984708SDavid Chisnall#else  // _LIBCPP_DEBUG2
45837a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
45847a984708SDavid Chisnall    __push_heap_back<_Comp_ref>(__first, __last, __comp, __last - __first);
45857a984708SDavid Chisnall#endif  // _LIBCPP_DEBUG2
45867a984708SDavid Chisnall}
45877a984708SDavid Chisnall
45887a984708SDavid Chisnalltemplate <class _RandomAccessIterator>
45897a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
45907a984708SDavid Chisnallvoid
45917a984708SDavid Chisnallpush_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
45927a984708SDavid Chisnall{
45937a984708SDavid Chisnall    _VSTD::push_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
45947a984708SDavid Chisnall}
45957a984708SDavid Chisnall
45967a984708SDavid Chisnall// pop_heap
45977a984708SDavid Chisnall
45987a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator>
45997a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
46007a984708SDavid Chisnallvoid
46017a984708SDavid Chisnall__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
46027a984708SDavid Chisnall           typename iterator_traits<_RandomAccessIterator>::difference_type __len)
46037a984708SDavid Chisnall{
46047a984708SDavid Chisnall    if (__len > 1)
46057a984708SDavid Chisnall    {
46067a984708SDavid Chisnall        swap(*__first, *--__last);
46077a984708SDavid Chisnall        __push_heap_front<_Compare>(__first, __last, __comp, __len-1);
46087a984708SDavid Chisnall    }
46097a984708SDavid Chisnall}
46107a984708SDavid Chisnall
46117a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare>
46127a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
46137a984708SDavid Chisnallvoid
46147a984708SDavid Chisnallpop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
46157a984708SDavid Chisnall{
46167a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2
46177a984708SDavid Chisnall    typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
46187a984708SDavid Chisnall    __debug_less<_Compare> __c(__comp);
46197a984708SDavid Chisnall    __pop_heap<_Comp_ref>(__first, __last, __c, __last - __first);
46207a984708SDavid Chisnall#else  // _LIBCPP_DEBUG2
46217a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
46227a984708SDavid Chisnall    __pop_heap<_Comp_ref>(__first, __last, __comp, __last - __first);
46237a984708SDavid Chisnall#endif  // _LIBCPP_DEBUG2
46247a984708SDavid Chisnall}
46257a984708SDavid Chisnall
46267a984708SDavid Chisnalltemplate <class _RandomAccessIterator>
46277a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
46287a984708SDavid Chisnallvoid
46297a984708SDavid Chisnallpop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
46307a984708SDavid Chisnall{
46317a984708SDavid Chisnall    _VSTD::pop_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
46327a984708SDavid Chisnall}
46337a984708SDavid Chisnall
46347a984708SDavid Chisnall// make_heap
46357a984708SDavid Chisnall
46367a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator>
46377a984708SDavid Chisnallvoid
46387a984708SDavid Chisnall__make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
46397a984708SDavid Chisnall{
46407a984708SDavid Chisnall    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
46417a984708SDavid Chisnall    difference_type __n = __last - __first;
46427a984708SDavid Chisnall    if (__n > 1)
46437a984708SDavid Chisnall    {
46447a984708SDavid Chisnall        __last = __first;
46457a984708SDavid Chisnall        ++__last;
46467a984708SDavid Chisnall        for (difference_type __i = 1; __i < __n;)
46477a984708SDavid Chisnall            __push_heap_back<_Compare>(__first, ++__last, __comp, ++__i);
46487a984708SDavid Chisnall    }
46497a984708SDavid Chisnall}
46507a984708SDavid Chisnall
46517a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare>
46527a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
46537a984708SDavid Chisnallvoid
46547a984708SDavid Chisnallmake_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
46557a984708SDavid Chisnall{
46567a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2
46577a984708SDavid Chisnall    typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
46587a984708SDavid Chisnall    __debug_less<_Compare> __c(__comp);
46597a984708SDavid Chisnall    __make_heap<_Comp_ref>(__first, __last, __c);
46607a984708SDavid Chisnall#else  // _LIBCPP_DEBUG2
46617a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
46627a984708SDavid Chisnall    __make_heap<_Comp_ref>(__first, __last, __comp);
46637a984708SDavid Chisnall#endif  // _LIBCPP_DEBUG2
46647a984708SDavid Chisnall}
46657a984708SDavid Chisnall
46667a984708SDavid Chisnalltemplate <class _RandomAccessIterator>
46677a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
46687a984708SDavid Chisnallvoid
46697a984708SDavid Chisnallmake_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
46707a984708SDavid Chisnall{
46717a984708SDavid Chisnall    _VSTD::make_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
46727a984708SDavid Chisnall}
46737a984708SDavid Chisnall
46747a984708SDavid Chisnall// sort_heap
46757a984708SDavid Chisnall
46767a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator>
46777a984708SDavid Chisnallvoid
46787a984708SDavid Chisnall__sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
46797a984708SDavid Chisnall{
46807a984708SDavid Chisnall    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
46817a984708SDavid Chisnall    for (difference_type __n = __last - __first; __n > 1; --__last, --__n)
46827a984708SDavid Chisnall        __pop_heap<_Compare>(__first, __last, __comp, __n);
46837a984708SDavid Chisnall}
46847a984708SDavid Chisnall
46857a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare>
46867a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
46877a984708SDavid Chisnallvoid
46887a984708SDavid Chisnallsort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
46897a984708SDavid Chisnall{
46907a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2
46917a984708SDavid Chisnall    typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
46927a984708SDavid Chisnall    __debug_less<_Compare> __c(__comp);
46937a984708SDavid Chisnall    __sort_heap<_Comp_ref>(__first, __last, __c);
46947a984708SDavid Chisnall#else  // _LIBCPP_DEBUG2
46957a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
46967a984708SDavid Chisnall    __sort_heap<_Comp_ref>(__first, __last, __comp);
46977a984708SDavid Chisnall#endif  // _LIBCPP_DEBUG2
46987a984708SDavid Chisnall}
46997a984708SDavid Chisnall
47007a984708SDavid Chisnalltemplate <class _RandomAccessIterator>
47017a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
47027a984708SDavid Chisnallvoid
47037a984708SDavid Chisnallsort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
47047a984708SDavid Chisnall{
47057a984708SDavid Chisnall    _VSTD::sort_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
47067a984708SDavid Chisnall}
47077a984708SDavid Chisnall
47087a984708SDavid Chisnall// partial_sort
47097a984708SDavid Chisnall
47107a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator>
47117a984708SDavid Chisnallvoid
47127a984708SDavid Chisnall__partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last,
47137a984708SDavid Chisnall             _Compare __comp)
47147a984708SDavid Chisnall{
47157a984708SDavid Chisnall    __make_heap<_Compare>(__first, __middle, __comp);
47167a984708SDavid Chisnall    typename iterator_traits<_RandomAccessIterator>::difference_type __len = __middle - __first;
47177a984708SDavid Chisnall    for (_RandomAccessIterator __i = __middle; __i != __last; ++__i)
47187a984708SDavid Chisnall    {
47197a984708SDavid Chisnall        if (__comp(*__i, *__first))
47207a984708SDavid Chisnall        {
47217a984708SDavid Chisnall            swap(*__i, *__first);
47227a984708SDavid Chisnall            __push_heap_front<_Compare>(__first, __middle, __comp, __len);
47237a984708SDavid Chisnall        }
47247a984708SDavid Chisnall    }
47257a984708SDavid Chisnall    __sort_heap<_Compare>(__first, __middle, __comp);
47267a984708SDavid Chisnall}
47277a984708SDavid Chisnall
47287a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare>
47297a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
47307a984708SDavid Chisnallvoid
47317a984708SDavid Chisnallpartial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last,
47327a984708SDavid Chisnall             _Compare __comp)
47337a984708SDavid Chisnall{
47347a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2
47357a984708SDavid Chisnall    typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
47367a984708SDavid Chisnall    __debug_less<_Compare> __c(__comp);
47377a984708SDavid Chisnall    __partial_sort<_Comp_ref>(__first, __middle, __last, __c);
47387a984708SDavid Chisnall#else  // _LIBCPP_DEBUG2
47397a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
47407a984708SDavid Chisnall    __partial_sort<_Comp_ref>(__first, __middle, __last, __comp);
47417a984708SDavid Chisnall#endif  // _LIBCPP_DEBUG2
47427a984708SDavid Chisnall}
47437a984708SDavid Chisnall
47447a984708SDavid Chisnalltemplate <class _RandomAccessIterator>
47457a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
47467a984708SDavid Chisnallvoid
47477a984708SDavid Chisnallpartial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last)
47487a984708SDavid Chisnall{
47497a984708SDavid Chisnall    _VSTD::partial_sort(__first, __middle, __last,
47507a984708SDavid Chisnall                       __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
47517a984708SDavid Chisnall}
47527a984708SDavid Chisnall
47537a984708SDavid Chisnall// partial_sort_copy
47547a984708SDavid Chisnall
47557a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator, class _RandomAccessIterator>
47567a984708SDavid Chisnall_RandomAccessIterator
47577a984708SDavid Chisnall__partial_sort_copy(_InputIterator __first, _InputIterator __last,
47587a984708SDavid Chisnall                    _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp)
47597a984708SDavid Chisnall{
47607a984708SDavid Chisnall    _RandomAccessIterator __r = __result_first;
47617a984708SDavid Chisnall    if (__r != __result_last)
47627a984708SDavid Chisnall    {
47637a984708SDavid Chisnall        typename iterator_traits<_RandomAccessIterator>::difference_type __len = 0;
47647a984708SDavid Chisnall        for (; __first != __last && __r != __result_last; ++__first, ++__r, ++__len)
47657a984708SDavid Chisnall            *__r = *__first;
47667a984708SDavid Chisnall        __make_heap<_Compare>(__result_first, __r, __comp);
47677a984708SDavid Chisnall        for (; __first != __last; ++__first)
47687a984708SDavid Chisnall            if (__comp(*__first, *__result_first))
47697a984708SDavid Chisnall            {
47707a984708SDavid Chisnall                *__result_first = *__first;
47717a984708SDavid Chisnall                __push_heap_front<_Compare>(__result_first, __r, __comp, __len);
47727a984708SDavid Chisnall            }
47737a984708SDavid Chisnall        __sort_heap<_Compare>(__result_first, __r, __comp);
47747a984708SDavid Chisnall    }
47757a984708SDavid Chisnall    return __r;
47767a984708SDavid Chisnall}
47777a984708SDavid Chisnall
47787a984708SDavid Chisnalltemplate <class _InputIterator, class _RandomAccessIterator, class _Compare>
47797a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
47807a984708SDavid Chisnall_RandomAccessIterator
47817a984708SDavid Chisnallpartial_sort_copy(_InputIterator __first, _InputIterator __last,
47827a984708SDavid Chisnall                  _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp)
47837a984708SDavid Chisnall{
47847a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2
47857a984708SDavid Chisnall    typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
47867a984708SDavid Chisnall    __debug_less<_Compare> __c(__comp);
47877a984708SDavid Chisnall    return __partial_sort_copy<_Comp_ref>(__first, __last, __result_first, __result_last, __c);
47887a984708SDavid Chisnall#else  // _LIBCPP_DEBUG2
47897a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
47907a984708SDavid Chisnall    return __partial_sort_copy<_Comp_ref>(__first, __last, __result_first, __result_last, __comp);
47917a984708SDavid Chisnall#endif  // _LIBCPP_DEBUG2
47927a984708SDavid Chisnall}
47937a984708SDavid Chisnall
47947a984708SDavid Chisnalltemplate <class _InputIterator, class _RandomAccessIterator>
47957a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
47967a984708SDavid Chisnall_RandomAccessIterator
47977a984708SDavid Chisnallpartial_sort_copy(_InputIterator __first, _InputIterator __last,
47987a984708SDavid Chisnall                  _RandomAccessIterator __result_first, _RandomAccessIterator __result_last)
47997a984708SDavid Chisnall{
48007a984708SDavid Chisnall    return _VSTD::partial_sort_copy(__first, __last, __result_first, __result_last,
48017a984708SDavid Chisnall                                   __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
48027a984708SDavid Chisnall}
48037a984708SDavid Chisnall
48047a984708SDavid Chisnall// nth_element
48057a984708SDavid Chisnall
48067a984708SDavid Chisnalltemplate <class _Compare, class _RandomAccessIterator>
48077a984708SDavid Chisnallvoid
48087a984708SDavid Chisnall__nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp)
48097a984708SDavid Chisnall{
48107a984708SDavid Chisnall    // _Compare is known to be a reference type
48117a984708SDavid Chisnall    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
48127a984708SDavid Chisnall    const difference_type __limit = 7;
48137a984708SDavid Chisnall    while (true)
48147a984708SDavid Chisnall    {
48157a984708SDavid Chisnall    __restart:
481694e3ee44SDavid Chisnall        if (__nth == __last)
481794e3ee44SDavid Chisnall            return;
48187a984708SDavid Chisnall        difference_type __len = __last - __first;
48197a984708SDavid Chisnall        switch (__len)
48207a984708SDavid Chisnall        {
48217a984708SDavid Chisnall        case 0:
48227a984708SDavid Chisnall        case 1:
48237a984708SDavid Chisnall            return;
48247a984708SDavid Chisnall        case 2:
48257a984708SDavid Chisnall            if (__comp(*--__last, *__first))
48267a984708SDavid Chisnall                swap(*__first, *__last);
48277a984708SDavid Chisnall            return;
48287a984708SDavid Chisnall        case 3:
48297a984708SDavid Chisnall            {
48307a984708SDavid Chisnall            _RandomAccessIterator __m = __first;
48317a984708SDavid Chisnall            _VSTD::__sort3<_Compare>(__first, ++__m, --__last, __comp);
48327a984708SDavid Chisnall            return;
48337a984708SDavid Chisnall            }
48347a984708SDavid Chisnall        }
48357a984708SDavid Chisnall        if (__len <= __limit)
48367a984708SDavid Chisnall        {
48377a984708SDavid Chisnall            __selection_sort<_Compare>(__first, __last, __comp);
48387a984708SDavid Chisnall            return;
48397a984708SDavid Chisnall        }
48407a984708SDavid Chisnall        // __len > __limit >= 3
48417a984708SDavid Chisnall        _RandomAccessIterator __m = __first + __len/2;
48427a984708SDavid Chisnall        _RandomAccessIterator __lm1 = __last;
48437a984708SDavid Chisnall        unsigned __n_swaps = _VSTD::__sort3<_Compare>(__first, __m, --__lm1, __comp);
48447a984708SDavid Chisnall        // *__m is median
48457a984708SDavid Chisnall        // partition [__first, __m) < *__m and *__m <= [__m, __last)
48467a984708SDavid Chisnall        // (this inhibits tossing elements equivalent to __m around unnecessarily)
48477a984708SDavid Chisnall        _RandomAccessIterator __i = __first;
48487a984708SDavid Chisnall        _RandomAccessIterator __j = __lm1;
48497a984708SDavid Chisnall        // j points beyond range to be tested, *__lm1 is known to be <= *__m
48507a984708SDavid Chisnall        // The search going up is known to be guarded but the search coming down isn't.
48517a984708SDavid Chisnall        // Prime the downward search with a guard.
48527a984708SDavid Chisnall        if (!__comp(*__i, *__m))  // if *__first == *__m
48537a984708SDavid Chisnall        {
48547a984708SDavid Chisnall            // *__first == *__m, *__first doesn't go in first part
48557a984708SDavid Chisnall            // manually guard downward moving __j against __i
48567a984708SDavid Chisnall            while (true)
48577a984708SDavid Chisnall            {
48587a984708SDavid Chisnall                if (__i == --__j)
48597a984708SDavid Chisnall                {
48607a984708SDavid Chisnall                    // *__first == *__m, *__m <= all other elements
48617a984708SDavid Chisnall                    // Parition instead into [__first, __i) == *__first and *__first < [__i, __last)
48627a984708SDavid Chisnall                    ++__i;  // __first + 1
48637a984708SDavid Chisnall                    __j = __last;
48647a984708SDavid Chisnall                    if (!__comp(*__first, *--__j))  // we need a guard if *__first == *(__last-1)
48657a984708SDavid Chisnall                    {
48667a984708SDavid Chisnall                        while (true)
48677a984708SDavid Chisnall                        {
48687a984708SDavid Chisnall                            if (__i == __j)
48697a984708SDavid Chisnall                                return;  // [__first, __last) all equivalent elements
48707a984708SDavid Chisnall                            if (__comp(*__first, *__i))
48717a984708SDavid Chisnall                            {
48727a984708SDavid Chisnall                                swap(*__i, *__j);
48737a984708SDavid Chisnall                                ++__n_swaps;
48747a984708SDavid Chisnall                                ++__i;
48757a984708SDavid Chisnall                                break;
48767a984708SDavid Chisnall                            }
48777a984708SDavid Chisnall                            ++__i;
48787a984708SDavid Chisnall                        }
48797a984708SDavid Chisnall                    }
48807a984708SDavid Chisnall                    // [__first, __i) == *__first and *__first < [__j, __last) and __j == __last - 1
48817a984708SDavid Chisnall                    if (__i == __j)
48827a984708SDavid Chisnall                        return;
48837a984708SDavid Chisnall                    while (true)
48847a984708SDavid Chisnall                    {
48857a984708SDavid Chisnall                        while (!__comp(*__first, *__i))
48867a984708SDavid Chisnall                            ++__i;
48877a984708SDavid Chisnall                        while (__comp(*__first, *--__j))
48887a984708SDavid Chisnall                            ;
48897a984708SDavid Chisnall                        if (__i >= __j)
48907a984708SDavid Chisnall                            break;
48917a984708SDavid Chisnall                        swap(*__i, *__j);
48927a984708SDavid Chisnall                        ++__n_swaps;
48937a984708SDavid Chisnall                        ++__i;
48947a984708SDavid Chisnall                    }
48957a984708SDavid Chisnall                    // [__first, __i) == *__first and *__first < [__i, __last)
48967a984708SDavid Chisnall                    // The first part is sorted,
48977a984708SDavid Chisnall                    if (__nth < __i)
48987a984708SDavid Chisnall                        return;
48997a984708SDavid Chisnall                    // __nth_element the secod part
49007a984708SDavid Chisnall                    // __nth_element<_Compare>(__i, __nth, __last, __comp);
49017a984708SDavid Chisnall                    __first = __i;
49027a984708SDavid Chisnall                    goto __restart;
49037a984708SDavid Chisnall                }
49047a984708SDavid Chisnall                if (__comp(*__j, *__m))
49057a984708SDavid Chisnall                {
49067a984708SDavid Chisnall                    swap(*__i, *__j);
49077a984708SDavid Chisnall                    ++__n_swaps;
49087a984708SDavid Chisnall                    break;  // found guard for downward moving __j, now use unguarded partition
49097a984708SDavid Chisnall                }
49107a984708SDavid Chisnall            }
49117a984708SDavid Chisnall        }
49127a984708SDavid Chisnall        ++__i;
49137a984708SDavid Chisnall        // j points beyond range to be tested, *__lm1 is known to be <= *__m
49147a984708SDavid Chisnall        // if not yet partitioned...
49157a984708SDavid Chisnall        if (__i < __j)
49167a984708SDavid Chisnall        {
49177a984708SDavid Chisnall            // known that *(__i - 1) < *__m
49187a984708SDavid Chisnall            while (true)
49197a984708SDavid Chisnall            {
49207a984708SDavid Chisnall                // __m still guards upward moving __i
49217a984708SDavid Chisnall                while (__comp(*__i, *__m))
49227a984708SDavid Chisnall                    ++__i;
49237a984708SDavid Chisnall                // It is now known that a guard exists for downward moving __j
49247a984708SDavid Chisnall                while (!__comp(*--__j, *__m))
49257a984708SDavid Chisnall                    ;
49267a984708SDavid Chisnall                if (__i >= __j)
49277a984708SDavid Chisnall                    break;
49287a984708SDavid Chisnall                swap(*__i, *__j);
49297a984708SDavid Chisnall                ++__n_swaps;
49307a984708SDavid Chisnall                // It is known that __m != __j
49317a984708SDavid Chisnall                // If __m just moved, follow it
49327a984708SDavid Chisnall                if (__m == __i)
49337a984708SDavid Chisnall                    __m = __j;
49347a984708SDavid Chisnall                ++__i;
49357a984708SDavid Chisnall            }
49367a984708SDavid Chisnall        }
49377a984708SDavid Chisnall        // [__first, __i) < *__m and *__m <= [__i, __last)
49387a984708SDavid Chisnall        if (__i != __m && __comp(*__m, *__i))
49397a984708SDavid Chisnall        {
49407a984708SDavid Chisnall            swap(*__i, *__m);
49417a984708SDavid Chisnall            ++__n_swaps;
49427a984708SDavid Chisnall        }
49437a984708SDavid Chisnall        // [__first, __i) < *__i and *__i <= [__i+1, __last)
49447a984708SDavid Chisnall        if (__nth == __i)
49457a984708SDavid Chisnall            return;
49467a984708SDavid Chisnall        if (__n_swaps == 0)
49477a984708SDavid Chisnall        {
49487a984708SDavid Chisnall            // We were given a perfectly partitioned sequence.  Coincidence?
49497a984708SDavid Chisnall            if (__nth < __i)
49507a984708SDavid Chisnall            {
49517a984708SDavid Chisnall                // Check for [__first, __i) already sorted
49527a984708SDavid Chisnall                __j = __m = __first;
49537a984708SDavid Chisnall                while (++__j != __i)
49547a984708SDavid Chisnall                {
49557a984708SDavid Chisnall                    if (__comp(*__j, *__m))
49567a984708SDavid Chisnall                        // not yet sorted, so sort
49577a984708SDavid Chisnall                        goto not_sorted;
49587a984708SDavid Chisnall                    __m = __j;
49597a984708SDavid Chisnall                }
49607a984708SDavid Chisnall                // [__first, __i) sorted
49617a984708SDavid Chisnall                return;
49627a984708SDavid Chisnall            }
49637a984708SDavid Chisnall            else
49647a984708SDavid Chisnall            {
49657a984708SDavid Chisnall                // Check for [__i, __last) already sorted
49667a984708SDavid Chisnall                __j = __m = __i;
49677a984708SDavid Chisnall                while (++__j != __last)
49687a984708SDavid Chisnall                {
49697a984708SDavid Chisnall                    if (__comp(*__j, *__m))
49707a984708SDavid Chisnall                        // not yet sorted, so sort
49717a984708SDavid Chisnall                        goto not_sorted;
49727a984708SDavid Chisnall                    __m = __j;
49737a984708SDavid Chisnall                }
49747a984708SDavid Chisnall                // [__i, __last) sorted
49757a984708SDavid Chisnall                return;
49767a984708SDavid Chisnall            }
49777a984708SDavid Chisnall        }
49787a984708SDavid Chisnallnot_sorted:
49797a984708SDavid Chisnall        // __nth_element on range containing __nth
49807a984708SDavid Chisnall        if (__nth < __i)
49817a984708SDavid Chisnall        {
49827a984708SDavid Chisnall            // __nth_element<_Compare>(__first, __nth, __i, __comp);
49837a984708SDavid Chisnall            __last = __i;
49847a984708SDavid Chisnall        }
49857a984708SDavid Chisnall        else
49867a984708SDavid Chisnall        {
49877a984708SDavid Chisnall            // __nth_element<_Compare>(__i+1, __nth, __last, __comp);
49887a984708SDavid Chisnall            __first = ++__i;
49897a984708SDavid Chisnall        }
49907a984708SDavid Chisnall    }
49917a984708SDavid Chisnall}
49927a984708SDavid Chisnall
49937a984708SDavid Chisnalltemplate <class _RandomAccessIterator, class _Compare>
49947a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
49957a984708SDavid Chisnallvoid
49967a984708SDavid Chisnallnth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp)
49977a984708SDavid Chisnall{
49987a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2
49997a984708SDavid Chisnall    typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
50007a984708SDavid Chisnall    __debug_less<_Compare> __c(__comp);
50017a984708SDavid Chisnall    __nth_element<_Comp_ref>(__first, __nth, __last, __c);
50027a984708SDavid Chisnall#else  // _LIBCPP_DEBUG2
50037a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
50047a984708SDavid Chisnall    __nth_element<_Comp_ref>(__first, __nth, __last, __comp);
50057a984708SDavid Chisnall#endif  // _LIBCPP_DEBUG2
50067a984708SDavid Chisnall}
50077a984708SDavid Chisnall
50087a984708SDavid Chisnalltemplate <class _RandomAccessIterator>
50097a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
50107a984708SDavid Chisnallvoid
50117a984708SDavid Chisnallnth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last)
50127a984708SDavid Chisnall{
50137a984708SDavid Chisnall    _VSTD::nth_element(__first, __nth, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
50147a984708SDavid Chisnall}
50157a984708SDavid Chisnall
50167a984708SDavid Chisnall// includes
50177a984708SDavid Chisnall
50187a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2>
50197a984708SDavid Chisnallbool
50207a984708SDavid Chisnall__includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2,
50217a984708SDavid Chisnall           _Compare __comp)
50227a984708SDavid Chisnall{
50237a984708SDavid Chisnall    for (; __first2 != __last2; ++__first1)
50247a984708SDavid Chisnall    {
50257a984708SDavid Chisnall        if (__first1 == __last1 || __comp(*__first2, *__first1))
50267a984708SDavid Chisnall            return false;
50277a984708SDavid Chisnall        if (!__comp(*__first1, *__first2))
50287a984708SDavid Chisnall            ++__first2;
50297a984708SDavid Chisnall    }
50307a984708SDavid Chisnall    return true;
50317a984708SDavid Chisnall}
50327a984708SDavid Chisnall
50337a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _Compare>
50347a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
50357a984708SDavid Chisnallbool
50367a984708SDavid Chisnallincludes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2,
50377a984708SDavid Chisnall         _Compare __comp)
50387a984708SDavid Chisnall{
50397a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2
50407a984708SDavid Chisnall    typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
50417a984708SDavid Chisnall    __debug_less<_Compare> __c(__comp);
50427a984708SDavid Chisnall    return __includes<_Comp_ref>(__first1, __last1, __first2, __last2, __c);
50437a984708SDavid Chisnall#else  // _LIBCPP_DEBUG2
50447a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
50457a984708SDavid Chisnall    return __includes<_Comp_ref>(__first1, __last1, __first2, __last2, __comp);
50467a984708SDavid Chisnall#endif  // _LIBCPP_DEBUG2
50477a984708SDavid Chisnall}
50487a984708SDavid Chisnall
50497a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2>
50507a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
50517a984708SDavid Chisnallbool
50527a984708SDavid Chisnallincludes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2)
50537a984708SDavid Chisnall{
50547a984708SDavid Chisnall    return _VSTD::includes(__first1, __last1, __first2, __last2,
50557a984708SDavid Chisnall                          __less<typename iterator_traits<_InputIterator1>::value_type,
50567a984708SDavid Chisnall                                 typename iterator_traits<_InputIterator2>::value_type>());
50577a984708SDavid Chisnall}
50587a984708SDavid Chisnall
50597a984708SDavid Chisnall// set_union
50607a984708SDavid Chisnall
50617a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
50627a984708SDavid Chisnall_OutputIterator
50637a984708SDavid Chisnall__set_union(_InputIterator1 __first1, _InputIterator1 __last1,
50647a984708SDavid Chisnall            _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
50657a984708SDavid Chisnall{
50667a984708SDavid Chisnall    for (; __first1 != __last1; ++__result)
50677a984708SDavid Chisnall    {
50687a984708SDavid Chisnall        if (__first2 == __last2)
50697a984708SDavid Chisnall            return _VSTD::copy(__first1, __last1, __result);
50707a984708SDavid Chisnall        if (__comp(*__first2, *__first1))
50717a984708SDavid Chisnall        {
50727a984708SDavid Chisnall            *__result = *__first2;
50737a984708SDavid Chisnall            ++__first2;
50747a984708SDavid Chisnall        }
50757a984708SDavid Chisnall        else
50767a984708SDavid Chisnall        {
50777a984708SDavid Chisnall            *__result = *__first1;
50787a984708SDavid Chisnall            if (!__comp(*__first1, *__first2))
50797a984708SDavid Chisnall                ++__first2;
50807a984708SDavid Chisnall            ++__first1;
50817a984708SDavid Chisnall        }
50827a984708SDavid Chisnall    }
50837a984708SDavid Chisnall    return _VSTD::copy(__first2, __last2, __result);
50847a984708SDavid Chisnall}
50857a984708SDavid Chisnall
50867a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
50877a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
50887a984708SDavid Chisnall_OutputIterator
50897a984708SDavid Chisnallset_union(_InputIterator1 __first1, _InputIterator1 __last1,
50907a984708SDavid Chisnall          _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
50917a984708SDavid Chisnall{
50927a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2
50937a984708SDavid Chisnall    typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
50947a984708SDavid Chisnall    __debug_less<_Compare> __c(__comp);
50957a984708SDavid Chisnall    return __set_union<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c);
50967a984708SDavid Chisnall#else  // _LIBCPP_DEBUG2
50977a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
50987a984708SDavid Chisnall    return __set_union<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
50997a984708SDavid Chisnall#endif  // _LIBCPP_DEBUG2
51007a984708SDavid Chisnall}
51017a984708SDavid Chisnall
51027a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator>
51037a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
51047a984708SDavid Chisnall_OutputIterator
51057a984708SDavid Chisnallset_union(_InputIterator1 __first1, _InputIterator1 __last1,
51067a984708SDavid Chisnall          _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
51077a984708SDavid Chisnall{
51087a984708SDavid Chisnall    return _VSTD::set_union(__first1, __last1, __first2, __last2, __result,
51097a984708SDavid Chisnall                          __less<typename iterator_traits<_InputIterator1>::value_type,
51107a984708SDavid Chisnall                                 typename iterator_traits<_InputIterator2>::value_type>());
51117a984708SDavid Chisnall}
51127a984708SDavid Chisnall
51137a984708SDavid Chisnall// set_intersection
51147a984708SDavid Chisnall
51157a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
51167a984708SDavid Chisnall_OutputIterator
51177a984708SDavid Chisnall__set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
51187a984708SDavid Chisnall                   _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
51197a984708SDavid Chisnall{
51207a984708SDavid Chisnall    while (__first1 != __last1 && __first2 != __last2)
51217a984708SDavid Chisnall    {
51227a984708SDavid Chisnall        if (__comp(*__first1, *__first2))
51237a984708SDavid Chisnall            ++__first1;
51247a984708SDavid Chisnall        else
51257a984708SDavid Chisnall        {
51267a984708SDavid Chisnall            if (!__comp(*__first2, *__first1))
51277a984708SDavid Chisnall            {
51287a984708SDavid Chisnall                *__result = *__first1;
51297a984708SDavid Chisnall                ++__result;
51307a984708SDavid Chisnall                ++__first1;
51317a984708SDavid Chisnall            }
51327a984708SDavid Chisnall            ++__first2;
51337a984708SDavid Chisnall        }
51347a984708SDavid Chisnall    }
51357a984708SDavid Chisnall    return __result;
51367a984708SDavid Chisnall}
51377a984708SDavid Chisnall
51387a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
51397a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
51407a984708SDavid Chisnall_OutputIterator
51417a984708SDavid Chisnallset_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
51427a984708SDavid Chisnall                 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
51437a984708SDavid Chisnall{
51447a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2
51457a984708SDavid Chisnall    typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
51467a984708SDavid Chisnall    __debug_less<_Compare> __c(__comp);
51477a984708SDavid Chisnall    return __set_intersection<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c);
51487a984708SDavid Chisnall#else  // _LIBCPP_DEBUG2
51497a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
51507a984708SDavid Chisnall    return __set_intersection<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
51517a984708SDavid Chisnall#endif  // _LIBCPP_DEBUG2
51527a984708SDavid Chisnall}
51537a984708SDavid Chisnall
51547a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator>
51557a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
51567a984708SDavid Chisnall_OutputIterator
51577a984708SDavid Chisnallset_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
51587a984708SDavid Chisnall                 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
51597a984708SDavid Chisnall{
51607a984708SDavid Chisnall    return _VSTD::set_intersection(__first1, __last1, __first2, __last2, __result,
51617a984708SDavid Chisnall                                  __less<typename iterator_traits<_InputIterator1>::value_type,
51627a984708SDavid Chisnall                                         typename iterator_traits<_InputIterator2>::value_type>());
51637a984708SDavid Chisnall}
51647a984708SDavid Chisnall
51657a984708SDavid Chisnall// set_difference
51667a984708SDavid Chisnall
51677a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
51687a984708SDavid Chisnall_OutputIterator
51697a984708SDavid Chisnall__set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
51707a984708SDavid Chisnall                 _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
51717a984708SDavid Chisnall{
51727a984708SDavid Chisnall    while (__first1 != __last1)
51737a984708SDavid Chisnall    {
51747a984708SDavid Chisnall        if (__first2 == __last2)
51757a984708SDavid Chisnall            return _VSTD::copy(__first1, __last1, __result);
51767a984708SDavid Chisnall        if (__comp(*__first1, *__first2))
51777a984708SDavid Chisnall        {
51787a984708SDavid Chisnall            *__result = *__first1;
51797a984708SDavid Chisnall            ++__result;
51807a984708SDavid Chisnall            ++__first1;
51817a984708SDavid Chisnall        }
51827a984708SDavid Chisnall        else
51837a984708SDavid Chisnall        {
51847a984708SDavid Chisnall            if (!__comp(*__first2, *__first1))
51857a984708SDavid Chisnall                ++__first1;
51867a984708SDavid Chisnall            ++__first2;
51877a984708SDavid Chisnall        }
51887a984708SDavid Chisnall    }
51897a984708SDavid Chisnall    return __result;
51907a984708SDavid Chisnall}
51917a984708SDavid Chisnall
51927a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
51937a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
51947a984708SDavid Chisnall_OutputIterator
51957a984708SDavid Chisnallset_difference(_InputIterator1 __first1, _InputIterator1 __last1,
51967a984708SDavid Chisnall               _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
51977a984708SDavid Chisnall{
51987a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2
51997a984708SDavid Chisnall    typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
52007a984708SDavid Chisnall    __debug_less<_Compare> __c(__comp);
52017a984708SDavid Chisnall    return __set_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c);
52027a984708SDavid Chisnall#else  // _LIBCPP_DEBUG2
52037a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
52047a984708SDavid Chisnall    return __set_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
52057a984708SDavid Chisnall#endif  // _LIBCPP_DEBUG2
52067a984708SDavid Chisnall}
52077a984708SDavid Chisnall
52087a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator>
52097a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
52107a984708SDavid Chisnall_OutputIterator
52117a984708SDavid Chisnallset_difference(_InputIterator1 __first1, _InputIterator1 __last1,
52127a984708SDavid Chisnall               _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
52137a984708SDavid Chisnall{
52147a984708SDavid Chisnall    return _VSTD::set_difference(__first1, __last1, __first2, __last2, __result,
52157a984708SDavid Chisnall                                __less<typename iterator_traits<_InputIterator1>::value_type,
52167a984708SDavid Chisnall                                       typename iterator_traits<_InputIterator2>::value_type>());
52177a984708SDavid Chisnall}
52187a984708SDavid Chisnall
52197a984708SDavid Chisnall// set_symmetric_difference
52207a984708SDavid Chisnall
52217a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
52227a984708SDavid Chisnall_OutputIterator
52237a984708SDavid Chisnall__set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
52247a984708SDavid Chisnall                           _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
52257a984708SDavid Chisnall{
52267a984708SDavid Chisnall    while (__first1 != __last1)
52277a984708SDavid Chisnall    {
52287a984708SDavid Chisnall        if (__first2 == __last2)
52297a984708SDavid Chisnall            return _VSTD::copy(__first1, __last1, __result);
52307a984708SDavid Chisnall        if (__comp(*__first1, *__first2))
52317a984708SDavid Chisnall        {
52327a984708SDavid Chisnall            *__result = *__first1;
52337a984708SDavid Chisnall            ++__result;
52347a984708SDavid Chisnall            ++__first1;
52357a984708SDavid Chisnall        }
52367a984708SDavid Chisnall        else
52377a984708SDavid Chisnall        {
52387a984708SDavid Chisnall            if (__comp(*__first2, *__first1))
52397a984708SDavid Chisnall            {
52407a984708SDavid Chisnall                *__result = *__first2;
52417a984708SDavid Chisnall                ++__result;
52427a984708SDavid Chisnall            }
52437a984708SDavid Chisnall            else
52447a984708SDavid Chisnall                ++__first1;
52457a984708SDavid Chisnall            ++__first2;
52467a984708SDavid Chisnall        }
52477a984708SDavid Chisnall    }
52487a984708SDavid Chisnall    return _VSTD::copy(__first2, __last2, __result);
52497a984708SDavid Chisnall}
52507a984708SDavid Chisnall
52517a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
52527a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
52537a984708SDavid Chisnall_OutputIterator
52547a984708SDavid Chisnallset_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
52557a984708SDavid Chisnall                         _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
52567a984708SDavid Chisnall{
52577a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2
52587a984708SDavid Chisnall    typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
52597a984708SDavid Chisnall    __debug_less<_Compare> __c(__comp);
52607a984708SDavid Chisnall    return __set_symmetric_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c);
52617a984708SDavid Chisnall#else  // _LIBCPP_DEBUG2
52627a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
52637a984708SDavid Chisnall    return __set_symmetric_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
52647a984708SDavid Chisnall#endif  // _LIBCPP_DEBUG2
52657a984708SDavid Chisnall}
52667a984708SDavid Chisnall
52677a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _OutputIterator>
52687a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
52697a984708SDavid Chisnall_OutputIterator
52707a984708SDavid Chisnallset_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
52717a984708SDavid Chisnall                         _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
52727a984708SDavid Chisnall{
52737a984708SDavid Chisnall    return _VSTD::set_symmetric_difference(__first1, __last1, __first2, __last2, __result,
52747a984708SDavid Chisnall                                          __less<typename iterator_traits<_InputIterator1>::value_type,
52757a984708SDavid Chisnall                                                 typename iterator_traits<_InputIterator2>::value_type>());
52767a984708SDavid Chisnall}
52777a984708SDavid Chisnall
52787a984708SDavid Chisnall// lexicographical_compare
52797a984708SDavid Chisnall
52807a984708SDavid Chisnalltemplate <class _Compare, class _InputIterator1, class _InputIterator2>
52817a984708SDavid Chisnallbool
52827a984708SDavid Chisnall__lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
52837a984708SDavid Chisnall                          _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp)
52847a984708SDavid Chisnall{
52857a984708SDavid Chisnall    for (; __first2 != __last2; ++__first1, ++__first2)
52867a984708SDavid Chisnall    {
52877a984708SDavid Chisnall        if (__first1 == __last1 || __comp(*__first1, *__first2))
52887a984708SDavid Chisnall            return true;
52897a984708SDavid Chisnall        if (__comp(*__first2, *__first1))
52907a984708SDavid Chisnall            return false;
52917a984708SDavid Chisnall    }
52927a984708SDavid Chisnall    return false;
52937a984708SDavid Chisnall}
52947a984708SDavid Chisnall
52957a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2, class _Compare>
52967a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
52977a984708SDavid Chisnallbool
52987a984708SDavid Chisnalllexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
52997a984708SDavid Chisnall                        _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp)
53007a984708SDavid Chisnall{
53017a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2
53027a984708SDavid Chisnall    typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
53037a984708SDavid Chisnall    __debug_less<_Compare> __c(__comp);
53047a984708SDavid Chisnall    return __lexicographical_compare<_Comp_ref>(__first1, __last1, __first2, __last2, __c);
53057a984708SDavid Chisnall#else  // _LIBCPP_DEBUG2
53067a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
53077a984708SDavid Chisnall    return __lexicographical_compare<_Comp_ref>(__first1, __last1, __first2, __last2, __comp);
53087a984708SDavid Chisnall#endif  // _LIBCPP_DEBUG2
53097a984708SDavid Chisnall}
53107a984708SDavid Chisnall
53117a984708SDavid Chisnalltemplate <class _InputIterator1, class _InputIterator2>
53127a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
53137a984708SDavid Chisnallbool
53147a984708SDavid Chisnalllexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
53157a984708SDavid Chisnall                        _InputIterator2 __first2, _InputIterator2 __last2)
53167a984708SDavid Chisnall{
53177a984708SDavid Chisnall    return _VSTD::lexicographical_compare(__first1, __last1, __first2, __last2,
53187a984708SDavid Chisnall                                         __less<typename iterator_traits<_InputIterator1>::value_type,
53197a984708SDavid Chisnall                                                typename iterator_traits<_InputIterator2>::value_type>());
53207a984708SDavid Chisnall}
53217a984708SDavid Chisnall
53227a984708SDavid Chisnall// next_permutation
53237a984708SDavid Chisnall
53247a984708SDavid Chisnalltemplate <class _Compare, class _BidirectionalIterator>
53257a984708SDavid Chisnallbool
53267a984708SDavid Chisnall__next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
53277a984708SDavid Chisnall{
53287a984708SDavid Chisnall    _BidirectionalIterator __i = __last;
53297a984708SDavid Chisnall    if (__first == __last || __first == --__i)
53307a984708SDavid Chisnall        return false;
53317a984708SDavid Chisnall    while (true)
53327a984708SDavid Chisnall    {
53337a984708SDavid Chisnall        _BidirectionalIterator __ip1 = __i;
53347a984708SDavid Chisnall        if (__comp(*--__i, *__ip1))
53357a984708SDavid Chisnall        {
53367a984708SDavid Chisnall            _BidirectionalIterator __j = __last;
53377a984708SDavid Chisnall            while (!__comp(*__i, *--__j))
53387a984708SDavid Chisnall                ;
53397a984708SDavid Chisnall            swap(*__i, *__j);
53407a984708SDavid Chisnall            _VSTD::reverse(__ip1, __last);
53417a984708SDavid Chisnall            return true;
53427a984708SDavid Chisnall        }
53437a984708SDavid Chisnall        if (__i == __first)
53447a984708SDavid Chisnall        {
53457a984708SDavid Chisnall            _VSTD::reverse(__first, __last);
53467a984708SDavid Chisnall            return false;
53477a984708SDavid Chisnall        }
53487a984708SDavid Chisnall    }
53497a984708SDavid Chisnall}
53507a984708SDavid Chisnall
53517a984708SDavid Chisnalltemplate <class _BidirectionalIterator, class _Compare>
53527a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
53537a984708SDavid Chisnallbool
53547a984708SDavid Chisnallnext_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
53557a984708SDavid Chisnall{
53567a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2
53577a984708SDavid Chisnall    typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
53587a984708SDavid Chisnall    __debug_less<_Compare> __c(__comp);
53597a984708SDavid Chisnall    return __next_permutation<_Comp_ref>(__first, __last, __c);
53607a984708SDavid Chisnall#else  // _LIBCPP_DEBUG2
53617a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
53627a984708SDavid Chisnall    return __next_permutation<_Comp_ref>(__first, __last, __comp);
53637a984708SDavid Chisnall#endif  // _LIBCPP_DEBUG2
53647a984708SDavid Chisnall}
53657a984708SDavid Chisnall
53667a984708SDavid Chisnalltemplate <class _BidirectionalIterator>
53677a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
53687a984708SDavid Chisnallbool
53697a984708SDavid Chisnallnext_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
53707a984708SDavid Chisnall{
53717a984708SDavid Chisnall    return _VSTD::next_permutation(__first, __last,
53727a984708SDavid Chisnall                                  __less<typename iterator_traits<_BidirectionalIterator>::value_type>());
53737a984708SDavid Chisnall}
53747a984708SDavid Chisnall
53757a984708SDavid Chisnall// prev_permutation
53767a984708SDavid Chisnall
53777a984708SDavid Chisnalltemplate <class _Compare, class _BidirectionalIterator>
53787a984708SDavid Chisnallbool
53797a984708SDavid Chisnall__prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
53807a984708SDavid Chisnall{
53817a984708SDavid Chisnall    _BidirectionalIterator __i = __last;
53827a984708SDavid Chisnall    if (__first == __last || __first == --__i)
53837a984708SDavid Chisnall        return false;
53847a984708SDavid Chisnall    while (true)
53857a984708SDavid Chisnall    {
53867a984708SDavid Chisnall        _BidirectionalIterator __ip1 = __i;
53877a984708SDavid Chisnall        if (__comp(*__ip1, *--__i))
53887a984708SDavid Chisnall        {
53897a984708SDavid Chisnall            _BidirectionalIterator __j = __last;
53907a984708SDavid Chisnall            while (!__comp(*--__j, *__i))
53917a984708SDavid Chisnall                ;
53927a984708SDavid Chisnall            swap(*__i, *__j);
53937a984708SDavid Chisnall            _VSTD::reverse(__ip1, __last);
53947a984708SDavid Chisnall            return true;
53957a984708SDavid Chisnall        }
53967a984708SDavid Chisnall        if (__i == __first)
53977a984708SDavid Chisnall        {
53987a984708SDavid Chisnall            _VSTD::reverse(__first, __last);
53997a984708SDavid Chisnall            return false;
54007a984708SDavid Chisnall        }
54017a984708SDavid Chisnall    }
54027a984708SDavid Chisnall}
54037a984708SDavid Chisnall
54047a984708SDavid Chisnalltemplate <class _BidirectionalIterator, class _Compare>
54057a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
54067a984708SDavid Chisnallbool
54077a984708SDavid Chisnallprev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
54087a984708SDavid Chisnall{
54097a984708SDavid Chisnall#ifdef _LIBCPP_DEBUG2
54107a984708SDavid Chisnall    typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
54117a984708SDavid Chisnall    __debug_less<_Compare> __c(__comp);
54127a984708SDavid Chisnall    return __prev_permutation<_Comp_ref>(__first, __last, __c);
54137a984708SDavid Chisnall#else  // _LIBCPP_DEBUG2
54147a984708SDavid Chisnall    typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
54157a984708SDavid Chisnall    return __prev_permutation<_Comp_ref>(__first, __last, __comp);
54167a984708SDavid Chisnall#endif  // _LIBCPP_DEBUG2
54177a984708SDavid Chisnall}
54187a984708SDavid Chisnall
54197a984708SDavid Chisnalltemplate <class _BidirectionalIterator>
54207a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
54217a984708SDavid Chisnallbool
54227a984708SDavid Chisnallprev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
54237a984708SDavid Chisnall{
54247a984708SDavid Chisnall    return _VSTD::prev_permutation(__first, __last,
54257a984708SDavid Chisnall                                  __less<typename iterator_traits<_BidirectionalIterator>::value_type>());
54267a984708SDavid Chisnall}
54277a984708SDavid Chisnall
54287a984708SDavid Chisnalltemplate <class _Tp>
54297a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
54307a984708SDavid Chisnalltypename enable_if
54317a984708SDavid Chisnall<
54327a984708SDavid Chisnall    is_integral<_Tp>::value,
54337a984708SDavid Chisnall    _Tp
54347a984708SDavid Chisnall>::type
54357a984708SDavid Chisnall__rotate_left(_Tp __t, _Tp __n = 1)
54367a984708SDavid Chisnall{
54377a984708SDavid Chisnall    const unsigned __bits = static_cast<unsigned>(sizeof(_Tp) * __CHAR_BIT__ - 1);
54387a984708SDavid Chisnall    __n &= __bits;
54397a984708SDavid Chisnall    return static_cast<_Tp>((__t << __n) | (static_cast<typename make_unsigned<_Tp>::type>(__t) >> (__bits - __n)));
54407a984708SDavid Chisnall}
54417a984708SDavid Chisnall
54427a984708SDavid Chisnalltemplate <class _Tp>
54437a984708SDavid Chisnallinline _LIBCPP_INLINE_VISIBILITY
54447a984708SDavid Chisnalltypename enable_if
54457a984708SDavid Chisnall<
54467a984708SDavid Chisnall    is_integral<_Tp>::value,
54477a984708SDavid Chisnall    _Tp
54487a984708SDavid Chisnall>::type
54497a984708SDavid Chisnall__rotate_right(_Tp __t, _Tp __n = 1)
54507a984708SDavid Chisnall{
54517a984708SDavid Chisnall    const unsigned __bits = static_cast<unsigned>(sizeof(_Tp) * __CHAR_BIT__ - 1);
54527a984708SDavid Chisnall    __n &= __bits;
54537a984708SDavid Chisnall    return static_cast<_Tp>((__t << (__bits - __n)) | (static_cast<typename make_unsigned<_Tp>::type>(__t) >> __n));
54547a984708SDavid Chisnall}
54557a984708SDavid Chisnall
54567a984708SDavid Chisnall_LIBCPP_END_NAMESPACE_STD
54577a984708SDavid Chisnall
54587a984708SDavid Chisnall#endif  // _LIBCPP_ALGORITHM
5459