iterator.h: Reformat to 80 columns; adjust some inline specifiers.

2008-01-09  Paolo Carlini  <pcarlini@suse.de>

	* include/parallel/iterator.h: Reformat to 80 columns; adjust some
	inline specifiers.
	* include/parallel/find_selectors.h: Likewise.
	* include/parallel/losertree.h: Likewise.
	* include/parallel/list_partition.h: Likewise.
	* include/parallel/for_each.h: Likewise.
	* include/parallel/multiseq_selection.h: Likewise.
	* include/parallel/algorithmfwd.h: Likewise.
	* include/parallel/for_each_selectors.h: Likewise.
	* include/parallel/balanced_quicksort.h: Likewise.
	* include/parallel/merge.h: Likewise.
	* include/parallel/algobase.h: Likewise.
	* include/parallel/find.h: Likewise.
	* include/parallel/algo.h: Likewise.
	* include/parallel/checkers.h: Likewise.

From-SVN: r131431

libstdc++-v3/ChangeLog

+2008-01-09  Paolo Carlini  <pcarlini@suse.de>
+
+	* include/parallel/iterator.h: Reformat to 80 columns; adjust some
+	inline specifiers.
+	* include/parallel/find_selectors.h: Likewise.
+	* include/parallel/losertree.h: Likewise.
+	* include/parallel/list_partition.h: Likewise.
+	* include/parallel/for_each.h: Likewise.
+	* include/parallel/multiseq_selection.h: Likewise.
+	* include/parallel/algorithmfwd.h: Likewise.
+	* include/parallel/for_each_selectors.h: Likewise.
+	* include/parallel/balanced_quicksort.h: Likewise.
+	* include/parallel/merge.h: Likewise.
+	* include/parallel/algobase.h: Likewise.
+	* include/parallel/find.h: Likewise.
+	* include/parallel/algo.h: Likewise.
+	* include/parallel/checkers.h: Likewise.	
+
 2008-01-09  Francesco Biscani  <bluescarni@gmail.com>
 
 	* include/tr1_impl/hashtable (_Hashtable): Fix friend declaration

libstdc++-v3/include/parallel/algo.h

 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 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 terms
@@ -77,7 +77,7 @@ namespace __parallel
 
   // Sequential fallback for input iterator case
   template<typename InputIterator, typename Function, typename IteratorTag>
-  Function
+    inline Function
     for_each_switch(InputIterator begin, InputIterator end, Function f, 
 		    IteratorTag)
     { return for_each(begin, end, f, __gnu_parallel::sequential_tag()); }
@@ -90,11 +90,21 @@ namespace __parallel
 		    __gnu_parallel::parallelism parallelism_tag
 		    = __gnu_parallel::parallel_balanced)
     {
-    if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::for_each_minimal_n && __gnu_parallel::is_parallel(parallelism_tag)))
+      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
+				      sequence_index_t>(end - begin)
+				      >= __gnu_parallel::Settings::
+				      for_each_minimal_n
+				      && __gnu_parallel::
+				      is_parallel(parallelism_tag)))
 	{
 	  bool dummy;
-	__gnu_parallel::for_each_selector<RandomAccessIterator> functionality;
-	return __gnu_parallel::for_each_template_random_access(begin, end, f, functionality, __gnu_parallel::dummy_reduct(), true, dummy, -1, parallelism_tag);
+	  __gnu_parallel::for_each_selector<RandomAccessIterator>
+	    functionality;
+
+	  return __gnu_parallel::
+	    for_each_template_random_access(begin, end, f, functionality,
+					    __gnu_parallel::dummy_reduct(),
+					    true, dummy, -1, parallelism_tag);
 	}
       else
 	return for_each(begin, end, f, __gnu_parallel::sequential_tag());
@@ -132,21 +142,26 @@ namespace __parallel
   // Sequential fallback for input iterator case
   template<typename InputIterator, typename T, typename IteratorTag>
     inline InputIterator
-  find_switch(InputIterator begin, InputIterator end, const T& val, IteratorTag)
+    find_switch(InputIterator begin, InputIterator end, const T& val,
+		IteratorTag)
     { return _GLIBCXX_STD_P::find(begin, end, val); }
 
   // Parallel find for random access iterators
   template<typename RandomAccessIterator, typename T>
     RandomAccessIterator
-  find_switch(RandomAccessIterator begin, RandomAccessIterator end, const T& val, random_access_iterator_tag)
+    find_switch(RandomAccessIterator begin, RandomAccessIterator end,
+		const T& val, random_access_iterator_tag)
     {
       typedef iterator_traits<RandomAccessIterator> traits_type;
       typedef typename traits_type::value_type value_type;
 
       if (_GLIBCXX_PARALLEL_CONDITION(true))
 	{
-	binder2nd<__gnu_parallel::equal_to<value_type, T> > comp(__gnu_parallel::equal_to<value_type, T>(), val);
-	return __gnu_parallel::find_template(begin, end, begin, comp, __gnu_parallel::find_if_selector()).first;
+	  binder2nd<__gnu_parallel::equal_to<value_type, T> >
+	    comp(__gnu_parallel::equal_to<value_type, T>(), val);
+	  return __gnu_parallel::find_template(begin, end, begin, comp,
+					       __gnu_parallel::
+					       find_if_selector()).first;
 	}
       else
 	return _GLIBCXX_STD_P::find(begin, end, val);
@@ -184,7 +199,8 @@ namespace __parallel
     {
       if (_GLIBCXX_PARALLEL_CONDITION(true))
 	return __gnu_parallel::find_template(begin, end, begin, pred, 
-				   __gnu_parallel::find_if_selector()).first;
+					     __gnu_parallel::
+					     find_if_selector()).first;
       else
 	return _GLIBCXX_STD_P::find_if(begin, end, pred);
     }
@@ -192,7 +208,7 @@ namespace __parallel
   // Public interface
   template<typename InputIterator, typename Predicate>
     inline InputIterator
-  find_if (InputIterator begin, InputIterator end, Predicate pred)
+    find_if(InputIterator begin, InputIterator end, Predicate pred)
     {
       typedef std::iterator_traits<InputIterator> iterator_traits;
       typedef typename iterator_traits::iterator_category iterator_category;
@@ -217,41 +233,45 @@ namespace __parallel
   { return _GLIBCXX_STD_P::find_first_of(begin1, end1, begin2, end2, comp); }
 
   // Sequential fallback for input iterator type
-  template<typename InputIterator, typename ForwardIterator, typename IteratorTag1, typename IteratorTag2>
+  template<typename InputIterator, typename ForwardIterator,
+	   typename IteratorTag1, typename IteratorTag2>
     inline InputIterator
     find_first_of_switch(InputIterator begin1, InputIterator end1,
 			 ForwardIterator begin2, ForwardIterator end2, 
 			 IteratorTag1, IteratorTag2)
-  {
-    return find_first_of(begin1, end1, begin2, end2, 
-			 __gnu_parallel::sequential_tag());
-  }
+    { return find_first_of(begin1, end1, begin2, end2, 
+			   __gnu_parallel::sequential_tag()); }
 
   // Parallel algorithm for random access iterators
-  template<typename RandomAccessIterator, typename ForwardIterator, typename BinaryPredicate, typename IteratorTag>
+  template<typename RandomAccessIterator, typename ForwardIterator,
+	   typename BinaryPredicate, typename IteratorTag>
     inline RandomAccessIterator
-  find_first_of_switch(RandomAccessIterator begin1, RandomAccessIterator end1,
+    find_first_of_switch(RandomAccessIterator begin1,
+			 RandomAccessIterator end1,
 			 ForwardIterator begin2, ForwardIterator end2, 
 			 BinaryPredicate comp, random_access_iterator_tag, 
 			 IteratorTag)
     {
-    return __gnu_parallel::find_template(begin1, end1, begin1, comp, __gnu_parallel::find_first_of_selector<ForwardIterator>(begin2, end2)).first;
+      return __gnu_parallel::
+	find_template(begin1, end1, begin1, comp,
+		      __gnu_parallel::find_first_of_selector
+		      <ForwardIterator>(begin2, end2)).first;
     }
 
   // Sequential fallback for input iterator type
-  template<typename InputIterator, typename ForwardIterator, typename BinaryPredicate, typename IteratorTag1, typename IteratorTag2>
-  inline
-  InputIterator
+  template<typename InputIterator, typename ForwardIterator,
+	   typename BinaryPredicate, typename IteratorTag1,
+	   typename IteratorTag2>
+    inline InputIterator
     find_first_of_switch(InputIterator begin1, InputIterator end1,
 			 ForwardIterator begin2, ForwardIterator end2, 
 			 BinaryPredicate comp, IteratorTag1, IteratorTag2)
-  {
-    return find_first_of(begin1, end1, begin2, end2, comp, 
-			 __gnu_parallel::sequential_tag());
-  }
+    { return find_first_of(begin1, end1, begin2, end2, comp, 
+			   __gnu_parallel::sequential_tag()); }
 
   // Public interface
-  template<typename InputIterator, typename ForwardIterator, typename BinaryPredicate>
+  template<typename InputIterator, typename ForwardIterator,
+	   typename BinaryPredicate>
     inline InputIterator
     find_first_of(InputIterator begin1, InputIterator end1,
 		  ForwardIterator begin2, ForwardIterator end2, 
@@ -268,7 +288,7 @@ namespace __parallel
 
   // Public interface, insert default comparator
   template<typename InputIterator, typename ForwardIterator>
-  InputIterator
+    inline InputIterator
     find_first_of(InputIterator begin1, InputIterator end1, 
 		  ForwardIterator begin2, ForwardIterator end2)
     {
@@ -277,8 +297,8 @@ namespace __parallel
       typedef typename iteratori_traits::value_type valuei_type;
       typedef typename iteratorf_traits::value_type valuef_type;
 
-    return find_first_of(begin1, end1, begin2, end2, 
-			 __gnu_parallel::equal_to<valuei_type, valuef_type>());
+      return find_first_of(begin1, end1, begin2, end2, __gnu_parallel::
+			   equal_to<valuei_type, valuef_type>());
     }
 
   // Sequential fallback
@@ -289,14 +309,16 @@ namespace __parallel
     { return _GLIBCXX_STD_P::unique_copy(begin1, end1, out); }
 
   // Sequential fallback
-  template<typename InputIterator, typename OutputIterator, typename Predicate>
+  template<typename InputIterator, typename OutputIterator,
+	   typename Predicate>
     inline OutputIterator
     unique_copy(InputIterator begin1, InputIterator end1, OutputIterator out,
 		Predicate pred, __gnu_parallel::sequential_tag)
     { return _GLIBCXX_STD_P::unique_copy(begin1, end1, out, pred); }
 
   // Sequential fallback for input iterator case
-  template<typename InputIterator, typename OutputIterator, typename Predicate, typename IteratorTag1, typename IteratorTag2>
+  template<typename InputIterator, typename OutputIterator,
+	   typename Predicate, typename IteratorTag1, typename IteratorTag2>
     inline OutputIterator
     unique_copy_switch(InputIterator begin, InputIterator last, 
 		       OutputIterator out, Predicate pred, 
@@ -304,13 +326,17 @@ namespace __parallel
     { return _GLIBCXX_STD_P::unique_copy(begin, last, out, pred); }
 
   // Parallel unique_copy for random access iterators
-  template<typename RandomAccessIterator, typename RandomAccessOutputIterator, typename Predicate>
+  template<typename RandomAccessIterator, typename RandomAccessOutputIterator,
+	   typename Predicate>
     RandomAccessOutputIterator
     unique_copy_switch(RandomAccessIterator begin, RandomAccessIterator last, 
 		       RandomAccessOutputIterator out, Predicate pred, 
 		       random_access_iterator_tag, random_access_iterator_tag)
     {
-    if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(last - begin) > __gnu_parallel::Settings::unique_copy_minimal_n))
+      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
+				      sequence_index_t>(last - begin)
+				      > __gnu_parallel::Settings::
+				      unique_copy_minimal_n))
 	return __gnu_parallel::parallel_unique_copy(begin, last, out, pred);
       else
 	return _GLIBCXX_STD_P::unique_copy(begin, last, out, pred);
@@ -347,7 +373,8 @@ namespace __parallel
     }
 
   // Sequential fallback
-  template<typename InputIterator1, typename InputIterator2, typename OutputIterator>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename OutputIterator>
     inline OutputIterator
     set_union(InputIterator1 begin1, InputIterator1 end1,
 	      InputIterator2 begin2, InputIterator2 end2,
@@ -355,24 +382,27 @@ namespace __parallel
     { return _GLIBCXX_STD_P::set_union(begin1, end1, begin2, end2, out); }
 
   // Sequential fallback
-  template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename OutputIterator, typename Predicate>
     inline OutputIterator
     set_union(InputIterator1 begin1, InputIterator1 end1,
 	      InputIterator2 begin2, InputIterator2 end2,
-	    OutputIterator out, Predicate pred, __gnu_parallel::sequential_tag)
-  { return _GLIBCXX_STD_P::set_union(begin1, end1, begin2, end2, out, pred); }
+	      OutputIterator out, Predicate pred,
+	      __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::set_union(begin1, end1,
+				       begin2, end2, out, pred); }
 
   // Sequential fallback for input iterator case
-  template<typename InputIterator1, typename InputIterator2, typename Predicate,
-	   typename OutputIterator, typename IteratorTag1, typename IteratorTag2, typename IteratorTag3>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename Predicate, typename OutputIterator,
+	   typename IteratorTag1, typename IteratorTag2, typename IteratorTag3>
     inline OutputIterator
     set_union_switch(InputIterator1 begin1, InputIterator1 end1, 
 		     InputIterator2 begin2, InputIterator2 end2, 
 		     OutputIterator result, Predicate pred, IteratorTag1,
 		     IteratorTag2, IteratorTag3)
-  {
-    return _GLIBCXX_STD_P::set_union(begin1, end1, begin2, end2, result, pred);
-  }
+    { return _GLIBCXX_STD_P::set_union(begin1, end1,
+				       begin2, end2, result, pred); }
 
   // Parallel set_union for random access iterators
   template<typename RandomAccessIterator1, typename RandomAccessIterator2,
@@ -384,23 +414,35 @@ namespace __parallel
 		     random_access_iterator_tag, random_access_iterator_tag, 
 		     random_access_iterator_tag)
     {
-    if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end1 - begin1) >= __gnu_parallel::Settings::set_union_minimal_n || static_cast<__gnu_parallel::sequence_index_t>(end2 - begin2) >= __gnu_parallel::Settings::set_union_minimal_n))
-      return __gnu_parallel::parallel_set_union(begin1, end1, begin2, end2, result, pred);
+      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
+				      sequence_index_t>(end1 - begin1)
+				      >= __gnu_parallel::Settings::
+				      set_union_minimal_n
+				      || static_cast<__gnu_parallel::
+				      sequence_index_t>(end2 - begin2)
+				      >= __gnu_parallel::Settings::
+				      set_union_minimal_n))
+	return __gnu_parallel::parallel_set_union(begin1, end1,
+						  begin2, end2, result, pred);
       else
-      return _GLIBCXX_STD_P::set_union(begin1, end1, begin2, end2, result, pred);
+	return _GLIBCXX_STD_P::set_union(begin1, end1,
+					 begin2, end2, result, pred);
     }
 
   // Public interface
-  template<typename InputIterator1, typename InputIterator2, typename OutputIterator>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename OutputIterator>
     inline OutputIterator 
-  set_union(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, 
-	    InputIterator2 end2, OutputIterator out)
+    set_union(InputIterator1 begin1, InputIterator1 end1,
+	      InputIterator2 begin2, InputIterator2 end2, OutputIterator out)
     {
       typedef std::iterator_traits<InputIterator1> iteratori1_traits;
       typedef std::iterator_traits<InputIterator2> iteratori2_traits;
       typedef std::iterator_traits<OutputIterator> iteratoro_traits;
-    typedef typename iteratori1_traits::iterator_category iteratori1_category;
-    typedef typename iteratori2_traits::iterator_category iteratori2_category;
+      typedef typename iteratori1_traits::iterator_category
+	iteratori1_category;
+      typedef typename iteratori2_traits::iterator_category
+	iteratori2_category;
       typedef typename iteratoro_traits::iterator_category iteratoro_category;
       typedef typename iteratori1_traits::value_type value1_type;
       typedef typename iteratori2_traits::value_type value2_type;
@@ -412,16 +454,20 @@ namespace __parallel
     }
 
   // Public interface
-  template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename OutputIterator, typename Predicate>
     inline OutputIterator 
-  set_union(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2,
-	    InputIterator2 end2, OutputIterator out, Predicate pred)
+    set_union(InputIterator1 begin1, InputIterator1 end1,
+	      InputIterator2 begin2, InputIterator2 end2,
+	      OutputIterator out, Predicate pred)
     {
       typedef std::iterator_traits<InputIterator1> iteratori1_traits;
       typedef std::iterator_traits<InputIterator2> iteratori2_traits;
       typedef std::iterator_traits<OutputIterator> iteratoro_traits;
-    typedef typename iteratori1_traits::iterator_category iteratori1_category;
-    typedef typename iteratori2_traits::iterator_category iteratori2_category;
+      typedef typename iteratori1_traits::iterator_category
+	iteratori1_category;
+      typedef typename iteratori2_traits::iterator_category
+	iteratori2_category;
       typedef typename iteratoro_traits::iterator_category iteratoro_category;
 
       return set_union_switch(begin1, end1, begin2, end2, out, pred,
@@ -430,47 +476,61 @@ namespace __parallel
     }
 
   // Sequential fallback.
-  template<typename InputIterator1, typename InputIterator2, typename OutputIterator>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename OutputIterator>
     inline OutputIterator
     set_intersection(InputIterator1 begin1, InputIterator1 end1,
 		     InputIterator2 begin2, InputIterator2 end2,
 		     OutputIterator out, __gnu_parallel::sequential_tag)
-  {
-    return _GLIBCXX_STD_P::set_intersection(begin1, end1, begin2, end2, out);
-  }
+    { return _GLIBCXX_STD_P::set_intersection(begin1, end1,
+					      begin2, end2, out); }
 
   // Sequential fallback.
-  template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename OutputIterator, typename Predicate>
     inline OutputIterator
     set_intersection(InputIterator1 begin1, InputIterator1 end1,
 		     InputIterator2 begin2, InputIterator2 end2,
 		     OutputIterator out, Predicate pred, 
 		     __gnu_parallel::sequential_tag)
-  {
-    return _GLIBCXX_STD_P::set_intersection(begin1, end1, begin2, end2, 
-					    out, pred);
-  }
+    { return _GLIBCXX_STD_P::set_intersection(begin1, end1, begin2, end2, 
+					      out, pred); }
 
   // Sequential fallback for input iterator case
-  template<typename InputIterator1, typename InputIterator2, typename Predicate,
-	   typename OutputIterator, typename IteratorTag1, typename IteratorTag2, typename IteratorTag3>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename Predicate, typename OutputIterator,
+	   typename IteratorTag1, typename IteratorTag2,
+	   typename IteratorTag3>
     inline OutputIterator 
     set_intersection_switch(InputIterator1 begin1, InputIterator1 end1, 
 			    InputIterator2 begin2, InputIterator2 end2, 
 			    OutputIterator result, Predicate pred, 
 			    IteratorTag1, IteratorTag2, IteratorTag3)
-  {
-    return _GLIBCXX_STD_P::set_intersection(begin1, end1, begin2, 
-					    end2, result, pred);
-  }
+    { return _GLIBCXX_STD_P::set_intersection(begin1, end1, begin2, 
+					      end2, result, pred); }
 
   // Parallel set_intersection for random access iterators
   template<typename RandomAccessIterator1, typename RandomAccessIterator2,
 	   typename OutputRandomAccessIterator, typename Predicate>
     OutputRandomAccessIterator
-  set_intersection_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, RandomAccessIterator2 begin2, RandomAccessIterator2 end2, OutputRandomAccessIterator result, Predicate pred, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag)
+    set_intersection_switch(RandomAccessIterator1 begin1,
+			    RandomAccessIterator1 end1,
+			    RandomAccessIterator2 begin2,
+			    RandomAccessIterator2 end2,
+			    OutputRandomAccessIterator result,
+			    Predicate pred,
+			    random_access_iterator_tag,
+			    random_access_iterator_tag,
+			    random_access_iterator_tag)
     {
-    if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end1 - begin1) >= __gnu_parallel::Settings::set_union_minimal_n || static_cast<__gnu_parallel::sequence_index_t>(end2 - begin2) >= __gnu_parallel::Settings::set_union_minimal_n))
+      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
+				      sequence_index_t>(end1 - begin1)
+				      >= __gnu_parallel::Settings::
+				      set_union_minimal_n
+				      || static_cast<__gnu_parallel::
+				      sequence_index_t>(end2 - begin2)
+				      >= __gnu_parallel::Settings::
+				      set_union_minimal_n))
 	return __gnu_parallel::parallel_set_intersection(begin1, end1, begin2, 
 							 end2, result, pred);
       else
@@ -479,7 +539,8 @@ namespace __parallel
     }
 
   // Public interface
-  template<typename InputIterator1, typename InputIterator2, typename OutputIterator>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename OutputIterator>
     inline OutputIterator 
     set_intersection(InputIterator1 begin1, InputIterator1 end1, 
 		     InputIterator2 begin2, InputIterator2 end2, 
@@ -488,32 +549,41 @@ namespace __parallel
       typedef std::iterator_traits<InputIterator1> iteratori1_traits;
       typedef std::iterator_traits<InputIterator2> iteratori2_traits;
       typedef std::iterator_traits<OutputIterator> iteratoro_traits;
-    typedef typename iteratori1_traits::iterator_category iteratori1_category;
-    typedef typename iteratori2_traits::iterator_category iteratori2_category;
+      typedef typename iteratori1_traits::iterator_category
+	iteratori1_category;
+      typedef typename iteratori2_traits::iterator_category
+	iteratori2_category;
       typedef typename iteratoro_traits::iterator_category iteratoro_category;
       typedef typename iteratori1_traits::value_type value1_type;
       typedef typename iteratori2_traits::value_type value2_type;
 
       return set_intersection_switch(begin1, end1, begin2, end2, out,
-			     __gnu_parallel::less<value1_type, value2_type>(),
-		       	   iteratori1_category(), iteratori2_category(), 
+				     __gnu_parallel::
+				     less<value1_type, value2_type>(),
+				     iteratori1_category(),
+				     iteratori2_category(), 
 				     iteratoro_category());
     }
 
-  template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename OutputIterator, typename Predicate>
     inline OutputIterator 
-  set_intersection(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2,
-		   InputIterator2 end2, OutputIterator out, Predicate pred)
+    set_intersection(InputIterator1 begin1, InputIterator1 end1,
+		     InputIterator2 begin2, InputIterator2 end2,
+		     OutputIterator out, Predicate pred)
     {
       typedef std::iterator_traits<InputIterator1> iteratori1_traits;
       typedef std::iterator_traits<InputIterator2> iteratori2_traits;
       typedef std::iterator_traits<OutputIterator> iteratoro_traits;
-    typedef typename iteratori1_traits::iterator_category iteratori1_category;
-    typedef typename iteratori2_traits::iterator_category iteratori2_category;
+      typedef typename iteratori1_traits::iterator_category
+	iteratori1_category;
+      typedef typename iteratori2_traits::iterator_category
+	iteratori2_category;
       typedef typename iteratoro_traits::iterator_category iteratoro_category;
 
       return set_intersection_switch(begin1, end1, begin2, end2, out, pred,
-			          iteratori1_category(), iteratori2_category(),
+				     iteratori1_category(),
+				     iteratori2_category(),
 				     iteratoro_category());
     }
 
@@ -523,11 +593,10 @@ namespace __parallel
     inline OutputIterator
     set_symmetric_difference(InputIterator1 begin1, InputIterator1 end1,
 			     InputIterator2 begin2, InputIterator2 end2,
-			   OutputIterator out, __gnu_parallel::sequential_tag)
-  {
-    return _GLIBCXX_STD_P::set_symmetric_difference(begin1,end1, begin2, 
-						    end2, out);
-  }
+			     OutputIterator out,
+			     __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::set_symmetric_difference(begin1,end1,
+						      begin2, end2, out); }
 
   // Sequential fallback
   template<typename InputIterator1, typename InputIterator2,
@@ -535,72 +604,111 @@ namespace __parallel
     inline OutputIterator
     set_symmetric_difference(InputIterator1 begin1, InputIterator1 end1,
 			     InputIterator2 begin2, InputIterator2 end2,
-			   OutputIterator out, Predicate pred, __gnu_parallel::sequential_tag)
-  {
-    return _GLIBCXX_STD_P::set_symmetric_difference(begin1, end1, begin2, 
-						    end2, out, pred);
-  }
+			     OutputIterator out, Predicate pred,
+			     __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::set_symmetric_difference(begin1, end1, begin2,
+						      end2, out, pred); }
 
   // Sequential fallback for input iterator case
-  template<typename InputIterator1, typename InputIterator2, typename Predicate, typename OutputIterator, typename IteratorTag1, typename IteratorTag2, typename IteratorTag3>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename Predicate, typename OutputIterator,
+	   typename IteratorTag1, typename IteratorTag2,
+	   typename IteratorTag3>
     inline OutputIterator 
-  set_symmetric_difference_switch(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, InputIterator2 end2, OutputIterator result, Predicate pred, IteratorTag1, IteratorTag2, IteratorTag3)
-  {
-    return _GLIBCXX_STD_P::set_symmetric_difference(begin1, end1, begin2, end2,
-						    result, pred);
-  }
+    set_symmetric_difference_switch(InputIterator1 begin1,
+				    InputIterator1 end1,
+				    InputIterator2 begin2,
+				    InputIterator2 end2,
+				    OutputIterator result, Predicate pred,
+				    IteratorTag1, IteratorTag2, IteratorTag3)
+    { return _GLIBCXX_STD_P::set_symmetric_difference(begin1, end1,
+						      begin2, end2,
+						      result, pred); }
 
   // Parallel set_symmetric_difference for random access iterators
   template<typename RandomAccessIterator1, typename RandomAccessIterator2,
 	   typename OutputRandomAccessIterator, typename Predicate>
     OutputRandomAccessIterator
-  set_symmetric_difference_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, RandomAccessIterator2 begin2, RandomAccessIterator2 end2, OutputRandomAccessIterator result, Predicate pred, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag)
+    set_symmetric_difference_switch(RandomAccessIterator1 begin1,
+				    RandomAccessIterator1 end1,
+				    RandomAccessIterator2 begin2,
+				    RandomAccessIterator2 end2,
+				    OutputRandomAccessIterator result,
+				    Predicate pred,
+				    random_access_iterator_tag,
+				    random_access_iterator_tag,
+				    random_access_iterator_tag)
     {
-    if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end1 - begin1) >= __gnu_parallel::Settings::set_symmetric_difference_minimal_n || static_cast<__gnu_parallel::sequence_index_t>(end2 - begin2) >= __gnu_parallel::Settings::set_symmetric_difference_minimal_n))
-      return __gnu_parallel::parallel_set_symmetric_difference(begin1, end1, begin2, end2, result, pred);
+      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
+				      sequence_index_t>(end1 - begin1)
+				      >= __gnu_parallel::Settings::
+				      set_symmetric_difference_minimal_n
+				      || static_cast<__gnu_parallel::
+				      sequence_index_t>(end2 - begin2)
+				      >= __gnu_parallel::Settings::
+				      set_symmetric_difference_minimal_n))
+	return __gnu_parallel::parallel_set_symmetric_difference(begin1, end1,
+								 begin2, end2,
+								 result, pred);
       else
-      return _GLIBCXX_STD_P::set_symmetric_difference(begin1, end1, begin2, end2, result, pred);
+	return _GLIBCXX_STD_P::set_symmetric_difference(begin1, end1,
+							begin2, end2,
+							result, pred);
     }
 
   // Public interface.
-  template<typename InputIterator1, typename InputIterator2, typename OutputIterator>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename OutputIterator>
     inline OutputIterator 
-  set_symmetric_difference(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, InputIterator2 end2, OutputIterator out)
+    set_symmetric_difference(InputIterator1 begin1, InputIterator1 end1,
+			     InputIterator2 begin2, InputIterator2 end2,
+			     OutputIterator out)
     {
       typedef std::iterator_traits<InputIterator1> iteratori1_traits;
       typedef std::iterator_traits<InputIterator2> iteratori2_traits;
       typedef std::iterator_traits<OutputIterator> iteratoro_traits;
-    typedef typename iteratori1_traits::iterator_category iteratori1_category;
-    typedef typename iteratori2_traits::iterator_category iteratori2_category;
+      typedef typename iteratori1_traits::iterator_category
+	iteratori1_category;
+      typedef typename iteratori2_traits::iterator_category
+	iteratori2_category;
       typedef typename iteratoro_traits::iterator_category iteratoro_category;
       typedef typename iteratori1_traits::value_type value1_type;
       typedef typename iteratori2_traits::value_type value2_type;
 
       return set_symmetric_difference_switch(begin1, end1, begin2, end2, out,
-			      __gnu_parallel::less<value1_type, value2_type>(),
-				  iteratori1_category(), iteratori2_category(),
+					     __gnu_parallel::
+					     less<value1_type, value2_type>(),
+					     iteratori1_category(),
+					     iteratori2_category(),
 					     iteratoro_category());
     }
 
   // Public interface.
-  template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename OutputIterator, typename Predicate>
     inline OutputIterator 
-  set_symmetric_difference(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, InputIterator2 end2, OutputIterator out, Predicate pred)
+    set_symmetric_difference(InputIterator1 begin1, InputIterator1 end1,
+			     InputIterator2 begin2, InputIterator2 end2,
+			     OutputIterator out, Predicate pred)
     {
       typedef std::iterator_traits<InputIterator1> iteratori1_traits;
       typedef std::iterator_traits<InputIterator2> iteratori2_traits;
       typedef std::iterator_traits<OutputIterator> iteratoro_traits;
-    typedef typename iteratori1_traits::iterator_category iteratori1_category;
-    typedef typename iteratori2_traits::iterator_category iteratori2_category;
+      typedef typename iteratori1_traits::iterator_category
+	iteratori1_category;
+      typedef typename iteratori2_traits::iterator_category
+	iteratori2_category;
       typedef typename iteratoro_traits::iterator_category iteratoro_category;
 
       return set_symmetric_difference_switch(begin1, end1, begin2, end2, out,
 					     pred, iteratori1_category(),
-				  iteratori2_category(), iteratoro_category());
+					     iteratori2_category(),
+					     iteratoro_category());
     }
 
   // Sequential fallback.
-  template<typename InputIterator1, typename InputIterator2, typename OutputIterator>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename OutputIterator>
     inline OutputIterator
     set_difference(InputIterator1 begin1, InputIterator1 end1, 
 		   InputIterator2 begin2, InputIterator2 end2, 
@@ -608,42 +716,60 @@ namespace __parallel
     { return _GLIBCXX_STD_P::set_difference(begin1,end1, begin2, end2, out); }
 
   // Sequential fallback.
-  template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename OutputIterator, typename Predicate>
     inline OutputIterator
     set_difference(InputIterator1 begin1, InputIterator1 end1, 
 		   InputIterator2 begin2, InputIterator2 end2, 
 		   OutputIterator out, Predicate pred, 
 		   __gnu_parallel::sequential_tag)
-  {
-    return _GLIBCXX_STD_P::set_difference(begin1, end1, begin2, end2, out, pred);
-  }
+    { return _GLIBCXX_STD_P::set_difference(begin1, end1,
+					    begin2, end2, out, pred); }
 
   // Sequential fallback for input iterator case.
-  template<typename InputIterator1, typename InputIterator2, typename Predicate,
-	   typename OutputIterator, typename IteratorTag1, typename IteratorTag2, typename IteratorTag3>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename Predicate, typename OutputIterator,
+	   typename IteratorTag1, typename IteratorTag2, typename IteratorTag3>
     inline OutputIterator
     set_difference_switch(InputIterator1 begin1, InputIterator1 end1, 
 			  InputIterator2 begin2, InputIterator2 end2, 
 			  OutputIterator result, Predicate pred, 
 			  IteratorTag1, IteratorTag2, IteratorTag3)
-  {
-    return _GLIBCXX_STD_P::set_difference(begin1, end1, begin2, end2, result, pred);
-  }
+    { return _GLIBCXX_STD_P::set_difference(begin1, end1,
+					    begin2, end2, result, pred); }
 
   // Parallel set_difference for random access iterators
   template<typename RandomAccessIterator1, typename RandomAccessIterator2,
 	   typename OutputRandomAccessIterator, typename Predicate>
     OutputRandomAccessIterator
-  set_difference_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, RandomAccessIterator2 begin2, RandomAccessIterator2 end2, OutputRandomAccessIterator result, Predicate pred, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag)
+    set_difference_switch(RandomAccessIterator1 begin1,
+			  RandomAccessIterator1 end1,
+			  RandomAccessIterator2 begin2,
+			  RandomAccessIterator2 end2,
+			  OutputRandomAccessIterator result, Predicate pred,
+			  random_access_iterator_tag,
+			  random_access_iterator_tag,
+			  random_access_iterator_tag)
     {
-    if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end1 - begin1) >= __gnu_parallel::Settings::set_difference_minimal_n || static_cast<__gnu_parallel::sequence_index_t>(end2 - begin2) >= __gnu_parallel::Settings::set_difference_minimal_n))
-      return __gnu_parallel::parallel_set_difference(begin1, end1, begin2, end2, result, pred);
+      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
+				      sequence_index_t>(end1 - begin1)
+				      >= __gnu_parallel::Settings::
+				      set_difference_minimal_n
+				      || static_cast<__gnu_parallel::
+				      sequence_index_t>(end2 - begin2)
+				      >= __gnu_parallel::Settings::
+				      set_difference_minimal_n))
+	return __gnu_parallel::parallel_set_difference(begin1, end1,
+						       begin2, end2,
+						       result, pred);
       else
-      return _GLIBCXX_STD_P::set_difference(begin1, end1, begin2, end2, result, pred);
+	return _GLIBCXX_STD_P::set_difference(begin1, end1,
+					      begin2, end2, result, pred);
     }
 
   // Public interface
-  template<typename InputIterator1, typename InputIterator2, typename OutputIterator>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename OutputIterator>
     inline OutputIterator
     set_difference(InputIterator1 begin1, InputIterator1 end1, 
 		   InputIterator2 begin2, InputIterator2 end2, 
@@ -652,20 +778,25 @@ namespace __parallel
       typedef std::iterator_traits<InputIterator1> iteratori1_traits;
       typedef std::iterator_traits<InputIterator2> iteratori2_traits;
       typedef std::iterator_traits<OutputIterator> iteratoro_traits;
-    typedef typename iteratori1_traits::iterator_category iteratori1_category;
-    typedef typename iteratori2_traits::iterator_category iteratori2_category;
+      typedef typename iteratori1_traits::iterator_category
+	iteratori1_category;
+      typedef typename iteratori2_traits::iterator_category
+	iteratori2_category;
       typedef typename iteratoro_traits::iterator_category iteratoro_category;
       typedef typename iteratori1_traits::value_type value1_type;
       typedef typename iteratori2_traits::value_type value2_type;
 
       return set_difference_switch(begin1, end1, begin2, end2, out,
-			    __gnu_parallel::less<value1_type, value2_type>(), 
-				 iteratori1_category(), iteratori2_category(), 
+				   __gnu_parallel::
+				   less<value1_type, value2_type>(), 
+				   iteratori1_category(),
+				   iteratori2_category(), 
 				   iteratoro_category());
     }
 
   // Public interface
-  template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename OutputIterator, typename Predicate>
     inline OutputIterator
     set_difference(InputIterator1 begin1, InputIterator1 end1, 
 		   InputIterator2 begin2, InputIterator2 end2, 
@@ -674,12 +805,15 @@ namespace __parallel
       typedef std::iterator_traits<InputIterator1> iteratori1_traits;
       typedef std::iterator_traits<InputIterator2> iteratori2_traits;
       typedef std::iterator_traits<OutputIterator> iteratoro_traits;
-    typedef typename iteratori1_traits::iterator_category iteratori1_category;
-    typedef typename iteratori2_traits::iterator_category iteratori2_category;
+      typedef typename iteratori1_traits::iterator_category
+	iteratori1_category;
+      typedef typename iteratori2_traits::iterator_category
+	iteratori2_category;
       typedef typename iteratoro_traits::iterator_category iteratoro_category;
 
       return set_difference_switch(begin1, end1, begin2, end2, out, pred,
-				 iteratori1_category(), iteratori2_category(), 
+				   iteratori1_category(),
+				   iteratori2_category(), 
 				   iteratoro_category());
     }
 
@@ -708,7 +842,9 @@ namespace __parallel
 
       if (_GLIBCXX_PARALLEL_CONDITION(true))
 	{
-	RandomAccessIterator spot = __gnu_parallel::find_template(begin, end - 1, begin, equal_to<value_type>(), __gnu_parallel::adjacent_find_selector()).first;
+	  RandomAccessIterator spot = __gnu_parallel::
+	    find_template(begin, end - 1, begin, equal_to<value_type>(),
+			  __gnu_parallel::adjacent_find_selector()).first;
 	  if (spot == (end - 1))
 	    return end;
 	  else
@@ -721,7 +857,8 @@ namespace __parallel
   // Sequential fallback for input iterator case
   template<typename ForwardIterator, typename IteratorTag>
     inline ForwardIterator
-  adjacent_find_switch(ForwardIterator begin, ForwardIterator end, IteratorTag)
+    adjacent_find_switch(ForwardIterator begin, ForwardIterator end,
+			 IteratorTag)
     { return adjacent_find(begin, end, __gnu_parallel::sequential_tag()); }
 
   // Public interface
@@ -735,11 +872,13 @@ namespace __parallel
     }
 
   // Sequential fallback for input iterator case
-  template<typename ForwardIterator, typename BinaryPredicate, typename IteratorTag>
+  template<typename ForwardIterator, typename BinaryPredicate,
+	   typename IteratorTag>
     inline ForwardIterator
     adjacent_find_switch(ForwardIterator begin, ForwardIterator end, 
 			 BinaryPredicate pred, IteratorTag)
-  { return adjacent_find(begin, end, pred, __gnu_parallel::sequential_tag()); }
+    { return adjacent_find(begin, end, pred,
+			   __gnu_parallel::sequential_tag()); }
 
   // Parallel algorithm for random access iterators
   template<typename RandomAccessIterator, typename BinaryPredicate>
@@ -749,9 +888,11 @@ namespace __parallel
     {
       if (_GLIBCXX_PARALLEL_CONDITION(true))
 	return __gnu_parallel::find_template(begin, end, begin, pred, 
-			      __gnu_parallel::adjacent_find_selector()).first;
+					     __gnu_parallel::
+					     adjacent_find_selector()).first;
       else
-      return adjacent_find(begin, end, pred, __gnu_parallel::sequential_tag());
+	return adjacent_find(begin, end, pred,
+			     __gnu_parallel::sequential_tag());
     }
 
   // Public interface
@@ -785,11 +926,21 @@ namespace __parallel
       typedef typename traits_type::difference_type difference_type;
       typedef __gnu_parallel::sequence_index_t sequence_index_t;
 
-    if (_GLIBCXX_PARALLEL_CONDITION(static_cast<sequence_index_t>(end - begin) >= __gnu_parallel::Settings::count_minimal_n && __gnu_parallel::is_parallel(parallelism_tag)))
+      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<sequence_index_t>
+				      (end - begin)
+				      >= __gnu_parallel::Settings::
+				      count_minimal_n
+				      && __gnu_parallel::
+				      is_parallel(parallelism_tag)))
 	{
-	__gnu_parallel::count_selector<RandomAccessIterator, difference_type> functionality;
+	  __gnu_parallel::count_selector<RandomAccessIterator, difference_type>
+	    functionality;
 	  difference_type res = 0;
-	__gnu_parallel::for_each_template_random_access(begin, end, value, functionality, std::plus<sequence_index_t>(), res, res, -1, parallelism_tag);
+	  __gnu_parallel::
+	    for_each_template_random_access(begin, end, value,
+					    functionality,
+					    std::plus<sequence_index_t>(),
+					    res, res, -1, parallelism_tag);
 	  return res;
 	}
       else
@@ -798,7 +949,7 @@ namespace __parallel
 
   // Sequential fallback for input iterator case.
   template<typename InputIterator, typename T, typename IteratorTag>
-  typename iterator_traits<InputIterator>::difference_type
+    inline typename iterator_traits<InputIterator>::difference_type
     count_switch(InputIterator begin, InputIterator end, const T& value, 
 		 IteratorTag)
     { return count(begin, end, value, __gnu_parallel::sequential_tag()); }
@@ -845,11 +996,22 @@ namespace __parallel
       typedef typename traits_type::difference_type difference_type;
       typedef __gnu_parallel::sequence_index_t sequence_index_t;
 
-    if (_GLIBCXX_PARALLEL_CONDITION(static_cast<sequence_index_t>(end - begin) >= __gnu_parallel::Settings::count_minimal_n && __gnu_parallel::is_parallel(parallelism_tag)))
+      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<sequence_index_t>
+				      (end - begin)
+				      >= __gnu_parallel::Settings::
+				      count_minimal_n
+				      && __gnu_parallel::
+				      is_parallel(parallelism_tag)))
 	{
 	  difference_type res = 0;
-	__gnu_parallel::count_if_selector<RandomAccessIterator, difference_type> functionality;
-	__gnu_parallel::for_each_template_random_access(begin, end, pred, functionality, std::plus<sequence_index_t>(), res, res, -1, parallelism_tag);
+	  __gnu_parallel::
+	    count_if_selector<RandomAccessIterator, difference_type>
+	    functionality;
+	  __gnu_parallel::
+	    for_each_template_random_access(begin, end, pred,
+					    functionality,
+					    std::plus<sequence_index_t>(),
+					    res, res, -1, parallelism_tag);
 	  return res;
 	}
       else
@@ -858,7 +1020,7 @@ namespace __parallel
 
   // Sequential fallback for input iterator case.
   template<typename InputIterator, typename Predicate, typename IteratorTag>
-  typename iterator_traits<InputIterator>::difference_type
+    inline typename iterator_traits<InputIterator>::difference_type
     count_if_switch(InputIterator begin, InputIterator end, Predicate pred, 
 		    IteratorTag)
     { return count_if(begin, end, pred, __gnu_parallel::sequential_tag()); }
@@ -888,15 +1050,17 @@ namespace __parallel
   // Sequential fallback.
   template<typename ForwardIterator1, typename ForwardIterator2>
     inline ForwardIterator1
-  search(ForwardIterator1 begin1, ForwardIterator1 end1, ForwardIterator2 begin2, ForwardIterator2 end2, __gnu_parallel::sequential_tag)
-  {
-    return _GLIBCXX_STD_P::search(begin1, end1, begin2, end2);
-  }
+    search(ForwardIterator1 begin1, ForwardIterator1 end1,
+	   ForwardIterator2 begin2, ForwardIterator2 end2,
+	   __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::search(begin1, end1, begin2, end2); }
 
   // Parallel algorithm for random access iterator
   template<typename RandomAccessIterator1, typename RandomAccessIterator2>
     RandomAccessIterator1
-  search_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, RandomAccessIterator2 begin2, RandomAccessIterator2 end2, random_access_iterator_tag, random_access_iterator_tag)
+    search_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1,
+		  RandomAccessIterator2 begin2, RandomAccessIterator2 end2,
+		  random_access_iterator_tag, random_access_iterator_tag)
     {
       typedef std::iterator_traits<RandomAccessIterator1> iterator1_traits;
       typedef typename iterator1_traits::value_type value1_type;
@@ -904,148 +1068,194 @@ namespace __parallel
       typedef typename iterator2_traits::value_type value2_type;
 
       if (_GLIBCXX_PARALLEL_CONDITION(true))
-      return __gnu_parallel::search_template(begin1, end1, begin2, end2, __gnu_parallel::equal_to<value1_type, value2_type>());
+	return __gnu_parallel::
+	  search_template(begin1, end1, begin2, end2, __gnu_parallel::
+			  equal_to<value1_type, value2_type>());
       else
-      return search(begin1, end1, begin2, end2, __gnu_parallel::sequential_tag());
+	return search(begin1, end1, begin2, end2,
+		      __gnu_parallel::sequential_tag());
     }
 
   // Sequential fallback for input iterator case
-  template<typename ForwardIterator1, typename ForwardIterator2, typename IteratorTag1, typename IteratorTag2>
+  template<typename ForwardIterator1, typename ForwardIterator2,
+	   typename IteratorTag1, typename IteratorTag2>
     inline ForwardIterator1
-  search_switch(ForwardIterator1 begin1, ForwardIterator1 end1, ForwardIterator2 begin2, ForwardIterator2 end2, IteratorTag1, IteratorTag2)
-  {
-    return search(begin1, end1, begin2, end2, __gnu_parallel::sequential_tag());
-  }
+    search_switch(ForwardIterator1 begin1, ForwardIterator1 end1,
+		  ForwardIterator2 begin2, ForwardIterator2 end2,
+		  IteratorTag1, IteratorTag2)
+    { return search(begin1, end1, begin2, end2,
+		    __gnu_parallel::sequential_tag()); }
 
   // Public interface.
   template<typename ForwardIterator1, typename ForwardIterator2>
     inline ForwardIterator1
-  search(ForwardIterator1 begin1, ForwardIterator1 end1, ForwardIterator2 begin2, ForwardIterator2 end2)
+    search(ForwardIterator1 begin1, ForwardIterator1 end1,
+	   ForwardIterator2 begin2, ForwardIterator2 end2)
     {
       typedef std::iterator_traits<ForwardIterator1> iterator1_traits;
       typedef typename iterator1_traits::iterator_category iterator1_category;
       typedef std::iterator_traits<ForwardIterator2> iterator2_traits;
       typedef typename iterator2_traits::iterator_category iterator2_category;
 
-    return search_switch(begin1, end1, begin2, end2, iterator1_category(), iterator2_category());
+      return search_switch(begin1, end1, begin2, end2,
+			   iterator1_category(), iterator2_category());
     }
 
   // Public interface.
-  template<typename ForwardIterator1, typename ForwardIterator2, typename BinaryPredicate>
+  template<typename ForwardIterator1, typename ForwardIterator2,
+	   typename BinaryPredicate>
     inline ForwardIterator1
-  search(ForwardIterator1 begin1, ForwardIterator1 end1, ForwardIterator2 begin2, ForwardIterator2 end2, BinaryPredicate pred, __gnu_parallel::sequential_tag)
-  {
-    return _GLIBCXX_STD_P::search(begin1, end1, begin2, end2, pred);
-  }
+    search(ForwardIterator1 begin1, ForwardIterator1 end1,
+	   ForwardIterator2 begin2, ForwardIterator2 end2,
+	   BinaryPredicate pred, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::search(begin1, end1, begin2, end2, pred); }
 
   // Parallel algorithm for random access iterator.
   template<typename RandomAccessIterator1, typename RandomAccessIterator2,
 	   typename BinaryPredicate>
     RandomAccessIterator1
     search_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1,
-		RandomAccessIterator2 begin2, RandomAccessIterator2 end2, BinaryPredicate  pred, random_access_iterator_tag, random_access_iterator_tag)
+		  RandomAccessIterator2 begin2, RandomAccessIterator2 end2,
+		  BinaryPredicate pred,
+		  random_access_iterator_tag, random_access_iterator_tag)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(true))
-      return __gnu_parallel::search_template(begin1, end1, begin2, end2, pred);
+	return __gnu_parallel::search_template(begin1, end1,
+					       begin2, end2, pred);
       else
-      return search(begin1, end1, begin2, end2, pred, __gnu_parallel::sequential_tag());
+	return search(begin1, end1, begin2, end2, pred,
+		      __gnu_parallel::sequential_tag());
     }
 
   // Sequential fallback for input iterator case
   template<typename ForwardIterator1, typename ForwardIterator2,
-	   typename BinaryPredicate, typename IteratorTag1, typename IteratorTag2>
+	   typename BinaryPredicate, typename IteratorTag1,
+	   typename IteratorTag2>
     inline ForwardIterator1
     search_switch(ForwardIterator1 begin1, ForwardIterator1 end1,
-		ForwardIterator2 begin2, ForwardIterator2 end2, BinaryPredicate pred, IteratorTag1, IteratorTag2)
-  {
-    return search(begin1, end1, begin2, end2, pred, __gnu_parallel::sequential_tag());
-  }
+		  ForwardIterator2 begin2, ForwardIterator2 end2,
+		  BinaryPredicate pred, IteratorTag1, IteratorTag2)
+    { return search(begin1, end1, begin2, end2, pred,
+		    __gnu_parallel::sequential_tag()); }
 
   // Public interface
-  template<typename ForwardIterator1, typename ForwardIterator2, typename BinaryPredicate>
+  template<typename ForwardIterator1, typename ForwardIterator2,
+	   typename BinaryPredicate>
     inline ForwardIterator1
-  search(ForwardIterator1 begin1, ForwardIterator1 end1, ForwardIterator2 begin2, ForwardIterator2 end2, BinaryPredicate  pred)
+    search(ForwardIterator1 begin1, ForwardIterator1 end1,
+	   ForwardIterator2 begin2, ForwardIterator2 end2,
+	   BinaryPredicate  pred)
     {
       typedef std::iterator_traits<ForwardIterator1> iterator1_traits;
       typedef typename iterator1_traits::iterator_category iterator1_category;
       typedef std::iterator_traits<ForwardIterator2> iterator2_traits;
       typedef typename iterator2_traits::iterator_category iterator2_category;
-    return search_switch(begin1, end1, begin2, end2, pred, iterator1_category(), iterator2_category());
+      return search_switch(begin1, end1, begin2, end2, pred,
+			   iterator1_category(), iterator2_category());
     }
 
   // Sequential fallback
   template<typename ForwardIterator, typename Integer, typename T>
     inline ForwardIterator
-  search_n(ForwardIterator begin, ForwardIterator end, Integer count, const T& val, __gnu_parallel::sequential_tag)
+    search_n(ForwardIterator begin, ForwardIterator end, Integer count,
+	     const T& val, __gnu_parallel::sequential_tag)
     { return _GLIBCXX_STD_P::search_n(begin, end, count, val); }
 
   // Sequential fallback
-  template<typename ForwardIterator, typename Integer, typename T, typename BinaryPredicate>
+  template<typename ForwardIterator, typename Integer, typename T,
+	   typename BinaryPredicate>
     inline ForwardIterator
-  search_n(ForwardIterator begin, ForwardIterator end, Integer count, const T& val, BinaryPredicate binary_pred, __gnu_parallel::sequential_tag)
-  {
-    return _GLIBCXX_STD_P::search_n(begin, end, count, val, binary_pred);
-  }
+    search_n(ForwardIterator begin, ForwardIterator end, Integer count,
+	     const T& val, BinaryPredicate binary_pred,
+	     __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::search_n(begin, end, count, val, binary_pred); }
 
   // Public interface.
   template<typename ForwardIterator, typename Integer, typename T>
     inline ForwardIterator
-  search_n(ForwardIterator begin, ForwardIterator end, Integer count, const T& val)
+    search_n(ForwardIterator begin, ForwardIterator end, Integer count,
+	     const T& val)
     {
       typedef typename iterator_traits<ForwardIterator>::value_type value_type;
-    return search_n(begin, end, count, val, __gnu_parallel::equal_to<value_type, T>());
+      return search_n(begin, end, count, val,
+		      __gnu_parallel::equal_to<value_type, T>());
     }
 
   // Parallel algorithm for random access iterators.
-  template<typename RandomAccessIterator, typename Integer, typename T, typename BinaryPredicate>
+  template<typename RandomAccessIterator, typename Integer,
+	   typename T, typename BinaryPredicate>
     RandomAccessIterator
-  search_n_switch(RandomAccessIterator begin, RandomAccessIterator end, Integer count, const T& val, BinaryPredicate binary_pred, random_access_iterator_tag)
+    search_n_switch(RandomAccessIterator begin, RandomAccessIterator end,
+		    Integer count, const T& val, BinaryPredicate binary_pred,
+		    random_access_iterator_tag)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(true))
 	{
 	  __gnu_parallel::pseudo_sequence<T, Integer> ps(val, count);
-	return __gnu_parallel::search_template(begin, end, ps.begin(), ps.end(), binary_pred);
+	  return __gnu_parallel::search_template(begin, end, ps.begin(),
+						 ps.end(), binary_pred);
 	}
       else
-      return std::__search_n(begin, end, count, val, binary_pred, random_access_iterator_tag());
+	return std::__search_n(begin, end, count, val,
+			       binary_pred, random_access_iterator_tag());
     }
 
   // Sequential fallback for input iterator case.
-  template<typename ForwardIterator, typename Integer, typename T, typename BinaryPredicate, typename IteratorTag>
+  template<typename ForwardIterator, typename Integer, typename T,
+	   typename BinaryPredicate, typename IteratorTag>
     inline ForwardIterator
-  search_n_switch(ForwardIterator begin, ForwardIterator end, Integer count, const T& val, BinaryPredicate binary_pred, IteratorTag)
-  {
-    return __search_n(begin, end, count, val, binary_pred, IteratorTag());
-  }
+    search_n_switch(ForwardIterator begin, ForwardIterator end, Integer count,
+		    const T& val, BinaryPredicate binary_pred, IteratorTag)
+    { return __search_n(begin, end, count, val, binary_pred, IteratorTag()); }
 
   // Public interface.
-  template<typename ForwardIterator, typename Integer, typename T, typename BinaryPredicate>
+  template<typename ForwardIterator, typename Integer, typename T,
+	   typename BinaryPredicate>
     inline ForwardIterator
-  search_n(ForwardIterator begin, ForwardIterator end, Integer count, const T& val, BinaryPredicate binary_pred)
+    search_n(ForwardIterator begin, ForwardIterator end, Integer count,
+	     const T& val, BinaryPredicate binary_pred)
     {
-    return search_n_switch(begin, end, count, val, binary_pred, typename std::iterator_traits<ForwardIterator>::iterator_category());
+      return search_n_switch(begin, end, count, val, binary_pred,
+			     typename std::iterator_traits<ForwardIterator>::
+			     iterator_category());
     }
 
 
   // Sequential fallback.
-  template<typename InputIterator, typename OutputIterator, typename UnaryOperation>
+  template<typename InputIterator, typename OutputIterator,
+	   typename UnaryOperation>
     inline OutputIterator
     transform(InputIterator begin, InputIterator end, OutputIterator result, 
 	      UnaryOperation unary_op, __gnu_parallel::sequential_tag)
     { return _GLIBCXX_STD_P::transform(begin, end, result, unary_op); }
 
   // Parallel unary transform for random access iterators.
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename UnaryOperation>
+  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
+	   typename UnaryOperation>
     RandomAccessIterator2
-  transform1_switch(RandomAccessIterator1 begin, RandomAccessIterator1 end, RandomAccessIterator2 result, UnaryOperation unary_op, random_access_iterator_tag, random_access_iterator_tag, __gnu_parallel::parallelism parallelism_tag = __gnu_parallel::parallel_balanced)
+    transform1_switch(RandomAccessIterator1 begin, RandomAccessIterator1 end,
+		      RandomAccessIterator2 result, UnaryOperation unary_op,
+		      random_access_iterator_tag, random_access_iterator_tag,
+		      __gnu_parallel::parallelism parallelism_tag
+		      = __gnu_parallel::parallel_balanced)
     {
-    if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::transform_minimal_n && __gnu_parallel::is_parallel(parallelism_tag)))
+      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
+				      sequence_index_t>(end - begin)
+				      >= __gnu_parallel::Settings::
+				      transform_minimal_n
+				      && __gnu_parallel::
+				      is_parallel(parallelism_tag)))
 	{
 	  bool dummy = true;
-	typedef __gnu_parallel::iterator_pair<RandomAccessIterator1, RandomAccessIterator2, random_access_iterator_tag> ip;
+	  typedef __gnu_parallel::iterator_pair<RandomAccessIterator1,
+	    RandomAccessIterator2, random_access_iterator_tag> ip;
 	  ip begin_pair(begin, result), end_pair(end, result + (end - begin));
 	  __gnu_parallel::transform1_selector<ip> functionality;
-	__gnu_parallel::for_each_template_random_access(begin_pair, end_pair, unary_op, functionality, __gnu_parallel::dummy_reduct(), dummy, dummy, -1, parallelism_tag);
+	  __gnu_parallel::
+	    for_each_template_random_access(begin_pair, end_pair,
+					    unary_op, functionality,
+					    __gnu_parallel::dummy_reduct(),
+					    dummy, dummy, -1, parallelism_tag);
 	  return functionality.finish_iterator;
 	}
       else
@@ -1054,16 +1264,19 @@ namespace __parallel
     }
 
   // Sequential fallback for input iterator case.
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename UnaryOperation, typename IteratorTag1, typename IteratorTag2>
+  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
+	   typename UnaryOperation, typename IteratorTag1,
+	   typename IteratorTag2>
     inline RandomAccessIterator2
-  transform1_switch(RandomAccessIterator1 begin, RandomAccessIterator1 end, RandomAccessIterator2 result, UnaryOperation unary_op, IteratorTag1, IteratorTag2)
-  { 
-    return transform(begin, end, result, unary_op, 
-		     __gnu_parallel::sequential_tag()); 
-  }
+    transform1_switch(RandomAccessIterator1 begin, RandomAccessIterator1 end,
+		      RandomAccessIterator2 result, UnaryOperation unary_op,
+		      IteratorTag1, IteratorTag2)
+    { return transform(begin, end, result, unary_op, 
+		       __gnu_parallel::sequential_tag()); }
 
   // Public interface.
-  template<typename InputIterator, typename OutputIterator, typename UnaryOperation>
+  template<typename InputIterator, typename OutputIterator,
+	   typename UnaryOperation>
     inline OutputIterator
     transform(InputIterator begin, InputIterator end, OutputIterator result,
 	      UnaryOperation unary_op, 
@@ -1079,7 +1292,8 @@ namespace __parallel
 			       parallelism_tag);
     }
 
-  template<typename InputIterator, typename OutputIterator, typename UnaryOperation>
+  template<typename InputIterator, typename OutputIterator,
+	   typename UnaryOperation>
     inline OutputIterator
     transform(InputIterator begin, InputIterator end, OutputIterator result,
 	      UnaryOperation unary_op)
@@ -1095,27 +1309,47 @@ namespace __parallel
 
 
   // Sequential fallback
-  template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename BinaryOperation>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename OutputIterator, typename BinaryOperation>
     inline OutputIterator
-  transform(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, 
-	    OutputIterator result, BinaryOperation binary_op, 
-	    __gnu_parallel::sequential_tag)
-  { 
-    return _GLIBCXX_STD_P::transform(begin1, end1, begin2, result, binary_op); 
-  }
+    transform(InputIterator1 begin1, InputIterator1 end1,
+	      InputIterator2 begin2, OutputIterator result,
+	      BinaryOperation binary_op, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::transform(begin1, end1,
+				       begin2, result, binary_op); }
 
   // Parallel binary transform for random access iterators.
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename RandomAccessIterator3, typename BinaryOperation>
+  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
+	   typename RandomAccessIterator3, typename BinaryOperation>
     RandomAccessIterator3
-  transform2_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, RandomAccessIterator2 begin2, RandomAccessIterator3 result, BinaryOperation binary_op, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag, __gnu_parallel::parallelism parallelism_tag = __gnu_parallel::parallel_balanced)
+    transform2_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1,
+		      RandomAccessIterator2 begin2,
+		      RandomAccessIterator3 result, BinaryOperation binary_op,
+		      random_access_iterator_tag, random_access_iterator_tag,
+		      random_access_iterator_tag,
+		      __gnu_parallel::parallelism parallelism_tag 
+		      = __gnu_parallel::parallel_balanced)
     {
-    if (_GLIBCXX_PARALLEL_CONDITION((end1 - begin1) >= __gnu_parallel::Settings::transform_minimal_n && __gnu_parallel::is_parallel(parallelism_tag)))
+      if (_GLIBCXX_PARALLEL_CONDITION((end1 - begin1)
+				      >= __gnu_parallel::Settings::
+				      transform_minimal_n
+				      && __gnu_parallel::
+				      is_parallel(parallelism_tag)))
 	{
 	  bool dummy = true;
-	typedef __gnu_parallel::iterator_triple<RandomAccessIterator1, RandomAccessIterator2, RandomAccessIterator3, random_access_iterator_tag> ip;
-	ip begin_triple(begin1, begin2, result), end_triple(end1, begin2 + (end1 - begin1), result + (end1 - begin1));
+	  typedef __gnu_parallel::iterator_triple<RandomAccessIterator1,
+	    RandomAccessIterator2, RandomAccessIterator3,
+	    random_access_iterator_tag> ip;
+	  ip begin_triple(begin1, begin2, result),
+	    end_triple(end1, begin2 + (end1 - begin1),
+		       result + (end1 - begin1));
 	  __gnu_parallel::transform2_selector<ip> functionality;
-	__gnu_parallel::for_each_template_random_access(begin_triple, end_triple, binary_op, functionality, __gnu_parallel::dummy_reduct(), dummy, dummy, -1, parallelism_tag);
+	  __gnu_parallel::
+	    for_each_template_random_access(begin_triple, end_triple,
+					    binary_op, functionality,
+					    __gnu_parallel::dummy_reduct(),
+					    dummy, dummy, -1,
+					    parallelism_tag);
 	  return functionality.finish_iterator;
 	}
       else
@@ -1124,27 +1358,31 @@ namespace __parallel
     }
 
   // Sequential fallback for input iterator case.
-  template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename BinaryOperation, typename tag1, typename tag2, typename tag3>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename OutputIterator, typename BinaryOperation,
+	   typename tag1, typename tag2, typename tag3>
     inline OutputIterator
     transform2_switch(InputIterator1 begin1, InputIterator1 end1, 
 		      InputIterator2 begin2, OutputIterator result, 
 		      BinaryOperation binary_op, tag1, tag2, tag3)
-  {
-    return transform(begin1, end1, begin2, result, binary_op,
-		     __gnu_parallel::sequential_tag());
-  }
+    { return transform(begin1, end1, begin2, result, binary_op,
+		       __gnu_parallel::sequential_tag()); }
 
   // Public interface.
-  template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename BinaryOperation>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename OutputIterator, typename BinaryOperation>
     inline OutputIterator
-  transform(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, 
-	    OutputIterator result, BinaryOperation binary_op, 
+    transform(InputIterator1 begin1, InputIterator1 end1,
+	      InputIterator2 begin2, OutputIterator result,
+	      BinaryOperation binary_op, 
 	      __gnu_parallel::parallelism parallelism_tag)
     {
       typedef std::iterator_traits<InputIterator1> iteratori1_traits;
-    typedef typename iteratori1_traits::iterator_category iteratori1_category;
+      typedef typename iteratori1_traits::iterator_category
+	iteratori1_category;
       typedef std::iterator_traits<InputIterator2> iteratori2_traits;
-    typedef typename iteratori2_traits::iterator_category iteratori2_category;
+      typedef typename iteratori2_traits::iterator_category
+	iteratori2_category;
       typedef std::iterator_traits<OutputIterator> iteratoro_traits;
       typedef typename iteratoro_traits::iterator_category iteratoro_category;
 
@@ -1153,15 +1391,19 @@ namespace __parallel
 			       iteratoro_category(), parallelism_tag);
     }
 
-  template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename BinaryOperation>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename OutputIterator, typename BinaryOperation>
     inline OutputIterator
-  transform(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, 
-	    OutputIterator result, BinaryOperation binary_op)
+    transform(InputIterator1 begin1, InputIterator1 end1,
+	      InputIterator2 begin2, OutputIterator result,
+	      BinaryOperation binary_op)
     {
       typedef std::iterator_traits<InputIterator1> iteratori1_traits;
-    typedef typename iteratori1_traits::iterator_category iteratori1_category;
+      typedef typename iteratori1_traits::iterator_category
+	iteratori1_category;
       typedef std::iterator_traits<InputIterator2> iteratori2_traits;
-    typedef typename iteratori2_traits::iterator_category iteratori2_category;
+      typedef typename iteratori2_traits::iterator_category
+	iteratori2_category;
       typedef std::iterator_traits<OutputIterator> iteratoro_traits;
       typedef typename iteratoro_traits::iterator_category iteratoro_category;
 
@@ -1179,17 +1421,15 @@ namespace __parallel
 
   // Sequential fallback for input iterator case
   template<typename ForwardIterator, typename T, typename IteratorTag>
-  void
+    inline void
     replace_switch(ForwardIterator begin, ForwardIterator end, 
 		   const T& old_value, const T& new_value, IteratorTag)
-  { 
-    replace(begin, end, old_value, new_value, 
-	    __gnu_parallel::sequential_tag());
-  }
+    { replace(begin, end, old_value, new_value, 
+	      __gnu_parallel::sequential_tag()); }
 
   // Parallel replace for random access iterators
   template<typename RandomAccessIterator, typename T>
-  void
+    inline void
     replace_switch(RandomAccessIterator begin, RandomAccessIterator end, 
 		   const T& old_value, const T& new_value, 
 		   random_access_iterator_tag, 
@@ -1232,11 +1472,13 @@ namespace __parallel
     { _GLIBCXX_STD_P::replace_if(begin, end, pred, new_value); }
 
   // Sequential fallback for input iterator case
-  template<typename ForwardIterator, typename Predicate, typename T, typename IteratorTag>
-  void
-  replace_if_switch(ForwardIterator begin, ForwardIterator end, Predicate pred,
-		    const T& new_value, IteratorTag)
-  { replace_if(begin, end, pred, new_value, __gnu_parallel::sequential_tag()); }
+  template<typename ForwardIterator, typename Predicate, typename T,
+	   typename IteratorTag>
+    inline void
+    replace_if_switch(ForwardIterator begin, ForwardIterator end,
+		      Predicate pred, const T& new_value, IteratorTag)
+    { replace_if(begin, end, pred, new_value,
+		 __gnu_parallel::sequential_tag()); }
 
   // Parallel algorithm for random access iterators.
   template<typename RandomAccessIterator, typename Predicate, typename T>
@@ -1247,11 +1489,22 @@ namespace __parallel
 		      __gnu_parallel::parallelism parallelism_tag
 		      = __gnu_parallel::parallel_balanced)
     {
-    if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::replace_minimal_n && __gnu_parallel::is_parallel(parallelism_tag)))
+      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
+				      sequence_index_t>(end - begin)
+				      >= __gnu_parallel::Settings::
+				      replace_minimal_n
+				      && __gnu_parallel::
+				      is_parallel(parallelism_tag)))
 	{
 	  bool dummy;
-	__gnu_parallel::replace_if_selector<RandomAccessIterator, Predicate, T> functionality(new_value);
-	__gnu_parallel::for_each_template_random_access(begin, end, pred, functionality, __gnu_parallel::dummy_reduct(), true, dummy, -1, parallelism_tag);
+	  __gnu_parallel::
+	    replace_if_selector<RandomAccessIterator, Predicate, T>
+	    functionality(new_value);
+	  __gnu_parallel::
+	    for_each_template_random_access(begin, end, pred,
+					    functionality,
+					    __gnu_parallel::dummy_reduct(),
+					    true, dummy, -1, parallelism_tag);
 	}
       else
 	replace_if(begin, end, pred, new_value, 
@@ -1290,7 +1543,7 @@ namespace __parallel
 
   // Sequential fallback for input iterator case.
   template<typename ForwardIterator, typename Generator, typename IteratorTag>
-  void
+    inline void
     generate_switch(ForwardIterator begin, ForwardIterator end, Generator gen, 
 		    IteratorTag)
     { generate(begin, end, gen, __gnu_parallel::sequential_tag()); }
@@ -1303,11 +1556,20 @@ namespace __parallel
 		    __gnu_parallel::parallelism parallelism_tag
 		    = __gnu_parallel::parallel_balanced)
     {
-    if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::generate_minimal_n && __gnu_parallel::is_parallel(parallelism_tag)))
+      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
+				      sequence_index_t>(end - begin)
+				      >= __gnu_parallel::Settings::
+				      generate_minimal_n
+				      && __gnu_parallel::
+				      is_parallel(parallelism_tag)))
 	{
 	  bool dummy;
-	__gnu_parallel::generate_selector<RandomAccessIterator> functionality;
-	__gnu_parallel::for_each_template_random_access(begin, end, gen, functionality, __gnu_parallel::dummy_reduct(), true, dummy, -1, parallelism_tag);
+	  __gnu_parallel::generate_selector<RandomAccessIterator>
+	    functionality;
+	  __gnu_parallel::
+	    for_each_template_random_access(begin, end, gen, functionality,
+					    __gnu_parallel::dummy_reduct(),
+					    true, dummy, -1, parallelism_tag);
 	}
       else
 	generate(begin, end, gen, __gnu_parallel::sequential_tag());
@@ -1342,8 +1604,9 @@ namespace __parallel
     { return _GLIBCXX_STD_P::generate_n(begin, n, gen); }
 
   // Sequential fallback for input iterator case.
-  template<typename OutputIterator, typename Size, typename Generator, typename IteratorTag>
-  OutputIterator
+  template<typename OutputIterator, typename Size, typename Generator,
+	   typename IteratorTag>
+    inline OutputIterator
     generate_n_switch(OutputIterator begin, Size n, Generator gen, IteratorTag)
     { return generate_n(begin, n, gen, __gnu_parallel::sequential_tag()); }
 
@@ -1400,7 +1663,8 @@ namespace __parallel
   template<typename must_be_int = int>
     struct c_rand_number
     {
-    inline int operator()(int limit)
+      int
+      operator()(int limit)
       { return rand() % limit; }
     };
 
@@ -1422,7 +1686,10 @@ namespace __parallel
     {
       if (begin == end)
 	return;
-    if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::random_shuffle_minimal_n))
+      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
+				      sequence_index_t>(end - begin)
+				      >= __gnu_parallel::Settings::
+				      random_shuffle_minimal_n))
 	__gnu_parallel::parallel_random_shuffle(begin, end, rand);
       else
 	__gnu_parallel::sequential_random_shuffle(begin, end, rand);
@@ -1431,24 +1698,33 @@ namespace __parallel
   // Sequential fallback.
   template<typename ForwardIterator, typename Predicate>
     inline ForwardIterator
-  partition(ForwardIterator begin, ForwardIterator end, Predicate pred, __gnu_parallel::sequential_tag)
+    partition(ForwardIterator begin, ForwardIterator end,
+	      Predicate pred, __gnu_parallel::sequential_tag)
     { return _GLIBCXX_STD_P::partition(begin, end, pred); }
 
   // Sequential fallback for input iterator case.
   template<typename ForwardIterator, typename Predicate, typename IteratorTag>
     inline ForwardIterator
-  partition_switch(ForwardIterator begin, ForwardIterator end, Predicate pred, IteratorTag)
+    partition_switch(ForwardIterator begin, ForwardIterator end,
+		     Predicate pred, IteratorTag)
     { return partition(begin, end, pred, __gnu_parallel::sequential_tag()); }
 
   // Parallel algorithm for random access iterators.
   template<typename RandomAccessIterator, typename Predicate>
     RandomAccessIterator
-  partition_switch(RandomAccessIterator begin, RandomAccessIterator end, Predicate pred, random_access_iterator_tag)
+    partition_switch(RandomAccessIterator begin, RandomAccessIterator end,
+		     Predicate pred, random_access_iterator_tag)
     {
-    if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::partition_minimal_n))
+      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
+				      sequence_index_t>(end - begin)
+				      >= __gnu_parallel::Settings::
+				      partition_minimal_n))
 	{
-	typedef typename std::iterator_traits<RandomAccessIterator>::difference_type difference_type;
-	difference_type middle = __gnu_parallel::parallel_partition(begin, end, pred, __gnu_parallel::get_max_threads());
+	  typedef typename std::iterator_traits<RandomAccessIterator>::
+	    difference_type difference_type;
+	  difference_type middle = __gnu_parallel::
+	    parallel_partition(begin, end, pred,
+			       __gnu_parallel::get_max_threads());
 	  return begin + middle;
 	}
       else
@@ -1477,7 +1753,8 @@ namespace __parallel
     inline void
     sort(RandomAccessIterator begin, RandomAccessIterator end, Comparator comp,
 	 __gnu_parallel::sequential_tag)
-  { _GLIBCXX_STD_P::sort<RandomAccessIterator, Comparator>(begin, end, comp); }
+    { _GLIBCXX_STD_P::sort<RandomAccessIterator, Comparator>(begin, end,
+							     comp); }
 
   // Public interface, insert default comparator
   template<typename RandomAccessIterator>
@@ -1498,7 +1775,10 @@ namespace __parallel
 
       if (begin != end)
 	{
-	if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::sort_minimal_n))
+	  if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
+					  sequence_index_t>(end - begin)
+					  >= __gnu_parallel::Settings::
+					  sort_minimal_n))
 	    __gnu_parallel::parallel_sort(begin, end, comp, false);
 	  else
 	    sort(begin, end, comp, __gnu_parallel::sequential_tag());
@@ -1520,7 +1800,7 @@ namespace __parallel
     { return _GLIBCXX_STD_P::stable_sort(begin, end, comp); }
 
   template<typename RandomAccessIterator>
-  void
+    inline void
     stable_sort(RandomAccessIterator begin, RandomAccessIterator end)
     {
       typedef iterator_traits<RandomAccessIterator> traits_type;
@@ -1536,7 +1816,10 @@ namespace __parallel
     {
       if (begin != end)
 	{
-	if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::sort_minimal_n))
+	  if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
+					  sequence_index_t>(end - begin)
+					  >= __gnu_parallel::Settings::
+					  sort_minimal_n))
 	    __gnu_parallel::parallel_sort(begin, end, comp, true);
 	  else
 	    stable_sort(begin, end, comp, __gnu_parallel::sequential_tag());
@@ -1544,7 +1827,8 @@ namespace __parallel
     }
 
   // Sequential fallback
-  template<typename InputIterator1, typename InputIterator2, typename OutputIterator>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename OutputIterator>
     inline OutputIterator
     merge(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, 
 	  InputIterator2 end2, OutputIterator result,
@@ -1552,7 +1836,8 @@ namespace __parallel
     { return _GLIBCXX_STD_P::merge(begin1, end1, begin2, end2, result); }
 
   // Sequential fallback
-  template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Comparator>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename OutputIterator, typename Comparator>
     inline OutputIterator
     merge(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2,
 	  InputIterator2 end2, OutputIterator result, Comparator comp,
@@ -1560,13 +1845,20 @@ namespace __parallel
     { return _GLIBCXX_STD_P::merge(begin1, end1, begin2, end2, result, comp); }
 
   // Sequential fallback for input iterator case
-  template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Comparator, typename IteratorTag1, typename IteratorTag2, typename IteratorTag3>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename OutputIterator, typename Comparator,
+	   typename IteratorTag1, typename IteratorTag2, typename IteratorTag3>
     inline OutputIterator
-  merge_switch(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, InputIterator2 end2, OutputIterator result, Comparator comp, IteratorTag1, IteratorTag2, IteratorTag3)
-  { return _GLIBCXX_STD_P::merge(begin1, end1, begin2, end2, result, comp); }
+    merge_switch(InputIterator1 begin1, InputIterator1 end1,
+		 InputIterator2 begin2, InputIterator2 end2,
+		 OutputIterator result, Comparator comp,
+		 IteratorTag1, IteratorTag2, IteratorTag3)
+     { return _GLIBCXX_STD_P::merge(begin1, end1, begin2, end2,
+				    result, comp); }
 
   // Parallel algorithm for random access iterators
-  template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Comparator>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename OutputIterator, typename Comparator>
     OutputIterator
     merge_switch(InputIterator1 begin1, InputIterator1 end1, 
 		 InputIterator2 begin2, InputIterator2 end2, 
@@ -1574,17 +1866,27 @@ namespace __parallel
 		 random_access_iterator_tag, random_access_iterator_tag, 
 		 random_access_iterator_tag)
     {
-    if (_GLIBCXX_PARALLEL_CONDITION((static_cast<__gnu_parallel::sequence_index_t>(end1 - begin1) >= __gnu_parallel::Settings::merge_minimal_n || static_cast<__gnu_parallel::sequence_index_t>(end2 - begin2) >= __gnu_parallel::Settings::merge_minimal_n)))
-      return __gnu_parallel::parallel_merge_advance(begin1, end1, begin2, end2,
-			      result, (end1 - begin1) + (end2 - begin2), comp);
+      if (_GLIBCXX_PARALLEL_CONDITION((static_cast<__gnu_parallel::
+				       sequence_index_t>(end1 - begin1)
+				       >= __gnu_parallel::Settings::
+				       merge_minimal_n
+				       || static_cast<__gnu_parallel::
+				       sequence_index_t>(end2 - begin2)
+				       >= __gnu_parallel::Settings::
+				       merge_minimal_n)))
+	return __gnu_parallel::parallel_merge_advance(begin1, end1,
+						      begin2, end2,
+						      result, (end1 - begin1)
+						      + (end2 - begin2), comp);
       else
-      return __gnu_parallel::merge_advance(begin1, end1, begin2, end2, result, 
-					   (end1 - begin1) + (end2 - begin2), 
-					   comp);
+	return __gnu_parallel::merge_advance(begin1, end1, begin2, end2,
+					     result, (end1 - begin1)
+					     + (end2 - begin2), comp);
   }
 
   // Public interface
-  template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Comparator>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename OutputIterator, typename Comparator>
     inline OutputIterator
     merge(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, 
 	  InputIterator2 end2, OutputIterator result, Comparator comp)
@@ -1594,8 +1896,10 @@ namespace __parallel
       typedef std::iterator_traits<InputIterator1> iteratori1_traits;
       typedef std::iterator_traits<InputIterator2> iteratori2_traits;
       typedef std::iterator_traits<OutputIterator> iteratoro_traits;
-    typedef typename iteratori1_traits::iterator_category iteratori1_category;
-    typedef typename iteratori2_traits::iterator_category iteratori2_category;
+      typedef typename iteratori1_traits::iterator_category
+	iteratori1_category;
+      typedef typename iteratori2_traits::iterator_category
+	iteratori2_category;
       typedef typename iteratoro_traits::iterator_category iteratoro_category;
 
       return merge_switch(begin1, end1, begin2, end2, result, comp, 
@@ -1605,7 +1909,8 @@ namespace __parallel
 
 
   // Public interface, insert default comparator
-  template<typename InputIterator1, typename InputIterator2, typename OutputIterator>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename OutputIterator>
     inline OutputIterator
     merge(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, 
 	  InputIterator2 end2, OutputIterator result)
@@ -1628,7 +1933,7 @@ namespace __parallel
 
   // Sequential fallback
   template<typename RandomAccessIterator, typename Comparator>
-  void
+    inline void
     nth_element(RandomAccessIterator begin, RandomAccessIterator nth, 
 		RandomAccessIterator end, Comparator comp, 
 	      __gnu_parallel::sequential_tag)
@@ -1640,7 +1945,10 @@ namespace __parallel
     nth_element(RandomAccessIterator begin, RandomAccessIterator nth, 
 		RandomAccessIterator end, Comparator comp)
     {
-    if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::nth_element_minimal_n))
+      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
+				      sequence_index_t>(end - begin)
+				      >= __gnu_parallel::Settings::
+				      nth_element_minimal_n))
 	__gnu_parallel::parallel_nth_element(begin, nth, end, comp);
       else
 	nth_element(begin, nth, end, comp, __gnu_parallel::sequential_tag());
@@ -1648,7 +1956,7 @@ namespace __parallel
 
   // Public interface, insert default comparator
   template<typename RandomAccessIterator>
-  void
+    inline void
     nth_element(RandomAccessIterator begin, RandomAccessIterator nth, 
 		RandomAccessIterator end)
     {
@@ -1659,7 +1967,7 @@ namespace __parallel
 
   // Sequential fallback
   template<typename RandomAccessIterator, typename _Compare>
-  void
+    inline void
     partial_sort(RandomAccessIterator begin, RandomAccessIterator middle, 
 		 RandomAccessIterator end, _Compare comp,
 		 __gnu_parallel::sequential_tag)
@@ -1678,15 +1986,19 @@ namespace __parallel
     partial_sort(RandomAccessIterator begin, RandomAccessIterator middle, 
 		 RandomAccessIterator end, _Compare comp)
     {
-    if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::partial_sort_minimal_n))
+      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
+				      sequence_index_t>(end - begin)
+				      >= __gnu_parallel::Settings::
+				      partial_sort_minimal_n))
 	__gnu_parallel::parallel_partial_sort(begin, middle, end, comp);
       else
-      partial_sort(begin, middle, end, comp, __gnu_parallel::sequential_tag());
+	partial_sort(begin, middle, end, comp,
+		     __gnu_parallel::sequential_tag());
     }
 
   // Public interface, insert default comparator
   template<typename RandomAccessIterator>
-  void
+    inline void
     partial_sort(RandomAccessIterator begin, RandomAccessIterator middle, 
 		 RandomAccessIterator end)
     {
@@ -1711,7 +2023,7 @@ namespace __parallel
 
   // Sequential fallback for input iterator case
   template<typename ForwardIterator, typename Comparator, typename IteratorTag>
-  ForwardIterator
+    inline ForwardIterator
     max_element_switch(ForwardIterator begin, ForwardIterator end, 
 		       Comparator comp, IteratorTag)
     { return max_element(begin, end, comp, __gnu_parallel::sequential_tag()); }
@@ -1724,11 +2036,24 @@ namespace __parallel
 		       __gnu_parallel::parallelism parallelism_tag
 		       = __gnu_parallel::parallel_balanced)
     {
-    if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::max_element_minimal_n && __gnu_parallel::is_parallel(parallelism_tag)))
+      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
+				      sequence_index_t>(end - begin)
+				      >= __gnu_parallel::Settings::
+				      max_element_minimal_n
+				      && __gnu_parallel::
+				      is_parallel(parallelism_tag)))
 	{
 	  RandomAccessIterator res(begin);
-	__gnu_parallel::identity_selector<RandomAccessIterator> functionality;
-	__gnu_parallel::for_each_template_random_access(begin, end, __gnu_parallel::nothing(), functionality, __gnu_parallel::max_element_reduct<Comparator, RandomAccessIterator>(comp), res, res, -1, parallelism_tag);
+	  __gnu_parallel::identity_selector<RandomAccessIterator>
+	    functionality;
+	  __gnu_parallel::
+	    for_each_template_random_access(begin, end,
+					    __gnu_parallel::nothing(),
+					    functionality,
+					    __gnu_parallel::
+					    max_element_reduct<Comparator,
+					    RandomAccessIterator>(comp),
+					    res, res, -1, parallelism_tag);
 	  return res;
 	}
       else
@@ -1777,8 +2102,7 @@ namespace __parallel
 
   // Sequential fallback
   template<typename ForwardIterator>
-  inline
-  ForwardIterator
+    inline ForwardIterator
     min_element(ForwardIterator begin, ForwardIterator end, 
 		__gnu_parallel::sequential_tag)
     { return _GLIBCXX_STD_P::min_element(begin, end); }
@@ -1792,7 +2116,7 @@ namespace __parallel
 
   // Sequential fallback for input iterator case
   template<typename ForwardIterator, typename Comparator, typename IteratorTag>
-  ForwardIterator
+    inline ForwardIterator
     min_element_switch(ForwardIterator begin, ForwardIterator end, 
 		       Comparator comp, IteratorTag)
     { return min_element(begin, end, comp, __gnu_parallel::sequential_tag()); }
@@ -1805,11 +2129,24 @@ namespace __parallel
 		       __gnu_parallel::parallelism parallelism_tag
 		       = __gnu_parallel::parallel_balanced)
     {
-    if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::min_element_minimal_n && __gnu_parallel::is_parallel(parallelism_tag)))
+      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
+				      sequence_index_t>(end - begin)
+				      >= __gnu_parallel::Settings::
+				      min_element_minimal_n
+				      && __gnu_parallel::
+				      is_parallel(parallelism_tag)))
 	{
 	  RandomAccessIterator res(begin);
-	__gnu_parallel::identity_selector<RandomAccessIterator> functionality;
-	__gnu_parallel::for_each_template_random_access(begin, end, __gnu_parallel::nothing(), functionality, __gnu_parallel::min_element_reduct<Comparator, RandomAccessIterator>(comp), res, res, -1, parallelism_tag);
+	  __gnu_parallel::identity_selector<RandomAccessIterator>
+	    functionality;
+	  __gnu_parallel::
+	    for_each_template_random_access(begin, end,
+					    __gnu_parallel::nothing(),
+					    functionality,
+					    __gnu_parallel::
+					    min_element_reduct<Comparator,
+					    RandomAccessIterator>(comp),
+					    res, res, -1, parallelism_tag);
 	  return res;
 	}
       else

libstdc++-v3/include/parallel/algobase.h

 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 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 terms
@@ -63,14 +63,16 @@ namespace __parallel
     { return _GLIBCXX_STD_P::mismatch(begin1, end1, begin2); }
 
   // Sequential fallback
-  template<typename InputIterator1, typename InputIterator2, typename Predicate>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename Predicate>
     inline pair<InputIterator1, InputIterator2>
     mismatch(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, 
 	     Predicate pred, __gnu_parallel::sequential_tag)
     { return _GLIBCXX_STD_P::mismatch(begin1, end1, begin2, pred); }
 
   // Sequential fallback for input iterator case
-  template<typename InputIterator1, typename InputIterator2, typename Predicate, typename IteratorTag1, typename IteratorTag2>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename Predicate, typename IteratorTag1, typename IteratorTag2>
     inline pair<InputIterator1, InputIterator2>
     mismatch_switch(InputIterator1 begin1, InputIterator1 end1, 
 		    InputIterator2 begin2, Predicate pred, IteratorTag1, 
@@ -78,7 +80,8 @@ namespace __parallel
     { return _GLIBCXX_STD_P::mismatch(begin1, end1, begin2, pred); }
 
   // Parallel mismatch for random access iterators
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Predicate>
+  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
+	   typename Predicate>
     pair<RandomAccessIterator1, RandomAccessIterator2>
     mismatch_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, 
 		    RandomAccessIterator2 begin2, Predicate pred, 
@@ -86,7 +89,10 @@ namespace __parallel
     {
       if (_GLIBCXX_PARALLEL_CONDITION(true))
 	{
-	RandomAccessIterator1 res = __gnu_parallel::find_template(begin1, end1, begin2, pred, __gnu_parallel::mismatch_selector()).first;
+	  RandomAccessIterator1 res =
+	    __gnu_parallel::find_template(begin1, end1, begin2, pred,
+					  __gnu_parallel::
+					  mismatch_selector()).first;
 	  return make_pair(res , begin2 + (res - begin1));
 	}
       else
@@ -112,7 +118,8 @@ namespace __parallel
     }
 
   // Public interface
-  template<typename InputIterator1, typename InputIterator2, typename Predicate>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename Predicate>
     inline pair<InputIterator1, InputIterator2>
     mismatch(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2,
 	     Predicate pred)
@@ -134,7 +141,8 @@ namespace __parallel
     { return _GLIBCXX_STD_P::equal(begin1, end1, begin2); }
 
   // Sequential fallback
-  template<typename InputIterator1, typename InputIterator2, typename Predicate>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename Predicate>
     inline bool
     equal(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, 
 	  Predicate pred, __gnu_parallel::sequential_tag)
@@ -147,7 +155,8 @@ namespace __parallel
     { return mismatch(begin1, end1, begin2).first == end1; }
 
   // Public interface
-  template<typename InputIterator1, typename InputIterator2, typename Predicate>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename Predicate>
     inline bool
     equal(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, 
 	  Predicate pred)
@@ -159,35 +168,33 @@ namespace __parallel
     lexicographical_compare(InputIterator1 begin1, InputIterator1 end1, 
 			    InputIterator2 begin2, InputIterator2 end2, 
 			    __gnu_parallel::sequential_tag)
-  {
-    return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1, begin2, end2);
-  }
+    { return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1,
+						     begin2, end2); }
 
   // Sequential fallback
-  template<typename InputIterator1, typename InputIterator2, typename Predicate>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename Predicate>
     inline bool
     lexicographical_compare(InputIterator1 begin1, InputIterator1 end1, 
 			    InputIterator2 begin2, InputIterator2 end2, 
 			    Predicate pred, __gnu_parallel::sequential_tag)
-  {
-    return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1, 
-						   begin2, end2, pred);
-  }
+    { return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1, 
+						     begin2, end2, pred); }
 
   // Sequential fallback for input iterator case
-  template<typename InputIterator1, typename InputIterator2, typename Predicate, typename IteratorTag1, typename IteratorTag2>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename Predicate, typename IteratorTag1, typename IteratorTag2>
     inline bool
     lexicographical_compare_switch(InputIterator1 begin1, InputIterator1 end1, 
 				   InputIterator2 begin2, InputIterator2 end2, 
 				   Predicate pred, IteratorTag1, IteratorTag2)
-  {
-    return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1, 
-						   begin2, end2, pred);
-  }
+    { return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1, 
+						     begin2, end2, pred); }
 
   // Parallel lexicographical_compare for random access iterators
   // Limitation: Both valuetypes must be the same
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Predicate>
+  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
+	   typename Predicate>
     bool
     lexicographical_compare_switch(RandomAccessIterator1 begin1, 
 				   RandomAccessIterator1 end1, 
@@ -204,12 +211,14 @@ namespace __parallel
 	  typedef iterator_traits<RandomAccessIterator2> traits2_type;
 	  typedef typename traits2_type::value_type value2_type;
 
-	typedef __gnu_parallel::equal_from_less<Predicate, value1_type, value2_type> equal_type;
+	  typedef __gnu_parallel::equal_from_less<Predicate, value1_type,
+	                                          value2_type> equal_type;
 
 	  // Longer sequence in first place.
 	  if ((end1 - begin1) < (end2 - begin2))
 	    {
-	    typedef pair<RandomAccessIterator1, RandomAccessIterator2> pair_type;
+	      typedef pair<RandomAccessIterator1, RandomAccessIterator2>
+		pair_type;
 	      pair_type mm = mismatch_switch(begin1, end1, begin2, 
 					     equal_type(pred), 
 					     random_access_iterator_tag(), 
@@ -219,7 +228,8 @@ namespace __parallel
 	    }
 	  else
 	    {
-	    typedef pair<RandomAccessIterator2, RandomAccessIterator1> pair_type;
+	      typedef pair<RandomAccessIterator2, RandomAccessIterator1>
+		pair_type;
 	      pair_type mm = mismatch_switch(begin2, end2, begin1, 
 					     equal_type(pred), 
 					     random_access_iterator_tag(), 
@@ -229,13 +239,15 @@ namespace __parallel
 	    }
 	}
       else
-      return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1, begin2, end2, pred);
+	return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1,
+						       begin2, end2, pred);
     }
 
   // Public interface
   template<typename InputIterator1, typename InputIterator2>
     inline bool
-  lexicographical_compare(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, InputIterator2 end2)
+    lexicographical_compare(InputIterator1 begin1, InputIterator1 end1,
+			    InputIterator2 begin2, InputIterator2 end2)
     {
       typedef iterator_traits<InputIterator1> traits1_type;
       typedef typename traits1_type::value_type value1_type;
@@ -252,9 +264,12 @@ namespace __parallel
     }
 
   // Public interface
-  template<typename InputIterator1, typename InputIterator2, typename Predicate>
+  template<typename InputIterator1, typename InputIterator2,
+	   typename Predicate>
     inline bool
-  lexicographical_compare(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, InputIterator2 end2, Predicate pred)
+    lexicographical_compare(InputIterator1 begin1, InputIterator1 end1,
+			    InputIterator2 begin2, InputIterator2 end2,
+			    Predicate pred)
     {
       typedef iterator_traits<InputIterator1> traits1_type;
       typedef typename traits1_type::iterator_category iterator1_category;

libstdc++-v3/include/parallel/algorithmfwd.h

 // <algorithm> parallel extensions -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 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 terms
@@ -84,43 +84,43 @@ namespace __parallel
     typename iterator_traits<_IIter>::difference_type
     count(_IIter, _IIter, const _Tp&);
 
-  template<typename _IIter, typename T>
+  template<typename _IIter, typename _Tp>
     typename iterator_traits<_IIter>::difference_type
-    count(_IIter, _IIter, const T&, __gnu_parallel::sequential_tag);
+    count(_IIter, _IIter, const _Tp&, __gnu_parallel::sequential_tag);
 
-  template<typename _IIter, typename T>
+  template<typename _IIter, typename _Tp>
     typename iterator_traits<_IIter>::difference_type
-    count(_IIter, _IIter, const T&, __gnu_parallel::parallelism);
+    count(_IIter, _IIter, const _Tp&, __gnu_parallel::parallelism);
 
-  template<typename _IIter, typename T, typename _IterTag>
+  template<typename _IIter, typename _Tp, typename _IterTag>
     typename iterator_traits<_IIter>::difference_type
-    count_switch(_IIter, _IIter, const T&, _IterTag);
+    count_switch(_IIter, _IIter, const _Tp&, _IterTag);
 
-  template<typename _RAIter, typename T>
+  template<typename _RAIter, typename _Tp>
     typename iterator_traits<_RAIter>::difference_type
-    count_switch(_RAIter, _RAIter, const T&, random_access_iterator_tag,
+    count_switch(_RAIter, _RAIter, const _Tp&, random_access_iterator_tag,
 		 __gnu_parallel::parallelism);
 
 
-  template<typename _IIter, typename Predicate>
+  template<typename _IIter, typename _Predicate>
     typename iterator_traits<_IIter>::difference_type
-    count_if(_IIter, _IIter, Predicate);
+    count_if(_IIter, _IIter, _Predicate);
 
-  template<typename _IIter, typename Predicate>
+  template<typename _IIter, typename _Predicate>
     typename iterator_traits<_IIter>::difference_type
-    count_if(_IIter, _IIter, Predicate, __gnu_parallel::sequential_tag);
+    count_if(_IIter, _IIter, _Predicate, __gnu_parallel::sequential_tag);
 
-  template<typename _IIter, typename Predicate>
+  template<typename _IIter, typename _Predicate>
     typename iterator_traits<_IIter>::difference_type
-    count_if(_IIter, _IIter, Predicate, __gnu_parallel::parallelism);
+    count_if(_IIter, _IIter, _Predicate, __gnu_parallel::parallelism);
 
-  template<typename _IIter, typename Predicate, typename _IterTag>
+  template<typename _IIter, typename _Predicate, typename _IterTag>
     typename iterator_traits<_IIter>::difference_type
-    count_if_switch(_IIter, _IIter, Predicate, _IterTag);
+    count_if_switch(_IIter, _IIter, _Predicate, _IterTag);
 
-  template<typename _RAIter, typename Predicate>
+  template<typename _RAIter, typename _Predicate>
     typename iterator_traits<_RAIter>::difference_type
-    count_if_switch(_RAIter, _RAIter, Predicate, random_access_iterator_tag, 
+    count_if_switch(_RAIter, _RAIter, _Predicate, random_access_iterator_tag,
 		    __gnu_parallel::parallelism);
 
   // algobase.h
@@ -130,7 +130,8 @@ namespace __parallel
 
   template<typename _IIter1, typename _IIter2, typename Predicate>
     bool
-  equal(_IIter1, _IIter1, _IIter2, Predicate, __gnu_parallel::sequential_tag);
+    equal(_IIter1, _IIter1, _IIter2, Predicate,
+	  __gnu_parallel::sequential_tag);
 
   template<typename _IIter1, typename _IIter2>
     bool
@@ -140,45 +141,47 @@ namespace __parallel
     bool
     equal(_IIter1, _IIter1, _IIter2, Predicate);
 
-  template<typename _IIter, typename T>
+  template<typename _IIter, typename _Tp>
     _IIter
-  find(_IIter, _IIter, const T&, __gnu_parallel::sequential_tag);
+    find(_IIter, _IIter, const _Tp&, __gnu_parallel::sequential_tag);
 
-  template<typename _IIter, typename T>
+  template<typename _IIter, typename _Tp>
     _IIter
-  find(_IIter, _IIter, const T& val);
+    find(_IIter, _IIter, const _Tp& val);
 
-  template<typename _IIter, typename T, typename _IterTag>
+  template<typename _IIter, typename _Tp, typename _IterTag>
     _IIter
-  find_switch(_IIter, _IIter, const T&, _IterTag);
+    find_switch(_IIter, _IIter, const _Tp&, _IterTag);
 
-  template<typename _RAIter, typename T>
+  template<typename _RAIter, typename _Tp>
     _RAIter
-  find_switch(_RAIter, _RAIter, const T&, random_access_iterator_tag);
+    find_switch(_RAIter, _RAIter, const _Tp&, random_access_iterator_tag);
 
-  template<typename _IIter, typename Predicate>
+  template<typename _IIter, typename _Predicate>
     _IIter
-  find_if(_IIter, _IIter, Predicate, __gnu_parallel::sequential_tag);
+    find_if(_IIter, _IIter, _Predicate, __gnu_parallel::sequential_tag);
 
-  template<typename _IIter, typename Predicate>
+  template<typename _IIter, typename _Predicate>
     _IIter
-  find_if(_IIter, _IIter, Predicate);
+    find_if(_IIter, _IIter, _Predicate);
 
-  template<typename _IIter, typename Predicate, typename _IterTag>
+  template<typename _IIter, typename _Predicate, typename _IterTag>
     _IIter
-  find_if_switch(_IIter, _IIter, Predicate, _IterTag);
+    find_if_switch(_IIter, _IIter, _Predicate, _IterTag);
 
-  template<typename _RAIter, typename Predicate>
+  template<typename _RAIter, typename _Predicate>
     _RAIter
-  find_if_switch(_RAIter, _RAIter, Predicate, random_access_iterator_tag);
+    find_if_switch(_RAIter, _RAIter, _Predicate, random_access_iterator_tag);
 
   template<typename _IIter, typename _FIter>
     _IIter
-  find_first_of(_IIter, _IIter, _FIter, _FIter, __gnu_parallel::sequential_tag);
+    find_first_of(_IIter, _IIter, _FIter, _FIter,
+		  __gnu_parallel::sequential_tag);
 
   template<typename _IIter, typename _FIter, typename _BiPredicate>
     _IIter
-  find_first_of(_IIter, _IIter, _FIter, _FIter, _BiPredicate, __gnu_parallel::sequential_tag);
+    find_first_of(_IIter, _IIter, _FIter, _FIter, _BiPredicate,
+		  __gnu_parallel::sequential_tag);
 
   template<typename _IIter, typename _FIter, typename _BiPredicate>
     _IIter
@@ -188,131 +191,147 @@ namespace __parallel
     _IIter
     find_first_of(_IIter, _IIter, _FIter, _FIter);
 
-  template<typename _IIter, typename _FIter, typename _IterTag1, typename _IterTag2>
+  template<typename _IIter, typename _FIter,
+	   typename _IterTag1, typename _IterTag2>
     _IIter
     find_first_of_switch(_IIter, _IIter, _FIter, _FIter, _IterTag1, _IterTag2);
 
-  template<typename _RAIter, typename _FIter, typename _BiPredicate, typename _IterTag>
+  template<typename _RAIter, typename _FIter, typename _BiPredicate,
+	   typename _IterTag>
     _RAIter
-  find_first_of_switch(_RAIter, _RAIter, _FIter, _FIter, _BiPredicate, random_access_iterator_tag, _IterTag);
+    find_first_of_switch(_RAIter, _RAIter, _FIter, _FIter, _BiPredicate,
+			 random_access_iterator_tag, _IterTag);
 
-  template<typename _IIter, typename _FIter, typename _BiPredicate, typename _IterTag1, typename _IterTag2>
+  template<typename _IIter, typename _FIter, typename _BiPredicate,
+	   typename _IterTag1, typename _IterTag2>
     _IIter
-  find_first_of_switch(_IIter, _IIter, _FIter, _FIter, _BiPredicate, _IterTag1, _IterTag2);
+    find_first_of_switch(_IIter, _IIter, _FIter, _FIter, _BiPredicate,
+			 _IterTag1, _IterTag2);
 
 
-  template<typename _IIter, typename Function>
-    Function
-    for_each(_IIter, _IIter, Function);
+  template<typename _IIter, typename _Function>
+    _Function
+    for_each(_IIter, _IIter, _Function);
 
-  template<typename _IIter, typename Function>
-    Function
-    for_each(_IIter, _IIter, Function, __gnu_parallel::sequential_tag);
+  template<typename _IIter, typename _Function>
+    _Function
+    for_each(_IIter, _IIter, _Function, __gnu_parallel::sequential_tag);
 
-  template<typename Iterator, typename Function>
-    Function
-    for_each(Iterator, Iterator, Function, __gnu_parallel::parallelism);
+  template<typename _Iterator, typename _Function>
+    _Function
+    for_each(_Iterator, _Iterator, _Function, __gnu_parallel::parallelism);
 
-  template<typename _IIter, typename Function, typename _IterTag>
-    Function
-    for_each_switch(_IIter, _IIter, Function, _IterTag);
+  template<typename _IIter, typename _Function, typename _IterTag>
+    _Function
+    for_each_switch(_IIter, _IIter, _Function, _IterTag);
 
-  template<typename _RAIter, typename Function>
-    Function
-    for_each_switch(_RAIter, _RAIter, Function, random_access_iterator_tag, 
+  template<typename _RAIter, typename _Function>
+    _Function
+    for_each_switch(_RAIter, _RAIter, _Function, random_access_iterator_tag, 
 		    __gnu_parallel::parallelism);
 
 
-  template<typename _FIter, typename Generator>
+  template<typename _FIter, typename _Generator>
     void
-    generate(_FIter, _FIter, Generator);
+    generate(_FIter, _FIter, _Generator);
 
-  template<typename _FIter, typename Generator>
+  template<typename _FIter, typename _Generator>
     void
-    generate(_FIter, _FIter, Generator, __gnu_parallel::sequential_tag);
+    generate(_FIter, _FIter, _Generator, __gnu_parallel::sequential_tag);
 
-  template<typename _FIter, typename Generator>
+  template<typename _FIter, typename _Generator>
     void
-    generate(_FIter, _FIter, Generator, __gnu_parallel::parallelism);
+    generate(_FIter, _FIter, _Generator, __gnu_parallel::parallelism);
 
-  template<typename _FIter, typename Generator, typename _IterTag>
+  template<typename _FIter, typename _Generator, typename _IterTag>
     void
-    generate_switch(_FIter, _FIter, Generator, _IterTag);
+    generate_switch(_FIter, _FIter, _Generator, _IterTag);
 
-  template<typename _RAIter, typename Generator>
+  template<typename _RAIter, typename _Generator>
     void
-    generate_switch(_RAIter, _RAIter, Generator, random_access_iterator_tag, 
+    generate_switch(_RAIter, _RAIter, _Generator, random_access_iterator_tag, 
 		    __gnu_parallel::parallelism);
 
-  template<typename _OIter, typename Size, typename Generator>
+  template<typename _OIter, typename _Size, typename _Generator>
     _OIter
-    generate_n(_OIter, Size, Generator);
+    generate_n(_OIter, _Size, _Generator);
 
-  template<typename _OIter, typename Size, typename Generator>
+  template<typename _OIter, typename _Size, typename _Generator>
     _OIter
-    generate_n(_OIter, Size, Generator, __gnu_parallel::sequential_tag);
+    generate_n(_OIter, _Size, _Generator, __gnu_parallel::sequential_tag);
 
-  template<typename _OIter, typename Size, typename Generator>
+  template<typename _OIter, typename _Size, typename _Generator>
     _OIter
-    generate_n(_OIter, Size, Generator, __gnu_parallel::parallelism);
+    generate_n(_OIter, _Size, _Generator, __gnu_parallel::parallelism);
 
-  template<typename _OIter, typename Size, typename Generator, typename _IterTag>
+  template<typename _OIter, typename _Size, typename _Generator,
+	   typename _IterTag>
     _OIter
-    generate_n_switch(_OIter, Size, Generator, _IterTag);
+    generate_n_switch(_OIter, _Size, _Generator, _IterTag);
 
-  template<typename _RAIter, typename Size, typename Generator>
+  template<typename _RAIter, typename _Size, typename _Generator>
     _RAIter
-    generate_n_switch(_RAIter, Size, Generator, random_access_iterator_tag, 
+    generate_n_switch(_RAIter, _Size, _Generator, random_access_iterator_tag, 
 		      __gnu_parallel::parallelism);
 
   template<typename _IIter1, typename _IIter2>
     bool
-  lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, __gnu_parallel::sequential_tag);
+    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2,
+			    __gnu_parallel::sequential_tag);
 
-  template<typename _IIter1, typename _IIter2, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _Predicate>
     bool
-  lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, Predicate, __gnu_parallel::sequential_tag);
+    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Predicate,
+			    __gnu_parallel::sequential_tag);
 
   template<typename _IIter1, typename _IIter2>
     bool
     lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
 
-  template<typename _IIter1, typename _IIter2, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _Predicate>
     bool
-  lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, Predicate);
+    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Predicate);
 
-  template<typename _IIter1, typename _IIter2, typename Predicate, typename _IterTag1, typename _IterTag2>
+  template<typename _IIter1, typename _IIter2,
+	   typename _Predicate, typename _IterTag1, typename _IterTag2>
     bool
-  lexicographical_compare_switch(_IIter1, _IIter1, _IIter2, _IIter2, Predicate, _IterTag1, _IterTag2);
+    lexicographical_compare_switch(_IIter1, _IIter1, _IIter2, _IIter2,
+				   _Predicate, _IterTag1, _IterTag2);
 
-  template<typename _RAIter1, typename _RAIter2, typename Predicate>
+  template<typename _RAIter1, typename _RAIter2, typename _Predicate>
     bool
-  lexicographical_compare_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, Predicate, random_access_iterator_tag, random_access_iterator_tag);
+    lexicographical_compare_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
+				   _Predicate, random_access_iterator_tag,
+				   random_access_iterator_tag);
 
   // algo.h
   template<typename _IIter1, typename _IIter2>
     pair<_IIter1, _IIter2>
     mismatch(_IIter1, _IIter1, _IIter2, __gnu_parallel::sequential_tag);
 
-  template<typename _IIter1, typename _IIter2, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _Predicate>
     pair<_IIter1, _IIter2>
-  mismatch(_IIter1, _IIter1, _IIter2, Predicate, __gnu_parallel::sequential_tag);
+    mismatch(_IIter1, _IIter1, _IIter2, _Predicate,
+	     __gnu_parallel::sequential_tag);
 
   template<typename _IIter1, typename _IIter2>
     pair<_IIter1, _IIter2>
     mismatch(_IIter1, _IIter1, _IIter2);
 
-  template<typename _IIter1, typename _IIter2, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _Predicate>
     pair<_IIter1, _IIter2>
-  mismatch(_IIter1, _IIter1, _IIter2, Predicate);
+    mismatch(_IIter1, _IIter1, _IIter2, _Predicate);
 
-  template<typename _IIter1, typename _IIter2, typename Predicate, typename _IterTag1, typename _IterTag2>
+  template<typename _IIter1, typename _IIter2, typename _Predicate,
+	   typename _IterTag1, typename _IterTag2>
     pair<_IIter1, _IIter2>
-  mismatch_switch(_IIter1, _IIter1, _IIter2, Predicate, _IterTag1, _IterTag2);
+    mismatch_switch(_IIter1, _IIter1, _IIter2, _Predicate,
+		    _IterTag1, _IterTag2);
 
-  template<typename _RAIter1, typename _RAIter2, typename Predicate>
+  template<typename _RAIter1, typename _RAIter2, typename _Predicate>
     pair<_RAIter1, _RAIter2>
-  mismatch_switch(_RAIter1, _RAIter1, _RAIter2, Predicate, random_access_iterator_tag, random_access_iterator_tag);
+    mismatch_switch(_RAIter1, _RAIter1, _RAIter2, _Predicate,
+		    random_access_iterator_tag, random_access_iterator_tag);
 
   template<typename _FIter1, typename _FIter2>
     _FIter1
@@ -324,7 +343,8 @@ namespace __parallel
 
   template<typename _FIter1, typename _FIter2, typename _BiPredicate>
     _FIter1
-  search(_FIter1, _FIter1, _FIter2, _FIter2, _BiPredicate, __gnu_parallel::sequential_tag);
+    search(_FIter1, _FIter1, _FIter2, _FIter2, _BiPredicate,
+	   __gnu_parallel::sequential_tag);
 
   template<typename _FIter1, typename _FIter2, typename _BiPredicate>
     _FIter1
@@ -332,43 +352,56 @@ namespace __parallel
 
   template<typename _RAIter1, typename _RAIter2>
     _RAIter1
-  search_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, random_access_iterator_tag, random_access_iterator_tag);
+    search_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
+		  random_access_iterator_tag, random_access_iterator_tag);
 
-  template<typename _FIter1, typename _FIter2, typename _IterTag1, typename _IterTag2>
+  template<typename _FIter1, typename _FIter2, typename _IterTag1,
+	   typename _IterTag2>
     _FIter1
     search_switch(_FIter1, _FIter1, _FIter2, _FIter2, _IterTag1, _IterTag2);
 
   template<typename _RAIter1, typename _RAIter2, typename _BiPredicate>
     _RAIter1
-  search_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, _BiPredicate , random_access_iterator_tag, random_access_iterator_tag);
+    search_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, _BiPredicate,
+		  random_access_iterator_tag, random_access_iterator_tag);
 
-  template<typename _FIter1, typename _FIter2, typename _BiPredicate, typename _IterTag1, typename _IterTag2>
+  template<typename _FIter1, typename _FIter2, typename _BiPredicate,
+	   typename _IterTag1, typename _IterTag2>
     _FIter1
-  search_switch(_FIter1, _FIter1, _FIter2, _FIter2, _BiPredicate, _IterTag1, _IterTag2);
+    search_switch(_FIter1, _FIter1, _FIter2, _FIter2, _BiPredicate,
+		  _IterTag1, _IterTag2);
 
-  template<typename _FIter, typename Integer, typename T>
+  template<typename _FIter, typename _Integer, typename _Tp>
     _FIter
-  search_n(_FIter, _FIter, Integer, const T&, __gnu_parallel::sequential_tag);
+    search_n(_FIter, _FIter, _Integer, const _Tp&,
+	     __gnu_parallel::sequential_tag);
 
-  template<typename _FIter, typename Integer, typename T, typename _BiPredicate>
+  template<typename _FIter, typename _Integer, typename _Tp,
+	   typename _BiPredicate>
     _FIter
-  search_n(_FIter, _FIter, Integer, const T&, _BiPredicate, __gnu_parallel::sequential_tag);
+    search_n(_FIter, _FIter, _Integer, const _Tp&, _BiPredicate,
+	     __gnu_parallel::sequential_tag);
     
-  template<typename _FIter, typename Integer, typename T>
+  template<typename _FIter, typename _Integer, typename _Tp>
     _FIter
-  search_n(_FIter, _FIter, Integer, const T& val);
+    search_n(_FIter, _FIter, _Integer, const _Tp&);
 
-  template<typename _FIter, typename Integer, typename T, typename _BiPredicate>
+  template<typename _FIter, typename _Integer, typename _Tp,
+	   typename _BiPredicate>
     _FIter
-  search_n(_FIter, _FIter, Integer, const T&, _BiPredicate);
+    search_n(_FIter, _FIter, _Integer, const _Tp&, _BiPredicate);
 
-  template<typename _RAIter, typename Integer, typename T, typename _BiPredicate>
+  template<typename _RAIter, typename _Integer, typename _Tp,
+	   typename _BiPredicate>
     _RAIter
-  search_n_switch(_RAIter, _RAIter, Integer, const T&, _BiPredicate, random_access_iterator_tag);
+    search_n_switch(_RAIter, _RAIter, _Integer, const _Tp&,
+		    _BiPredicate, random_access_iterator_tag);
 
-  template<typename _FIter, typename Integer, typename T, typename _BiPredicate, typename _IterTag>
+  template<typename _FIter, typename _Integer, typename _Tp,
+	   typename _BiPredicate, typename _IterTag>
     _FIter
-  search_n_switch(_FIter, _FIter, Integer, const T&, _BiPredicate, _IterTag);
+    search_n_switch(_FIter, _FIter, _Integer, const _Tp&,
+		    _BiPredicate, _IterTag);
 
 
   template<typename _IIter, typename _OIter, typename UnaryOperation>
@@ -385,7 +418,8 @@ namespace __parallel
     transform(_IIter, _IIter, _OIter, UnaryOperation, 
 	      __gnu_parallel::parallelism);
 
-  template<typename _IIter, typename _OIter, typename UnaryOperation, typename _IterTag1, typename _IterTag2>
+  template<typename _IIter, typename _OIter, typename UnaryOperation,
+	   typename _IterTag1, typename _IterTag2>
     _OIter
     transform1_switch(_IIter, _IIter, _OIter, UnaryOperation, 
 		      _IterTag1, _IterTag2);
@@ -398,78 +432,87 @@ namespace __parallel
 		      __gnu_parallel::parallelism);
 
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename _BiOperation>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _BiOperation>
     _OIter
     transform(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename _BiOperation>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _BiOperation>
     _OIter
     transform(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation, 
 	      __gnu_parallel::sequential_tag);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename _BiOperation>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _BiOperation>
     _OIter
     transform(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation, 
 	      __gnu_parallel::parallelism);
 
-  template<typename _RAIter1, typename _RAIter2, typename _RAIter3, typename _BiOperation>
+  template<typename _RAIter1, typename _RAIter2, typename _RAIter3,
+	   typename _BiOperation>
     _RAIter3
     transform2_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter3, _BiOperation, 
 		      random_access_iterator_tag, random_access_iterator_tag, 
 		      random_access_iterator_tag, 
 		      __gnu_parallel::parallelism parallelism_tag);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename _BiOperation, typename tag1, typename tag2, typename tag3>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _BiOperation, typename _Tag1,
+	   typename _Tag2, typename _Tag3>
     _OIter
     transform2_switch(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation, 
-		      tag1, tag2, tag3);
+		      _Tag1, _Tag2, _Tag3);
 
 
-  template<typename _FIter, typename T>
+  template<typename _FIter, typename _Tp>
     void
-    replace(_FIter, _FIter, const T&, const T&);
+    replace(_FIter, _FIter, const _Tp&, const _Tp&);
 
-  template<typename _FIter, typename T>
+  template<typename _FIter, typename _Tp>
     void
-    replace(_FIter, _FIter, const T&, const T&, 
+    replace(_FIter, _FIter, const _Tp&, const _Tp&, 
 	    __gnu_parallel::sequential_tag);
 
-  template<typename _FIter, typename T>
+  template<typename _FIter, typename _Tp>
     void
-    replace(_FIter, _FIter, const T&, const T&, __gnu_parallel::parallelism);
+    replace(_FIter, _FIter, const _Tp&, const _Tp&,
+	    __gnu_parallel::parallelism);
 
-  template<typename _FIter, typename T, typename _IterTag>
+  template<typename _FIter, typename _Tp, typename _IterTag>
     void
-    replace_switch(_FIter, _FIter, const T&, const T&, _IterTag);
+    replace_switch(_FIter, _FIter, const _Tp&, const _Tp&, _IterTag);
 
-  template<typename _RAIter, typename T>
+  template<typename _RAIter, typename _Tp>
     void
-    replace_switch(_RAIter, _RAIter, const T&, const T&, 
+    replace_switch(_RAIter, _RAIter, const _Tp&, const _Tp&, 
 		   random_access_iterator_tag, __gnu_parallel::parallelism);
 
 
-  template<typename _FIter, typename Predicate, typename T>
+  template<typename _FIter, typename _Predicate, typename _Tp>
     void
-    replace_if(_FIter, _FIter, Predicate, const T&);
+    replace_if(_FIter, _FIter, _Predicate, const _Tp&);
 
-  template<typename _FIter, typename Predicate, typename T>
+  template<typename _FIter, typename _Predicate, typename _Tp>
     void
-    replace_if(_FIter, _FIter, Predicate, const T&, 
+    replace_if(_FIter, _FIter, _Predicate, const _Tp&,
 	       __gnu_parallel::sequential_tag);
 
-  template<typename _FIter, typename Predicate, typename T>
+  template<typename _FIter, typename _Predicate, typename _Tp>
     void
-    replace_if(_FIter, _FIter, Predicate, const T&, 
+    replace_if(_FIter, _FIter, _Predicate, const _Tp&,
 	       __gnu_parallel::parallelism);
 
-  template<typename _FIter, typename Predicate, typename T, typename _IterTag>
+  template<typename _FIter, typename _Predicate, typename _Tp,
+	   typename _IterTag>
     void
-    replace_if_switch(_FIter, _FIter, Predicate, const T&, _IterTag);
+    replace_if_switch(_FIter, _FIter, _Predicate, const _Tp&, _IterTag);
  
-  template<typename _RAIter, typename Predicate, typename T>
+  template<typename _RAIter, typename _Predicate, typename _Tp>
     void
-    replace_if_switch(_RAIter, _RAIter, Predicate, const T&, 
-		      random_access_iterator_tag, __gnu_parallel::parallelism);
+    replace_if_switch(_RAIter, _RAIter, _Predicate, const _Tp&,
+		      random_access_iterator_tag,
+		      __gnu_parallel::parallelism);
 
 
   template<typename _FIter>
@@ -511,12 +554,14 @@ namespace __parallel
     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, 
 	  __gnu_parallel::sequential_tag);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename _Compare>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Compare>
     _OIter
     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare, 
 	  __gnu_parallel::sequential_tag);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename _Compare>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Compare>
     _OIter
     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 
@@ -524,12 +569,15 @@ namespace __parallel
     _OIter
     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename _Compare, typename _IterTag1, typename _IterTag2, typename _IterTag3>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Compare, typename _IterTag1, typename _IterTag2,
+	   typename _IterTag3>
     _OIter
     merge_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare, 
 		 _IterTag1, _IterTag2, _IterTag3);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename _Compare>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Compare>
     _OIter
     merge_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare, 
 		 random_access_iterator_tag, random_access_iterator_tag, 
@@ -575,7 +623,8 @@ namespace __parallel
 
   template<typename _RAIter, typename _Compare>
     void
-  nth_element(_RAIter, _RAIter, _RAIter, _Compare, __gnu_parallel::sequential_tag);
+    nth_element(_RAIter, _RAIter, _RAIter, _Compare,
+		__gnu_parallel::sequential_tag);
 
   template<typename _RAIter, typename _Compare>
     void
@@ -587,7 +636,8 @@ namespace __parallel
 
   template<typename _RAIter, typename _Compare>
     void
-  partial_sort(_RAIter, _RAIter, _RAIter, _Compare, __gnu_parallel::sequential_tag);
+    partial_sort(_RAIter, _RAIter, _RAIter, _Compare,
+		 __gnu_parallel::sequential_tag);
 
   template<typename _RAIter>
     void
@@ -621,114 +671,163 @@ namespace __parallel
     void
     random_shuffle(_RAIter, _RAIter, __gnu_parallel::sequential_tag);
 
-  template<typename _RAIter, typename RandomNumberGenerator>
+  template<typename _RAIter, typename _RandomNumberGenerator>
     void
-  random_shuffle(_RAIter, _RAIter, RandomNumberGenerator& rand, __gnu_parallel::sequential_tag);
+    random_shuffle(_RAIter, _RAIter, _RandomNumberGenerator&,
+		   __gnu_parallel::sequential_tag);
 
   template<typename _RAIter>
     void
     random_shuffle(_RAIter, _RAIter);
 
-  template<typename _RAIter, typename RandomNumberGenerator>
+  template<typename _RAIter, typename _RandomNumberGenerator>
     void
-  random_shuffle(_RAIter, _RAIter, RandomNumberGenerator& rand);
+    random_shuffle(_RAIter, _RAIter, _RandomNumberGenerator&);
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
     _OIter
-  set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, __gnu_parallel::sequential_tag);
+    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+	    __gnu_parallel::sequential_tag);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename Predicate>
     _OIter
-  set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate, __gnu_parallel::sequential_tag);
+    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate,
+	      __gnu_parallel::sequential_tag);
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
     _OIter
     set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Predicate>
     _OIter 
-  set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate);
+    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate);
 
-  template<typename _IIter1, typename _IIter2, typename Predicate, typename _OIter, typename _IterTag1, typename _IterTag2, typename _IterTag3>
+  template<typename _IIter1, typename _IIter2, typename _Predicate,
+	   typename _OIter, typename _IterTag1, typename _IterTag2,
+	   typename _IterTag3>
     _OIter
-  set_union_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate, _IterTag1, _IterTag2, _IterTag3);
+    set_union_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+		     _Predicate, _IterTag1, _IterTag2, _IterTag3);
 
-  template<typename _RAIter1, typename _RAIter2, typename Output_RAIter, typename Predicate>
-  Output_RAIter 
-  set_union_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, Output_RAIter, Predicate, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag);
+  template<typename _RAIter1, typename _RAIter2, typename _Output_RAIter,
+	   typename _Predicate>
+    _Output_RAIter
+    set_union_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, _Output_RAIter,
+		     _Predicate, random_access_iterator_tag,
+		     random_access_iterator_tag, random_access_iterator_tag);
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
     _OIter
-  set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, __gnu_parallel::sequential_tag);
+    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+		     __gnu_parallel::sequential_tag);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Predicate>
     _OIter
-  set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate, __gnu_parallel::sequential_tag);
+    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate,
+		     __gnu_parallel::sequential_tag);
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
     _OIter
     set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Predicate>
     _OIter 
-  set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate);
+    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate);
 
-  template<typename _IIter1, typename _IIter2, typename Predicate, typename _OIter, typename _IterTag1, typename _IterTag2, typename _IterTag3>
+  template<typename _IIter1, typename _IIter2, typename _Predicate,
+	   typename _OIter, typename _IterTag1, typename _IterTag2,
+	   typename _IterTag3>
     _OIter
-  set_intersection_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate, _IterTag1, _IterTag2, _IterTag3);
+    set_intersection_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+			    _Predicate, _IterTag1, _IterTag2, _IterTag3);
 
-  template<typename _RAIter1, typename _RAIter2, typename Output_RAIter, typename Predicate>
-  Output_RAIter 
-  set_intersection_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, Output_RAIter, Predicate, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag);
+  template<typename _RAIter1, typename _RAIter2, typename _Output_RAIter,
+	   typename _Predicate>
+    _Output_RAIter
+    set_intersection_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
+			    _Output_RAIter, _Predicate,
+			    random_access_iterator_tag,
+			    random_access_iterator_tag,
+			    random_access_iterator_tag);
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
     _OIter
-  set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, __gnu_parallel::sequential_tag);
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+			     __gnu_parallel::sequential_tag);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Predicate>
     _OIter
-  set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate, __gnu_parallel::sequential_tag);
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+			     _Predicate, __gnu_parallel::sequential_tag);
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
     _OIter 
     set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Predicate>
     _OIter 
-  set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate);
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+			     _Predicate);
 
-  template<typename _IIter1, typename _IIter2, typename Predicate, typename _OIter, typename _IterTag1, typename _IterTag2, typename _IterTag3>
+  template<typename _IIter1, typename _IIter2, typename _Predicate,
+	   typename _OIter, typename _IterTag1, typename _IterTag2,
+	   typename _IterTag3>
     _OIter
-  set_symmetric_difference_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate, _IterTag1, _IterTag2, _IterTag3);
+    set_symmetric_difference_switch(_IIter1, _IIter1, _IIter2, _IIter2,
+				    _OIter, _Predicate, _IterTag1, _IterTag2,
+				    _IterTag3);
 
-  template<typename _RAIter1, typename _RAIter2, typename Output_RAIter, typename Predicate>
-  Output_RAIter 
-  set_symmetric_difference_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, Output_RAIter, Predicate, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag);
+  template<typename _RAIter1, typename _RAIter2, typename _Output_RAIter,
+	   typename _Predicate>
+    _Output_RAIter
+    set_symmetric_difference_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
+				    _Output_RAIter, _Predicate,
+				    random_access_iterator_tag,
+				    random_access_iterator_tag,
+				    random_access_iterator_tag);
 
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
     _OIter
-  set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, __gnu_parallel::sequential_tag);
+    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+		   __gnu_parallel::sequential_tag);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Predicate>
     _OIter
-  set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate, __gnu_parallel::sequential_tag);
+    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate,
+		   __gnu_parallel::sequential_tag);
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
     _OIter
     set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 
-  template<typename _IIter1, typename _IIter2, typename _OIter, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+	   typename _Predicate>
     _OIter
-  set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate);
+    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate);
 
-  template<typename _IIter1, typename _IIter2, typename Predicate, typename _OIter, typename _IterTag1, typename _IterTag2, typename _IterTag3>
+  template<typename _IIter1, typename _IIter2, typename _Predicate,
+	   typename _OIter, typename _IterTag1, typename _IterTag2,
+	   typename _IterTag3>
     _OIter
-  set_difference_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate, _IterTag1, _IterTag2, _IterTag3);
+    set_difference_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+			  _Predicate, _IterTag1, _IterTag2, _IterTag3);
 
-  template<typename _RAIter1, typename _RAIter2, typename Output_RAIter, typename Predicate>
-  Output_RAIter
-  set_difference_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, Output_RAIter, Predicate, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag);
+  template<typename _RAIter1, typename _RAIter2, typename _Output_RAIter,
+	   typename _Predicate>
+    _Output_RAIter
+    set_difference_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
+			  _Output_RAIter, _Predicate,
+			  random_access_iterator_tag,
+			  random_access_iterator_tag,
+			  random_access_iterator_tag);
 
 
   template<typename _RAIter>
@@ -767,25 +866,28 @@ namespace __parallel
     _OIter
     unique_copy(_IIter, _IIter, _OIter, __gnu_parallel::sequential_tag);
 
-  template<typename _IIter, typename _OIter, typename Predicate>
+  template<typename _IIter, typename _OIter, typename _Predicate>
     _OIter
-  unique_copy(_IIter, _IIter, _OIter, Predicate, __gnu_parallel::sequential_tag);
+    unique_copy(_IIter, _IIter, _OIter, _Predicate,
+		__gnu_parallel::sequential_tag);
 
   template<typename _IIter, typename _OIter>
     _OIter
     unique_copy(_IIter, _IIter, _OIter);
 
-  template<typename _IIter, typename _OIter, typename Predicate>
+  template<typename _IIter, typename _OIter, typename _Predicate>
     _OIter
-  unique_copy(_IIter, _IIter, _OIter, Predicate);
+    unique_copy(_IIter, _IIter, _OIter, _Predicate);
 
-  template<typename _IIter, typename _OIter, typename Predicate, typename _IterTag1, typename _IterTag2>
+  template<typename _IIter, typename _OIter, typename _Predicate,
+	   typename _IterTag1, typename _IterTag2>
     _OIter
-  unique_copy_switch(_IIter, _IIter, _OIter, Predicate, _IterTag1, _IterTag2);
+    unique_copy_switch(_IIter, _IIter, _OIter, _Predicate,
+		       _IterTag1, _IterTag2);
 
-  template<typename _RAIter, typename RandomAccess_OIter, typename Predicate>
-  RandomAccess_OIter
-  unique_copy_switch(_RAIter, _RAIter, RandomAccess_OIter, Predicate, 
+  template<typename _RAIter, typename _RandomAccess_OIter, typename _Predicate>
+    _RandomAccess_OIter
+    unique_copy_switch(_RAIter, _RAIter, _RandomAccess_OIter, _Predicate,
 		       random_access_iterator_tag, random_access_iterator_tag);
 } // end namespace __parallel
 } // end namespace std

libstdc++-v3/include/parallel/balanced_quicksort.h

 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 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 terms
@@ -102,7 +102,7 @@ template<typename RandomAccessIterator>
   *  this part.
   *  @pre @c (end-begin)>=1 */
 template<typename RandomAccessIterator, typename Comparator>
-  inline typename std::iterator_traits<RandomAccessIterator>::difference_type
+  typename std::iterator_traits<RandomAccessIterator>::difference_type
   qsb_divide(RandomAccessIterator begin, RandomAccessIterator end,
              Comparator comp, thread_index_t num_threads)
   {
@@ -164,7 +164,7 @@ template<typename RandomAccessIterator, typename Comparator>
   *  @param num_threads
   *          Number of threads that are allowed to work on this part. */
 template<typename RandomAccessIterator, typename Comparator>
-  inline void
+  void
   qsb_conquer(QSBThreadLocal<RandomAccessIterator>** tls,
               RandomAccessIterator begin, RandomAccessIterator end,
               Comparator comp,
@@ -240,7 +240,7 @@ template<typename RandomAccessIterator, typename Comparator>
   *  @param iam Number of the thread processing this function.
   */
 template<typename RandomAccessIterator, typename Comparator>
-  inline void
+  void
   qsb_local_sort_with_helping(QSBThreadLocal<RandomAccessIterator>** tls,
                               Comparator& comp, int iam, bool wait)
   {
@@ -418,7 +418,7 @@ template<typename RandomAccessIterator, typename Comparator>
   *  this part.
   */
 template<typename RandomAccessIterator, typename Comparator>
-  inline void
+  void
   parallel_sort_qsb(RandomAccessIterator begin, RandomAccessIterator end,
                     Comparator comp,
                     typename std::iterator_traits<RandomAccessIterator>

libstdc++-v3/include/parallel/checkers.h

 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 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 terms
@@ -54,7 +54,10 @@ namespace __gnu_parallel
   // XXX Comparator default template argument
   template<typename InputIterator, typename Comparator>
     bool
-  is_sorted(InputIterator begin, InputIterator end, Comparator comp = std::less<typename std::iterator_traits<InputIterator>::value_type>())
+    is_sorted(InputIterator begin, InputIterator end,
+	      Comparator comp
+	      = std::less<typename std::iterator_traits<InputIterator>::
+	      value_type>())
     {
       if (begin == end)
 	return true;
@@ -66,7 +69,8 @@ namespace __gnu_parallel
 	{
 	  if (comp(*current, *recent))
 	    {
-	    printf("is_sorted: check failed before position %i.\n", position);
+	      printf("is_sorted: check failed before position %i.\n",
+		     position);
 	      return false;
 	    }
 	  recent = current;
@@ -88,7 +92,11 @@ namespace __gnu_parallel
   // XXX Comparator default template argument
   template<typename InputIterator, typename Comparator>
     bool
-  is_sorted_failure(InputIterator begin, InputIterator end, InputIterator& first_failure, Comparator comp = std::less<typename std::iterator_traits<InputIterator>::value_type>())
+    is_sorted_failure(InputIterator begin, InputIterator end,
+		      InputIterator& first_failure,
+		      Comparator comp
+		      = std::less<typename std::iterator_traits<InputIterator>::
+		      value_type>())
     {
       if (begin == end)
 	return true;
@@ -101,7 +109,8 @@ namespace __gnu_parallel
 	  if (comp(*current, *recent))
 	    {
 	      first_failure = current;
-	    printf("is_sorted: check failed before position %lld.\n", position);
+	      printf("is_sorted: check failed before position %lld.\n",
+		     position);
 	      return false;
 	    }
 	  recent = current;
@@ -123,7 +132,10 @@ namespace __gnu_parallel
   template<typename InputIterator, typename Comparator>
     bool
     // XXX Comparator default template argument
-  is_sorted_print_failures(InputIterator begin, InputIterator end, Comparator comp = std::less<typename std::iterator_traits<InputIterator>::value_type>())
+    is_sorted_print_failures(InputIterator begin, InputIterator end,
+			     Comparator comp
+			     = std::less<typename std::iterator_traits
+			     <InputIterator>::value_type>())
     {
       if (begin == end)
 	return true;

libstdc++-v3/include/parallel/find.h

 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 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 terms
@@ -58,8 +58,7 @@ namespace __gnu_parallel
  *  @param selector Functionality (e. g. std::find_if (), std::equal(),...)
  *  @return Place of finding in both sequences.
  */
-template<
-    typename RandomAccessIterator1,
+template<typename RandomAccessIterator1,
 	 typename RandomAccessIterator2,
 	 typename Pred,
 	 typename Selector>
@@ -96,8 +95,7 @@ template<
  *  @param selector Functionality (e. g. std::find_if (), std::equal(),...)
  *  @return Place of finding in both sequences.
  */
-template<
-    typename RandomAccessIterator1,
+template<typename RandomAccessIterator1,
 	 typename RandomAccessIterator2,
 	 typename Pred,
 	 typename Selector>
@@ -190,8 +188,7 @@ template<
  *     for CSB, the blocks are allocated in a predetermined manner,
  *     namely spacial round-robin.
  */
-template<
-    typename RandomAccessIterator1,
+template<typename RandomAccessIterator1,
 	 typename RandomAccessIterator2,
 	 typename Pred,
 	 typename Selector>
@@ -311,8 +308,7 @@ template<
  *  blocks are allocated in a predetermined manner, namely spacial
  *  round-robin.
  */
-template<
-    typename RandomAccessIterator1,
+template<typename RandomAccessIterator1,
 	 typename RandomAccessIterator2,
 	 typename Pred,
 	 typename Selector>

libstdc++-v3/include/parallel/find_selectors.h

 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 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 terms
@@ -60,8 +60,9 @@ namespace __gnu_parallel
      * @param i2 Iterator on second sequence (unused).
      * @param pred Find predicate.
      */
-    template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Pred>
-    inline bool 
+    template<typename RandomAccessIterator1, typename RandomAccessIterator2,
+	     typename Pred>
+      bool 
       operator()(RandomAccessIterator1 i1, RandomAccessIterator2 i2, Pred pred)
       { return pred(*i1); }
 
@@ -71,12 +72,14 @@ namespace __gnu_parallel
      *  @param begin2 Begin iterator of second sequence.
      *  @param pred Find predicate.
      */
-    template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Pred>
-    inline std::pair<RandomAccessIterator1, RandomAccessIterator2> 
-    sequential_algorithm(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, RandomAccessIterator2 begin2, Pred pred)
-    {
-      return std::make_pair(find_if(begin1, end1, pred, sequential_tag()), begin2);
-    }
+    template<typename RandomAccessIterator1, typename RandomAccessIterator2,
+	     typename Pred>
+      std::pair<RandomAccessIterator1, RandomAccessIterator2> 
+      sequential_algorithm(RandomAccessIterator1 begin1,
+			   RandomAccessIterator1 end1,
+			   RandomAccessIterator2 begin2, Pred pred)
+      { return std::make_pair(find_if(begin1, end1, pred,
+				      sequential_tag()), begin2); }
   };
 
   /** @brief Test predicate on two adjacent elements. */
@@ -87,8 +90,9 @@ namespace __gnu_parallel
      *  @param i2 Iterator on second sequence (unused).
      *  @param pred Find predicate.
      */
-    template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Pred>
-    inline bool 
+    template<typename RandomAccessIterator1, typename RandomAccessIterator2,
+	     typename Pred>
+      bool 
       operator()(RandomAccessIterator1 i1, RandomAccessIterator2 i2, Pred pred)
       {
 	// Passed end iterator is one short.
@@ -101,12 +105,16 @@ namespace __gnu_parallel
      *  @param begin2 Begin iterator of second sequence.
      *  @param pred Find predicate.
      */
-    template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Pred>
-    inline std::pair<RandomAccessIterator1, RandomAccessIterator2>
-    sequential_algorithm(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, RandomAccessIterator2 begin2, Pred pred)
+    template<typename RandomAccessIterator1, typename RandomAccessIterator2,
+	     typename Pred>
+      std::pair<RandomAccessIterator1, RandomAccessIterator2>
+      sequential_algorithm(RandomAccessIterator1 begin1,
+			   RandomAccessIterator1 end1,
+			   RandomAccessIterator2 begin2, Pred pred)
       {
 	// Passed end iterator is one short.
-      RandomAccessIterator1 spot = adjacent_find(begin1, end1 + 1, pred, sequential_tag());
+	RandomAccessIterator1 spot = adjacent_find(begin1, end1 + 1,
+						   pred, sequential_tag());
 	if (spot == (end1 + 1))
 	  spot = end1;
 	return std::make_pair(spot, begin2);
@@ -122,8 +130,9 @@ namespace __gnu_parallel
      *  @param i2 Iterator on second sequence (unused).
      *  @param pred Find predicate. 
      */
-    template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Pred>
-    inline bool 
+    template<typename RandomAccessIterator1, typename RandomAccessIterator2,
+	     typename Pred>
+      bool 
       operator()(RandomAccessIterator1 i1, RandomAccessIterator2 i2, Pred pred)
       { return !pred(*i1, *i2); }
 
@@ -134,12 +143,13 @@ namespace __gnu_parallel
      *  @param begin2 Begin iterator of second sequence.
      *  @param pred Find predicate. 
      */
-    template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Pred>
-    inline std::pair<RandomAccessIterator1, RandomAccessIterator2>
-    sequential_algorithm(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, RandomAccessIterator2 begin2, Pred pred)
-    { 
-      return mismatch(begin1, end1, begin2, pred, sequential_tag()); 
-    }
+    template<typename RandomAccessIterator1, typename RandomAccessIterator2,
+	     typename Pred>
+      std::pair<RandomAccessIterator1, RandomAccessIterator2>
+      sequential_algorithm(RandomAccessIterator1 begin1,
+			   RandomAccessIterator1 end1,
+			   RandomAccessIterator2 begin2, Pred pred)
+      { return mismatch(begin1, end1, begin2, pred, sequential_tag()); }
   };
 
 
@@ -157,11 +167,13 @@ namespace __gnu_parallel
      *  @param i1 Iterator on first sequence.
      *  @param i2 Iterator on second sequence (unused).
      *  @param pred Find predicate. */
-    template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Pred>
-    inline bool 
+    template<typename RandomAccessIterator1, typename RandomAccessIterator2,
+	     typename Pred>
+      bool 
       operator()(RandomAccessIterator1 i1, RandomAccessIterator2 i2, Pred pred)
       {
-      for (ForwardIterator pos_in_candidates = begin; pos_in_candidates != end; pos_in_candidates++)
+	for (ForwardIterator pos_in_candidates = begin;
+	     pos_in_candidates != end; ++pos_in_candidates)
 	  if (pred(*i1, *pos_in_candidates))
 	    return true;
 	return false;
@@ -172,12 +184,14 @@ namespace __gnu_parallel
      *  @param end1 End iterator of first sequence.
      *  @param begin2 Begin iterator of second sequence.
      *  @param pred Find predicate. */
-    template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Pred>
-    inline std::pair<RandomAccessIterator1, RandomAccessIterator2>
-    sequential_algorithm(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, RandomAccessIterator2 begin2, Pred pred)
-    {
-      return std::make_pair(find_first_of(begin1, end1, begin, end, pred, sequential_tag()), begin2);
-    }
+    template<typename RandomAccessIterator1, typename RandomAccessIterator2,
+	     typename Pred>
+      std::pair<RandomAccessIterator1, RandomAccessIterator2>
+      sequential_algorithm(RandomAccessIterator1 begin1,
+			   RandomAccessIterator1 end1,
+			   RandomAccessIterator2 begin2, Pred pred)
+      { return std::make_pair(find_first_of(begin1, end1, begin, end, pred,
+					    sequential_tag()), begin2); }
   };
 }
 

libstdc++-v3/include/parallel/for_each.h

 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 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 terms
@@ -61,22 +61,42 @@ namespace __gnu_parallel
    *  @param output Output iterator.
    *  @param bound Maximum number of elements processed.
    *  @param parallelism_tag Parallelization method */
-  template<typename InputIterator, typename UserOp, typename Functionality, typename Red, typename Result>
+  template<typename InputIterator, typename UserOp,
+	   typename Functionality, typename Red, typename Result>
     UserOp
     for_each_template_random_access(InputIterator begin, InputIterator end,
-				  UserOp user_op, Functionality& functionality,
+				    UserOp user_op,
+				    Functionality& functionality,
 				    Red reduction, Result reduction_start,
-				  Result& output,
-				  typename std::iterator_traits<InputIterator>::difference_type bound, parallelism parallelism_tag)
+				    Result& output, typename
+				    std::iterator_traits<InputIterator>::
+				    difference_type bound,
+				    parallelism parallelism_tag)
     {
       if (parallelism_tag == parallel_unbalanced)
-      return for_each_template_random_access_ed(begin, end, user_op, functionality, reduction, reduction_start, output, bound);
+	return for_each_template_random_access_ed(begin, end, user_op,
+						  functionality, reduction,
+						  reduction_start,
+						  output, bound);
       else if (parallelism_tag == parallel_omp_loop)
-      return for_each_template_random_access_omp_loop(begin, end, user_op, functionality, reduction, reduction_start, output, bound);
+	return for_each_template_random_access_omp_loop(begin, end, user_op,
+							functionality,
+							reduction,
+							reduction_start,
+							output, bound);
       else if (parallelism_tag == parallel_omp_loop_static)
-      return for_each_template_random_access_omp_loop(begin, end, user_op, functionality, reduction, reduction_start, output, bound);
+	return for_each_template_random_access_omp_loop(begin, end, user_op,
+							functionality,
+							reduction,
+							reduction_start,
+							output, bound);
       else	//e. g. parallel_balanced
-      return for_each_template_random_access_workstealing(begin, end, user_op, functionality, reduction, reduction_start, output, bound);
+	return for_each_template_random_access_workstealing(begin, end,
+							    user_op,
+							    functionality,
+							    reduction,
+							    reduction_start,
+							    output, bound);
   }
 }
 

libstdc++-v3/include/parallel/for_each_selectors.h

 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 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 terms
@@ -63,7 +63,8 @@ namespace __gnu_parallel
      *  @param o Operator.
      *  @param i Iterator referencing object. */
     template<typename Op>
-    inline bool operator()(Op& o, It i)
+      bool
+      operator()(Op& o, It i)
       {
 	o(*i);
 	return true;
@@ -78,7 +79,8 @@ namespace __gnu_parallel
      *  @param o Operator.
      *  @param i Iterator referencing object. */
     template<typename Op>
-    inline bool operator()(Op& o, It i)
+      bool
+      operator()(Op& o, It i)
       {
 	*i = o();
 	return true;
@@ -93,7 +95,8 @@ namespace __gnu_parallel
      *  @param v Current value.
      *  @param i Iterator referencing object. */
     template<typename Val>
-    inline bool operator()(Val& v, It i)
+      bool
+      operator()(Val& v, It i)
       {
 	*i = v;
 	return true;
@@ -108,7 +111,8 @@ namespace __gnu_parallel
      *  @param o Operator.
      *  @param i Iterator referencing object. */
     template<typename Op>
-    inline bool operator()(Op& o, It i)
+      bool
+      operator()(Op& o, It i)
       {
 	*i.second = o(*i.first);
 	return true;
@@ -123,7 +127,8 @@ namespace __gnu_parallel
      *  @param o Operator.
      *  @param i Iterator referencing object. */
     template<typename Op>
-    inline bool operator()(Op& o, It i)
+      bool
+      operator()(Op& o, It i)
       {
 	*i.third = o(*i.first, *i.second);
 	return true;
@@ -144,7 +149,8 @@ namespace __gnu_parallel
     /** @brief Functor execution.
      *  @param v Current value.
      *  @param i Iterator referencing object. */
-    inline bool operator()(T& v, It i)
+    bool
+    operator()(T& v, It i)
     {
       if (*i == v)
 	*i = new_val;
@@ -166,7 +172,8 @@ namespace __gnu_parallel
     /** @brief Functor execution.
      *  @param o Operator.
      *  @param i Iterator referencing object. */
-    inline bool operator()(Op& o, It i)
+    bool
+    operator()(Op& o, It i)
     {
       if (o(*i))
 	*i = new_val;
@@ -183,7 +190,8 @@ namespace __gnu_parallel
      *  @param i Iterator referencing object.
      *  @return 1 if count, 0 if does not count. */
     template<typename Val>
-    inline Diff operator()(Val& v, It i)
+      Diff
+      operator()(Val& v, It i)
       { return (v == *i) ? 1 : 0; }
   };
 
@@ -196,7 +204,8 @@ namespace __gnu_parallel
      *  @param i Iterator referencing object.
      *  @return 1 if count, 0 if does not count. */
     template<typename Op>
-    inline Diff operator()(Op& o, It i)
+      Diff
+      operator()(Op& o, It i)
       { return (o(*i)) ? 1 : 0; }
   };
 
@@ -209,7 +218,7 @@ namespace __gnu_parallel
      *  @param i Iterator referencing object.
      *  @return The current value. */
     template<typename Op>
-    inline typename std::iterator_traits<It>::value_type operator()(Op o, It i)
+      typename std::iterator_traits<It>::value_type operator()(Op o, It i)
       { return *i; }
   };
 
@@ -226,16 +235,19 @@ namespace __gnu_parallel
     /** @brief Constructor.
      *  @param b1 Begin iterator of first sequence.
      *  @param b2 Begin iterator of second sequence. */
-    explicit inner_product_selector(It b1, It2 b2) : begin1_iterator(b1), begin2_iterator(b2) { }
+    explicit inner_product_selector(It b1, It2 b2)
+    : begin1_iterator(b1), begin2_iterator(b2) { }
 
     /** @brief Functor execution.
      *  @param mult Multiplication functor.
      *  @param current Iterator referencing object.
      *  @return Inner product elemental result. */
     template<typename Op>
-    inline T operator()(Op mult, It current)
+      T
+      operator()(Op mult, It current)
       {
-      typename std::iterator_traits<It>::difference_type position = current - begin1_iterator;
+	typename std::iterator_traits<It>::difference_type position
+	  = current - begin1_iterator;
 	return mult(*current, *(begin2_iterator + position));
       }
   };
@@ -249,7 +261,8 @@ namespace __gnu_parallel
      *  @param i Iterator referencing object.
      *  @return Passed iterator. */
     template<typename Op>
-    inline It operator()(Op o, It i)
+      It
+      operator()(Op o, It i)
       { return i; }
   };
 
@@ -260,7 +273,8 @@ namespace __gnu_parallel
   struct adjacent_difference_selector : public generic_for_each_selector<It>
   {
     template<typename Op>
-    inline bool operator()(Op& o, It i)
+      bool
+      operator()(Op& o, It i)
       {
 	typename It::first_type go_back_one = i.first;
 	--go_back_one;
@@ -280,14 +294,15 @@ namespace __gnu_parallel
     /** @brief Functor execution.
      *  @param i Iterator referencing object. */
     template<typename It>
-    inline void operator()(It i)
-    { }
+      void
+      operator()(It i) { }
   };
 
   /** @brief Reduction function doing nothing. */
   struct dummy_reduct
   {
-    inline bool operator()(bool /*x*/, bool /*y*/) const
+    bool
+    operator()(bool /*x*/, bool /*y*/) const
     { return true; }
   };
 
@@ -300,7 +315,8 @@ namespace __gnu_parallel
     explicit min_element_reduct(Comp &c) : comp(c)
     { }
 
-    inline It operator()(It x, It y)
+    It
+    operator()(It x, It y)
     {
       if (comp(*x, *y))
 	return x;
@@ -318,7 +334,8 @@ namespace __gnu_parallel
     explicit max_element_reduct(Comp& c) : comp(c)
     { }
 
-    inline It operator()(It x, It y)
+    It
+    operator()(It x, It y)
     {
       if (comp(*x, *y))
 	return y;
@@ -336,7 +353,9 @@ namespace __gnu_parallel
     explicit accumulate_binop_reduct(BinOp& b) : binop(b) {}
 
     template<typename Result, typename Addend>
-    Result operator()(const Result& x, const Addend& y) { return binop(x, y); }
+      Result
+      operator()(const Result& x, const Addend& y)
+      { return binop(x, y); }
   };
 }
 

libstdc++-v3/include/parallel/iterator.h

 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 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 terms
@@ -120,11 +120,13 @@ namespace __gnu_parallel
   /** @brief A triple of iterators. The usual iterator operations are
       applied to all three child iterators.
    */
-  template<typename Iterator1, typename Iterator2, typename Iterator3, typename IteratorCategory>
+  template<typename Iterator1, typename Iterator2, typename Iterator3,
+	   typename IteratorCategory>
     class iterator_triple
     {
     private:
-    typedef iterator_triple<Iterator1, Iterator2, Iterator3, IteratorCategory> type;
+      typedef iterator_triple<Iterator1, Iterator2, Iterator3,
+			      IteratorCategory> type;
 
     public:
       typedef IteratorCategory iterator_category;

libstdc++-v3/include/parallel/list_partition.h

 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 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 terms
@@ -53,13 +53,13 @@ namespace __gnu_parallel
    */
   template<typename InputIterator>
     void
-  shrink_and_double(std::vector<InputIterator>& os_starts, size_t& count_to_two, size_t& range_length, const bool make_twice)
+    shrink_and_double(std::vector<InputIterator>& os_starts,
+		      size_t& count_to_two, size_t& range_length,
+		      const bool make_twice)
     {
       ++count_to_two;
       if (not make_twice or count_to_two < 2)
-      {
 	shrink(os_starts, count_to_two, range_length);
-      }
       else
 	{
 	  os_starts.resize((os_starts.size() - 1) * 2 + 1);
@@ -76,10 +76,9 @@ namespace __gnu_parallel
     shrink(std::vector<InputIterator>& os_starts, size_t& count_to_two,
 	   size_t& range_length)
     {
-    for (typename std::vector<InputIterator>::size_type i = 0; i <= (os_starts.size() / 2); ++i)
-      {
+      for (typename std::vector<InputIterator>::size_type i = 0;
+	   i <= (os_starts.size() / 2); ++i)
 	os_starts[i] = os_starts[i * 2];
-      }
       range_length *= 2;
     }
 
@@ -125,11 +124,13 @@ namespace __gnu_parallel
       size_t cur = 1, next = 1;
       size_t range_length = 1;
       size_t count_to_two = 0;
-    while (it != end){
+      while (it != end)
+	{
 	  cur = next;
 	  for (; cur < os_starts.size() and it != end; ++cur)
 	    {
-	  for (dist_limit += range_length; dist < dist_limit and it != end; ++dist)
+	      for (dist_limit += range_length;
+		   dist < dist_limit and it != end; ++dist)
 		{
 		  f(it);
 		  ++it;
@@ -143,7 +144,7 @@ namespace __gnu_parallel
 	    break;
 
 	  shrink_and_double(os_starts, count_to_two, range_length, make_twice);
-      next = os_starts.size()/2 + 1;
+	  next = os_starts.size() / 2 + 1;
 	}
 
       // Calculation of the parts (one must be extracted from current

libstdc++-v3/include/parallel/losertree.h

@@ -76,7 +76,6 @@ template<typename T, typename Comparator = std::less<T> >
     Comparator comp;
 
   public:
-    inline
     LoserTreeExplicit(unsigned int _size, Comparator _comp = std::less<T>())
     : comp(_comp)
     {
@@ -92,14 +91,14 @@ template<typename T, typename Comparator = std::less<T> >
         }
     }
 
-    inline ~LoserTreeExplicit()
+    ~LoserTreeExplicit()
     { delete[] losers; }
 
-    inline int
+    int
     get_min_source()
     { return losers[0].source; }
 
-    inline void
+    void
     insert_start(T key, int source, bool sup)
     {
       bool inf = false;
@@ -122,10 +121,10 @@ template<typename T, typename Comparator = std::less<T> >
       losers[0].source = source;
     }
 
-    inline void
+    void
     init() { }
 
-    inline void
+    void
     delete_min_insert(T key, bool sup)
     {
       bool inf = false;
@@ -151,7 +150,7 @@ template<typename T, typename Comparator = std::less<T> >
       losers[0].source = source;
     }
 
-    inline void
+    void
     insert_start_stable(T key, int source, bool sup)
     {
       bool inf = false;
@@ -176,10 +175,10 @@ template<typename T, typename Comparator = std::less<T> >
       losers[0].source = source;
     }
 
-    inline void
+    void
     init_stable() { }
 
-    inline void
+    void
     delete_min_insert_stable(T key, bool sup)
     {
       bool inf = false;
@@ -233,7 +232,7 @@ template<typename T, typename Comparator = std::less<T> >
     bool first_insert;
 
   public:
-    inline LoserTree(unsigned int _k, Comparator _comp = std::less<T>())
+    LoserTree(unsigned int _k, Comparator _comp = std::less<T>())
     : comp(_comp)
     {
       ik = _k;
@@ -249,14 +248,14 @@ template<typename T, typename Comparator = std::less<T> >
       first_insert = true;
     }
 
-    inline ~LoserTree()
+    ~LoserTree()
     { ::operator delete(losers); }
 
-    inline int
+    int
     get_min_source()
     { return losers[0].source; }
 
-    inline void
+    void
     insert_start(const T& key, int source, bool sup)
     {
       unsigned int pos = k + source;
@@ -303,12 +302,12 @@ template<typename T, typename Comparator = std::less<T> >
         }
     }
 
-    inline void
+    void
     init()
     { losers[0] = losers[init_winner(1)]; }
 
     // Do not pass const reference since key will be used as local variable.
-    inline void
+    void
     delete_min_insert(T key, bool sup)
     {
       int source = losers[0].source;
@@ -329,7 +328,7 @@ template<typename T, typename Comparator = std::less<T> >
       losers[0].key = key;
     }
 
-    inline void
+    void
     insert_start_stable(const T& key, int source, bool sup)
     { return insert_start(key, source, sup); }
 
@@ -361,12 +360,12 @@ template<typename T, typename Comparator = std::less<T> >
         }
     }
 
-    inline void
+    void
     init_stable()
     { losers[0] = losers[init_winner_stable(1)]; }
 
     // Do not pass const reference since key will be used as local variable.
-    inline void
+    void
     delete_min_insert_stable(T key, bool sup)
     {
       int source = losers[0].source;
@@ -432,7 +431,6 @@ template<typename T, typename Comparator = std::less<T> >
     Comparator comp;
 
   public:
-    inline
     LoserTreeReference(unsigned int _k, Comparator _comp = std::less<T>())
     : comp(_comp)
     {
@@ -449,7 +447,7 @@ template<typename T, typename Comparator = std::less<T> >
         losers[i + k].sup = true;
     }
 
-    inline ~LoserTreeReference()
+    ~LoserTreeReference()
     {
       delete[] losers;
 #ifndef COPY
@@ -457,11 +455,11 @@ template<typename T, typename Comparator = std::less<T> >
 #endif
     }
 
-    inline int
+    int
     get_min_source()
     { return losers[0].source; }
 
-    inline void
+    void
     insert_start(T key, int source, bool sup)
     {
       unsigned int pos = k + source;
@@ -498,13 +496,13 @@ template<typename T, typename Comparator = std::less<T> >
         }
     }
 
-    inline void
+    void
     init()
     {
       losers[0] = losers[init_winner(1)];
     }
 
-    inline void
+    void
     delete_min_insert(T key, bool sup)
     {
       int source = losers[0].source;
@@ -529,7 +527,7 @@ template<typename T, typename Comparator = std::less<T> >
 #endif
     }
 
-    inline void
+    void
     insert_start_stable(T key, int source, bool sup)
     { return insert_start(key, source, sup); }
 
@@ -560,11 +558,11 @@ template<typename T, typename Comparator = std::less<T> >
         }
     }
 
-    inline void
+    void
     init_stable()
     { losers[0] = losers[init_winner_stable(1)]; }
 
-    inline void
+    void
     delete_min_insert_stable(T key, bool sup)
     {
       int source = losers[0].source;
@@ -622,7 +620,6 @@ template<typename T, typename Comparator = std::less<T> >
     Comparator comp;
 
   public:
-    inline
     LoserTreePointer(unsigned int _k, Comparator _comp = std::less<T>())
       : comp(_comp)
     {
@@ -636,14 +633,14 @@ template<typename T, typename Comparator = std::less<T> >
         losers[i + k].sup = true;
     }
 
-    inline ~LoserTreePointer()
+    ~LoserTreePointer()
     { delete[] losers; }
 
-    inline int
+    int
     get_min_source()
     { return losers[0].source; }
 
-    inline void
+    void
     insert_start(const T& key, int source, bool sup)
     {
       unsigned int pos = k + source;
@@ -657,9 +654,7 @@ template<typename T, typename Comparator = std::less<T> >
     init_winner(unsigned int root)
     {
       if (root >= k)
-        {
 	return root;
-        }
       else
         {
           unsigned int left = init_winner (2 * root);
@@ -681,11 +676,11 @@ template<typename T, typename Comparator = std::less<T> >
         }
     }
 
-    inline void
+    void
     init()
     { losers[0] = losers[init_winner(1)]; }
 
-    inline void
+    void
     delete_min_insert(const T& key, bool sup)
     {
       const T* keyp = &key;
@@ -707,7 +702,7 @@ template<typename T, typename Comparator = std::less<T> >
       losers[0].keyp = keyp;
     }
 
-    inline void
+    void
     insert_start_stable(const T& key, int source, bool sup)
     { return insert_start(key, source, sup); }
 
@@ -739,11 +734,11 @@ template<typename T, typename Comparator = std::less<T> >
         }
     }
 
-    inline void
+    void
     init_stable()
     { losers[0] = losers[init_winner_stable(1)]; }
 
-    inline void
+    void
     delete_min_insert_stable(const T& key, bool sup)
     {
       const T* keyp = &key;
@@ -810,7 +805,6 @@ template<typename T, typename Comparator = std::less<T> >
     }
 
   public:
-    inline
     LoserTreeUnguarded(unsigned int _k, Comparator _comp = std::less<T>())
     : comp(_comp)
     {
@@ -823,17 +817,17 @@ template<typename T, typename Comparator = std::less<T> >
       map(1, 0, ik);
     }
 
-    inline ~LoserTreeUnguarded()
+    ~LoserTreeUnguarded()
     {
       delete[] losers;
       delete[] mapping;
     }
 
-    inline int
+    int
     get_min_source()
     { return losers[0].source; }
 
-    inline void
+    void
     insert_start(const T& key, int source, bool)
     {
       unsigned int pos = mapping[source];
@@ -868,12 +862,12 @@ template<typename T, typename Comparator = std::less<T> >
         }
     }
 
-    inline void
+    void
     init()
     { losers[0] = losers[init_winner(1, 0, ik)]; }
 
     // Do not pass const reference since key will be used as local variable.
-    inline void
+    void
     delete_min_insert(const T& key, bool)
     {
       losers[0].key = key;
@@ -891,15 +885,15 @@ template<typename T, typename Comparator = std::less<T> >
         }
     }
 
-    inline void
+    void
     insert_start_stable(const T& key, int source, bool)
     { return insert_start(key, source, false); }
 
-    inline void
+    void
     init_stable()
     { init(); }
 
-    inline void
+    void
     delete_min_insert_stable(const T& key, bool)
     {
       losers[0].key = key;
@@ -959,7 +953,6 @@ template<typename T, typename Comparator = std::less<T> >
     }
 
   public:
-    inline
     LoserTreePointerUnguarded(unsigned int _k,
                               Comparator _comp = std::less<T>())
     : comp(_comp)
@@ -974,17 +967,17 @@ template<typename T, typename Comparator = std::less<T> >
       map(1, 0, ik);
     }
 
-    inline ~LoserTreePointerUnguarded()
+    ~LoserTreePointerUnguarded()
     {
       delete[] losers;
       delete[] mapping;
     }
 
-    inline int
+    int
     get_min_source()
     { return losers[0].source; }
 
-    inline void
+    void
     insert_start(const T& key, int source, bool)
     {
       unsigned int pos = mapping[source];
@@ -1019,13 +1012,11 @@ template<typename T, typename Comparator = std::less<T> >
         }
     }
 
-    inline void
+    void
     init()
-    {
-      losers[0] = losers[init_winner(1, 0, ik)];
-    }
+    { losers[0] = losers[init_winner(1, 0, ik)]; }
 
-    inline void
+    void
     delete_min_insert(const T& key, bool)
     {
       const T* keyp = &key;
@@ -1044,15 +1035,15 @@ template<typename T, typename Comparator = std::less<T> >
       losers[0].keyp = keyp;
     }
 
-    inline void
+    void
     insert_start_stable(const T& key, int source, bool)
     { return insert_start(key, source, false); }
 
-    inline void
+    void
     init_stable()
     { init(); }
 
-    inline void
+    void
     delete_min_insert_stable(const T& key, bool)
     {
       int& source = losers[0].source;

libstdc++-v3/include/parallel/merge.h

 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 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 terms
@@ -56,9 +56,15 @@ namespace __gnu_parallel
    * @param max_length Maximum number of elements to merge.
    * @param comp Comparator.
    * @return Output end iterator. */
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename OutputIterator, typename _DifferenceTp, typename Comparator>
+  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
+	   typename OutputIterator, typename _DifferenceTp,
+	   typename Comparator>
     OutputIterator
-  merge_advance_usual(RandomAccessIterator1& begin1, RandomAccessIterator1 end1, RandomAccessIterator2& begin2, RandomAccessIterator2 end2, OutputIterator target, _DifferenceTp max_length, Comparator comp)
+    merge_advance_usual(RandomAccessIterator1& begin1,
+			RandomAccessIterator1 end1,
+			RandomAccessIterator2& begin2,
+			RandomAccessIterator2 end2, OutputIterator target,
+			_DifferenceTp max_length, Comparator comp)
     {
       typedef _DifferenceTp difference_type;
       while (begin1 != end1 && begin2 != end2 && max_length > 0)
@@ -99,13 +105,22 @@ namespace __gnu_parallel
    * @param max_length Maximum number of elements to merge.
    * @param comp Comparator.
    * @return Output end iterator. */
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename OutputIterator, typename _DifferenceTp, typename Comparator>
+  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
+	   typename OutputIterator, typename _DifferenceTp,
+	   typename Comparator>
     OutputIterator
-  merge_advance_movc(RandomAccessIterator1& begin1, RandomAccessIterator1 end1, RandomAccessIterator2& begin2, RandomAccessIterator2 end2, OutputIterator target, _DifferenceTp max_length, Comparator comp)
+    merge_advance_movc(RandomAccessIterator1& begin1,
+		       RandomAccessIterator1 end1,
+		       RandomAccessIterator2& begin2,
+		       RandomAccessIterator2 end2,
+		       OutputIterator target,
+		       _DifferenceTp max_length, Comparator comp)
     {
       typedef _DifferenceTp difference_type;
-    typedef typename std::iterator_traits<RandomAccessIterator1>::value_type value_type1;
-    typedef typename std::iterator_traits<RandomAccessIterator2>::value_type value_type2;
+      typedef typename std::iterator_traits<RandomAccessIterator1>::value_type
+	value_type1;
+      typedef typename std::iterator_traits<RandomAccessIterator2>::value_type
+	value_type2;
 
 #if _GLIBCXX_ASSERTIONS
       _GLIBCXX_PARALLEL_ASSERT(max_length >= 0);
@@ -124,9 +139,7 @@ namespace __gnu_parallel
 	      begin2 = next2;
 	    }
 	  else
-	  {
 	    begin1 = next1;
-	  }
 
 	  *target = element1;
 
@@ -160,13 +173,19 @@ namespace __gnu_parallel
    *  @param max_length Maximum number of elements to merge.
    *  @param comp Comparator.
    *  @return Output end iterator. */
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename OutputIterator, typename _DifferenceTp, typename Comparator>
+  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
+	   typename OutputIterator, typename _DifferenceTp,
+	   typename Comparator>
     inline OutputIterator
-  merge_advance(RandomAccessIterator1& begin1, RandomAccessIterator1 end1, RandomAccessIterator2& begin2, RandomAccessIterator2 end2, OutputIterator target, _DifferenceTp max_length, Comparator comp)
+    merge_advance(RandomAccessIterator1& begin1, RandomAccessIterator1 end1,
+		  RandomAccessIterator2& begin2, RandomAccessIterator2 end2,
+		  OutputIterator target, _DifferenceTp max_length,
+		  Comparator comp)
     {
       _GLIBCXX_CALL(max_length)
 
-      return merge_advance_movc(begin1, end1, begin2, end2, target, max_length, comp);
+      return merge_advance_movc(begin1, end1, begin2, end2, target,
+				max_length, comp);
     }
 
   /** @brief Merge routine fallback to sequential in case the
@@ -179,15 +198,20 @@ namespace __gnu_parallel
       *  @param max_length Maximum number of elements to merge.
       *  @param comp Comparator.
       *  @return Output end iterator. */
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename RandomAccessIterator3, typename Comparator>
+  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
+	   typename RandomAccessIterator3, typename Comparator>
     inline RandomAccessIterator3
-  parallel_merge_advance(RandomAccessIterator1& begin1, RandomAccessIterator1 end1,
-			 RandomAccessIterator2& begin2, RandomAccessIterator2 end2,	//different iterators, parallel implementation not available
-			 RandomAccessIterator3 target,
-			 typename std::iterator_traits<RandomAccessIterator1>::difference_type max_length, Comparator comp)
-  {
-    return merge_advance(begin1, end1, begin2, end2, target, max_length, comp);
-  }
+    parallel_merge_advance(RandomAccessIterator1& begin1,
+			   RandomAccessIterator1 end1,
+			   RandomAccessIterator2& begin2,
+			   // different iterators, parallel implementation
+			   // not available			   
+			   RandomAccessIterator2 end2,
+			   RandomAccessIterator3 target, typename
+			   std::iterator_traits<RandomAccessIterator1>::
+			   difference_type max_length, Comparator comp)
+    { return merge_advance(begin1, end1, begin2, end2, target,
+			   max_length, comp); }
 
   /** @brief Parallel merge routine being able to merge only the @c
    * max_length smallest elements.
@@ -204,19 +228,30 @@ namespace __gnu_parallel
    *  @param comp Comparator.
    *  @return Output end iterator.
    */
-  template<typename RandomAccessIterator1, typename RandomAccessIterator3, typename Comparator>
+  template<typename RandomAccessIterator1, typename RandomAccessIterator3,
+	   typename Comparator>
     inline RandomAccessIterator3
-  parallel_merge_advance(RandomAccessIterator1& begin1, RandomAccessIterator1 end1, RandomAccessIterator1& begin2, RandomAccessIterator1 end2, RandomAccessIterator3 target, typename std::iterator_traits<RandomAccessIterator1>::difference_type max_length, Comparator comp)
+    parallel_merge_advance(RandomAccessIterator1& begin1,
+			   RandomAccessIterator1 end1,
+			   RandomAccessIterator1& begin2,
+			   RandomAccessIterator1 end2,
+			   RandomAccessIterator3 target, typename
+			   std::iterator_traits<RandomAccessIterator1>::
+			   difference_type max_length, Comparator comp)
     {
       typedef typename std::iterator_traits<RandomAccessIterator1>::value_type
 	value_type;
-    typedef typename std::iterator_traits<RandomAccessIterator1>::difference_type
-      difference_type1 /* == difference_type2 */;
-    typedef typename std::iterator_traits<RandomAccessIterator3>::difference_type
-      difference_type3;
+      typedef typename std::iterator_traits<RandomAccessIterator1>::
+	difference_type difference_type1 /* == difference_type2 */;
+      typedef typename std::iterator_traits<RandomAccessIterator3>::
+	difference_type difference_type3;
 
-    std::pair<RandomAccessIterator1, RandomAccessIterator1> seqs[2] = { std::make_pair(begin1, end1), std::make_pair(begin2, end2) };
-    RandomAccessIterator3 target_end = parallel_multiway_merge(seqs, seqs + 2, target, comp, max_length, true, false);
+      std::pair<RandomAccessIterator1, RandomAccessIterator1>
+	seqs[2] = { std::make_pair(begin1, end1),
+		    std::make_pair(begin2, end2) };
+      RandomAccessIterator3 
+	target_end = parallel_multiway_merge(seqs, seqs + 2, target,
+					     comp, max_length, true, false);
 
       return target_end;
     }

libstdc++-v3/include/parallel/multiseq_selection.h

 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 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 terms
@@ -58,7 +58,8 @@ namespace __gnu_parallel
 {
   /** @brief Compare a pair of types lexicographically, ascending. */
   template<typename T1, typename T2, typename Comparator>
-  class lexicographic : public std::binary_function<std::pair<T1, T2>, std::pair<T1, T2>, bool>
+    class lexicographic
+    : public std::binary_function<std::pair<T1, T2>, std::pair<T1, T2>, bool>
     {
     private:
       Comparator& comp;
@@ -67,8 +68,9 @@ namespace __gnu_parallel
       lexicographic(Comparator& _comp) : comp(_comp) { }
 
       // XXX const
-    inline bool
-    operator()(const std::pair<T1, T2>& p1, const std::pair<T1, T2>& p2) const
+      bool
+      operator()(const std::pair<T1, T2>& p1,
+		 const std::pair<T1, T2>& p2) const
       {
 	if (comp(p1.first, p2.first))
 	  return true;
@@ -91,8 +93,9 @@ namespace __gnu_parallel
     public:
       lexicographic_reverse(Comparator& _comp) : comp(_comp) { }
 
-    inline bool
-    operator()(const std::pair<T1, T2>& p1, const std::pair<T1, T2>& p2) const
+      bool
+      operator()(const std::pair<T1, T2>& p1,
+		 const std::pair<T1, T2>& p2) const
       {
 	if (comp(p2.first, p1.first))
 	  return true;
@@ -121,17 +124,23 @@ namespace __gnu_parallel
    *  the respective sequence.
    *  @param comp The ordering functor, defaults to std::less<T>. 
    */
-  template<typename RanSeqs, typename RankType, typename RankIterator, typename Comparator>
+  template<typename RanSeqs, typename RankType, typename RankIterator,
+	   typename Comparator>
     void
-  multiseq_partition(RanSeqs begin_seqs, RanSeqs end_seqs, RankType rank,
+    multiseq_partition(RanSeqs begin_seqs, RanSeqs end_seqs,
+		       RankType rank,
 		       RankIterator begin_offsets,
 		       Comparator comp = std::less<
-		     typename std::iterator_traits<typename std::iterator_traits<RanSeqs>::value_type::first_type>::value_type>()) // std::less<T>
+		       typename std::iterator_traits<typename
+		       std::iterator_traits<RanSeqs>::value_type::
+		       first_type>::value_type>()) // std::less<T>
     {
       _GLIBCXX_CALL(end_seqs - begin_seqs)
 
-    typedef typename std::iterator_traits<RanSeqs>::value_type::first_type It;
-    typedef typename std::iterator_traits<It>::difference_type difference_type;
+      typedef typename std::iterator_traits<RanSeqs>::value_type::first_type
+	It;
+      typedef typename std::iterator_traits<It>::difference_type
+	difference_type;
       typedef typename std::iterator_traits<It>::value_type value_type;
 
       lexicographic<value_type, int, Comparator> lcomp(comp);
@@ -139,7 +148,8 @@ namespace __gnu_parallel
 
       // Number of sequences, number of elements in total (possibly
       // including padding).
-    difference_type m = std::distance(begin_seqs, end_seqs), N = 0, nmax, n, r;
+      difference_type m = std::distance(begin_seqs, end_seqs), N = 0,
+	nmax, n, r;
 
       for (int i = 0; i < m; i++)
 	N += std::distance(begin_seqs[i].first, begin_seqs[i].second);
@@ -240,7 +250,8 @@ namespace __gnu_parallel
 	    {
 	      difference_type middle = (b[i] + a[i]) / 2;
 	      if (lmax && middle < ns[i] &&
-		lcomp(std::make_pair(S(i)[middle], i), std::make_pair(*lmax, lmax_seq)))
+		  lcomp(std::make_pair(S(i)[middle], i),
+			std::make_pair(*lmax, lmax_seq)))
 		a[i] = std::min(a[i] + n + 1, ns[i]);
 	      else
 		b[i] -= n + 1;
@@ -253,12 +264,16 @@ namespace __gnu_parallel
 	      total += l / (n + 1);
 	    }
 	  
-	difference_type skew = static_cast<difference_type>(static_cast<uint64>(total) * rank / N - leftsize);
+	  difference_type skew = static_cast<difference_type>
+	    (static_cast<uint64>(total) * rank / N - leftsize);
 
 	  if (skew > 0)
 	    {
 	      // Move to the left, find smallest.
-	    std::priority_queue<std::pair<value_type, int>, std::vector<std::pair<value_type, int> >, lexicographic_reverse<value_type, int, Comparator> > pq(lrcomp);
+	      std::priority_queue<std::pair<value_type, int>,
+		std::vector<std::pair<value_type, int> >,
+		lexicographic_reverse<value_type, int, Comparator> >
+		pq(lrcomp);
 	      
 	      for (int i = 0; i < m; i++)
 		if (b[i] < ns[i])
@@ -279,7 +294,9 @@ namespace __gnu_parallel
 	  else if (skew < 0)
 	    {
 	      // Move to the right, find greatest.
-	    std::priority_queue<std::pair<value_type, int>, std::vector<std::pair<value_type, int> >, lexicographic<value_type, int, Comparator> > pq(lcomp);
+	      std::priority_queue<std::pair<value_type, int>,
+		std::vector<std::pair<value_type, int> >,
+		lexicographic<value_type, int, Comparator> > pq(lcomp);
 
 	      for (int i = 0; i < m; i++)
 		if (a[i] > 0)
@@ -360,15 +377,18 @@ namespace __gnu_parallel
    *  selected element is unique, this number is 0.
    *  @param comp The ordering functor, defaults to std::less. 
    */
-  template<typename T, typename RanSeqs, typename RankType, typename Comparator>
+  template<typename T, typename RanSeqs, typename RankType,
+	   typename Comparator>
     T
     multiseq_selection(RanSeqs begin_seqs, RanSeqs end_seqs, RankType rank,
 		       RankType& offset, Comparator comp = std::less<T>())
     {
       _GLIBCXX_CALL(end_seqs - begin_seqs)
 
-    typedef typename std::iterator_traits<RanSeqs>::value_type::first_type It;
-    typedef typename std::iterator_traits<It>::difference_type difference_type;
+      typedef typename std::iterator_traits<RanSeqs>::value_type::first_type
+	It;
+      typedef typename std::iterator_traits<It>::difference_type
+	difference_type;
 
       lexicographic<T, int, Comparator> lcomp(comp);
       lexicographic_reverse<T, int, Comparator> lrcomp(comp);
@@ -429,7 +449,8 @@ namespace __gnu_parallel
       for (int i = 0; i < m; i++)
 	if (n < ns[i])
 	  sample.push_back(std::make_pair(S(i)[n], i));
-    __gnu_sequential::sort(sample.begin(), sample.end(), lcomp, sequential_tag());
+      __gnu_sequential::sort(sample.begin(), sample.end(),
+			     lcomp, sequential_tag());
 
       // Conceptual infinity.
       for (int i = 0; i < m; i++)
@@ -455,9 +476,7 @@ namespace __gnu_parallel
 	      if (a[i] > 0)
 		{
 		  if (!lmax)
-		  {
 		    lmax = &(S(i)[a[i] - 1]);
-		  }
 		  else
 		    {
 		      if (comp(*lmax, S(i)[a[i] - 1]))	//max
@@ -483,18 +502,21 @@ namespace __gnu_parallel
 	      total += l / (n + 1);
 	    }
 
-	difference_type skew = (unsigned long long)total * rank / N - leftsize;
+	  difference_type skew = ((unsigned long long)total * rank / N
+				  - leftsize);
 
 	  if (skew > 0)
 	    {
 	      // Move to the left, find smallest.
-	    std::priority_queue<std::pair<T, int>, std::vector<std::pair<T, int> >, lexicographic_reverse<T, int, Comparator> > pq(lrcomp);
+	      std::priority_queue<std::pair<T, int>,
+		std::vector<std::pair<T, int> >,
+		lexicographic_reverse<T, int, Comparator> > pq(lrcomp);
 
 	      for (int i = 0; i < m; i++)
 		if (b[i] < ns[i])
 		  pq.push(std::make_pair(S(i)[b[i]], i));
 
-	    for (; skew != 0 && !pq.empty(); skew--)
+	      for (; skew != 0 && !pq.empty(); --skew)
 		{
 		  int source = pq.top().second;
 		  pq.pop();
@@ -509,13 +531,15 @@ namespace __gnu_parallel
 	  else if (skew < 0)
 	    {
 	      // Move to the right, find greatest.
-	    std::priority_queue<std::pair<T, int>, std::vector<std::pair<T, int> >, lexicographic<T, int, Comparator> > pq(lcomp);
+	      std::priority_queue<std::pair<T, int>,
+		std::vector<std::pair<T, int> >,
+		lexicographic<T, int, Comparator> > pq(lcomp);
 
 	      for (int i = 0; i < m; i++)
 		if (a[i] > 0)
 		  pq.push(std::make_pair(S(i)[a[i] - 1], i));
 
-	    for (; skew != 0; skew++)
+	      for (; skew != 0; ++skew)
 		{
 		  int source = pq.top().second;
 		  pq.pop();
@@ -588,7 +612,8 @@ namespace __gnu_parallel
 
 	  for (int i = 0; i < m; i++)
 	    {
-	    difference_type lb = std::lower_bound(S(i), S(i) + ns[i], minright,
+	      difference_type lb = std::lower_bound(S(i), S(i) + ns[i],
+						    minright,
 						    comp) - S(i);
 	      offset += a[i] - lb;
 	    }