wpkg test coverage results

Coverage test results of the Windows Packager by Made to Order Software Corporation.

LCOV - code coverage report
Current view: top level - usr/include/c++/4.6/bits - stl_algo.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 95 139 68.3 %
Date: 2013-06-17 Functions: 12 31 38.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : // Algorithm implementation -*- C++ -*-
       2             : 
       3             : // Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
       4             : // 2010, 2011
       5             : // Free Software Foundation, Inc.
       6             : //
       7             : // This file is part of the GNU ISO C++ Library.  This library is free
       8             : // software; you can redistribute it and/or modify it under the
       9             : // terms of the GNU General Public License as published by the
      10             : // Free Software Foundation; either version 3, or (at your option)
      11             : // any later version.
      12             : 
      13             : // This library is distributed in the hope that it will be useful,
      14             : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      15             : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      16             : // GNU General Public License for more details.
      17             : 
      18             : // Under Section 7 of GPL version 3, you are granted additional
      19             : // permissions described in the GCC Runtime Library Exception, version
      20             : // 3.1, as published by the Free Software Foundation.
      21             : 
      22             : // You should have received a copy of the GNU General Public License and
      23             : // a copy of the GCC Runtime Library Exception along with this program;
      24             : // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
      25             : // <http://www.gnu.org/licenses/>.
      26             : 
      27             : /*
      28             :  *
      29             :  * Copyright (c) 1994
      30             :  * Hewlett-Packard Company
      31             :  *
      32             :  * Permission to use, copy, modify, distribute and sell this software
      33             :  * and its documentation for any purpose is hereby granted without fee,
      34             :  * provided that the above copyright notice appear in all copies and
      35             :  * that both that copyright notice and this permission notice appear
      36             :  * in supporting documentation.  Hewlett-Packard Company makes no
      37             :  * representations about the suitability of this software for any
      38             :  * purpose.  It is provided "as is" without express or implied warranty.
      39             :  *
      40             :  *
      41             :  * Copyright (c) 1996
      42             :  * Silicon Graphics Computer Systems, Inc.
      43             :  *
      44             :  * Permission to use, copy, modify, distribute and sell this software
      45             :  * and its documentation for any purpose is hereby granted without fee,
      46             :  * provided that the above copyright notice appear in all copies and
      47             :  * that both that copyright notice and this permission notice appear
      48             :  * in supporting documentation.  Silicon Graphics makes no
      49             :  * representations about the suitability of this software for any
      50             :  * purpose.  It is provided "as is" without express or implied warranty.
      51             :  */
      52             : 
      53             : /** @file bits/stl_algo.h
      54             :  *  This is an internal header file, included by other library headers.
      55             :  *  Do not attempt to use it directly. @headername{algorithm}
      56             :  */
      57             : 
      58             : #ifndef _STL_ALGO_H
      59             : #define _STL_ALGO_H 1
      60             : 
      61             : #include <cstdlib>             // for rand
      62             : #include <bits/algorithmfwd.h>
      63             : #include <bits/stl_heap.h>
      64             : #include <bits/stl_tempbuf.h>  // for _Temporary_buffer
      65             : 
      66             : #ifdef __GXX_EXPERIMENTAL_CXX0X__
      67             : #include <random>     // for std::uniform_int_distribution
      68             : #include <functional> // for std::bind
      69             : #endif
      70             : 
      71             : // See concept_check.h for the __glibcxx_*_requires macros.
      72             : 
      73             : namespace std _GLIBCXX_VISIBILITY(default)
      74             : {
      75             : _GLIBCXX_BEGIN_NAMESPACE_VERSION
      76             : 
      77             :   /// Swaps the median value of *__a, *__b and *__c to *__a
      78             :   template<typename _Iterator>
      79             :     void
      80        1107 :     __move_median_first(_Iterator __a, _Iterator __b, _Iterator __c)
      81             :     {
      82             :       // concept requirements
      83             :       __glibcxx_function_requires(_LessThanComparableConcept<
      84             :             typename iterator_traits<_Iterator>::value_type>)
      85             : 
      86        1107 :       if (*__a < *__b)
      87             :         {
      88         330 :           if (*__b < *__c)
      89         207 :             std::iter_swap(__a, __b);
      90         123 :           else if (*__a < *__c)
      91         117 :             std::iter_swap(__a, __c);
      92             :         }
      93         777 :       else if (*__a < *__c)
      94        1107 :         return;
      95         751 :       else if (*__b < *__c)
      96         471 :         std::iter_swap(__a, __c);
      97             :       else
      98         280 :         std::iter_swap(__a, __b);
      99             :     }
     100             : 
     101             :   /// Swaps the median value of *__a, *__b and *__c under __comp to *__a
     102             :   template<typename _Iterator, typename _Compare>
     103             :     void
     104             :     __move_median_first(_Iterator __a, _Iterator __b, _Iterator __c,
     105             :                         _Compare __comp)
     106             :     {
     107             :       // concept requirements
     108             :       __glibcxx_function_requires(_BinaryFunctionConcept<_Compare, bool,
     109             :             typename iterator_traits<_Iterator>::value_type,
     110             :             typename iterator_traits<_Iterator>::value_type>)
     111             : 
     112             :       if (__comp(*__a, *__b))
     113             :         {
     114             :           if (__comp(*__b, *__c))
     115             :             std::iter_swap(__a, __b);
     116             :           else if (__comp(*__a, *__c))
     117             :             std::iter_swap(__a, __c);
     118             :         }
     119             :       else if (__comp(*__a, *__c))
     120             :         return;
     121             :       else if (__comp(*__b, *__c))
     122             :         std::iter_swap(__a, __c);
     123             :       else
     124             :         std::iter_swap(__a, __b);
     125             :     }
     126             : 
     127             :   // for_each
     128             : 
     129             :   /// This is an overload used by find() for the Input Iterator case.
     130             :   template<typename _InputIterator, typename _Tp>
     131             :     inline _InputIterator
     132             :     __find(_InputIterator __first, _InputIterator __last,
     133             :            const _Tp& __val, input_iterator_tag)
     134             :     {
     135             :       while (__first != __last && !(*__first == __val))
     136             :         ++__first;
     137             :       return __first;
     138             :     }
     139             : 
     140             :   /// This is an overload used by find_if() for the Input Iterator case.
     141             :   template<typename _InputIterator, typename _Predicate>
     142             :     inline _InputIterator
     143             :     __find_if(_InputIterator __first, _InputIterator __last,
     144             :               _Predicate __pred, input_iterator_tag)
     145             :     {
     146             :       while (__first != __last && !bool(__pred(*__first)))
     147             :         ++__first;
     148             :       return __first;
     149             :     }
     150             : 
     151             :   /// This is an overload used by find() for the RAI case.
     152             :   template<typename _RandomAccessIterator, typename _Tp>
     153             :     _RandomAccessIterator
     154          35 :     __find(_RandomAccessIterator __first, _RandomAccessIterator __last,
     155             :            const _Tp& __val, random_access_iterator_tag)
     156             :     {
     157             :       typename iterator_traits<_RandomAccessIterator>::difference_type
     158          35 :         __trip_count = (__last - __first) >> 2;
     159             : 
     160         135 :       for (; __trip_count > 0; --__trip_count)
     161             :         {
     162         100 :           if (*__first == __val)
     163           0 :             return __first;
     164         100 :           ++__first;
     165             : 
     166         100 :           if (*__first == __val)
     167           0 :             return __first;
     168         100 :           ++__first;
     169             : 
     170         100 :           if (*__first == __val)
     171           0 :             return __first;
     172         100 :           ++__first;
     173             : 
     174         100 :           if (*__first == __val)
     175           0 :             return __first;
     176         100 :           ++__first;
     177             :         }
     178             : 
     179          35 :       switch (__last - __first)
     180             :         {
     181             :         case 3:
     182           6 :           if (*__first == __val)
     183           0 :             return __first;
     184           6 :           ++__first;
     185             :         case 2:
     186          11 :           if (*__first == __val)
     187           1 :             return __first;
     188          10 :           ++__first;
     189             :         case 1:
     190          18 :           if (*__first == __val)
     191           6 :             return __first;
     192          12 :           ++__first;
     193             :         case 0:
     194             :         default:
     195          35 :           return __last;
     196             :         }
     197             :     }
     198             : 
     199             :   /// This is an overload used by find_if() for the RAI case.
     200             :   template<typename _RandomAccessIterator, typename _Predicate>
     201             :     _RandomAccessIterator
     202           0 :     __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
     203             :               _Predicate __pred, random_access_iterator_tag)
     204             :     {
     205             :       typename iterator_traits<_RandomAccessIterator>::difference_type
     206           0 :         __trip_count = (__last - __first) >> 2;
     207             : 
     208           0 :       for (; __trip_count > 0; --__trip_count)
     209             :         {
     210           0 :           if (__pred(*__first))
     211           0 :             return __first;
     212           0 :           ++__first;
     213             : 
     214           0 :           if (__pred(*__first))
     215           0 :             return __first;
     216           0 :           ++__first;
     217             : 
     218           0 :           if (__pred(*__first))
     219           0 :             return __first;
     220           0 :           ++__first;
     221             : 
     222           0 :           if (__pred(*__first))
     223           0 :             return __first;
     224           0 :           ++__first;
     225             :         }
     226             : 
     227           0 :       switch (__last - __first)
     228             :         {
     229             :         case 3:
     230           0 :           if (__pred(*__first))
     231           0 :             return __first;
     232           0 :           ++__first;
     233             :         case 2:
     234           0 :           if (__pred(*__first))
     235           0 :             return __first;
     236           0 :           ++__first;
     237             :         case 1:
     238           0 :           if (__pred(*__first))
     239           0 :             return __first;
     240           0 :           ++__first;
     241             :         case 0:
     242             :         default:
     243           0 :           return __last;
     244             :         }
     245             :     }
     246             : 
     247             : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     248             :   /// This is an overload used by find_if_not() for the Input Iterator case.
     249             :   template<typename _InputIterator, typename _Predicate>
     250             :     inline _InputIterator
     251             :     __find_if_not(_InputIterator __first, _InputIterator __last,
     252             :                   _Predicate __pred, input_iterator_tag)
     253             :     {
     254             :       while (__first != __last && bool(__pred(*__first)))
     255             :         ++__first;
     256             :       return __first;
     257             :     }
     258             : 
     259             :   /// This is an overload used by find_if_not() for the RAI case.
     260             :   template<typename _RandomAccessIterator, typename _Predicate>
     261             :     _RandomAccessIterator
     262             :     __find_if_not(_RandomAccessIterator __first, _RandomAccessIterator __last,
     263             :                   _Predicate __pred, random_access_iterator_tag)
     264             :     {
     265             :       typename iterator_traits<_RandomAccessIterator>::difference_type
     266             :         __trip_count = (__last - __first) >> 2;
     267             : 
     268             :       for (; __trip_count > 0; --__trip_count)
     269             :         {
     270             :           if (!bool(__pred(*__first)))
     271             :             return __first;
     272             :           ++__first;
     273             : 
     274             :           if (!bool(__pred(*__first)))
     275             :             return __first;
     276             :           ++__first;
     277             : 
     278             :           if (!bool(__pred(*__first)))
     279             :             return __first;
     280             :           ++__first;
     281             : 
     282             :           if (!bool(__pred(*__first)))
     283             :             return __first;
     284             :           ++__first;
     285             :         }
     286             : 
     287             :       switch (__last - __first)
     288             :         {
     289             :         case 3:
     290             :           if (!bool(__pred(*__first)))
     291             :             return __first;
     292             :           ++__first;
     293             :         case 2:
     294             :           if (!bool(__pred(*__first)))
     295             :             return __first;
     296             :           ++__first;
     297             :         case 1:
     298             :           if (!bool(__pred(*__first)))
     299             :             return __first;
     300             :           ++__first;
     301             :         case 0:
     302             :         default:
     303             :           return __last;
     304             :         }
     305             :     }
     306             : #endif
     307             : 
     308             :   // set_difference
     309             :   // set_intersection
     310             :   // set_symmetric_difference
     311             :   // set_union
     312             :   // for_each
     313             :   // find
     314             :   // find_if
     315             :   // find_first_of
     316             :   // adjacent_find
     317             :   // count
     318             :   // count_if
     319             :   // search
     320             : 
     321             :   /**
     322             :    *  This is an uglified
     323             :    *  search_n(_ForwardIterator, _ForwardIterator, _Integer, const _Tp&)
     324             :    *  overloaded for forward iterators.
     325             :   */
     326             :   template<typename _ForwardIterator, typename _Integer, typename _Tp>
     327             :     _ForwardIterator
     328             :     __search_n(_ForwardIterator __first, _ForwardIterator __last,
     329             :                _Integer __count, const _Tp& __val,
     330             :                std::forward_iterator_tag)
     331             :     {
     332             :       __first = _GLIBCXX_STD_A::find(__first, __last, __val);
     333             :       while (__first != __last)
     334             :         {
     335             :           typename iterator_traits<_ForwardIterator>::difference_type
     336             :             __n = __count;
     337             :           _ForwardIterator __i = __first;
     338             :           ++__i;
     339             :           while (__i != __last && __n != 1 && *__i == __val)
     340             :             {
     341             :               ++__i;
     342             :               --__n;
     343             :             }
     344             :           if (__n == 1)
     345             :             return __first;
     346             :           if (__i == __last)
     347             :             return __last;
     348             :           __first = _GLIBCXX_STD_A::find(++__i, __last, __val);
     349             :         }
     350             :       return __last;
     351             :     }
     352             : 
     353             :   /**
     354             :    *  This is an uglified
     355             :    *  search_n(_ForwardIterator, _ForwardIterator, _Integer, const _Tp&)
     356             :    *  overloaded for random access iterators.
     357             :   */
     358             :   template<typename _RandomAccessIter, typename _Integer, typename _Tp>
     359             :     _RandomAccessIter
     360             :     __search_n(_RandomAccessIter __first, _RandomAccessIter __last,
     361             :                _Integer __count, const _Tp& __val, 
     362             :                std::random_access_iterator_tag)
     363             :     {
     364             :       
     365             :       typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
     366             :         _DistanceType;
     367             : 
     368             :       _DistanceType __tailSize = __last - __first;
     369             :       const _DistanceType __pattSize = __count;
     370             : 
     371             :       if (__tailSize < __pattSize)
     372             :         return __last;
     373             : 
     374             :       const _DistanceType __skipOffset = __pattSize - 1;
     375             :       _RandomAccessIter __lookAhead = __first + __skipOffset;
     376             :       __tailSize -= __pattSize;
     377             : 
     378             :       while (1) // the main loop...
     379             :         {
     380             :           // __lookAhead here is always pointing to the last element of next 
     381             :           // possible match.
     382             :           while (!(*__lookAhead == __val)) // the skip loop...
     383             :             {
     384             :               if (__tailSize < __pattSize)
     385             :                 return __last;  // Failure
     386             :               __lookAhead += __pattSize;
     387             :               __tailSize -= __pattSize;
     388             :             }
     389             :           _DistanceType __remainder = __skipOffset;
     390             :           for (_RandomAccessIter __backTrack = __lookAhead - 1; 
     391             :                *__backTrack == __val; --__backTrack)
     392             :             {
     393             :               if (--__remainder == 0)
     394             :                 return (__lookAhead - __skipOffset); // Success
     395             :             }
     396             :           if (__remainder > __tailSize)
     397             :             return __last; // Failure
     398             :           __lookAhead += __remainder;
     399             :           __tailSize -= __remainder;
     400             :         }
     401             :     }
     402             : 
     403             :   // search_n
     404             : 
     405             :   /**
     406             :    *  This is an uglified
     407             :    *  search_n(_ForwardIterator, _ForwardIterator, _Integer, const _Tp&,
     408             :    *           _BinaryPredicate)
     409             :    *  overloaded for forward iterators.
     410             :   */
     411             :   template<typename _ForwardIterator, typename _Integer, typename _Tp,
     412             :            typename _BinaryPredicate>
     413             :     _ForwardIterator
     414             :     __search_n(_ForwardIterator __first, _ForwardIterator __last,
     415             :                _Integer __count, const _Tp& __val,
     416             :                _BinaryPredicate __binary_pred, std::forward_iterator_tag)
     417             :     {
     418             :       while (__first != __last && !bool(__binary_pred(*__first, __val)))
     419             :         ++__first;
     420             : 
     421             :       while (__first != __last)
     422             :         {
     423             :           typename iterator_traits<_ForwardIterator>::difference_type
     424             :             __n = __count;
     425             :           _ForwardIterator __i = __first;
     426             :           ++__i;
     427             :           while (__i != __last && __n != 1 && bool(__binary_pred(*__i, __val)))
     428             :             {
     429             :               ++__i;
     430             :               --__n;
     431             :             }
     432             :           if (__n == 1)
     433             :             return __first;
     434             :           if (__i == __last)
     435             :             return __last;
     436             :           __first = ++__i;
     437             :           while (__first != __last
     438             :                  && !bool(__binary_pred(*__first, __val)))
     439             :             ++__first;
     440             :         }
     441             :       return __last;
     442             :     }
     443             : 
     444             :   /**
     445             :    *  This is an uglified
     446             :    *  search_n(_ForwardIterator, _ForwardIterator, _Integer, const _Tp&,
     447             :    *           _BinaryPredicate)
     448             :    *  overloaded for random access iterators.
     449             :   */
     450             :   template<typename _RandomAccessIter, typename _Integer, typename _Tp,
     451             :            typename _BinaryPredicate>
     452             :     _RandomAccessIter
     453             :     __search_n(_RandomAccessIter __first, _RandomAccessIter __last,
     454             :                _Integer __count, const _Tp& __val,
     455             :                _BinaryPredicate __binary_pred, std::random_access_iterator_tag)
     456             :     {
     457             :       
     458             :       typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
     459             :         _DistanceType;
     460             : 
     461             :       _DistanceType __tailSize = __last - __first;
     462             :       const _DistanceType __pattSize = __count;
     463             : 
     464             :       if (__tailSize < __pattSize)
     465             :         return __last;
     466             : 
     467             :       const _DistanceType __skipOffset = __pattSize - 1;
     468             :       _RandomAccessIter __lookAhead = __first + __skipOffset;
     469             :       __tailSize -= __pattSize;
     470             : 
     471             :       while (1) // the main loop...
     472             :         {
     473             :           // __lookAhead here is always pointing to the last element of next 
     474             :           // possible match.
     475             :           while (!bool(__binary_pred(*__lookAhead, __val))) // the skip loop...
     476             :             {
     477             :               if (__tailSize < __pattSize)
     478             :                 return __last;  // Failure
     479             :               __lookAhead += __pattSize;
     480             :               __tailSize -= __pattSize;
     481             :             }
     482             :           _DistanceType __remainder = __skipOffset;
     483             :           for (_RandomAccessIter __backTrack = __lookAhead - 1; 
     484             :                __binary_pred(*__backTrack, __val); --__backTrack)
     485             :             {
     486             :               if (--__remainder == 0)
     487             :                 return (__lookAhead - __skipOffset); // Success
     488             :             }
     489             :           if (__remainder > __tailSize)
     490             :             return __last; // Failure
     491             :           __lookAhead += __remainder;
     492             :           __tailSize -= __remainder;
     493             :         }
     494             :     }
     495             : 
     496             :   // find_end for forward iterators.
     497             :   template<typename _ForwardIterator1, typename _ForwardIterator2>
     498             :     _ForwardIterator1
     499             :     __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
     500             :                _ForwardIterator2 __first2, _ForwardIterator2 __last2,
     501             :                forward_iterator_tag, forward_iterator_tag)
     502             :     {
     503             :       if (__first2 == __last2)
     504             :         return __last1;
     505             :       else
     506             :         {
     507             :           _ForwardIterator1 __result = __last1;
     508             :           while (1)
     509             :             {
     510             :               _ForwardIterator1 __new_result
     511             :                 = _GLIBCXX_STD_A::search(__first1, __last1, __first2, __last2);
     512             :               if (__new_result == __last1)
     513             :                 return __result;
     514             :               else
     515             :                 {
     516             :                   __result = __new_result;
     517             :                   __first1 = __new_result;
     518             :                   ++__first1;
     519             :                 }
     520             :             }
     521             :         }
     522             :     }
     523             : 
     524             :   template<typename _ForwardIterator1, typename _ForwardIterator2,
     525             :            typename _BinaryPredicate>
     526             :     _ForwardIterator1
     527             :     __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
     528             :                _ForwardIterator2 __first2, _ForwardIterator2 __last2,
     529             :                forward_iterator_tag, forward_iterator_tag,
     530             :                _BinaryPredicate __comp)
     531             :     {
     532             :       if (__first2 == __last2)
     533             :         return __last1;
     534             :       else
     535             :         {
     536             :           _ForwardIterator1 __result = __last1;
     537             :           while (1)
     538             :             {
     539             :               _ForwardIterator1 __new_result
     540             :                 = _GLIBCXX_STD_A::search(__first1, __last1, __first2,
     541             :                                          __last2, __comp);
     542             :               if (__new_result == __last1)
     543             :                 return __result;
     544             :               else
     545             :                 {
     546             :                   __result = __new_result;
     547             :                   __first1 = __new_result;
     548             :                   ++__first1;
     549             :                 }
     550             :             }
     551             :         }
     552             :     }
     553             : 
     554             :   // find_end for bidirectional iterators (much faster).
     555             :   template<typename _BidirectionalIterator1, typename _BidirectionalIterator2>
     556             :     _BidirectionalIterator1
     557             :     __find_end(_BidirectionalIterator1 __first1,
     558             :                _BidirectionalIterator1 __last1,
     559             :                _BidirectionalIterator2 __first2,
     560             :                _BidirectionalIterator2 __last2,
     561             :                bidirectional_iterator_tag, bidirectional_iterator_tag)
     562             :     {
     563             :       // concept requirements
     564             :       __glibcxx_function_requires(_BidirectionalIteratorConcept<
     565             :                                   _BidirectionalIterator1>)
     566             :       __glibcxx_function_requires(_BidirectionalIteratorConcept<
     567             :                                   _BidirectionalIterator2>)
     568             : 
     569             :       typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
     570             :       typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
     571             : 
     572             :       _RevIterator1 __rlast1(__first1);
     573             :       _RevIterator2 __rlast2(__first2);
     574             :       _RevIterator1 __rresult = _GLIBCXX_STD_A::search(_RevIterator1(__last1),
     575             :                                                        __rlast1,
     576             :                                                        _RevIterator2(__last2),
     577             :                                                        __rlast2);
     578             : 
     579             :       if (__rresult == __rlast1)
     580             :         return __last1;
     581             :       else
     582             :         {
     583             :           _BidirectionalIterator1 __result = __rresult.base();
     584             :           std::advance(__result, -std::distance(__first2, __last2));
     585             :           return __result;
     586             :         }
     587             :     }
     588             : 
     589             :   template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
     590             :            typename _BinaryPredicate>
     591             :     _BidirectionalIterator1
     592             :     __find_end(_BidirectionalIterator1 __first1,
     593             :                _BidirectionalIterator1 __last1,
     594             :                _BidirectionalIterator2 __first2,
     595             :                _BidirectionalIterator2 __last2,
     596             :                bidirectional_iterator_tag, bidirectional_iterator_tag,
     597             :                _BinaryPredicate __comp)
     598             :     {
     599             :       // concept requirements
     600             :       __glibcxx_function_requires(_BidirectionalIteratorConcept<
     601             :                                   _BidirectionalIterator1>)
     602             :       __glibcxx_function_requires(_BidirectionalIteratorConcept<
     603             :                                   _BidirectionalIterator2>)
     604             : 
     605             :       typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
     606             :       typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
     607             : 
     608             :       _RevIterator1 __rlast1(__first1);
     609             :       _RevIterator2 __rlast2(__first2);
     610             :       _RevIterator1 __rresult = std::search(_RevIterator1(__last1), __rlast1,
     611             :                                             _RevIterator2(__last2), __rlast2,
     612             :                                             __comp);
     613             : 
     614             :       if (__rresult == __rlast1)
     615             :         return __last1;
     616             :       else
     617             :         {
     618             :           _BidirectionalIterator1 __result = __rresult.base();
     619             :           std::advance(__result, -std::distance(__first2, __last2));
     620             :           return __result;
     621             :         }
     622             :     }
     623             : 
     624             :   /**
     625             :    *  @brief  Find last matching subsequence in a sequence.
     626             :    *  @ingroup non_mutating_algorithms
     627             :    *  @param  first1  Start of range to search.
     628             :    *  @param  last1   End of range to search.
     629             :    *  @param  first2  Start of sequence to match.
     630             :    *  @param  last2   End of sequence to match.
     631             :    *  @return   The last iterator @c i in the range
     632             :    *  @p [first1,last1-(last2-first2)) such that @c *(i+N) == @p *(first2+N)
     633             :    *  for each @c N in the range @p [0,last2-first2), or @p last1 if no
     634             :    *  such iterator exists.
     635             :    *
     636             :    *  Searches the range @p [first1,last1) for a sub-sequence that compares
     637             :    *  equal value-by-value with the sequence given by @p [first2,last2) and
     638             :    *  returns an iterator to the first element of the sub-sequence, or
     639             :    *  @p last1 if the sub-sequence is not found.  The sub-sequence will be the
     640             :    *  last such subsequence contained in [first,last1).
     641             :    *
     642             :    *  Because the sub-sequence must lie completely within the range
     643             :    *  @p [first1,last1) it must start at a position less than
     644             :    *  @p last1-(last2-first2) where @p last2-first2 is the length of the
     645             :    *  sub-sequence.
     646             :    *  This means that the returned iterator @c i will be in the range
     647             :    *  @p [first1,last1-(last2-first2))
     648             :   */
     649             :   template<typename _ForwardIterator1, typename _ForwardIterator2>
     650             :     inline _ForwardIterator1
     651             :     find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
     652             :              _ForwardIterator2 __first2, _ForwardIterator2 __last2)
     653             :     {
     654             :       // concept requirements
     655             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
     656             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
     657             :       __glibcxx_function_requires(_EqualOpConcept<
     658             :             typename iterator_traits<_ForwardIterator1>::value_type,
     659             :             typename iterator_traits<_ForwardIterator2>::value_type>)
     660             :       __glibcxx_requires_valid_range(__first1, __last1);
     661             :       __glibcxx_requires_valid_range(__first2, __last2);
     662             : 
     663             :       return std::__find_end(__first1, __last1, __first2, __last2,
     664             :                              std::__iterator_category(__first1),
     665             :                              std::__iterator_category(__first2));
     666             :     }
     667             : 
     668             :   /**
     669             :    *  @brief  Find last matching subsequence in a sequence using a predicate.
     670             :    *  @ingroup non_mutating_algorithms
     671             :    *  @param  first1  Start of range to search.
     672             :    *  @param  last1   End of range to search.
     673             :    *  @param  first2  Start of sequence to match.
     674             :    *  @param  last2   End of sequence to match.
     675             :    *  @param  comp    The predicate to use.
     676             :    *  @return   The last iterator @c i in the range
     677             :    *  @p [first1,last1-(last2-first2)) such that @c predicate(*(i+N), @p
     678             :    *  (first2+N)) is true for each @c N in the range @p [0,last2-first2), or
     679             :    *  @p last1 if no such iterator exists.
     680             :    *
     681             :    *  Searches the range @p [first1,last1) for a sub-sequence that compares
     682             :    *  equal value-by-value with the sequence given by @p [first2,last2) using
     683             :    *  comp as a predicate and returns an iterator to the first element of the
     684             :    *  sub-sequence, or @p last1 if the sub-sequence is not found.  The
     685             :    *  sub-sequence will be the last such subsequence contained in
     686             :    *  [first,last1).
     687             :    *
     688             :    *  Because the sub-sequence must lie completely within the range
     689             :    *  @p [first1,last1) it must start at a position less than
     690             :    *  @p last1-(last2-first2) where @p last2-first2 is the length of the
     691             :    *  sub-sequence.
     692             :    *  This means that the returned iterator @c i will be in the range
     693             :    *  @p [first1,last1-(last2-first2))
     694             :   */
     695             :   template<typename _ForwardIterator1, typename _ForwardIterator2,
     696             :            typename _BinaryPredicate>
     697             :     inline _ForwardIterator1
     698             :     find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
     699             :              _ForwardIterator2 __first2, _ForwardIterator2 __last2,
     700             :              _BinaryPredicate __comp)
     701             :     {
     702             :       // concept requirements
     703             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
     704             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
     705             :       __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
     706             :             typename iterator_traits<_ForwardIterator1>::value_type,
     707             :             typename iterator_traits<_ForwardIterator2>::value_type>)
     708             :       __glibcxx_requires_valid_range(__first1, __last1);
     709             :       __glibcxx_requires_valid_range(__first2, __last2);
     710             : 
     711             :       return std::__find_end(__first1, __last1, __first2, __last2,
     712             :                              std::__iterator_category(__first1),
     713             :                              std::__iterator_category(__first2),
     714             :                              __comp);
     715             :     }
     716             : 
     717             : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     718             :   /**
     719             :    *  @brief  Checks that a predicate is true for all the elements
     720             :    *          of a sequence.
     721             :    *  @ingroup non_mutating_algorithms
     722             :    *  @param  first   An input iterator.
     723             :    *  @param  last    An input iterator.
     724             :    *  @param  pred    A predicate.
     725             :    *  @return  True if the check is true, false otherwise.
     726             :    *
     727             :    *  Returns true if @p pred is true for each element in the range
     728             :    *  @p [first,last), and false otherwise.
     729             :   */
     730             :   template<typename _InputIterator, typename _Predicate>
     731             :     inline bool
     732             :     all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
     733             :     { return __last == std::find_if_not(__first, __last, __pred); }
     734             : 
     735             :   /**
     736             :    *  @brief  Checks that a predicate is false for all the elements
     737             :    *          of a sequence.
     738             :    *  @ingroup non_mutating_algorithms
     739             :    *  @param  first   An input iterator.
     740             :    *  @param  last    An input iterator.
     741             :    *  @param  pred    A predicate.
     742             :    *  @return  True if the check is true, false otherwise.
     743             :    *
     744             :    *  Returns true if @p pred is false for each element in the range
     745             :    *  @p [first,last), and false otherwise.
     746             :   */
     747             :   template<typename _InputIterator, typename _Predicate>
     748             :     inline bool
     749             :     none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
     750             :     { return __last == _GLIBCXX_STD_A::find_if(__first, __last, __pred); }
     751             : 
     752             :   /**
     753             :    *  @brief  Checks that a predicate is false for at least an element
     754             :    *          of a sequence.
     755             :    *  @ingroup non_mutating_algorithms
     756             :    *  @param  first   An input iterator.
     757             :    *  @param  last    An input iterator.
     758             :    *  @param  pred    A predicate.
     759             :    *  @return  True if the check is true, false otherwise.
     760             :    *
     761             :    *  Returns true if an element exists in the range @p [first,last) such that
     762             :    *  @p pred is true, and false otherwise.
     763             :   */
     764             :   template<typename _InputIterator, typename _Predicate>
     765             :     inline bool
     766             :     any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
     767             :     { return !std::none_of(__first, __last, __pred); }
     768             : 
     769             :   /**
     770             :    *  @brief  Find the first element in a sequence for which a
     771             :    *          predicate is false.
     772             :    *  @ingroup non_mutating_algorithms
     773             :    *  @param  first  An input iterator.
     774             :    *  @param  last   An input iterator.
     775             :    *  @param  pred   A predicate.
     776             :    *  @return   The first iterator @c i in the range @p [first,last)
     777             :    *  such that @p pred(*i) is false, or @p last if no such iterator exists.
     778             :   */
     779             :   template<typename _InputIterator, typename _Predicate>
     780             :     inline _InputIterator
     781             :     find_if_not(_InputIterator __first, _InputIterator __last,
     782             :                 _Predicate __pred)
     783             :     {
     784             :       // concept requirements
     785             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
     786             :       __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
     787             :               typename iterator_traits<_InputIterator>::value_type>)
     788             :       __glibcxx_requires_valid_range(__first, __last);
     789             :       return std::__find_if_not(__first, __last, __pred,
     790             :                                 std::__iterator_category(__first));
     791             :     }
     792             : 
     793             :   /**
     794             :    *  @brief  Checks whether the sequence is partitioned.
     795             :    *  @ingroup mutating_algorithms
     796             :    *  @param  first  An input iterator.
     797             :    *  @param  last   An input iterator.
     798             :    *  @param  pred   A predicate.
     799             :    *  @return  True if the range @p [first,last) is partioned by @p pred,
     800             :    *  i.e. if all elements that satisfy @p pred appear before those that
     801             :    *  do not.
     802             :   */
     803             :   template<typename _InputIterator, typename _Predicate>
     804             :     inline bool
     805             :     is_partitioned(_InputIterator __first, _InputIterator __last,
     806             :                    _Predicate __pred)
     807             :     {
     808             :       __first = std::find_if_not(__first, __last, __pred);
     809             :       return std::none_of(__first, __last, __pred);
     810             :     }
     811             : 
     812             :   /**
     813             :    *  @brief  Find the partition point of a partitioned range.
     814             :    *  @ingroup mutating_algorithms
     815             :    *  @param  first   An iterator.
     816             :    *  @param  last    Another iterator.
     817             :    *  @param  pred    A predicate.
     818             :    *  @return  An iterator @p mid such that @p all_of(first, mid, pred)
     819             :    *           and @p none_of(mid, last, pred) are both true.
     820             :   */
     821             :   template<typename _ForwardIterator, typename _Predicate>
     822             :     _ForwardIterator
     823             :     partition_point(_ForwardIterator __first, _ForwardIterator __last,
     824             :                     _Predicate __pred)
     825             :     {
     826             :       // concept requirements
     827             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
     828             :       __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
     829             :               typename iterator_traits<_ForwardIterator>::value_type>)
     830             : 
     831             :       // A specific debug-mode test will be necessary...
     832             :       __glibcxx_requires_valid_range(__first, __last);
     833             : 
     834             :       typedef typename iterator_traits<_ForwardIterator>::difference_type
     835             :         _DistanceType;
     836             : 
     837             :       _DistanceType __len = std::distance(__first, __last);
     838             :       _DistanceType __half;
     839             :       _ForwardIterator __middle;
     840             : 
     841             :       while (__len > 0)
     842             :         {
     843             :           __half = __len >> 1;
     844             :           __middle = __first;
     845             :           std::advance(__middle, __half);
     846             :           if (__pred(*__middle))
     847             :             {
     848             :               __first = __middle;
     849             :               ++__first;
     850             :               __len = __len - __half - 1;
     851             :             }
     852             :           else
     853             :             __len = __half;
     854             :         }
     855             :       return __first;
     856             :     }
     857             : #endif
     858             : 
     859             : 
     860             :   /**
     861             :    *  @brief Copy a sequence, removing elements of a given value.
     862             :    *  @ingroup mutating_algorithms
     863             :    *  @param  first   An input iterator.
     864             :    *  @param  last    An input iterator.
     865             :    *  @param  result  An output iterator.
     866             :    *  @param  value   The value to be removed.
     867             :    *  @return   An iterator designating the end of the resulting sequence.
     868             :    *
     869             :    *  Copies each element in the range @p [first,last) not equal to @p value
     870             :    *  to the range beginning at @p result.
     871             :    *  remove_copy() is stable, so the relative order of elements that are
     872             :    *  copied is unchanged.
     873             :   */
     874             :   template<typename _InputIterator, typename _OutputIterator, typename _Tp>
     875             :     _OutputIterator
     876             :     remove_copy(_InputIterator __first, _InputIterator __last,
     877             :                 _OutputIterator __result, const _Tp& __value)
     878             :     {
     879             :       // concept requirements
     880             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
     881             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
     882             :             typename iterator_traits<_InputIterator>::value_type>)
     883             :       __glibcxx_function_requires(_EqualOpConcept<
     884             :             typename iterator_traits<_InputIterator>::value_type, _Tp>)
     885             :       __glibcxx_requires_valid_range(__first, __last);
     886             : 
     887             :       for (; __first != __last; ++__first)
     888             :         if (!(*__first == __value))
     889             :           {
     890             :             *__result = *__first;
     891             :             ++__result;
     892             :           }
     893             :       return __result;
     894             :     }
     895             : 
     896             :   /**
     897             :    *  @brief Copy a sequence, removing elements for which a predicate is true.
     898             :    *  @ingroup mutating_algorithms
     899             :    *  @param  first   An input iterator.
     900             :    *  @param  last    An input iterator.
     901             :    *  @param  result  An output iterator.
     902             :    *  @param  pred    A predicate.
     903             :    *  @return   An iterator designating the end of the resulting sequence.
     904             :    *
     905             :    *  Copies each element in the range @p [first,last) for which
     906             :    *  @p pred returns false to the range beginning at @p result.
     907             :    *
     908             :    *  remove_copy_if() is stable, so the relative order of elements that are
     909             :    *  copied is unchanged.
     910             :   */
     911             :   template<typename _InputIterator, typename _OutputIterator,
     912             :            typename _Predicate>
     913             :     _OutputIterator
     914             :     remove_copy_if(_InputIterator __first, _InputIterator __last,
     915             :                    _OutputIterator __result, _Predicate __pred)
     916             :     {
     917             :       // concept requirements
     918             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
     919             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
     920             :             typename iterator_traits<_InputIterator>::value_type>)
     921             :       __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
     922             :             typename iterator_traits<_InputIterator>::value_type>)
     923             :       __glibcxx_requires_valid_range(__first, __last);
     924             : 
     925             :       for (; __first != __last; ++__first)
     926             :         if (!bool(__pred(*__first)))
     927             :           {
     928             :             *__result = *__first;
     929             :             ++__result;
     930             :           }
     931             :       return __result;
     932             :     }
     933             : 
     934             : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     935             :   /**
     936             :    *  @brief Copy the elements of a sequence for which a predicate is true.
     937             :    *  @ingroup mutating_algorithms
     938             :    *  @param  first   An input iterator.
     939             :    *  @param  last    An input iterator.
     940             :    *  @param  result  An output iterator.
     941             :    *  @param  pred    A predicate.
     942             :    *  @return   An iterator designating the end of the resulting sequence.
     943             :    *
     944             :    *  Copies each element in the range @p [first,last) for which
     945             :    *  @p pred returns true to the range beginning at @p result.
     946             :    *
     947             :    *  copy_if() is stable, so the relative order of elements that are
     948             :    *  copied is unchanged.
     949             :   */
     950             :   template<typename _InputIterator, typename _OutputIterator,
     951             :            typename _Predicate>
     952             :     _OutputIterator
     953             :     copy_if(_InputIterator __first, _InputIterator __last,
     954             :             _OutputIterator __result, _Predicate __pred)
     955             :     {
     956             :       // concept requirements
     957             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
     958             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
     959             :             typename iterator_traits<_InputIterator>::value_type>)
     960             :       __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
     961             :             typename iterator_traits<_InputIterator>::value_type>)
     962             :       __glibcxx_requires_valid_range(__first, __last);
     963             : 
     964             :       for (; __first != __last; ++__first)
     965             :         if (__pred(*__first))
     966             :           {
     967             :             *__result = *__first;
     968             :             ++__result;
     969             :           }
     970             :       return __result;
     971             :     }
     972             : 
     973             : 
     974             :   template<typename _InputIterator, typename _Size, typename _OutputIterator>
     975             :     _OutputIterator
     976             :     __copy_n(_InputIterator __first, _Size __n,
     977             :              _OutputIterator __result, input_iterator_tag)
     978             :     {
     979             :       for (; __n > 0; --__n)
     980             :         {
     981             :           *__result = *__first;
     982             :           ++__first;
     983             :           ++__result;
     984             :         }
     985             :       return __result;
     986             :     }
     987             : 
     988             :   template<typename _RandomAccessIterator, typename _Size,
     989             :            typename _OutputIterator>
     990             :     inline _OutputIterator
     991             :     __copy_n(_RandomAccessIterator __first, _Size __n,
     992             :              _OutputIterator __result, random_access_iterator_tag)
     993             :     { return std::copy(__first, __first + __n, __result); }
     994             : 
     995             :   /**
     996             :    *  @brief Copies the range [first,first+n) into [result,result+n).
     997             :    *  @ingroup mutating_algorithms
     998             :    *  @param  first  An input iterator.
     999             :    *  @param  n      The number of elements to copy.
    1000             :    *  @param  result An output iterator.
    1001             :    *  @return  result+n.
    1002             :    *
    1003             :    *  This inline function will boil down to a call to @c memmove whenever
    1004             :    *  possible.  Failing that, if random access iterators are passed, then the
    1005             :    *  loop count will be known (and therefore a candidate for compiler
    1006             :    *  optimizations such as unrolling).
    1007             :   */
    1008             :   template<typename _InputIterator, typename _Size, typename _OutputIterator>
    1009             :     inline _OutputIterator
    1010             :     copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
    1011             :     {
    1012             :       // concept requirements
    1013             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    1014             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    1015             :             typename iterator_traits<_InputIterator>::value_type>)
    1016             : 
    1017             :       return std::__copy_n(__first, __n, __result,
    1018             :                            std::__iterator_category(__first));
    1019             :     }
    1020             : 
    1021             :   /**
    1022             :    *  @brief Copy the elements of a sequence to separate output sequences
    1023             :    *         depending on the truth value of a predicate.
    1024             :    *  @ingroup mutating_algorithms
    1025             :    *  @param  first   An input iterator.
    1026             :    *  @param  last    An input iterator.
    1027             :    *  @param  out_true   An output iterator.
    1028             :    *  @param  out_false  An output iterator.
    1029             :    *  @param  pred    A predicate.
    1030             :    *  @return   A pair designating the ends of the resulting sequences.
    1031             :    *
    1032             :    *  Copies each element in the range @p [first,last) for which
    1033             :    *  @p pred returns true to the range beginning at @p out_true
    1034             :    *  and each element for which @p pred returns false to @p out_false.
    1035             :   */
    1036             :   template<typename _InputIterator, typename _OutputIterator1,
    1037             :            typename _OutputIterator2, typename _Predicate>
    1038             :     pair<_OutputIterator1, _OutputIterator2>
    1039             :     partition_copy(_InputIterator __first, _InputIterator __last,
    1040             :                    _OutputIterator1 __out_true, _OutputIterator2 __out_false,
    1041             :                    _Predicate __pred)
    1042             :     {
    1043             :       // concept requirements
    1044             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    1045             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator1,
    1046             :             typename iterator_traits<_InputIterator>::value_type>)
    1047             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator2,
    1048             :             typename iterator_traits<_InputIterator>::value_type>)
    1049             :       __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
    1050             :             typename iterator_traits<_InputIterator>::value_type>)
    1051             :       __glibcxx_requires_valid_range(__first, __last);
    1052             :       
    1053             :       for (; __first != __last; ++__first)
    1054             :         if (__pred(*__first))
    1055             :           {
    1056             :             *__out_true = *__first;
    1057             :             ++__out_true;
    1058             :           }
    1059             :         else
    1060             :           {
    1061             :             *__out_false = *__first;
    1062             :             ++__out_false;
    1063             :           }
    1064             : 
    1065             :       return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
    1066             :     }
    1067             : #endif
    1068             : 
    1069             :   /**
    1070             :    *  @brief Remove elements from a sequence.
    1071             :    *  @ingroup mutating_algorithms
    1072             :    *  @param  first  An input iterator.
    1073             :    *  @param  last   An input iterator.
    1074             :    *  @param  value  The value to be removed.
    1075             :    *  @return   An iterator designating the end of the resulting sequence.
    1076             :    *
    1077             :    *  All elements equal to @p value are removed from the range
    1078             :    *  @p [first,last).
    1079             :    *
    1080             :    *  remove() is stable, so the relative order of elements that are
    1081             :    *  not removed is unchanged.
    1082             :    *
    1083             :    *  Elements between the end of the resulting sequence and @p last
    1084             :    *  are still present, but their value is unspecified.
    1085             :   */
    1086             :   template<typename _ForwardIterator, typename _Tp>
    1087             :     _ForwardIterator
    1088             :     remove(_ForwardIterator __first, _ForwardIterator __last,
    1089             :            const _Tp& __value)
    1090             :     {
    1091             :       // concept requirements
    1092             :       __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
    1093             :                                   _ForwardIterator>)
    1094             :       __glibcxx_function_requires(_EqualOpConcept<
    1095             :             typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
    1096             :       __glibcxx_requires_valid_range(__first, __last);
    1097             : 
    1098             :       __first = _GLIBCXX_STD_A::find(__first, __last, __value);
    1099             :       if(__first == __last)
    1100             :         return __first;
    1101             :       _ForwardIterator __result = __first;
    1102             :       ++__first;
    1103             :       for(; __first != __last; ++__first)
    1104             :         if(!(*__first == __value))
    1105             :           {
    1106             :             *__result = _GLIBCXX_MOVE(*__first);
    1107             :             ++__result;
    1108             :           }
    1109             :       return __result;
    1110             :     }
    1111             : 
    1112             :   /**
    1113             :    *  @brief Remove elements from a sequence using a predicate.
    1114             :    *  @ingroup mutating_algorithms
    1115             :    *  @param  first  A forward iterator.
    1116             :    *  @param  last   A forward iterator.
    1117             :    *  @param  pred   A predicate.
    1118             :    *  @return   An iterator designating the end of the resulting sequence.
    1119             :    *
    1120             :    *  All elements for which @p pred returns true are removed from the range
    1121             :    *  @p [first,last).
    1122             :    *
    1123             :    *  remove_if() is stable, so the relative order of elements that are
    1124             :    *  not removed is unchanged.
    1125             :    *
    1126             :    *  Elements between the end of the resulting sequence and @p last
    1127             :    *  are still present, but their value is unspecified.
    1128             :   */
    1129             :   template<typename _ForwardIterator, typename _Predicate>
    1130             :     _ForwardIterator
    1131             :     remove_if(_ForwardIterator __first, _ForwardIterator __last,
    1132             :               _Predicate __pred)
    1133             :     {
    1134             :       // concept requirements
    1135             :       __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
    1136             :                                   _ForwardIterator>)
    1137             :       __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
    1138             :             typename iterator_traits<_ForwardIterator>::value_type>)
    1139             :       __glibcxx_requires_valid_range(__first, __last);
    1140             : 
    1141             :       __first = _GLIBCXX_STD_A::find_if(__first, __last, __pred);
    1142             :       if(__first == __last)
    1143             :         return __first;
    1144             :       _ForwardIterator __result = __first;
    1145             :       ++__first;
    1146             :       for(; __first != __last; ++__first)
    1147             :         if(!bool(__pred(*__first)))
    1148             :           {
    1149             :             *__result = _GLIBCXX_MOVE(*__first);
    1150             :             ++__result;
    1151             :           }
    1152             :       return __result;
    1153             :     }
    1154             : 
    1155             :   /**
    1156             :    *  @brief Remove consecutive duplicate values from a sequence.
    1157             :    *  @ingroup mutating_algorithms
    1158             :    *  @param  first  A forward iterator.
    1159             :    *  @param  last   A forward iterator.
    1160             :    *  @return  An iterator designating the end of the resulting sequence.
    1161             :    *
    1162             :    *  Removes all but the first element from each group of consecutive
    1163             :    *  values that compare equal.
    1164             :    *  unique() is stable, so the relative order of elements that are
    1165             :    *  not removed is unchanged.
    1166             :    *  Elements between the end of the resulting sequence and @p last
    1167             :    *  are still present, but their value is unspecified.
    1168             :   */
    1169             :   template<typename _ForwardIterator>
    1170             :     _ForwardIterator
    1171             :     unique(_ForwardIterator __first, _ForwardIterator __last)
    1172             :     {
    1173             :       // concept requirements
    1174             :       __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
    1175             :                                   _ForwardIterator>)
    1176             :       __glibcxx_function_requires(_EqualityComparableConcept<
    1177             :                      typename iterator_traits<_ForwardIterator>::value_type>)
    1178             :       __glibcxx_requires_valid_range(__first, __last);
    1179             : 
    1180             :       // Skip the beginning, if already unique.
    1181             :       __first = _GLIBCXX_STD_A::adjacent_find(__first, __last);
    1182             :       if (__first == __last)
    1183             :         return __last;
    1184             : 
    1185             :       // Do the real copy work.
    1186             :       _ForwardIterator __dest = __first;
    1187             :       ++__first;
    1188             :       while (++__first != __last)
    1189             :         if (!(*__dest == *__first))
    1190             :           *++__dest = _GLIBCXX_MOVE(*__first);
    1191             :       return ++__dest;
    1192             :     }
    1193             : 
    1194             :   /**
    1195             :    *  @brief Remove consecutive values from a sequence using a predicate.
    1196             :    *  @ingroup mutating_algorithms
    1197             :    *  @param  first        A forward iterator.
    1198             :    *  @param  last         A forward iterator.
    1199             :    *  @param  binary_pred  A binary predicate.
    1200             :    *  @return  An iterator designating the end of the resulting sequence.
    1201             :    *
    1202             :    *  Removes all but the first element from each group of consecutive
    1203             :    *  values for which @p binary_pred returns true.
    1204             :    *  unique() is stable, so the relative order of elements that are
    1205             :    *  not removed is unchanged.
    1206             :    *  Elements between the end of the resulting sequence and @p last
    1207             :    *  are still present, but their value is unspecified.
    1208             :   */
    1209             :   template<typename _ForwardIterator, typename _BinaryPredicate>
    1210             :     _ForwardIterator
    1211             :     unique(_ForwardIterator __first, _ForwardIterator __last,
    1212             :            _BinaryPredicate __binary_pred)
    1213             :     {
    1214             :       // concept requirements
    1215             :       __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
    1216             :                                   _ForwardIterator>)
    1217             :       __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
    1218             :                 typename iterator_traits<_ForwardIterator>::value_type,
    1219             :                 typename iterator_traits<_ForwardIterator>::value_type>)
    1220             :       __glibcxx_requires_valid_range(__first, __last);
    1221             : 
    1222             :       // Skip the beginning, if already unique.
    1223             :       __first = _GLIBCXX_STD_A::adjacent_find(__first, __last, __binary_pred);
    1224             :       if (__first == __last)
    1225             :         return __last;
    1226             : 
    1227             :       // Do the real copy work.
    1228             :       _ForwardIterator __dest = __first;
    1229             :       ++__first;
    1230             :       while (++__first != __last)
    1231             :         if (!bool(__binary_pred(*__dest, *__first)))
    1232             :           *++__dest = _GLIBCXX_MOVE(*__first);
    1233             :       return ++__dest;
    1234             :     }
    1235             : 
    1236             :   /**
    1237             :    *  This is an uglified unique_copy(_InputIterator, _InputIterator,
    1238             :    *                                  _OutputIterator)
    1239             :    *  overloaded for forward iterators and output iterator as result.
    1240             :   */
    1241             :   template<typename _ForwardIterator, typename _OutputIterator>
    1242             :     _OutputIterator
    1243             :     __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
    1244             :                   _OutputIterator __result,
    1245             :                   forward_iterator_tag, output_iterator_tag)
    1246             :     {
    1247             :       // concept requirements -- taken care of in dispatching function
    1248             :       _ForwardIterator __next = __first;
    1249             :       *__result = *__first;
    1250             :       while (++__next != __last)
    1251             :         if (!(*__first == *__next))
    1252             :           {
    1253             :             __first = __next;
    1254             :             *++__result = *__first;
    1255             :           }
    1256             :       return ++__result;
    1257             :     }
    1258             : 
    1259             :   /**
    1260             :    *  This is an uglified unique_copy(_InputIterator, _InputIterator,
    1261             :    *                                  _OutputIterator)
    1262             :    *  overloaded for input iterators and output iterator as result.
    1263             :   */
    1264             :   template<typename _InputIterator, typename _OutputIterator>
    1265             :     _OutputIterator
    1266             :     __unique_copy(_InputIterator __first, _InputIterator __last,
    1267             :                   _OutputIterator __result,
    1268             :                   input_iterator_tag, output_iterator_tag)
    1269             :     {
    1270             :       // concept requirements -- taken care of in dispatching function
    1271             :       typename iterator_traits<_InputIterator>::value_type __value = *__first;
    1272             :       *__result = __value;
    1273             :       while (++__first != __last)
    1274             :         if (!(__value == *__first))
    1275             :           {
    1276             :             __value = *__first;
    1277             :             *++__result = __value;
    1278             :           }
    1279             :       return ++__result;
    1280             :     }
    1281             : 
    1282             :   /**
    1283             :    *  This is an uglified unique_copy(_InputIterator, _InputIterator,
    1284             :    *                                  _OutputIterator)
    1285             :    *  overloaded for input iterators and forward iterator as result.
    1286             :   */
    1287             :   template<typename _InputIterator, typename _ForwardIterator>
    1288             :     _ForwardIterator
    1289             :     __unique_copy(_InputIterator __first, _InputIterator __last,
    1290             :                   _ForwardIterator __result,
    1291             :                   input_iterator_tag, forward_iterator_tag)
    1292             :     {
    1293             :       // concept requirements -- taken care of in dispatching function
    1294             :       *__result = *__first;
    1295             :       while (++__first != __last)
    1296             :         if (!(*__result == *__first))
    1297             :           *++__result = *__first;
    1298             :       return ++__result;
    1299             :     }
    1300             : 
    1301             :   /**
    1302             :    *  This is an uglified
    1303             :    *  unique_copy(_InputIterator, _InputIterator, _OutputIterator,
    1304             :    *              _BinaryPredicate)
    1305             :    *  overloaded for forward iterators and output iterator as result.
    1306             :   */
    1307             :   template<typename _ForwardIterator, typename _OutputIterator,
    1308             :            typename _BinaryPredicate>
    1309             :     _OutputIterator
    1310             :     __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
    1311             :                   _OutputIterator __result, _BinaryPredicate __binary_pred,
    1312             :                   forward_iterator_tag, output_iterator_tag)
    1313             :     {
    1314             :       // concept requirements -- iterators already checked
    1315             :       __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
    1316             :           typename iterator_traits<_ForwardIterator>::value_type,
    1317             :           typename iterator_traits<_ForwardIterator>::value_type>)
    1318             : 
    1319             :       _ForwardIterator __next = __first;
    1320             :       *__result = *__first;
    1321             :       while (++__next != __last)
    1322             :         if (!bool(__binary_pred(*__first, *__next)))
    1323             :           {
    1324             :             __first = __next;
    1325             :             *++__result = *__first;
    1326             :           }
    1327             :       return ++__result;
    1328             :     }
    1329             : 
    1330             :   /**
    1331             :    *  This is an uglified
    1332             :    *  unique_copy(_InputIterator, _InputIterator, _OutputIterator,
    1333             :    *              _BinaryPredicate)
    1334             :    *  overloaded for input iterators and output iterator as result.
    1335             :   */
    1336             :   template<typename _InputIterator, typename _OutputIterator,
    1337             :            typename _BinaryPredicate>
    1338             :     _OutputIterator
    1339             :     __unique_copy(_InputIterator __first, _InputIterator __last,
    1340             :                   _OutputIterator __result, _BinaryPredicate __binary_pred,
    1341             :                   input_iterator_tag, output_iterator_tag)
    1342             :     {
    1343             :       // concept requirements -- iterators already checked
    1344             :       __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
    1345             :           typename iterator_traits<_InputIterator>::value_type,
    1346             :           typename iterator_traits<_InputIterator>::value_type>)
    1347             : 
    1348             :       typename iterator_traits<_InputIterator>::value_type __value = *__first;
    1349             :       *__result = __value;
    1350             :       while (++__first != __last)
    1351             :         if (!bool(__binary_pred(__value, *__first)))
    1352             :           {
    1353             :             __value = *__first;
    1354             :             *++__result = __value;
    1355             :           }
    1356             :       return ++__result;
    1357             :     }
    1358             : 
    1359             :   /**
    1360             :    *  This is an uglified
    1361             :    *  unique_copy(_InputIterator, _InputIterator, _OutputIterator,
    1362             :    *              _BinaryPredicate)
    1363             :    *  overloaded for input iterators and forward iterator as result.
    1364             :   */
    1365             :   template<typename _InputIterator, typename _ForwardIterator,
    1366             :            typename _BinaryPredicate>
    1367             :     _ForwardIterator
    1368             :     __unique_copy(_InputIterator __first, _InputIterator __last,
    1369             :                   _ForwardIterator __result, _BinaryPredicate __binary_pred,
    1370             :                   input_iterator_tag, forward_iterator_tag)
    1371             :     {
    1372             :       // concept requirements -- iterators already checked
    1373             :       __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
    1374             :           typename iterator_traits<_ForwardIterator>::value_type,
    1375             :           typename iterator_traits<_InputIterator>::value_type>)
    1376             : 
    1377             :       *__result = *__first;
    1378             :       while (++__first != __last)
    1379             :         if (!bool(__binary_pred(*__result, *__first)))
    1380             :           *++__result = *__first;
    1381             :       return ++__result;
    1382             :     }
    1383             : 
    1384             :   /**
    1385             :    *  This is an uglified reverse(_BidirectionalIterator,
    1386             :    *                              _BidirectionalIterator)
    1387             :    *  overloaded for bidirectional iterators.
    1388             :   */
    1389             :   template<typename _BidirectionalIterator>
    1390             :     void
    1391             :     __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
    1392             :               bidirectional_iterator_tag)
    1393             :     {
    1394             :       while (true)
    1395             :         if (__first == __last || __first == --__last)
    1396             :           return;
    1397             :         else
    1398             :           {
    1399             :             std::iter_swap(__first, __last);
    1400             :             ++__first;
    1401             :           }
    1402             :     }
    1403             : 
    1404             :   /**
    1405             :    *  This is an uglified reverse(_BidirectionalIterator,
    1406             :    *                              _BidirectionalIterator)
    1407             :    *  overloaded for random access iterators.
    1408             :   */
    1409             :   template<typename _RandomAccessIterator>
    1410             :     void
    1411             :     __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
    1412             :               random_access_iterator_tag)
    1413             :     {
    1414             :       if (__first == __last)
    1415             :         return;
    1416             :       --__last;
    1417             :       while (__first < __last)
    1418             :         {
    1419             :           std::iter_swap(__first, __last);
    1420             :           ++__first;
    1421             :           --__last;
    1422             :         }
    1423             :     }
    1424             : 
    1425             :   /**
    1426             :    *  @brief Reverse a sequence.
    1427             :    *  @ingroup mutating_algorithms
    1428             :    *  @param  first  A bidirectional iterator.
    1429             :    *  @param  last   A bidirectional iterator.
    1430             :    *  @return   reverse() returns no value.
    1431             :    *
    1432             :    *  Reverses the order of the elements in the range @p [first,last),
    1433             :    *  so that the first element becomes the last etc.
    1434             :    *  For every @c i such that @p 0<=i<=(last-first)/2), @p reverse()
    1435             :    *  swaps @p *(first+i) and @p *(last-(i+1))
    1436             :   */
    1437             :   template<typename _BidirectionalIterator>
    1438             :     inline void
    1439             :     reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
    1440             :     {
    1441             :       // concept requirements
    1442             :       __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
    1443             :                                   _BidirectionalIterator>)
    1444             :       __glibcxx_requires_valid_range(__first, __last);
    1445             :       std::__reverse(__first, __last, std::__iterator_category(__first));
    1446             :     }
    1447             : 
    1448             :   /**
    1449             :    *  @brief Copy a sequence, reversing its elements.
    1450             :    *  @ingroup mutating_algorithms
    1451             :    *  @param  first   A bidirectional iterator.
    1452             :    *  @param  last    A bidirectional iterator.
    1453             :    *  @param  result  An output iterator.
    1454             :    *  @return  An iterator designating the end of the resulting sequence.
    1455             :    *
    1456             :    *  Copies the elements in the range @p [first,last) to the range
    1457             :    *  @p [result,result+(last-first)) such that the order of the
    1458             :    *  elements is reversed.
    1459             :    *  For every @c i such that @p 0<=i<=(last-first), @p reverse_copy()
    1460             :    *  performs the assignment @p *(result+(last-first)-i) = *(first+i).
    1461             :    *  The ranges @p [first,last) and @p [result,result+(last-first))
    1462             :    *  must not overlap.
    1463             :   */
    1464             :   template<typename _BidirectionalIterator, typename _OutputIterator>
    1465             :     _OutputIterator
    1466             :     reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
    1467             :                  _OutputIterator __result)
    1468             :     {
    1469             :       // concept requirements
    1470             :       __glibcxx_function_requires(_BidirectionalIteratorConcept<
    1471             :                                   _BidirectionalIterator>)
    1472             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    1473             :                 typename iterator_traits<_BidirectionalIterator>::value_type>)
    1474             :       __glibcxx_requires_valid_range(__first, __last);
    1475             : 
    1476             :       while (__first != __last)
    1477             :         {
    1478             :           --__last;
    1479             :           *__result = *__last;
    1480             :           ++__result;
    1481             :         }
    1482             :       return __result;
    1483             :     }
    1484             : 
    1485             :   /**
    1486             :    *  This is a helper function for the rotate algorithm specialized on RAIs.
    1487             :    *  It returns the greatest common divisor of two integer values.
    1488             :   */
    1489             :   template<typename _EuclideanRingElement>
    1490             :     _EuclideanRingElement
    1491             :     __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
    1492             :     {
    1493             :       while (__n != 0)
    1494             :         {
    1495             :           _EuclideanRingElement __t = __m % __n;
    1496             :           __m = __n;
    1497             :           __n = __t;
    1498             :         }
    1499             :       return __m;
    1500             :     }
    1501             : 
    1502             :   /// This is a helper function for the rotate algorithm.
    1503             :   template<typename _ForwardIterator>
    1504             :     void
    1505             :     __rotate(_ForwardIterator __first,
    1506             :              _ForwardIterator __middle,
    1507             :              _ForwardIterator __last,
    1508             :              forward_iterator_tag)
    1509             :     {
    1510             :       if (__first == __middle || __last  == __middle)
    1511             :         return;
    1512             : 
    1513             :       _ForwardIterator __first2 = __middle;
    1514             :       do
    1515             :         {
    1516             :           std::iter_swap(__first, __first2);
    1517             :           ++__first;
    1518             :           ++__first2;
    1519             :           if (__first == __middle)
    1520             :             __middle = __first2;
    1521             :         }
    1522             :       while (__first2 != __last);
    1523             : 
    1524             :       __first2 = __middle;
    1525             : 
    1526             :       while (__first2 != __last)
    1527             :         {
    1528             :           std::iter_swap(__first, __first2);
    1529             :           ++__first;
    1530             :           ++__first2;
    1531             :           if (__first == __middle)
    1532             :             __middle = __first2;
    1533             :           else if (__first2 == __last)
    1534             :             __first2 = __middle;
    1535             :         }
    1536             :     }
    1537             : 
    1538             :    /// This is a helper function for the rotate algorithm.
    1539             :   template<typename _BidirectionalIterator>
    1540             :     void
    1541             :     __rotate(_BidirectionalIterator __first,
    1542             :              _BidirectionalIterator __middle,
    1543             :              _BidirectionalIterator __last,
    1544             :               bidirectional_iterator_tag)
    1545             :     {
    1546             :       // concept requirements
    1547             :       __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
    1548             :                                   _BidirectionalIterator>)
    1549             : 
    1550             :       if (__first == __middle || __last  == __middle)
    1551             :         return;
    1552             : 
    1553             :       std::__reverse(__first,  __middle, bidirectional_iterator_tag());
    1554             :       std::__reverse(__middle, __last,   bidirectional_iterator_tag());
    1555             : 
    1556             :       while (__first != __middle && __middle != __last)
    1557             :         {
    1558             :           std::iter_swap(__first, --__last);
    1559             :           ++__first;
    1560             :         }
    1561             : 
    1562             :       if (__first == __middle)
    1563             :         std::__reverse(__middle, __last,   bidirectional_iterator_tag());
    1564             :       else
    1565             :         std::__reverse(__first,  __middle, bidirectional_iterator_tag());
    1566             :     }
    1567             : 
    1568             :   /// This is a helper function for the rotate algorithm.
    1569             :   template<typename _RandomAccessIterator>
    1570             :     void
    1571             :     __rotate(_RandomAccessIterator __first,
    1572             :              _RandomAccessIterator __middle,
    1573             :              _RandomAccessIterator __last,
    1574             :              random_access_iterator_tag)
    1575             :     {
    1576             :       // concept requirements
    1577             :       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
    1578             :                                   _RandomAccessIterator>)
    1579             : 
    1580             :       if (__first == __middle || __last  == __middle)
    1581             :         return;
    1582             : 
    1583             :       typedef typename iterator_traits<_RandomAccessIterator>::difference_type
    1584             :         _Distance;
    1585             :       typedef typename iterator_traits<_RandomAccessIterator>::value_type
    1586             :         _ValueType;
    1587             : 
    1588             :       _Distance __n = __last   - __first;
    1589             :       _Distance __k = __middle - __first;
    1590             : 
    1591             :       if (__k == __n - __k)
    1592             :         {
    1593             :           std::swap_ranges(__first, __middle, __middle);
    1594             :           return;
    1595             :         }
    1596             : 
    1597             :       _RandomAccessIterator __p = __first;
    1598             : 
    1599             :       for (;;)
    1600             :         {
    1601             :           if (__k < __n - __k)
    1602             :             {
    1603             :               if (__is_pod(_ValueType) && __k == 1)
    1604             :                 {
    1605             :                   _ValueType __t = _GLIBCXX_MOVE(*__p);
    1606             :                   _GLIBCXX_MOVE3(__p + 1, __p + __n, __p);
    1607             :                   *(__p + __n - 1) = _GLIBCXX_MOVE(__t);
    1608             :                   return;
    1609             :                 }
    1610             :               _RandomAccessIterator __q = __p + __k;
    1611             :               for (_Distance __i = 0; __i < __n - __k; ++ __i)
    1612             :                 {
    1613             :                   std::iter_swap(__p, __q);
    1614             :                   ++__p;
    1615             :                   ++__q;
    1616             :                 }
    1617             :               __n %= __k;
    1618             :               if (__n == 0)
    1619             :                 return;
    1620             :               std::swap(__n, __k);
    1621             :               __k = __n - __k;
    1622             :             }
    1623             :           else
    1624             :             {
    1625             :               __k = __n - __k;
    1626             :               if (__is_pod(_ValueType) && __k == 1)
    1627             :                 {
    1628             :                   _ValueType __t = _GLIBCXX_MOVE(*(__p + __n - 1));
    1629             :                   _GLIBCXX_MOVE_BACKWARD3(__p, __p + __n - 1, __p + __n);
    1630             :                   *__p = _GLIBCXX_MOVE(__t);
    1631             :                   return;
    1632             :                 }
    1633             :               _RandomAccessIterator __q = __p + __n;
    1634             :               __p = __q - __k;
    1635             :               for (_Distance __i = 0; __i < __n - __k; ++ __i)
    1636             :                 {
    1637             :                   --__p;
    1638             :                   --__q;
    1639             :                   std::iter_swap(__p, __q);
    1640             :                 }
    1641             :               __n %= __k;
    1642             :               if (__n == 0)
    1643             :                 return;
    1644             :               std::swap(__n, __k);
    1645             :             }
    1646             :         }
    1647             :     }
    1648             : 
    1649             :   /**
    1650             :    *  @brief Rotate the elements of a sequence.
    1651             :    *  @ingroup mutating_algorithms
    1652             :    *  @param  first   A forward iterator.
    1653             :    *  @param  middle  A forward iterator.
    1654             :    *  @param  last    A forward iterator.
    1655             :    *  @return  Nothing.
    1656             :    *
    1657             :    *  Rotates the elements of the range @p [first,last) by @p (middle-first)
    1658             :    *  positions so that the element at @p middle is moved to @p first, the
    1659             :    *  element at @p middle+1 is moved to @first+1 and so on for each element
    1660             :    *  in the range @p [first,last).
    1661             :    *
    1662             :    *  This effectively swaps the ranges @p [first,middle) and
    1663             :    *  @p [middle,last).
    1664             :    *
    1665             :    *  Performs @p *(first+(n+(last-middle))%(last-first))=*(first+n) for
    1666             :    *  each @p n in the range @p [0,last-first).
    1667             :   */
    1668             :   template<typename _ForwardIterator>
    1669             :     inline void
    1670             :     rotate(_ForwardIterator __first, _ForwardIterator __middle,
    1671             :            _ForwardIterator __last)
    1672             :     {
    1673             :       // concept requirements
    1674             :       __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
    1675             :                                   _ForwardIterator>)
    1676             :       __glibcxx_requires_valid_range(__first, __middle);
    1677             :       __glibcxx_requires_valid_range(__middle, __last);
    1678             : 
    1679             :       typedef typename iterator_traits<_ForwardIterator>::iterator_category
    1680             :         _IterType;
    1681             :       std::__rotate(__first, __middle, __last, _IterType());
    1682             :     }
    1683             : 
    1684             :   /**
    1685             :    *  @brief Copy a sequence, rotating its elements.
    1686             :    *  @ingroup mutating_algorithms
    1687             :    *  @param  first   A forward iterator.
    1688             :    *  @param  middle  A forward iterator.
    1689             :    *  @param  last    A forward iterator.
    1690             :    *  @param  result  An output iterator.
    1691             :    *  @return   An iterator designating the end of the resulting sequence.
    1692             :    *
    1693             :    *  Copies the elements of the range @p [first,last) to the range
    1694             :    *  beginning at @result, rotating the copied elements by @p (middle-first)
    1695             :    *  positions so that the element at @p middle is moved to @p result, the
    1696             :    *  element at @p middle+1 is moved to @result+1 and so on for each element
    1697             :    *  in the range @p [first,last).
    1698             :    *
    1699             :    *  Performs @p *(result+(n+(last-middle))%(last-first))=*(first+n) for
    1700             :    *  each @p n in the range @p [0,last-first).
    1701             :   */
    1702             :   template<typename _ForwardIterator, typename _OutputIterator>
    1703             :     _OutputIterator
    1704             :     rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
    1705             :                 _ForwardIterator __last, _OutputIterator __result)
    1706             :     {
    1707             :       // concept requirements
    1708             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    1709             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    1710             :                 typename iterator_traits<_ForwardIterator>::value_type>)
    1711             :       __glibcxx_requires_valid_range(__first, __middle);
    1712             :       __glibcxx_requires_valid_range(__middle, __last);
    1713             : 
    1714             :       return std::copy(__first, __middle,
    1715             :                        std::copy(__middle, __last, __result));
    1716             :     }
    1717             : 
    1718             :   /// This is a helper function...
    1719             :   template<typename _ForwardIterator, typename _Predicate>
    1720             :     _ForwardIterator
    1721             :     __partition(_ForwardIterator __first, _ForwardIterator __last,
    1722             :                 _Predicate __pred, forward_iterator_tag)
    1723             :     {
    1724             :       if (__first == __last)
    1725             :         return __first;
    1726             : 
    1727             :       while (__pred(*__first))
    1728             :         if (++__first == __last)
    1729             :           return __first;
    1730             : 
    1731             :       _ForwardIterator __next = __first;
    1732             : 
    1733             :       while (++__next != __last)
    1734             :         if (__pred(*__next))
    1735             :           {
    1736             :             std::iter_swap(__first, __next);
    1737             :             ++__first;
    1738             :           }
    1739             : 
    1740             :       return __first;
    1741             :     }
    1742             : 
    1743             :   /// This is a helper function...
    1744             :   template<typename _BidirectionalIterator, typename _Predicate>
    1745             :     _BidirectionalIterator
    1746             :     __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
    1747             :                 _Predicate __pred, bidirectional_iterator_tag)
    1748             :     {
    1749             :       while (true)
    1750             :         {
    1751             :           while (true)
    1752             :             if (__first == __last)
    1753             :               return __first;
    1754             :             else if (__pred(*__first))
    1755             :               ++__first;
    1756             :             else
    1757             :               break;
    1758             :           --__last;
    1759             :           while (true)
    1760             :             if (__first == __last)
    1761             :               return __first;
    1762             :             else if (!bool(__pred(*__last)))
    1763             :               --__last;
    1764             :             else
    1765             :               break;
    1766             :           std::iter_swap(__first, __last);
    1767             :           ++__first;
    1768             :         }
    1769             :     }
    1770             : 
    1771             :   // partition
    1772             : 
    1773             :   /// This is a helper function...
    1774             :   template<typename _ForwardIterator, typename _Predicate, typename _Distance>
    1775             :     _ForwardIterator
    1776             :     __inplace_stable_partition(_ForwardIterator __first,
    1777             :                                _ForwardIterator __last,
    1778             :                                _Predicate __pred, _Distance __len)
    1779             :     {
    1780             :       if (__len == 1)
    1781             :         return __pred(*__first) ? __last : __first;
    1782             :       _ForwardIterator __middle = __first;
    1783             :       std::advance(__middle, __len / 2);
    1784             :       _ForwardIterator __begin = std::__inplace_stable_partition(__first,
    1785             :                                                                  __middle,
    1786             :                                                                  __pred,
    1787             :                                                                  __len / 2);
    1788             :       _ForwardIterator __end = std::__inplace_stable_partition(__middle, __last,
    1789             :                                                                __pred,
    1790             :                                                                __len
    1791             :                                                                - __len / 2);
    1792             :       std::rotate(__begin, __middle, __end);
    1793             :       std::advance(__begin, std::distance(__middle, __end));
    1794             :       return __begin;
    1795             :     }
    1796             : 
    1797             :   /// This is a helper function...
    1798             :   template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
    1799             :            typename _Distance>
    1800             :     _ForwardIterator
    1801             :     __stable_partition_adaptive(_ForwardIterator __first,
    1802             :                                 _ForwardIterator __last,
    1803             :                                 _Predicate __pred, _Distance __len,
    1804             :                                 _Pointer __buffer,
    1805             :                                 _Distance __buffer_size)
    1806             :     {
    1807             :       if (__len <= __buffer_size)
    1808             :         {
    1809             :           _ForwardIterator __result1 = __first;
    1810             :           _Pointer __result2 = __buffer;
    1811             :           for (; __first != __last; ++__first)
    1812             :             if (__pred(*__first))
    1813             :               {
    1814             :                 *__result1 = _GLIBCXX_MOVE(*__first);
    1815             :                 ++__result1;
    1816             :               }
    1817             :             else
    1818             :               {
    1819             :                 *__result2 = _GLIBCXX_MOVE(*__first);
    1820             :                 ++__result2;
    1821             :               }
    1822             :           _GLIBCXX_MOVE3(__buffer, __result2, __result1);
    1823             :           return __result1;
    1824             :         }
    1825             :       else
    1826             :         {
    1827             :           _ForwardIterator __middle = __first;
    1828             :           std::advance(__middle, __len / 2);
    1829             :           _ForwardIterator __begin =
    1830             :             std::__stable_partition_adaptive(__first, __middle, __pred,
    1831             :                                              __len / 2, __buffer,
    1832             :                                              __buffer_size);
    1833             :           _ForwardIterator __end =
    1834             :             std::__stable_partition_adaptive(__middle, __last, __pred,
    1835             :                                              __len - __len / 2,
    1836             :                                              __buffer, __buffer_size);
    1837             :           std::rotate(__begin, __middle, __end);
    1838             :           std::advance(__begin, std::distance(__middle, __end));
    1839             :           return __begin;
    1840             :         }
    1841             :     }
    1842             : 
    1843             :   /**
    1844             :    *  @brief Move elements for which a predicate is true to the beginning
    1845             :    *         of a sequence, preserving relative ordering.
    1846             :    *  @ingroup mutating_algorithms
    1847             :    *  @param  first   A forward iterator.
    1848             :    *  @param  last    A forward iterator.
    1849             :    *  @param  pred    A predicate functor.
    1850             :    *  @return  An iterator @p middle such that @p pred(i) is true for each
    1851             :    *  iterator @p i in the range @p [first,middle) and false for each @p i
    1852             :    *  in the range @p [middle,last).
    1853             :    *
    1854             :    *  Performs the same function as @p partition() with the additional
    1855             :    *  guarantee that the relative ordering of elements in each group is
    1856             :    *  preserved, so any two elements @p x and @p y in the range
    1857             :    *  @p [first,last) such that @p pred(x)==pred(y) will have the same
    1858             :    *  relative ordering after calling @p stable_partition().
    1859             :   */
    1860             :   template<typename _ForwardIterator, typename _Predicate>
    1861             :     _ForwardIterator
    1862             :     stable_partition(_ForwardIterator __first, _ForwardIterator __last,
    1863             :                      _Predicate __pred)
    1864             :     {
    1865             :       // concept requirements
    1866             :       __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
    1867             :                                   _ForwardIterator>)
    1868             :       __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
    1869             :             typename iterator_traits<_ForwardIterator>::value_type>)
    1870             :       __glibcxx_requires_valid_range(__first, __last);
    1871             : 
    1872             :       if (__first == __last)
    1873             :         return __first;
    1874             :       else
    1875             :         {
    1876             :           typedef typename iterator_traits<_ForwardIterator>::value_type
    1877             :             _ValueType;
    1878             :           typedef typename iterator_traits<_ForwardIterator>::difference_type
    1879             :             _DistanceType;
    1880             : 
    1881             :           _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first,
    1882             :                                                                 __last);
    1883             :         if (__buf.size() > 0)
    1884             :           return
    1885             :             std::__stable_partition_adaptive(__first, __last, __pred,
    1886             :                                           _DistanceType(__buf.requested_size()),
    1887             :                                           __buf.begin(),
    1888             :                                           _DistanceType(__buf.size()));
    1889             :         else
    1890             :           return
    1891             :             std::__inplace_stable_partition(__first, __last, __pred,
    1892             :                                          _DistanceType(__buf.requested_size()));
    1893             :         }
    1894             :     }
    1895             : 
    1896             :   /// This is a helper function for the sort routines.
    1897             :   template<typename _RandomAccessIterator>
    1898             :     void
    1899           0 :     __heap_select(_RandomAccessIterator __first,
    1900             :                   _RandomAccessIterator __middle,
    1901             :                   _RandomAccessIterator __last)
    1902             :     {
    1903           0 :       std::make_heap(__first, __middle);
    1904           0 :       for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
    1905           0 :         if (*__i < *__first)
    1906           0 :           std::__pop_heap(__first, __middle, __i);
    1907           0 :     }
    1908             : 
    1909             :   /// This is a helper function for the sort routines.
    1910             :   template<typename _RandomAccessIterator, typename _Compare>
    1911             :     void
    1912             :     __heap_select(_RandomAccessIterator __first,
    1913             :                   _RandomAccessIterator __middle,
    1914             :                   _RandomAccessIterator __last, _Compare __comp)
    1915             :     {
    1916             :       std::make_heap(__first, __middle, __comp);
    1917             :       for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
    1918             :         if (__comp(*__i, *__first))
    1919             :           std::__pop_heap(__first, __middle, __i, __comp);
    1920             :     }
    1921             : 
    1922             :   // partial_sort
    1923             : 
    1924             :   /**
    1925             :    *  @brief Copy the smallest elements of a sequence.
    1926             :    *  @ingroup sorting_algorithms
    1927             :    *  @param  first   An iterator.
    1928             :    *  @param  last    Another iterator.
    1929             :    *  @param  result_first   A random-access iterator.
    1930             :    *  @param  result_last    Another random-access iterator.
    1931             :    *  @return   An iterator indicating the end of the resulting sequence.
    1932             :    *
    1933             :    *  Copies and sorts the smallest N values from the range @p [first,last)
    1934             :    *  to the range beginning at @p result_first, where the number of
    1935             :    *  elements to be copied, @p N, is the smaller of @p (last-first) and
    1936             :    *  @p (result_last-result_first).
    1937             :    *  After the sort if @p i and @j are iterators in the range
    1938             :    *  @p [result_first,result_first+N) such that @i precedes @j then
    1939             :    *  @p *j<*i is false.
    1940             :    *  The value returned is @p result_first+N.
    1941             :   */
    1942             :   template<typename _InputIterator, typename _RandomAccessIterator>
    1943             :     _RandomAccessIterator
    1944             :     partial_sort_copy(_InputIterator __first, _InputIterator __last,
    1945             :                       _RandomAccessIterator __result_first,
    1946             :                       _RandomAccessIterator __result_last)
    1947             :     {
    1948             :       typedef typename iterator_traits<_InputIterator>::value_type
    1949             :         _InputValueType;
    1950             :       typedef typename iterator_traits<_RandomAccessIterator>::value_type
    1951             :         _OutputValueType;
    1952             :       typedef typename iterator_traits<_RandomAccessIterator>::difference_type
    1953             :         _DistanceType;
    1954             : 
    1955             :       // concept requirements
    1956             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    1957             :       __glibcxx_function_requires(_ConvertibleConcept<_InputValueType,
    1958             :                                   _OutputValueType>)
    1959             :       __glibcxx_function_requires(_LessThanOpConcept<_InputValueType,
    1960             :                                                      _OutputValueType>)
    1961             :       __glibcxx_function_requires(_LessThanComparableConcept<_OutputValueType>)
    1962             :       __glibcxx_requires_valid_range(__first, __last);
    1963             :       __glibcxx_requires_valid_range(__result_first, __result_last);
    1964             : 
    1965             :       if (__result_first == __result_last)
    1966             :         return __result_last;
    1967             :       _RandomAccessIterator __result_real_last = __result_first;
    1968             :       while(__first != __last && __result_real_last != __result_last)
    1969             :         {
    1970             :           *__result_real_last = *__first;
    1971             :           ++__result_real_last;
    1972             :           ++__first;
    1973             :         }
    1974             :       std::make_heap(__result_first, __result_real_last);
    1975             :       while (__first != __last)
    1976             :         {
    1977             :           if (*__first < *__result_first)
    1978             :             std::__adjust_heap(__result_first, _DistanceType(0),
    1979             :                                _DistanceType(__result_real_last
    1980             :                                              - __result_first),
    1981             :                                _InputValueType(*__first));
    1982             :           ++__first;
    1983             :         }
    1984             :       std::sort_heap(__result_first, __result_real_last);
    1985             :       return __result_real_last;
    1986             :     }
    1987             : 
    1988             :   /**
    1989             :    *  @brief Copy the smallest elements of a sequence using a predicate for
    1990             :    *         comparison.
    1991             :    *  @ingroup sorting_algorithms
    1992             :    *  @param  first   An input iterator.
    1993             :    *  @param  last    Another input iterator.
    1994             :    *  @param  result_first   A random-access iterator.
    1995             :    *  @param  result_last    Another random-access iterator.
    1996             :    *  @param  comp    A comparison functor.
    1997             :    *  @return   An iterator indicating the end of the resulting sequence.
    1998             :    *
    1999             :    *  Copies and sorts the smallest N values from the range @p [first,last)
    2000             :    *  to the range beginning at @p result_first, where the number of
    2001             :    *  elements to be copied, @p N, is the smaller of @p (last-first) and
    2002             :    *  @p (result_last-result_first).
    2003             :    *  After the sort if @p i and @j are iterators in the range
    2004             :    *  @p [result_first,result_first+N) such that @i precedes @j then
    2005             :    *  @p comp(*j,*i) is false.
    2006             :    *  The value returned is @p result_first+N.
    2007             :   */
    2008             :   template<typename _InputIterator, typename _RandomAccessIterator, typename _Compare>
    2009             :     _RandomAccessIterator
    2010             :     partial_sort_copy(_InputIterator __first, _InputIterator __last,
    2011             :                       _RandomAccessIterator __result_first,
    2012             :                       _RandomAccessIterator __result_last,
    2013             :                       _Compare __comp)
    2014             :     {
    2015             :       typedef typename iterator_traits<_InputIterator>::value_type
    2016             :         _InputValueType;
    2017             :       typedef typename iterator_traits<_RandomAccessIterator>::value_type
    2018             :         _OutputValueType;
    2019             :       typedef typename iterator_traits<_RandomAccessIterator>::difference_type
    2020             :         _DistanceType;
    2021             : 
    2022             :       // concept requirements
    2023             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    2024             :       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
    2025             :                                   _RandomAccessIterator>)
    2026             :       __glibcxx_function_requires(_ConvertibleConcept<_InputValueType,
    2027             :                                   _OutputValueType>)
    2028             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    2029             :                                   _InputValueType, _OutputValueType>)
    2030             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    2031             :                                   _OutputValueType, _OutputValueType>)
    2032             :       __glibcxx_requires_valid_range(__first, __last);
    2033             :       __glibcxx_requires_valid_range(__result_first, __result_last);
    2034             : 
    2035             :       if (__result_first == __result_last)
    2036             :         return __result_last;
    2037             :       _RandomAccessIterator __result_real_last = __result_first;
    2038             :       while(__first != __last && __result_real_last != __result_last)
    2039             :         {
    2040             :           *__result_real_last = *__first;
    2041             :           ++__result_real_last;
    2042             :           ++__first;
    2043             :         }
    2044             :       std::make_heap(__result_first, __result_real_last, __comp);
    2045             :       while (__first != __last)
    2046             :         {
    2047             :           if (__comp(*__first, *__result_first))
    2048             :             std::__adjust_heap(__result_first, _DistanceType(0),
    2049             :                                _DistanceType(__result_real_last
    2050             :                                              - __result_first),
    2051             :                                _InputValueType(*__first),
    2052             :                                __comp);
    2053             :           ++__first;
    2054             :         }
    2055             :       std::sort_heap(__result_first, __result_real_last, __comp);
    2056             :       return __result_real_last;
    2057             :     }
    2058             : 
    2059             :   /// This is a helper function for the sort routine.
    2060             :   template<typename _RandomAccessIterator>
    2061             :     void
    2062       10283 :     __unguarded_linear_insert(_RandomAccessIterator __last)
    2063             :     {
    2064             :       typename iterator_traits<_RandomAccessIterator>::value_type
    2065       10283 :         __val = _GLIBCXX_MOVE(*__last);
    2066       10283 :       _RandomAccessIterator __next = __last;
    2067       10283 :       --__next;
    2068       33990 :       while (__val < *__next)
    2069             :         {
    2070       23707 :           *__last = _GLIBCXX_MOVE(*__next);
    2071       23707 :           __last = __next;
    2072       23707 :           --__next;
    2073             :         }
    2074       10283 :       *__last = _GLIBCXX_MOVE(__val);
    2075       10283 :     }
    2076             : 
    2077             :   /// This is a helper function for the sort routine.
    2078             :   template<typename _RandomAccessIterator, typename _Compare>
    2079             :     void
    2080             :     __unguarded_linear_insert(_RandomAccessIterator __last,
    2081             :                               _Compare __comp)
    2082             :     {
    2083             :       typename iterator_traits<_RandomAccessIterator>::value_type
    2084             :         __val = _GLIBCXX_MOVE(*__last);
    2085             :       _RandomAccessIterator __next = __last;
    2086             :       --__next;
    2087             :       while (__comp(__val, *__next))
    2088             :         {
    2089             :           *__last = _GLIBCXX_MOVE(*__next);
    2090             :           __last = __next;
    2091             :           --__next;
    2092             :         }
    2093             :       *__last = _GLIBCXX_MOVE(__val);
    2094             :     }
    2095             : 
    2096             :   /// This is a helper function for the sort routine.
    2097             :   template<typename _RandomAccessIterator>
    2098             :     void
    2099         315 :     __insertion_sort(_RandomAccessIterator __first,
    2100             :                      _RandomAccessIterator __last)
    2101             :     {
    2102         315 :       if (__first == __last)
    2103         315 :         return;
    2104             : 
    2105        3745 :       for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
    2106             :         {
    2107        3430 :           if (*__i < *__first)
    2108             :             {
    2109             :               typename iterator_traits<_RandomAccessIterator>::value_type
    2110         560 :                 __val = _GLIBCXX_MOVE(*__i);
    2111         560 :               _GLIBCXX_MOVE_BACKWARD3(__first, __i, __i + 1);
    2112         560 :               *__first = _GLIBCXX_MOVE(__val);
    2113             :             }
    2114             :           else
    2115        2870 :             std::__unguarded_linear_insert(__i);
    2116             :         }
    2117             :     }
    2118             : 
    2119             :   /// This is a helper function for the sort routine.
    2120             :   template<typename _RandomAccessIterator, typename _Compare>
    2121             :     void
    2122             :     __insertion_sort(_RandomAccessIterator __first,
    2123             :                      _RandomAccessIterator __last, _Compare __comp)
    2124             :     {
    2125             :       if (__first == __last) return;
    2126             : 
    2127             :       for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
    2128             :         {
    2129             :           if (__comp(*__i, *__first))
    2130             :             {
    2131             :               typename iterator_traits<_RandomAccessIterator>::value_type
    2132             :                 __val = _GLIBCXX_MOVE(*__i);
    2133             :               _GLIBCXX_MOVE_BACKWARD3(__first, __i, __i + 1);
    2134             :               *__first = _GLIBCXX_MOVE(__val);
    2135             :             }
    2136             :           else
    2137             :             std::__unguarded_linear_insert(__i, __comp);
    2138             :         }
    2139             :     }
    2140             : 
    2141             :   /// This is a helper function for the sort routine.
    2142             :   template<typename _RandomAccessIterator>
    2143             :     inline void
    2144         209 :     __unguarded_insertion_sort(_RandomAccessIterator __first,
    2145             :                                _RandomAccessIterator __last)
    2146             :     {
    2147             :       typedef typename iterator_traits<_RandomAccessIterator>::value_type
    2148             :         _ValueType;
    2149             : 
    2150        7622 :       for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
    2151        7413 :         std::__unguarded_linear_insert(__i);
    2152         209 :     }
    2153             : 
    2154             :   /// This is a helper function for the sort routine.
    2155             :   template<typename _RandomAccessIterator, typename _Compare>
    2156             :     inline void
    2157             :     __unguarded_insertion_sort(_RandomAccessIterator __first,
    2158             :                                _RandomAccessIterator __last, _Compare __comp)
    2159             :     {
    2160             :       typedef typename iterator_traits<_RandomAccessIterator>::value_type
    2161             :         _ValueType;
    2162             : 
    2163             :       for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
    2164             :         std::__unguarded_linear_insert(__i, __comp);
    2165             :     }
    2166             : 
    2167             :   /**
    2168             :    *  @doctodo
    2169             :    *  This controls some aspect of the sort routines.
    2170             :   */
    2171             :   enum { _S_threshold = 16 };
    2172             : 
    2173             :   /// This is a helper function for the sort routine.
    2174             :   template<typename _RandomAccessIterator>
    2175             :     void
    2176         315 :     __final_insertion_sort(_RandomAccessIterator __first,
    2177             :                            _RandomAccessIterator __last)
    2178             :     {
    2179         315 :       if (__last - __first > int(_S_threshold))
    2180             :         {
    2181         209 :           std::__insertion_sort(__first, __first + int(_S_threshold));
    2182         209 :           std::__unguarded_insertion_sort(__first + int(_S_threshold), __last);
    2183             :         }
    2184             :       else
    2185         106 :         std::__insertion_sort(__first, __last);
    2186         315 :     }
    2187             : 
    2188             :   /// This is a helper function for the sort routine.
    2189             :   template<typename _RandomAccessIterator, typename _Compare>
    2190             :     void
    2191             :     __final_insertion_sort(_RandomAccessIterator __first,
    2192             :                            _RandomAccessIterator __last, _Compare __comp)
    2193             :     {
    2194             :       if (__last - __first > int(_S_threshold))
    2195             :         {
    2196             :           std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
    2197             :           std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,
    2198             :                                           __comp);
    2199             :         }
    2200             :       else
    2201             :         std::__insertion_sort(__first, __last, __comp);
    2202             :     }
    2203             : 
    2204             :   /// This is a helper function...
    2205             :   template<typename _RandomAccessIterator, typename _Tp>
    2206             :     _RandomAccessIterator
    2207        6485 :     __unguarded_partition(_RandomAccessIterator __first,
    2208             :                           _RandomAccessIterator __last, const _Tp& __pivot)
    2209             :     {
    2210        5378 :       while (true)
    2211             :         {
    2212       25130 :           while (*__first < __pivot)
    2213       18645 :             ++__first;
    2214        6485 :           --__last;
    2215       13711 :           while (__pivot < *__last)
    2216        7226 :             --__last;
    2217        6485 :           if (!(__first < __last))
    2218        1107 :             return __first;
    2219        5378 :           std::iter_swap(__first, __last);
    2220        5378 :           ++__first;
    2221             :         }
    2222             :     }
    2223             : 
    2224             :   /// This is a helper function...
    2225             :   template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
    2226             :     _RandomAccessIterator
    2227             :     __unguarded_partition(_RandomAccessIterator __first,
    2228             :                           _RandomAccessIterator __last,
    2229             :                           const _Tp& __pivot, _Compare __comp)
    2230             :     {
    2231             :       while (true)
    2232             :         {
    2233             :           while (__comp(*__first, __pivot))
    2234             :             ++__first;
    2235             :           --__last;
    2236             :           while (__comp(__pivot, *__last))
    2237             :             --__last;
    2238             :           if (!(__first < __last))
    2239             :             return __first;
    2240             :           std::iter_swap(__first, __last);
    2241             :           ++__first;
    2242             :         }
    2243             :     }
    2244             : 
    2245             :   /// This is a helper function...
    2246             :   template<typename _RandomAccessIterator>
    2247             :     inline _RandomAccessIterator
    2248        1107 :     __unguarded_partition_pivot(_RandomAccessIterator __first,
    2249             :                                 _RandomAccessIterator __last)
    2250             :     {
    2251        1107 :       _RandomAccessIterator __mid = __first + (__last - __first) / 2;
    2252        1107 :       std::__move_median_first(__first, __mid, (__last - 1));
    2253        1107 :       return std::__unguarded_partition(__first + 1, __last, *__first);
    2254             :     }
    2255             : 
    2256             : 
    2257             :   /// This is a helper function...
    2258             :   template<typename _RandomAccessIterator, typename _Compare>
    2259             :     inline _RandomAccessIterator
    2260             :     __unguarded_partition_pivot(_RandomAccessIterator __first,
    2261             :                                 _RandomAccessIterator __last, _Compare __comp)
    2262             :     {
    2263             :       _RandomAccessIterator __mid = __first + (__last - __first) / 2;
    2264             :       std::__move_median_first(__first, __mid, (__last - 1), __comp);
    2265             :       return std::__unguarded_partition(__first + 1, __last, *__first, __comp);
    2266             :     }
    2267             : 
    2268             :   /// This is a helper function for the sort routine.
    2269             :   template<typename _RandomAccessIterator, typename _Size>
    2270             :     void
    2271        1422 :     __introsort_loop(_RandomAccessIterator __first,
    2272             :                      _RandomAccessIterator __last,
    2273             :                      _Size __depth_limit)
    2274             :     {
    2275        2529 :       while (__last - __first > int(_S_threshold))
    2276             :         {
    2277        1107 :           if (__depth_limit == 0)
    2278             :             {
    2279           0 :               _GLIBCXX_STD_A::partial_sort(__first, __last, __last);
    2280        1422 :               return;
    2281             :             }
    2282        1107 :           --__depth_limit;
    2283             :           _RandomAccessIterator __cut =
    2284        1107 :             std::__unguarded_partition_pivot(__first, __last);
    2285        1107 :           std::__introsort_loop(__cut, __last, __depth_limit);
    2286        1107 :           __last = __cut;
    2287             :         }
    2288             :     }
    2289             : 
    2290             :   /// This is a helper function for the sort routine.
    2291             :   template<typename _RandomAccessIterator, typename _Size, typename _Compare>
    2292             :     void
    2293             :     __introsort_loop(_RandomAccessIterator __first,
    2294             :                      _RandomAccessIterator __last,
    2295             :                      _Size __depth_limit, _Compare __comp)
    2296             :     {
    2297             :       while (__last - __first > int(_S_threshold))
    2298             :         {
    2299             :           if (__depth_limit == 0)
    2300             :             {
    2301             :               _GLIBCXX_STD_A::partial_sort(__first, __last, __last, __comp);
    2302             :               return;
    2303             :             }
    2304             :           --__depth_limit;
    2305             :           _RandomAccessIterator __cut =
    2306             :             std::__unguarded_partition_pivot(__first, __last, __comp);
    2307             :           std::__introsort_loop(__cut, __last, __depth_limit, __comp);
    2308             :           __last = __cut;
    2309             :         }
    2310             :     }
    2311             : 
    2312             :   // sort
    2313             : 
    2314             :   template<typename _RandomAccessIterator, typename _Size>
    2315             :     void
    2316             :     __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
    2317             :                   _RandomAccessIterator __last, _Size __depth_limit)
    2318             :     {
    2319             :       typedef typename iterator_traits<_RandomAccessIterator>::value_type
    2320             :         _ValueType;
    2321             : 
    2322             :       while (__last - __first > 3)
    2323             :         {
    2324             :           if (__depth_limit == 0)
    2325             :             {
    2326             :               std::__heap_select(__first, __nth + 1, __last);
    2327             : 
    2328             :               // Place the nth largest element in its final position.
    2329             :               std::iter_swap(__first, __nth);
    2330             :               return;
    2331             :             }
    2332             :           --__depth_limit;
    2333             :           _RandomAccessIterator __cut =
    2334             :             std::__unguarded_partition_pivot(__first, __last);
    2335             :           if (__cut <= __nth)
    2336             :             __first = __cut;
    2337             :           else
    2338             :             __last = __cut;
    2339             :         }
    2340             :       std::__insertion_sort(__first, __last);
    2341             :     }
    2342             : 
    2343             :   template<typename _RandomAccessIterator, typename _Size, typename _Compare>
    2344             :     void
    2345             :     __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
    2346             :                   _RandomAccessIterator __last, _Size __depth_limit,
    2347             :                   _Compare __comp)
    2348             :     {
    2349             :       typedef typename iterator_traits<_RandomAccessIterator>::value_type
    2350             :         _ValueType;
    2351             : 
    2352             :       while (__last - __first > 3)
    2353             :         {
    2354             :           if (__depth_limit == 0)
    2355             :             {
    2356             :               std::__heap_select(__first, __nth + 1, __last, __comp);
    2357             :               // Place the nth largest element in its final position.
    2358             :               std::iter_swap(__first, __nth);
    2359             :               return;
    2360             :             }
    2361             :           --__depth_limit;
    2362             :           _RandomAccessIterator __cut =
    2363             :             std::__unguarded_partition_pivot(__first, __last, __comp);
    2364             :           if (__cut <= __nth)
    2365             :             __first = __cut;
    2366             :           else
    2367             :             __last = __cut;
    2368             :         }
    2369             :       std::__insertion_sort(__first, __last, __comp);
    2370             :     }
    2371             : 
    2372             :   // nth_element
    2373             : 
    2374             :   // lower_bound moved to stl_algobase.h
    2375             : 
    2376             :   /**
    2377             :    *  @brief Finds the first position in which @a val could be inserted
    2378             :    *         without changing the ordering.
    2379             :    *  @ingroup binary_search_algorithms
    2380             :    *  @param  first   An iterator.
    2381             :    *  @param  last    Another iterator.
    2382             :    *  @param  val     The search term.
    2383             :    *  @param  comp    A functor to use for comparisons.
    2384             :    *  @return An iterator pointing to the first element <em>not less
    2385             :    *           than</em> @a val, or end() if every element is less
    2386             :    *           than @a val.
    2387             :    *  @ingroup binary_search_algorithms
    2388             :    *
    2389             :    *  The comparison function should have the same effects on ordering as
    2390             :    *  the function used for the initial sort.
    2391             :   */
    2392             :   template<typename _ForwardIterator, typename _Tp, typename _Compare>
    2393             :     _ForwardIterator
    2394             :     lower_bound(_ForwardIterator __first, _ForwardIterator __last,
    2395             :                 const _Tp& __val, _Compare __comp)
    2396             :     {
    2397             :       typedef typename iterator_traits<_ForwardIterator>::value_type
    2398             :         _ValueType;
    2399             :       typedef typename iterator_traits<_ForwardIterator>::difference_type
    2400             :         _DistanceType;
    2401             : 
    2402             :       // concept requirements
    2403             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    2404             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    2405             :                                   _ValueType, _Tp>)
    2406             :       __glibcxx_requires_partitioned_lower_pred(__first, __last,
    2407             :                                                 __val, __comp);
    2408             : 
    2409             :       _DistanceType __len = std::distance(__first, __last);
    2410             : 
    2411             :       while (__len > 0)
    2412             :         {
    2413             :           _DistanceType __half = __len >> 1;
    2414             :           _ForwardIterator __middle = __first;
    2415             :           std::advance(__middle, __half);
    2416             :           if (__comp(*__middle, __val))
    2417             :             {
    2418             :               __first = __middle;
    2419             :               ++__first;
    2420             :               __len = __len - __half - 1;
    2421             :             }
    2422             :           else
    2423             :             __len = __half;
    2424             :         }
    2425             :       return __first;
    2426             :     }
    2427             : 
    2428             :   /**
    2429             :    *  @brief Finds the last position in which @a val could be inserted
    2430             :    *         without changing the ordering.
    2431             :    *  @ingroup binary_search_algorithms
    2432             :    *  @param  first   An iterator.
    2433             :    *  @param  last    Another iterator.
    2434             :    *  @param  val     The search term.
    2435             :    *  @return  An iterator pointing to the first element greater than @a val,
    2436             :    *           or end() if no elements are greater than @a val.
    2437             :    *  @ingroup binary_search_algorithms
    2438             :   */
    2439             :   template<typename _ForwardIterator, typename _Tp>
    2440             :     _ForwardIterator
    2441             :     upper_bound(_ForwardIterator __first, _ForwardIterator __last,
    2442             :                 const _Tp& __val)
    2443             :     {
    2444             :       typedef typename iterator_traits<_ForwardIterator>::value_type
    2445             :         _ValueType;
    2446             :       typedef typename iterator_traits<_ForwardIterator>::difference_type
    2447             :         _DistanceType;
    2448             : 
    2449             :       // concept requirements
    2450             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    2451             :       __glibcxx_function_requires(_LessThanOpConcept<_Tp, _ValueType>)
    2452             :       __glibcxx_requires_partitioned_upper(__first, __last, __val);
    2453             : 
    2454             :       _DistanceType __len = std::distance(__first, __last);
    2455             : 
    2456             :       while (__len > 0)
    2457             :         {
    2458             :           _DistanceType __half = __len >> 1;
    2459             :           _ForwardIterator __middle = __first;
    2460             :           std::advance(__middle, __half);
    2461             :           if (__val < *__middle)
    2462             :             __len = __half;
    2463             :           else
    2464             :             {
    2465             :               __first = __middle;
    2466             :               ++__first;
    2467             :               __len = __len - __half - 1;
    2468             :             }
    2469             :         }
    2470             :       return __first;
    2471             :     }
    2472             : 
    2473             :   /**
    2474             :    *  @brief Finds the last position in which @a val could be inserted
    2475             :    *         without changing the ordering.
    2476             :    *  @ingroup binary_search_algorithms
    2477             :    *  @param  first   An iterator.
    2478             :    *  @param  last    Another iterator.
    2479             :    *  @param  val     The search term.
    2480             :    *  @param  comp    A functor to use for comparisons.
    2481             :    *  @return  An iterator pointing to the first element greater than @a val,
    2482             :    *           or end() if no elements are greater than @a val.
    2483             :    *  @ingroup binary_search_algorithms
    2484             :    *
    2485             :    *  The comparison function should have the same effects on ordering as
    2486             :    *  the function used for the initial sort.
    2487             :   */
    2488             :   template<typename _ForwardIterator, typename _Tp, typename _Compare>
    2489             :     _ForwardIterator
    2490             :     upper_bound(_ForwardIterator __first, _ForwardIterator __last,
    2491             :                 const _Tp& __val, _Compare __comp)
    2492             :     {
    2493             :       typedef typename iterator_traits<_ForwardIterator>::value_type
    2494             :         _ValueType;
    2495             :       typedef typename iterator_traits<_ForwardIterator>::difference_type
    2496             :         _DistanceType;
    2497             : 
    2498             :       // concept requirements
    2499             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    2500             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    2501             :                                   _Tp, _ValueType>)
    2502             :       __glibcxx_requires_partitioned_upper_pred(__first, __last,
    2503             :                                                 __val, __comp);
    2504             : 
    2505             :       _DistanceType __len = std::distance(__first, __last);
    2506             : 
    2507             :       while (__len > 0)
    2508             :         {
    2509             :           _DistanceType __half = __len >> 1;
    2510             :           _ForwardIterator __middle = __first;
    2511             :           std::advance(__middle, __half);
    2512             :           if (__comp(__val, *__middle))
    2513             :             __len = __half;
    2514             :           else
    2515             :             {
    2516             :               __first = __middle;
    2517             :               ++__first;
    2518             :               __len = __len - __half - 1;
    2519             :             }
    2520             :         }
    2521             :       return __first;
    2522             :     }
    2523             : 
    2524             :   /**
    2525             :    *  @brief Finds the largest subrange in which @a val could be inserted
    2526             :    *         at any place in it without changing the ordering.
    2527             :    *  @ingroup binary_search_algorithms
    2528             :    *  @param  first   An iterator.
    2529             :    *  @param  last    Another iterator.
    2530             :    *  @param  val     The search term.
    2531             :    *  @return  An pair of iterators defining the subrange.
    2532             :    *  @ingroup binary_search_algorithms
    2533             :    *
    2534             :    *  This is equivalent to
    2535             :    *  @code
    2536             :    *    std::make_pair(lower_bound(first, last, val),
    2537             :    *                   upper_bound(first, last, val))
    2538             :    *  @endcode
    2539             :    *  but does not actually call those functions.
    2540             :   */
    2541             :   template<typename _ForwardIterator, typename _Tp>
    2542             :     pair<_ForwardIterator, _ForwardIterator>
    2543             :     equal_range(_ForwardIterator __first, _ForwardIterator __last,
    2544             :                 const _Tp& __val)
    2545             :     {
    2546             :       typedef typename iterator_traits<_ForwardIterator>::value_type
    2547             :         _ValueType;
    2548             :       typedef typename iterator_traits<_ForwardIterator>::difference_type
    2549             :         _DistanceType;
    2550             : 
    2551             :       // concept requirements
    2552             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    2553             :       __glibcxx_function_requires(_LessThanOpConcept<_ValueType, _Tp>)
    2554             :       __glibcxx_function_requires(_LessThanOpConcept<_Tp, _ValueType>)    
    2555             :       __glibcxx_requires_partitioned_lower(__first, __last, __val);
    2556             :       __glibcxx_requires_partitioned_upper(__first, __last, __val);      
    2557             : 
    2558             :       _DistanceType __len = std::distance(__first, __last);
    2559             :  
    2560             :       while (__len > 0)
    2561             :         {
    2562             :           _DistanceType __half = __len >> 1;
    2563             :           _ForwardIterator __middle = __first;
    2564             :           std::advance(__middle, __half);
    2565             :           if (*__middle < __val)
    2566             :             {
    2567             :               __first = __middle;
    2568             :               ++__first;
    2569             :               __len = __len - __half - 1;
    2570             :             }
    2571             :           else if (__val < *__middle)
    2572             :             __len = __half;
    2573             :           else
    2574             :             {
    2575             :               _ForwardIterator __left = std::lower_bound(__first, __middle,
    2576             :                                                          __val);
    2577             :               std::advance(__first, __len);
    2578             :               _ForwardIterator __right = std::upper_bound(++__middle, __first,
    2579             :                                                           __val);
    2580             :               return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
    2581             :             }
    2582             :         }
    2583             :       return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
    2584             :     }
    2585             : 
    2586             :   /**
    2587             :    *  @brief Finds the largest subrange in which @a val could be inserted
    2588             :    *         at any place in it without changing the ordering.
    2589             :    *  @param  first   An iterator.
    2590             :    *  @param  last    Another iterator.
    2591             :    *  @param  val     The search term.
    2592             :    *  @param  comp    A functor to use for comparisons.
    2593             :    *  @return  An pair of iterators defining the subrange.
    2594             :    *  @ingroup binary_search_algorithms
    2595             :    *
    2596             :    *  This is equivalent to
    2597             :    *  @code
    2598             :    *    std::make_pair(lower_bound(first, last, val, comp),
    2599             :    *                   upper_bound(first, last, val, comp))
    2600             :    *  @endcode
    2601             :    *  but does not actually call those functions.
    2602             :   */
    2603             :   template<typename _ForwardIterator, typename _Tp, typename _Compare>
    2604             :     pair<_ForwardIterator, _ForwardIterator>
    2605             :     equal_range(_ForwardIterator __first, _ForwardIterator __last,
    2606             :                 const _Tp& __val, _Compare __comp)
    2607             :     {
    2608             :       typedef typename iterator_traits<_ForwardIterator>::value_type
    2609             :         _ValueType;
    2610             :       typedef typename iterator_traits<_ForwardIterator>::difference_type
    2611             :         _DistanceType;
    2612             : 
    2613             :       // concept requirements
    2614             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    2615             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    2616             :                                   _ValueType, _Tp>)
    2617             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    2618             :                                   _Tp, _ValueType>)
    2619             :       __glibcxx_requires_partitioned_lower_pred(__first, __last,
    2620             :                                                 __val, __comp);
    2621             :       __glibcxx_requires_partitioned_upper_pred(__first, __last,
    2622             :                                                 __val, __comp);
    2623             : 
    2624             :       _DistanceType __len = std::distance(__first, __last);
    2625             : 
    2626             :       while (__len > 0)
    2627             :         {
    2628             :           _DistanceType __half = __len >> 1;
    2629             :           _ForwardIterator __middle = __first;
    2630             :           std::advance(__middle, __half);
    2631             :           if (__comp(*__middle, __val))
    2632             :             {
    2633             :               __first = __middle;
    2634             :               ++__first;
    2635             :               __len = __len - __half - 1;
    2636             :             }
    2637             :           else if (__comp(__val, *__middle))
    2638             :             __len = __half;
    2639             :           else
    2640             :             {
    2641             :               _ForwardIterator __left = std::lower_bound(__first, __middle,
    2642             :                                                          __val, __comp);
    2643             :               std::advance(__first, __len);
    2644             :               _ForwardIterator __right = std::upper_bound(++__middle, __first,
    2645             :                                                           __val, __comp);
    2646             :               return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
    2647             :             }
    2648             :         }
    2649             :       return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
    2650             :     }
    2651             : 
    2652             :   /**
    2653             :    *  @brief Determines whether an element exists in a range.
    2654             :    *  @ingroup binary_search_algorithms
    2655             :    *  @param  first   An iterator.
    2656             :    *  @param  last    Another iterator.
    2657             :    *  @param  val     The search term.
    2658             :    *  @return  True if @a val (or its equivalent) is in [@a first,@a last ].
    2659             :    *
    2660             :    *  Note that this does not actually return an iterator to @a val.  For
    2661             :    *  that, use std::find or a container's specialized find member functions.
    2662             :   */
    2663             :   template<typename _ForwardIterator, typename _Tp>
    2664             :     bool
    2665             :     binary_search(_ForwardIterator __first, _ForwardIterator __last,
    2666             :                   const _Tp& __val)
    2667             :     {
    2668             :       typedef typename iterator_traits<_ForwardIterator>::value_type
    2669             :         _ValueType;
    2670             : 
    2671             :       // concept requirements
    2672             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    2673             :       __glibcxx_function_requires(_LessThanOpConcept<_Tp, _ValueType>)
    2674             :       __glibcxx_requires_partitioned_lower(__first, __last, __val);
    2675             :       __glibcxx_requires_partitioned_upper(__first, __last, __val);
    2676             : 
    2677             :       _ForwardIterator __i = std::lower_bound(__first, __last, __val);
    2678             :       return __i != __last && !(__val < *__i);
    2679             :     }
    2680             : 
    2681             :   /**
    2682             :    *  @brief Determines whether an element exists in a range.
    2683             :    *  @ingroup binary_search_algorithms
    2684             :    *  @param  first   An iterator.
    2685             :    *  @param  last    Another iterator.
    2686             :    *  @param  val     The search term.
    2687             :    *  @param  comp    A functor to use for comparisons.
    2688             :    *  @return  True if @a val (or its equivalent) is in [@a first,@a last ].
    2689             :    *
    2690             :    *  Note that this does not actually return an iterator to @a val.  For
    2691             :    *  that, use std::find or a container's specialized find member functions.
    2692             :    *
    2693             :    *  The comparison function should have the same effects on ordering as
    2694             :    *  the function used for the initial sort.
    2695             :   */
    2696             :   template<typename _ForwardIterator, typename _Tp, typename _Compare>
    2697             :     bool
    2698             :     binary_search(_ForwardIterator __first, _ForwardIterator __last,
    2699             :                   const _Tp& __val, _Compare __comp)
    2700             :     {
    2701             :       typedef typename iterator_traits<_ForwardIterator>::value_type
    2702             :         _ValueType;
    2703             : 
    2704             :       // concept requirements
    2705             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    2706             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    2707             :                                   _Tp, _ValueType>)
    2708             :       __glibcxx_requires_partitioned_lower_pred(__first, __last,
    2709             :                                                 __val, __comp);
    2710             :       __glibcxx_requires_partitioned_upper_pred(__first, __last,
    2711             :                                                 __val, __comp);
    2712             : 
    2713             :       _ForwardIterator __i = std::lower_bound(__first, __last, __val, __comp);
    2714             :       return __i != __last && !bool(__comp(__val, *__i));
    2715             :     }
    2716             : 
    2717             :   // merge
    2718             : 
    2719             :   /// This is a helper function for the __merge_adaptive routines.
    2720             :   template<typename _InputIterator1, typename _InputIterator2,
    2721             :            typename _OutputIterator>
    2722             :     void
    2723             :     __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
    2724             :                           _InputIterator2 __first2, _InputIterator2 __last2,
    2725             :                           _OutputIterator __result)
    2726             :     {
    2727             :       while (__first1 != __last1 && __first2 != __last2)
    2728             :         {
    2729             :           if (*__first2 < *__first1)
    2730             :             {
    2731             :               *__result = _GLIBCXX_MOVE(*__first2);
    2732             :               ++__first2;
    2733             :             }
    2734             :           else
    2735             :             {
    2736             :               *__result = _GLIBCXX_MOVE(*__first1);
    2737             :               ++__first1;
    2738             :             }
    2739             :           ++__result;
    2740             :         }
    2741             :       if (__first1 != __last1)
    2742             :         _GLIBCXX_MOVE3(__first1, __last1, __result);
    2743             :     }
    2744             : 
    2745             :   /// This is a helper function for the __merge_adaptive routines.
    2746             :   template<typename _InputIterator1, typename _InputIterator2,
    2747             :            typename _OutputIterator, typename _Compare>
    2748             :     void
    2749             :     __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
    2750             :                           _InputIterator2 __first2, _InputIterator2 __last2,
    2751             :                           _OutputIterator __result, _Compare __comp)
    2752             :     {
    2753             :       while (__first1 != __last1 && __first2 != __last2)
    2754             :         {
    2755             :           if (__comp(*__first2, *__first1))
    2756             :             {
    2757             :               *__result = _GLIBCXX_MOVE(*__first2);
    2758             :               ++__first2;
    2759             :             }
    2760             :           else
    2761             :             {
    2762             :               *__result = _GLIBCXX_MOVE(*__first1);
    2763             :               ++__first1;
    2764             :             }
    2765             :           ++__result;
    2766             :         }
    2767             :       if (__first1 != __last1)
    2768             :         _GLIBCXX_MOVE3(__first1, __last1, __result);
    2769             :     }
    2770             : 
    2771             :   /// This is a helper function for the __merge_adaptive routines.
    2772             :   template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
    2773             :            typename _BidirectionalIterator3>
    2774             :     void
    2775             :     __move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
    2776             :                                    _BidirectionalIterator1 __last1,
    2777             :                                    _BidirectionalIterator2 __first2,
    2778             :                                    _BidirectionalIterator2 __last2,
    2779             :                                    _BidirectionalIterator3 __result)
    2780             :     {
    2781             :       if (__first1 == __last1)
    2782             :         {
    2783             :           _GLIBCXX_MOVE_BACKWARD3(__first2, __last2, __result);
    2784             :           return;
    2785             :         }
    2786             :       else if (__first2 == __last2)
    2787             :         return;
    2788             : 
    2789             :       --__last1;
    2790             :       --__last2;
    2791             :       while (true)
    2792             :         {
    2793             :           if (*__last2 < *__last1)
    2794             :             {
    2795             :               *--__result = _GLIBCXX_MOVE(*__last1);
    2796             :               if (__first1 == __last1)
    2797             :                 {
    2798             :                   _GLIBCXX_MOVE_BACKWARD3(__first2, ++__last2, __result);
    2799             :                   return;
    2800             :                 }
    2801             :               --__last1;
    2802             :             }
    2803             :           else
    2804             :             {
    2805             :               *--__result = _GLIBCXX_MOVE(*__last2);
    2806             :               if (__first2 == __last2)
    2807             :                 return;
    2808             :               --__last2;
    2809             :             }
    2810             :         }
    2811             :     }
    2812             : 
    2813             :   /// This is a helper function for the __merge_adaptive routines.
    2814             :   template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
    2815             :            typename _BidirectionalIterator3, typename _Compare>
    2816             :     void
    2817             :     __move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
    2818             :                                    _BidirectionalIterator1 __last1,
    2819             :                                    _BidirectionalIterator2 __first2,
    2820             :                                    _BidirectionalIterator2 __last2,
    2821             :                                    _BidirectionalIterator3 __result,
    2822             :                                    _Compare __comp)
    2823             :     {
    2824             :       if (__first1 == __last1)
    2825             :         {
    2826             :           _GLIBCXX_MOVE_BACKWARD3(__first2, __last2, __result);
    2827             :           return;
    2828             :         }
    2829             :       else if (__first2 == __last2)
    2830             :         return;
    2831             : 
    2832             :       --__last1;
    2833             :       --__last2;
    2834             :       while (true)
    2835             :         {
    2836             :           if (__comp(*__last2, *__last1))
    2837             :             {
    2838             :               *--__result = _GLIBCXX_MOVE(*__last1);
    2839             :               if (__first1 == __last1)
    2840             :                 {
    2841             :                   _GLIBCXX_MOVE_BACKWARD3(__first2, ++__last2, __result);
    2842             :                   return;
    2843             :                 }
    2844             :               --__last1;
    2845             :             }
    2846             :           else
    2847             :             {
    2848             :               *--__result = _GLIBCXX_MOVE(*__last2);
    2849             :               if (__first2 == __last2)
    2850             :                 return;
    2851             :               --__last2;
    2852             :             }
    2853             :         }
    2854             :     }
    2855             : 
    2856             :   /// This is a helper function for the merge routines.
    2857             :   template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
    2858             :            typename _Distance>
    2859             :     _BidirectionalIterator1
    2860             :     __rotate_adaptive(_BidirectionalIterator1 __first,
    2861             :                       _BidirectionalIterator1 __middle,
    2862             :                       _BidirectionalIterator1 __last,
    2863             :                       _Distance __len1, _Distance __len2,
    2864             :                       _BidirectionalIterator2 __buffer,
    2865             :                       _Distance __buffer_size)
    2866             :     {
    2867             :       _BidirectionalIterator2 __buffer_end;
    2868             :       if (__len1 > __len2 && __len2 <= __buffer_size)
    2869             :         {
    2870             :           if (__len2)
    2871             :             {
    2872             :               __buffer_end = _GLIBCXX_MOVE3(__middle, __last, __buffer);
    2873             :               _GLIBCXX_MOVE_BACKWARD3(__first, __middle, __last);
    2874             :               return _GLIBCXX_MOVE3(__buffer, __buffer_end, __first);
    2875             :             }
    2876             :           else
    2877             :             return __first;
    2878             :         }
    2879             :       else if (__len1 <= __buffer_size)
    2880             :         {
    2881             :           if (__len1)
    2882             :             {
    2883             :               __buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer);
    2884             :               _GLIBCXX_MOVE3(__middle, __last, __first);
    2885             :               return _GLIBCXX_MOVE_BACKWARD3(__buffer, __buffer_end, __last);
    2886             :             }
    2887             :           else
    2888             :             return __last;
    2889             :         }
    2890             :       else
    2891             :         {
    2892             :           std::rotate(__first, __middle, __last);
    2893             :           std::advance(__first, std::distance(__middle, __last));
    2894             :           return __first;
    2895             :         }
    2896             :     }
    2897             : 
    2898             :   /// This is a helper function for the merge routines.
    2899             :   template<typename _BidirectionalIterator, typename _Distance,
    2900             :            typename _Pointer>
    2901             :     void
    2902             :     __merge_adaptive(_BidirectionalIterator __first,
    2903             :                      _BidirectionalIterator __middle,
    2904             :                      _BidirectionalIterator __last,
    2905             :                      _Distance __len1, _Distance __len2,
    2906             :                      _Pointer __buffer, _Distance __buffer_size)
    2907             :     {
    2908             :       if (__len1 <= __len2 && __len1 <= __buffer_size)
    2909             :         {
    2910             :           _Pointer __buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer);
    2911             :           std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
    2912             :                                      __first);
    2913             :         }
    2914             :       else if (__len2 <= __buffer_size)
    2915             :         {
    2916             :           _Pointer __buffer_end = _GLIBCXX_MOVE3(__middle, __last, __buffer);
    2917             :           std::__move_merge_adaptive_backward(__first, __middle, __buffer,
    2918             :                                               __buffer_end, __last);
    2919             :         }
    2920             :       else
    2921             :         {
    2922             :           _BidirectionalIterator __first_cut = __first;
    2923             :           _BidirectionalIterator __second_cut = __middle;
    2924             :           _Distance __len11 = 0;
    2925             :           _Distance __len22 = 0;
    2926             :           if (__len1 > __len2)
    2927             :             {
    2928             :               __len11 = __len1 / 2;
    2929             :               std::advance(__first_cut, __len11);
    2930             :               __second_cut = std::lower_bound(__middle, __last,
    2931             :                                               *__first_cut);
    2932             :               __len22 = std::distance(__middle, __second_cut);
    2933             :             }
    2934             :           else
    2935             :             {
    2936             :               __len22 = __len2 / 2;
    2937             :               std::advance(__second_cut, __len22);
    2938             :               __first_cut = std::upper_bound(__first, __middle,
    2939             :                                              *__second_cut);
    2940             :               __len11 = std::distance(__first, __first_cut);
    2941             :             }
    2942             :           _BidirectionalIterator __new_middle =
    2943             :             std::__rotate_adaptive(__first_cut, __middle, __second_cut,
    2944             :                                    __len1 - __len11, __len22, __buffer,
    2945             :                                    __buffer_size);
    2946             :           std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
    2947             :                                 __len22, __buffer, __buffer_size);
    2948             :           std::__merge_adaptive(__new_middle, __second_cut, __last,
    2949             :                                 __len1 - __len11,
    2950             :                                 __len2 - __len22, __buffer, __buffer_size);
    2951             :         }
    2952             :     }
    2953             : 
    2954             :   /// This is a helper function for the merge routines.
    2955             :   template<typename _BidirectionalIterator, typename _Distance, 
    2956             :            typename _Pointer, typename _Compare>
    2957             :     void
    2958             :     __merge_adaptive(_BidirectionalIterator __first,
    2959             :                      _BidirectionalIterator __middle,
    2960             :                      _BidirectionalIterator __last,
    2961             :                      _Distance __len1, _Distance __len2,
    2962             :                      _Pointer __buffer, _Distance __buffer_size,
    2963             :                      _Compare __comp)
    2964             :     {
    2965             :       if (__len1 <= __len2 && __len1 <= __buffer_size)
    2966             :         {
    2967             :           _Pointer __buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer);
    2968             :           std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
    2969             :                                      __first, __comp);
    2970             :         }
    2971             :       else if (__len2 <= __buffer_size)
    2972             :         {
    2973             :           _Pointer __buffer_end = _GLIBCXX_MOVE3(__middle, __last, __buffer);
    2974             :           std::__move_merge_adaptive_backward(__first, __middle, __buffer,
    2975             :                                               __buffer_end, __last, __comp);
    2976             :         }
    2977             :       else
    2978             :         {
    2979             :           _BidirectionalIterator __first_cut = __first;
    2980             :           _BidirectionalIterator __second_cut = __middle;
    2981             :           _Distance __len11 = 0;
    2982             :           _Distance __len22 = 0;
    2983             :           if (__len1 > __len2)
    2984             :             {
    2985             :               __len11 = __len1 / 2;
    2986             :               std::advance(__first_cut, __len11);
    2987             :               __second_cut = std::lower_bound(__middle, __last, *__first_cut,
    2988             :                                               __comp);
    2989             :               __len22 = std::distance(__middle, __second_cut);
    2990             :             }
    2991             :           else
    2992             :             {
    2993             :               __len22 = __len2 / 2;
    2994             :               std::advance(__second_cut, __len22);
    2995             :               __first_cut = std::upper_bound(__first, __middle, *__second_cut,
    2996             :                                              __comp);
    2997             :               __len11 = std::distance(__first, __first_cut);
    2998             :             }
    2999             :           _BidirectionalIterator __new_middle =
    3000             :             std::__rotate_adaptive(__first_cut, __middle, __second_cut,
    3001             :                                    __len1 - __len11, __len22, __buffer,
    3002             :                                    __buffer_size);
    3003             :           std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
    3004             :                                 __len22, __buffer, __buffer_size, __comp);
    3005             :           std::__merge_adaptive(__new_middle, __second_cut, __last,
    3006             :                                 __len1 - __len11,
    3007             :                                 __len2 - __len22, __buffer,
    3008             :                                 __buffer_size, __comp);
    3009             :         }
    3010             :     }
    3011             : 
    3012             :   /// This is a helper function for the merge routines.
    3013             :   template<typename _BidirectionalIterator, typename _Distance>
    3014             :     void
    3015             :     __merge_without_buffer(_BidirectionalIterator __first,
    3016             :                            _BidirectionalIterator __middle,
    3017             :                            _BidirectionalIterator __last,
    3018             :                            _Distance __len1, _Distance __len2)
    3019             :     {
    3020             :       if (__len1 == 0 || __len2 == 0)
    3021             :         return;
    3022             :       if (__len1 + __len2 == 2)
    3023             :         {
    3024             :           if (*__middle < *__first)
    3025             :             std::iter_swap(__first, __middle);
    3026             :           return;
    3027             :         }
    3028             :       _BidirectionalIterator __first_cut = __first;
    3029             :       _BidirectionalIterator __second_cut = __middle;
    3030             :       _Distance __len11 = 0;
    3031             :       _Distance __len22 = 0;
    3032             :       if (__len1 > __len2)
    3033             :         {
    3034             :           __len11 = __len1 / 2;
    3035             :           std::advance(__first_cut, __len11);
    3036             :           __second_cut = std::lower_bound(__middle, __last, *__first_cut);
    3037             :           __len22 = std::distance(__middle, __second_cut);
    3038             :         }
    3039             :       else
    3040             :         {
    3041             :           __len22 = __len2 / 2;
    3042             :           std::advance(__second_cut, __len22);
    3043             :           __first_cut = std::upper_bound(__first, __middle, *__second_cut);
    3044             :           __len11 = std::distance(__first, __first_cut);
    3045             :         }
    3046             :       std::rotate(__first_cut, __middle, __second_cut);
    3047             :       _BidirectionalIterator __new_middle = __first_cut;
    3048             :       std::advance(__new_middle, std::distance(__middle, __second_cut));
    3049             :       std::__merge_without_buffer(__first, __first_cut, __new_middle,
    3050             :                                   __len11, __len22);
    3051             :       std::__merge_without_buffer(__new_middle, __second_cut, __last,
    3052             :                                   __len1 - __len11, __len2 - __len22);
    3053             :     }
    3054             : 
    3055             :   /// This is a helper function for the merge routines.
    3056             :   template<typename _BidirectionalIterator, typename _Distance,
    3057             :            typename _Compare>
    3058             :     void
    3059             :     __merge_without_buffer(_BidirectionalIterator __first,
    3060             :                            _BidirectionalIterator __middle,
    3061             :                            _BidirectionalIterator __last,
    3062             :                            _Distance __len1, _Distance __len2,
    3063             :                            _Compare __comp)
    3064             :     {
    3065             :       if (__len1 == 0 || __len2 == 0)
    3066             :         return;
    3067             :       if (__len1 + __len2 == 2)
    3068             :         {
    3069             :           if (__comp(*__middle, *__first))
    3070             :             std::iter_swap(__first, __middle);
    3071             :           return;
    3072             :         }
    3073             :       _BidirectionalIterator __first_cut = __first;
    3074             :       _BidirectionalIterator __second_cut = __middle;
    3075             :       _Distance __len11 = 0;
    3076             :       _Distance __len22 = 0;
    3077             :       if (__len1 > __len2)
    3078             :         {
    3079             :           __len11 = __len1 / 2;
    3080             :           std::advance(__first_cut, __len11);
    3081             :           __second_cut = std::lower_bound(__middle, __last, *__first_cut,
    3082             :                                           __comp);
    3083             :           __len22 = std::distance(__middle, __second_cut);
    3084             :         }
    3085             :       else
    3086             :         {
    3087             :           __len22 = __len2 / 2;
    3088             :           std::advance(__second_cut, __len22);
    3089             :           __first_cut = std::upper_bound(__first, __middle, *__second_cut,
    3090             :                                          __comp);
    3091             :           __len11 = std::distance(__first, __first_cut);
    3092             :         }
    3093             :       std::rotate(__first_cut, __middle, __second_cut);
    3094             :       _BidirectionalIterator __new_middle = __first_cut;
    3095             :       std::advance(__new_middle, std::distance(__middle, __second_cut));
    3096             :       std::__merge_without_buffer(__first, __first_cut, __new_middle,
    3097             :                                   __len11, __len22, __comp);
    3098             :       std::__merge_without_buffer(__new_middle, __second_cut, __last,
    3099             :                                   __len1 - __len11, __len2 - __len22, __comp);
    3100             :     }
    3101             : 
    3102             :   /**
    3103             :    *  @brief Merges two sorted ranges in place.
    3104             :    *  @ingroup sorting_algorithms
    3105             :    *  @param  first   An iterator.
    3106             :    *  @param  middle  Another iterator.
    3107             :    *  @param  last    Another iterator.
    3108             :    *  @return  Nothing.
    3109             :    *
    3110             :    *  Merges two sorted and consecutive ranges, [first,middle) and
    3111             :    *  [middle,last), and puts the result in [first,last).  The output will
    3112             :    *  be sorted.  The sort is @e stable, that is, for equivalent
    3113             :    *  elements in the two ranges, elements from the first range will always
    3114             :    *  come before elements from the second.
    3115             :    *
    3116             :    *  If enough additional memory is available, this takes (last-first)-1
    3117             :    *  comparisons.  Otherwise an NlogN algorithm is used, where N is
    3118             :    *  distance(first,last).
    3119             :   */
    3120             :   template<typename _BidirectionalIterator>
    3121             :     void
    3122             :     inplace_merge(_BidirectionalIterator __first,
    3123             :                   _BidirectionalIterator __middle,
    3124             :                   _BidirectionalIterator __last)
    3125             :     {
    3126             :       typedef typename iterator_traits<_BidirectionalIterator>::value_type
    3127             :           _ValueType;
    3128             :       typedef typename iterator_traits<_BidirectionalIterator>::difference_type
    3129             :           _DistanceType;
    3130             : 
    3131             :       // concept requirements
    3132             :       __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
    3133             :             _BidirectionalIterator>)
    3134             :       __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
    3135             :       __glibcxx_requires_sorted(__first, __middle);
    3136             :       __glibcxx_requires_sorted(__middle, __last);
    3137             : 
    3138             :       if (__first == __middle || __middle == __last)
    3139             :         return;
    3140             : 
    3141             :       _DistanceType __len1 = std::distance(__first, __middle);
    3142             :       _DistanceType __len2 = std::distance(__middle, __last);
    3143             : 
    3144             :       _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first,
    3145             :                                                                   __last);
    3146             :       if (__buf.begin() == 0)
    3147             :         std::__merge_without_buffer(__first, __middle, __last, __len1, __len2);
    3148             :       else
    3149             :         std::__merge_adaptive(__first, __middle, __last, __len1, __len2,
    3150             :                               __buf.begin(), _DistanceType(__buf.size()));
    3151             :     }
    3152             : 
    3153             :   /**
    3154             :    *  @brief Merges two sorted ranges in place.
    3155             :    *  @ingroup sorting_algorithms
    3156             :    *  @param  first   An iterator.
    3157             :    *  @param  middle  Another iterator.
    3158             :    *  @param  last    Another iterator.
    3159             :    *  @param  comp    A functor to use for comparisons.
    3160             :    *  @return  Nothing.
    3161             :    *
    3162             :    *  Merges two sorted and consecutive ranges, [first,middle) and
    3163             :    *  [middle,last), and puts the result in [first,last).  The output will
    3164             :    *  be sorted.  The sort is @e stable, that is, for equivalent
    3165             :    *  elements in the two ranges, elements from the first range will always
    3166             :    *  come before elements from the second.
    3167             :    *
    3168             :    *  If enough additional memory is available, this takes (last-first)-1
    3169             :    *  comparisons.  Otherwise an NlogN algorithm is used, where N is
    3170             :    *  distance(first,last).
    3171             :    *
    3172             :    *  The comparison function should have the same effects on ordering as
    3173             :    *  the function used for the initial sort.
    3174             :   */
    3175             :   template<typename _BidirectionalIterator, typename _Compare>
    3176             :     void
    3177             :     inplace_merge(_BidirectionalIterator __first,
    3178             :                   _BidirectionalIterator __middle,
    3179             :                   _BidirectionalIterator __last,
    3180             :                   _Compare __comp)
    3181             :     {
    3182             :       typedef typename iterator_traits<_BidirectionalIterator>::value_type
    3183             :           _ValueType;
    3184             :       typedef typename iterator_traits<_BidirectionalIterator>::difference_type
    3185             :           _DistanceType;
    3186             : 
    3187             :       // concept requirements
    3188             :       __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<
    3189             :             _BidirectionalIterator>)
    3190             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    3191             :             _ValueType, _ValueType>)
    3192             :       __glibcxx_requires_sorted_pred(__first, __middle, __comp);
    3193             :       __glibcxx_requires_sorted_pred(__middle, __last, __comp);
    3194             : 
    3195             :       if (__first == __middle || __middle == __last)
    3196             :         return;
    3197             : 
    3198             :       const _DistanceType __len1 = std::distance(__first, __middle);
    3199             :       const _DistanceType __len2 = std::distance(__middle, __last);
    3200             : 
    3201             :       _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first,
    3202             :                                                                   __last);
    3203             :       if (__buf.begin() == 0)
    3204             :         std::__merge_without_buffer(__first, __middle, __last, __len1,
    3205             :                                     __len2, __comp);
    3206             :       else
    3207             :         std::__merge_adaptive(__first, __middle, __last, __len1, __len2,
    3208             :                               __buf.begin(), _DistanceType(__buf.size()),
    3209             :                               __comp);
    3210             :     }
    3211             : 
    3212             : 
    3213             :   /// This is a helper function for the __merge_sort_loop routines.
    3214             :   template<typename _InputIterator1, typename _InputIterator2,
    3215             :            typename _OutputIterator>
    3216             :     _OutputIterator
    3217             :     __move_merge(_InputIterator1 __first1, _InputIterator1 __last1,
    3218             :                  _InputIterator2 __first2, _InputIterator2 __last2,
    3219             :                  _OutputIterator __result)
    3220             :     {
    3221             :       while (__first1 != __last1 && __first2 != __last2)
    3222             :         {
    3223             :           if (*__first2 < *__first1)
    3224             :             {
    3225             :               *__result = _GLIBCXX_MOVE(*__first2);
    3226             :               ++__first2;
    3227             :             }
    3228             :           else
    3229             :             {
    3230             :               *__result = _GLIBCXX_MOVE(*__first1);
    3231             :               ++__first1;
    3232             :             }
    3233             :           ++__result;
    3234             :         }
    3235             :       return _GLIBCXX_MOVE3(__first2, __last2,
    3236             :                             _GLIBCXX_MOVE3(__first1, __last1,
    3237             :                                            __result));
    3238             :     }
    3239             : 
    3240             :   /// This is a helper function for the __merge_sort_loop routines.
    3241             :   template<typename _InputIterator1, typename _InputIterator2,
    3242             :            typename _OutputIterator, typename _Compare>
    3243             :     _OutputIterator
    3244             :     __move_merge(_InputIterator1 __first1, _InputIterator1 __last1,
    3245             :                  _InputIterator2 __first2, _InputIterator2 __last2,
    3246             :                  _OutputIterator __result, _Compare __comp)
    3247             :     {
    3248             :       while (__first1 != __last1 && __first2 != __last2)
    3249             :         {
    3250             :           if (__comp(*__first2, *__first1))
    3251             :             {
    3252             :               *__result = _GLIBCXX_MOVE(*__first2);
    3253             :               ++__first2;
    3254             :             }
    3255             :           else
    3256             :             {
    3257             :               *__result = _GLIBCXX_MOVE(*__first1);
    3258             :               ++__first1;
    3259             :             }
    3260             :           ++__result;
    3261             :         }
    3262             :       return _GLIBCXX_MOVE3(__first2, __last2,
    3263             :                             _GLIBCXX_MOVE3(__first1, __last1,
    3264             :                                            __result));
    3265             :     }
    3266             : 
    3267             :   template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
    3268             :            typename _Distance>
    3269             :     void
    3270             :     __merge_sort_loop(_RandomAccessIterator1 __first,
    3271             :                       _RandomAccessIterator1 __last,
    3272             :                       _RandomAccessIterator2 __result,
    3273             :                       _Distance __step_size)
    3274             :     {
    3275             :       const _Distance __two_step = 2 * __step_size;
    3276             : 
    3277             :       while (__last - __first >= __two_step)
    3278             :         {
    3279             :           __result = std::__move_merge(__first, __first + __step_size,
    3280             :                                        __first + __step_size,
    3281             :                                        __first + __two_step, __result);
    3282             :           __first += __two_step;
    3283             :         }
    3284             : 
    3285             :       __step_size = std::min(_Distance(__last - __first), __step_size);
    3286             :       std::__move_merge(__first, __first + __step_size,
    3287             :                         __first + __step_size, __last, __result);
    3288             :     }
    3289             : 
    3290             :   template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
    3291             :            typename _Distance, typename _Compare>
    3292             :     void
    3293             :     __merge_sort_loop(_RandomAccessIterator1 __first,
    3294             :                       _RandomAccessIterator1 __last,
    3295             :                       _RandomAccessIterator2 __result, _Distance __step_size,
    3296             :                       _Compare __comp)
    3297             :     {
    3298             :       const _Distance __two_step = 2 * __step_size;
    3299             : 
    3300             :       while (__last - __first >= __two_step)
    3301             :         {
    3302             :           __result = std::__move_merge(__first, __first + __step_size,
    3303             :                                        __first + __step_size,
    3304             :                                        __first + __two_step,
    3305             :                                        __result, __comp);
    3306             :           __first += __two_step;
    3307             :         }
    3308             :       __step_size = std::min(_Distance(__last - __first), __step_size);
    3309             : 
    3310             :       std::__move_merge(__first,__first + __step_size,
    3311             :                         __first + __step_size, __last, __result, __comp);
    3312             :     }
    3313             : 
    3314             :   template<typename _RandomAccessIterator, typename _Distance>
    3315             :     void
    3316             :     __chunk_insertion_sort(_RandomAccessIterator __first,
    3317             :                            _RandomAccessIterator __last,
    3318             :                            _Distance __chunk_size)
    3319             :     {
    3320             :       while (__last - __first >= __chunk_size)
    3321             :         {
    3322             :           std::__insertion_sort(__first, __first + __chunk_size);
    3323             :           __first += __chunk_size;
    3324             :         }
    3325             :       std::__insertion_sort(__first, __last);
    3326             :     }
    3327             : 
    3328             :   template<typename _RandomAccessIterator, typename _Distance,
    3329             :            typename _Compare>
    3330             :     void
    3331             :     __chunk_insertion_sort(_RandomAccessIterator __first,
    3332             :                            _RandomAccessIterator __last,
    3333             :                            _Distance __chunk_size, _Compare __comp)
    3334             :     {
    3335             :       while (__last - __first >= __chunk_size)
    3336             :         {
    3337             :           std::__insertion_sort(__first, __first + __chunk_size, __comp);
    3338             :           __first += __chunk_size;
    3339             :         }
    3340             :       std::__insertion_sort(__first, __last, __comp);
    3341             :     }
    3342             : 
    3343             :   enum { _S_chunk_size = 7 };
    3344             : 
    3345             :   template<typename _RandomAccessIterator, typename _Pointer>
    3346             :     void
    3347             :     __merge_sort_with_buffer(_RandomAccessIterator __first,
    3348             :                              _RandomAccessIterator __last,
    3349             :                              _Pointer __buffer)
    3350             :     {
    3351             :       typedef typename iterator_traits<_RandomAccessIterator>::difference_type
    3352             :         _Distance;
    3353             : 
    3354             :       const _Distance __len = __last - __first;
    3355             :       const _Pointer __buffer_last = __buffer + __len;
    3356             : 
    3357             :       _Distance __step_size = _S_chunk_size;
    3358             :       std::__chunk_insertion_sort(__first, __last, __step_size);
    3359             : 
    3360             :       while (__step_size < __len)
    3361             :         {
    3362             :           std::__merge_sort_loop(__first, __last, __buffer, __step_size);
    3363             :           __step_size *= 2;
    3364             :           std::__merge_sort_loop(__buffer, __buffer_last, __first, __step_size);
    3365             :           __step_size *= 2;
    3366             :         }
    3367             :     }
    3368             : 
    3369             :   template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
    3370             :     void
    3371             :     __merge_sort_with_buffer(_RandomAccessIterator __first,
    3372             :                              _RandomAccessIterator __last,
    3373             :                              _Pointer __buffer, _Compare __comp)
    3374             :     {
    3375             :       typedef typename iterator_traits<_RandomAccessIterator>::difference_type
    3376             :         _Distance;
    3377             : 
    3378             :       const _Distance __len = __last - __first;
    3379             :       const _Pointer __buffer_last = __buffer + __len;
    3380             : 
    3381             :       _Distance __step_size = _S_chunk_size;
    3382             :       std::__chunk_insertion_sort(__first, __last, __step_size, __comp);
    3383             : 
    3384             :       while (__step_size < __len)
    3385             :         {
    3386             :           std::__merge_sort_loop(__first, __last, __buffer,
    3387             :                                  __step_size, __comp);
    3388             :           __step_size *= 2;
    3389             :           std::__merge_sort_loop(__buffer, __buffer_last, __first,
    3390             :                                  __step_size, __comp);
    3391             :           __step_size *= 2;
    3392             :         }
    3393             :     }
    3394             : 
    3395             :   template<typename _RandomAccessIterator, typename _Pointer,
    3396             :            typename _Distance>
    3397             :     void
    3398             :     __stable_sort_adaptive(_RandomAccessIterator __first,
    3399             :                            _RandomAccessIterator __last,
    3400             :                            _Pointer __buffer, _Distance __buffer_size)
    3401             :     {
    3402             :       const _Distance __len = (__last - __first + 1) / 2;
    3403             :       const _RandomAccessIterator __middle = __first + __len;
    3404             :       if (__len > __buffer_size)
    3405             :         {
    3406             :           std::__stable_sort_adaptive(__first, __middle,
    3407             :                                       __buffer, __buffer_size);
    3408             :           std::__stable_sort_adaptive(__middle, __last,
    3409             :                                       __buffer, __buffer_size);
    3410             :         }
    3411             :       else
    3412             :         {
    3413             :           std::__merge_sort_with_buffer(__first, __middle, __buffer);
    3414             :           std::__merge_sort_with_buffer(__middle, __last, __buffer);
    3415             :         }
    3416             :       std::__merge_adaptive(__first, __middle, __last,
    3417             :                             _Distance(__middle - __first),
    3418             :                             _Distance(__last - __middle),
    3419             :                             __buffer, __buffer_size);
    3420             :     }
    3421             : 
    3422             :   template<typename _RandomAccessIterator, typename _Pointer,
    3423             :            typename _Distance, typename _Compare>
    3424             :     void
    3425             :     __stable_sort_adaptive(_RandomAccessIterator __first,
    3426             :                            _RandomAccessIterator __last,
    3427             :                            _Pointer __buffer, _Distance __buffer_size,
    3428             :                            _Compare __comp)
    3429             :     {
    3430             :       const _Distance __len = (__last - __first + 1) / 2;
    3431             :       const _RandomAccessIterator __middle = __first + __len;
    3432             :       if (__len > __buffer_size)
    3433             :         {
    3434             :           std::__stable_sort_adaptive(__first, __middle, __buffer,
    3435             :                                       __buffer_size, __comp);
    3436             :           std::__stable_sort_adaptive(__middle, __last, __buffer,
    3437             :                                       __buffer_size, __comp);
    3438             :         }
    3439             :       else
    3440             :         {
    3441             :           std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
    3442             :           std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
    3443             :         }
    3444             :       std::__merge_adaptive(__first, __middle, __last,
    3445             :                             _Distance(__middle - __first),
    3446             :                             _Distance(__last - __middle),
    3447             :                             __buffer, __buffer_size,
    3448             :                             __comp);
    3449             :     }
    3450             : 
    3451             :   /// This is a helper function for the stable sorting routines.
    3452             :   template<typename _RandomAccessIterator>
    3453             :     void
    3454             :     __inplace_stable_sort(_RandomAccessIterator __first,
    3455             :                           _RandomAccessIterator __last)
    3456             :     {
    3457             :       if (__last - __first < 15)
    3458             :         {
    3459             :           std::__insertion_sort(__first, __last);
    3460             :           return;
    3461             :         }
    3462             :       _RandomAccessIterator __middle = __first + (__last - __first) / 2;
    3463             :       std::__inplace_stable_sort(__first, __middle);
    3464             :       std::__inplace_stable_sort(__middle, __last);
    3465             :       std::__merge_without_buffer(__first, __middle, __last,
    3466             :                                   __middle - __first,
    3467             :                                   __last - __middle);
    3468             :     }
    3469             : 
    3470             :   /// This is a helper function for the stable sorting routines.
    3471             :   template<typename _RandomAccessIterator, typename _Compare>
    3472             :     void
    3473             :     __inplace_stable_sort(_RandomAccessIterator __first,
    3474             :                           _RandomAccessIterator __last, _Compare __comp)
    3475             :     {
    3476             :       if (__last - __first < 15)
    3477             :         {
    3478             :           std::__insertion_sort(__first, __last, __comp);
    3479             :           return;
    3480             :         }
    3481             :       _RandomAccessIterator __middle = __first + (__last - __first) / 2;
    3482             :       std::__inplace_stable_sort(__first, __middle, __comp);
    3483             :       std::__inplace_stable_sort(__middle, __last, __comp);
    3484             :       std::__merge_without_buffer(__first, __middle, __last,
    3485             :                                   __middle - __first,
    3486             :                                   __last - __middle,
    3487             :                                   __comp);
    3488             :     }
    3489             : 
    3490             :   // stable_sort
    3491             : 
    3492             :   // Set algorithms: includes, set_union, set_intersection, set_difference,
    3493             :   // set_symmetric_difference.  All of these algorithms have the precondition
    3494             :   // that their input ranges are sorted and the postcondition that their output
    3495             :   // ranges are sorted.
    3496             : 
    3497             :   /**
    3498             :    *  @brief Determines whether all elements of a sequence exists in a range.
    3499             :    *  @param  first1  Start of search range.
    3500             :    *  @param  last1   End of search range.
    3501             :    *  @param  first2  Start of sequence
    3502             :    *  @param  last2   End of sequence.
    3503             :    *  @return  True if each element in [first2,last2) is contained in order
    3504             :    *  within [first1,last1).  False otherwise.
    3505             :    *  @ingroup set_algorithms
    3506             :    *
    3507             :    *  This operation expects both [first1,last1) and [first2,last2) to be
    3508             :    *  sorted.  Searches for the presence of each element in [first2,last2)
    3509             :    *  within [first1,last1).  The iterators over each range only move forward,
    3510             :    *  so this is a linear algorithm.  If an element in [first2,last2) is not
    3511             :    *  found before the search iterator reaches @a last2, false is returned.
    3512             :   */
    3513             :   template<typename _InputIterator1, typename _InputIterator2>
    3514             :     bool
    3515             :     includes(_InputIterator1 __first1, _InputIterator1 __last1,
    3516             :              _InputIterator2 __first2, _InputIterator2 __last2)
    3517             :     {
    3518             :       typedef typename iterator_traits<_InputIterator1>::value_type
    3519             :         _ValueType1;
    3520             :       typedef typename iterator_traits<_InputIterator2>::value_type
    3521             :         _ValueType2;
    3522             : 
    3523             :       // concept requirements
    3524             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    3525             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    3526             :       __glibcxx_function_requires(_LessThanOpConcept<_ValueType1, _ValueType2>)
    3527             :       __glibcxx_function_requires(_LessThanOpConcept<_ValueType2, _ValueType1>)
    3528             :       __glibcxx_requires_sorted_set(__first1, __last1, __first2);
    3529             :       __glibcxx_requires_sorted_set(__first2, __last2, __first1);
    3530             : 
    3531             :       while (__first1 != __last1 && __first2 != __last2)
    3532             :         if (*__first2 < *__first1)
    3533             :           return false;
    3534             :         else if(*__first1 < *__first2)
    3535             :           ++__first1;
    3536             :         else
    3537             :           ++__first1, ++__first2;
    3538             : 
    3539             :       return __first2 == __last2;
    3540             :     }
    3541             : 
    3542             :   /**
    3543             :    *  @brief Determines whether all elements of a sequence exists in a range
    3544             :    *  using comparison.
    3545             :    *  @ingroup set_algorithms
    3546             :    *  @param  first1  Start of search range.
    3547             :    *  @param  last1   End of search range.
    3548             :    *  @param  first2  Start of sequence
    3549             :    *  @param  last2   End of sequence.
    3550             :    *  @param  comp    Comparison function to use.
    3551             :    *  @return  True if each element in [first2,last2) is contained in order
    3552             :    *  within [first1,last1) according to comp.  False otherwise.
    3553             :    *  @ingroup set_algorithms
    3554             :    *
    3555             :    *  This operation expects both [first1,last1) and [first2,last2) to be
    3556             :    *  sorted.  Searches for the presence of each element in [first2,last2)
    3557             :    *  within [first1,last1), using comp to decide.  The iterators over each
    3558             :    *  range only move forward, so this is a linear algorithm.  If an element
    3559             :    *  in [first2,last2) is not found before the search iterator reaches @a
    3560             :    *  last2, false is returned.
    3561             :   */
    3562             :   template<typename _InputIterator1, typename _InputIterator2,
    3563             :            typename _Compare>
    3564             :     bool
    3565             :     includes(_InputIterator1 __first1, _InputIterator1 __last1,
    3566             :              _InputIterator2 __first2, _InputIterator2 __last2,
    3567             :              _Compare __comp)
    3568             :     {
    3569             :       typedef typename iterator_traits<_InputIterator1>::value_type
    3570             :         _ValueType1;
    3571             :       typedef typename iterator_traits<_InputIterator2>::value_type
    3572             :         _ValueType2;
    3573             : 
    3574             :       // concept requirements
    3575             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    3576             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    3577             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    3578             :                                   _ValueType1, _ValueType2>)
    3579             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    3580             :                                   _ValueType2, _ValueType1>)
    3581             :       __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
    3582             :       __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
    3583             : 
    3584             :       while (__first1 != __last1 && __first2 != __last2)
    3585             :         if (__comp(*__first2, *__first1))
    3586             :           return false;
    3587             :         else if(__comp(*__first1, *__first2))
    3588             :           ++__first1;
    3589             :         else
    3590             :           ++__first1, ++__first2;
    3591             : 
    3592             :       return __first2 == __last2;
    3593             :     }
    3594             : 
    3595             :   // nth_element
    3596             :   // merge
    3597             :   // set_difference
    3598             :   // set_intersection
    3599             :   // set_union
    3600             :   // stable_sort
    3601             :   // set_symmetric_difference
    3602             :   // min_element
    3603             :   // max_element
    3604             : 
    3605             :   /**
    3606             :    *  @brief  Permute range into the next @a dictionary ordering.
    3607             :    *  @ingroup sorting_algorithms
    3608             :    *  @param  first  Start of range.
    3609             :    *  @param  last   End of range.
    3610             :    *  @return  False if wrapped to first permutation, true otherwise.
    3611             :    *
    3612             :    *  Treats all permutations of the range as a set of @a dictionary sorted
    3613             :    *  sequences.  Permutes the current sequence into the next one of this set.
    3614             :    *  Returns true if there are more sequences to generate.  If the sequence
    3615             :    *  is the largest of the set, the smallest is generated and false returned.
    3616             :   */
    3617             :   template<typename _BidirectionalIterator>
    3618             :     bool
    3619             :     next_permutation(_BidirectionalIterator __first,
    3620             :                      _BidirectionalIterator __last)
    3621             :     {
    3622             :       // concept requirements
    3623             :       __glibcxx_function_requires(_BidirectionalIteratorConcept<
    3624             :                                   _BidirectionalIterator>)
    3625             :       __glibcxx_function_requires(_LessThanComparableConcept<
    3626             :             typename iterator_traits<_BidirectionalIterator>::value_type>)
    3627             :       __glibcxx_requires_valid_range(__first, __last);
    3628             : 
    3629             :       if (__first == __last)
    3630             :         return false;
    3631             :       _BidirectionalIterator __i = __first;
    3632             :       ++__i;
    3633             :       if (__i == __last)
    3634             :         return false;
    3635             :       __i = __last;
    3636             :       --__i;
    3637             : 
    3638             :       for(;;)
    3639             :         {
    3640             :           _BidirectionalIterator __ii = __i;
    3641             :           --__i;
    3642             :           if (*__i < *__ii)
    3643             :             {
    3644             :               _BidirectionalIterator __j = __last;
    3645             :               while (!(*__i < *--__j))
    3646             :                 {}
    3647             :               std::iter_swap(__i, __j);
    3648             :               std::reverse(__ii, __last);
    3649             :               return true;
    3650             :             }
    3651             :           if (__i == __first)
    3652             :             {
    3653             :               std::reverse(__first, __last);
    3654             :               return false;
    3655             :             }
    3656             :         }
    3657             :     }
    3658             : 
    3659             :   /**
    3660             :    *  @brief  Permute range into the next @a dictionary ordering using
    3661             :    *          comparison functor.
    3662             :    *  @ingroup sorting_algorithms
    3663             :    *  @param  first  Start of range.
    3664             :    *  @param  last   End of range.
    3665             :    *  @param  comp   A comparison functor.
    3666             :    *  @return  False if wrapped to first permutation, true otherwise.
    3667             :    *
    3668             :    *  Treats all permutations of the range [first,last) as a set of
    3669             :    *  @a dictionary sorted sequences ordered by @a comp.  Permutes the current
    3670             :    *  sequence into the next one of this set.  Returns true if there are more
    3671             :    *  sequences to generate.  If the sequence is the largest of the set, the
    3672             :    *  smallest is generated and false returned.
    3673             :   */
    3674             :   template<typename _BidirectionalIterator, typename _Compare>
    3675             :     bool
    3676             :     next_permutation(_BidirectionalIterator __first,
    3677             :                      _BidirectionalIterator __last, _Compare __comp)
    3678             :     {
    3679             :       // concept requirements
    3680             :       __glibcxx_function_requires(_BidirectionalIteratorConcept<
    3681             :                                   _BidirectionalIterator>)
    3682             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    3683             :             typename iterator_traits<_BidirectionalIterator>::value_type,
    3684             :             typename iterator_traits<_BidirectionalIterator>::value_type>)
    3685             :       __glibcxx_requires_valid_range(__first, __last);
    3686             : 
    3687             :       if (__first == __last)
    3688             :         return false;
    3689             :       _BidirectionalIterator __i = __first;
    3690             :       ++__i;
    3691             :       if (__i == __last)
    3692             :         return false;
    3693             :       __i = __last;
    3694             :       --__i;
    3695             : 
    3696             :       for(;;)
    3697             :         {
    3698             :           _BidirectionalIterator __ii = __i;
    3699             :           --__i;
    3700             :           if (__comp(*__i, *__ii))
    3701             :             {
    3702             :               _BidirectionalIterator __j = __last;
    3703             :               while (!bool(__comp(*__i, *--__j)))
    3704             :                 {}
    3705             :               std::iter_swap(__i, __j);
    3706             :               std::reverse(__ii, __last);
    3707             :               return true;
    3708             :             }
    3709             :           if (__i == __first)
    3710             :             {
    3711             :               std::reverse(__first, __last);
    3712             :               return false;
    3713             :             }
    3714             :         }
    3715             :     }
    3716             : 
    3717             :   /**
    3718             :    *  @brief  Permute range into the previous @a dictionary ordering.
    3719             :    *  @ingroup sorting_algorithms
    3720             :    *  @param  first  Start of range.
    3721             :    *  @param  last   End of range.
    3722             :    *  @return  False if wrapped to last permutation, true otherwise.
    3723             :    *
    3724             :    *  Treats all permutations of the range as a set of @a dictionary sorted
    3725             :    *  sequences.  Permutes the current sequence into the previous one of this
    3726             :    *  set.  Returns true if there are more sequences to generate.  If the
    3727             :    *  sequence is the smallest of the set, the largest is generated and false
    3728             :    *  returned.
    3729             :   */
    3730             :   template<typename _BidirectionalIterator>
    3731             :     bool
    3732             :     prev_permutation(_BidirectionalIterator __first,
    3733             :                      _BidirectionalIterator __last)
    3734             :     {
    3735             :       // concept requirements
    3736             :       __glibcxx_function_requires(_BidirectionalIteratorConcept<
    3737             :                                   _BidirectionalIterator>)
    3738             :       __glibcxx_function_requires(_LessThanComparableConcept<
    3739             :             typename iterator_traits<_BidirectionalIterator>::value_type>)
    3740             :       __glibcxx_requires_valid_range(__first, __last);
    3741             : 
    3742             :       if (__first == __last)
    3743             :         return false;
    3744             :       _BidirectionalIterator __i = __first;
    3745             :       ++__i;
    3746             :       if (__i == __last)
    3747             :         return false;
    3748             :       __i = __last;
    3749             :       --__i;
    3750             : 
    3751             :       for(;;)
    3752             :         {
    3753             :           _BidirectionalIterator __ii = __i;
    3754             :           --__i;
    3755             :           if (*__ii < *__i)
    3756             :             {
    3757             :               _BidirectionalIterator __j = __last;
    3758             :               while (!(*--__j < *__i))
    3759             :                 {}
    3760             :               std::iter_swap(__i, __j);
    3761             :               std::reverse(__ii, __last);
    3762             :               return true;
    3763             :             }
    3764             :           if (__i == __first)
    3765             :             {
    3766             :               std::reverse(__first, __last);
    3767             :               return false;
    3768             :             }
    3769             :         }
    3770             :     }
    3771             : 
    3772             :   /**
    3773             :    *  @brief  Permute range into the previous @a dictionary ordering using
    3774             :    *          comparison functor.
    3775             :    *  @ingroup sorting_algorithms
    3776             :    *  @param  first  Start of range.
    3777             :    *  @param  last   End of range.
    3778             :    *  @param  comp   A comparison functor.
    3779             :    *  @return  False if wrapped to last permutation, true otherwise.
    3780             :    *
    3781             :    *  Treats all permutations of the range [first,last) as a set of
    3782             :    *  @a dictionary sorted sequences ordered by @a comp.  Permutes the current
    3783             :    *  sequence into the previous one of this set.  Returns true if there are
    3784             :    *  more sequences to generate.  If the sequence is the smallest of the set,
    3785             :    *  the largest is generated and false returned.
    3786             :   */
    3787             :   template<typename _BidirectionalIterator, typename _Compare>
    3788             :     bool
    3789             :     prev_permutation(_BidirectionalIterator __first,
    3790             :                      _BidirectionalIterator __last, _Compare __comp)
    3791             :     {
    3792             :       // concept requirements
    3793             :       __glibcxx_function_requires(_BidirectionalIteratorConcept<
    3794             :                                   _BidirectionalIterator>)
    3795             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    3796             :             typename iterator_traits<_BidirectionalIterator>::value_type,
    3797             :             typename iterator_traits<_BidirectionalIterator>::value_type>)
    3798             :       __glibcxx_requires_valid_range(__first, __last);
    3799             : 
    3800             :       if (__first == __last)
    3801             :         return false;
    3802             :       _BidirectionalIterator __i = __first;
    3803             :       ++__i;
    3804             :       if (__i == __last)
    3805             :         return false;
    3806             :       __i = __last;
    3807             :       --__i;
    3808             : 
    3809             :       for(;;)
    3810             :         {
    3811             :           _BidirectionalIterator __ii = __i;
    3812             :           --__i;
    3813             :           if (__comp(*__ii, *__i))
    3814             :             {
    3815             :               _BidirectionalIterator __j = __last;
    3816             :               while (!bool(__comp(*--__j, *__i)))
    3817             :                 {}
    3818             :               std::iter_swap(__i, __j);
    3819             :               std::reverse(__ii, __last);
    3820             :               return true;
    3821             :             }
    3822             :           if (__i == __first)
    3823             :             {
    3824             :               std::reverse(__first, __last);
    3825             :               return false;
    3826             :             }
    3827             :         }
    3828             :     }
    3829             : 
    3830             :   // replace
    3831             :   // replace_if
    3832             : 
    3833             :   /**
    3834             :    *  @brief Copy a sequence, replacing each element of one value with another
    3835             :    *         value.
    3836             :    *  @param  first      An input iterator.
    3837             :    *  @param  last       An input iterator.
    3838             :    *  @param  result     An output iterator.
    3839             :    *  @param  old_value  The value to be replaced.
    3840             :    *  @param  new_value  The replacement value.
    3841             :    *  @return   The end of the output sequence, @p result+(last-first).
    3842             :    *
    3843             :    *  Copies each element in the input range @p [first,last) to the
    3844             :    *  output range @p [result,result+(last-first)) replacing elements
    3845             :    *  equal to @p old_value with @p new_value.
    3846             :   */
    3847             :   template<typename _InputIterator, typename _OutputIterator, typename _Tp>
    3848             :     _OutputIterator
    3849             :     replace_copy(_InputIterator __first, _InputIterator __last,
    3850             :                  _OutputIterator __result,
    3851             :                  const _Tp& __old_value, const _Tp& __new_value)
    3852             :     {
    3853             :       // concept requirements
    3854             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    3855             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    3856             :             typename iterator_traits<_InputIterator>::value_type>)
    3857             :       __glibcxx_function_requires(_EqualOpConcept<
    3858             :             typename iterator_traits<_InputIterator>::value_type, _Tp>)
    3859             :       __glibcxx_requires_valid_range(__first, __last);
    3860             : 
    3861             :       for (; __first != __last; ++__first, ++__result)
    3862             :         if (*__first == __old_value)
    3863             :           *__result = __new_value;
    3864             :         else
    3865             :           *__result = *__first;
    3866             :       return __result;
    3867             :     }
    3868             : 
    3869             :   /**
    3870             :    *  @brief Copy a sequence, replacing each value for which a predicate
    3871             :    *         returns true with another value.
    3872             :    *  @ingroup mutating_algorithms
    3873             :    *  @param  first      An input iterator.
    3874             :    *  @param  last       An input iterator.
    3875             :    *  @param  result     An output iterator.
    3876             :    *  @param  pred       A predicate.
    3877             :    *  @param  new_value  The replacement value.
    3878             :    *  @return   The end of the output sequence, @p result+(last-first).
    3879             :    *
    3880             :    *  Copies each element in the range @p [first,last) to the range
    3881             :    *  @p [result,result+(last-first)) replacing elements for which
    3882             :    *  @p pred returns true with @p new_value.
    3883             :   */
    3884             :   template<typename _InputIterator, typename _OutputIterator,
    3885             :            typename _Predicate, typename _Tp>
    3886             :     _OutputIterator
    3887             :     replace_copy_if(_InputIterator __first, _InputIterator __last,
    3888             :                     _OutputIterator __result,
    3889             :                     _Predicate __pred, const _Tp& __new_value)
    3890             :     {
    3891             :       // concept requirements
    3892             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    3893             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    3894             :             typename iterator_traits<_InputIterator>::value_type>)
    3895             :       __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
    3896             :             typename iterator_traits<_InputIterator>::value_type>)
    3897             :       __glibcxx_requires_valid_range(__first, __last);
    3898             : 
    3899             :       for (; __first != __last; ++__first, ++__result)
    3900             :         if (__pred(*__first))
    3901             :           *__result = __new_value;
    3902             :         else
    3903             :           *__result = *__first;
    3904             :       return __result;
    3905             :     }
    3906             : 
    3907             : #ifdef __GXX_EXPERIMENTAL_CXX0X__
    3908             :   /**
    3909             :    *  @brief  Determines whether the elements of a sequence are sorted.
    3910             :    *  @ingroup sorting_algorithms
    3911             :    *  @param  first   An iterator.
    3912             :    *  @param  last    Another iterator.
    3913             :    *  @return  True if the elements are sorted, false otherwise.
    3914             :   */
    3915             :   template<typename _ForwardIterator>
    3916             :     inline bool
    3917             :     is_sorted(_ForwardIterator __first, _ForwardIterator __last)
    3918             :     { return std::is_sorted_until(__first, __last) == __last; }
    3919             : 
    3920             :   /**
    3921             :    *  @brief  Determines whether the elements of a sequence are sorted
    3922             :    *          according to a comparison functor.
    3923             :    *  @ingroup sorting_algorithms
    3924             :    *  @param  first   An iterator.
    3925             :    *  @param  last    Another iterator.
    3926             :    *  @param  comp    A comparison functor.
    3927             :    *  @return  True if the elements are sorted, false otherwise.
    3928             :   */
    3929             :   template<typename _ForwardIterator, typename _Compare>
    3930             :     inline bool
    3931             :     is_sorted(_ForwardIterator __first, _ForwardIterator __last,
    3932             :               _Compare __comp)
    3933             :     { return std::is_sorted_until(__first, __last, __comp) == __last; }
    3934             : 
    3935             :   /**
    3936             :    *  @brief  Determines the end of a sorted sequence.
    3937             :    *  @ingroup sorting_algorithms
    3938             :    *  @param  first   An iterator.
    3939             :    *  @param  last    Another iterator.
    3940             :    *  @return  An iterator pointing to the last iterator i in [first, last)
    3941             :    *           for which the range [first, i) is sorted.
    3942             :   */
    3943             :   template<typename _ForwardIterator>
    3944             :     _ForwardIterator
    3945             :     is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
    3946             :     {
    3947             :       // concept requirements
    3948             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    3949             :       __glibcxx_function_requires(_LessThanComparableConcept<
    3950             :             typename iterator_traits<_ForwardIterator>::value_type>)
    3951             :       __glibcxx_requires_valid_range(__first, __last);
    3952             : 
    3953             :       if (__first == __last)
    3954             :         return __last;
    3955             : 
    3956             :       _ForwardIterator __next = __first;
    3957             :       for (++__next; __next != __last; __first = __next, ++__next)
    3958             :         if (*__next < *__first)
    3959             :           return __next;
    3960             :       return __next;
    3961             :     }
    3962             : 
    3963             :   /**
    3964             :    *  @brief  Determines the end of a sorted sequence using comparison functor.
    3965             :    *  @ingroup sorting_algorithms
    3966             :    *  @param  first   An iterator.
    3967             :    *  @param  last    Another iterator.
    3968             :    *  @param  comp    A comparison functor.
    3969             :    *  @return  An iterator pointing to the last iterator i in [first, last)
    3970             :    *           for which the range [first, i) is sorted.
    3971             :   */
    3972             :   template<typename _ForwardIterator, typename _Compare>
    3973             :     _ForwardIterator
    3974             :     is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
    3975             :                     _Compare __comp)
    3976             :     {
    3977             :       // concept requirements
    3978             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    3979             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    3980             :             typename iterator_traits<_ForwardIterator>::value_type,
    3981             :             typename iterator_traits<_ForwardIterator>::value_type>)
    3982             :       __glibcxx_requires_valid_range(__first, __last);
    3983             : 
    3984             :       if (__first == __last)
    3985             :         return __last;
    3986             : 
    3987             :       _ForwardIterator __next = __first;
    3988             :       for (++__next; __next != __last; __first = __next, ++__next)
    3989             :         if (__comp(*__next, *__first))
    3990             :           return __next;
    3991             :       return __next;
    3992             :     }
    3993             : 
    3994             :   /**
    3995             :    *  @brief  Determines min and max at once as an ordered pair.
    3996             :    *  @ingroup sorting_algorithms
    3997             :    *  @param  a  A thing of arbitrary type.
    3998             :    *  @param  b  Another thing of arbitrary type.
    3999             :    *  @return  A pair(b, a) if b is smaller than a, pair(a, b) otherwise.
    4000             :   */
    4001             :   template<typename _Tp>
    4002             :     inline pair<const _Tp&, const _Tp&>
    4003             :     minmax(const _Tp& __a, const _Tp& __b)
    4004             :     {
    4005             :       // concept requirements
    4006             :       __glibcxx_function_requires(_LessThanComparableConcept<_Tp>)
    4007             : 
    4008             :       return __b < __a ? pair<const _Tp&, const _Tp&>(__b, __a)
    4009             :                        : pair<const _Tp&, const _Tp&>(__a, __b);
    4010             :     }
    4011             : 
    4012             :   /**
    4013             :    *  @brief  Determines min and max at once as an ordered pair.
    4014             :    *  @ingroup sorting_algorithms
    4015             :    *  @param  a  A thing of arbitrary type.
    4016             :    *  @param  b  Another thing of arbitrary type.
    4017             :    *  @param  comp  A @link comparison_functor comparison functor@endlink.
    4018             :    *  @return  A pair(b, a) if b is smaller than a, pair(a, b) otherwise.
    4019             :   */
    4020             :   template<typename _Tp, typename _Compare>
    4021             :     inline pair<const _Tp&, const _Tp&>
    4022             :     minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
    4023             :     {
    4024             :       return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a)
    4025             :                               : pair<const _Tp&, const _Tp&>(__a, __b);
    4026             :     }
    4027             : 
    4028             :   /**
    4029             :    *  @brief  Return a pair of iterators pointing to the minimum and maximum
    4030             :    *          elements in a range.
    4031             :    *  @ingroup sorting_algorithms
    4032             :    *  @param  first  Start of range.
    4033             :    *  @param  last   End of range.
    4034             :    *  @return  make_pair(m, M), where m is the first iterator i in 
    4035             :    *           [first, last) such that no other element in the range is
    4036             :    *           smaller, and where M is the last iterator i in [first, last)
    4037             :    *           such that no other element in the range is larger.
    4038             :   */
    4039             :   template<typename _ForwardIterator>
    4040             :     pair<_ForwardIterator, _ForwardIterator>
    4041             :     minmax_element(_ForwardIterator __first, _ForwardIterator __last)
    4042             :     {
    4043             :       // concept requirements
    4044             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    4045             :       __glibcxx_function_requires(_LessThanComparableConcept<
    4046             :             typename iterator_traits<_ForwardIterator>::value_type>)
    4047             :       __glibcxx_requires_valid_range(__first, __last);
    4048             : 
    4049             :       _ForwardIterator __next = __first;
    4050             :       if (__first == __last
    4051             :           || ++__next == __last)
    4052             :         return std::make_pair(__first, __first);
    4053             : 
    4054             :       _ForwardIterator __min, __max;
    4055             :       if (*__next < *__first)
    4056             :         {
    4057             :           __min = __next;
    4058             :           __max = __first;
    4059             :         }
    4060             :       else
    4061             :         {
    4062             :           __min = __first;
    4063             :           __max = __next;
    4064             :         }
    4065             : 
    4066             :       __first = __next;
    4067             :       ++__first;
    4068             : 
    4069             :       while (__first != __last)
    4070             :         {
    4071             :           __next = __first;
    4072             :           if (++__next == __last)
    4073             :             {
    4074             :               if (*__first < *__min)
    4075             :                 __min = __first;
    4076             :               else if (!(*__first < *__max))
    4077             :                 __max = __first;
    4078             :               break;
    4079             :             }
    4080             : 
    4081             :           if (*__next < *__first)
    4082             :             {
    4083             :               if (*__next < *__min)
    4084             :                 __min = __next;
    4085             :               if (!(*__first < *__max))
    4086             :                 __max = __first;
    4087             :             }
    4088             :           else
    4089             :             {
    4090             :               if (*__first < *__min)
    4091             :                 __min = __first;
    4092             :               if (!(*__next < *__max))
    4093             :                 __max = __next;
    4094             :             }
    4095             : 
    4096             :           __first = __next;
    4097             :           ++__first;
    4098             :         }
    4099             : 
    4100             :       return std::make_pair(__min, __max);
    4101             :     }
    4102             : 
    4103             :   /**
    4104             :    *  @brief  Return a pair of iterators pointing to the minimum and maximum
    4105             :    *          elements in a range.
    4106             :    *  @ingroup sorting_algorithms
    4107             :    *  @param  first  Start of range.
    4108             :    *  @param  last   End of range.
    4109             :    *  @param  comp   Comparison functor.
    4110             :    *  @return  make_pair(m, M), where m is the first iterator i in 
    4111             :    *           [first, last) such that no other element in the range is
    4112             :    *           smaller, and where M is the last iterator i in [first, last)
    4113             :    *           such that no other element in the range is larger.
    4114             :   */
    4115             :   template<typename _ForwardIterator, typename _Compare>
    4116             :     pair<_ForwardIterator, _ForwardIterator>
    4117             :     minmax_element(_ForwardIterator __first, _ForwardIterator __last,
    4118             :                    _Compare __comp)
    4119             :     {
    4120             :       // concept requirements
    4121             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    4122             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    4123             :             typename iterator_traits<_ForwardIterator>::value_type,
    4124             :             typename iterator_traits<_ForwardIterator>::value_type>)
    4125             :       __glibcxx_requires_valid_range(__first, __last);
    4126             : 
    4127             :       _ForwardIterator __next = __first;
    4128             :       if (__first == __last
    4129             :           || ++__next == __last)
    4130             :         return std::make_pair(__first, __first);
    4131             : 
    4132             :       _ForwardIterator __min, __max;
    4133             :       if (__comp(*__next, *__first))
    4134             :         {
    4135             :           __min = __next;
    4136             :           __max = __first;
    4137             :         }
    4138             :       else
    4139             :         {
    4140             :           __min = __first;
    4141             :           __max = __next;
    4142             :         }
    4143             : 
    4144             :       __first = __next;
    4145             :       ++__first;
    4146             : 
    4147             :       while (__first != __last)
    4148             :         {
    4149             :           __next = __first;
    4150             :           if (++__next == __last)
    4151             :             {
    4152             :               if (__comp(*__first, *__min))
    4153             :                 __min = __first;
    4154             :               else if (!__comp(*__first, *__max))
    4155             :                 __max = __first;
    4156             :               break;
    4157             :             }
    4158             : 
    4159             :           if (__comp(*__next, *__first))
    4160             :             {
    4161             :               if (__comp(*__next, *__min))
    4162             :                 __min = __next;
    4163             :               if (!__comp(*__first, *__max))
    4164             :                 __max = __first;
    4165             :             }
    4166             :           else
    4167             :             {
    4168             :               if (__comp(*__first, *__min))
    4169             :                 __min = __first;
    4170             :               if (!__comp(*__next, *__max))
    4171             :                 __max = __next;
    4172             :             }
    4173             : 
    4174             :           __first = __next;
    4175             :           ++__first;
    4176             :         }
    4177             : 
    4178             :       return std::make_pair(__min, __max);
    4179             :     }
    4180             : 
    4181             :   // N2722 + DR 915.
    4182             :   template<typename _Tp>
    4183             :     inline _Tp
    4184             :     min(initializer_list<_Tp> __l)
    4185             :     { return *std::min_element(__l.begin(), __l.end()); }
    4186             : 
    4187             :   template<typename _Tp, typename _Compare>
    4188             :     inline _Tp
    4189             :     min(initializer_list<_Tp> __l, _Compare __comp)
    4190             :     { return *std::min_element(__l.begin(), __l.end(), __comp); }
    4191             : 
    4192             :   template<typename _Tp>
    4193             :     inline _Tp
    4194             :     max(initializer_list<_Tp> __l)
    4195             :     { return *std::max_element(__l.begin(), __l.end()); }
    4196             : 
    4197             :   template<typename _Tp, typename _Compare>
    4198             :     inline _Tp
    4199             :     max(initializer_list<_Tp> __l, _Compare __comp)
    4200             :     { return *std::max_element(__l.begin(), __l.end(), __comp); }
    4201             : 
    4202             :   template<typename _Tp>
    4203             :     inline pair<_Tp, _Tp>
    4204             :     minmax(initializer_list<_Tp> __l)
    4205             :     {
    4206             :       pair<const _Tp*, const _Tp*> __p =
    4207             :         std::minmax_element(__l.begin(), __l.end());
    4208             :       return std::make_pair(*__p.first, *__p.second);
    4209             :     }
    4210             : 
    4211             :   template<typename _Tp, typename _Compare>
    4212             :     inline pair<_Tp, _Tp>
    4213             :     minmax(initializer_list<_Tp> __l, _Compare __comp)
    4214             :     {
    4215             :       pair<const _Tp*, const _Tp*> __p =
    4216             :         std::minmax_element(__l.begin(), __l.end(), __comp);
    4217             :       return std::make_pair(*__p.first, *__p.second);
    4218             :     }
    4219             : 
    4220             :   /**
    4221             :    *  @brief  Checks whether a permutaion of the second sequence is equal
    4222             :    *          to the first sequence.
    4223             :    *  @ingroup non_mutating_algorithms
    4224             :    *  @param  first1  Start of first range.
    4225             :    *  @param  last1   End of first range.
    4226             :    *  @param  first2  Start of second range.
    4227             :    *  @return true if there exists a permutation of the elements in the range
    4228             :    *          [first2, first2 + (last1 - first1)), beginning with 
    4229             :    *          ForwardIterator2 begin, such that equal(first1, last1, begin)
    4230             :    *          returns true; otherwise, returns false.
    4231             :   */
    4232             :   template<typename _ForwardIterator1, typename _ForwardIterator2>
    4233             :     bool
    4234             :     is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
    4235             :                    _ForwardIterator2 __first2)
    4236             :     {
    4237             :       // Efficiently compare identical prefixes:  O(N) if sequences
    4238             :       // have the same elements in the same order.
    4239             :       for (; __first1 != __last1; ++__first1, ++__first2)
    4240             :         if (!(*__first1 == *__first2))
    4241             :           break;
    4242             : 
    4243             :       if (__first1 == __last1)
    4244             :         return true;
    4245             : 
    4246             :       // Establish __last2 assuming equal ranges by iterating over the
    4247             :       // rest of the list.
    4248             :       _ForwardIterator2 __last2 = __first2;
    4249             :       std::advance(__last2, std::distance(__first1, __last1));
    4250             :       for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
    4251             :         {
    4252             :           if (__scan != _GLIBCXX_STD_A::find(__first1, __scan, *__scan))
    4253             :             continue; // We've seen this one before.
    4254             : 
    4255             :           auto __matches = std::count(__first2, __last2, *__scan);
    4256             :           if (0 == __matches
    4257             :               || std::count(__scan, __last1, *__scan) != __matches)
    4258             :             return false;
    4259             :         }
    4260             :       return true;
    4261             :     }
    4262             : 
    4263             :   /**
    4264             :    *  @brief  Checks whether a permutation of the second sequence is equal
    4265             :    *          to the first sequence.
    4266             :    *  @ingroup non_mutating_algorithms
    4267             :    *  @param  first1  Start of first range.
    4268             :    *  @param  last1   End of first range.
    4269             :    *  @param  first2  Start of second range.
    4270             :    *  @param  pred    A binary predicate.
    4271             :    *  @return true if there exists a permutation of the elements in the range
    4272             :    *          [first2, first2 + (last1 - first1)), beginning with 
    4273             :    *          ForwardIterator2 begin, such that equal(first1, last1, begin,
    4274             :    *          pred) returns true; otherwise, returns false.
    4275             :   */
    4276             :   template<typename _ForwardIterator1, typename _ForwardIterator2,
    4277             :            typename _BinaryPredicate>
    4278             :     bool
    4279             :     is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
    4280             :                    _ForwardIterator2 __first2, _BinaryPredicate __pred)
    4281             :     {
    4282             :       // Efficiently compare identical prefixes:  O(N) if sequences
    4283             :       // have the same elements in the same order.
    4284             :       for (; __first1 != __last1; ++__first1, ++__first2)
    4285             :         if (!bool(__pred(*__first1, *__first2)))
    4286             :           break;
    4287             : 
    4288             :       if (__first1 == __last1)
    4289             :         return true;
    4290             : 
    4291             :       // Establish __last2 assuming equal ranges by iterating over the
    4292             :       // rest of the list.
    4293             :       _ForwardIterator2 __last2 = __first2;
    4294             :       std::advance(__last2, std::distance(__first1, __last1));
    4295             :       for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
    4296             :         {
    4297             :           using std::placeholders::_1;
    4298             : 
    4299             :           if (__scan != _GLIBCXX_STD_A::find_if(__first1, __scan,
    4300             :                                                 std::bind(__pred, _1, *__scan)))
    4301             :             continue; // We've seen this one before.
    4302             :           
    4303             :           auto __matches = std::count_if(__first2, __last2,
    4304             :                                          std::bind(__pred, _1, *__scan));
    4305             :           if (0 == __matches
    4306             :               || std::count_if(__scan, __last1,
    4307             :                                std::bind(__pred, _1, *__scan)) != __matches)
    4308             :             return false;
    4309             :         }
    4310             :       return true;
    4311             :     }
    4312             : 
    4313             : #ifdef _GLIBCXX_USE_C99_STDINT_TR1
    4314             :   /**
    4315             :    *  @brief Shuffle the elements of a sequence using a uniform random
    4316             :    *         number generator.
    4317             :    *  @ingroup mutating_algorithms
    4318             :    *  @param  first   A forward iterator.
    4319             :    *  @param  last    A forward iterator.
    4320             :    *  @param  g       A UniformRandomNumberGenerator (26.5.1.3).
    4321             :    *  @return  Nothing.
    4322             :    *
    4323             :    *  Reorders the elements in the range @p [first,last) using @p g to
    4324             :    *  provide random numbers.
    4325             :   */
    4326             :   template<typename _RandomAccessIterator,
    4327             :            typename _UniformRandomNumberGenerator>
    4328             :     void
    4329             :     shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
    4330             :             _UniformRandomNumberGenerator&& __g)
    4331             :     {
    4332             :       // concept requirements
    4333             :       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
    4334             :             _RandomAccessIterator>)
    4335             :       __glibcxx_requires_valid_range(__first, __last);
    4336             : 
    4337             :       if (__first == __last)
    4338             :         return;
    4339             : 
    4340             :       typedef typename iterator_traits<_RandomAccessIterator>::difference_type
    4341             :         _DistanceType;
    4342             : 
    4343             :       typedef typename std::make_unsigned<_DistanceType>::type __ud_type;
    4344             :       typedef typename std::uniform_int_distribution<__ud_type> __distr_type;
    4345             :       typedef typename __distr_type::param_type __p_type;
    4346             :       __distr_type __d;
    4347             : 
    4348             :       for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
    4349             :         std::iter_swap(__i, __first + __d(__g, __p_type(0, __i - __first)));
    4350             :     }
    4351             : #endif
    4352             : 
    4353             : #endif // __GXX_EXPERIMENTAL_CXX0X__
    4354             : 
    4355             : _GLIBCXX_END_NAMESPACE_VERSION
    4356             : 
    4357             : _GLIBCXX_BEGIN_NAMESPACE_ALGO
    4358             : 
    4359             :   /**
    4360             :    *  @brief Apply a function to every element of a sequence.
    4361             :    *  @ingroup non_mutating_algorithms
    4362             :    *  @param  first  An input iterator.
    4363             :    *  @param  last   An input iterator.
    4364             :    *  @param  f      A unary function object.
    4365             :    *  @return   @p f (std::move(@p f) in C++0x).
    4366             :    *
    4367             :    *  Applies the function object @p f to each element in the range
    4368             :    *  @p [first,last).  @p f must not modify the order of the sequence.
    4369             :    *  If @p f has a return value it is ignored.
    4370             :   */
    4371             :   template<typename _InputIterator, typename _Function>
    4372             :     _Function
    4373             :     for_each(_InputIterator __first, _InputIterator __last, _Function __f)
    4374             :     {
    4375             :       // concept requirements
    4376             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    4377             :       __glibcxx_requires_valid_range(__first, __last);
    4378             :       for (; __first != __last; ++__first)
    4379             :         __f(*__first);
    4380             :       return _GLIBCXX_MOVE(__f);
    4381             :     }
    4382             : 
    4383             :   /**
    4384             :    *  @brief Find the first occurrence of a value in a sequence.
    4385             :    *  @ingroup non_mutating_algorithms
    4386             :    *  @param  first  An input iterator.
    4387             :    *  @param  last   An input iterator.
    4388             :    *  @param  val    The value to find.
    4389             :    *  @return   The first iterator @c i in the range @p [first,last)
    4390             :    *  such that @c *i == @p val, or @p last if no such iterator exists.
    4391             :   */
    4392             :   template<typename _InputIterator, typename _Tp>
    4393             :     inline _InputIterator
    4394          35 :     find(_InputIterator __first, _InputIterator __last,
    4395             :          const _Tp& __val)
    4396             :     {
    4397             :       // concept requirements
    4398             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    4399             :       __glibcxx_function_requires(_EqualOpConcept<
    4400             :                 typename iterator_traits<_InputIterator>::value_type, _Tp>)
    4401             :       __glibcxx_requires_valid_range(__first, __last);
    4402             :       return std::__find(__first, __last, __val,
    4403          35 :                          std::__iterator_category(__first));
    4404             :     }
    4405             : 
    4406             :   /**
    4407             :    *  @brief Find the first element in a sequence for which a
    4408             :    *         predicate is true.
    4409             :    *  @ingroup non_mutating_algorithms
    4410             :    *  @param  first  An input iterator.
    4411             :    *  @param  last   An input iterator.
    4412             :    *  @param  pred   A predicate.
    4413             :    *  @return   The first iterator @c i in the range @p [first,last)
    4414             :    *  such that @p pred(*i) is true, or @p last if no such iterator exists.
    4415             :   */
    4416             :   template<typename _InputIterator, typename _Predicate>
    4417             :     inline _InputIterator
    4418           0 :     find_if(_InputIterator __first, _InputIterator __last,
    4419             :             _Predicate __pred)
    4420             :     {
    4421             :       // concept requirements
    4422             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    4423             :       __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
    4424             :               typename iterator_traits<_InputIterator>::value_type>)
    4425             :       __glibcxx_requires_valid_range(__first, __last);
    4426             :       return std::__find_if(__first, __last, __pred,
    4427           0 :                             std::__iterator_category(__first));
    4428             :     }
    4429             : 
    4430             :   /**
    4431             :    *  @brief  Find element from a set in a sequence.
    4432             :    *  @ingroup non_mutating_algorithms
    4433             :    *  @param  first1  Start of range to search.
    4434             :    *  @param  last1   End of range to search.
    4435             :    *  @param  first2  Start of match candidates.
    4436             :    *  @param  last2   End of match candidates.
    4437             :    *  @return   The first iterator @c i in the range
    4438             :    *  @p [first1,last1) such that @c *i == @p *(i2) such that i2 is an
    4439             :    *  iterator in [first2,last2), or @p last1 if no such iterator exists.
    4440             :    *
    4441             :    *  Searches the range @p [first1,last1) for an element that is equal to
    4442             :    *  some element in the range [first2,last2).  If found, returns an iterator
    4443             :    *  in the range [first1,last1), otherwise returns @p last1.
    4444             :   */
    4445             :   template<typename _InputIterator, typename _ForwardIterator>
    4446             :     _InputIterator
    4447             :     find_first_of(_InputIterator __first1, _InputIterator __last1,
    4448             :                   _ForwardIterator __first2, _ForwardIterator __last2)
    4449             :     {
    4450             :       // concept requirements
    4451             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    4452             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    4453             :       __glibcxx_function_requires(_EqualOpConcept<
    4454             :             typename iterator_traits<_InputIterator>::value_type,
    4455             :             typename iterator_traits<_ForwardIterator>::value_type>)
    4456             :       __glibcxx_requires_valid_range(__first1, __last1);
    4457             :       __glibcxx_requires_valid_range(__first2, __last2);
    4458             : 
    4459             :       for (; __first1 != __last1; ++__first1)
    4460             :         for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
    4461             :           if (*__first1 == *__iter)
    4462             :             return __first1;
    4463             :       return __last1;
    4464             :     }
    4465             : 
    4466             :   /**
    4467             :    *  @brief  Find element from a set in a sequence using a predicate.
    4468             :    *  @ingroup non_mutating_algorithms
    4469             :    *  @param  first1  Start of range to search.
    4470             :    *  @param  last1   End of range to search.
    4471             :    *  @param  first2  Start of match candidates.
    4472             :    *  @param  last2   End of match candidates.
    4473             :    *  @param  comp    Predicate to use.
    4474             :    *  @return   The first iterator @c i in the range
    4475             :    *  @p [first1,last1) such that @c comp(*i, @p *(i2)) is true and i2 is an
    4476             :    *  iterator in [first2,last2), or @p last1 if no such iterator exists.
    4477             :    *
    4478             : 
    4479             :    *  Searches the range @p [first1,last1) for an element that is
    4480             :    *  equal to some element in the range [first2,last2).  If found,
    4481             :    *  returns an iterator in the range [first1,last1), otherwise
    4482             :    *  returns @p last1.
    4483             :   */
    4484             :   template<typename _InputIterator, typename _ForwardIterator,
    4485             :            typename _BinaryPredicate>
    4486             :     _InputIterator
    4487             :     find_first_of(_InputIterator __first1, _InputIterator __last1,
    4488             :                   _ForwardIterator __first2, _ForwardIterator __last2,
    4489             :                   _BinaryPredicate __comp)
    4490             :     {
    4491             :       // concept requirements
    4492             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    4493             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    4494             :       __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
    4495             :             typename iterator_traits<_InputIterator>::value_type,
    4496             :             typename iterator_traits<_ForwardIterator>::value_type>)
    4497             :       __glibcxx_requires_valid_range(__first1, __last1);
    4498             :       __glibcxx_requires_valid_range(__first2, __last2);
    4499             : 
    4500             :       for (; __first1 != __last1; ++__first1)
    4501             :         for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
    4502             :           if (__comp(*__first1, *__iter))
    4503             :             return __first1;
    4504             :       return __last1;
    4505             :     }
    4506             : 
    4507             :   /**
    4508             :    *  @brief Find two adjacent values in a sequence that are equal.
    4509             :    *  @ingroup non_mutating_algorithms
    4510             :    *  @param  first  A forward iterator.
    4511             :    *  @param  last   A forward iterator.
    4512             :    *  @return   The first iterator @c i such that @c i and @c i+1 are both
    4513             :    *  valid iterators in @p [first,last) and such that @c *i == @c *(i+1),
    4514             :    *  or @p last if no such iterator exists.
    4515             :   */
    4516             :   template<typename _ForwardIterator>
    4517             :     _ForwardIterator
    4518             :     adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
    4519             :     {
    4520             :       // concept requirements
    4521             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    4522             :       __glibcxx_function_requires(_EqualityComparableConcept<
    4523             :             typename iterator_traits<_ForwardIterator>::value_type>)
    4524             :       __glibcxx_requires_valid_range(__first, __last);
    4525             :       if (__first == __last)
    4526             :         return __last;
    4527             :       _ForwardIterator __next = __first;
    4528             :       while(++__next != __last)
    4529             :         {
    4530             :           if (*__first == *__next)
    4531             :             return __first;
    4532             :           __first = __next;
    4533             :         }
    4534             :       return __last;
    4535             :     }
    4536             : 
    4537             :   /**
    4538             :    *  @brief Find two adjacent values in a sequence using a predicate.
    4539             :    *  @ingroup non_mutating_algorithms
    4540             :    *  @param  first         A forward iterator.
    4541             :    *  @param  last          A forward iterator.
    4542             :    *  @param  binary_pred   A binary predicate.
    4543             :    *  @return   The first iterator @c i such that @c i and @c i+1 are both
    4544             :    *  valid iterators in @p [first,last) and such that
    4545             :    *  @p binary_pred(*i,*(i+1)) is true, or @p last if no such iterator
    4546             :    *  exists.
    4547             :   */
    4548             :   template<typename _ForwardIterator, typename _BinaryPredicate>
    4549             :     _ForwardIterator
    4550             :     adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
    4551             :                   _BinaryPredicate __binary_pred)
    4552             :     {
    4553             :       // concept requirements
    4554             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    4555             :       __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
    4556             :             typename iterator_traits<_ForwardIterator>::value_type,
    4557             :             typename iterator_traits<_ForwardIterator>::value_type>)
    4558             :       __glibcxx_requires_valid_range(__first, __last);
    4559             :       if (__first == __last)
    4560             :         return __last;
    4561             :       _ForwardIterator __next = __first;
    4562             :       while(++__next != __last)
    4563             :         {
    4564             :           if (__binary_pred(*__first, *__next))
    4565             :             return __first;
    4566             :           __first = __next;
    4567             :         }
    4568             :       return __last;
    4569             :     }
    4570             : 
    4571             :   /**
    4572             :    *  @brief Count the number of copies of a value in a sequence.
    4573             :    *  @ingroup non_mutating_algorithms
    4574             :    *  @param  first  An input iterator.
    4575             :    *  @param  last   An input iterator.
    4576             :    *  @param  value  The value to be counted.
    4577             :    *  @return   The number of iterators @c i in the range @p [first,last)
    4578             :    *  for which @c *i == @p value
    4579             :   */
    4580             :   template<typename _InputIterator, typename _Tp>
    4581             :     typename iterator_traits<_InputIterator>::difference_type
    4582             :     count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
    4583             :     {
    4584             :       // concept requirements
    4585             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    4586             :       __glibcxx_function_requires(_EqualOpConcept<
    4587             :         typename iterator_traits<_InputIterator>::value_type, _Tp>)
    4588             :       __glibcxx_requires_valid_range(__first, __last);
    4589             :       typename iterator_traits<_InputIterator>::difference_type __n = 0;
    4590             :       for (; __first != __last; ++__first)
    4591             :         if (*__first == __value)
    4592             :           ++__n;
    4593             :       return __n;
    4594             :     }
    4595             : 
    4596             :   /**
    4597             :    *  @brief Count the elements of a sequence for which a predicate is true.
    4598             :    *  @ingroup non_mutating_algorithms
    4599             :    *  @param  first  An input iterator.
    4600             :    *  @param  last   An input iterator.
    4601             :    *  @param  pred   A predicate.
    4602             :    *  @return   The number of iterators @c i in the range @p [first,last)
    4603             :    *  for which @p pred(*i) is true.
    4604             :   */
    4605             :   template<typename _InputIterator, typename _Predicate>
    4606             :     typename iterator_traits<_InputIterator>::difference_type
    4607             :     count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
    4608             :     {
    4609             :       // concept requirements
    4610             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    4611             :       __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
    4612             :             typename iterator_traits<_InputIterator>::value_type>)
    4613             :       __glibcxx_requires_valid_range(__first, __last);
    4614             :       typename iterator_traits<_InputIterator>::difference_type __n = 0;
    4615             :       for (; __first != __last; ++__first)
    4616             :         if (__pred(*__first))
    4617             :           ++__n;
    4618             :       return __n;
    4619             :     }
    4620             : 
    4621             :   /**
    4622             :    *  @brief Search a sequence for a matching sub-sequence.
    4623             :    *  @ingroup non_mutating_algorithms
    4624             :    *  @param  first1  A forward iterator.
    4625             :    *  @param  last1   A forward iterator.
    4626             :    *  @param  first2  A forward iterator.
    4627             :    *  @param  last2   A forward iterator.
    4628             :    *  @return   The first iterator @c i in the range
    4629             :    *  @p [first1,last1-(last2-first2)) such that @c *(i+N) == @p *(first2+N)
    4630             :    *  for each @c N in the range @p [0,last2-first2), or @p last1 if no
    4631             :    *  such iterator exists.
    4632             :    *
    4633             :    *  Searches the range @p [first1,last1) for a sub-sequence that compares
    4634             :    *  equal value-by-value with the sequence given by @p [first2,last2) and
    4635             :    *  returns an iterator to the first element of the sub-sequence, or
    4636             :    *  @p last1 if the sub-sequence is not found.
    4637             :    *
    4638             :    *  Because the sub-sequence must lie completely within the range
    4639             :    *  @p [first1,last1) it must start at a position less than
    4640             :    *  @p last1-(last2-first2) where @p last2-first2 is the length of the
    4641             :    *  sub-sequence.
    4642             :    *  This means that the returned iterator @c i will be in the range
    4643             :    *  @p [first1,last1-(last2-first2))
    4644             :   */
    4645             :   template<typename _ForwardIterator1, typename _ForwardIterator2>
    4646             :     _ForwardIterator1
    4647             :     search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
    4648             :            _ForwardIterator2 __first2, _ForwardIterator2 __last2)
    4649             :     {
    4650             :       // concept requirements
    4651             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
    4652             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
    4653             :       __glibcxx_function_requires(_EqualOpConcept<
    4654             :             typename iterator_traits<_ForwardIterator1>::value_type,
    4655             :             typename iterator_traits<_ForwardIterator2>::value_type>)
    4656             :       __glibcxx_requires_valid_range(__first1, __last1);
    4657             :       __glibcxx_requires_valid_range(__first2, __last2);
    4658             : 
    4659             :       // Test for empty ranges
    4660             :       if (__first1 == __last1 || __first2 == __last2)
    4661             :         return __first1;
    4662             : 
    4663             :       // Test for a pattern of length 1.
    4664             :       _ForwardIterator2 __p1(__first2);
    4665             :       if (++__p1 == __last2)
    4666             :         return _GLIBCXX_STD_A::find(__first1, __last1, *__first2);
    4667             : 
    4668             :       // General case.
    4669             :       _ForwardIterator2 __p;
    4670             :       _ForwardIterator1 __current = __first1;
    4671             : 
    4672             :       for (;;)
    4673             :         {
    4674             :           __first1 = _GLIBCXX_STD_A::find(__first1, __last1, *__first2);
    4675             :           if (__first1 == __last1)
    4676             :             return __last1;
    4677             : 
    4678             :           __p = __p1;
    4679             :           __current = __first1;
    4680             :           if (++__current == __last1)
    4681             :             return __last1;
    4682             : 
    4683             :           while (*__current == *__p)
    4684             :             {
    4685             :               if (++__p == __last2)
    4686             :                 return __first1;
    4687             :               if (++__current == __last1)
    4688             :                 return __last1;
    4689             :             }
    4690             :           ++__first1;
    4691             :         }
    4692             :       return __first1;
    4693             :     }
    4694             : 
    4695             :   /**
    4696             :    *  @brief Search a sequence for a matching sub-sequence using a predicate.
    4697             :    *  @ingroup non_mutating_algorithms
    4698             :    *  @param  first1     A forward iterator.
    4699             :    *  @param  last1      A forward iterator.
    4700             :    *  @param  first2     A forward iterator.
    4701             :    *  @param  last2      A forward iterator.
    4702             :    *  @param  predicate  A binary predicate.
    4703             :    *  @return   The first iterator @c i in the range
    4704             :    *  @p [first1,last1-(last2-first2)) such that
    4705             :    *  @p predicate(*(i+N),*(first2+N)) is true for each @c N in the range
    4706             :    *  @p [0,last2-first2), or @p last1 if no such iterator exists.
    4707             :    *
    4708             :    *  Searches the range @p [first1,last1) for a sub-sequence that compares
    4709             :    *  equal value-by-value with the sequence given by @p [first2,last2),
    4710             :    *  using @p predicate to determine equality, and returns an iterator
    4711             :    *  to the first element of the sub-sequence, or @p last1 if no such
    4712             :    *  iterator exists.
    4713             :    *
    4714             :    *  @see search(_ForwardIter1, _ForwardIter1, _ForwardIter2, _ForwardIter2)
    4715             :   */
    4716             :   template<typename _ForwardIterator1, typename _ForwardIterator2,
    4717             :            typename _BinaryPredicate>
    4718             :     _ForwardIterator1
    4719             :     search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
    4720             :            _ForwardIterator2 __first2, _ForwardIterator2 __last2,
    4721             :            _BinaryPredicate  __predicate)
    4722             :     {
    4723             :       // concept requirements
    4724             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>)
    4725             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>)
    4726             :       __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
    4727             :             typename iterator_traits<_ForwardIterator1>::value_type,
    4728             :             typename iterator_traits<_ForwardIterator2>::value_type>)
    4729             :       __glibcxx_requires_valid_range(__first1, __last1);
    4730             :       __glibcxx_requires_valid_range(__first2, __last2);
    4731             : 
    4732             :       // Test for empty ranges
    4733             :       if (__first1 == __last1 || __first2 == __last2)
    4734             :         return __first1;
    4735             : 
    4736             :       // Test for a pattern of length 1.
    4737             :       _ForwardIterator2 __p1(__first2);
    4738             :       if (++__p1 == __last2)
    4739             :         {
    4740             :           while (__first1 != __last1
    4741             :                  && !bool(__predicate(*__first1, *__first2)))
    4742             :             ++__first1;
    4743             :           return __first1;
    4744             :         }
    4745             : 
    4746             :       // General case.
    4747             :       _ForwardIterator2 __p;
    4748             :       _ForwardIterator1 __current = __first1;
    4749             : 
    4750             :       for (;;)
    4751             :         {
    4752             :           while (__first1 != __last1
    4753             :                  && !bool(__predicate(*__first1, *__first2)))
    4754             :             ++__first1;
    4755             :           if (__first1 == __last1)
    4756             :             return __last1;
    4757             : 
    4758             :           __p = __p1;
    4759             :           __current = __first1;
    4760             :           if (++__current == __last1)
    4761             :             return __last1;
    4762             : 
    4763             :           while (__predicate(*__current, *__p))
    4764             :             {
    4765             :               if (++__p == __last2)
    4766             :                 return __first1;
    4767             :               if (++__current == __last1)
    4768             :                 return __last1;
    4769             :             }
    4770             :           ++__first1;
    4771             :         }
    4772             :       return __first1;
    4773             :     }
    4774             : 
    4775             : 
    4776             :   /**
    4777             :    *  @brief Search a sequence for a number of consecutive values.
    4778             :    *  @ingroup non_mutating_algorithms
    4779             :    *  @param  first  A forward iterator.
    4780             :    *  @param  last   A forward iterator.
    4781             :    *  @param  count  The number of consecutive values.
    4782             :    *  @param  val    The value to find.
    4783             :    *  @return   The first iterator @c i in the range @p [first,last-count)
    4784             :    *  such that @c *(i+N) == @p val for each @c N in the range @p [0,count),
    4785             :    *  or @p last if no such iterator exists.
    4786             :    *
    4787             :    *  Searches the range @p [first,last) for @p count consecutive elements
    4788             :    *  equal to @p val.
    4789             :   */
    4790             :   template<typename _ForwardIterator, typename _Integer, typename _Tp>
    4791             :     _ForwardIterator
    4792             :     search_n(_ForwardIterator __first, _ForwardIterator __last,
    4793             :              _Integer __count, const _Tp& __val)
    4794             :     {
    4795             :       // concept requirements
    4796             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    4797             :       __glibcxx_function_requires(_EqualOpConcept<
    4798             :         typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
    4799             :       __glibcxx_requires_valid_range(__first, __last);
    4800             : 
    4801             :       if (__count <= 0)
    4802             :         return __first;
    4803             :       if (__count == 1)
    4804             :         return _GLIBCXX_STD_A::find(__first, __last, __val);
    4805             :       return std::__search_n(__first, __last, __count, __val,
    4806             :                              std::__iterator_category(__first));
    4807             :     }
    4808             : 
    4809             : 
    4810             :   /**
    4811             :    *  @brief Search a sequence for a number of consecutive values using a
    4812             :    *         predicate.
    4813             :    *  @ingroup non_mutating_algorithms
    4814             :    *  @param  first        A forward iterator.
    4815             :    *  @param  last         A forward iterator.
    4816             :    *  @param  count        The number of consecutive values.
    4817             :    *  @param  val          The value to find.
    4818             :    *  @param  binary_pred  A binary predicate.
    4819             :    *  @return   The first iterator @c i in the range @p [first,last-count)
    4820             :    *  such that @p binary_pred(*(i+N),val) is true for each @c N in the
    4821             :    *  range @p [0,count), or @p last if no such iterator exists.
    4822             :    *
    4823             :    *  Searches the range @p [first,last) for @p count consecutive elements
    4824             :    *  for which the predicate returns true.
    4825             :   */
    4826             :   template<typename _ForwardIterator, typename _Integer, typename _Tp,
    4827             :            typename _BinaryPredicate>
    4828             :     _ForwardIterator
    4829             :     search_n(_ForwardIterator __first, _ForwardIterator __last,
    4830             :              _Integer __count, const _Tp& __val,
    4831             :              _BinaryPredicate __binary_pred)
    4832             :     {
    4833             :       // concept requirements
    4834             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    4835             :       __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
    4836             :             typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
    4837             :       __glibcxx_requires_valid_range(__first, __last);
    4838             : 
    4839             :       if (__count <= 0)
    4840             :         return __first;
    4841             :       if (__count == 1)
    4842             :         {
    4843             :           while (__first != __last && !bool(__binary_pred(*__first, __val)))
    4844             :             ++__first;
    4845             :           return __first;
    4846             :         }
    4847             :       return std::__search_n(__first, __last, __count, __val, __binary_pred,
    4848             :                              std::__iterator_category(__first));
    4849             :     }
    4850             : 
    4851             : 
    4852             :   /**
    4853             :    *  @brief Perform an operation on a sequence.
    4854             :    *  @ingroup mutating_algorithms
    4855             :    *  @param  first     An input iterator.
    4856             :    *  @param  last      An input iterator.
    4857             :    *  @param  result    An output iterator.
    4858             :    *  @param  unary_op  A unary operator.
    4859             :    *  @return   An output iterator equal to @p result+(last-first).
    4860             :    *
    4861             :    *  Applies the operator to each element in the input range and assigns
    4862             :    *  the results to successive elements of the output sequence.
    4863             :    *  Evaluates @p *(result+N)=unary_op(*(first+N)) for each @c N in the
    4864             :    *  range @p [0,last-first).
    4865             :    *
    4866             :    *  @p unary_op must not alter its argument.
    4867             :   */
    4868             :   template<typename _InputIterator, typename _OutputIterator,
    4869             :            typename _UnaryOperation>
    4870             :     _OutputIterator
    4871       58710 :     transform(_InputIterator __first, _InputIterator __last,
    4872             :               _OutputIterator __result, _UnaryOperation __unary_op)
    4873             :     {
    4874             :       // concept requirements
    4875             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    4876             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    4877             :             // "the type returned by a _UnaryOperation"
    4878             :             __typeof__(__unary_op(*__first))>)
    4879             :       __glibcxx_requires_valid_range(__first, __last);
    4880             : 
    4881      993266 :       for (; __first != __last; ++__first, ++__result)
    4882      934556 :         *__result = __unary_op(*__first);
    4883       58710 :       return __result;
    4884             :     }
    4885             : 
    4886             :   /**
    4887             :    *  @brief Perform an operation on corresponding elements of two sequences.
    4888             :    *  @ingroup mutating_algorithms
    4889             :    *  @param  first1     An input iterator.
    4890             :    *  @param  last1      An input iterator.
    4891             :    *  @param  first2     An input iterator.
    4892             :    *  @param  result     An output iterator.
    4893             :    *  @param  binary_op  A binary operator.
    4894             :    *  @return   An output iterator equal to @p result+(last-first).
    4895             :    *
    4896             :    *  Applies the operator to the corresponding elements in the two
    4897             :    *  input ranges and assigns the results to successive elements of the
    4898             :    *  output sequence.
    4899             :    *  Evaluates @p *(result+N)=binary_op(*(first1+N),*(first2+N)) for each
    4900             :    *  @c N in the range @p [0,last1-first1).
    4901             :    *
    4902             :    *  @p binary_op must not alter either of its arguments.
    4903             :   */
    4904             :   template<typename _InputIterator1, typename _InputIterator2,
    4905             :            typename _OutputIterator, typename _BinaryOperation>
    4906             :     _OutputIterator
    4907             :     transform(_InputIterator1 __first1, _InputIterator1 __last1,
    4908             :               _InputIterator2 __first2, _OutputIterator __result,
    4909             :               _BinaryOperation __binary_op)
    4910             :     {
    4911             :       // concept requirements
    4912             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    4913             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    4914             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    4915             :             // "the type returned by a _BinaryOperation"
    4916             :             __typeof__(__binary_op(*__first1,*__first2))>)
    4917             :       __glibcxx_requires_valid_range(__first1, __last1);
    4918             : 
    4919             :       for (; __first1 != __last1; ++__first1, ++__first2, ++__result)
    4920             :         *__result = __binary_op(*__first1, *__first2);
    4921             :       return __result;
    4922             :     }
    4923             : 
    4924             :   /**
    4925             :    *  @brief Replace each occurrence of one value in a sequence with another
    4926             :    *         value.
    4927             :    *  @ingroup mutating_algorithms
    4928             :    *  @param  first      A forward iterator.
    4929             :    *  @param  last       A forward iterator.
    4930             :    *  @param  old_value  The value to be replaced.
    4931             :    *  @param  new_value  The replacement value.
    4932             :    *  @return   replace() returns no value.
    4933             :    *
    4934             :    *  For each iterator @c i in the range @p [first,last) if @c *i ==
    4935             :    *  @p old_value then the assignment @c *i = @p new_value is performed.
    4936             :   */
    4937             :   template<typename _ForwardIterator, typename _Tp>
    4938             :     void
    4939             :     replace(_ForwardIterator __first, _ForwardIterator __last,
    4940             :             const _Tp& __old_value, const _Tp& __new_value)
    4941             :     {
    4942             :       // concept requirements
    4943             :       __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
    4944             :                                   _ForwardIterator>)
    4945             :       __glibcxx_function_requires(_EqualOpConcept<
    4946             :             typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
    4947             :       __glibcxx_function_requires(_ConvertibleConcept<_Tp,
    4948             :             typename iterator_traits<_ForwardIterator>::value_type>)
    4949             :       __glibcxx_requires_valid_range(__first, __last);
    4950             : 
    4951             :       for (; __first != __last; ++__first)
    4952             :         if (*__first == __old_value)
    4953             :           *__first = __new_value;
    4954             :     }
    4955             : 
    4956             :   /**
    4957             :    *  @brief Replace each value in a sequence for which a predicate returns
    4958             :    *         true with another value.
    4959             :    *  @ingroup mutating_algorithms
    4960             :    *  @param  first      A forward iterator.
    4961             :    *  @param  last       A forward iterator.
    4962             :    *  @param  pred       A predicate.
    4963             :    *  @param  new_value  The replacement value.
    4964             :    *  @return   replace_if() returns no value.
    4965             :    *
    4966             :    *  For each iterator @c i in the range @p [first,last) if @p pred(*i)
    4967             :    *  is true then the assignment @c *i = @p new_value is performed.
    4968             :   */
    4969             :   template<typename _ForwardIterator, typename _Predicate, typename _Tp>
    4970             :     void
    4971             :     replace_if(_ForwardIterator __first, _ForwardIterator __last,
    4972             :                _Predicate __pred, const _Tp& __new_value)
    4973             :     {
    4974             :       // concept requirements
    4975             :       __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
    4976             :                                   _ForwardIterator>)
    4977             :       __glibcxx_function_requires(_ConvertibleConcept<_Tp,
    4978             :             typename iterator_traits<_ForwardIterator>::value_type>)
    4979             :       __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
    4980             :             typename iterator_traits<_ForwardIterator>::value_type>)
    4981             :       __glibcxx_requires_valid_range(__first, __last);
    4982             : 
    4983             :       for (; __first != __last; ++__first)
    4984             :         if (__pred(*__first))
    4985             :           *__first = __new_value;
    4986             :     }
    4987             : 
    4988             :   /**
    4989             :    *  @brief Assign the result of a function object to each value in a
    4990             :    *         sequence.
    4991             :    *  @ingroup mutating_algorithms
    4992             :    *  @param  first  A forward iterator.
    4993             :    *  @param  last   A forward iterator.
    4994             :    *  @param  gen    A function object taking no arguments and returning
    4995             :    *                 std::iterator_traits<_ForwardIterator>::value_type
    4996             :    *  @return   generate() returns no value.
    4997             :    *
    4998             :    *  Performs the assignment @c *i = @p gen() for each @c i in the range
    4999             :    *  @p [first,last).
    5000             :   */
    5001             :   template<typename _ForwardIterator, typename _Generator>
    5002             :     void
    5003             :     generate(_ForwardIterator __first, _ForwardIterator __last,
    5004             :              _Generator __gen)
    5005             :     {
    5006             :       // concept requirements
    5007             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    5008             :       __glibcxx_function_requires(_GeneratorConcept<_Generator,
    5009             :             typename iterator_traits<_ForwardIterator>::value_type>)
    5010             :       __glibcxx_requires_valid_range(__first, __last);
    5011             : 
    5012             :       for (; __first != __last; ++__first)
    5013             :         *__first = __gen();
    5014             :     }
    5015             : 
    5016             :   /**
    5017             :    *  @brief Assign the result of a function object to each value in a
    5018             :    *         sequence.
    5019             :    *  @ingroup mutating_algorithms
    5020             :    *  @param  first  A forward iterator.
    5021             :    *  @param  n      The length of the sequence.
    5022             :    *  @param  gen    A function object taking no arguments and returning
    5023             :    *                 std::iterator_traits<_ForwardIterator>::value_type
    5024             :    *  @return   The end of the sequence, @p first+n
    5025             :    *
    5026             :    *  Performs the assignment @c *i = @p gen() for each @c i in the range
    5027             :    *  @p [first,first+n).
    5028             :    *
    5029             :    *  _GLIBCXX_RESOLVE_LIB_DEFECTS
    5030             :    *  DR 865. More algorithms that throw away information
    5031             :   */
    5032             :   template<typename _OutputIterator, typename _Size, typename _Generator>
    5033             :     _OutputIterator
    5034             :     generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
    5035             :     {
    5036             :       // concept requirements
    5037             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    5038             :             // "the type returned by a _Generator"
    5039             :             __typeof__(__gen())>)
    5040             : 
    5041             :       for (__decltype(__n + 0) __niter = __n;
    5042             :            __niter > 0; --__niter, ++__first)
    5043             :         *__first = __gen();
    5044             :       return __first;
    5045             :     }
    5046             : 
    5047             : 
    5048             :   /**
    5049             :    *  @brief Copy a sequence, removing consecutive duplicate values.
    5050             :    *  @ingroup mutating_algorithms
    5051             :    *  @param  first   An input iterator.
    5052             :    *  @param  last    An input iterator.
    5053             :    *  @param  result  An output iterator.
    5054             :    *  @return   An iterator designating the end of the resulting sequence.
    5055             :    *
    5056             :    *  Copies each element in the range @p [first,last) to the range
    5057             :    *  beginning at @p result, except that only the first element is copied
    5058             :    *  from groups of consecutive elements that compare equal.
    5059             :    *  unique_copy() is stable, so the relative order of elements that are
    5060             :    *  copied is unchanged.
    5061             :    *
    5062             :    *  _GLIBCXX_RESOLVE_LIB_DEFECTS
    5063             :    *  DR 241. Does unique_copy() require CopyConstructible and Assignable?
    5064             :    *  
    5065             :    *  _GLIBCXX_RESOLVE_LIB_DEFECTS
    5066             :    *  DR 538. 241 again: Does unique_copy() require CopyConstructible and 
    5067             :    *  Assignable?
    5068             :   */
    5069             :   template<typename _InputIterator, typename _OutputIterator>
    5070             :     inline _OutputIterator
    5071             :     unique_copy(_InputIterator __first, _InputIterator __last,
    5072             :                 _OutputIterator __result)
    5073             :     {
    5074             :       // concept requirements
    5075             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    5076             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    5077             :             typename iterator_traits<_InputIterator>::value_type>)
    5078             :       __glibcxx_function_requires(_EqualityComparableConcept<
    5079             :             typename iterator_traits<_InputIterator>::value_type>)
    5080             :       __glibcxx_requires_valid_range(__first, __last);
    5081             : 
    5082             :       if (__first == __last)
    5083             :         return __result;
    5084             :       return std::__unique_copy(__first, __last, __result,
    5085             :                                 std::__iterator_category(__first),
    5086             :                                 std::__iterator_category(__result));
    5087             :     }
    5088             : 
    5089             :   /**
    5090             :    *  @brief Copy a sequence, removing consecutive values using a predicate.
    5091             :    *  @ingroup mutating_algorithms
    5092             :    *  @param  first        An input iterator.
    5093             :    *  @param  last         An input iterator.
    5094             :    *  @param  result       An output iterator.
    5095             :    *  @param  binary_pred  A binary predicate.
    5096             :    *  @return   An iterator designating the end of the resulting sequence.
    5097             :    *
    5098             :    *  Copies each element in the range @p [first,last) to the range
    5099             :    *  beginning at @p result, except that only the first element is copied
    5100             :    *  from groups of consecutive elements for which @p binary_pred returns
    5101             :    *  true.
    5102             :    *  unique_copy() is stable, so the relative order of elements that are
    5103             :    *  copied is unchanged.
    5104             :    *
    5105             :    *  _GLIBCXX_RESOLVE_LIB_DEFECTS
    5106             :    *  DR 241. Does unique_copy() require CopyConstructible and Assignable?
    5107             :   */
    5108             :   template<typename _InputIterator, typename _OutputIterator,
    5109             :            typename _BinaryPredicate>
    5110             :     inline _OutputIterator
    5111             :     unique_copy(_InputIterator __first, _InputIterator __last,
    5112             :                 _OutputIterator __result,
    5113             :                 _BinaryPredicate __binary_pred)
    5114             :     {
    5115             :       // concept requirements -- predicates checked later
    5116             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
    5117             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    5118             :             typename iterator_traits<_InputIterator>::value_type>)
    5119             :       __glibcxx_requires_valid_range(__first, __last);
    5120             : 
    5121             :       if (__first == __last)
    5122             :         return __result;
    5123             :       return std::__unique_copy(__first, __last, __result, __binary_pred,
    5124             :                                 std::__iterator_category(__first),
    5125             :                                 std::__iterator_category(__result));
    5126             :     }
    5127             : 
    5128             : 
    5129             :   /**
    5130             :    *  @brief Randomly shuffle the elements of a sequence.
    5131             :    *  @ingroup mutating_algorithms
    5132             :    *  @param  first   A forward iterator.
    5133             :    *  @param  last    A forward iterator.
    5134             :    *  @return  Nothing.
    5135             :    *
    5136             :    *  Reorder the elements in the range @p [first,last) using a random
    5137             :    *  distribution, so that every possible ordering of the sequence is
    5138             :    *  equally likely.
    5139             :   */
    5140             :   template<typename _RandomAccessIterator>
    5141             :     inline void
    5142             :     random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
    5143             :     {
    5144             :       // concept requirements
    5145             :       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
    5146             :             _RandomAccessIterator>)
    5147             :       __glibcxx_requires_valid_range(__first, __last);
    5148             : 
    5149             :       if (__first != __last)
    5150             :         for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
    5151             :           std::iter_swap(__i, __first + (std::rand() % ((__i - __first) + 1)));
    5152             :     }
    5153             : 
    5154             :   /**
    5155             :    *  @brief Shuffle the elements of a sequence using a random number
    5156             :    *         generator.
    5157             :    *  @ingroup mutating_algorithms
    5158             :    *  @param  first   A forward iterator.
    5159             :    *  @param  last    A forward iterator.
    5160             :    *  @param  rand    The RNG functor or function.
    5161             :    *  @return  Nothing.
    5162             :    *
    5163             :    *  Reorders the elements in the range @p [first,last) using @p rand to
    5164             :    *  provide a random distribution. Calling @p rand(N) for a positive
    5165             :    *  integer @p N should return a randomly chosen integer from the
    5166             :    *  range [0,N).
    5167             :   */
    5168             :   template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
    5169             :     void
    5170             :     random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
    5171             : #ifdef __GXX_EXPERIMENTAL_CXX0X__
    5172             :                    _RandomNumberGenerator&& __rand)
    5173             : #else
    5174             :                    _RandomNumberGenerator& __rand)
    5175             : #endif
    5176             :     {
    5177             :       // concept requirements
    5178             :       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
    5179             :             _RandomAccessIterator>)
    5180             :       __glibcxx_requires_valid_range(__first, __last);
    5181             : 
    5182             :       if (__first == __last)
    5183             :         return;
    5184             :       for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
    5185             :         std::iter_swap(__i, __first + __rand((__i - __first) + 1));
    5186             :     }
    5187             : 
    5188             : 
    5189             :   /**
    5190             :    *  @brief Move elements for which a predicate is true to the beginning
    5191             :    *         of a sequence.
    5192             :    *  @ingroup mutating_algorithms
    5193             :    *  @param  first   A forward iterator.
    5194             :    *  @param  last    A forward iterator.
    5195             :    *  @param  pred    A predicate functor.
    5196             :    *  @return  An iterator @p middle such that @p pred(i) is true for each
    5197             :    *  iterator @p i in the range @p [first,middle) and false for each @p i
    5198             :    *  in the range @p [middle,last).
    5199             :    *
    5200             :    *  @p pred must not modify its operand. @p partition() does not preserve
    5201             :    *  the relative ordering of elements in each group, use
    5202             :    *  @p stable_partition() if this is needed.
    5203             :   */
    5204             :   template<typename _ForwardIterator, typename _Predicate>
    5205             :     inline _ForwardIterator
    5206             :     partition(_ForwardIterator __first, _ForwardIterator __last,
    5207             :               _Predicate   __pred)
    5208             :     {
    5209             :       // concept requirements
    5210             :       __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
    5211             :                                   _ForwardIterator>)
    5212             :       __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
    5213             :             typename iterator_traits<_ForwardIterator>::value_type>)
    5214             :       __glibcxx_requires_valid_range(__first, __last);
    5215             : 
    5216             :       return std::__partition(__first, __last, __pred,
    5217             :                               std::__iterator_category(__first));
    5218             :     }
    5219             : 
    5220             : 
    5221             : 
    5222             :   /**
    5223             :    *  @brief Sort the smallest elements of a sequence.
    5224             :    *  @ingroup sorting_algorithms
    5225             :    *  @param  first   An iterator.
    5226             :    *  @param  middle  Another iterator.
    5227             :    *  @param  last    Another iterator.
    5228             :    *  @return  Nothing.
    5229             :    *
    5230             :    *  Sorts the smallest @p (middle-first) elements in the range
    5231             :    *  @p [first,last) and moves them to the range @p [first,middle). The
    5232             :    *  order of the remaining elements in the range @p [middle,last) is
    5233             :    *  undefined.
    5234             :    *  After the sort if @p i and @j are iterators in the range
    5235             :    *  @p [first,middle) such that @i precedes @j and @k is an iterator in
    5236             :    *  the range @p [middle,last) then @p *j<*i and @p *k<*i are both false.
    5237             :   */
    5238             :   template<typename _RandomAccessIterator>
    5239             :     inline void
    5240           0 :     partial_sort(_RandomAccessIterator __first,
    5241             :                  _RandomAccessIterator __middle,
    5242             :                  _RandomAccessIterator __last)
    5243             :     {
    5244             :       typedef typename iterator_traits<_RandomAccessIterator>::value_type
    5245             :         _ValueType;
    5246             : 
    5247             :       // concept requirements
    5248             :       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
    5249             :             _RandomAccessIterator>)
    5250             :       __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
    5251             :       __glibcxx_requires_valid_range(__first, __middle);
    5252             :       __glibcxx_requires_valid_range(__middle, __last);
    5253             : 
    5254           0 :       std::__heap_select(__first, __middle, __last);
    5255           0 :       std::sort_heap(__first, __middle);
    5256           0 :     }
    5257             : 
    5258             :   /**
    5259             :    *  @brief Sort the smallest elements of a sequence using a predicate
    5260             :    *         for comparison.
    5261             :    *  @ingroup sorting_algorithms
    5262             :    *  @param  first   An iterator.
    5263             :    *  @param  middle  Another iterator.
    5264             :    *  @param  last    Another iterator.
    5265             :    *  @param  comp    A comparison functor.
    5266             :    *  @return  Nothing.
    5267             :    *
    5268             :    *  Sorts the smallest @p (middle-first) elements in the range
    5269             :    *  @p [first,last) and moves them to the range @p [first,middle). The
    5270             :    *  order of the remaining elements in the range @p [middle,last) is
    5271             :    *  undefined.
    5272             :    *  After the sort if @p i and @j are iterators in the range
    5273             :    *  @p [first,middle) such that @i precedes @j and @k is an iterator in
    5274             :    *  the range @p [middle,last) then @p *comp(j,*i) and @p comp(*k,*i)
    5275             :    *  are both false.
    5276             :   */
    5277             :   template<typename _RandomAccessIterator, typename _Compare>
    5278             :     inline void
    5279             :     partial_sort(_RandomAccessIterator __first,
    5280             :                  _RandomAccessIterator __middle,
    5281             :                  _RandomAccessIterator __last,
    5282             :                  _Compare __comp)
    5283             :     {
    5284             :       typedef typename iterator_traits<_RandomAccessIterator>::value_type
    5285             :         _ValueType;
    5286             : 
    5287             :       // concept requirements
    5288             :       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
    5289             :             _RandomAccessIterator>)
    5290             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    5291             :                                   _ValueType, _ValueType>)
    5292             :       __glibcxx_requires_valid_range(__first, __middle);
    5293             :       __glibcxx_requires_valid_range(__middle, __last);
    5294             : 
    5295             :       std::__heap_select(__first, __middle, __last, __comp);
    5296             :       std::sort_heap(__first, __middle, __comp);
    5297             :     }
    5298             : 
    5299             :   /**
    5300             :    *  @brief Sort a sequence just enough to find a particular position.
    5301             :    *  @ingroup sorting_algorithms
    5302             :    *  @param  first   An iterator.
    5303             :    *  @param  nth     Another iterator.
    5304             :    *  @param  last    Another iterator.
    5305             :    *  @return  Nothing.
    5306             :    *
    5307             :    *  Rearranges the elements in the range @p [first,last) so that @p *nth
    5308             :    *  is the same element that would have been in that position had the
    5309             :    *  whole sequence been sorted.
    5310             :    *  whole sequence been sorted. The elements either side of @p *nth are
    5311             :    *  not completely sorted, but for any iterator @i in the range
    5312             :    *  @p [first,nth) and any iterator @j in the range @p [nth,last) it
    5313             :    *  holds that @p *j<*i is false.
    5314             :   */
    5315             :   template<typename _RandomAccessIterator>
    5316             :     inline void
    5317             :     nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
    5318             :                 _RandomAccessIterator __last)
    5319             :     {
    5320             :       typedef typename iterator_traits<_RandomAccessIterator>::value_type
    5321             :         _ValueType;
    5322             : 
    5323             :       // concept requirements
    5324             :       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
    5325             :                                   _RandomAccessIterator>)
    5326             :       __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
    5327             :       __glibcxx_requires_valid_range(__first, __nth);
    5328             :       __glibcxx_requires_valid_range(__nth, __last);
    5329             : 
    5330             :       if (__first == __last || __nth == __last)
    5331             :         return;
    5332             : 
    5333             :       std::__introselect(__first, __nth, __last,
    5334             :                          std::__lg(__last - __first) * 2);
    5335             :     }
    5336             : 
    5337             :   /**
    5338             :    *  @brief Sort a sequence just enough to find a particular position
    5339             :    *         using a predicate for comparison.
    5340             :    *  @ingroup sorting_algorithms
    5341             :    *  @param  first   An iterator.
    5342             :    *  @param  nth     Another iterator.
    5343             :    *  @param  last    Another iterator.
    5344             :    *  @param  comp    A comparison functor.
    5345             :    *  @return  Nothing.
    5346             :    *
    5347             :    *  Rearranges the elements in the range @p [first,last) so that @p *nth
    5348             :    *  is the same element that would have been in that position had the
    5349             :    *  whole sequence been sorted. The elements either side of @p *nth are
    5350             :    *  not completely sorted, but for any iterator @i in the range
    5351             :    *  @p [first,nth) and any iterator @j in the range @p [nth,last) it
    5352             :    *  holds that @p comp(*j,*i) is false.
    5353             :   */
    5354             :   template<typename _RandomAccessIterator, typename _Compare>
    5355             :     inline void
    5356             :     nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
    5357             :                 _RandomAccessIterator __last, _Compare __comp)
    5358             :     {
    5359             :       typedef typename iterator_traits<_RandomAccessIterator>::value_type
    5360             :         _ValueType;
    5361             : 
    5362             :       // concept requirements
    5363             :       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
    5364             :                                   _RandomAccessIterator>)
    5365             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    5366             :                                   _ValueType, _ValueType>)
    5367             :       __glibcxx_requires_valid_range(__first, __nth);
    5368             :       __glibcxx_requires_valid_range(__nth, __last);
    5369             : 
    5370             :       if (__first == __last || __nth == __last)
    5371             :         return;
    5372             : 
    5373             :       std::__introselect(__first, __nth, __last,
    5374             :                          std::__lg(__last - __first) * 2, __comp);
    5375             :     }
    5376             : 
    5377             : 
    5378             :   /**
    5379             :    *  @brief Sort the elements of a sequence.
    5380             :    *  @ingroup sorting_algorithms
    5381             :    *  @param  first   An iterator.
    5382             :    *  @param  last    Another iterator.
    5383             :    *  @return  Nothing.
    5384             :    *
    5385             :    *  Sorts the elements in the range @p [first,last) in ascending order,
    5386             :    *  such that @p *(i+1)<*i is false for each iterator @p i in the range
    5387             :    *  @p [first,last-1).
    5388             :    *
    5389             :    *  The relative ordering of equivalent elements is not preserved, use
    5390             :    *  @p stable_sort() if this is needed.
    5391             :   */
    5392             :   template<typename _RandomAccessIterator>
    5393             :     inline void
    5394         330 :     sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
    5395             :     {
    5396             :       typedef typename iterator_traits<_RandomAccessIterator>::value_type
    5397             :         _ValueType;
    5398             : 
    5399             :       // concept requirements
    5400             :       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
    5401             :             _RandomAccessIterator>)
    5402             :       __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
    5403             :       __glibcxx_requires_valid_range(__first, __last);
    5404             : 
    5405         330 :       if (__first != __last)
    5406             :         {
    5407         315 :           std::__introsort_loop(__first, __last,
    5408             :                                 std::__lg(__last - __first) * 2);
    5409         315 :           std::__final_insertion_sort(__first, __last);
    5410             :         }
    5411         330 :     }
    5412             : 
    5413             :   /**
    5414             :    *  @brief Sort the elements of a sequence using a predicate for comparison.
    5415             :    *  @ingroup sorting_algorithms
    5416             :    *  @param  first   An iterator.
    5417             :    *  @param  last    Another iterator.
    5418             :    *  @param  comp    A comparison functor.
    5419             :    *  @return  Nothing.
    5420             :    *
    5421             :    *  Sorts the elements in the range @p [first,last) in ascending order,
    5422             :    *  such that @p comp(*(i+1),*i) is false for every iterator @p i in the
    5423             :    *  range @p [first,last-1).
    5424             :    *
    5425             :    *  The relative ordering of equivalent elements is not preserved, use
    5426             :    *  @p stable_sort() if this is needed.
    5427             :   */
    5428             :   template<typename _RandomAccessIterator, typename _Compare>
    5429             :     inline void
    5430             :     sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
    5431             :          _Compare __comp)
    5432             :     {
    5433             :       typedef typename iterator_traits<_RandomAccessIterator>::value_type
    5434             :         _ValueType;
    5435             : 
    5436             :       // concept requirements
    5437             :       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
    5438             :             _RandomAccessIterator>)
    5439             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, _ValueType,
    5440             :                                   _ValueType>)
    5441             :       __glibcxx_requires_valid_range(__first, __last);
    5442             : 
    5443             :       if (__first != __last)
    5444             :         {
    5445             :           std::__introsort_loop(__first, __last,
    5446             :                                 std::__lg(__last - __first) * 2, __comp);
    5447             :           std::__final_insertion_sort(__first, __last, __comp);
    5448             :         }
    5449             :     }
    5450             : 
    5451             :   /**
    5452             :    *  @brief Merges two sorted ranges.
    5453             :    *  @ingroup sorting_algorithms
    5454             :    *  @param  first1  An iterator.
    5455             :    *  @param  first2  Another iterator.
    5456             :    *  @param  last1   Another iterator.
    5457             :    *  @param  last2   Another iterator.
    5458             :    *  @param  result  An iterator pointing to the end of the merged range.
    5459             :    *  @return         An iterator pointing to the first element <em>not less
    5460             :    *                  than</em> @a val.
    5461             :    *
    5462             :    *  Merges the ranges [first1,last1) and [first2,last2) into the sorted range
    5463             :    *  [result, result + (last1-first1) + (last2-first2)).  Both input ranges
    5464             :    *  must be sorted, and the output range must not overlap with either of
    5465             :    *  the input ranges.  The sort is @e stable, that is, for equivalent
    5466             :    *  elements in the two ranges, elements from the first range will always
    5467             :    *  come before elements from the second.
    5468             :   */
    5469             :   template<typename _InputIterator1, typename _InputIterator2,
    5470             :            typename _OutputIterator>
    5471             :     _OutputIterator
    5472             :     merge(_InputIterator1 __first1, _InputIterator1 __last1,
    5473             :           _InputIterator2 __first2, _InputIterator2 __last2,
    5474             :           _OutputIterator __result)
    5475             :     {
    5476             :       typedef typename iterator_traits<_InputIterator1>::value_type
    5477             :         _ValueType1;
    5478             :       typedef typename iterator_traits<_InputIterator2>::value_type
    5479             :         _ValueType2;
    5480             : 
    5481             :       // concept requirements
    5482             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    5483             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    5484             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    5485             :                                   _ValueType1>)
    5486             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    5487             :                                   _ValueType2>)
    5488             :       __glibcxx_function_requires(_LessThanOpConcept<_ValueType2, _ValueType1>)   
    5489             :       __glibcxx_requires_sorted_set(__first1, __last1, __first2);
    5490             :       __glibcxx_requires_sorted_set(__first2, __last2, __first1);
    5491             : 
    5492             :       while (__first1 != __last1 && __first2 != __last2)
    5493             :         {
    5494             :           if (*__first2 < *__first1)
    5495             :             {
    5496             :               *__result = *__first2;
    5497             :               ++__first2;
    5498             :             }
    5499             :           else
    5500             :             {
    5501             :               *__result = *__first1;
    5502             :               ++__first1;
    5503             :             }
    5504             :           ++__result;
    5505             :         }
    5506             :       return std::copy(__first2, __last2, std::copy(__first1, __last1,
    5507             :                                                     __result));
    5508             :     }
    5509             : 
    5510             :   /**
    5511             :    *  @brief Merges two sorted ranges.
    5512             :    *  @ingroup sorting_algorithms
    5513             :    *  @param  first1  An iterator.
    5514             :    *  @param  first2  Another iterator.
    5515             :    *  @param  last1   Another iterator.
    5516             :    *  @param  last2   Another iterator.
    5517             :    *  @param  result  An iterator pointing to the end of the merged range.
    5518             :    *  @param  comp    A functor to use for comparisons.
    5519             :    *  @return         An iterator pointing to the first element "not less
    5520             :    *                  than" @a val.
    5521             :    *
    5522             :    *  Merges the ranges [first1,last1) and [first2,last2) into the sorted range
    5523             :    *  [result, result + (last1-first1) + (last2-first2)).  Both input ranges
    5524             :    *  must be sorted, and the output range must not overlap with either of
    5525             :    *  the input ranges.  The sort is @e stable, that is, for equivalent
    5526             :    *  elements in the two ranges, elements from the first range will always
    5527             :    *  come before elements from the second.
    5528             :    *
    5529             :    *  The comparison function should have the same effects on ordering as
    5530             :    *  the function used for the initial sort.
    5531             :   */
    5532             :   template<typename _InputIterator1, typename _InputIterator2,
    5533             :            typename _OutputIterator, typename _Compare>
    5534             :     _OutputIterator
    5535             :     merge(_InputIterator1 __first1, _InputIterator1 __last1,
    5536             :           _InputIterator2 __first2, _InputIterator2 __last2,
    5537             :           _OutputIterator __result, _Compare __comp)
    5538             :     {
    5539             :       typedef typename iterator_traits<_InputIterator1>::value_type
    5540             :         _ValueType1;
    5541             :       typedef typename iterator_traits<_InputIterator2>::value_type
    5542             :         _ValueType2;
    5543             : 
    5544             :       // concept requirements
    5545             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    5546             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    5547             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    5548             :                                   _ValueType1>)
    5549             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    5550             :                                   _ValueType2>)
    5551             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    5552             :                                   _ValueType2, _ValueType1>)
    5553             :       __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
    5554             :       __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
    5555             : 
    5556             :       while (__first1 != __last1 && __first2 != __last2)
    5557             :         {
    5558             :           if (__comp(*__first2, *__first1))
    5559             :             {
    5560             :               *__result = *__first2;
    5561             :               ++__first2;
    5562             :             }
    5563             :           else
    5564             :             {
    5565             :               *__result = *__first1;
    5566             :               ++__first1;
    5567             :             }
    5568             :           ++__result;
    5569             :         }
    5570             :       return std::copy(__first2, __last2, std::copy(__first1, __last1,
    5571             :                                                     __result));
    5572             :     }
    5573             : 
    5574             : 
    5575             :   /**
    5576             :    *  @brief Sort the elements of a sequence, preserving the relative order
    5577             :    *         of equivalent elements.
    5578             :    *  @ingroup sorting_algorithms
    5579             :    *  @param  first   An iterator.
    5580             :    *  @param  last    Another iterator.
    5581             :    *  @return  Nothing.
    5582             :    *
    5583             :    *  Sorts the elements in the range @p [first,last) in ascending order,
    5584             :    *  such that @p *(i+1)<*i is false for each iterator @p i in the range
    5585             :    *  @p [first,last-1).
    5586             :    *
    5587             :    *  The relative ordering of equivalent elements is preserved, so any two
    5588             :    *  elements @p x and @p y in the range @p [first,last) such that
    5589             :    *  @p x<y is false and @p y<x is false will have the same relative
    5590             :    *  ordering after calling @p stable_sort().
    5591             :   */
    5592             :   template<typename _RandomAccessIterator>
    5593             :     inline void
    5594             :     stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
    5595             :     {
    5596             :       typedef typename iterator_traits<_RandomAccessIterator>::value_type
    5597             :         _ValueType;
    5598             :       typedef typename iterator_traits<_RandomAccessIterator>::difference_type
    5599             :         _DistanceType;
    5600             : 
    5601             :       // concept requirements
    5602             :       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
    5603             :             _RandomAccessIterator>)
    5604             :       __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
    5605             :       __glibcxx_requires_valid_range(__first, __last);
    5606             : 
    5607             :       _Temporary_buffer<_RandomAccessIterator, _ValueType> __buf(__first,
    5608             :                                                                  __last);
    5609             :       if (__buf.begin() == 0)
    5610             :         std::__inplace_stable_sort(__first, __last);
    5611             :       else
    5612             :         std::__stable_sort_adaptive(__first, __last, __buf.begin(),
    5613             :                                     _DistanceType(__buf.size()));
    5614             :     }
    5615             : 
    5616             :   /**
    5617             :    *  @brief Sort the elements of a sequence using a predicate for comparison,
    5618             :    *         preserving the relative order of equivalent elements.
    5619             :    *  @ingroup sorting_algorithms
    5620             :    *  @param  first   An iterator.
    5621             :    *  @param  last    Another iterator.
    5622             :    *  @param  comp    A comparison functor.
    5623             :    *  @return  Nothing.
    5624             :    *
    5625             :    *  Sorts the elements in the range @p [first,last) in ascending order,
    5626             :    *  such that @p comp(*(i+1),*i) is false for each iterator @p i in the
    5627             :    *  range @p [first,last-1).
    5628             :    *
    5629             :    *  The relative ordering of equivalent elements is preserved, so any two
    5630             :    *  elements @p x and @p y in the range @p [first,last) such that
    5631             :    *  @p comp(x,y) is false and @p comp(y,x) is false will have the same
    5632             :    *  relative ordering after calling @p stable_sort().
    5633             :   */
    5634             :   template<typename _RandomAccessIterator, typename _Compare>
    5635             :     inline void
    5636             :     stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
    5637             :                 _Compare __comp)
    5638             :     {
    5639             :       typedef typename iterator_traits<_RandomAccessIterator>::value_type
    5640             :         _ValueType;
    5641             :       typedef typename iterator_traits<_RandomAccessIterator>::difference_type
    5642             :         _DistanceType;
    5643             : 
    5644             :       // concept requirements
    5645             :       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
    5646             :             _RandomAccessIterator>)
    5647             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    5648             :                                   _ValueType,
    5649             :                                   _ValueType>)
    5650             :       __glibcxx_requires_valid_range(__first, __last);
    5651             : 
    5652             :       _Temporary_buffer<_RandomAccessIterator, _ValueType> __buf(__first,
    5653             :                                                                  __last);
    5654             :       if (__buf.begin() == 0)
    5655             :         std::__inplace_stable_sort(__first, __last, __comp);
    5656             :       else
    5657             :         std::__stable_sort_adaptive(__first, __last, __buf.begin(),
    5658             :                                     _DistanceType(__buf.size()), __comp);
    5659             :     }
    5660             : 
    5661             : 
    5662             :   /**
    5663             :    *  @brief Return the union of two sorted ranges.
    5664             :    *  @ingroup set_algorithms
    5665             :    *  @param  first1  Start of first range.
    5666             :    *  @param  last1   End of first range.
    5667             :    *  @param  first2  Start of second range.
    5668             :    *  @param  last2   End of second range.
    5669             :    *  @return  End of the output range.
    5670             :    *  @ingroup set_algorithms
    5671             :    *
    5672             :    *  This operation iterates over both ranges, copying elements present in
    5673             :    *  each range in order to the output range.  Iterators increment for each
    5674             :    *  range.  When the current element of one range is less than the other,
    5675             :    *  that element is copied and the iterator advanced.  If an element is
    5676             :    *  contained in both ranges, the element from the first range is copied and
    5677             :    *  both ranges advance.  The output range may not overlap either input
    5678             :    *  range.
    5679             :   */
    5680             :   template<typename _InputIterator1, typename _InputIterator2,
    5681             :            typename _OutputIterator>
    5682             :     _OutputIterator
    5683             :     set_union(_InputIterator1 __first1, _InputIterator1 __last1,
    5684             :               _InputIterator2 __first2, _InputIterator2 __last2,
    5685             :               _OutputIterator __result)
    5686             :     {
    5687             :       typedef typename iterator_traits<_InputIterator1>::value_type
    5688             :         _ValueType1;
    5689             :       typedef typename iterator_traits<_InputIterator2>::value_type
    5690             :         _ValueType2;
    5691             : 
    5692             :       // concept requirements
    5693             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    5694             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    5695             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    5696             :                                   _ValueType1>)
    5697             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    5698             :                                   _ValueType2>)
    5699             :       __glibcxx_function_requires(_LessThanOpConcept<_ValueType1, _ValueType2>)
    5700             :       __glibcxx_function_requires(_LessThanOpConcept<_ValueType2, _ValueType1>)
    5701             :       __glibcxx_requires_sorted_set(__first1, __last1, __first2);
    5702             :       __glibcxx_requires_sorted_set(__first2, __last2, __first1);
    5703             : 
    5704             :       while (__first1 != __last1 && __first2 != __last2)
    5705             :         {
    5706             :           if (*__first1 < *__first2)
    5707             :             {
    5708             :               *__result = *__first1;
    5709             :               ++__first1;
    5710             :             }
    5711             :           else if (*__first2 < *__first1)
    5712             :             {
    5713             :               *__result = *__first2;
    5714             :               ++__first2;
    5715             :             }
    5716             :           else
    5717             :             {
    5718             :               *__result = *__first1;
    5719             :               ++__first1;
    5720             :               ++__first2;
    5721             :             }
    5722             :           ++__result;
    5723             :         }
    5724             :       return std::copy(__first2, __last2, std::copy(__first1, __last1,
    5725             :                                                     __result));
    5726             :     }
    5727             : 
    5728             :   /**
    5729             :    *  @brief Return the union of two sorted ranges using a comparison functor.
    5730             :    *  @ingroup set_algorithms
    5731             :    *  @param  first1  Start of first range.
    5732             :    *  @param  last1   End of first range.
    5733             :    *  @param  first2  Start of second range.
    5734             :    *  @param  last2   End of second range.
    5735             :    *  @param  comp    The comparison functor.
    5736             :    *  @return  End of the output range.
    5737             :    *  @ingroup set_algorithms
    5738             :    *
    5739             :    *  This operation iterates over both ranges, copying elements present in
    5740             :    *  each range in order to the output range.  Iterators increment for each
    5741             :    *  range.  When the current element of one range is less than the other
    5742             :    *  according to @a comp, that element is copied and the iterator advanced.
    5743             :    *  If an equivalent element according to @a comp is contained in both
    5744             :    *  ranges, the element from the first range is copied and both ranges
    5745             :    *  advance.  The output range may not overlap either input range.
    5746             :   */
    5747             :   template<typename _InputIterator1, typename _InputIterator2,
    5748             :            typename _OutputIterator, typename _Compare>
    5749             :     _OutputIterator
    5750             :     set_union(_InputIterator1 __first1, _InputIterator1 __last1,
    5751             :               _InputIterator2 __first2, _InputIterator2 __last2,
    5752             :               _OutputIterator __result, _Compare __comp)
    5753             :     {
    5754             :       typedef typename iterator_traits<_InputIterator1>::value_type
    5755             :         _ValueType1;
    5756             :       typedef typename iterator_traits<_InputIterator2>::value_type
    5757             :         _ValueType2;
    5758             : 
    5759             :       // concept requirements
    5760             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    5761             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    5762             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    5763             :                                   _ValueType1>)
    5764             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    5765             :                                   _ValueType2>)
    5766             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    5767             :                                   _ValueType1, _ValueType2>)
    5768             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    5769             :                                   _ValueType2, _ValueType1>)
    5770             :       __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
    5771             :       __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
    5772             : 
    5773             :       while (__first1 != __last1 && __first2 != __last2)
    5774             :         {
    5775             :           if (__comp(*__first1, *__first2))
    5776             :             {
    5777             :               *__result = *__first1;
    5778             :               ++__first1;
    5779             :             }
    5780             :           else if (__comp(*__first2, *__first1))
    5781             :             {
    5782             :               *__result = *__first2;
    5783             :               ++__first2;
    5784             :             }
    5785             :           else
    5786             :             {
    5787             :               *__result = *__first1;
    5788             :               ++__first1;
    5789             :               ++__first2;
    5790             :             }
    5791             :           ++__result;
    5792             :         }
    5793             :       return std::copy(__first2, __last2, std::copy(__first1, __last1,
    5794             :                                                     __result));
    5795             :     }
    5796             : 
    5797             :   /**
    5798             :    *  @brief Return the intersection of two sorted ranges.
    5799             :    *  @ingroup set_algorithms
    5800             :    *  @param  first1  Start of first range.
    5801             :    *  @param  last1   End of first range.
    5802             :    *  @param  first2  Start of second range.
    5803             :    *  @param  last2   End of second range.
    5804             :    *  @return  End of the output range.
    5805             :    *  @ingroup set_algorithms
    5806             :    *
    5807             :    *  This operation iterates over both ranges, copying elements present in
    5808             :    *  both ranges in order to the output range.  Iterators increment for each
    5809             :    *  range.  When the current element of one range is less than the other,
    5810             :    *  that iterator advances.  If an element is contained in both ranges, the
    5811             :    *  element from the first range is copied and both ranges advance.  The
    5812             :    *  output range may not overlap either input range.
    5813             :   */
    5814             :   template<typename _InputIterator1, typename _InputIterator2,
    5815             :            typename _OutputIterator>
    5816             :     _OutputIterator
    5817             :     set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
    5818             :                      _InputIterator2 __first2, _InputIterator2 __last2,
    5819             :                      _OutputIterator __result)
    5820             :     {
    5821             :       typedef typename iterator_traits<_InputIterator1>::value_type
    5822             :         _ValueType1;
    5823             :       typedef typename iterator_traits<_InputIterator2>::value_type
    5824             :         _ValueType2;
    5825             : 
    5826             :       // concept requirements
    5827             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    5828             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    5829             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    5830             :                                   _ValueType1>)
    5831             :       __glibcxx_function_requires(_LessThanOpConcept<_ValueType1, _ValueType2>)
    5832             :       __glibcxx_function_requires(_LessThanOpConcept<_ValueType2, _ValueType1>)
    5833             :       __glibcxx_requires_sorted_set(__first1, __last1, __first2);
    5834             :       __glibcxx_requires_sorted_set(__first2, __last2, __first1);
    5835             : 
    5836             :       while (__first1 != __last1 && __first2 != __last2)
    5837             :         if (*__first1 < *__first2)
    5838             :           ++__first1;
    5839             :         else if (*__first2 < *__first1)
    5840             :           ++__first2;
    5841             :         else
    5842             :           {
    5843             :             *__result = *__first1;
    5844             :             ++__first1;
    5845             :             ++__first2;
    5846             :             ++__result;
    5847             :           }
    5848             :       return __result;
    5849             :     }
    5850             : 
    5851             :   /**
    5852             :    *  @brief Return the intersection of two sorted ranges using comparison
    5853             :    *  functor.
    5854             :    *  @ingroup set_algorithms
    5855             :    *  @param  first1  Start of first range.
    5856             :    *  @param  last1   End of first range.
    5857             :    *  @param  first2  Start of second range.
    5858             :    *  @param  last2   End of second range.
    5859             :    *  @param  comp    The comparison functor.
    5860             :    *  @return  End of the output range.
    5861             :    *  @ingroup set_algorithms
    5862             :    *
    5863             :    *  This operation iterates over both ranges, copying elements present in
    5864             :    *  both ranges in order to the output range.  Iterators increment for each
    5865             :    *  range.  When the current element of one range is less than the other
    5866             :    *  according to @a comp, that iterator advances.  If an element is
    5867             :    *  contained in both ranges according to @a comp, the element from the
    5868             :    *  first range is copied and both ranges advance.  The output range may not
    5869             :    *  overlap either input range.
    5870             :   */
    5871             :   template<typename _InputIterator1, typename _InputIterator2,
    5872             :            typename _OutputIterator, typename _Compare>
    5873             :     _OutputIterator
    5874             :     set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
    5875             :                      _InputIterator2 __first2, _InputIterator2 __last2,
    5876             :                      _OutputIterator __result, _Compare __comp)
    5877             :     {
    5878             :       typedef typename iterator_traits<_InputIterator1>::value_type
    5879             :         _ValueType1;
    5880             :       typedef typename iterator_traits<_InputIterator2>::value_type
    5881             :         _ValueType2;
    5882             : 
    5883             :       // concept requirements
    5884             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    5885             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    5886             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    5887             :                                   _ValueType1>)
    5888             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    5889             :                                   _ValueType1, _ValueType2>)
    5890             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    5891             :                                   _ValueType2, _ValueType1>)
    5892             :       __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
    5893             :       __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
    5894             : 
    5895             :       while (__first1 != __last1 && __first2 != __last2)
    5896             :         if (__comp(*__first1, *__first2))
    5897             :           ++__first1;
    5898             :         else if (__comp(*__first2, *__first1))
    5899             :           ++__first2;
    5900             :         else
    5901             :           {
    5902             :             *__result = *__first1;
    5903             :             ++__first1;
    5904             :             ++__first2;
    5905             :             ++__result;
    5906             :           }
    5907             :       return __result;
    5908             :     }
    5909             : 
    5910             :   /**
    5911             :    *  @brief Return the difference of two sorted ranges.
    5912             :    *  @ingroup set_algorithms
    5913             :    *  @param  first1  Start of first range.
    5914             :    *  @param  last1   End of first range.
    5915             :    *  @param  first2  Start of second range.
    5916             :    *  @param  last2   End of second range.
    5917             :    *  @return  End of the output range.
    5918             :    *  @ingroup set_algorithms
    5919             :    *
    5920             :    *  This operation iterates over both ranges, copying elements present in
    5921             :    *  the first range but not the second in order to the output range.
    5922             :    *  Iterators increment for each range.  When the current element of the
    5923             :    *  first range is less than the second, that element is copied and the
    5924             :    *  iterator advances.  If the current element of the second range is less,
    5925             :    *  the iterator advances, but no element is copied.  If an element is
    5926             :    *  contained in both ranges, no elements are copied and both ranges
    5927             :    *  advance.  The output range may not overlap either input range.
    5928             :   */
    5929             :   template<typename _InputIterator1, typename _InputIterator2,
    5930             :            typename _OutputIterator>
    5931             :     _OutputIterator
    5932             :     set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
    5933             :                    _InputIterator2 __first2, _InputIterator2 __last2,
    5934             :                    _OutputIterator __result)
    5935             :     {
    5936             :       typedef typename iterator_traits<_InputIterator1>::value_type
    5937             :         _ValueType1;
    5938             :       typedef typename iterator_traits<_InputIterator2>::value_type
    5939             :         _ValueType2;
    5940             : 
    5941             :       // concept requirements
    5942             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    5943             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    5944             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    5945             :                                   _ValueType1>)
    5946             :       __glibcxx_function_requires(_LessThanOpConcept<_ValueType1, _ValueType2>)
    5947             :       __glibcxx_function_requires(_LessThanOpConcept<_ValueType2, _ValueType1>)   
    5948             :       __glibcxx_requires_sorted_set(__first1, __last1, __first2);
    5949             :       __glibcxx_requires_sorted_set(__first2, __last2, __first1);
    5950             : 
    5951             :       while (__first1 != __last1 && __first2 != __last2)
    5952             :         if (*__first1 < *__first2)
    5953             :           {
    5954             :             *__result = *__first1;
    5955             :             ++__first1;
    5956             :             ++__result;
    5957             :           }
    5958             :         else if (*__first2 < *__first1)
    5959             :           ++__first2;
    5960             :         else
    5961             :           {
    5962             :             ++__first1;
    5963             :             ++__first2;
    5964             :           }
    5965             :       return std::copy(__first1, __last1, __result);
    5966             :     }
    5967             : 
    5968             :   /**
    5969             :    *  @brief  Return the difference of two sorted ranges using comparison
    5970             :    *  functor.
    5971             :    *  @ingroup set_algorithms
    5972             :    *  @param  first1  Start of first range.
    5973             :    *  @param  last1   End of first range.
    5974             :    *  @param  first2  Start of second range.
    5975             :    *  @param  last2   End of second range.
    5976             :    *  @param  comp    The comparison functor.
    5977             :    *  @return  End of the output range.
    5978             :    *  @ingroup set_algorithms
    5979             :    *
    5980             :    *  This operation iterates over both ranges, copying elements present in
    5981             :    *  the first range but not the second in order to the output range.
    5982             :    *  Iterators increment for each range.  When the current element of the
    5983             :    *  first range is less than the second according to @a comp, that element
    5984             :    *  is copied and the iterator advances.  If the current element of the
    5985             :    *  second range is less, no element is copied and the iterator advances.
    5986             :    *  If an element is contained in both ranges according to @a comp, no
    5987             :    *  elements are copied and both ranges advance.  The output range may not
    5988             :    *  overlap either input range.
    5989             :   */
    5990             :   template<typename _InputIterator1, typename _InputIterator2,
    5991             :            typename _OutputIterator, typename _Compare>
    5992             :     _OutputIterator
    5993             :     set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
    5994             :                    _InputIterator2 __first2, _InputIterator2 __last2,
    5995             :                    _OutputIterator __result, _Compare __comp)
    5996             :     {
    5997             :       typedef typename iterator_traits<_InputIterator1>::value_type
    5998             :         _ValueType1;
    5999             :       typedef typename iterator_traits<_InputIterator2>::value_type
    6000             :         _ValueType2;
    6001             : 
    6002             :       // concept requirements
    6003             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    6004             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    6005             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    6006             :                                   _ValueType1>)
    6007             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    6008             :                                   _ValueType1, _ValueType2>)
    6009             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    6010             :                                   _ValueType2, _ValueType1>)
    6011             :       __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
    6012             :       __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
    6013             : 
    6014             :       while (__first1 != __last1 && __first2 != __last2)
    6015             :         if (__comp(*__first1, *__first2))
    6016             :           {
    6017             :             *__result = *__first1;
    6018             :             ++__first1;
    6019             :             ++__result;
    6020             :           }
    6021             :         else if (__comp(*__first2, *__first1))
    6022             :           ++__first2;
    6023             :         else
    6024             :           {
    6025             :             ++__first1;
    6026             :             ++__first2;
    6027             :           }
    6028             :       return std::copy(__first1, __last1, __result);
    6029             :     }
    6030             : 
    6031             :   /**
    6032             :    *  @brief  Return the symmetric difference of two sorted ranges.
    6033             :    *  @ingroup set_algorithms
    6034             :    *  @param  first1  Start of first range.
    6035             :    *  @param  last1   End of first range.
    6036             :    *  @param  first2  Start of second range.
    6037             :    *  @param  last2   End of second range.
    6038             :    *  @return  End of the output range.
    6039             :    *  @ingroup set_algorithms
    6040             :    *
    6041             :    *  This operation iterates over both ranges, copying elements present in
    6042             :    *  one range but not the other in order to the output range.  Iterators
    6043             :    *  increment for each range.  When the current element of one range is less
    6044             :    *  than the other, that element is copied and the iterator advances.  If an
    6045             :    *  element is contained in both ranges, no elements are copied and both
    6046             :    *  ranges advance.  The output range may not overlap either input range.
    6047             :   */
    6048             :   template<typename _InputIterator1, typename _InputIterator2,
    6049             :            typename _OutputIterator>
    6050             :     _OutputIterator
    6051             :     set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
    6052             :                              _InputIterator2 __first2, _InputIterator2 __last2,
    6053             :                              _OutputIterator __result)
    6054             :     {
    6055             :       typedef typename iterator_traits<_InputIterator1>::value_type
    6056             :         _ValueType1;
    6057             :       typedef typename iterator_traits<_InputIterator2>::value_type
    6058             :         _ValueType2;
    6059             : 
    6060             :       // concept requirements
    6061             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    6062             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    6063             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    6064             :                                   _ValueType1>)
    6065             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    6066             :                                   _ValueType2>)
    6067             :       __glibcxx_function_requires(_LessThanOpConcept<_ValueType1, _ValueType2>)
    6068             :       __glibcxx_function_requires(_LessThanOpConcept<_ValueType2, _ValueType1>)   
    6069             :       __glibcxx_requires_sorted_set(__first1, __last1, __first2);
    6070             :       __glibcxx_requires_sorted_set(__first2, __last2, __first1);
    6071             : 
    6072             :       while (__first1 != __last1 && __first2 != __last2)
    6073             :         if (*__first1 < *__first2)
    6074             :           {
    6075             :             *__result = *__first1;
    6076             :             ++__first1;
    6077             :             ++__result;
    6078             :           }
    6079             :         else if (*__first2 < *__first1)
    6080             :           {
    6081             :             *__result = *__first2;
    6082             :             ++__first2;
    6083             :             ++__result;
    6084             :           }
    6085             :         else
    6086             :           {
    6087             :             ++__first1;
    6088             :             ++__first2;
    6089             :           }
    6090             :       return std::copy(__first2, __last2, std::copy(__first1,
    6091             :                                                     __last1, __result));
    6092             :     }
    6093             : 
    6094             :   /**
    6095             :    *  @brief  Return the symmetric difference of two sorted ranges using
    6096             :    *  comparison functor.
    6097             :    *  @ingroup set_algorithms
    6098             :    *  @param  first1  Start of first range.
    6099             :    *  @param  last1   End of first range.
    6100             :    *  @param  first2  Start of second range.
    6101             :    *  @param  last2   End of second range.
    6102             :    *  @param  comp    The comparison functor.
    6103             :    *  @return  End of the output range.
    6104             :    *  @ingroup set_algorithms
    6105             :    *
    6106             :    *  This operation iterates over both ranges, copying elements present in
    6107             :    *  one range but not the other in order to the output range.  Iterators
    6108             :    *  increment for each range.  When the current element of one range is less
    6109             :    *  than the other according to @a comp, that element is copied and the
    6110             :    *  iterator advances.  If an element is contained in both ranges according
    6111             :    *  to @a comp, no elements are copied and both ranges advance.  The output
    6112             :    *  range may not overlap either input range.
    6113             :   */
    6114             :   template<typename _InputIterator1, typename _InputIterator2,
    6115             :            typename _OutputIterator, typename _Compare>
    6116             :     _OutputIterator
    6117             :     set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
    6118             :                              _InputIterator2 __first2, _InputIterator2 __last2,
    6119             :                              _OutputIterator __result,
    6120             :                              _Compare __comp)
    6121             :     {
    6122             :       typedef typename iterator_traits<_InputIterator1>::value_type
    6123             :         _ValueType1;
    6124             :       typedef typename iterator_traits<_InputIterator2>::value_type
    6125             :         _ValueType2;
    6126             : 
    6127             :       // concept requirements
    6128             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
    6129             :       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
    6130             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    6131             :                                   _ValueType1>)
    6132             :       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
    6133             :                                   _ValueType2>)
    6134             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    6135             :                                   _ValueType1, _ValueType2>)
    6136             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    6137             :                                   _ValueType2, _ValueType1>)
    6138             :       __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp);
    6139             :       __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp);
    6140             : 
    6141             :       while (__first1 != __last1 && __first2 != __last2)
    6142             :         if (__comp(*__first1, *__first2))
    6143             :           {
    6144             :             *__result = *__first1;
    6145             :             ++__first1;
    6146             :             ++__result;
    6147             :           }
    6148             :         else if (__comp(*__first2, *__first1))
    6149             :           {
    6150             :             *__result = *__first2;
    6151             :             ++__first2;
    6152             :             ++__result;
    6153             :           }
    6154             :         else
    6155             :           {
    6156             :             ++__first1;
    6157             :             ++__first2;
    6158             :           }
    6159             :       return std::copy(__first2, __last2, 
    6160             :                        std::copy(__first1, __last1, __result));
    6161             :     }
    6162             : 
    6163             : 
    6164             :   /**
    6165             :    *  @brief  Return the minimum element in a range.
    6166             :    *  @ingroup sorting_algorithms
    6167             :    *  @param  first  Start of range.
    6168             :    *  @param  last   End of range.
    6169             :    *  @return  Iterator referencing the first instance of the smallest value.
    6170             :   */
    6171             :   template<typename _ForwardIterator>
    6172             :     _ForwardIterator
    6173             :     min_element(_ForwardIterator __first, _ForwardIterator __last)
    6174             :     {
    6175             :       // concept requirements
    6176             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    6177             :       __glibcxx_function_requires(_LessThanComparableConcept<
    6178             :             typename iterator_traits<_ForwardIterator>::value_type>)
    6179             :       __glibcxx_requires_valid_range(__first, __last);
    6180             : 
    6181             :       if (__first == __last)
    6182             :         return __first;
    6183             :       _ForwardIterator __result = __first;
    6184             :       while (++__first != __last)
    6185             :         if (*__first < *__result)
    6186             :           __result = __first;
    6187             :       return __result;
    6188             :     }
    6189             : 
    6190             :   /**
    6191             :    *  @brief  Return the minimum element in a range using comparison functor.
    6192             :    *  @ingroup sorting_algorithms
    6193             :    *  @param  first  Start of range.
    6194             :    *  @param  last   End of range.
    6195             :    *  @param  comp   Comparison functor.
    6196             :    *  @return  Iterator referencing the first instance of the smallest value
    6197             :    *  according to comp.
    6198             :   */
    6199             :   template<typename _ForwardIterator, typename _Compare>
    6200             :     _ForwardIterator
    6201             :     min_element(_ForwardIterator __first, _ForwardIterator __last,
    6202             :                 _Compare __comp)
    6203             :     {
    6204             :       // concept requirements
    6205             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    6206             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    6207             :             typename iterator_traits<_ForwardIterator>::value_type,
    6208             :             typename iterator_traits<_ForwardIterator>::value_type>)
    6209             :       __glibcxx_requires_valid_range(__first, __last);
    6210             : 
    6211             :       if (__first == __last)
    6212             :         return __first;
    6213             :       _ForwardIterator __result = __first;
    6214             :       while (++__first != __last)
    6215             :         if (__comp(*__first, *__result))
    6216             :           __result = __first;
    6217             :       return __result;
    6218             :     }
    6219             : 
    6220             :   /**
    6221             :    *  @brief  Return the maximum element in a range.
    6222             :    *  @ingroup sorting_algorithms
    6223             :    *  @param  first  Start of range.
    6224             :    *  @param  last   End of range.
    6225             :    *  @return  Iterator referencing the first instance of the largest value.
    6226             :   */
    6227             :   template<typename _ForwardIterator>
    6228             :     _ForwardIterator
    6229             :     max_element(_ForwardIterator __first, _ForwardIterator __last)
    6230             :     {
    6231             :       // concept requirements
    6232             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    6233             :       __glibcxx_function_requires(_LessThanComparableConcept<
    6234             :             typename iterator_traits<_ForwardIterator>::value_type>)
    6235             :       __glibcxx_requires_valid_range(__first, __last);
    6236             : 
    6237             :       if (__first == __last)
    6238             :         return __first;
    6239             :       _ForwardIterator __result = __first;
    6240             :       while (++__first != __last)
    6241             :         if (*__result < *__first)
    6242             :           __result = __first;
    6243             :       return __result;
    6244             :     }
    6245             : 
    6246             :   /**
    6247             :    *  @brief  Return the maximum element in a range using comparison functor.
    6248             :    *  @ingroup sorting_algorithms
    6249             :    *  @param  first  Start of range.
    6250             :    *  @param  last   End of range.
    6251             :    *  @param  comp   Comparison functor.
    6252             :    *  @return  Iterator referencing the first instance of the largest value
    6253             :    *  according to comp.
    6254             :   */
    6255             :   template<typename _ForwardIterator, typename _Compare>
    6256             :     _ForwardIterator
    6257             :     max_element(_ForwardIterator __first, _ForwardIterator __last,
    6258             :                 _Compare __comp)
    6259             :     {
    6260             :       // concept requirements
    6261             :       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
    6262             :       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
    6263             :             typename iterator_traits<_ForwardIterator>::value_type,
    6264             :             typename iterator_traits<_ForwardIterator>::value_type>)
    6265             :       __glibcxx_requires_valid_range(__first, __last);
    6266             : 
    6267             :       if (__first == __last) return __first;
    6268             :       _ForwardIterator __result = __first;
    6269             :       while (++__first != __last)
    6270             :         if (__comp(*__result, *__first))
    6271             :           __result = __first;
    6272             :       return __result;
    6273             :     }
    6274             : 
    6275             : _GLIBCXX_END_NAMESPACE_ALGO
    6276             : } // namespace std
    6277             : 
    6278             : #endif /* _STL_ALGO_H */

Generated by: LCOV version 1.9

The wpkg tool is an open source tool created by Made to Order Software Corporation.