stl_algo.h: Wrap overlong lines...

2004-01-31  Paolo Carlini  <pcarlini@suse.de>

	* include/bits/stl_algo.h: Wrap overlong lines, constify
	a few variables, reformat according to the coding standards.
	* include/bits/stl_algobase.h: Likewise.
	* include/bits/stl_heap.h: Likewise.

From-SVN: r77050

libstdc++-v3/ChangeLog

 2004-01-31  Paolo Carlini  <pcarlini@suse.de>
 
+	* include/bits/stl_algo.h: Wrap overlong lines, constify
+	a few variables, reformat according to the coding standards.
+	* include/bits/stl_algobase.h: Likewise.
+	* include/bits/stl_heap.h: Likewise.
+
+2004-01-31  Paolo Carlini  <pcarlini@suse.de>
+
 	* include/bits/basic_string.h (_Rep::operator[]): Remove, unused.
 
 	* include/bits/basic_string.h: Fix two comments.

libstdc++-v3/include/bits/stl_algo.h

@@ -202,32 +202,41 @@ namespace std
 	 const _Tp& __val,
 	 random_access_iterator_tag)
     {
-      typename iterator_traits<_RandomAccessIterator>::difference_type __trip_count
-	= (__last - __first) >> 2;
+      typename iterator_traits<_RandomAccessIterator>::difference_type
+	__trip_count = (__last - __first) >> 2;
 
-      for ( ; __trip_count > 0 ; --__trip_count) {
-	if (*__first == __val) return __first;
+      for ( ; __trip_count > 0 ; --__trip_count)
+	{
+	  if (*__first == __val)
+	    return __first;
 	  ++__first;
 
-	if (*__first == __val) return __first;
+	  if (*__first == __val)
+	    return __first;
 	  ++__first;
 	  
-	if (*__first == __val) return __first;
+	  if (*__first == __val)
+	    return __first;
 	  ++__first;
 
-	if (*__first == __val) return __first;
+	  if (*__first == __val)
+	    return __first;
 	  ++__first;
 	}
 
-      switch(__last - __first) {
+      switch (__last - __first)
+	{
 	case 3:
-	if (*__first == __val) return __first;
+	  if (*__first == __val)
+	    return __first;
 	  ++__first;
 	case 2:
-	if (*__first == __val) return __first;
+	  if (*__first == __val)
+	    return __first;
 	  ++__first;
 	case 1:
-	if (*__first == __val) return __first;
+	  if (*__first == __val)
+	    return __first;
 	  ++__first;
 	case 0:
 	default:
@@ -246,32 +255,41 @@ namespace std
 	    _Predicate __pred,
 	    random_access_iterator_tag)
     {
-      typename iterator_traits<_RandomAccessIterator>::difference_type __trip_count
-	= (__last - __first) >> 2;
+      typename iterator_traits<_RandomAccessIterator>::difference_type
+	__trip_count = (__last - __first) >> 2;
 
-      for ( ; __trip_count > 0 ; --__trip_count) {
-	if (__pred(*__first)) return __first;
+      for ( ; __trip_count > 0 ; --__trip_count)
+	{
+	  if (__pred(*__first))
+	    return __first;
 	  ++__first;
 
-	if (__pred(*__first)) return __first;
+	  if (__pred(*__first))
+	    return __first;
 	  ++__first;
 
-	if (__pred(*__first)) return __first;
+	  if (__pred(*__first))
+	    return __first;
 	  ++__first;
 
-	if (__pred(*__first)) return __first;
+	  if (__pred(*__first))
+	    return __first;
 	  ++__first;
 	}
 
-      switch(__last - __first) {
+      switch (__last - __first)
+	{
 	case 3:
-	if (__pred(*__first)) return __first;
+	  if (__pred(*__first))
+	    return __first;
 	  ++__first;
 	case 2:
-	if (__pred(*__first)) return __first;
+	  if (__pred(*__first))
+	    return __first;
 	  ++__first;
 	case 1:
-	if (__pred(*__first)) return __first;
+	  if (__pred(*__first))
+	    return __first;
 	  ++__first;
 	case 0:
 	default:
@@ -297,7 +315,8 @@ namespace std
       __glibcxx_function_requires(_EqualOpConcept<
 		typename iterator_traits<_InputIterator>::value_type, _Tp>)
       __glibcxx_requires_valid_range(__first, __last);
-      return std::find(__first, __last, __val, std::__iterator_category(__first));
+      return std::find(__first, __last, __val,
+		       std::__iterator_category(__first));
     }
 
   /**
@@ -318,7 +337,8 @@ namespace std
       __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
 	      typename iterator_traits<_InputIterator>::value_type>)
       __glibcxx_requires_valid_range(__first, __last);
-      return std::find_if(__first, __last, __pred, std::__iterator_category(__first));
+      return std::find_if(__first, __last, __pred,
+			  std::__iterator_category(__first));
     }
 
   /**
@@ -341,7 +361,8 @@ namespace std
       if (__first == __last)
 	return __last;
       _ForwardIterator __next = __first;
-      while(++__next != __last) {
+      while(++__next != __last)
+	{
 	  if (*__first == *__next)
 	    return __first;
 	  __first = __next;
@@ -373,7 +394,8 @@ namespace std
       if (__first == __last)
 	return __last;
       _ForwardIterator __next = __first;
-      while(++__next != __last) {
+      while(++__next != __last)
+	{
 	  if (__binary_pred(*__first, *__next))
 	    return __first;
 	  __first = __next;
@@ -430,7 +452,6 @@ namespace std
       return __n;
     }
 
-
   /**
    *  @brief Search a sequence for a matching sub-sequence.
    *  @param  first1  A forward iterator.
@@ -478,14 +499,12 @@ namespace std
 	return std::find(__first1, __last1, *__first2);
 
       // General case.
-
       _ForwardIterator2 __p1, __p;
-
       __p1 = __first2; ++__p1;
-
       _ForwardIterator1 __current = __first1;
 
-      while (__first1 != __last1) {
+      while (__first1 != __last1)
+	{
 	  __first1 = std::find(__first1, __last1, *__first2);
 	  if (__first1 == __last1)
 	    return __last1;
@@ -495,13 +514,13 @@ namespace std
 	  if (++__current == __last1)
 	    return __last1;
 
-	while (*__current == *__p) {
+	  while (*__current == *__p)
+	    {
 	      if (++__p == __last2)
 		return __first1;
 	      if (++__current == __last1)
 		return __last1;
 	    }
-
 	  ++__first1;
 	}
       return __first1;
@@ -527,7 +546,8 @@ namespace std
    *
    *  @see search(_ForwardIter1, _ForwardIter1, _ForwardIter2, _ForwardIter2)
   */
-  template<typename _ForwardIterator1, typename _ForwardIterator2, typename _BinaryPredicate>
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+	   typename _BinaryPredicate>
     _ForwardIterator1
     search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
 	   _ForwardIterator2 __first2, _ForwardIterator2 __last2,
@@ -549,22 +569,22 @@ namespace std
       // Test for a pattern of length 1.
       _ForwardIterator2 __tmp(__first2);
       ++__tmp;
-      if (__tmp == __last2) {
+      if (__tmp == __last2)
+	{
 	  while (__first1 != __last1 && !__predicate(*__first1, *__first2))
 	    ++__first1;
 	  return __first1;
 	}
 
       // General case.
-
       _ForwardIterator2 __p1, __p;
-
       __p1 = __first2; ++__p1;
-
       _ForwardIterator1 __current = __first1;
 
-      while (__first1 != __last1) {
-	while (__first1 != __last1) {
+      while (__first1 != __last1)
+	{
+	  while (__first1 != __last1)
+	    {
 	      if (__predicate(*__first1, *__first2))
 		break;
 	      ++__first1;
@@ -576,15 +596,16 @@ namespace std
 
 	  __p = __p1;
 	  __current = __first1;
-	if (++__current == __last1) return __last1;
+	  if (++__current == __last1)
+	    return __last1;
 
-	while (__predicate(*__current, *__p)) {
+	  while (__predicate(*__current, *__p))
+	    {
 	      if (++__p == __last2)
 		return __first1;
 	      if (++__current == __last1)
 		return __last1;
 	    }
-
 	  ++__first1;
 	}
       return __first1;
@@ -617,13 +638,17 @@ namespace std
 
       if (__count <= 0)
 	return __first;
-      else {
+      else
+	{
 	  __first = std::find(__first, __last, __val);
-	while (__first != __last) {
-	  typename iterator_traits<_ForwardIterator>::difference_type __n = __count;
+	  while (__first != __last)
+	    {
+	      typename iterator_traits<_ForwardIterator>::difference_type
+		__n = __count;
 	      _ForwardIterator __i = __first;
 	      ++__i;
-	  while (__i != __last && __n != 1 && *__i == __val) {
+	      while (__i != __last && __n != 1 && *__i == __val)
+		{
 		  ++__i;
 		  --__n;
 		}
@@ -666,24 +691,31 @@ namespace std
 
       if (__count <= 0)
 	return __first;
-      else {
-	while (__first != __last) {
+      else
+	{
+	  while (__first != __last)
+	    {
 	      if (__binary_pred(*__first, __val))
 		break;
 	      ++__first;
 	    }
-	while (__first != __last) {
-	  typename iterator_traits<_ForwardIterator>::difference_type __n = __count;
+	  while (__first != __last)
+	    {
+	      typename iterator_traits<_ForwardIterator>::difference_type
+		__n = __count;
 	      _ForwardIterator __i = __first;
 	      ++__i;
-	  while (__i != __last && __n != 1 && __binary_pred(*__i, __val)) {
+	      while (__i != __last && __n != 1 && __binary_pred(*__i, __val))
+		{
 		  ++__i;
 		  --__n;
 		}
 	      if (__n == 1)
 		return __first;
-	  else {
-	    while (__i != __last) {
+	      else
+		{
+		  while (__i != __last)
+		    {
 		      if (__binary_pred(*__i, __val))
 			break;
 		      ++__i;
@@ -712,8 +744,10 @@ namespace std
 		_ForwardIterator2 __first2)
     {
       // concept requirements
-      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator1>)
-      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator2>)
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator1>)
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator2>)
       __glibcxx_function_requires(_ConvertibleConcept<
 	    typename iterator_traits<_ForwardIterator1>::value_type,
 	    typename iterator_traits<_ForwardIterator2>::value_type>)
@@ -742,7 +776,8 @@ namespace std
    *
    *  @p unary_op must not alter its argument.
   */
-  template<typename _InputIterator, typename _OutputIterator, typename _UnaryOperation>
+  template<typename _InputIterator, typename _OutputIterator,
+	   typename _UnaryOperation>
     _OutputIterator
     transform(_InputIterator __first, _InputIterator __last,
 	      _OutputIterator __result, _UnaryOperation __unary_op)
@@ -776,8 +811,8 @@ namespace std
    *
    *  @p binary_op must not alter either of its arguments.
   */
-  template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator,
-	   typename _BinaryOperation>
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator, typename _BinaryOperation>
     _OutputIterator
     transform(_InputIterator1 __first1, _InputIterator1 __last1,
 	      _InputIterator2 __first2, _OutputIterator __result,
@@ -814,7 +849,8 @@ namespace std
 	    const _Tp& __old_value, const _Tp& __new_value)
     {
       // concept requirements
-      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator>)
       __glibcxx_function_requires(_EqualOpConcept<
 	    typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
       __glibcxx_function_requires(_ConvertibleConcept<_Tp,
@@ -844,7 +880,8 @@ namespace std
 	       _Predicate __pred, const _Tp& __new_value)
     {
       // concept requirements
-      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator>)
       __glibcxx_function_requires(_ConvertibleConcept<_Tp,
 	    typename iterator_traits<_ForwardIterator>::value_type>)
       __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
@@ -903,8 +940,8 @@ namespace std
    *  @p [result,result+(last-first)) replacing elements for which
    *  @p pred returns true with @p new_value.
   */
-  template<typename _InputIterator, typename _OutputIterator, typename _Predicate,
-           typename _Tp>
+  template<typename _InputIterator, typename _OutputIterator,
+	   typename _Predicate, typename _Tp>
     _OutputIterator
     replace_copy_if(_InputIterator __first, _InputIterator __last,
 		    _OutputIterator __result,
@@ -936,7 +973,8 @@ namespace std
   */
   template<typename _ForwardIterator, typename _Generator>
     void
-    generate(_ForwardIterator __first, _ForwardIterator __last, _Generator __gen)
+    generate(_ForwardIterator __first, _ForwardIterator __last,
+	     _Generator __gen)
     {
       // concept requirements
       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
@@ -1000,7 +1038,8 @@ namespace std
       __glibcxx_requires_valid_range(__first, __last);
 
       for ( ; __first != __last; ++__first)
-	if (!(*__first == __value)) {
+	if (!(*__first == __value))
+	  {
 	    *__result = *__first;
 	    ++__result;
 	  }
@@ -1021,7 +1060,8 @@ namespace std
    *  remove_copy_if() is stable, so the relative order of elements that are
    *  copied is unchanged.
   */
-  template<typename _InputIterator, typename _OutputIterator, typename _Predicate>
+  template<typename _InputIterator, typename _OutputIterator,
+	   typename _Predicate>
     _OutputIterator
     remove_copy_if(_InputIterator __first, _InputIterator __last,
 		   _OutputIterator __result, _Predicate __pred)
@@ -1035,7 +1075,8 @@ namespace std
       __glibcxx_requires_valid_range(__first, __last);
 
       for ( ; __first != __last; ++__first)
-	if (!__pred(*__first)) {
+	if (!__pred(*__first))
+	  {
 	    *__result = *__first;
 	    ++__result;
 	  }
@@ -1064,7 +1105,8 @@ namespace std
 	   const _Tp& __value)
     {
       // concept requirements
-      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator>)
       __glibcxx_function_requires(_ConvertibleConcept<_Tp,
 	    typename iterator_traits<_ForwardIterator>::value_type>)
       __glibcxx_function_requires(_EqualOpConcept<
@@ -1074,7 +1116,8 @@ namespace std
       __first = std::find(__first, __last, __value);
       _ForwardIterator __i = __first;
       return __first == __last ? __first
-			       : std::remove_copy(++__i, __last, __first, __value);
+			       : std::remove_copy(++__i, __last,
+						  __first, __value);
     }
 
   /**
@@ -1099,7 +1142,8 @@ namespace std
 	      _Predicate __pred)
     {
       // concept requirements
-      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator>)
       __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
 	    typename iterator_traits<_ForwardIterator>::value_type>)
       __glibcxx_requires_valid_range(__first, __last);
@@ -1107,12 +1151,14 @@ namespace std
       __first = std::find_if(__first, __last, __pred);
       _ForwardIterator __i = __first;
       return __first == __last ? __first
-			       : std::remove_copy_if(++__i, __last, __first, __pred);
+			       : std::remove_copy_if(++__i, __last,
+						     __first, __pred);
     }
 
   /**
    *  @if maint
-   *  This is an uglified unique_copy(_InputIterator, _InputIterator, _OutputIterator)
+   *  This is an uglified unique_copy(_InputIterator, _InputIterator,
+   *                                  _OutputIterator)
    *  overloaded for output iterators.
    *  @endif
   */
@@ -1126,7 +1172,8 @@ namespace std
       typename iterator_traits<_InputIterator>::value_type __value = *__first;
       *__result = __value;
       while (++__first != __last)
-	if (!(__value == *__first)) {
+	if (!(__value == *__first))
+	  {
 	    __value = *__first;
 	    *++__result = __value;
 	  }
@@ -1135,7 +1182,8 @@ namespace std
 
   /**
    *  @if maint
-   *  This is an uglified unique_copy(_InputIterator, _InputIterator, _OutputIterator)
+   *  This is an uglified unique_copy(_InputIterator, _InputIterator,
+   *                                  _OutputIterator)
    *  overloaded for forward iterators.
    *  @endif
   */
@@ -1156,11 +1204,13 @@ namespace std
   /**
    *  @if maint
    *  This is an uglified
-   *  unique_copy(_InputIterator, _InputIterator, _OutputIterator, _BinaryPredicate)
+   *  unique_copy(_InputIterator, _InputIterator, _OutputIterator,
+   *              _BinaryPredicate)
    *  overloaded for output iterators.
    *  @endif
   */
-  template<typename _InputIterator, typename _OutputIterator, typename _BinaryPredicate>
+  template<typename _InputIterator, typename _OutputIterator,
+	   typename _BinaryPredicate>
     _OutputIterator
     __unique_copy(_InputIterator __first, _InputIterator __last,
 		  _OutputIterator __result,
@@ -1175,7 +1225,8 @@ namespace std
       typename iterator_traits<_InputIterator>::value_type __value = *__first;
       *__result = __value;
       while (++__first != __last)
-	if (!__binary_pred(__value, *__first)) {
+	if (!__binary_pred(__value, *__first))
+	  {
 	    __value = *__first;
 	    *++__result = __value;
 	  }
@@ -1185,11 +1236,13 @@ namespace std
   /**
    *  @if maint
    *  This is an uglified
-   *  unique_copy(_InputIterator, _InputIterator, _OutputIterator, _BinaryPredicate)
+   *  unique_copy(_InputIterator, _InputIterator, _OutputIterator,
+   *              _BinaryPredicate)
    *  overloaded for forward iterators.
    *  @endif
   */
-  template<typename _InputIterator, typename _ForwardIterator, typename _BinaryPredicate>
+  template<typename _InputIterator, typename _ForwardIterator,
+	   typename _BinaryPredicate>
     _ForwardIterator
     __unique_copy(_InputIterator __first, _InputIterator __last,
 		  _ForwardIterator __result,
@@ -1233,7 +1286,8 @@ namespace std
 	    typename iterator_traits<_InputIterator>::value_type>)
       __glibcxx_requires_valid_range(__first, __last);
 
-      typedef typename iterator_traits<_OutputIterator>::iterator_category _IterType;
+      typedef typename iterator_traits<_OutputIterator>::iterator_category
+	_IterType;
 
       if (__first == __last) return __result;
       return std::__unique_copy(__first, __last, __result, _IterType());
@@ -1254,7 +1308,8 @@ namespace std
    *  unique_copy() is stable, so the relative order of elements that are
    *  copied is unchanged.
   */
-  template<typename _InputIterator, typename _OutputIterator, typename _BinaryPredicate>
+  template<typename _InputIterator, typename _OutputIterator,
+	   typename _BinaryPredicate>
     inline _OutputIterator
     unique_copy(_InputIterator __first, _InputIterator __last,
 		_OutputIterator __result,
@@ -1266,10 +1321,12 @@ namespace std
 	    typename iterator_traits<_InputIterator>::value_type>)
       __glibcxx_requires_valid_range(__first, __last);
 
-      typedef typename iterator_traits<_OutputIterator>::iterator_category _IterType;
+      typedef typename iterator_traits<_OutputIterator>::iterator_category
+	_IterType;
 
       if (__first == __last) return __result;
-      return std::__unique_copy(__first, __last, __result, __binary_pred, _IterType());
+      return std::__unique_copy(__first, __last, __result,
+				__binary_pred, _IterType());
     }
 
   /**
@@ -1290,7 +1347,8 @@ namespace std
     unique(_ForwardIterator __first, _ForwardIterator __last)
     {
       // concept requirements
-      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator>)
       __glibcxx_function_requires(_EqualityComparableConcept<
 		     typename iterator_traits<_ForwardIterator>::value_type>)
       __glibcxx_requires_valid_range(__first, __last);
@@ -1329,7 +1387,8 @@ namespace std
            _BinaryPredicate __binary_pred)
     {
       // concept requirements
-      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator>)
       __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
 		typename iterator_traits<_ForwardIterator>::value_type,
 		typename iterator_traits<_ForwardIterator>::value_type>)
@@ -1351,7 +1410,8 @@ namespace std
 
   /**
    *  @if maint
-   *  This is an uglified reverse(_BidirectionalIterator, _BidirectionalIterator)
+   *  This is an uglified reverse(_BidirectionalIterator,
+   *                              _BidirectionalIterator)
    *  overloaded for bidirectional iterators.
    *  @endif
   */
@@ -1369,7 +1429,8 @@ namespace std
 
   /**
    *  @if maint
-   *  This is an uglified reverse(_BidirectionalIterator, _BidirectionalIterator)
+   *  This is an uglified reverse(_BidirectionalIterator,
+   *                              _BidirectionalIterator)
    *  overloaded for bidirectional iterators.
    *  @endif
   */
@@ -1425,12 +1486,14 @@ namespace std
 			     _OutputIterator __result)
     {
       // concept requirements
-      __glibcxx_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator>)
+      __glibcxx_function_requires(_BidirectionalIteratorConcept<
+				  _BidirectionalIterator>)
       __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
 		typename iterator_traits<_BidirectionalIterator>::value_type>)
       __glibcxx_requires_valid_range(__first, __last);
 
-      while (__first != __last) {
+      while (__first != __last)
+	{
 	  --__last;
 	  *__result = *__last;
 	  ++__result;
@@ -1449,7 +1512,8 @@ namespace std
     _EuclideanRingElement
     __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
     {
-      while (__n != 0) {
+      while (__n != 0)
+	{
 	  _EuclideanRingElement __t = __m % __n;
 	  __m = __n;
 	  __n = __t;
@@ -1473,15 +1537,18 @@ namespace std
 	return;
 
       _ForwardIterator __first2 = __middle;
-      do {
+      do
+	{
 	  swap(*__first++, *__first2++);
 	  if (__first == __middle)
 	    __middle = __first2;
-      } while (__first2 != __last);
+	}
+      while (__first2 != __last);
 
       __first2 = __middle;
 
-      while (__first2 != __last) {
+      while (__first2 != __last)
+	{
 	  swap(*__first++, *__first2++);
 	  if (__first == __middle)
 	    __middle = __first2;
@@ -1515,13 +1582,11 @@ namespace std
       while (__first != __middle && __middle != __last)
 	swap(*__first++, *--__last);
 
-      if (__first == __middle) {
+      if (__first == __middle)
 	std::__reverse(__middle, __last,   bidirectional_iterator_tag());
-      }
-      else {
+      else
 	std::__reverse(__first,  __middle, bidirectional_iterator_tag());
     }
-    }
 
   /**
    *  @if maint
@@ -1542,27 +1607,34 @@ namespace std
       if ((__first == __middle) || (__last  == __middle))
 	return;
 
-      typedef typename iterator_traits<_RandomAccessIterator>::difference_type _Distance;
-      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+	_Distance;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	_ValueType;
 
-      _Distance __n = __last   - __first;
-      _Distance __k = __middle - __first;
-      _Distance __l = __n - __k;
+      const _Distance __n = __last   - __first;
+      const _Distance __k = __middle - __first;
+      const _Distance __l = __n - __k;
 
-      if (__k == __l) {
+      if (__k == __l)
+	{
 	  std::swap_ranges(__first, __middle, __middle);
 	  return;
 	}
 
-      _Distance __d = __gcd(__n, __k);
+      const _Distance __d = __gcd(__n, __k);
 
-      for (_Distance __i = 0; __i < __d; __i++) {
-	_ValueType __tmp = *__first;
+      for (_Distance __i = 0; __i < __d; __i++)
+	{
+	  const _ValueType __tmp = *__first;
 	  _RandomAccessIterator __p = __first;
 	  
-	if (__k < __l) {
-	  for (_Distance __j = 0; __j < __l/__d; __j++) {
-	    if (__p > __first + __l) {
+	  if (__k < __l)
+	    {
+	      for (_Distance __j = 0; __j < __l / __d; __j++)
+		{
+		  if (__p > __first + __l)
+		    {
 		      *__p = *(__p - __l);
 		      __p -= __l;
 		    }
@@ -1571,14 +1643,15 @@ namespace std
 		  __p += __k;
 		}
 	    }
-
-	else {
-	  for (_Distance __j = 0; __j < __k/__d - 1; __j ++) {
-	    if (__p < __last - __k) {
+	  else
+	    {
+	      for (_Distance __j = 0; __j < __k / __d - 1; __j ++)
+		{
+		  if (__p < __last - __k)
+		    {
 		      *__p = *(__p + __k);
 		      __p += __k;
 		    }
-
 		  *__p = * (__p - __l);
 		  __p -= __l;
 		}
@@ -1609,14 +1682,17 @@ namespace std
   */
   template<typename _ForwardIterator>
     inline void
-    rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last)
+    rotate(_ForwardIterator __first, _ForwardIterator __middle,
+	   _ForwardIterator __last)
     {
       // concept requirements
-      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator>)
       __glibcxx_requires_valid_range(__first, __middle);
       __glibcxx_requires_valid_range(__middle, __last);
 
-      typedef typename iterator_traits<_ForwardIterator>::iterator_category _IterType;
+      typedef typename iterator_traits<_ForwardIterator>::iterator_category
+	_IterType;
       std::__rotate(__first, __middle, __last, _IterType());
     }
 
@@ -1699,7 +1775,8 @@ namespace std
 	    _RandomAccessIterator>)
       __glibcxx_requires_valid_range(__first, __last);
 
-      if (__first == __last) return;
+      if (__first == __last)
+	return;
       for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
 	std::iter_swap(__i, __first + __rand((__i - __first) + 1));
     }
@@ -1716,15 +1793,18 @@ namespace std
 		_Predicate __pred,
 		forward_iterator_tag)
     {
-      if (__first == __last) return __first;
+      if (__first == __last)
+	return __first;
 
       while (__pred(*__first))
-	if (++__first == __last) return __first;
+	if (++__first == __last)
+	  return __first;
 
       _ForwardIterator __next = __first;
 
       while (++__next != __last)
-	if (__pred(*__next)) {
+	if (__pred(*__next))
+	  {
 	    swap(*__first, *__next);
 	    ++__first;
 	  }
@@ -1743,7 +1823,8 @@ namespace std
 		_Predicate __pred,
 		bidirectional_iterator_tag)
     {
-      while (true) {
+      while (true)
+	{
 	  while (true)
 	    if (__first == __last)
 	      return __first;
@@ -1784,12 +1865,14 @@ namespace std
 	      _Predicate   __pred)
     {
       // concept requirements
-      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator>)
       __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
 	    typename iterator_traits<_ForwardIterator>::value_type>)
       __glibcxx_requires_valid_range(__first, __last);
 
-      return std::__partition(__first, __last, __pred, std::__iterator_category(__first));
+      return std::__partition(__first, __last, __pred,
+			      std::__iterator_category(__first));
     }
 
 
@@ -1800,19 +1883,22 @@ namespace std
   */
   template<typename _ForwardIterator, typename _Predicate, typename _Distance>
     _ForwardIterator
-    __inplace_stable_partition(_ForwardIterator __first, _ForwardIterator __last,
+    __inplace_stable_partition(_ForwardIterator __first,
+			       _ForwardIterator __last,
 			       _Predicate __pred, _Distance __len)
     {
       if (__len == 1)
 	return __pred(*__first) ? __last : __first;
       _ForwardIterator __middle = __first;
       std::advance(__middle, __len / 2);
-      _ForwardIterator __begin = std::__inplace_stable_partition(__first, __middle,
+      _ForwardIterator __begin = std::__inplace_stable_partition(__first,
+								 __middle,
 								 __pred,
 								 __len / 2);
       _ForwardIterator __end = std::__inplace_stable_partition(__middle, __last,
 							       __pred,
-							       __len - __len / 2);
+							       __len
+							       - __len / 2);
       std::rotate(__begin, __middle, __end);
       std::advance(__begin, std::distance(__middle, __end));
       return __begin;
@@ -1826,35 +1912,40 @@ namespace std
   template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
 	   typename _Distance>
     _ForwardIterator
-    __stable_partition_adaptive(_ForwardIterator __first, _ForwardIterator __last,
+    __stable_partition_adaptive(_ForwardIterator __first,
+				_ForwardIterator __last,
 				_Predicate __pred, _Distance __len,
 				_Pointer __buffer,
 				_Distance __buffer_size)
     {
-      if (__len <= __buffer_size) {
+      if (__len <= __buffer_size)
+	{
 	  _ForwardIterator __result1 = __first;
 	  _Pointer __result2 = __buffer;
 	  for ( ; __first != __last ; ++__first)
-	  if (__pred(*__first)) {
+	    if (__pred(*__first))
+	      {
 		*__result1 = *__first;
 		++__result1;
 	      }
-	  else {
+	    else
+	      {
 		*__result2 = *__first;
 		++__result2;
 	      }
 	  std::copy(__buffer, __result2, __result1);
 	  return __result1;
 	}
-      else {
+      else
+	{
 	  _ForwardIterator __middle = __first;
 	  std::advance(__middle, __len / 2);
-	_ForwardIterator __begin = std::__stable_partition_adaptive(__first, __middle,
-								    __pred,
-								    __len / 2,
-								    __buffer, __buffer_size);
-	_ForwardIterator __end = std::__stable_partition_adaptive( __middle, __last,
-								   __pred,
+	  _ForwardIterator __begin =
+	    std::__stable_partition_adaptive(__first, __middle, __pred,
+					     __len / 2, __buffer,
+					     __buffer_size);
+	  _ForwardIterator __end =
+	    std::__stable_partition_adaptive(__middle, __last, __pred,
 					     __len - __len / 2,
 					     __buffer, __buffer_size);
 	  std::rotate(__begin, __middle, __end);
@@ -1885,7 +1976,8 @@ namespace std
 		     _Predicate __pred)
     {
       // concept requirements
-      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator>)
       __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
 	    typename iterator_traits<_ForwardIterator>::value_type>)
       __glibcxx_requires_valid_range(__first, __last);
@@ -1894,16 +1986,21 @@ namespace std
 	return __first;
       else
 	{
-	typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
-	typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType;
+	  typedef typename iterator_traits<_ForwardIterator>::value_type
+	    _ValueType;
+	  typedef typename iterator_traits<_ForwardIterator>::difference_type
+	    _DistanceType;
 
-	_Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first, __last);
+	  _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first,
+								__last);
 	if (__buf.size() > 0)
-	  return std::__stable_partition_adaptive(__first, __last, __pred,
+	  return
+	    std::__stable_partition_adaptive(__first, __last, __pred,
 					  _DistanceType(__buf.requested_size()),
 					  __buf.begin(), __buf.size());
 	else
-	  return std::__inplace_stable_partition(__first, __last, __pred,
+	  return
+	    std::__inplace_stable_partition(__first, __last, __pred,
 					 _DistanceType(__buf.requested_size()));
 	}
     }
@@ -1915,10 +2012,11 @@ namespace std
   */
   template<typename _RandomAccessIterator, typename _Tp>
     _RandomAccessIterator
-    __unguarded_partition(_RandomAccessIterator __first, _RandomAccessIterator __last,
-			  _Tp __pivot)
+    __unguarded_partition(_RandomAccessIterator __first,
+			  _RandomAccessIterator __last, _Tp __pivot)
+    {
+      while (true)
 	{
-      while (true) {
 	  while (*__first < __pivot)
 	    ++__first;
 	  --__last;
@@ -1938,10 +2036,12 @@ namespace std
   */
   template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
     _RandomAccessIterator
-    __unguarded_partition(_RandomAccessIterator __first, _RandomAccessIterator __last,
+    __unguarded_partition(_RandomAccessIterator __first,
+			  _RandomAccessIterator __last,
 			  _Tp __pivot, _Compare __comp)
     {
-      while (true) {
+      while (true)
+	{
 	  while (__comp(*__first, __pivot))
 	    ++__first;
 	  --__last;
@@ -1954,7 +2054,6 @@ namespace std
 	}
     }
 
-
   /**
    *  @if maint
    *  @doctodo
@@ -1974,7 +2073,8 @@ namespace std
     {
       _RandomAccessIterator __next = __last;
       --__next;
-      while (__val < *__next) {
+      while (__val < *__next)
+	{
 	  *__last = *__next;
 	  __last = __next;
 	  --__next;
@@ -1989,11 +2089,13 @@ namespace std
   */
   template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
     void
-    __unguarded_linear_insert(_RandomAccessIterator __last, _Tp __val, _Compare __comp)
+    __unguarded_linear_insert(_RandomAccessIterator __last, _Tp __val,
+			      _Compare __comp)
     {
       _RandomAccessIterator __next = __last;
       --__next;
-      while (__comp(__val, *__next)) {
+      while (__comp(__val, *__next))
+	{
 	  *__last = *__next;
 	  __last = __next;
 	  --__next;
@@ -2008,14 +2110,18 @@ namespace std
   */
   template<typename _RandomAccessIterator>
     void
-    __insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    __insertion_sort(_RandomAccessIterator __first,
+		     _RandomAccessIterator __last)
     {
-      if (__first == __last) return;
+      if (__first == __last)
+	return;
 
       for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
       {
-	typename iterator_traits<_RandomAccessIterator>::value_type __val = *__i;
-	if (__val < *__first) {
+	typename iterator_traits<_RandomAccessIterator>::value_type
+	  __val = *__i;
+	if (__val < *__first)
+	  {
 	    std::copy_backward(__first, __i, __i + 1);
 	    *__first = __val;
 	  }
@@ -2031,15 +2137,17 @@ namespace std
   */
   template<typename _RandomAccessIterator, typename _Compare>
     void
-    __insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
-		     _Compare __comp)
+    __insertion_sort(_RandomAccessIterator __first,
+		     _RandomAccessIterator __last, _Compare __comp)
     {
       if (__first == __last) return;
 
       for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
       {
-	typename iterator_traits<_RandomAccessIterator>::value_type __val = *__i;
-	if (__comp(__val, *__first)) {
+	typename iterator_traits<_RandomAccessIterator>::value_type
+	  __val = *__i;
+	if (__comp(__val, *__first))
+	  {
 	    std::copy_backward(__first, __i, __i + 1);
 	    *__first = __val;
 	  }
@@ -2055,9 +2163,11 @@ namespace std
   */
   template<typename _RandomAccessIterator>
     inline void
-    __unguarded_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    __unguarded_insertion_sort(_RandomAccessIterator __first,
+			       _RandomAccessIterator __last)
     {
-      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	_ValueType;
 
       for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
 	std::__unguarded_linear_insert(__i, _ValueType(*__i));
@@ -2070,10 +2180,11 @@ namespace std
   */
   template<typename _RandomAccessIterator, typename _Compare>
     inline void
-    __unguarded_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
-			       _Compare __comp)
+    __unguarded_insertion_sort(_RandomAccessIterator __first,
+			       _RandomAccessIterator __last, _Compare __comp)
     {
-      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	_ValueType;
 
       for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
 	std::__unguarded_linear_insert(__i, _ValueType(*__i), __comp);
@@ -2086,9 +2197,11 @@ namespace std
   */
   template<typename _RandomAccessIterator>
     void
-    __final_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    __final_insertion_sort(_RandomAccessIterator __first,
+			   _RandomAccessIterator __last)
+    {
+      if (__last - __first > _S_threshold)
 	{
-      if (__last - __first > _S_threshold) {
 	  std::__insertion_sort(__first, __first + _S_threshold);
 	  std::__unguarded_insertion_sort(__first + _S_threshold, __last);
 	}
@@ -2103,12 +2216,14 @@ namespace std
   */
   template<typename _RandomAccessIterator, typename _Compare>
     void
-    __final_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
-			   _Compare __comp)
+    __final_insertion_sort(_RandomAccessIterator __first,
+			   _RandomAccessIterator __last, _Compare __comp)
+    {
+      if (__last - __first > _S_threshold)
 	{
-      if (__last - __first > _S_threshold) {
 	  std::__insertion_sort(__first, __first + _S_threshold, __comp);
-	std::__unguarded_insertion_sort(__first + _S_threshold, __last, __comp);
+	  std::__unguarded_insertion_sort(__first + _S_threshold, __last,
+					  __comp);
 	}
       else
 	std::__insertion_sort(__first, __last, __comp);
@@ -2124,7 +2239,8 @@ namespace std
     __lg(_Size __n)
     {
       _Size __k;
-      for (__k = 0; __n != 1; __n >>= 1) ++__k;
+      for (__k = 0; __n != 1; __n >>= 1)
+	++__k;
       return __k;
     }
 
@@ -2149,7 +2265,8 @@ namespace std
 		 _RandomAccessIterator __middle,
 		 _RandomAccessIterator __last)
     {
-      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	_ValueType;
 
       // concept requirements
       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
@@ -2190,7 +2307,8 @@ namespace std
 		 _RandomAccessIterator __last,
 		 _Compare __comp)
     {
-      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	_ValueType;
 
       // concept requirements
       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
@@ -2230,30 +2348,38 @@ namespace std
 		      _RandomAccessIterator __result_first,
 		      _RandomAccessIterator __result_last)
     {
-      typedef typename iterator_traits<_InputIterator>::value_type _InputValueType;
-      typedef typename iterator_traits<_RandomAccessIterator>::value_type _OutputValueType;
-      typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType;
+      typedef typename iterator_traits<_InputIterator>::value_type
+	_InputValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	_OutputValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+	_DistanceType;
 
       // concept requirements
       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
-      __glibcxx_function_requires(_ConvertibleConcept<_InputValueType, _OutputValueType>)
+      __glibcxx_function_requires(_ConvertibleConcept<_InputValueType,
+				  _OutputValueType>)
       __glibcxx_function_requires(_LessThanComparableConcept<_OutputValueType>)
       __glibcxx_function_requires(_LessThanComparableConcept<_InputValueType>)
       __glibcxx_requires_valid_range(__first, __last);
       __glibcxx_requires_valid_range(__result_first, __result_last);
 
-      if (__result_first == __result_last) return __result_last;
+      if (__result_first == __result_last)
+	return __result_last;
       _RandomAccessIterator __result_real_last = __result_first;
-      while(__first != __last && __result_real_last != __result_last) {
+      while(__first != __last && __result_real_last != __result_last)
+	{
 	  *__result_real_last = *__first;
 	  ++__result_real_last;
 	  ++__first;
 	}
       std::make_heap(__result_first, __result_real_last);
-      while (__first != __last) {
+      while (__first != __last)
+	{
 	  if (*__first < *__result_first)
 	    std::__adjust_heap(__result_first, _DistanceType(0),
-			     _DistanceType(__result_real_last - __result_first),
+			       _DistanceType(__result_real_last
+					     - __result_first),
 			       _InputValueType(*__first));
 	  ++__first;
 	}
@@ -2287,31 +2413,40 @@ namespace std
 		      _RandomAccessIterator __result_last,
 		      _Compare __comp)
     {
-      typedef typename iterator_traits<_InputIterator>::value_type _InputValueType;
-      typedef typename iterator_traits<_RandomAccessIterator>::value_type _OutputValueType;
-      typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType;
+      typedef typename iterator_traits<_InputIterator>::value_type
+	_InputValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	_OutputValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+	_DistanceType;
 
       // concept requirements
       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
-      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<_RandomAccessIterator>)
-      __glibcxx_function_requires(_ConvertibleConcept<_InputValueType, _OutputValueType>)
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+				  _RandomAccessIterator>)
+      __glibcxx_function_requires(_ConvertibleConcept<_InputValueType,
+				  _OutputValueType>)
       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
 				  _OutputValueType, _OutputValueType>)
       __glibcxx_requires_valid_range(__first, __last);
       __glibcxx_requires_valid_range(__result_first, __result_last);
 
-      if (__result_first == __result_last) return __result_last;
+      if (__result_first == __result_last)
+	return __result_last;
       _RandomAccessIterator __result_real_last = __result_first;
-      while(__first != __last && __result_real_last != __result_last) {
+      while(__first != __last && __result_real_last != __result_last)
+	{
 	  *__result_real_last = *__first;
 	  ++__result_real_last;
 	  ++__first;
 	}
       std::make_heap(__result_first, __result_real_last, __comp);
-      while (__first != __last) {
+      while (__first != __last)
+	{
 	  if (__comp(*__first, *__result_first))
 	    std::__adjust_heap(__result_first, _DistanceType(0),
-			     _DistanceType(__result_real_last - __result_first),
+			       _DistanceType(__result_real_last
+					     - __result_first),
 			       _InputValueType(*__first),
 			       __comp);
 	  ++__first;
@@ -2327,13 +2462,17 @@ namespace std
   */
   template<typename _RandomAccessIterator, typename _Size>
     void
-    __introsort_loop(_RandomAccessIterator __first, _RandomAccessIterator __last,
+    __introsort_loop(_RandomAccessIterator __first,
+		     _RandomAccessIterator __last,
 		     _Size __depth_limit)
     {
-      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	_ValueType;
 
-      while (__last - __first > _S_threshold) {
-	if (__depth_limit == 0) {
+      while (__last - __first > _S_threshold)
+	{
+	  if (__depth_limit == 0)
+	    {
 	      std::partial_sort(__first, __last, __last);
 	      return;
 	    }
@@ -2341,8 +2480,12 @@ namespace std
 	  _RandomAccessIterator __cut =
 	    std::__unguarded_partition(__first, __last,
 				       _ValueType(std::__median(*__first,
-							      *(__first + (__last - __first)/2),
-							      *(__last - 1))));
+								*(__first
+								  + (__last 
+								     - __first) 
+								  / 2),
+								*(__last 
+								  - 1))));
 	  std::__introsort_loop(__cut, __last, __depth_limit);
 	  __last = __cut;
 	}
@@ -2355,13 +2498,17 @@ namespace std
   */
   template<typename _RandomAccessIterator, typename _Size, typename _Compare>
     void
-    __introsort_loop(_RandomAccessIterator __first, _RandomAccessIterator __last,
+    __introsort_loop(_RandomAccessIterator __first,
+		     _RandomAccessIterator __last,
 		     _Size __depth_limit, _Compare __comp)
     {
-      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	_ValueType;
 
-      while (__last - __first > _S_threshold) {
-	if (__depth_limit == 0) {
+      while (__last - __first > _S_threshold)
+	{
+	  if (__depth_limit == 0)
+	    {
 	      std::partial_sort(__first, __last, __last, __comp);
 	      return;
 	    }
@@ -2369,8 +2516,13 @@ namespace std
 	  _RandomAccessIterator __cut =
 	    std::__unguarded_partition(__first, __last,
 				       _ValueType(std::__median(*__first,
-							      *(__first + (__last - __first)/2),
-							      *(__last - 1), __comp)), __comp);
+								*(__first
+								  + (__last
+								     - __first)
+								  / 2),
+								*(__last - 1),
+								__comp)),
+				       __comp);
 	  std::__introsort_loop(__cut, __last, __depth_limit, __comp);
 	  __last = __cut;
 	}
@@ -2393,7 +2545,8 @@ namespace std
     inline void
     sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
     {
-      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	_ValueType;
 
       // concept requirements
       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
@@ -2401,7 +2554,8 @@ namespace std
       __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
       __glibcxx_requires_valid_range(__first, __last);
 
-      if (__first != __last) {
+      if (__first != __last)
+	{
 	  std::__introsort_loop(__first, __last, __lg(__last - __first) * 2);
 	  std::__final_insertion_sort(__first, __last);
 	}
@@ -2423,18 +2577,23 @@ namespace std
   */
   template<typename _RandomAccessIterator, typename _Compare>
     inline void
-    sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
+    sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+	 _Compare __comp)
     {
-      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	_ValueType;
 
       // concept requirements
       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
 	    _RandomAccessIterator>)
-      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, _ValueType, _ValueType>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, _ValueType,
+				  _ValueType>)
       __glibcxx_requires_valid_range(__first, __last);
 
-      if (__first != __last) {
-	std::__introsort_loop(__first, __last, __lg(__last - __first) * 2, __comp);
+      if (__first != __last)
+	{
+	  std::__introsort_loop(__first, __last, __lg(__last - __first) * 2,
+				__comp);
 	  std::__final_insertion_sort(__first, __last, __comp);
 	}
     }
@@ -2451,10 +2610,13 @@ namespace std
   */
   template<typename _ForwardIterator, typename _Tp>
     _ForwardIterator
-    lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val)
+    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
+		const _Tp& __val)
     {
-      typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
-      typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType;
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+	_ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+	_DistanceType;
 
       // concept requirements
       // Note that these are slightly stricter than those of the 4-argument
@@ -2470,11 +2632,13 @@ namespace std
       _DistanceType __half;
       _ForwardIterator __middle;
 
-      while (__len > 0) {
+      while (__len > 0)
+	{
 	  __half = __len >> 1;
 	  __middle = __first;
 	  std::advance(__middle, __half);
-	if (*__middle < __val) {
+	  if (*__middle < __val)
+	    {
 	      __first = __middle;
 	      ++__first;
 	      __len = __len - __half - 1;
@@ -2504,23 +2668,28 @@ namespace std
     lower_bound(_ForwardIterator __first, _ForwardIterator __last,
 		const _Tp& __val, _Compare __comp)
     {
-      typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
-      typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType;
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+	_ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+	_DistanceType;
 
       // concept requirements
       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
-      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, _ValueType, _Tp>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+				  _ValueType, _Tp>)
       __glibcxx_requires_partitioned_pred(__first, __last, __val, __comp);
 
       _DistanceType __len = std::distance(__first, __last);
       _DistanceType __half;
       _ForwardIterator __middle;
 
-      while (__len > 0) {
+      while (__len > 0)
+	{
 	  __half = __len >> 1;
 	  __middle = __first;
 	  std::advance(__middle, __half);
-	if (__comp(*__middle, __val)) {
+	  if (__comp(*__middle, __val))
+	    {
 	      __first = __middle;
 	      ++__first;
 	      __len = __len - __half - 1;
@@ -2543,10 +2712,13 @@ namespace std
   */
   template<typename _ForwardIterator, typename _Tp>
     _ForwardIterator
-    upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val)
+    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
+		const _Tp& __val)
     {
-      typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
-      typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType;
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+	_ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+	_DistanceType;
 
       // concept requirements
       // See comments on lower_bound.
@@ -2559,13 +2731,15 @@ namespace std
       _DistanceType __half;
       _ForwardIterator __middle;
 
-      while (__len > 0) {
+      while (__len > 0)
+	{
 	  __half = __len >> 1;
 	  __middle = __first;
 	  std::advance(__middle, __half);
 	  if (__val < *__middle)
 	    __len = __half;
-	else {
+	  else
+	    {
 	      __first = __middle;
 	      ++__first;
 	      __len = __len - __half - 1;
@@ -2593,25 +2767,30 @@ namespace std
     upper_bound(_ForwardIterator __first, _ForwardIterator __last,
 		const _Tp& __val, _Compare __comp)
     {
-      typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
-      typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType;
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+	_ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+	_DistanceType;
 
       // concept requirements
       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
-      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, _Tp, _ValueType>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+				  _Tp, _ValueType>)
       __glibcxx_requires_partitioned_pred(__first, __last, __val, __comp);
 
       _DistanceType __len = std::distance(__first, __last);
       _DistanceType __half;
       _ForwardIterator __middle;
 
-      while (__len > 0) {
+      while (__len > 0)
+	{
 	  __half = __len >> 1;
 	  __middle = __first;
 	  std::advance(__middle, __half);
 	  if (__comp(__val, *__middle))
 	    __len = __half;
-	else {
+	  else
+	    {
 	      __first = __middle;
 	      ++__first;
 	      __len = __len - __half - 1;
@@ -2634,7 +2813,8 @@ namespace std
     {
       if (__len1 == 0 || __len2 == 0)
 	return;
-      if (__len1 + __len2 == 2) {
+      if (__len1 + __len2 == 2)
+	{
 	  if (*__middle < *__first)
 	    std::iter_swap(__first, __middle);
 	  return;
@@ -2643,13 +2823,15 @@ namespace std
       _BidirectionalIterator __second_cut = __middle;
       _Distance __len11 = 0;
       _Distance __len22 = 0;
-      if (__len1 > __len2) {
+      if (__len1 > __len2)
+	{
 	  __len11 = __len1 / 2;
 	  std::advance(__first_cut, __len11);
 	  __second_cut = std::lower_bound(__middle, __last, *__first_cut);
 	  __len22 = std::distance(__middle, __second_cut);
 	}
-      else {
+      else
+	{
 	  __len22 = __len2 / 2;
 	  std::advance(__second_cut, __len22);
 	  __first_cut = std::upper_bound(__first, __middle, *__second_cut);
@@ -2669,7 +2851,8 @@ namespace std
    *  This is a helper function for the merge routines.
    *  @endif
   */
-  template<typename _BidirectionalIterator, typename _Distance, typename _Compare>
+  template<typename _BidirectionalIterator, typename _Distance,
+	   typename _Compare>
     void
     __merge_without_buffer(_BidirectionalIterator __first,
                            _BidirectionalIterator __middle,
@@ -2679,7 +2862,8 @@ namespace std
     {
       if (__len1 == 0 || __len2 == 0)
 	return;
-      if (__len1 + __len2 == 2) {
+      if (__len1 + __len2 == 2)
+	{
 	  if (__comp(*__middle, *__first))
 	    std::iter_swap(__first, __middle);
 	  return;
@@ -2688,16 +2872,20 @@ namespace std
       _BidirectionalIterator __second_cut = __middle;
       _Distance __len11 = 0;
       _Distance __len22 = 0;
-      if (__len1 > __len2) {
+      if (__len1 > __len2)
+	{
 	  __len11 = __len1 / 2;
 	  std::advance(__first_cut, __len11);
-	__second_cut = std::lower_bound(__middle, __last, *__first_cut, __comp);
+	  __second_cut = std::lower_bound(__middle, __last, *__first_cut,
+					  __comp);
 	  __len22 = std::distance(__middle, __second_cut);
 	}
-      else {
+      else
+	{
 	  __len22 = __len2 / 2;
 	  std::advance(__second_cut, __len22);
-	__first_cut = std::upper_bound(__first, __middle, *__second_cut, __comp);
+	  __first_cut = std::upper_bound(__first, __middle, *__second_cut,
+					 __comp);
 	  __len11 = std::distance(__first, __first_cut);
 	}
       std::rotate(__first_cut, __middle, __second_cut);
@@ -2716,9 +2904,11 @@ namespace std
   */
   template<typename _RandomAccessIterator>
     void
-    __inplace_stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    __inplace_stable_sort(_RandomAccessIterator __first,
+			  _RandomAccessIterator __last)
+    {
+      if (__last - __first < 15)
 	{
-      if (__last - __first < 15) {
 	  std::__insertion_sort(__first, __last);
 	  return;
 	}
@@ -2737,10 +2927,11 @@ namespace std
   */
   template<typename _RandomAccessIterator, typename _Compare>
     void
-    __inplace_stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
-			  _Compare __comp)
+    __inplace_stable_sort(_RandomAccessIterator __first,
+			  _RandomAccessIterator __last, _Compare __comp)
+    {
+      if (__last - __first < 15)
 	{
-      if (__last - __first < 15) {
 	  std::__insertion_sort(__first, __last, __comp);
 	  return;
 	}
@@ -2769,7 +2960,8 @@ namespace std
    *  elements in the two ranges, elements from the first range will always
    *  come before elements from the second.
   */
-  template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator>
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator>
     _OutputIterator
     merge(_InputIterator1 __first1, _InputIterator1 __last1,
 	  _InputIterator2 __first2, _InputIterator2 __last2,
@@ -2788,18 +2980,22 @@ namespace std
       __glibcxx_requires_sorted(__first1, __last1);
       __glibcxx_requires_sorted(__first2, __last2);
 
-      while (__first1 != __last1 && __first2 != __last2) {
-	if (*__first2 < *__first1) {
+      while (__first1 != __last1 && __first2 != __last2)
+	{
+	  if (*__first2 < *__first1)
+	    {
 	      *__result = *__first2;
 	      ++__first2;
 	    }
-	else {
+	  else
+	    {
 	      *__result = *__first1;
 	      ++__first1;
 	    }
 	  ++__result;
 	}
-      return std::copy(__first2, __last2, std::copy(__first1, __last1, __result));
+      return std::copy(__first2, __last2, std::copy(__first1, __last1,
+						    __result));
     }
 
   /**
@@ -2822,8 +3018,8 @@ namespace std
    *  The comparison function should have the same effects on ordering as
    *  the function used for the initial sort.
   */
-  template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator,
-	   typename _Compare>
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator, typename _Compare>
     _OutputIterator
     merge(_InputIterator1 __first1, _InputIterator1 __last1,
 	  _InputIterator2 __first2, _InputIterator2 __last2,
@@ -2843,29 +3039,36 @@ namespace std
       __glibcxx_requires_sorted_pred(__first1, __last1, __comp);
       __glibcxx_requires_sorted_pred(__first2, __last2, __comp);
 
-      while (__first1 != __last1 && __first2 != __last2) {
-	if (__comp(*__first2, *__first1)) {
+      while (__first1 != __last1 && __first2 != __last2)
+	{
+	  if (__comp(*__first2, *__first1))
+	    {
 	      *__result = *__first2;
 	      ++__first2;
 	    }
-	else {
+	  else
+	    {
 	      *__result = *__first1;
 	      ++__first1;
 	    }
 	  ++__result;
 	}
-      return std::copy(__first2, __last2, std::copy(__first1, __last1, __result));
+      return std::copy(__first2, __last2, std::copy(__first1, __last1,
+						    __result));
     }
 
   template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
 	   typename _Distance>
     void
-    __merge_sort_loop(_RandomAccessIterator1 __first, _RandomAccessIterator1 __last,
-		      _RandomAccessIterator2 __result, _Distance __step_size)
+    __merge_sort_loop(_RandomAccessIterator1 __first,
+		      _RandomAccessIterator1 __last,
+		      _RandomAccessIterator2 __result,
+		      _Distance __step_size)
     {
-      _Distance __two_step = 2 * __step_size;
+      const _Distance __two_step = 2 * __step_size;
 
-      while (__last - __first >= __two_step) {
+      while (__last - __first >= __two_step)
+	{
 	  __result = std::merge(__first, __first + __step_size,
 				__first + __step_size, __first + __two_step,
 				__result);
@@ -2880,13 +3083,15 @@ namespace std
   template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
 	   typename _Distance, typename _Compare>
     void
-    __merge_sort_loop(_RandomAccessIterator1 __first, _RandomAccessIterator1 __last,
+    __merge_sort_loop(_RandomAccessIterator1 __first,
+		      _RandomAccessIterator1 __last,
 		      _RandomAccessIterator2 __result, _Distance __step_size,
 		      _Compare __comp)
     {
-      _Distance __two_step = 2 * __step_size;
+      const _Distance __two_step = 2 * __step_size;
 
-      while (__last - __first >= __two_step) {
+      while (__last - __first >= __two_step)
+	{
 	  __result = std::merge(__first, __first + __step_size,
 				__first + __step_size, __first + __two_step,
 				__result,
@@ -2905,10 +3110,12 @@ namespace std
 
   template<typename _RandomAccessIterator, typename _Distance>
     void
-    __chunk_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+    __chunk_insertion_sort(_RandomAccessIterator __first,
+			   _RandomAccessIterator __last,
 			   _Distance __chunk_size)
     {
-      while (__last - __first >= __chunk_size) {
+      while (__last - __first >= __chunk_size)
+	{
 	  std::__insertion_sort(__first, __first + __chunk_size);
 	  __first += __chunk_size;
 	}
@@ -2917,10 +3124,12 @@ namespace std
 
   template<typename _RandomAccessIterator, typename _Distance, typename _Compare>
     void
-    __chunk_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+    __chunk_insertion_sort(_RandomAccessIterator __first,
+			   _RandomAccessIterator __last,
 			   _Distance __chunk_size, _Compare __comp)
     {
-      while (__last - __first >= __chunk_size) {
+      while (__last - __first >= __chunk_size)
+	{
 	  std::__insertion_sort(__first, __first + __chunk_size, __comp);
 	  __first += __chunk_size;
 	}
@@ -2929,18 +3138,21 @@ namespace std
 
   template<typename _RandomAccessIterator, typename _Pointer>
     void
-    __merge_sort_with_buffer(_RandomAccessIterator __first, _RandomAccessIterator __last,
+    __merge_sort_with_buffer(_RandomAccessIterator __first,
+			     _RandomAccessIterator __last,
                              _Pointer __buffer)
     {
-      typedef typename iterator_traits<_RandomAccessIterator>::difference_type _Distance;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+	_Distance;
 
-      _Distance __len = __last - __first;
-      _Pointer __buffer_last = __buffer + __len;
+      const _Distance __len = __last - __first;
+      const _Pointer __buffer_last = __buffer + __len;
 
       _Distance __step_size = _S_chunk_size;
       std::__chunk_insertion_sort(__first, __last, __step_size);
 
-      while (__step_size < __len) {
+      while (__step_size < __len)
+	{
 	  std::__merge_sort_loop(__first, __last, __buffer, __step_size);
 	  __step_size *= 2;
 	  std::__merge_sort_loop(__buffer, __buffer_last, __first, __step_size);
@@ -2950,21 +3162,26 @@ namespace std
 
   template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
     void
-    __merge_sort_with_buffer(_RandomAccessIterator __first, _RandomAccessIterator __last,
+    __merge_sort_with_buffer(_RandomAccessIterator __first,
+			     _RandomAccessIterator __last,
                              _Pointer __buffer, _Compare __comp)
     {
-      typedef typename iterator_traits<_RandomAccessIterator>::difference_type _Distance;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+	_Distance;
 
-      _Distance __len = __last - __first;
-      _Pointer __buffer_last = __buffer + __len;
+      const _Distance __len = __last - __first;
+      const _Pointer __buffer_last = __buffer + __len;
 
       _Distance __step_size = _S_chunk_size;
       std::__chunk_insertion_sort(__first, __last, __step_size, __comp);
 
-      while (__step_size < __len) {
-	std::__merge_sort_loop(__first, __last, __buffer, __step_size, __comp);
+      while (__step_size < __len)
+	{
+	  std::__merge_sort_loop(__first, __last, __buffer,
+				 __step_size, __comp);
 	  __step_size *= 2;
-	std::__merge_sort_loop(__buffer, __buffer_last, __first, __step_size, __comp);
+	  std::__merge_sort_loop(__buffer, __buffer_last, __first,
+				 __step_size, __comp);
 	  __step_size *= 2;
 	}
     }
@@ -2977,8 +3194,10 @@ namespace std
   template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
 	   typename _BidirectionalIterator3>
     _BidirectionalIterator3
-    __merge_backward(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1,
-		     _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2,
+    __merge_backward(_BidirectionalIterator1 __first1,
+		     _BidirectionalIterator1 __last1,
+		     _BidirectionalIterator2 __first2,
+		     _BidirectionalIterator2 __last2,
 		     _BidirectionalIterator3 __result)
     {
       if (__first1 == __last1)
@@ -2987,14 +3206,17 @@ namespace std
 	return std::copy_backward(__first1, __last1, __result);
       --__last1;
       --__last2;
-      while (true) {
-	if (*__last2 < *__last1) {
+      while (true)
+	{
+	  if (*__last2 < *__last1)
+	    {
 	      *--__result = *__last1;
 	      if (__first1 == __last1)
 		return std::copy_backward(__first2, ++__last2, __result);
 	      --__last1;
 	    }
-	else {
+	  else
+	    {
 	      *--__result = *__last2;
 	      if (__first2 == __last2)
 		return std::copy_backward(__first1, ++__last1, __result);
@@ -3011,8 +3233,10 @@ namespace std
   template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
 	   typename _BidirectionalIterator3, typename _Compare>
     _BidirectionalIterator3
-    __merge_backward(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1,
-		     _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2,
+    __merge_backward(_BidirectionalIterator1 __first1,
+		     _BidirectionalIterator1 __last1,
+		     _BidirectionalIterator2 __first2,
+		     _BidirectionalIterator2 __last2,
 		     _BidirectionalIterator3 __result,
 		     _Compare __comp)
     {
@@ -3022,14 +3246,17 @@ namespace std
 	return std::copy_backward(__first1, __last1, __result);
       --__last1;
       --__last2;
-      while (true) {
-	if (__comp(*__last2, *__last1)) {
+      while (true)
+	{
+	  if (__comp(*__last2, *__last1))
+	    {
 	      *--__result = *__last1;
 	      if (__first1 == __last1)
 		return std::copy_backward(__first2, ++__last2, __result);
 	      --__last1;
 	    }
-	else {
+	  else
+	    {
 	      *--__result = *__last2;
 	      if (__first2 == __last2)
 		return std::copy_backward(__first1, ++__last1, __result);
@@ -3054,17 +3281,20 @@ namespace std
 		      _Distance __buffer_size)
     {
       _BidirectionalIterator2 __buffer_end;
-      if (__len1 > __len2 && __len2 <= __buffer_size) {
+      if (__len1 > __len2 && __len2 <= __buffer_size)
+	{
 	  __buffer_end = std::copy(__middle, __last, __buffer);
 	  std::copy_backward(__first, __middle, __last);
 	  return std::copy(__buffer, __buffer_end, __first);
 	}
-      else if (__len1 <= __buffer_size) {
+      else if (__len1 <= __buffer_size)
+	{
 	  __buffer_end = std::copy(__first, __middle, __buffer);
 	  std::copy(__middle, __last, __first);
 	  return std::copy_backward(__buffer, __buffer_end, __last);
 	}
-      else {
+      else
+	{
 	  std::rotate(__first, __middle, __last);
 	  std::advance(__first, std::distance(__middle, __last));
 	  return __first;
@@ -3076,7 +3306,8 @@ namespace std
    *  This is a helper function for the merge routines.
    *  @endif
   */
-  template<typename _BidirectionalIterator, typename _Distance, typename _Pointer>
+  template<typename _BidirectionalIterator, typename _Distance,
+	   typename _Pointer>
     void
     __merge_adaptive(_BidirectionalIterator __first,
                      _BidirectionalIterator __middle,
@@ -3084,29 +3315,37 @@ namespace std
 		     _Distance __len1, _Distance __len2,
 		     _Pointer __buffer, _Distance __buffer_size)
     {
-	  if (__len1 <= __len2 && __len1 <= __buffer_size) {
+      if (__len1 <= __len2 && __len1 <= __buffer_size)
+	{
 	  _Pointer __buffer_end = std::copy(__first, __middle, __buffer);
 	  std::merge(__buffer, __buffer_end, __middle, __last, __first);
 	}
-	  else if (__len2 <= __buffer_size) {
+      else if (__len2 <= __buffer_size)
+	{
 	  _Pointer __buffer_end = std::copy(__middle, __last, __buffer);
-	    std::__merge_backward(__first, __middle, __buffer, __buffer_end, __last);
+	  std::__merge_backward(__first, __middle, __buffer,
+				__buffer_end, __last);
 	}
-	  else {
+      else
+	{
 	  _BidirectionalIterator __first_cut = __first;
 	  _BidirectionalIterator __second_cut = __middle;
 	  _Distance __len11 = 0;
 	  _Distance __len22 = 0;
-	    if (__len1 > __len2) {
+	  if (__len1 > __len2)
+	    {
 	      __len11 = __len1 / 2;
 	      std::advance(__first_cut, __len11);
-		  __second_cut = std::lower_bound(__middle, __last, *__first_cut);
+	      __second_cut = std::lower_bound(__middle, __last,
+					      *__first_cut);
 	      __len22 = std::distance(__middle, __second_cut);
 	    }
-	    else {
+	  else
+	    {
 	      __len22 = __len2 / 2;
 	      std::advance(__second_cut, __len22);
-		  __first_cut = std::upper_bound(__first, __middle, *__second_cut);
+	      __first_cut = std::upper_bound(__first, __middle,
+					     *__second_cut);
 	      __len11 = std::distance(__first, __first_cut);
 	    }
 	  _BidirectionalIterator __new_middle =
@@ -3115,7 +3354,8 @@ namespace std
 				   __buffer_size);
 	  std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
 				__len22, __buffer, __buffer_size);
-	    std::__merge_adaptive(__new_middle, __second_cut, __last, __len1 - __len11,
+	  std::__merge_adaptive(__new_middle, __second_cut, __last,
+				__len1 - __len11,
 				__len2 - __len22, __buffer, __buffer_size);
 	}
     }
@@ -3135,30 +3375,37 @@ namespace std
 		     _Pointer __buffer, _Distance __buffer_size,
 		     _Compare __comp)
     {
-	  if (__len1 <= __len2 && __len1 <= __buffer_size) {
+      if (__len1 <= __len2 && __len1 <= __buffer_size)
+	{
 	  _Pointer __buffer_end = std::copy(__first, __middle, __buffer);
 	  std::merge(__buffer, __buffer_end, __middle, __last, __first, __comp);
 	}
-	  else if (__len2 <= __buffer_size) {
+      else if (__len2 <= __buffer_size)
+	{
 	  _Pointer __buffer_end = std::copy(__middle, __last, __buffer);
-	    std::__merge_backward(__first, __middle, __buffer, __buffer_end, __last,
-				  __comp);
+	  std::__merge_backward(__first, __middle, __buffer, __buffer_end,
+				__last, __comp);
 	}
-	  else {
+      else
+	{
 	  _BidirectionalIterator __first_cut = __first;
 	  _BidirectionalIterator __second_cut = __middle;
 	  _Distance __len11 = 0;
 	  _Distance __len22 = 0;
-	    if (__len1 > __len2) {
+	  if (__len1 > __len2)
+	    {
 	      __len11 = __len1 / 2;
 	      std::advance(__first_cut, __len11);
-		  __second_cut = std::lower_bound(__middle, __last, *__first_cut, __comp);
+	      __second_cut = std::lower_bound(__middle, __last, *__first_cut,
+					      __comp);
 	      __len22 = std::distance(__middle, __second_cut);
 	    }
-	    else {
+	  else
+	    {
 	      __len22 = __len2 / 2;
 	      std::advance(__second_cut, __len22);
-		  __first_cut = std::upper_bound(__first, __middle, *__second_cut, __comp);
+	      __first_cut = std::upper_bound(__first, __middle, *__second_cut,
+					     __comp);
 	      __len11 = std::distance(__first, __first_cut);
 	    }
 	  _BidirectionalIterator __new_middle =
@@ -3167,8 +3414,10 @@ namespace std
 				   __buffer_size);
 	  std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
 				__len22, __buffer, __buffer_size, __comp);
-	    std::__merge_adaptive(__new_middle, __second_cut, __last, __len1 - __len11,
-				  __len2 - __len22, __buffer, __buffer_size, __comp);
+	  std::__merge_adaptive(__new_middle, __second_cut, __last,
+				__len1 - __len11,
+				__len2 - __len22, __buffer,
+				__buffer_size, __comp);
 	}
     }
 
@@ -3213,7 +3462,8 @@ namespace std
       _DistanceType __len1 = std::distance(__first, __middle);
       _DistanceType __len2 = std::distance(__middle, __last);
 
-      _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first, __last);
+      _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first,
+								  __last);
       if (__buf.begin() == 0)
 	std::__merge_without_buffer(__first, __middle, __last, __len1, __len2);
       else
@@ -3265,58 +3515,73 @@ namespace std
       if (__first == __middle || __middle == __last)
 	return;
 
-      _DistanceType __len1 = std::distance(__first, __middle);
-      _DistanceType __len2 = std::distance(__middle, __last);
+      const _DistanceType __len1 = std::distance(__first, __middle);
+      const _DistanceType __len2 = std::distance(__middle, __last);
 
-      _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first, __last);
+      _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first,
+								  __last);
       if (__buf.begin() == 0)
-	std::__merge_without_buffer(__first, __middle, __last, __len1, __len2, __comp);
+	std::__merge_without_buffer(__first, __middle, __last, __len1,
+				    __len2, __comp);
       else
 	std::__merge_adaptive(__first, __middle, __last, __len1, __len2,
 			      __buf.begin(), _DistanceType(__buf.size()),
 			      __comp);
     }
 
-  template<typename _RandomAccessIterator, typename _Pointer, typename _Distance>
+  template<typename _RandomAccessIterator, typename _Pointer,
+	   typename _Distance>
     void
-    __stable_sort_adaptive(_RandomAccessIterator __first, _RandomAccessIterator __last,
+    __stable_sort_adaptive(_RandomAccessIterator __first,
+			   _RandomAccessIterator __last,
                            _Pointer __buffer, _Distance __buffer_size)
     {
-      _Distance __len = (__last - __first + 1) / 2;
-      _RandomAccessIterator __middle = __first + __len;
-      if (__len > __buffer_size) {
-	std::__stable_sort_adaptive(__first, __middle, __buffer, __buffer_size);
-	std::__stable_sort_adaptive(__middle, __last, __buffer, __buffer_size);
+      const _Distance __len = (__last - __first + 1) / 2;
+      const _RandomAccessIterator __middle = __first + __len;
+      if (__len > __buffer_size)
+	{
+	  std::__stable_sort_adaptive(__first, __middle,
+				      __buffer, __buffer_size);
+	  std::__stable_sort_adaptive(__middle, __last,
+				      __buffer, __buffer_size);
 	}
-      else {
+      else
+	{
 	  std::__merge_sort_with_buffer(__first, __middle, __buffer);
 	  std::__merge_sort_with_buffer(__middle, __last, __buffer);
 	}
-      std::__merge_adaptive(__first, __middle, __last, _Distance(__middle - __first),
-			    _Distance(__last - __middle), __buffer, __buffer_size);
+      std::__merge_adaptive(__first, __middle, __last,
+			    _Distance(__middle - __first),
+			    _Distance(__last - __middle),
+			    __buffer, __buffer_size);
     }
 
-  template<typename _RandomAccessIterator, typename _Pointer, typename _Distance,
-           typename _Compare>
+  template<typename _RandomAccessIterator, typename _Pointer,
+	   typename _Distance, typename _Compare>
     void
-    __stable_sort_adaptive(_RandomAccessIterator __first, _RandomAccessIterator __last,
+    __stable_sort_adaptive(_RandomAccessIterator __first,
+			   _RandomAccessIterator __last,
                            _Pointer __buffer, _Distance __buffer_size,
                            _Compare __comp)
     {
-      _Distance __len = (__last - __first + 1) / 2;
-      _RandomAccessIterator __middle = __first + __len;
-      if (__len > __buffer_size) {
-	std::__stable_sort_adaptive(__first, __middle, __buffer, __buffer_size,
-				    __comp);
-	std::__stable_sort_adaptive(__middle, __last, __buffer, __buffer_size,
-				    __comp);
+      const _Distance __len = (__last - __first + 1) / 2;
+      const _RandomAccessIterator __middle = __first + __len;
+      if (__len > __buffer_size)
+	{
+	  std::__stable_sort_adaptive(__first, __middle, __buffer,
+				      __buffer_size, __comp);
+	  std::__stable_sort_adaptive(__middle, __last, __buffer,
+				      __buffer_size, __comp);
 	}
-      else {
+      else
+	{
 	  std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
 	  std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
 	}
-      std::__merge_adaptive(__first, __middle, __last, _Distance(__middle - __first),
-			    _Distance(__last - __middle), __buffer, __buffer_size,
+      std::__merge_adaptive(__first, __middle, __last,
+			    _Distance(__middle - __first),
+			    _Distance(__last - __middle),
+			    __buffer, __buffer_size,
 			    __comp);
     }
 
@@ -3340,8 +3605,10 @@ namespace std
     inline void
     stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
     {
-      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
-      typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	_ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+	_DistanceType;
 
       // concept requirements
       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
@@ -3349,11 +3616,13 @@ namespace std
       __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
       __glibcxx_requires_valid_range(__first, __last);
 
-      _Temporary_buffer<_RandomAccessIterator, _ValueType> buf(__first, __last);
+      _Temporary_buffer<_RandomAccessIterator, _ValueType>
+	buf(__first, __last);
       if (buf.begin() == 0)
 	std::__inplace_stable_sort(__first, __last);
       else
-	std::__stable_sort_adaptive(__first, __last, buf.begin(), _DistanceType(buf.size()));
+	std::__stable_sort_adaptive(__first, __last, buf.begin(),
+				    _DistanceType(buf.size()));
     }
 
   /**
@@ -3375,24 +3644,28 @@ namespace std
   */
   template<typename _RandomAccessIterator, typename _Compare>
     inline void
-    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
+    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+		_Compare __comp)
     {
-      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
-      typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	_ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+	_DistanceType;
 
       // concept requirements
       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
 	    _RandomAccessIterator>)
       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
-							  _ValueType, _ValueType>)
+				  _ValueType,
+				  _ValueType>)
       __glibcxx_requires_valid_range(__first, __last);
 
       _Temporary_buffer<_RandomAccessIterator, _ValueType> buf(__first, __last);
       if (buf.begin() == 0)
 	std::__inplace_stable_sort(__first, __last, __comp);
       else
-	std::__stable_sort_adaptive(__first, __last, buf.begin(), _DistanceType(buf.size()),
-				    __comp);
+	std::__stable_sort_adaptive(__first, __last, buf.begin(),
+				    _DistanceType(buf.size()), __comp);
     }
 
   /**
@@ -3416,20 +3689,27 @@ namespace std
 		_RandomAccessIterator __nth,
 		_RandomAccessIterator __last)
     {
-      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	_ValueType;
 
       // concept requirements
-      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<_RandomAccessIterator>)
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+				  _RandomAccessIterator>)
       __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
       __glibcxx_requires_valid_range(__first, __nth);
       __glibcxx_requires_valid_range(__nth, __last);
 
-      while (__last - __first > 3) {
+      while (__last - __first > 3)
+	{
 	  _RandomAccessIterator __cut =
 	    std::__unguarded_partition(__first, __last,
 				       _ValueType(std::__median(*__first,
-							      *(__first + (__last - __first)/2),
-							      *(__last - 1))));
+								*(__first
+								  + (__last
+								     - __first)
+								  / 2),
+								*(__last
+								  - 1))));
 	  if (__cut <= __nth)
 	    __first = __cut;
 	  else
@@ -3461,20 +3741,26 @@ namespace std
 		_RandomAccessIterator __last,
 			    _Compare __comp)
     {
-      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	_ValueType;
 
       // concept requirements
-      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<_RandomAccessIterator>)
+      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
+				  _RandomAccessIterator>)
       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
 				  _ValueType, _ValueType>)
       __glibcxx_requires_valid_range(__first, __nth);
       __glibcxx_requires_valid_range(__nth, __last);
 
-      while (__last - __first > 3) {
+      while (__last - __first > 3)
+	{
 	  _RandomAccessIterator __cut =
 	    std::__unguarded_partition(__first, __last,
 				       _ValueType(std::__median(*__first,
-							      *(__first + (__last - __first)/2),
+								*(__first 
+								  + (__last
+								     - __first) 
+								  / 2),
 								*(__last - 1),
 							      __comp)), __comp);
 	  if (__cut <= __nth)
@@ -3503,10 +3789,13 @@ namespace std
   */
   template<typename _ForwardIterator, typename _Tp>
     pair<_ForwardIterator, _ForwardIterator>
-    equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val)
+    equal_range(_ForwardIterator __first, _ForwardIterator __last,
+		const _Tp& __val)
     {
-      typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
-      typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType;
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+	_ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+	_DistanceType;
 
       // concept requirements
       // See comments on lower_bound.
@@ -3519,18 +3808,21 @@ namespace std
       _DistanceType __half;
       _ForwardIterator __middle, __left, __right;
 
-      while (__len > 0) {
+      while (__len > 0)
+	{
 	  __half = __len >> 1;
 	  __middle = __first;
 	  std::advance(__middle, __half);
-	if (*__middle < __val) {
+	  if (*__middle < __val)
+	    {
 	      __first = __middle;
 	      ++__first;
 	      __len = __len - __half - 1;
 	    }
 	  else if (__val < *__middle)
 	    __len = __half;
-	else {
+	  else
+	    {
 	      __left = std::lower_bound(__first, __middle, __val);
 	      std::advance(__first, __len);
 	      __right = std::upper_bound(++__middle, __first, __val);
@@ -3559,34 +3851,42 @@ namespace std
   */
   template<typename _ForwardIterator, typename _Tp, typename _Compare>
     pair<_ForwardIterator, _ForwardIterator>
-    equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val,
+    equal_range(_ForwardIterator __first, _ForwardIterator __last,
+		const _Tp& __val,
 		_Compare __comp)
     {
-      typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
-      typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType;
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+	_ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+	_DistanceType;
 
       // concept requirements
       __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
-      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, _ValueType, _Tp>)
-      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, _Tp, _ValueType>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+				  _ValueType, _Tp>)
+      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
+				  _Tp, _ValueType>)
       __glibcxx_requires_partitioned_pred(__first, __last, __val, __comp);
 
       _DistanceType __len = std::distance(__first, __last);
       _DistanceType __half;
       _ForwardIterator __middle, __left, __right;
 
-      while (__len > 0) {
+      while (__len > 0)
+	{
 	  __half = __len >> 1;
 	  __middle = __first;
 	  std::advance(__middle, __half);
-	if (__comp(*__middle, __val)) {
+	  if (__comp(*__middle, __val))
+	    {
 	      __first = __middle;
 	      ++__first;
 	      __len = __len - __half - 1;
 	    }
 	  else if (__comp(__val, *__middle))
 	    __len = __half;
-	else {
+	  else
+	    {
 	      __left = std::lower_bound(__first, __middle, __val, __comp);
 	      std::advance(__first, __len);
 	      __right = std::upper_bound(++__middle, __first, __val, __comp);
@@ -3723,7 +4023,8 @@ namespace std
    *  in [first2,last2) is not found before the search iterator reaches @a
    *  last2, false is returned.
   */
-  template<typename _InputIterator1, typename _InputIterator2, typename _Compare>
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _Compare>
     bool
     includes(_InputIterator1 __first1, _InputIterator1 __last1,
 	     _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp)
@@ -3768,7 +4069,8 @@ namespace std
    *  both ranges advance.  The output range may not overlap either input
    *  range.
   */
-  template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator>
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator>
     _OutputIterator
     set_union(_InputIterator1 __first1, _InputIterator1 __last1,
 	      _InputIterator2 __first2, _InputIterator2 __last2,
@@ -3787,23 +4089,28 @@ namespace std
       __glibcxx_requires_sorted(__first1, __last1);
       __glibcxx_requires_sorted(__first2, __last2);
 
-      while (__first1 != __last1 && __first2 != __last2) {
-	if (*__first1 < *__first2) {
+      while (__first1 != __last1 && __first2 != __last2)
+	{
+	  if (*__first1 < *__first2)
+	    {
 	      *__result = *__first1;
 	      ++__first1;
 	    }
-	else if (*__first2 < *__first1) {
+	  else if (*__first2 < *__first1)
+	    {
 	      *__result = *__first2;
 	      ++__first2;
 	    }
-	else {
+	  else
+	    {
 	      *__result = *__first1;
 	      ++__first1;
 	      ++__first2;
 	    }
 	  ++__result;
 	}
-      return std::copy(__first2, __last2, std::copy(__first1, __last1, __result));
+      return std::copy(__first2, __last2, std::copy(__first1, __last1,
+						    __result));
     }
 
   /**
@@ -3824,8 +4131,8 @@ namespace std
    *  ranges, the element from the first range is copied and both ranges
    *  advance.  The output range may not overlap either input range.
   */
-  template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator,
-	   typename _Compare>
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator, typename _Compare>
     _OutputIterator
     set_union(_InputIterator1 __first1, _InputIterator1 __last1,
 	      _InputIterator2 __first2, _InputIterator2 __last2,
@@ -3845,23 +4152,28 @@ namespace std
       __glibcxx_requires_sorted_pred(__first1, __last1, __comp);
       __glibcxx_requires_sorted_pred(__first2, __last2, __comp);
 
-      while (__first1 != __last1 && __first2 != __last2) {
-	if (__comp(*__first1, *__first2)) {
+      while (__first1 != __last1 && __first2 != __last2)
+	{
+	  if (__comp(*__first1, *__first2))
+	    {
 	      *__result = *__first1;
 	      ++__first1;
 	    }
-	else if (__comp(*__first2, *__first1)) {
+	  else if (__comp(*__first2, *__first1))
+	    {
 	      *__result = *__first2;
 	      ++__first2;
 	    }
-	else {
+	  else 
+	    {
 	      *__result = *__first1;
 	      ++__first1;
 	      ++__first2;
 	    }
 	  ++__result;
 	}
-      return std::copy(__first2, __last2, std::copy(__first1, __last1, __result));
+      return std::copy(__first2, __last2, std::copy(__first1, __last1, 
+						    __result));
     }
 
   /**
@@ -3880,7 +4192,8 @@ namespace std
    *  element from the first range is copied and both ranges advance.  The
    *  output range may not overlap either input range.
   */
-  template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator>
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator>
     _OutputIterator
     set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
 		     _InputIterator2 __first2, _InputIterator2 __last2,
@@ -3904,7 +4217,8 @@ namespace std
 	  ++__first1;
 	else if (*__first2 < *__first1)
 	  ++__first2;
-	else {
+	else
+	  {
 	    *__result = *__first1;
 	    ++__first1;
 	    ++__first2;
@@ -3932,8 +4246,8 @@ namespace std
    *  first range is copied and both ranges advance.  The output range may not
    *  overlap either input range.
   */
-  template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator,
-	   typename _Compare>
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator, typename _Compare>
     _OutputIterator
     set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
 		     _InputIterator2 __first2, _InputIterator2 __last2,
@@ -3958,7 +4272,8 @@ namespace std
 	  ++__first1;
 	else if (__comp(*__first2, *__first1))
 	  ++__first2;
-	else {
+	else
+	  {
 	    *__result = *__first1;
 	    ++__first1;
 	    ++__first2;
@@ -3985,7 +4300,8 @@ namespace std
    *  contained in both ranges, no elements are copied and both ranges
    *  advance.  The output range may not overlap either input range.
   */
-  template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator>
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator>
     _OutputIterator
     set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
 		   _InputIterator2 __first2, _InputIterator2 __last2,
@@ -4005,14 +4321,16 @@ namespace std
       __glibcxx_requires_sorted(__first2, __last2);
 
       while (__first1 != __last1 && __first2 != __last2)
-	if (*__first1 < *__first2) {
+	if (*__first1 < *__first2)
+	  {
 	    *__result = *__first1;
 	    ++__first1;
 	    ++__result;
 	  }
 	else if (*__first2 < *__first1)
 	  ++__first2;
-	else {
+	else
+	  {
 	    ++__first1;
 	    ++__first2;
 	  }
@@ -4040,8 +4358,8 @@ namespace std
    *  elements are copied and both ranges advance.  The output range may not
    *  overlap either input range.
   */
-  template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator,
-	   typename _Compare>
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator, typename _Compare>
     _OutputIterator
     set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
 		   _InputIterator2 __first2, _InputIterator2 __last2,
@@ -4062,14 +4380,16 @@ namespace std
       __glibcxx_requires_sorted_pred(__first2, __last2, __comp);
 
       while (__first1 != __last1 && __first2 != __last2)
-	if (__comp(*__first1, *__first2)) {
+	if (__comp(*__first1, *__first2))
+	  {
 	    *__result = *__first1;
 	    ++__first1;
 	    ++__result;
 	  }
 	else if (__comp(*__first2, *__first1))
 	  ++__first2;
-	else {
+	else
+	  {
 	    ++__first1;
 	    ++__first2;
 	  }
@@ -4092,7 +4412,8 @@ namespace std
    *  element is contained in both ranges, no elements are copied and both
    *  ranges advance.  The output range may not overlap either input range.
   */
-  template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator>
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator>
     _OutputIterator
     set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
 			     _InputIterator2 __first2, _InputIterator2 __last2,
@@ -4112,21 +4433,25 @@ namespace std
       __glibcxx_requires_sorted(__first2, __last2);
 
       while (__first1 != __last1 && __first2 != __last2)
-	if (*__first1 < *__first2) {
+	if (*__first1 < *__first2)
+	  {
 	    *__result = *__first1;
 	    ++__first1;
 	    ++__result;
 	  }
-	else if (*__first2 < *__first1) {
+	else if (*__first2 < *__first1)
+	  {
 	    *__result = *__first2;
 	    ++__first2;
 	    ++__result;
 	  }
-	else {
+	else
+	  {
 	    ++__first1;
 	    ++__first2;
 	  }
-      return std::copy(__first2, __last2, std::copy(__first1, __last1, __result));
+      return std::copy(__first2, __last2, std::copy(__first1, 
+						    __last1, __result));
     }
 
   /**
@@ -4148,8 +4473,8 @@ namespace std
    *  to @a comp, no elements are copied and both ranges advance.  The output
    *  range may not overlap either input range.
   */
-  template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator,
-	   typename _Compare>
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _OutputIterator, typename _Compare>
     _OutputIterator
     set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
 			     _InputIterator2 __first2, _InputIterator2 __last2,
@@ -4171,21 +4496,25 @@ namespace std
       __glibcxx_requires_sorted_pred(__first2, __last2, __comp);
 
       while (__first1 != __last1 && __first2 != __last2)
-	if (__comp(*__first1, *__first2)) {
+	if (__comp(*__first1, *__first2))
+	  {
 	    *__result = *__first1;
 	    ++__first1;
 	    ++__result;
 	  }
-	else if (__comp(*__first2, *__first1)) {
+	else if (__comp(*__first2, *__first1))
+	  {
 	    *__result = *__first2;
 	    ++__first2;
 	    ++__result;
 	  }
-	else {
+	else
+	  {
 	    ++__first1;
 	    ++__first2;
 	  }
-      return std::copy(__first2, __last2, std::copy(__first1, __last1, __result));
+      return std::copy(__first2, __last2, std::copy(__first1,
+						    __last1, __result));
     }
 
   // min_element and max_element, with and without an explicitly supplied
@@ -4207,7 +4536,8 @@ namespace std
 	    typename iterator_traits<_ForwardIterator>::value_type>)
       __glibcxx_requires_valid_range(__first, __last);
 
-      if (__first == __last) return __first;
+      if (__first == __last)
+	return __first;
       _ForwardIterator __result = __first;
       while (++__first != __last)
 	if (*__result < *__first)
@@ -4258,7 +4588,8 @@ namespace std
 	    typename iterator_traits<_ForwardIterator>::value_type>)
       __glibcxx_requires_valid_range(__first, __last);
 
-      if (__first == __last) return __first;
+      if (__first == __last)
+	return __first;
       _ForwardIterator __result = __first;
       while (++__first != __last)
 	if (*__first < *__result)
@@ -4286,7 +4617,8 @@ namespace std
 	    typename iterator_traits<_ForwardIterator>::value_type>)
       __glibcxx_requires_valid_range(__first, __last);
 
-      if (__first == __last) return __first;
+      if (__first == __last)
+	return __first;
       _ForwardIterator __result = __first;
       while (++__first != __last)
 	if (__comp(*__first, *__result))
@@ -4310,10 +4642,12 @@ namespace std
   */
   template<typename _BidirectionalIterator>
     bool
-    next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
+    next_permutation(_BidirectionalIterator __first,
+		     _BidirectionalIterator __last)
     {
       // concept requirements
-      __glibcxx_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator>)
+      __glibcxx_function_requires(_BidirectionalIteratorConcept<
+				  _BidirectionalIterator>)
       __glibcxx_function_requires(_LessThanComparableConcept<
 	    typename iterator_traits<_BidirectionalIterator>::value_type>)
       __glibcxx_requires_valid_range(__first, __last);
@@ -4327,10 +4661,12 @@ namespace std
       __i = __last;
       --__i;
 
-      for(;;) {
+      for(;;)
+	{
 	  _BidirectionalIterator __ii = __i;
 	  --__i;
-	if (*__i < *__ii) {
+	  if (*__i < *__ii)
+	    {
 	      _BidirectionalIterator __j = __last;
 	      while (!(*__i < *--__j))
 		{}
@@ -4338,7 +4674,8 @@ namespace std
 	      std::reverse(__ii, __last);
 	      return true;
 	    }
-	if (__i == __first) {
+	  if (__i == __first)
+	    {
 	      std::reverse(__first, __last);
 	      return false;
 	    }
@@ -4361,11 +4698,12 @@ namespace std
   */
   template<typename _BidirectionalIterator, typename _Compare>
     bool
-    next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last,
-		     _Compare __comp)
+    next_permutation(_BidirectionalIterator __first,
+		     _BidirectionalIterator __last, _Compare __comp)
     {
       // concept requirements
-      __glibcxx_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator>)
+      __glibcxx_function_requires(_BidirectionalIteratorConcept<
+				  _BidirectionalIterator>)
       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
 	    typename iterator_traits<_BidirectionalIterator>::value_type,
 	    typename iterator_traits<_BidirectionalIterator>::value_type>)
@@ -4380,10 +4718,12 @@ namespace std
       __i = __last;
       --__i;
 
-      for(;;) {
+      for(;;)
+	{
 	  _BidirectionalIterator __ii = __i;
 	  --__i;
-	if (__comp(*__i, *__ii)) {
+	  if (__comp(*__i, *__ii))
+	    {
 	      _BidirectionalIterator __j = __last;
 	      while (!__comp(*__i, *--__j))
 		{}
@@ -4391,7 +4731,8 @@ namespace std
 	      std::reverse(__ii, __last);
 	      return true;
 	    }
-	if (__i == __first) {
+	  if (__i == __first)
+	    {
 	      std::reverse(__first, __last);
 	      return false;
 	    }
@@ -4412,10 +4753,12 @@ namespace std
   */
   template<typename _BidirectionalIterator>
     bool
-    prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
+    prev_permutation(_BidirectionalIterator __first,
+		     _BidirectionalIterator __last)
     {
       // concept requirements
-      __glibcxx_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator>)
+      __glibcxx_function_requires(_BidirectionalIteratorConcept<
+				  _BidirectionalIterator>)
       __glibcxx_function_requires(_LessThanComparableConcept<
 	    typename iterator_traits<_BidirectionalIterator>::value_type>)
       __glibcxx_requires_valid_range(__first, __last);
@@ -4429,10 +4772,12 @@ namespace std
       __i = __last;
       --__i;
 
-      for(;;) {
+      for(;;)
+	{
 	  _BidirectionalIterator __ii = __i;
 	  --__i;
-	if (*__ii < *__i) {
+	  if (*__ii < *__i)
+	    {
 	      _BidirectionalIterator __j = __last;
 	      while (!(*--__j < *__i))
 		{}
@@ -4440,7 +4785,8 @@ namespace std
 	      std::reverse(__ii, __last);
 	      return true;
 	    }
-	if (__i == __first) {
+	  if (__i == __first)
+	    {
 	      std::reverse(__first, __last);
 	      return false;
 	    }
@@ -4463,11 +4809,12 @@ namespace std
   */
   template<typename _BidirectionalIterator, typename _Compare>
     bool
-    prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last,
-		     _Compare __comp)
+    prev_permutation(_BidirectionalIterator __first,
+		     _BidirectionalIterator __last, _Compare __comp)
     {
       // concept requirements
-      __glibcxx_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator>)
+      __glibcxx_function_requires(_BidirectionalIteratorConcept<
+				  _BidirectionalIterator>)
       __glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
 	    typename iterator_traits<_BidirectionalIterator>::value_type,
 	    typename iterator_traits<_BidirectionalIterator>::value_type>)
@@ -4482,10 +4829,12 @@ namespace std
       __i = __last;
       --__i;
 
-      for(;;) {
+      for(;;)
+	{
 	  _BidirectionalIterator __ii = __i;
 	  --__i;
-	if (__comp(*__ii, *__i)) {
+	  if (__comp(*__ii, *__i))
+	    {
 	      _BidirectionalIterator __j = __last;
 	      while (!__comp(*--__j, *__i))
 		{}
@@ -4493,7 +4842,8 @@ namespace std
 	      std::reverse(__ii, __last);
 	      return true;
 	    }
-	if (__i == __first) {
+	  if (__i == __first)
+	    {
 	      std::reverse(__first, __last);
 	      return false;
 	    }
@@ -4552,7 +4902,8 @@ namespace std
    *  some element in the range [first2,last2).  If found, returns an iterator in
    *  the range [first1,last1), otherwise returns @p last1.
   */
-  template<typename _InputIterator, typename _ForwardIterator, typename _BinaryPredicate>
+  template<typename _InputIterator, typename _ForwardIterator,
+	   typename _BinaryPredicate>
     _InputIterator
     find_first_of(_InputIterator __first1, _InputIterator __last1,
 		  _ForwardIterator __first2, _ForwardIterator __last2,
@@ -4592,14 +4943,17 @@ namespace std
     {
       if (__first2 == __last2)
 	return __last1;
-      else {
+      else
+	{
 	  _ForwardIterator1 __result = __last1;
-	while (1) {
+	  while (1)
+	    {
 	      _ForwardIterator1 __new_result
 		= std::search(__first1, __last1, __first2, __last2);
 	      if (__new_result == __last1)
 		return __result;
-	  else {
+	      else
+		{
 		  __result = __new_result;
 		  __first1 = __new_result;
 		  ++__first1;
@@ -4618,14 +4972,17 @@ namespace std
     {
       if (__first2 == __last2)
 	return __last1;
-      else {
+      else
+	{
 	  _ForwardIterator1 __result = __last1;
-	while (1) {
+	  while (1)
+	    {
 	      _ForwardIterator1 __new_result
 		= std::search(__first1, __last1, __first2, __last2, __comp);
 	      if (__new_result == __last1)
 		return __result;
-	  else {
+	      else
+		{
 		  __result = __new_result;
 		  __first1 = __new_result;
 		  ++__first1;
@@ -4637,13 +4994,17 @@ namespace std
   // find_end for bidirectional iterators.  Requires partial specialization.
   template<typename _BidirectionalIterator1, typename _BidirectionalIterator2>
     _BidirectionalIterator1
-    __find_end(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1,
-	       _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2,
+    __find_end(_BidirectionalIterator1 __first1,
+	       _BidirectionalIterator1 __last1,
+	       _BidirectionalIterator2 __first2,
+	       _BidirectionalIterator2 __last2,
 	       bidirectional_iterator_tag, bidirectional_iterator_tag)
     {
       // concept requirements
-      __glibcxx_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator1>)
-      __glibcxx_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator2>)
+      __glibcxx_function_requires(_BidirectionalIteratorConcept<
+				  _BidirectionalIterator1>)
+      __glibcxx_function_requires(_BidirectionalIteratorConcept<
+				  _BidirectionalIterator2>)
 
       typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
       typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
@@ -4655,7 +5016,8 @@ namespace std
 
       if (__rresult == __rlast1)
 	return __last1;
-      else {
+      else
+	{
 	  _BidirectionalIterator1 __result = __rresult.base();
 	  std::advance(__result, -std::distance(__first2, __last2));
 	  return __result;
@@ -4665,14 +5027,18 @@ namespace std
   template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
 	   typename _BinaryPredicate>
     _BidirectionalIterator1
-    __find_end(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1,
-	       _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2,
+    __find_end(_BidirectionalIterator1 __first1, 
+	       _BidirectionalIterator1 __last1,
+	       _BidirectionalIterator2 __first2, 
+	       _BidirectionalIterator2 __last2,
 	       bidirectional_iterator_tag, bidirectional_iterator_tag,
 	       _BinaryPredicate __comp)
     {
       // concept requirements
-      __glibcxx_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator1>)
-      __glibcxx_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator2>)
+      __glibcxx_function_requires(_BidirectionalIteratorConcept<
+				  _BidirectionalIterator1>)
+      __glibcxx_function_requires(_BidirectionalIteratorConcept<
+				  _BidirectionalIterator2>)
 
       typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
       typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
@@ -4685,7 +5051,8 @@ namespace std
 
       if (__rresult == __rlast1)
 	return __last1;
-      else {
+      else
+	{
 	  _BidirectionalIterator1 __result = __rresult.base();
 	  std::advance(__result, -std::distance(__first2, __last2));
 	  return __result;
@@ -4788,4 +5155,3 @@ namespace std
 } // namespace std
 
 #endif /* _ALGO_H */
-

libstdc++-v3/include/bits/stl_algobase.h

@@ -91,16 +91,22 @@ namespace std
     inline void
     iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
     {
-      typedef typename iterator_traits<_ForwardIterator1>::value_type _ValueType1;
-      typedef typename iterator_traits<_ForwardIterator2>::value_type _ValueType2;
+      typedef typename iterator_traits<_ForwardIterator1>::value_type
+	_ValueType1;
+      typedef typename iterator_traits<_ForwardIterator2>::value_type
+	_ValueType2;
 
       // concept requirements
-      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator1>)
-      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator2>)
-      __glibcxx_function_requires(_ConvertibleConcept<_ValueType1, _ValueType2>)
-      __glibcxx_function_requires(_ConvertibleConcept<_ValueType2, _ValueType1>)
-
-      _ValueType1 __tmp = *__a;
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator1>)
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator2>)
+      __glibcxx_function_requires(_ConvertibleConcept<_ValueType1,
+				  _ValueType2>)
+      __glibcxx_function_requires(_ConvertibleConcept<_ValueType2,
+				  _ValueType1>)
+
+      const _ValueType1 __tmp = *__a;
       *__a = *__b;
       *__b = __tmp;
     }
@@ -121,7 +127,7 @@ namespace std
       // concept requirements
       __glibcxx_function_requires(_SGIAssignableConcept<_Tp>)
       
-      _Tp __tmp = __a;
+      const _Tp __tmp = __a;
       __a = __b;
       __b = __tmp;
     }
@@ -146,7 +152,9 @@ namespace std
       // concept requirements
       __glibcxx_function_requires(_LessThanComparableConcept<_Tp>)
       //return __b < __a ? __b : __a;
-      if (__b < __a) return __b; return __a;
+      if (__b < __a)
+	return __b;
+      return __a;
     }
 
   /**
@@ -166,7 +174,9 @@ namespace std
       // concept requirements
       __glibcxx_function_requires(_LessThanComparableConcept<_Tp>)
       //return  __a < __b ? __b : __a;
-      if (__a < __b) return __b; return __a;
+      if (__a < __b)
+	return __b;
+      return __a;
     }
 
   /**
@@ -184,7 +194,9 @@ namespace std
     min(const _Tp& __a, const _Tp& __b, _Compare __comp)
     {
       //return __comp(__b, __a) ? __b : __a;
-      if (__comp(__b, __a)) return __b; return __a;
+      if (__comp(__b, __a))
+	return __b;
+      return __a;
     }
 
   /**
@@ -202,7 +214,9 @@ namespace std
     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
     {
       //return __comp(__a, __b) ? __b : __a;
-      if (__comp(__a, __b)) return __b; return __a;
+      if (__comp(__a, __b))
+	return __b;
+      return __a;
     }
 
   // All of these auxiliary functions serve two purposes.  (1) Replace
@@ -249,13 +263,15 @@ namespace std
     inline _OutputIterator
     __copy_aux2(_InputIterator __first, _InputIterator __last,
 		_OutputIterator __result, __false_type)
-    { return std::__copy(__first, __last, __result, std::__iterator_category(__first)); }
+    { return std::__copy(__first, __last, __result,
+			 std::__iterator_category(__first)); }
 
   template<typename _InputIterator, typename _OutputIterator>
     inline _OutputIterator
     __copy_aux2(_InputIterator __first, _InputIterator __last,
 		_OutputIterator __result, __true_type)
-    { return std::__copy(__first, __last, __result, std::__iterator_category(__first)); }
+    { return std::__copy(__first, __last, __result,
+			 std::__iterator_category(__first)); }
 
   template<typename _Tp>
     inline _Tp*
@@ -275,8 +291,8 @@ namespace std
     {
       typedef typename iterator_traits<_InputIterator>::value_type
 	_ValueType;
-      typedef typename __type_traits<_ValueType>::has_trivial_assignment_operator
-	  _Trivial;
+      typedef typename __type_traits<
+	_ValueType>::has_trivial_assignment_operator _Trivial;
       return _OutputIterator(std::__copy_aux2(__first, __last, __result.base(),
 					      _Trivial()));
     }
@@ -287,8 +303,8 @@ namespace std
 	       _OutputIterator __result, __false_type)
     {
       typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
-      typedef typename __type_traits<_ValueType>::has_trivial_assignment_operator
-          _Trivial;
+      typedef typename __type_traits<
+	_ValueType>::has_trivial_assignment_operator _Trivial;
       return std::__copy_aux2(__first, __last, __result, _Trivial());
     }
 
@@ -298,7 +314,8 @@ namespace std
 	       _OutputIterator __result, __true_type)
     {
       typedef typename _Is_normal_iterator<_OutputIterator>::_Normal __Normal;
-      return std::__copy_ni2(__first.base(), __last.base(), __result, __Normal());
+      return std::__copy_ni2(__first.base(), __last.base(),
+			     __result, __Normal());
     }
 
   template<typename _InputIterator, typename _OutputIterator>
@@ -328,7 +345,8 @@ namespace std
   */
   template<typename _InputIterator, typename _OutputIterator>
     inline _OutputIterator
-    copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
+    copy(_InputIterator __first, _InputIterator __last,
+	 _OutputIterator __result)
     {
       // concept requirements
       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
@@ -342,8 +360,10 @@ namespace std
 
   template<typename _BidirectionalIterator1, typename _BidirectionalIterator2>
     inline _BidirectionalIterator2
-    __copy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, 
-		    _BidirectionalIterator2 __result, bidirectional_iterator_tag)
+    __copy_backward(_BidirectionalIterator1 __first,
+		    _BidirectionalIterator1 __last, 
+		    _BidirectionalIterator2 __result,
+		    bidirectional_iterator_tag)
     {
       while (__first != __last)
         *--__result = *--__last;
@@ -373,10 +393,8 @@ namespace std
       static _BidirectionalIterator2
       copy(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, 
 	   _BidirectionalIterator2 __result)
-      {
-        return std::__copy_backward(__first, __last, __result, 
-				    std::__iterator_category(__first));
-      }
+      { return std::__copy_backward(__first, __last, __result, 
+				    std::__iterator_category(__first)); }
     };
 
   template<typename _Tp>
@@ -408,7 +426,8 @@ namespace std
     {
       typedef typename __type_traits<typename iterator_traits<_BI2>::value_type>
 			    ::has_trivial_assignment_operator _Trivial;
-      return std::__copy_backward_dispatch<_BI1, _BI2, _Trivial>::copy(__first, 
+      return
+	std::__copy_backward_dispatch<_BI1, _BI2, _Trivial>::copy(__first, 
 								  __last, 
 								  __result);
     }
@@ -432,8 +451,8 @@ namespace std
     {
       typedef typename _Is_normal_iterator<_BI2>::_Normal __Normal;
       return std::__copy_backward_output_normal_iterator(__first.base(),
-							 __last.base(), __result, 
-							 __Normal());
+							 __last.base(),
+							 __result, __Normal());
     }
 
   template <typename _BI1, typename _BI2>
@@ -442,8 +461,8 @@ namespace std
 					  _BI2 __result, __false_type)
     {
       typedef typename _Is_normal_iterator<_BI2>::_Normal __Normal;
-      return std::__copy_backward_output_normal_iterator(__first, __last, __result,
-							 __Normal());
+      return std::__copy_backward_output_normal_iterator(__first, __last,
+							 __result, __Normal());
     }
 
   /**
@@ -476,8 +495,8 @@ namespace std
       __glibcxx_requires_valid_range(__first, __last);
 
       typedef typename _Is_normal_iterator<_BI1>::_Normal __Normal;
-      return std::__copy_backward_input_normal_iterator(__first, __last, __result,
-							__Normal());
+      return std::__copy_backward_input_normal_iterator(__first, __last,
+							__result, __Normal());
     }
 
 
@@ -497,7 +516,8 @@ namespace std
     fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
     {
       // concept requirements
-      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIterator>)
+      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
+				  _ForwardIterator>)
       __glibcxx_requires_valid_range(__first, __last);
 
       for ( ; __first != __last; ++__first)
@@ -532,7 +552,7 @@ namespace std
   fill(unsigned char* __first, unsigned char* __last, const unsigned char& __c)
   {
     __glibcxx_requires_valid_range(__first, __last);
-    unsigned char __tmp = __c;
+    const unsigned char __tmp = __c;
     std::memset(__first, __tmp, __last - __first);
   }
 
@@ -540,7 +560,7 @@ namespace std
   fill(signed char* __first, signed char* __last, const signed char& __c)
   {
     __glibcxx_requires_valid_range(__first, __last);
-    signed char __tmp = __c;
+    const signed char __tmp = __c;
     std::memset(__first, static_cast<unsigned char>(__tmp), __last - __first);
   }
 
@@ -548,7 +568,7 @@ namespace std
   fill(char* __first, char* __last, const char& __c)
   {
     __glibcxx_requires_valid_range(__first, __last);
-    char __tmp = __c;
+    const char __tmp = __c;
     std::memset(__first, static_cast<unsigned char>(__tmp), __last - __first);
   }
 
@@ -625,7 +645,8 @@ namespace std
    *  second iterator points into the second range, and the elements pointed
    *  to by the iterators are not equal.
   */
-  template<typename _InputIterator1, typename _InputIterator2, typename _BinaryPredicate>
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _BinaryPredicate>
     pair<_InputIterator1, _InputIterator2>
     mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
 	     _InputIterator2 __first2, _BinaryPredicate __binary_pred)
@@ -656,7 +677,8 @@ namespace std
   */
   template<typename _InputIterator1, typename _InputIterator2>
     inline bool
-    equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2)
+    equal(_InputIterator1 __first1, _InputIterator1 __last1,
+	  _InputIterator2 __first2)
     {
       // concept requirements
       __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
@@ -685,7 +707,8 @@ namespace std
    *  false depending on whether all of the corresponding elements of the
    *  ranges are equal.
   */
-  template<typename _InputIterator1, typename _InputIterator2, typename _BinaryPredicate>
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _BinaryPredicate>
     inline bool
     equal(_InputIterator1 __first1, _InputIterator1 __last1,
 	  _InputIterator2 __first2,
@@ -753,7 +776,8 @@ namespace std
    *  The same as the four-parameter @c lexigraphical_compare, but uses the
    *  comp parameter instead of @c <.
   */
-  template<typename _InputIterator1, typename _InputIterator2, typename _Compare>
+  template<typename _InputIterator1, typename _InputIterator2,
+	   typename _Compare>
     bool
     lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
 			    _InputIterator2 __first2, _InputIterator2 __last2,
@@ -787,7 +811,8 @@ namespace std
 
     const size_t __len1 = __last1 - __first1;
     const size_t __len2 = __last2 - __first2;
-    const int __result = std::memcmp(__first1, __first2, std::min(__len1, __len2));
+    const int __result = std::memcmp(__first1, __first2,
+				     std::min(__len1, __len2));
     return __result != 0 ? __result < 0 : __len1 < __len2;
   }
 

libstdc++-v3/include/bits/stl_heap.h

 // Heap implementation -*- C++ -*-
 
-// Copyright (C) 2001 Free Software Foundation, Inc.
+// Copyright (C) 2001, 2004 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -72,7 +72,8 @@ namespace std
     __is_heap(_RandomAccessIterator __first, _Distance __n)
     {
       _Distance __parent = 0;
-      for (_Distance __child = 1; __child < __n; ++__child) {
+      for (_Distance __child = 1; __child < __n; ++__child)
+	{
 	  if (__first[__parent] < __first[__child]) 
 	    return false;
 	  if ((__child & 1) == 0)
@@ -88,7 +89,8 @@ namespace std
 	      _Distance __n)
     {
       _Distance __parent = 0;
-      for (_Distance __child = 1; __child < __n; ++__child) {
+      for (_Distance __child = 1; __child < __n; ++__child)
+	{
 	  if (__comp(__first[__parent], __first[__child]))
 	    return false;
 	  if ((__child & 1) == 0)
@@ -116,7 +118,8 @@ namespace std
 		_Distance __holeIndex, _Distance __topIndex, _Tp __value)
     {
       _Distance __parent = (__holeIndex - 1) / 2;
-      while (__holeIndex > __topIndex && *(__first + __parent) < __value) {
+      while (__holeIndex > __topIndex && *(__first + __parent) < __value)
+	{
 	  *(__first + __holeIndex) = *(__first + __parent);
 	  __holeIndex = __parent;
 	  __parent = (__holeIndex - 1) / 2;
@@ -149,8 +152,8 @@ namespace std
       __glibcxx_requires_valid_range(__first, __last);
       //      __glibcxx_requires_heap(__first, __last - 1);
 
-      std::__push_heap(__first, _DistanceType((__last - __first) - 1), _DistanceType(0), 
-		       _ValueType(*(__last - 1)));
+      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
+		       _DistanceType(0), _ValueType(*(__last - 1)));
     }
 
   template<typename _RandomAccessIterator, typename _Distance, typename _Tp, 
@@ -160,7 +163,9 @@ namespace std
 		_Distance __topIndex, _Tp __value, _Compare __comp)
     {
       _Distance __parent = (__holeIndex - 1) / 2;
-      while (__holeIndex > __topIndex && __comp(*(__first + __parent), __value)) {
+      while (__holeIndex > __topIndex
+	     && __comp(*(__first + __parent), __value))
+	{
 	  *(__first + __holeIndex) = *(__first + __parent);
 	  __holeIndex = __parent;
 	  __parent = (__holeIndex - 1) / 2;
@@ -195,8 +200,8 @@ namespace std
       __glibcxx_requires_valid_range(__first, __last);
       __glibcxx_requires_heap_pred(__first, __last - 1, __comp);
 
-      std::__push_heap(__first, _DistanceType((__last - __first) - 1), _DistanceType(0), 
-		       _ValueType(*(__last - 1)), __comp);
+      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
+		       _DistanceType(0), _ValueType(*(__last - 1)), __comp);
     }
 
   template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
@@ -204,16 +209,18 @@ namespace std
     __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
 		  _Distance __len, _Tp __value)
     {
-      _Distance __topIndex = __holeIndex;
+      const _Distance __topIndex = __holeIndex;
       _Distance __secondChild = 2 * __holeIndex + 2;
-      while (__secondChild < __len) {
+      while (__secondChild < __len)
+	{
 	  if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
 	    __secondChild--;
 	  *(__first + __holeIndex) = *(__first + __secondChild);
 	  __holeIndex = __secondChild;
 	  __secondChild = 2 * (__secondChild + 1);
 	}
-      if (__secondChild == __len) {
+      if (__secondChild == __len)
+	{
 	  *(__first + __holeIndex) = *(__first + (__secondChild - 1));
 	  __holeIndex = __secondChild - 1;
 	}
@@ -225,9 +232,11 @@ namespace std
     __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
 	       _RandomAccessIterator __result, _Tp __value)
     {
-      typedef typename iterator_traits<_RandomAccessIterator>::difference_type _Distance;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+	_Distance;
       *__result = *__first;
-      std::__adjust_heap(__first, _Distance(0), _Distance(__last - __first), __value);
+      std::__adjust_heap(__first, _Distance(0), _Distance(__last - __first),
+			 __value);
     }
 
   /**
@@ -243,7 +252,8 @@ namespace std
     inline void
     pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
     {
-      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	_ValueType;
 
       // concept requirements
       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
@@ -252,7 +262,8 @@ namespace std
       __glibcxx_requires_valid_range(__first, __last);
       __glibcxx_requires_heap(__first, __last);
 
-      std::__pop_heap(__first, __last - 1, __last - 1, _ValueType(*(__last - 1)));
+      std::__pop_heap(__first, __last - 1, __last - 1,
+		      _ValueType(*(__last - 1)));
     }
 
   template<typename _RandomAccessIterator, typename _Distance,
@@ -261,16 +272,19 @@ namespace std
     __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
 		  _Distance __len, _Tp __value, _Compare __comp)
     {
-      _Distance __topIndex = __holeIndex;
+      const _Distance __topIndex = __holeIndex;
       _Distance __secondChild = 2 * __holeIndex + 2;
-      while (__secondChild < __len) {
-	if (__comp(*(__first + __secondChild), *(__first + (__secondChild - 1))))
+      while (__secondChild < __len)
+	{
+	  if (__comp(*(__first + __secondChild),
+		     *(__first + (__secondChild - 1))))
 	    __secondChild--;
 	  *(__first + __holeIndex) = *(__first + __secondChild);
 	  __holeIndex = __secondChild;
 	  __secondChild = 2 * (__secondChild + 1);
 	}
-      if (__secondChild == __len) {
+      if (__secondChild == __len)
+	{
 	  *(__first + __holeIndex) = *(__first + (__secondChild - 1));
 	  __holeIndex = __secondChild - 1;
 	}
@@ -282,7 +296,8 @@ namespace std
     __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
 	       _RandomAccessIterator __result, _Tp __value, _Compare __comp)
     {
-      typedef typename iterator_traits<_RandomAccessIterator>::difference_type _Distance;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+	_Distance;
       *__result = *__first;
       std::__adjust_heap(__first, _Distance(0), _Distance(__last - __first),
 			 __value, __comp);
@@ -310,8 +325,10 @@ namespace std
       __glibcxx_requires_valid_range(__first, __last);
       __glibcxx_requires_heap_pred(__first, __last, __comp);
 
-      typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
-      std::__pop_heap(__first, __last - 1, __last - 1, _ValueType(*(__last - 1)), __comp);
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+	_ValueType;
+      std::__pop_heap(__first, __last - 1, __last - 1,
+		      _ValueType(*(__last - 1)), __comp);
     }
 
   /**
@@ -337,13 +354,17 @@ namespace std
       __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
       __glibcxx_requires_valid_range(__first, __last);
 
-      if (__last - __first < 2) return;
-      _DistanceType __len = __last - __first;
-      _DistanceType __parent = (__len - 2)/2;
+      if (__last - __first < 2)
+	return;
 
-      while (true) {
-	std::__adjust_heap(__first, __parent, __len, _ValueType(*(__first + __parent)));
-	if (__parent == 0) return;
+      const _DistanceType __len = __last - __first;    
+      _DistanceType __parent = (__len - 2) / 2;
+      while (true)
+	{
+	  std::__adjust_heap(__first, __parent, __len,
+			     _ValueType(*(__first + __parent)));
+	  if (__parent == 0)
+	    return;
 	  __parent--;
 	}
     }
@@ -373,14 +394,17 @@ namespace std
 	    _RandomAccessIterator>)
       __glibcxx_requires_valid_range(__first, __last);
       
-      if (__last - __first < 2) return;
-      _DistanceType __len = __last - __first;
-      _DistanceType __parent = (__len - 2)/2;
+      if (__last - __first < 2)
+	return;
 
-      while (true) {
+      const _DistanceType __len = __last - __first;
+      _DistanceType __parent = (__len - 2) / 2;
+      while (true)
+	{
 	  std::__adjust_heap(__first, __parent, __len,
 			     _ValueType(*(__first + __parent)), __comp);
-	if (__parent == 0) return;
+	  if (__parent == 0)
+	    return;
 	  __parent--;
 	}
     }