From fb21a4dfe2c81640379f64855509fb7613530887 Mon Sep 17 00:00:00 2001 From: Enrico Zini Date: Wed, 9 Sep 2015 22:43:35 +0200 Subject: Removed wrongly added coverage report --- rep/usr/include/c++/4.3/bits/stl_algo.h.gcov.html | 5703 --------------------- 1 file changed, 5703 deletions(-) delete mode 100644 rep/usr/include/c++/4.3/bits/stl_algo.h.gcov.html (limited to 'rep/usr/include/c++/4.3/bits/stl_algo.h.gcov.html') diff --git a/rep/usr/include/c++/4.3/bits/stl_algo.h.gcov.html b/rep/usr/include/c++/4.3/bits/stl_algo.h.gcov.html deleted file mode 100644 index bb0c409..0000000 --- a/rep/usr/include/c++/4.3/bits/stl_algo.h.gcov.html +++ /dev/null @@ -1,5703 +0,0 @@ - - - - - - - LCOV - lcov.info - /usr/include/c++/4.3/bits/stl_algo.h - - - - - - - - - - - - - -
LTP GCOV extension - code coverage report
- - - - - - - - - - - - - - - - - - - - - - - -
Current view:directory - usr/include/c++/4.3/bits - stl_algo.h
Test:lcov.info
Date:2008-08-14Instrumented lines:226
Code covered:85.0 %Executed lines:192
-
- - - - - - - - - 

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