multiway_merge.h: Simple formatting and uglification fixes.

2009-11-06  Paolo Carlini  <paolo.carlini@oracle.com>

	* include/parallel/multiway_merge.h: Simple formatting and
	uglification fixes.
	* 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/workstealing.h: Likewise.
	* include/parallel/par_loop.h: Likewise.
	* include/parallel/numeric: Likewise.
	* include/parallel/quicksort.h: Likewise.
	* include/parallel/equally_split.h: Likewise.
	* include/parallel/omp_loop_static.h: Likewise.
	* include/parallel/random_shuffle.h: Likewise.
	* include/parallel/balanced_quicksort.h: Likewise.
	* include/parallel/tags.h: Likewise.
	* include/parallel/set_operations.h: Likewise.
	* include/parallel/merge.h: Likewise.
	* include/parallel/unique_copy.h: Likewise.
	* include/parallel/multiway_mergesort.h: Likewise.
	* include/parallel/search.h: Likewise.
	* include/parallel/partition.h: Likewise.
	* include/parallel/partial_sum.h: Likewise.
	* include/parallel/find.h: Likewise.
	* include/parallel/queue.h: Likewise.
	* include/parallel/omp_loop.h: Likewise.
	* include/parallel/checkers.h: Likewise.
	* include/parallel/sort.h: Likewise.

From-SVN: r153966

libstdc++-v3/ChangeLog

+2009-11-06  Paolo Carlini  <paolo.carlini@oracle.com>
+
+	* include/parallel/multiway_merge.h: Simple formatting and
+	uglification fixes.
+	* 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/workstealing.h: Likewise.
+	* include/parallel/par_loop.h: Likewise.
+	* include/parallel/numeric: Likewise.
+	* include/parallel/quicksort.h: Likewise.
+	* include/parallel/equally_split.h: Likewise.
+	* include/parallel/omp_loop_static.h: Likewise.
+	* include/parallel/random_shuffle.h: Likewise.
+	* include/parallel/balanced_quicksort.h: Likewise.
+	* include/parallel/tags.h: Likewise.
+	* include/parallel/set_operations.h: Likewise.
+	* include/parallel/merge.h: Likewise.
+	* include/parallel/unique_copy.h: Likewise.
+	* include/parallel/multiway_mergesort.h: Likewise.
+	* include/parallel/search.h: Likewise.
+	* include/parallel/partition.h: Likewise.
+	* include/parallel/partial_sum.h: Likewise.
+	* include/parallel/find.h: Likewise.
+	* include/parallel/queue.h: Likewise.
+	* include/parallel/omp_loop.h: Likewise.
+	* include/parallel/checkers.h: Likewise.
+	* include/parallel/sort.h: Likewise.
+
 2009-11-06  Jonathan Wakely  <jwakely.gcc@gmail.com>
 
 	PR libstdc++/41949

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

@@ -57,8 +57,8 @@
 
 namespace __gnu_parallel
 {
-/** @brief Information local to one thread in the parallel quicksort run. */
-template<typename _RAIter>
+  /** @brief Information local to one thread in the parallel quicksort run. */
+  template<typename _RAIter>
     struct _QSBThreadLocal
     {
       typedef std::iterator_traits<_RAIter> _TraitsType;
@@ -88,14 +88,14 @@ template<typename _RAIter>
       _QSBThreadLocal(int __queue_size) : _M_leftover_parts(__queue_size) { }
     };
 
-/** @brief Balanced quicksort divide step.
+  /** @brief Balanced quicksort divide step.
     *  @param __begin Begin iterator of subsequence.
     *  @param __end End iterator of subsequence.
     *  @param __comp Comparator.
     *  @param __num_threads Number of threads that are allowed to work on
     *  this part.
     *  @pre @__c (__end-__begin)>=1 */
-template<typename _RAIter, typename _Compare>
+  template<typename _RAIter, typename _Compare>
     typename std::iterator_traits<_RAIter>::difference_type
     __qsb_divide(_RAIter __begin, _RAIter __end,
 		 _Compare __comp, _ThreadIndex __num_threads)
@@ -114,19 +114,20 @@ template<typename _RAIter, typename _Compare>
       // Must be in between somewhere.
       _DifferenceType __n = __end - __begin;
 
-    _GLIBCXX_PARALLEL_ASSERT(
-           (!__comp(*__pivot_pos, *__begin) &&
-              !__comp(*(__begin + __n / 2), *__pivot_pos))
-        || (!__comp(*__pivot_pos, *__begin) &&
-              !__comp(*(__end - 1), *__pivot_pos))
-        || (!__comp(*__pivot_pos, *(__begin + __n / 2)) &&
-              !__comp(*__begin, *__pivot_pos))
-        || (!__comp(*__pivot_pos, *(__begin + __n / 2)) &&
-              !__comp(*(__end - 1), *__pivot_pos))
-        || (!__comp(*__pivot_pos, *(__end - 1)) &&
-              !__comp(*__begin, *__pivot_pos))
-        || (!__comp(*__pivot_pos, *(__end - 1)) &&
-              !__comp(*(__begin + __n / 2), *__pivot_pos)));
+      _GLIBCXX_PARALLEL_ASSERT((!__comp(*__pivot_pos, *__begin)
+				&& !__comp(*(__begin + __n / 2),
+					   *__pivot_pos))
+			       || (!__comp(*__pivot_pos, *__begin)
+				   && !__comp(*(__end - 1), *__pivot_pos))
+			       || (!__comp(*__pivot_pos, *(__begin + __n / 2))
+				   && !__comp(*__begin, *__pivot_pos))
+			       || (!__comp(*__pivot_pos, *(__begin + __n / 2))
+				   && !__comp(*(__end - 1), *__pivot_pos))
+			       || (!__comp(*__pivot_pos, *(__end - 1))
+				   && !__comp(*__begin, *__pivot_pos))
+			       || (!__comp(*__pivot_pos, *(__end - 1))
+				   && !__comp(*(__begin + __n / 2),
+					      *__pivot_pos)));
 #endif
 
       // Swap pivot value to end.
@@ -138,8 +139,9 @@ template<typename _RAIter, typename _Compare>
 	__pred(__comp, *__pivot_pos);
 
       // Divide, returning __end - __begin - 1 in the worst case.
-    _DifferenceType __split_pos = __parallel_partition(
-        __begin, __end - 1, __pred, __num_threads);
+      _DifferenceType __split_pos = __parallel_partition(__begin, __end - 1,
+							 __pred,
+							 __num_threads);
 
       // Swap back pivot to middle.
       std::swap(*(__begin + __split_pos), *__pivot_pos);
@@ -156,7 +158,7 @@ template<typename _RAIter, typename _Compare>
       return __split_pos;
     }
 
-/** @brief Quicksort conquer step.
+  /** @brief Quicksort conquer step.
     *  @param __tls Array of thread-local storages.
     *  @param __begin Begin iterator of subsequence.
     *  @param __end End iterator of subsequence.
@@ -164,7 +166,7 @@ template<typename _RAIter, typename _Compare>
     *  @param __iam Number of the thread processing this function.
     *  @param __num_threads
     *          Number of threads that are allowed to work on this part. */
-template<typename _RAIter, typename _Compare>
+  template<typename _RAIter, typename _Compare>
     void
     __qsb_conquer(_QSBThreadLocal<_RAIter>** __tls,
 		  _RAIter __begin, _RAIter __end,
@@ -197,9 +199,10 @@ template<typename _RAIter, typename _Compare>
                                __split_pos < (__end - __begin));
 #endif
 
-    _ThreadIndex __num_threads_leftside =
-        std::max<_ThreadIndex>(1, std::min<_ThreadIndex>(
-            __num_threads - 1, __split_pos * __num_threads / __n));
+      _ThreadIndex
+	__num_threads_leftside = std::max<_ThreadIndex>
+	(1, std::min<_ThreadIndex>(__num_threads - 1, __split_pos
+				   * __num_threads / __n));
 
 #     pragma omp atomic
       *__tls[__iam]->_M_elements_leftover -= (_DifferenceType)1;
@@ -218,9 +221,7 @@ template<typename _RAIter, typename _Compare>
 #         pragma omp section
 	  {
 	    __qsb_conquer(__tls, __begin, __begin + __split_pos, __comp,
-                          __iam,
-                          __num_threads_leftside,
-                          __wait);
+			  __iam, __num_threads_leftside, __wait);
 	    __wait = __parent_wait;
 	  }
 	  // The pivot_pos is left in place, to ensure termination.
@@ -228,21 +229,20 @@ template<typename _RAIter, typename _Compare>
 	  {
 	    __qsb_conquer(__tls, __begin + __split_pos + 1, __end, __comp,
 			  __iam + __num_threads_leftside,
-                          __num_threads - __num_threads_leftside,
-                          __wait);
+			  __num_threads - __num_threads_leftside, __wait);
 	    __wait = __parent_wait;
 	  }
 	}
       }
     }
 
-/**
+  /**
     *  @brief Quicksort step doing load-balanced local sort.
     *  @param __tls Array of thread-local storages.
     *  @param __comp Comparator.
     *  @param __iam Number of the thread processing this function.
     */
-template<typename _RAIter, typename _Compare>
+  template<typename _RAIter, typename _Compare>
     void
     __qsb_local_sort_with_helping(_QSBThreadLocal<_RAIter>** __tls,
 				  _Compare& __comp, int __iam, bool __wait)
@@ -254,8 +254,8 @@ template<typename _RAIter, typename _Compare>
 
       _QSBThreadLocal<_RAIter>& __tl = *__tls[__iam];
 
-    _DifferenceType __base_case_n =
-        _Settings::get().sort_qsb_base_case_maximal_n;
+      _DifferenceType
+	__base_case_n = _Settings::get().sort_qsb_base_case_maximal_n;
       if (__base_case_n < 2)
 	__base_case_n = 2;
       _ThreadIndex __num_threads = __tl._M_num_threads;
@@ -292,8 +292,8 @@ template<typename _RAIter, typename _Compare>
 
               // Divide, leave pivot unchanged in last place.
               _RAIter __split_pos1, __split_pos2;
-            __split_pos1 =
-                    __gnu_sequential::partition(__begin, __end - 1, __pred);
+              __split_pos1 = __gnu_sequential::partition(__begin, __end - 1,
+							 __pred);
 
               // Left side: < __pivot_pos; __right side: >= __pivot_pos.
 #if _GLIBCXX_ASSERTIONS
@@ -314,8 +314,8 @@ template<typename _RAIter, typename _Compare>
                   __gnu_parallel::__unary_negate<__gnu_parallel::__binder1st
                     <_Compare, _ValueType, _ValueType, bool>, _ValueType>
                     __pred(__gnu_parallel::__binder1st
-                       <_Compare, _ValueType, _ValueType, bool>(
-                          __comp, *__pivot_pos));
+                	 <_Compare, _ValueType, _ValueType, bool>
+			   (__comp, *__pivot_pos));
 
                   // Find other end of pivot-equal range.
                   __split_pos2 = __gnu_sequential::partition(__split_pos1 + 1,
@@ -335,8 +335,8 @@ template<typename _RAIter, typename _Compare>
         	{
                   // Right side larger.
                   if ((__split_pos2) != __end)
-                  __tl._M_leftover_parts.push_front(
-                    std::make_pair(__split_pos2, __end));
+                    __tl._M_leftover_parts.push_front
+		      (std::make_pair(__split_pos2, __end));
 
                   //__current.first = __begin;    //already set anyway
                   __current.second = __split_pos1;
@@ -346,8 +346,8 @@ template<typename _RAIter, typename _Compare>
         	{
                   // Left side larger.
                   if (__begin != __split_pos1)
-                  __tl._M_leftover_parts.push_front(std::make_pair(__begin,
-                                                              __split_pos1));
+                    __tl._M_leftover_parts.push_front(std::make_pair
+						      (__begin, __split_pos1));
 
                   __current.first = __split_pos2;
                   //__current.second = __end;     //already set anyway
@@ -417,18 +417,17 @@ template<typename _RAIter, typename _Compare>
 	}
     }
 
-/** @brief Top-level quicksort routine.
+  /** @brief Top-level quicksort routine.
     *  @param __begin Begin iterator of sequence.
     *  @param __end End iterator of sequence.
     *  @param __comp Comparator.
     *  @param __num_threads Number of threads that are allowed to work on
     *  this part.
     */
-template<typename _RAIter, typename _Compare>
+  template<typename _RAIter, typename _Compare>
     void
     __parallel_sort_qsb(_RAIter __begin, _RAIter __end,
-                    _Compare __comp,
-                    _ThreadIndex __num_threads)
+			_Compare __comp, _ThreadIndex __num_threads)
     {
       _GLIBCXX_CALL(__end - __begin)
 
@@ -450,20 +449,20 @@ template<typename _RAIter, typename _Compare>
 
       // Initialize thread local storage
       _TLSType** __tls = new _TLSType*[__num_threads];
-    _DifferenceType __queue_size =
-                           __num_threads * (_ThreadIndex)(log2(__n) + 1);
+      _DifferenceType __queue_size = (__num_threads
+				      * (_ThreadIndex)(__rd_log2(__n) + 1));
       for (_ThreadIndex __t = 0; __t < __num_threads; ++__t)
 	__tls[__t] = new _QSBThreadLocal<_RAIter>(__queue_size);
 
-    // There can never be more than ceil(log2(__n)) ranges on the stack,
-    // because
+      // There can never be more than ceil(__rd_log2(__n)) ranges on the
+      // stack, because
       // 1. Only one processor pushes onto the stack
       // 2. The largest range has at most length __n
       // 3. Each range is larger than half of the range remaining
-    volatile _DifferenceType _M_elements_leftover = __n;
+      volatile _DifferenceType __elements_leftover = __n;
       for (int __i = 0; __i < __num_threads; ++__i)
 	{
-        __tls[__i]->_M_elements_leftover = &_M_elements_leftover;
+          __tls[__i]->_M_elements_leftover = &__elements_leftover;
           __tls[__i]->_M_num_threads = __num_threads;
           __tls[__i]->_M_global = std::make_pair(__begin, __end);
 
@@ -472,8 +471,8 @@ template<typename _RAIter, typename _Compare>
 	}
 
       // Main recursion call.
-    __qsb_conquer(
-      __tls, __begin, __begin + __n, __comp, 0, __num_threads, true);
+      __qsb_conquer(__tls, __begin, __begin + __n, __comp, 0,
+		    __num_threads, true);
 
 #if _GLIBCXX_ASSERTIONS
       // All stack must be empty.

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

@@ -68,5 +68,6 @@ namespace __gnu_parallel
 
       return true;
     }
+}
 
 #endif /* _GLIBCXX_PARALLEL_CHECKERS_H */

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

 // -*- C++ -*-
 
-// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008, 2009 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
@@ -33,17 +33,17 @@
 
 namespace __gnu_parallel
 {
-/** @brief function to split a sequence into parts of almost equal size.
+  /** @brief function to split a sequence into parts of almost equal size.
    *
- *  The resulting sequence __s of length __num_threads+1 contains the splitting
- *  positions when splitting the range [0,__n) into parts of almost
- *  equal size (plus minus 1).  The first entry is 0, the last one
-*  n. There may result empty parts.
+   *  The resulting sequence __s of length __num_threads+1 contains the
+   *  splitting positions when splitting the range [0,__n) into parts of
+   *  almost equal size (plus minus 1).  The first entry is 0, the last
+   *  one n. There may result empty parts.
    *  @param __n Number of elements
    *  @param __num_threads Number of parts
    *  @param __s Splitters
    *  @returns End of __splitter sequence, i.e. @__c __s+__num_threads+1 */
-template<typename _DifferenceType, typename _OutputIterator>
+  template<typename _DifferenceType, typename _OutputIterator>
     _OutputIterator
     equally_split(_DifferenceType __n, _ThreadIndex __num_threads,
 		  _OutputIterator __s)
@@ -54,15 +54,14 @@ template<typename _DifferenceType, typename _OutputIterator>
       for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)
 	{
 	  *__s++ = __pos;
-        __pos += (__i < __num_longer_chunks) ?
-                                      (__chunk_length + 1) : __chunk_length;
+	  __pos += ((__i < __num_longer_chunks)
+		    ? (__chunk_length + 1) : __chunk_length);
 	}
       *__s++ = __n;
       return __s;
     }
 
-
-/** @brief function to split a sequence into parts of almost equal size.
+  /** @brief function to split a sequence into parts of almost equal size.
    *
    *  Returns the position of the splitting point between
    *  thread number __thread_no (included) and
@@ -70,7 +69,7 @@ template<typename _DifferenceType, typename _OutputIterator>
    *  @param __n Number of elements
    *  @param __num_threads Number of parts
    *  @returns splitting point */
-template<typename _DifferenceType>
+  template<typename _DifferenceType>
     _DifferenceType
     equally_split_point(_DifferenceType __n,
 			_ThreadIndex __num_threads,

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

@@ -42,17 +42,17 @@
 
 namespace __gnu_parallel
 {
-/**
+  /**
    *  @brief Parallel std::find, switch for different algorithms.
    *  @param __begin1 Begin iterator of first sequence.
    *  @param __end1 End iterator of first sequence.
    *  @param __begin2 Begin iterator of second sequence. Must have same
    *  length as first sequence.
    *  @param __pred Find predicate.
- *  @param __selector _Functionality (e. g. std::find_if (), std::equal(),...)
+   *  @param __selector _Functionality (e. g. std::find_if(), std::equal(),...)
    *  @return Place of finding in both sequences.
    */
-template<typename _RAIter1,
+  template<typename _RAIter1,
 	   typename _RAIter2,
 	   typename _Pred,
            typename _Selector>
@@ -63,14 +63,14 @@ template<typename _RAIter1,
       switch (_Settings::get().find_algorithm)
 	{
 	case GROWING_BLOCKS:
-        return __find_template(__begin1, __end1, __begin2, __pred, __selector,
-                             growing_blocks_tag());
+          return __find_template(__begin1, __end1, __begin2, __pred,
+				 __selector, growing_blocks_tag());
 	case CONSTANT_SIZE_BLOCKS:
-        return __find_template(__begin1, __end1, __begin2, __pred, __selector,
-                             constant_size_blocks_tag());
+          return __find_template(__begin1, __end1, __begin2, __pred,
+				 __selector, constant_size_blocks_tag());
 	case EQUAL_SPLIT:
-        return __find_template(__begin1, __end1, __begin2, __pred, __selector,
-                             equal_split_tag());
+          return __find_template(__begin1, __end1, __begin2, __pred,
+				 __selector, equal_split_tag());
 	default:
           _GLIBCXX_PARALLEL_ASSERT(false);
           return std::make_pair(__begin1, __begin2);
@@ -79,27 +79,24 @@ template<typename _RAIter1,
 
 #if _GLIBCXX_FIND_EQUAL_SPLIT
 
-/**
+  /**
    *  @brief Parallel std::find, equal splitting variant.
    *  @param __begin1 Begin iterator of first sequence.
    *  @param __end1 End iterator of first sequence.
    *  @param __begin2 Begin iterator of second sequence. Second __sequence
    *  must have same length as first sequence.
    *  @param __pred Find predicate.
- *  @param __selector _Functionality (e. g. std::find_if (), std::equal(),...)
+   *  @param __selector _Functionality (e. g. std::find_if(), std::equal(),...)
    *  @return Place of finding in both sequences.
    */
-template<typename _RAIter1,
+  template<typename _RAIter1,
            typename _RAIter2,
            typename _Pred,
            typename _Selector>
     std::pair<_RAIter1, _RAIter2>
-  __find_template(_RAIter1 __begin1,
-                _RAIter1 __end1,
-                _RAIter2 __begin2,
-                _Pred __pred,
-                _Selector __selector,
-                equal_split_tag)
+    __find_template(_RAIter1 __begin1, _RAIter1 __end1,
+		    _RAIter2 __begin2, _Pred __pred,
+		    _Selector __selector, equal_split_tag)
     {
       _GLIBCXX_CALL(__end1 - __begin1)
 
@@ -132,7 +129,7 @@ template<typename _RAIter1,
 	_RAIter2 __i2 = __begin2 + __start;
 	for (_DifferenceType __pos = __start; __pos < __stop; ++__pos)
 	  {
-            #pragma omp flush(__result)
+#           pragma omp flush(__result)
 	    // Result has been set to something lower.
 	    if (__result < __pos)
 	      break;
@@ -153,22 +150,22 @@ template<typename _RAIter1,
       omp_destroy_lock(&__result_lock);
       delete[] __borders;
 
-    return
-      std::pair<_RAIter1, _RAIter2>(__begin1 + __result, __begin2 + __result);
+      return std::pair<_RAIter1, _RAIter2>(__begin1 + __result,
+					   __begin2 + __result);
     }
 
 #endif
 
 #if _GLIBCXX_FIND_GROWING_BLOCKS
 
-/**
+  /**
    *  @brief Parallel std::find, growing block size variant.
    *  @param __begin1 Begin iterator of first sequence.
    *  @param __end1 End iterator of first sequence.
    *  @param __begin2 Begin iterator of second sequence. Second __sequence
    *  must have same length as first sequence.
    *  @param __pred Find predicate.
- *  @param __selector _Functionality (e. g. std::find_if (), std::equal(),...)
+   *  @param __selector _Functionality (e. g. std::find_if(), std::equal(),...)
    *  @return Place of finding in both sequences.
    *  @see __gnu_parallel::_Settings::find_sequential_search_size
    *  @see __gnu_parallel::_Settings::find_initial_block_size
@@ -182,7 +179,7 @@ template<typename _RAIter1,
    *     for CSB, the blocks are allocated in a predetermined manner,
    *     namely spacial round-robin.
    */
-template<typename _RAIter1,
+  template<typename _RAIter1,
            typename _RAIter2,
            typename _Pred,
            typename _Selector>
@@ -201,13 +198,15 @@ template<typename _RAIter1,
 
       _DifferenceType __length = __end1 - __begin1;
 
-    _DifferenceType __sequential_search_size =
-      std::min<_DifferenceType>(__length, __s.find_sequential_search_size);
+      _DifferenceType
+	__sequential_search_size = std::min<_DifferenceType>
+	(__length, __s.find_sequential_search_size);
 
       // Try it sequentially first.
-    std::pair<_RAIter1, _RAIter2> __find_seq_result =
-      __selector._M_sequential_algorithm(
-          __begin1, __begin1 + __sequential_search_size, __begin2, __pred);
+      std::pair<_RAIter1, _RAIter2>
+	__find_seq_result = __selector._M_sequential_algorithm
+	(__begin1, __begin1 + __sequential_search_size,
+	 __begin2, __pred);
 
       if (__find_seq_result.first != (__begin1 + __sequential_search_size))
 	return __find_seq_result;
@@ -229,8 +228,8 @@ template<typename _RAIter1,
 	_ThreadIndex __iam = omp_get_thread_num();
 
 	_DifferenceType __block_size = __s.find_initial_block_size;
-        _DifferenceType __start =
-          __fetch_and_add<_DifferenceType>(&__next_block_start, __block_size);
+	_DifferenceType __start = __fetch_and_add<_DifferenceType>
+	  (&__next_block_start, __block_size);
 
 	// Get new block, update pointer to next block.
 	_DifferenceType __stop =
@@ -248,9 +247,10 @@ template<typename _RAIter1,
 		break;
 	      }
 
-            __local_result = __selector._M_sequential_algorithm(
-                               __begin1 + __start, __begin1 + __stop,
+	    __local_result = __selector._M_sequential_algorithm
+	      (__begin1 + __start, __begin1 + __stop,
 	       __begin2 + __start, __pred);
+
 	    if (__local_result.first != (__begin1 + __stop))
 	      {
 		omp_set_lock(&__result_lock);
@@ -259,21 +259,20 @@ template<typename _RAIter1,
 		    __result = __local_result.first - __begin1;
 
 		    // Result cannot be in future blocks, stop algorithm.
-                    __fetch_and_add<_DifferenceType>(
-                      &__next_block_start, __length);
+		    __fetch_and_add<_DifferenceType>(&__next_block_start,
+						     __length);
 		  }
 		omp_unset_lock(&__result_lock);
 	      }
 
-            __block_size = std::min<_DifferenceType>(
-              __block_size * __s.find_increasing_factor,
+	    __block_size = std::min<_DifferenceType>
+	      (__block_size * __s.find_increasing_factor,
 	       __s.find_maximum_block_size);
 
 	    // Get new block, update pointer to next block.
-            __start =
-              __fetch_and_add<_DifferenceType>(
-                &__next_block_start, __block_size);
-            __stop = ((__length < (__start + __block_size))
+	    __start = __fetch_and_add<_DifferenceType>(&__next_block_start,
+						       __block_size);
+	    __stop = (__length < (__start + __block_size)
 		      ? __length : (__start + __block_size));
 	  }
       } //parallel
@@ -282,21 +281,22 @@ template<typename _RAIter1,
 
       // Return iterator on found element.
       return
-      std::pair<_RAIter1, _RAIter2>(__begin1 + __result, __begin2 + __result);
+	std::pair<_RAIter1, _RAIter2>(__begin1 + __result,
+				      __begin2 + __result);
     }
 
 #endif
 
 #if _GLIBCXX_FIND_CONSTANT_SIZE_BLOCKS
 
-/**
+  /**
    *   @brief Parallel std::find, constant block size variant.
    *  @param __begin1 Begin iterator of first sequence.
    *  @param __end1 End iterator of first sequence.
    *  @param __begin2 Begin iterator of second sequence. Second __sequence
    *  must have same length as first sequence.
    *  @param __pred Find predicate.
- *  @param __selector _Functionality (e. g. std::find_if (), std::equal(),...)
+   *  @param __selector _Functionality (e. g. std::find_if(), std::equal(),...)
    *  @return Place of finding in both sequences.
    *  @see __gnu_parallel::_Settings::find_sequential_search_size
    *  @see __gnu_parallel::_Settings::find_block_size
@@ -307,7 +307,7 @@ template<typename _RAIter1,
    *  blocks are allocated in a predetermined manner, namely spacial
    *  round-robin.
    */
-template<typename _RAIter1,
+  template<typename _RAIter1,
            typename _RAIter2,
            typename _Pred,
            typename _Selector>
@@ -325,13 +325,13 @@ template<typename _RAIter1,
 
       _DifferenceType __length = __end1 - __begin1;
 
-    _DifferenceType __sequential_search_size = std::min<_DifferenceType>(
-        __length, __s.find_sequential_search_size);
+      _DifferenceType __sequential_search_size = std::min<_DifferenceType>
+	(__length, __s.find_sequential_search_size);
 
       // Try it sequentially first.
-    std::pair<_RAIter1, _RAIter2> __find_seq_result =
-      __selector._M_sequential_algorithm(
-        __begin1, __begin1 + __sequential_search_size, __begin2, __pred);
+      std::pair<_RAIter1, _RAIter2>
+	__find_seq_result = __selector._M_sequential_algorithm
+	(__begin1, __begin1 + __sequential_search_size, __begin2, __pred);
 
       if (__find_seq_result.first != (__begin1 + __sequential_search_size))
 	return __find_seq_result;
@@ -356,8 +356,9 @@ template<typename _RAIter1,
 
 	// Where to work (initialization).
 	_DifferenceType __start = __iteration_start + __iam * __block_size;
-        _DifferenceType __stop =
-            std::min<_DifferenceType>(__length, __start + __block_size);
+	_DifferenceType __stop = std::min<_DifferenceType>(__length,
+							   __start
+							   + __block_size);
 
 	std::pair<_RAIter1, _RAIter2> __local_result;
 
@@ -368,9 +369,11 @@ template<typename _RAIter1,
 	    // No chance to find first element.
 	    if (__result < __start)
 	      break;
-            __local_result = __selector._M_sequential_algorithm(
-                __begin1 + __start, __begin1 + __stop,
+
+	    __local_result = __selector._M_sequential_algorithm
+	      (__begin1 + __start, __begin1 + __stop,
 	       __begin2 + __start, __pred);
+
 	    if (__local_result.first != (__begin1 + __stop))
 	      {
 		omp_set_lock(&__result_lock);
@@ -385,16 +388,16 @@ template<typename _RAIter1,
 
 	    // Where to work.
 	    __start = __iteration_start + __iam * __block_size;
-            __stop = std::min<_DifferenceType>(
-                       __length, __start + __block_size);
+	    __stop = std::min<_DifferenceType>(__length,
+					       __start + __block_size);
 	  }
       } //parallel
 
       omp_destroy_lock(&__result_lock);
 
       // Return iterator on found element.
-    return
-      std::pair<_RAIter1, _RAIter2>(__begin1 + __result, __begin2 + __result);
+      return std::pair<_RAIter1, _RAIter2>(__begin1 + __result,
+					   __begin2 + __result);
     }
 #endif
 } // end namespace

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

@@ -143,8 +143,8 @@ namespace __gnu_parallel
       _M_sequential_algorithm(_RAIter1 __begin1,
 			      _RAIter1 __end1,
 			      _RAIter2 __begin2, _Pred __pred)
-      { return mismatch(__begin1, __end1, __begin2, __pred, sequential_tag());
-        }
+      { return mismatch(__begin1, __end1, __begin2,
+			__pred, sequential_tag()); }
   };
 
 
@@ -155,7 +155,8 @@ namespace __gnu_parallel
       _FIterator _M_begin;
       _FIterator _M_end;
 
-    explicit __find_first_of_selector(_FIterator __begin, _FIterator __end)
+      explicit __find_first_of_selector(_FIterator __begin,
+					_FIterator __end)
       : _M_begin(__begin), _M_end(__end) { }
 
       /** @brief Test on one position.
@@ -186,8 +187,8 @@ namespace __gnu_parallel
 				_RAIter1 __end1,
 				_RAIter2 __begin2, _Pred __pred)
         {
-        return std::make_pair(
-                 find_first_of(__begin1, __end1, _M_begin, _M_end, __pred,
+	  return std::make_pair(find_first_of(__begin1, __end1,
+					      _M_begin, _M_end, __pred,
 					      sequential_tag()), __begin2);
 	}
      };

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

@@ -69,31 +69,21 @@ namespace __gnu_parallel
                                       _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/list_partition.h

@@ -52,7 +52,7 @@ namespace __gnu_parallel
 			const bool __make_twice)
     {
       ++__count_to_two;
-      if (not __make_twice or __count_to_two < 2)
+      if (!__make_twice || __count_to_two < 2)
         __shrink(__os_starts, __count_to_two, __range_length);
       else
         {
@@ -112,7 +112,7 @@ namespace __gnu_parallel
 
       std::vector<_IIter> __os_starts(2 * __oversampling * __num_parts + 1);
 
-      __os_starts[0]= __begin;
+      __os_starts[0] = __begin;
       _IIter __prev  = __begin, __it = __begin;
       size_t __dist_limit = 0, __dist = 0;
       size_t __cur = 1, __next = 1;

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

@@ -40,7 +40,7 @@
 
 namespace __gnu_parallel
 {
-/**
+  /**
    * @brief Guarded loser/tournament tree.
    *
    * The smallest element is at the top.
@@ -52,7 +52,7 @@ namespace __gnu_parallel
    * @param _Tp the element type
    * @param _Compare the comparator to use, defaults to std::less<_Tp>
    */
-template<typename _Tp, typename _Compare>
+  template<typename _Tp, typename _Compare>
     class _LoserTreeBase
     {
     protected:
@@ -105,8 +105,8 @@ template<typename _Tp, typename _Compare>
 	_M_offset = _M_k;
 
 	// Avoid default-constructing _M_losers[]._M_key
-      _M_losers
-        = static_cast<_Loser*>(::operator new(2 * _M_k * sizeof(_Loser)));
+	_M_losers = static_cast<_Loser*>(::operator new(2 * _M_k
+							* sizeof(_Loser)));
 	for (unsigned int __i = _M_ik - 1; __i < _M_k; ++__i)
 	  _M_losers[__i + _M_k]._M_sup = true;
 
@@ -120,30 +120,30 @@ template<typename _Tp, typename _Compare>
       { ::operator delete(_M_losers); }
 
       /**
-     * @brief Initializes the sequence "_M_source" with the element "_M_key".
+       * @brief Initializes the sequence "_M_source" with the element "__key".
        *
-     * @param _M_key the element to insert
-     * @param _M_source __index of the __source __sequence
-     * @param _M_sup flag that determines whether the value to insert is an
+       * @param __key the element to insert
+       * @param __source __index of the __source __sequence
+       * @param __sup flag that determines whether the value to insert is an
        *   explicit __supremum.
        */
       void
-    __insert_start(const _Tp& _M_key, int _M_source, bool _M_sup)
+      __insert_start(const _Tp& __key, int __source, bool __sup)
       {
-      unsigned int __pos = _M_k + _M_source;
+	unsigned int __pos = _M_k + __source;
 
 	if(_M_first_insert)
 	  {
 	    // Construct all keys, so we can easily deconstruct them.
 	    for (unsigned int __i = 0; __i < (2 * _M_k); ++__i)
-	    new(&(_M_losers[__i]._M_key)) _Tp(_M_key);
+	      new(&(_M_losers[__i]._M_key)) _Tp(__key);
 	    _M_first_insert = false;
 	  }
 	else
-	new(&(_M_losers[__pos]._M_key)) _Tp(_M_key);
+	  new(&(_M_losers[__pos]._M_key)) _Tp(__key);
 
-      _M_losers[__pos]._M_sup = _M_sup;
-      _M_losers[__pos]._M_source = _M_source;
+	_M_losers[__pos]._M_sup = __sup;
+	_M_losers[__pos]._M_source = __source;
       }
 
       /**
@@ -161,7 +161,7 @@ template<typename _Tp, typename _Compare>
      *
      * Unstable variant is done using partial specialisation below.
      */
-template<bool __stable/* default == true */, typename _Tp,
+  template<bool __stable/* default == true */, typename _Tp,
 	   typename _Compare>
     class _LoserTree
     : public _LoserTreeBase<_Tp, _Compare>
@@ -183,8 +183,8 @@ template<bool __stable/* default == true */, typename _Tp,
 	  return __root;
 	else
 	  {
-	  unsigned int __left = __init_winner (2 * __root);
-	  unsigned int __right = __init_winner (2 * __root + 1);
+	    unsigned int __left = __init_winner(2 * __root);
+	    unsigned int __right = __init_winner(2 * __root + 1);
 	    if (_M_losers[__right]._M_sup
 		|| (!_M_losers[__left]._M_sup
 		    && !_M_comp(_M_losers[__right]._M_key,
@@ -212,38 +212,38 @@ template<bool __stable/* default == true */, typename _Tp,
        *
        * This implementation is stable.
        */
-    // Do not pass a const reference since _M_key will be used as
+      // Do not pass a const reference since __key will be used as
       // local variable.
       void
-    __delete_min_insert(_Tp _M_key, bool _M_sup)
+      __delete_min_insert(_Tp __key, bool __sup)
       {
 #if _GLIBCXX_ASSERTIONS
 	// no dummy sequence can ever be at the top!
 	_GLIBCXX_PARALLEL_ASSERT(_M_losers[0]._M_source != -1);
 #endif
 
-      int _M_source = _M_losers[0]._M_source;
-      for (unsigned int __pos = (_M_k + _M_source) / 2; __pos > 0;
+	int __source = _M_losers[0]._M_source;
+	for (unsigned int __pos = (_M_k + __source) / 2; __pos > 0;
 	     __pos /= 2)
 	  {
 	    // The smaller one gets promoted, ties are broken by _M_source.
-	  if ((_M_sup && (!_M_losers[__pos]._M_sup
-			  || _M_losers[__pos]._M_source < _M_source))
-	      || (!_M_sup && !_M_losers[__pos]._M_sup
-		  && ((_M_comp(_M_losers[__pos]._M_key, _M_key))
-		      || (!_M_comp(_M_key, _M_losers[__pos]._M_key)
-			  && _M_losers[__pos]._M_source < _M_source))))
+	    if ((__sup && (!_M_losers[__pos]._M_sup
+			   || _M_losers[__pos]._M_source < __source))
+		|| (!__sup && !_M_losers[__pos]._M_sup
+		    && ((_M_comp(_M_losers[__pos]._M_key, __key))
+			|| (!_M_comp(__key, _M_losers[__pos]._M_key)
+			    && _M_losers[__pos]._M_source < __source))))
 	      {
 		// The other one is smaller.
-	      std::swap(_M_losers[__pos]._M_sup, _M_sup);
-	      std::swap(_M_losers[__pos]._M_source, _M_source);
-	      std::swap(_M_losers[__pos]._M_key, _M_key);
+		std::swap(_M_losers[__pos]._M_sup, __sup);
+		std::swap(_M_losers[__pos]._M_source, __source);
+		std::swap(_M_losers[__pos]._M_key, __key);
 	      }
 	  }
 
-      _M_losers[0]._M_sup = _M_sup;
-      _M_losers[0]._M_source = _M_source;
-      _M_losers[0]._M_key = _M_key;
+	_M_losers[0]._M_sup = __sup;
+	_M_losers[0]._M_source = __source;
+	_M_losers[0]._M_key = __key;
       }
     };
 
@@ -252,7 +252,7 @@ template<bool __stable/* default == true */, typename _Tp,
      *
      * Stability (non-stable here) is selected with partial specialization.
      */
-template<typename _Tp, typename _Compare>
+  template<typename _Tp, typename _Compare>
     class _LoserTree</* __stable == */false, _Tp, _Compare>
     : public _LoserTreeBase<_Tp, _Compare>
     {
@@ -281,8 +281,8 @@ template<typename _Tp, typename _Compare>
 	  return __root;
 	else
 	  {
-	  unsigned int __left = __init_winner (2 * __root);
-	  unsigned int __right = __init_winner (2 * __root + 1);
+	    unsigned int __left = __init_winner(2 * __root);
+	    unsigned int __right = __init_winner(2 * __root + 1);
 	    if (_M_losers[__right]._M_sup
 		|| (!_M_losers[__left]._M_sup
 		    && !_M_comp(_M_losers[__right]._M_key,
@@ -306,47 +306,47 @@ template<typename _Tp, typename _Compare>
       { _M_losers[0] = _M_losers[__init_winner(1)]; }
 
       /**
-     * Delete the _M_key smallest element and insert the element _M_key
+       * Delete the _M_key smallest element and insert the element __key
        * instead.
        *
-     * @param _M_key the _M_key to insert
-     * @param _M_sup true iff _M_key is an explicitly marked supremum
+       * @param __key the _M_key to insert
+       * @param __sup true iff __key is an explicitly marked supremum
        */
-    // Do not pass a const reference since _M_key will be used as local
+      // Do not pass a const reference since __key will be used as local
       // variable.
       void
-    __delete_min_insert(_Tp _M_key, bool _M_sup)
+      __delete_min_insert(_Tp __key, bool __sup)
       {
 #if _GLIBCXX_ASSERTIONS
 	// no dummy sequence can ever be at the top!
 	_GLIBCXX_PARALLEL_ASSERT(_M_losers[0]._M_source != -1);
 #endif
 
-      int _M_source = _M_losers[0]._M_source;
-      for (unsigned int __pos = (_M_k + _M_source) / 2; __pos > 0;
+	int __source = _M_losers[0]._M_source;
+	for (unsigned int __pos = (_M_k + __source) / 2; __pos > 0;
 	     __pos /= 2)
 	  {
 	    // The smaller one gets promoted.
-	  if (_M_sup || (!_M_losers[__pos]._M_sup
-			 && _M_comp(_M_losers[__pos]._M_key, _M_key)))
+	    if (__sup || (!_M_losers[__pos]._M_sup
+			  && _M_comp(_M_losers[__pos]._M_key, __key)))
 	      {
 		// The other one is smaller.
-	      std::swap(_M_losers[__pos]._M_sup, _M_sup);
-	      std::swap(_M_losers[__pos]._M_source, _M_source);
-	      std::swap(_M_losers[__pos]._M_key, _M_key);
+		std::swap(_M_losers[__pos]._M_sup, __sup);
+		std::swap(_M_losers[__pos]._M_source, __source);
+		std::swap(_M_losers[__pos]._M_key, __key);
 	      }
 	  }
 
-      _M_losers[0]._M_sup = _M_sup;
-      _M_losers[0]._M_source = _M_source;
-      _M_losers[0]._M_key = _M_key;
+	_M_losers[0]._M_sup = __sup;
+	_M_losers[0]._M_source = __source;
+	_M_losers[0]._M_key = __key;
       }
     };
 
-/**
+  /**
    * @brief Base class of _Loser Tree implementation using pointers.
    */
-template<typename _Tp, typename _Compare>
+  template<typename _Tp, typename _Compare>
     class _LoserTreePointerBase
     {
     protected:
@@ -383,22 +383,22 @@ template<typename _Tp, typename _Compare>
       int __get_min_source()
       { return _M_losers[0]._M_source; }
 
-    void __insert_start(const _Tp& _M_key, int _M_source, bool _M_sup)
+      void __insert_start(const _Tp& __key, int __source, bool __sup)
       {
-      unsigned int __pos = _M_k + _M_source;
+	unsigned int __pos = _M_k + __source;
 
-      _M_losers[__pos]._M_sup = _M_sup;
-      _M_losers[__pos]._M_source = _M_source;
-      _M_losers[__pos]._M_keyp = &_M_key;
+	_M_losers[__pos]._M_sup = __sup;
+	_M_losers[__pos]._M_source = __source;
+	_M_losers[__pos]._M_keyp = &__key;
       }
     };
 
-/**
+  /**
    * @brief Stable _LoserTree implementation.
    *
    * The unstable variant is implemented using partial instantiation below.
    */
-template<bool __stable/* default == true */, typename _Tp, typename _Compare>
+  template<bool __stable/* default == true */, typename _Tp, typename _Compare>
     class _LoserTreePointer
     : public _LoserTreePointerBase<_Tp, _Compare>
     {
@@ -418,8 +418,8 @@ template<bool __stable/* default == true */, typename _Tp, typename _Compare>
 	  return __root;
 	else
 	  {
-	  unsigned int __left = __init_winner (2 * __root);
-	  unsigned int __right = __init_winner (2 * __root + 1);
+	    unsigned int __left = __init_winner(2 * __root);
+	    unsigned int __right = __init_winner(2 * __root + 1);
 	    if (_M_losers[__right]._M_sup
 		|| (!_M_losers[__left]._M_sup
 		    && !_M_comp(*_M_losers[__right]._M_keyp,
@@ -441,44 +441,45 @@ template<bool __stable/* default == true */, typename _Tp, typename _Compare>
       void __init()
       { _M_losers[0] = _M_losers[__init_winner(1)]; }
 
-    void __delete_min_insert(const _Tp& _M_key, bool _M_sup)
+      void __delete_min_insert(const _Tp& __key, bool __sup)
       {
 #if _GLIBCXX_ASSERTIONS
 	// no dummy sequence can ever be at the top!
 	_GLIBCXX_PARALLEL_ASSERT(_M_losers[0]._M_source != -1);
 #endif
 
-      const _Tp* _M_keyp = &_M_key;
-      int _M_source = _M_losers[0]._M_source;
-      for (unsigned int __pos = (_M_k + _M_source) / 2; __pos > 0; __pos /= 2)
+	const _Tp* __keyp = &__key;
+	int __source = _M_losers[0]._M_source;
+	for (unsigned int __pos = (_M_k + __source) / 2; __pos > 0;
+	     __pos /= 2)
 	  {
-	  // The smaller one gets promoted, ties are broken by _M_source.
-	  if ((_M_sup && (!_M_losers[__pos]._M_sup ||
-			  _M_losers[__pos]._M_source < _M_source)) ||
-              (!_M_sup && !_M_losers[__pos]._M_sup &&
-	       ((_M_comp(*_M_losers[__pos]._M_keyp, *_M_keyp)) ||
-                (!_M_comp(*_M_keyp, *_M_losers[__pos]._M_keyp)
-		 && _M_losers[__pos]._M_source < _M_source))))
+	    // The smaller one gets promoted, ties are broken by __source.
+	    if ((__sup && (!_M_losers[__pos]._M_sup
+			   || _M_losers[__pos]._M_source < __source))
+		|| (!__sup && !_M_losers[__pos]._M_sup &&
+		    ((_M_comp(*_M_losers[__pos]._M_keyp, *__keyp))
+		     || (!_M_comp(*__keyp, *_M_losers[__pos]._M_keyp)
+			 && _M_losers[__pos]._M_source < __source))))
 	      {
 		// The other one is smaller.
-	      std::swap(_M_losers[__pos]._M_sup, _M_sup);
-	      std::swap(_M_losers[__pos]._M_source, _M_source);
-	      std::swap(_M_losers[__pos]._M_keyp, _M_keyp);
+		std::swap(_M_losers[__pos]._M_sup, __sup);
+		std::swap(_M_losers[__pos]._M_source, __source);
+		std::swap(_M_losers[__pos]._M_keyp, __keyp);
 	      }
 	  }
 
-      _M_losers[0]._M_sup = _M_sup;
-      _M_losers[0]._M_source = _M_source;
-      _M_losers[0]._M_keyp = _M_keyp;
+	_M_losers[0]._M_sup = __sup;
+	_M_losers[0]._M_source = __source;
+	_M_losers[0]._M_keyp = __keyp;
       }
     };
 
-/**
+  /**
    * @brief Unstable _LoserTree implementation.
    *
    * The stable variant is above.
    */
-template<typename _Tp, typename _Compare>
+  template<typename _Tp, typename _Compare>
     class _LoserTreePointer</* __stable == */false, _Tp, _Compare>
     : public _LoserTreePointerBase<_Tp, _Compare>
     {
@@ -498,8 +499,8 @@ template<typename _Tp, typename _Compare>
 	  return __root;
 	else
 	  {
-	  unsigned int __left = __init_winner (2 * __root);
-	  unsigned int __right = __init_winner (2 * __root + 1);
+	    unsigned int __left = __init_winner(2 * __root);
+	    unsigned int __right = __init_winner(2 * __root + 1);
 	    if (_M_losers[__right]._M_sup
         	|| (!_M_losers[__left]._M_sup
 		    && !_M_comp(*_M_losers[__right]._M_keyp,
@@ -521,36 +522,36 @@ template<typename _Tp, typename _Compare>
       void __init()
       { _M_losers[0] = _M_losers[__init_winner(1)]; }
 
-    void __delete_min_insert(const _Tp& _M_key, bool _M_sup)
+      void __delete_min_insert(const _Tp& __key, bool __sup)
       {
 #if _GLIBCXX_ASSERTIONS
 	// no dummy sequence can ever be at the top!
 	_GLIBCXX_PARALLEL_ASSERT(_M_losers[0]._M_source != -1);
 #endif
 
-      const _Tp* _M_keyp = &_M_key;
-      int _M_source = _M_losers[0]._M_source;
-      for (unsigned int __pos = (_M_k + _M_source) / 2; __pos > 0;
+	const _Tp* __keyp = &__key;
+	int __source = _M_losers[0]._M_source;
+	for (unsigned int __pos = (_M_k + __source) / 2; __pos > 0;
 	     __pos /= 2)
 	  {
 	    // The smaller one gets promoted.
-	  if (_M_sup || (!_M_losers[__pos]._M_sup
-			 && _M_comp(*_M_losers[__pos]._M_keyp, *_M_keyp)))
+	    if (__sup || (!_M_losers[__pos]._M_sup
+			  && _M_comp(*_M_losers[__pos]._M_keyp, *__keyp)))
 	      {
 		// The other one is smaller.
-	      std::swap(_M_losers[__pos]._M_sup, _M_sup);
-	      std::swap(_M_losers[__pos]._M_source, _M_source);
-	      std::swap(_M_losers[__pos]._M_keyp, _M_keyp);
+		std::swap(_M_losers[__pos]._M_sup, __sup);
+		std::swap(_M_losers[__pos]._M_source, __source);
+		std::swap(_M_losers[__pos]._M_keyp, __keyp);
 	      }
 	  }
 
-      _M_losers[0]._M_sup = _M_sup;
-      _M_losers[0]._M_source = _M_source;
-      _M_losers[0]._M_keyp = _M_keyp;
+	_M_losers[0]._M_sup = __sup;
+	_M_losers[0]._M_source = __source;
+	_M_losers[0]._M_keyp = __keyp;
       }
     };
 
-/** @brief Base class for unguarded _LoserTree implementation.
+  /** @brief Base class for unguarded _LoserTree implementation.
    * 
    * The whole element is copied into the tree structure.
    *
@@ -560,7 +561,7 @@ template<typename _Tp, typename _Compare>
    *
    * This is a very fast variant.
    */
-template<typename _Tp, typename _Compare>
+  template<typename _Tp, typename _Compare>
     class _LoserTreeUnguardedBase
     {
     protected:
@@ -575,7 +576,7 @@ template<typename _Tp, typename _Compare>
       _Compare _M_comp;
 
     public:
-    _LoserTreeUnguardedBase(unsigned int __k, const _Tp _sentinel,
+      _LoserTreeUnguardedBase(unsigned int __k, const _Tp __sentinel,
 			      _Compare __comp = std::less<_Tp>())
       : _M_comp(__comp)
       {
@@ -585,12 +586,12 @@ template<typename _Tp, typename _Compare>
 	_M_k = 1 << (__rd_log2(_M_ik - 1) + 1);
 	_M_offset = _M_k;
 	// Avoid default-constructing _M_losers[]._M_key
-      _M_losers
-        = static_cast<_Loser*>(::operator new(2 * _M_k * sizeof(_Loser)));
+	_M_losers = static_cast<_Loser*>(::operator new(2 * _M_k
+							* sizeof(_Loser)));
 
 	for (unsigned int __i = _M_k + _M_ik - 1; __i < (2 * _M_k); ++__i)
 	  {
-	  _M_losers[__i]._M_key = _sentinel;
+	    _M_losers[__i]._M_key = __sentinel;
 	    _M_losers[__i]._M_source = -1;
 	  }
       }
@@ -609,21 +610,21 @@ template<typename _Tp, typename _Compare>
       }
 
       void
-    __insert_start(const _Tp& _M_key, int _M_source, bool)
+      __insert_start(const _Tp& __key, int __source, bool)
       {
-      unsigned int __pos = _M_k + _M_source;
+	unsigned int __pos = _M_k + __source;
 
-      new(&(_M_losers[__pos]._M_key)) _Tp(_M_key);
-      _M_losers[__pos]._M_source = _M_source;
+	new(&(_M_losers[__pos]._M_key)) _Tp(__key);
+	_M_losers[__pos]._M_source = __source;
       }
     };
 
-/**
+  /**
    * @brief Stable implementation of unguarded _LoserTree.
    *
    * Unstable variant is selected below with partial specialization.
    */
-template<bool __stable/* default == true */, typename _Tp, typename _Compare>
+  template<bool __stable/* default == true */, typename _Tp, typename _Compare>
     class _LoserTreeUnguarded
     : public _LoserTreeUnguardedBase<_Tp, _Compare>
     {
@@ -631,10 +632,10 @@ template<bool __stable/* default == true */, typename _Tp, typename _Compare>
       using _Base::_M_k;
       using _Base::_M_losers;
 
-public:
-    _LoserTreeUnguarded(unsigned int __k, const _Tp _sentinel,
+  public:
+      _LoserTreeUnguarded(unsigned int __k, const _Tp __sentinel,
 			  _Compare __comp = std::less<_Tp>())
-    : _Base::_LoserTreeUnguardedBase(__k, _sentinel, __comp)
+      : _Base::_LoserTreeUnguardedBase(__k, __sentinel, __comp)
       { }
 
       unsigned int
@@ -644,9 +645,10 @@ public:
 	  return __root;
 	else
 	  {
-	  unsigned int __left = __init_winner (2 * __root);
-	  unsigned int __right = __init_winner (2 * __root + 1);
-	  if (!_M_comp(_M_losers[__right]._M_key, _M_losers[__left]._M_key))
+	    unsigned int __left = __init_winner(2 * __root);
+	    unsigned int __right = __init_winner(2 * __root + 1);
+	    if (!_M_comp(_M_losers[__right]._M_key,
+			 _M_losers[__left]._M_key))
 	      {
 		// Left one is less or equal.
 		_M_losers[__root] = _M_losers[__right];
@@ -673,41 +675,42 @@ public:
 #endif
       }
 
-    // Do not pass a const reference since _M_key will be used as
+      // Do not pass a const reference since __key will be used as
       // local variable.
       void
-    __delete_min_insert(_Tp _M_key, bool)
+      __delete_min_insert(_Tp __key, bool)
       {
 #if _GLIBCXX_ASSERTIONS
 	// no dummy sequence can ever be at the top!
 	_GLIBCXX_PARALLEL_ASSERT(_M_losers[0]._M_source != -1);
 #endif
 
-      int _M_source = _M_losers[0]._M_source;
-      for (unsigned int __pos = (_M_k + _M_source) / 2; __pos > 0; __pos /= 2)
+	int __source = _M_losers[0]._M_source;
+	for (unsigned int __pos = (_M_k + __source) / 2; __pos > 0;
+	     __pos /= 2)
 	  {
 	    // The smaller one gets promoted, ties are broken by _M_source.
-	  if (_M_comp(_M_losers[__pos]._M_key, _M_key)
-              || (!_M_comp(_M_key, _M_losers[__pos]._M_key)
-                  && _M_losers[__pos]._M_source < _M_source))
+	    if (_M_comp(_M_losers[__pos]._M_key, __key)
+        	|| (!_M_comp(__key, _M_losers[__pos]._M_key)
+                    && _M_losers[__pos]._M_source < __source))
 	      {
 		// The other one is smaller.
-	      std::swap(_M_losers[__pos]._M_source, _M_source);
-	      std::swap(_M_losers[__pos]._M_key, _M_key);
+		std::swap(_M_losers[__pos]._M_source, __source);
+		std::swap(_M_losers[__pos]._M_key, __key);
 	      }
 	  }
 
-      _M_losers[0]._M_source = _M_source;
-      _M_losers[0]._M_key = _M_key;
+	_M_losers[0]._M_source = __source;
+	_M_losers[0]._M_key = __key;
       }
     };
 
-/**
+  /**
    * @brief Non-Stable implementation of unguarded _LoserTree.
    *
    * Stable implementation is above.
    */
-template<typename _Tp, typename _Compare>
+  template<typename _Tp, typename _Compare>
     class _LoserTreeUnguarded</* __stable == */false, _Tp, _Compare>
     : public _LoserTreeUnguardedBase<_Tp, _Compare>
     {
@@ -715,10 +718,10 @@ template<typename _Tp, typename _Compare>
       using _Base::_M_k;
       using _Base::_M_losers;
 
-public:
-    _LoserTreeUnguarded(unsigned int __k, const _Tp _sentinel,
+    public:
+      _LoserTreeUnguarded(unsigned int __k, const _Tp __sentinel,
 			  _Compare __comp = std::less<_Tp>())
-    : _Base::_LoserTreeUnguardedBase(__k, _sentinel, __comp)
+      : _Base::_LoserTreeUnguardedBase(__k, __sentinel, __comp)
       { }
 
       unsigned int
@@ -728,8 +731,8 @@ public:
 	  return __root;
 	else
 	  {
-	  unsigned int __left = __init_winner (2 * __root);
-	  unsigned int __right = __init_winner (2 * __root + 1);
+	    unsigned int __left = __init_winner(2 * __root);
+	    unsigned int __right = __init_winner(2 * __root + 1);
 
 #if _GLIBCXX_ASSERTIONS
 	    // If __left one is sentinel then __right one must be, too.
@@ -737,7 +740,8 @@ public:
 	      _GLIBCXX_PARALLEL_ASSERT(_M_losers[__right]._M_source == -1);
 #endif
 
-	  if (!_M_comp(_M_losers[__right]._M_key, _M_losers[__left]._M_key))
+	    if (!_M_comp(_M_losers[__right]._M_key,
+			 _M_losers[__left]._M_key))
 	      {
 		// Left one is less or equal.
 		_M_losers[__root] = _M_losers[__right];
@@ -764,40 +768,41 @@ public:
 #endif
       }
 
-    // Do not pass a const reference since _M_key will be used as
+      // Do not pass a const reference since __key will be used as
       // local variable.
       void
-    __delete_min_insert(_Tp _M_key, bool)
+      __delete_min_insert(_Tp __key, bool)
       {
 #if _GLIBCXX_ASSERTIONS
 	// no dummy sequence can ever be at the top!
 	_GLIBCXX_PARALLEL_ASSERT(_M_losers[0]._M_source != -1);
 #endif
 
-      int _M_source = _M_losers[0]._M_source;
-      for (unsigned int __pos = (_M_k + _M_source) / 2; __pos > 0; __pos /= 2)
+	int __source = _M_losers[0]._M_source;
+	for (unsigned int __pos = (_M_k + __source) / 2; __pos > 0;
+	     __pos /= 2)
 	  {
 	    // The smaller one gets promoted.
-	  if (_M_comp(_M_losers[__pos]._M_key, _M_key))
+	    if (_M_comp(_M_losers[__pos]._M_key, __key))
 	      {
 		// The other one is smaller.
-	      std::swap(_M_losers[__pos]._M_source, _M_source);
-	      std::swap(_M_losers[__pos]._M_key, _M_key);
+		std::swap(_M_losers[__pos]._M_source, __source);
+		std::swap(_M_losers[__pos]._M_key, __key);
 	      }
 	  }
 
-      _M_losers[0]._M_source = _M_source;
-      _M_losers[0]._M_key = _M_key;
+	_M_losers[0]._M_source = __source;
+	_M_losers[0]._M_key = __key;
       }
     };
 
-/** @brief Unguarded loser tree, keeping only pointers to the
-* elements in the tree structure.
-*
-*  No guarding is done, therefore not a single input sequence must
-*  run empty.  This is a very fast variant.
-*/
-template<typename _Tp, typename _Compare>
+  /** @brief Unguarded loser tree, keeping only pointers to the
+  * elements in the tree structure.
+  *
+  *  No guarding is done, therefore not a single input sequence must
+  *  run empty.  This is a very fast variant.
+  */
+  template<typename _Tp, typename _Compare>
     class _LoserTreePointerUnguardedBase
     {
     protected:
@@ -813,7 +818,7 @@ template<typename _Tp, typename _Compare>
 
     public:
 
-    _LoserTreePointerUnguardedBase(unsigned int __k, const _Tp& _sentinel,
+      _LoserTreePointerUnguardedBase(unsigned int __k, const _Tp& __sentinel,
 				     _Compare __comp = std::less<_Tp>())
       : _M_comp(__comp)
       {
@@ -827,7 +832,7 @@ template<typename _Tp, typename _Compare>
 
 	for (unsigned int __i = _M_k + _M_ik - 1; __i < (2 * _M_k); ++__i)
 	  {
-	  _M_losers[__i]._M_keyp = &_sentinel;
+	    _M_losers[__i]._M_keyp = &__sentinel;
 	    _M_losers[__i]._M_source = -1;
 	  }
       }
@@ -846,21 +851,21 @@ template<typename _Tp, typename _Compare>
       }
 
       void
-    __insert_start(const _Tp& _M_key, int _M_source, bool)
+      __insert_start(const _Tp& __key, int __source, bool)
       {
-      unsigned int __pos = _M_k + _M_source;
+	unsigned int __pos = _M_k + __source;
 
-      _M_losers[__pos]._M_keyp = &_M_key;
-      _M_losers[__pos]._M_source = _M_source;
+	_M_losers[__pos]._M_keyp = &__key;
+	_M_losers[__pos]._M_source = __source;
       }
     };
 
-/**
+  /**
    * @brief Stable unguarded _LoserTree variant storing pointers.
    *
    * Unstable variant is implemented below using partial specialization.
    */
-template<bool __stable/* default == true */, typename _Tp, typename _Compare>
+  template<bool __stable/* default == true */, typename _Tp, typename _Compare>
     class _LoserTreePointerUnguarded
     : public _LoserTreePointerUnguardedBase<_Tp, _Compare>
     {
@@ -869,9 +874,9 @@ template<bool __stable/* default == true */, typename _Tp, typename _Compare>
       using _Base::_M_losers;
 
     public:
-    _LoserTreePointerUnguarded(unsigned int __k, const _Tp& _sentinel,
+      _LoserTreePointerUnguarded(unsigned int __k, const _Tp& __sentinel,
 				 _Compare __comp = std::less<_Tp>())
-    : _Base::_LoserTreePointerUnguardedBase(__k, _sentinel, __comp)
+      : _Base::_LoserTreePointerUnguardedBase(__k, __sentinel, __comp)
       { }
 
       unsigned int
@@ -881,8 +886,8 @@ template<bool __stable/* default == true */, typename _Tp, typename _Compare>
 	  return __root;
 	else
 	  {
-	  unsigned int __left = __init_winner (2 * __root);
-	  unsigned int __right = __init_winner (2 * __root + 1);
+	    unsigned int __left = __init_winner(2 * __root);
+	    unsigned int __right = __init_winner(2 * __root + 1);
 	    if (!_M_comp(*_M_losers[__right]._M_keyp,
 			 *_M_losers[__left]._M_keyp))
 	      {
@@ -912,39 +917,40 @@ template<bool __stable/* default == true */, typename _Tp, typename _Compare>
       }
 
       void
-    __delete_min_insert(const _Tp& _M_key, bool _M_sup)
+      __delete_min_insert(const _Tp& __key, bool __sup)
       {
 #if _GLIBCXX_ASSERTIONS
 	// no dummy sequence can ever be at the top!
 	_GLIBCXX_PARALLEL_ASSERT(_M_losers[0]._M_source != -1);
 #endif
 
-      const _Tp* _M_keyp = &_M_key;
-      int _M_source = _M_losers[0]._M_source;
-      for (unsigned int __pos = (_M_k + _M_source) / 2; __pos > 0; __pos /= 2)
+	const _Tp* __keyp = &__key;
+	int __source = _M_losers[0]._M_source;
+	for (unsigned int __pos = (_M_k + __source) / 2; __pos > 0;
+	     __pos /= 2)
 	  {
 	    // The smaller one gets promoted, ties are broken by _M_source.
-	  if (_M_comp(*_M_losers[__pos]._M_keyp, *_M_keyp)
-	      || (!_M_comp(*_M_keyp, *_M_losers[__pos]._M_keyp)
-		  && _M_losers[__pos]._M_source < _M_source))
+	    if (_M_comp(*_M_losers[__pos]._M_keyp, *__keyp)
+		|| (!_M_comp(*__keyp, *_M_losers[__pos]._M_keyp)
+		    && _M_losers[__pos]._M_source < __source))
 	      {
 		// The other one is smaller.
-	      std::swap(_M_losers[__pos]._M_source, _M_source);
-	      std::swap(_M_losers[__pos]._M_keyp, _M_keyp);
+		std::swap(_M_losers[__pos]._M_source, __source);
+		std::swap(_M_losers[__pos]._M_keyp, __keyp);
 	      }
 	  }
 
-      _M_losers[0]._M_source = _M_source;
-      _M_losers[0]._M_keyp = _M_keyp;
+	_M_losers[0]._M_source = __source;
+	_M_losers[0]._M_keyp = __keyp;
       }
     };
 
-/**
+  /**
    * @brief Unstable unguarded _LoserTree variant storing pointers.
    *
    * Stable variant is above.
    */
-template<typename _Tp, typename _Compare>
+  template<typename _Tp, typename _Compare>
     class _LoserTreePointerUnguarded</* __stable == */false, _Tp, _Compare>
     : public _LoserTreePointerUnguardedBase<_Tp, _Compare>
     {
@@ -952,10 +958,10 @@ template<typename _Tp, typename _Compare>
       using _Base::_M_k;
       using _Base::_M_losers;
 
-public:
-    _LoserTreePointerUnguarded(unsigned int __k, const _Tp& _sentinel,
+  public:
+      _LoserTreePointerUnguarded(unsigned int __k, const _Tp& __sentinel,
 				 _Compare __comp = std::less<_Tp>())
-    : _Base::_LoserTreePointerUnguardedBase(__k, _sentinel, __comp)
+      : _Base::_LoserTreePointerUnguardedBase(__k, __sentinel, __comp)
       { }
 
       unsigned int
@@ -965,8 +971,8 @@ public:
 	  return __root;
 	else
 	  {
-	  unsigned int __left = __init_winner (2 * __root);
-	  unsigned int __right = __init_winner (2 * __root + 1);
+	    unsigned int __left = __init_winner(2 * __root);
+	    unsigned int __right = __init_winner(2 * __root + 1);
 
 #if _GLIBCXX_ASSERTIONS
 	    // If __left one is sentinel then __right one must be, too.
@@ -1003,28 +1009,29 @@ public:
       }
 
       void
-    __delete_min_insert(const _Tp& _M_key, bool _M_sup)
+      __delete_min_insert(const _Tp& __key, bool __sup)
       {
 #if _GLIBCXX_ASSERTIONS
 	// no dummy sequence can ever be at the top!
 	_GLIBCXX_PARALLEL_ASSERT(_M_losers[0]._M_source != -1);
 #endif
 
-      const _Tp* _M_keyp = &_M_key;
-      int _M_source = _M_losers[0]._M_source;
-      for (unsigned int __pos = (_M_k + _M_source) / 2; __pos > 0; __pos /= 2)
+	const _Tp* __keyp = &__key;
+	int __source = _M_losers[0]._M_source;
+	for (unsigned int __pos = (_M_k + __source) / 2; __pos > 0;
+	     __pos /= 2)
 	  {
 	    // The smaller one gets promoted.
-	  if (_M_comp(*(_M_losers[__pos]._M_keyp), *_M_keyp))
+	    if (_M_comp(*(_M_losers[__pos]._M_keyp), *__keyp))
 	      {
 		// The other one is smaller.
-	      std::swap(_M_losers[__pos]._M_source, _M_source);
-	      std::swap(_M_losers[__pos]._M_keyp, _M_keyp);
+		std::swap(_M_losers[__pos]._M_source, __source);
+		std::swap(_M_losers[__pos]._M_keyp, __keyp);
 	      }
 	  }
 
-      _M_losers[0]._M_source = _M_source;
-      _M_losers[0]._M_keyp = _M_keyp;
+	_M_losers[0]._M_source = __source;
+	_M_losers[0]._M_keyp = __keyp;
       }
     };
 } // namespace __gnu_parallel

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

@@ -54,10 +54,9 @@ namespace __gnu_parallel
            typename _OutputIterator, typename _DifferenceTp,
            typename _Compare>
     _OutputIterator
-    __merge_advance_usual(_RAIter1& __begin1,
-                        _RAIter1 __end1,
-                        _RAIter2& __begin2,
-                        _RAIter2 __end2, _OutputIterator __target,
+    __merge_advance_usual(_RAIter1& __begin1, _RAIter1 __end1,
+			  _RAIter2& __begin2, _RAIter2 __end2,
+			  _OutputIterator __target,
 			  _DifferenceTp __max_length, _Compare __comp)
     {
       typedef _DifferenceTp _DifferenceType;
@@ -103,10 +102,8 @@ namespace __gnu_parallel
            typename _OutputIterator, typename _DifferenceTp,
            typename _Compare>
     _OutputIterator
-    __merge_advance_movc(_RAIter1& __begin1,
-                       _RAIter1 __end1,
-                       _RAIter2& __begin2,
-                       _RAIter2 __end2,
+    __merge_advance_movc(_RAIter1& __begin1, _RAIter1 __end1,
+			 _RAIter2& __begin2, _RAIter2 __end2,
 			 _OutputIterator __target,
 			 _DifferenceTp __max_length, _Compare __comp)
     {
@@ -178,8 +175,8 @@ namespace __gnu_parallel
     {
       _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
@@ -195,13 +192,11 @@ namespace __gnu_parallel
   template<typename _RAIter1, typename _RAIter2,
            typename _RAIter3, typename _Compare>
     inline _RAIter3
-    __parallel_merge_advance(_RAIter1& __begin1,
-                           _RAIter1 __end1,
+    __parallel_merge_advance(_RAIter1& __begin1, _RAIter1 __end1,
 			     _RAIter2& __begin2,
 			     // different iterators, parallel implementation
 			     // not available
-                           _RAIter2 __end2,
-                           _RAIter3 __target, typename
+			     _RAIter2 __end2, _RAIter3 __target, typename
 			     std::iterator_traits<_RAIter1>::
 			     difference_type __max_length, _Compare __comp)
     { return __merge_advance(__begin1, __end1, __begin2, __end2, __target,
@@ -225,10 +220,8 @@ namespace __gnu_parallel
   template<typename _RAIter1, typename _RAIter3,
            typename _Compare>
     inline _RAIter3
-    __parallel_merge_advance(_RAIter1& __begin1,
-                           _RAIter1 __end1,
-                           _RAIter1& __begin2,
-                           _RAIter1 __end2,
+    __parallel_merge_advance(_RAIter1& __begin1, _RAIter1 __end1,
+			     _RAIter1& __begin2, _RAIter1 __end2,
 			     _RAIter3 __target, typename
 			     std::iterator_traits<_RAIter1>::
 			     difference_type __max_length, _Compare __comp)
@@ -242,17 +235,14 @@ namespace __gnu_parallel
       typedef typename std::pair<_RAIter1, _RAIter1>
         _IteratorPair;
 
-      _IteratorPair
-        seqs[2] = { std::make_pair(__begin1, __end1),
+      _IteratorPair __seqs[2] = { std::make_pair(__begin1, __end1),
 				  std::make_pair(__begin2, __end2) };
-      _RAIter3
-        __target_end = parallel_multiway_merge
-          < /* __stable = */ true, /* __sentinels = */ false>(
-            seqs, seqs + 2, __target,
-            multiway_merge_exact_splitting
+      _RAIter3 __target_end = parallel_multiway_merge
+	< /* __stable = */ true, /* __sentinels = */ false>
+	(__seqs, __seqs + 2, __target, multiway_merge_exact_splitting
 	 < /* __stable = */ true, _IteratorPair*,
-                _Compare, _DifferenceType1>,
-            __max_length, __comp, omp_get_max_threads());
+	 _Compare, _DifferenceType1>, __max_length, __comp,
+	 omp_get_max_threads());
 
       return __target_end;
     }

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

@@ -53,8 +53,8 @@ namespace __gnu_parallel
   /** @brief Compare __a pair of types lexicographically, ascending. */
   template<typename _T1, typename _T2, typename _Compare>
     class _Lexicographic
-    : public std::binary_function<
-                                std::pair<_T1, _T2>, std::pair<_T1, _T2>, bool>
+    : public std::binary_function<std::pair<_T1, _T2>,
+				  std::pair<_T1, _T2>, bool>
     {
     private:
       _Compare& _M_comp;
@@ -142,19 +142,19 @@ namespace __gnu_parallel
 
       // Number of sequences, number of elements in total (possibly
       // including padding).
-      _DifferenceType __m = std::distance(__begin_seqs, __end_seqs), __N = 0,
+      _DifferenceType __m = std::distance(__begin_seqs, __end_seqs), __nn = 0,
                       __nmax, __n, __r;
 
       for (int __i = 0; __i < __m; __i++)
         {
-          __N += std::distance(__begin_seqs[__i].first,
+          __nn += std::distance(__begin_seqs[__i].first,
                                __begin_seqs[__i].second);
           _GLIBCXX_PARALLEL_ASSERT(
             std::distance(__begin_seqs[__i].first,
                           __begin_seqs[__i].second) > 0);
         }
 
-      if (__rank == __N)
+      if (__rank == __nn)
         {
           for (int __i = 0; __i < __m; __i++)
             __begin_offsets[__i] = __begin_seqs[__i].second; // Very end.
@@ -163,9 +163,9 @@ namespace __gnu_parallel
         }
 
       _GLIBCXX_PARALLEL_ASSERT(__m != 0);
-      _GLIBCXX_PARALLEL_ASSERT(__N != 0);
+      _GLIBCXX_PARALLEL_ASSERT(__nn != 0);
       _GLIBCXX_PARALLEL_ASSERT(__rank >= 0);
-      _GLIBCXX_PARALLEL_ASSERT(__rank < __N);
+      _GLIBCXX_PARALLEL_ASSERT(__rank < __nn);
 
       _DifferenceType* __ns = new _DifferenceType[__m];
       _DifferenceType* __a = new _DifferenceType[__m];
@@ -401,14 +401,14 @@ namespace __gnu_parallel
       // Number of sequences, number of elements in total (possibly
       // including padding).
       _DifferenceType __m = std::distance(__begin_seqs, __end_seqs);
-      _DifferenceType __N = 0;
+      _DifferenceType __nn = 0;
       _DifferenceType __nmax, __n, __r;
 
       for (int __i = 0; __i < __m; __i++)
-        __N += std::distance(__begin_seqs[__i].first,
+        __nn += std::distance(__begin_seqs[__i].first,
 			      __begin_seqs[__i].second);
 
-      if (__m == 0 || __N == 0 || __rank < 0 || __rank >= __N)
+      if (__m == 0 || __nn == 0 || __rank < 0 || __rank >= __nn)
         {
           // result undefined if there is no data or __rank is outside bounds
           throw std::exception();
@@ -433,7 +433,7 @@ namespace __gnu_parallel
 
       // Pad all lists to this length, at least as long as any ns[__i],
       // equality iff __nmax = 2^__k - 1
-      __l = pow2(__r) - 1;
+      __l = __round_up_to_pow2(__r) - 1;
 
       for (int __i = 0; __i < __m; ++__i)
         {

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

@@ -54,7 +54,7 @@
 
 namespace __gnu_parallel
 {
-/** @brief _Iterator wrapper supporting an implicit supremum at the end
+  /** @brief _Iterator wrapper supporting an implicit supremum at the end
    *         of the sequence, dominating all comparisons.
    *
    * The implicit supremum comes with a performance cost.
@@ -62,7 +62,7 @@ namespace __gnu_parallel
    * Deriving from _RAIter is not possible since
    * _RAIter need not be a class.
    */
-template<typename _RAIter, typename _Compare>
+  template<typename _RAIter, typename _Compare>
     class _GuardedIterator
     {
     private:
@@ -113,11 +113,11 @@ template<typename _RAIter, typename _Compare>
       operator<(_GuardedIterator<_RAIter, _Compare>& __bi1,
 		_GuardedIterator<_RAIter, _Compare>& __bi2)
       {
-      if (__bi1._M_current == __bi1._M_end)       //__bi1 is sup
-	return __bi2._M_current == __bi2._M_end;  //__bi2 is not sup
-      if (__bi2._M_current == __bi2._M_end)       //__bi2 is sup
+	if (__bi1._M_current == __bi1._M_end)       // __bi1 is sup
+	  return __bi2._M_current == __bi2._M_end;  // __bi2 is not sup
+	if (__bi2._M_current == __bi2._M_end)       // __bi2 is sup
 	  return true;
-      return (__bi1.__comp)(*__bi1, *__bi2);      //normal compare
+	return (__bi1.__comp)(*__bi1, *__bi2);      // normal compare
       }
 
       /** @brief Compare two elements referenced by guarded iterators.
@@ -128,15 +128,15 @@ template<typename _RAIter, typename _Compare>
       operator<=(_GuardedIterator<_RAIter, _Compare>& __bi1,
 		 _GuardedIterator<_RAIter, _Compare>& __bi2)
       {
-      if (__bi2._M_current == __bi2._M_end)       //__bi1 is sup
-	return __bi1._M_current != __bi1._M_end;  //__bi2 is not sup
-      if (__bi1._M_current == __bi1._M_end)       //__bi2 is sup
+	if (__bi2._M_current == __bi2._M_end)       // __bi1 is sup
+	  return __bi1._M_current != __bi1._M_end;  // __bi2 is not sup
+	if (__bi1._M_current == __bi1._M_end)       // __bi2 is sup
 	  return false;
-      return !(__bi1.__comp)(*__bi2, *__bi1);     //normal compare
+	return !(__bi1.__comp)(*__bi2, *__bi1);     // normal compare
       } 
     };
 
-template<typename _RAIter, typename _Compare>
+  template<typename _RAIter, typename _Compare>
     class _UnguardedIterator
     {
     private:
@@ -200,7 +200,7 @@ template<typename _RAIter, typename _Compare>
       }
     };
 
-/** @brief Highly efficient 3-way merging procedure.
+  /** @brief Highly efficient 3-way merging procedure.
    *
    * Merging is done with the algorithm implementation described by Peter
    * Sanders.  Basically, the idea is to minimize the number of necessary
@@ -225,7 +225,7 @@ template<typename _RAIter, typename _Compare>
    *
    * @return End iterator of output sequence.
    */
-template<template<typename RAI, typename C> class iterator,
+  template<template<typename RAI, typename C> class iterator,
            typename _RAIterIterator,
            typename _RAIter3,
            typename _DifferenceTp,
@@ -250,7 +250,7 @@ template<template<typename RAI, typename C> class iterator,
 	return __target;
 
 #if _GLIBCXX_ASSERTIONS
-    _DifferenceTp orig_length = __length;
+      _DifferenceTp __orig_length = __length;
 #endif
 
       iterator<_RAIter1, _Compare>
@@ -280,15 +280,15 @@ template<template<typename RAI, typename C> class iterator,
           else
             goto __s210;
 	}
-#define _GLIBCXX_PARALLEL_MERGE_3_CASE(__a,__b,__c,c0,c1)     \
+#define _GLIBCXX_PARALLEL_MERGE_3_CASE(__a, __b, __c, __c0, __c1) \
       __s ## __a ## __b ## __c :                            \
 	*__target = *__seq ## __a;                          \
 	++__target;                                         \
 	--__length;                                         \
 	++__seq ## __a;                                     \
-      if (__length == 0) goto finish;                     \
-      if (__seq ## __a c0 __seq ## __b) goto __s ## __a ## __b ## __c;  \
-      if (__seq ## __a c1 __seq ## __c) goto __s ## __b ## __a ## __c;  \
+	if (__length == 0) goto __finish;                   \
+	if (__seq ## __a __c0 __seq ## __b) goto __s ## __a ## __b ## __c; \
+	if (__seq ## __a __c1 __seq ## __c) goto __s ## __b ## __a ## __c; \
 	goto __s ## __b ## __c ## __a;
 
       _GLIBCXX_PARALLEL_MERGE_3_CASE(0, 1, 2, <=, <=);
@@ -300,7 +300,7 @@ template<template<typename RAI, typename C> class iterator,
 
 #undef _GLIBCXX_PARALLEL_MERGE_3_CASE
 
-  finish:
+    __finish:
       ;
 
 #if _GLIBCXX_ASSERTIONS
@@ -308,7 +308,7 @@ template<template<typename RAI, typename C> class iterator,
 	((_RAIter1)__seq0 - __seqs_begin[0].first) +
 	((_RAIter1)__seq1 - __seqs_begin[1].first) +
 	((_RAIter1)__seq2 - __seqs_begin[2].first)
-      == orig_length);
+	== __orig_length);
 #endif
 
       __seqs_begin[0].first = __seq0;
@@ -318,7 +318,7 @@ template<template<typename RAI, typename C> class iterator,
       return __target;
     }
 
-/**
+  /**
    * @brief Highly efficient 4-way merging procedure.
    *
    * Merging is done with the algorithm implementation described by Peter
@@ -344,7 +344,7 @@ template<template<typename RAI, typename C> class iterator,
    *
    * @return End iterator of output sequence.
    */
-template<template<typename RAI, typename C> class iterator,
+  template<template<typename RAI, typename C> class iterator,
            typename _RAIterIterator,
            typename _RAIter3,
            typename _DifferenceTp,
@@ -370,11 +370,14 @@ template<template<typename RAI, typename C> class iterator,
 	__seq2(__seqs_begin[2].first, __seqs_begin[2].second, __comp),
 	__seq3(__seqs_begin[3].first, __seqs_begin[3].second, __comp);
 
-#define _GLIBCXX_PARALLEL_DECISION(__a,__b,__c,d) {                      \
-      if (__seq ## d < __seq ## __a) goto __s ## d ## __a ## __b ## __c; \
-      if (__seq ## d < __seq ## __b) goto __s ## __a ## d ## __b ## __c; \
-      if (__seq ## d < __seq ## __c) goto __s ## __a ## __b ## d ## __c; \
-      goto __s ## __a ## __b ## __c ## d;  }
+#define _GLIBCXX_PARALLEL_DECISION(__a, __b, __c, __d) {  \
+	if (__seq ## __d < __seq ## __a)		  \
+	  goto __s ## __d ## __a ## __b ## __c;		  \
+	if (__seq ## __d < __seq ## __b)		  \
+	  goto __s ## __a ## __d ## __b ## __c;		  \
+	if (__seq ## __d < __seq ## __c)		  \
+	  goto __s ## __a ## __b ## __d ## __c;		  \
+	goto __s ## __a ## __b ## __c ## __d;  }
 
       if (__seq0 <= __seq1)
 	{
@@ -399,17 +402,21 @@ template<template<typename RAI, typename C> class iterator,
             _GLIBCXX_PARALLEL_DECISION(2,1,0,3)
               }
 
-#define _GLIBCXX_PARALLEL_MERGE_4_CASE(__a,__b,__c,d,c0,c1,c2)            \
-    __s ## __a ## __b ## __c ## d:                                        \
-      if (__length == 0) goto finish;                                     \
+#define _GLIBCXX_PARALLEL_MERGE_4_CASE(__a, __b, __c, __d,  \
+				       __c0, __c1, __c2)    \
+      __s ## __a ## __b ## __c ## __d:                      \
+      if (__length == 0) goto __finish;                     \
       *__target = *__seq ## __a;                            \
       ++__target;                                           \
       --__length;                                           \
       ++__seq ## __a;                                       \
-    if (__seq ## __a c0 __seq ## __b) goto __s ## __a ## __b ## __c ## d; \
-    if (__seq ## __a c1 __seq ## __c) goto __s ## __b ## __a ## __c ## d; \
-    if (__seq ## __a c2 __seq ## d) goto __s ## __b ## __c ## __a ## d;   \
-    goto __s ## __b ## __c ## d ## __a;
+      if (__seq ## __a __c0 __seq ## __b)      \
+	goto __s ## __a ## __b ## __c ## __d;  \
+      if (__seq ## __a __c1 __seq ## __c)      \
+	goto __s ## __b ## __a ## __c ## __d;  \
+      if (__seq ## __a __c2 __seq ## __d)      \
+	goto __s ## __b ## __c ## __a ## __d;  \
+      goto __s ## __b ## __c ## __d ## __a;
 
       _GLIBCXX_PARALLEL_MERGE_4_CASE(0, 1, 2, 3, <=, <=, <=);
       _GLIBCXX_PARALLEL_MERGE_4_CASE(0, 1, 3, 2, <=, <=, <=);
@@ -439,7 +446,7 @@ template<template<typename RAI, typename C> class iterator,
 #undef _GLIBCXX_PARALLEL_MERGE_4_CASE
 #undef _GLIBCXX_PARALLEL_DECISION
 
-  finish:
+    __finish:
       ;
 
       __seqs_begin[0].first = __seq0;
@@ -450,7 +457,7 @@ template<template<typename RAI, typename C> class iterator,
       return __target;
     }
 
-/** @brief Multi-way merging procedure for a high branching factor,
+  /** @brief Multi-way merging procedure for a high branching factor,
    *         guarded case.
    *
    * This merging variant uses a LoserTree class as selected by <tt>_LT</tt>.
@@ -468,7 +475,7 @@ template<template<typename RAI, typename C> class iterator,
    *
    * @return End iterator of output sequence.
    */
-template<typename _LT,
+  template<typename _LT,
            typename _RAIterIterator,
            typename _RAIter3,
            typename _DifferenceTp,
@@ -532,7 +539,7 @@ template<typename _LT,
       return __target;
     }
 
-/** @brief Multi-way merging procedure for a high branching factor,
+  /** @brief Multi-way merging procedure for a high branching factor,
    *         unguarded case.
    *
    * Merging is done using the LoserTree class <tt>_LT</tt>.
@@ -550,7 +557,7 @@ template<typename _LT,
    *
    * @return End iterator of output sequence.
    */
-template<typename _LT,
+  template<typename _LT,
 	   typename _RAIterIterator,
 	   typename _RAIter3,
 	   typename _DifferenceTp, typename _Compare>
@@ -620,7 +627,7 @@ template<typename _LT,
     }
 
 
-/** @brief Multi-way merging procedure for a high branching factor,
+  /** @brief Multi-way merging procedure for a high branching factor,
    *         requiring sentinels to exist.
    *
    * @param __stable The value must the same as for the used LoserTrees.
@@ -638,7 +645,7 @@ template<typename _LT,
    *
    * @return End iterator of output sequence.
    */
-template<typename UnguardedLoserTree,
+  template<typename UnguardedLoserTree,
 	   typename _RAIterIterator,
 	   typename _RAIter3,
 	   typename _DifferenceTp,
@@ -672,8 +679,7 @@ template<typename UnguardedLoserTree,
 	// non-sentinel elements as we have.
 	++((*__s).second);
 
-    __target_end = multiway_merge_loser_tree_unguarded
-        <UnguardedLoserTree>
+      __target_end = multiway_merge_loser_tree_unguarded<UnguardedLoserTree>
 	(__seqs_begin, __seqs_end, __target, __sentinel, __length, __comp);
 
 #if _GLIBCXX_ASSERTIONS
@@ -689,12 +695,12 @@ template<typename UnguardedLoserTree,
       return __target_end;
     }
 
-/**
+  /**
    * @brief Traits for determining whether the loser tree should
    *   use pointers or copies.
    *
- * The field "_M_use_pointer" is used to determine whether to use pointers in
- * the loser trees or whether to copy the values into the loser tree.
+   * The field "_M_use_pointer" is used to determine whether to use pointers
+   * in he loser trees or whether to copy the values into the loser tree.
    *
    * The default behavior is to use pointers if the data type is 4 times as
    * big as the pointer to it.
@@ -713,7 +719,7 @@ template<typename UnguardedLoserTree,
    *
    * @param _Tp type to give the loser tree traits for.
    */
-template <typename _Tp>
+  template <typename _Tp>
     struct _LoserTreeTraits
     {
       /**
@@ -725,12 +731,12 @@ template <typename _Tp>
       static const bool _M_use_pointer = (sizeof(_Tp) > 4 * sizeof(_Tp*));
     };
 
-/**
+  /**
    * @brief Switch for 3-way merging with __sentinels turned off.
    *
    * Note that 3-way merging is always stable!
    */
-template<bool __sentinels /*default == false*/,
+  template<bool __sentinels /*default == false*/,
 	   typename _RAIterIterator,
 	   typename _RAIter3,
 	   typename _DifferenceTp,
@@ -742,18 +748,16 @@ template<bool __sentinels /*default == false*/,
 		 _RAIterIterator __seqs_end,
 		 _RAIter3 __target,
 		 _DifferenceTp __length, _Compare __comp)
-    {
-      return multiway_merge_3_variant<_GuardedIterator>
-	(__seqs_begin, __seqs_end, __target, __length, __comp);
-    }
+      { return multiway_merge_3_variant<_GuardedIterator>
+	  (__seqs_begin, __seqs_end, __target, __length, __comp); }
     };
 
-/**
+  /**
    * @brief Switch for 3-way merging with __sentinels turned on.
    *
    * Note that 3-way merging is always stable!
    */
-template<typename _RAIterIterator,
+  template<typename _RAIterIterator,
 	   typename _RAIter3,
 	   typename _DifferenceTp,
 	   typename _Compare>
@@ -766,18 +770,16 @@ template<typename _RAIterIterator,
 		 _RAIterIterator __seqs_end,
 		 _RAIter3 __target,
 		 _DifferenceTp __length, _Compare __comp)
-    {
-      return multiway_merge_3_variant<_UnguardedIterator>
-	(__seqs_begin, __seqs_end, __target, __length, __comp);
-    }
+      { return multiway_merge_3_variant<_UnguardedIterator>
+	  (__seqs_begin, __seqs_end, __target, __length, __comp); }
     };
 
-/**
+  /**
    * @brief Switch for 4-way merging with __sentinels turned off.
    *
    * Note that 4-way merging is always stable!
    */
-template<bool __sentinels /*default == false*/,
+  template<bool __sentinels /*default == false*/,
 	   typename _RAIterIterator,
 	   typename _RAIter3,
 	   typename _DifferenceTp,
@@ -789,18 +791,16 @@ template<bool __sentinels /*default == false*/,
 		 _RAIterIterator __seqs_end,
 		 _RAIter3 __target,
 		 _DifferenceTp __length, _Compare __comp)
-    {
-      return multiway_merge_4_variant<_GuardedIterator>
-	(__seqs_begin, __seqs_end, __target, __length, __comp);
-    }
+      { return multiway_merge_4_variant<_GuardedIterator>
+	  (__seqs_begin, __seqs_end, __target, __length, __comp); }
     };
 
-/**
+  /**
    * @brief Switch for 4-way merging with __sentinels turned on.
    *
    * Note that 4-way merging is always stable!
    */
-template<typename _RAIterIterator,
+  template<typename _RAIterIterator,
 	   typename _RAIter3,
 	   typename _DifferenceTp,
 	   typename _Compare>
@@ -813,16 +813,14 @@ template<typename _RAIterIterator,
 		 _RAIterIterator __seqs_end,
 		 _RAIter3 __target,
 		 _DifferenceTp __length, _Compare __comp)
-    {
-      return multiway_merge_4_variant<_UnguardedIterator>
-	(__seqs_begin, __seqs_end, __target, __length, __comp);
-    }
+      { return multiway_merge_4_variant<_UnguardedIterator>
+	  (__seqs_begin, __seqs_end, __target, __length, __comp); }
     };
 
-/**
+  /**
    * @brief Switch for k-way merging with __sentinels turned on.
    */
-template<bool __sentinels,
+  template<bool __sentinels,
 	   bool __stable,
 	   typename _RAIterIterator,
 	   typename _RAIter3,
@@ -855,10 +853,10 @@ template<bool __sentinels,
       }
     };
 
-/**
+  /**
    * @brief Switch for k-way merging with __sentinels turned off.
    */
-template<bool __stable,
+  template<bool __stable,
 	   typename _RAIterIterator,
 	   typename _RAIter3,
 	   typename _DifferenceTp,
@@ -891,7 +889,7 @@ template<bool __stable,
       }
     };
 
-/** @brief Sequential multi-way merging switch.
+  /** @brief Sequential multi-way merging switch.
    *
    *  The _GLIBCXX_PARALLEL_DECISION is based on the branching factor and
    *  runtime settings.
@@ -904,7 +902,7 @@ template<bool __stable,
    *  @param __stable Stable merging incurs a performance penalty.
    *  @param __sentinel The sequences have __a __sentinel element.
    *  @return End iterator of output sequence. */
-template<bool __stable,
+  template<bool __stable,
 	   bool __sentinels,
 	   typename _RAIterIterator,
 	   typename _RAIter3,
@@ -931,8 +929,8 @@ template<bool __stable,
 #if _GLIBCXX_ASSERTIONS
       for (_RAIterIterator __s = __seqs_begin; __s != __seqs_end; ++__s)
 	{
-        _GLIBCXX_PARALLEL_ASSERT(
-          __is_sorted((*__s).first, (*__s).second, __comp));
+          _GLIBCXX_PARALLEL_ASSERT(__is_sorted((*__s).first,
+					       (*__s).second, __comp));
 	}
 #endif
 
@@ -966,30 +964,20 @@ template<bool __stable,
 					    __target, __length, __comp);
           break;
 	case 3:
-        __return_target = __multiway_merge_3_variant_sentinel_switch<
-	  __sentinels,
-	  _RAIterIterator,
-	  _RAIter3,
-	  _DifferenceTp,
-	  _Compare>()(__seqs_begin, __seqs_end, __target, __length, __comp);
+          __return_target = __multiway_merge_3_variant_sentinel_switch
+	    <__sentinels, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare>()
+	    (__seqs_begin, __seqs_end, __target, __length, __comp);
           break;
 	case 4:
-        __return_target = __multiway_merge_4_variant_sentinel_switch<
-	  __sentinels,
-	  _RAIterIterator,
-	  _RAIter3,
-	  _DifferenceTp,
-	  _Compare>()(__seqs_begin, __seqs_end, __target, __length, __comp);
+          __return_target = __multiway_merge_4_variant_sentinel_switch
+	    <__sentinels, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare>()
+	    (__seqs_begin, __seqs_end, __target, __length, __comp);
           break;
 	default:
-	__return_target = __multiway_merge_k_variant_sentinel_switch<
-	  __sentinels,
-	  __stable,
-	  _RAIterIterator,
-	  _RAIter3,
-	  _DifferenceTp,
-	  _Compare>()(__seqs_begin, __seqs_end, __target, __sentinel,
-		      __length, __comp);
+	  __return_target = __multiway_merge_k_variant_sentinel_switch
+	    <__sentinels, __stable, _RAIterIterator, _RAIter3, _DifferenceTp,
+	     _Compare>()
+	    (__seqs_begin, __seqs_end, __target, __sentinel, __length, __comp);
 	  break;
 	}
 #if _GLIBCXX_ASSERTIONS
@@ -1000,12 +988,12 @@ template<bool __stable,
       return __return_target;
     }
 
-/**
+  /**
    * @brief Stable sorting functor.
    *
    * Used to reduce code instanciation in multiway_merge_sampling_splitting.
    */
-template<bool __stable, class _RAIter, class _StrictWeakOrdering>
+  template<bool __stable, class _RAIter, class _StrictWeakOrdering>
     struct _SamplingSorter
     {
       void
@@ -1013,12 +1001,12 @@ template<bool __stable, class _RAIter, class _StrictWeakOrdering>
       { __gnu_sequential::stable_sort(__first, __last, __comp); }
     };
 
-/**
+  /**
    * @brief Non-__stable sorting functor.
    *
    * Used to reduce code instantiation in multiway_merge_sampling_splitting.
    */
-template<class _RAIter, class _StrictWeakOrdering>
+  template<class _RAIter, class _StrictWeakOrdering>
     struct _SamplingSorter<false, _RAIter, _StrictWeakOrdering>
     {
       void
@@ -1026,10 +1014,10 @@ template<class _RAIter, class _StrictWeakOrdering>
       { __gnu_sequential::sort(__first, __last, __comp); }
     };
 
-/**
+  /**
    * @brief Sampling based splitting for parallel multiway-merge routine.
    */
-template<bool __stable,
+  template<bool __stable,
 	   typename _RAIterIterator,
 	   typename _Compare,
 	   typename _DifferenceType>
@@ -1061,8 +1049,7 @@ template<bool __stable,
       for (int __s = 0; __s < __k; ++__s)
 	for (_DifferenceType __i = 0; __i < __num_samples; ++__i)
 	  {
-	  _DifferenceType sample_index =
-            static_cast<_DifferenceType>
+	    _DifferenceType sample_index = static_cast<_DifferenceType>
 	      (_GLIBCXX_PARALLEL_LENGTH(__seqs_begin[__s])
 	       * (double(__i + 1) / (__num_samples + 1))
 	       * (double(__length) / __total_length));
@@ -1081,37 +1068,34 @@ template<bool __stable,
 	  {
 	    // For each sequence.
 	    if (__slab > 0)
-	    __pieces[__slab][__seq].first =
-              std::upper_bound
-	      (__seqs_begin[__seq].first,
-	       __seqs_begin[__seq].second,
+	      __pieces[__slab][__seq].first = std::upper_bound
+		(__seqs_begin[__seq].first, __seqs_begin[__seq].second,
 		 __samples[__num_samples * __k * __slab / __num_threads],
-	       __comp) - __seqs_begin[__seq].first;
+		 __comp)
+		- __seqs_begin[__seq].first;
 	    else
 	      // Absolute beginning.
 	      __pieces[__slab][__seq].first = 0;
 	    if ((__slab + 1) < __num_threads)
-	    __pieces[__slab][__seq].second =
-              std::upper_bound
-	      (__seqs_begin[__seq].first,
-	       __seqs_begin[__seq].second,
-	       __samples[__num_samples * __k * (__slab + 1) /
-			 __num_threads], __comp)
+	      __pieces[__slab][__seq].second = std::upper_bound
+		(__seqs_begin[__seq].first, __seqs_begin[__seq].second,
+		 __samples[__num_samples * __k * (__slab + 1) / __num_threads],
+		 __comp)
 		- __seqs_begin[__seq].first;
 	    else
               // Absolute end.
-	    __pieces[__slab][__seq].second
-	      = _GLIBCXX_PARALLEL_LENGTH(__seqs_begin[__seq]);
+	      __pieces[__slab][__seq].second =
+		_GLIBCXX_PARALLEL_LENGTH(__seqs_begin[__seq]);
 	  }
       ::operator delete(__samples);
     }
 
-/**
+  /**
    * @brief Exact splitting for parallel multiway-merge routine.
    *
    * None of the passed sequences may be empty.
    */
-template<bool __stable,
+  template<bool __stable,
 	   typename _RAIterIterator,
 	   typename _Compare,
 	   typename _DifferenceType>
@@ -1134,7 +1118,8 @@ template<bool __stable,
 
       const int __num_threads = omp_get_num_threads();
 
-    // (Settings::multiway_merge_splitting == __gnu_parallel::_Settings::EXACT).
+      // (Settings::multiway_merge_splitting
+      //  == __gnu_parallel::_Settings::EXACT).
       std::vector<_RAIter1>* __offsets = 
 	new std::vector<_RAIter1>[__num_threads];
       std::vector<std::pair<_RAIter1, _RAIter1> > __se(__k);
@@ -1148,8 +1133,7 @@ template<bool __stable,
       for (int __s = 0; __s < (__num_threads - 1); ++__s)
 	{
 	  __offsets[__s].resize(__k);
-	multiseq_partition
-	  (__se.begin(), __se.end(), __borders[__s + 1],
+	  multiseq_partition(__se.begin(), __se.end(), __borders[__s + 1],
 			     __offsets[__s].begin(), __comp);
 
 	  // Last one also needed and available.
@@ -1158,7 +1142,8 @@ template<bool __stable,
 	      __offsets[__num_threads - 1].resize(__k);
 	      multiseq_partition(__se.begin(), __se.end(),
 				 _DifferenceType(__length),
-			       __offsets[__num_threads - 1].begin(), __comp);
+				 __offsets[__num_threads - 1].begin(),
+				 __comp);
 	    }
 	}
       delete[] __borders;
@@ -1191,7 +1176,7 @@ template<bool __stable,
       delete[] __offsets;
     }
 
-/** @brief Parallel multi-way merge routine.
+  /** @brief Parallel multi-way merge routine.
    *
    * The _GLIBCXX_PARALLEL_DECISION is based on the branching factor
    * and runtime settings.
@@ -1210,7 +1195,7 @@ template<bool __stable,
    * @param __sentinel Ignored.
    * @return End iterator of output sequence.
    */
-template<bool __stable,
+  template<bool __stable,
 	   bool __sentinels,
 	   typename _RAIterIterator,
 	   typename _RAIter3,
@@ -1282,8 +1267,8 @@ template<bool __stable,
 	      __pieces[__s].resize(__k);
 
 	    _DifferenceType __num_samples =
-                  __gnu_parallel::_Settings::get().merge_oversampling *
-                    __num_threads;
+	      __gnu_parallel::_Settings::get().merge_oversampling
+	      * __num_threads;
 
 	    __splitter(__ne_seqs, __ne_seqs + __k, __length, __total_length,
 		       __comp, __pieces);
@@ -1299,15 +1284,14 @@ template<bool __stable,
 	  seq_type* __chunks = new seq_type[__k];
 
 	  for (int __s = 0; __s < __k; ++__s)
-            {
-              __chunks[__s] = std::make_pair(
-                __ne_seqs[__s].first + __pieces[__iam][__s].first,
-                __ne_seqs[__s].first + __pieces[__iam][__s].second);
-            }
+	    __chunks[__s] = std::make_pair(__ne_seqs[__s].first
+					   + __pieces[__iam][__s].first,
+					   __ne_seqs[__s].first
+					   + __pieces[__iam][__s].second);
 
 	  if(__length > __target_position)
-            __sequential_multiway_merge<__stable, __sentinels>(
-              __chunks, __chunks + __k, __target + __target_position,
+	    __sequential_multiway_merge<__stable, __sentinels>
+	      (__chunks, __chunks + __k, __target + __target_position,
 	       *(__seqs_begin->second), __length - __target_position, __comp);
 
 	  delete[] __chunks;
@@ -1334,7 +1318,7 @@ template<bool __stable,
 	return __target + __length;
       }
 
-/**
+  /**
    * @brief Multiway Merge Frontend.
    *
    * Merge the sequences specified by seqs_begin and __seqs_end into
@@ -1370,7 +1354,8 @@ template<bool __stable,
    *   int __out[33];
    *   std::vector<std::pair<int*> > seqs;
    *   for (int __i = 0; __i < 10; ++__i)
- *     { seqs.push(std::make_pair<int*>(sequences[__i], sequences[__i] + 10)) }
+   *     { seqs.push(std::make_pair<int*>(sequences[__i],
+   *                                      sequences[__i] + 10)) }
    *
    *   multiway_merge(seqs.begin(), seqs.end(), __target, std::less<int>(), 33);
    * </pre>
@@ -1402,9 +1387,9 @@ template<bool __stable,
    *
    * @return _M_end iterator of output sequence
    */
-// multiway_merge
-// public interface
-template<typename _RAIterPairIterator,
+  // multiway_merge
+  // public interface
+  template<typename _RAIterPairIterator,
 	   typename _RAIterOut,
 	   typename _DifferenceTp,
 	   typename _Compare>
@@ -1429,8 +1414,8 @@ template<typename _RAIterPairIterator,
 	 *(__seqs_begin->second), __length, __comp);
     }
 
-// public interface
-template<typename _RAIterPairIterator,
+  // public interface
+  template<typename _RAIterPairIterator,
 	   typename _RAIterOut,
 	   typename _DifferenceTp,
 	   typename _Compare>
@@ -1451,15 +1436,15 @@ template<typename _RAIterPairIterator,
       // Execute merge; maybe parallel, depending on the number of merged
       // elements and the number of sequences and global thresholds in
       // Settings.
-    if ((__seqs_end - __seqs_begin > 1) &&
-          _GLIBCXX_PARALLEL_CONDITION(
+      if ((__seqs_end - __seqs_begin > 1)
+	  && _GLIBCXX_PARALLEL_CONDITION(
             ((__seqs_end - __seqs_begin) >=
                __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
             && ((_SequenceIndex)__length >=
               __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
 	return parallel_multiway_merge
-                    </* __stable = */ false, /* __sentinels = */ false>(
-          __seqs_begin, __seqs_end, __target,
+	  </* __stable = */ false, /* __sentinels = */ false>
+	  (__seqs_begin, __seqs_end, __target,
 	   multiway_merge_exact_splitting</* __stable = */ false,
 	   typename std::iterator_traits<_RAIterPairIterator>
 	   ::value_type*, _Compare, _DifferenceTp>,
@@ -1467,13 +1452,13 @@ template<typename _RAIterPairIterator,
 	   __tag.__get_num_threads());
       else
 	return __sequential_multiway_merge
-                      </* __stable = */ false, /* __sentinels = */ false>(
-               __seqs_begin, __seqs_end, __target, *(__seqs_begin->second),
-               __length, __comp);
+	  </* __stable = */ false, /* __sentinels = */ false>
+	  (__seqs_begin, __seqs_end, __target,
+	   *(__seqs_begin->second), __length, __comp);
     }
 
-// public interface
-template<typename _RAIterPairIterator,
+  // public interface
+  template<typename _RAIterPairIterator,
 	   typename _RAIterOut,
 	   typename _DifferenceTp,
 	   typename _Compare>
@@ -1494,16 +1479,15 @@ template<typename _RAIterPairIterator,
       // Execute merge; maybe parallel, depending on the number of merged
       // elements and the number of sequences and global thresholds in
       // Settings.
-    if ((__seqs_end - __seqs_begin > 1) &&
-          _GLIBCXX_PARALLEL_CONDITION(
+      if ((__seqs_end - __seqs_begin > 1)
+	  && _GLIBCXX_PARALLEL_CONDITION(
             ((__seqs_end - __seqs_begin) >=
                __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
             && ((_SequenceIndex)__length >=
               __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
 	return parallel_multiway_merge
-                    </* __stable = */ false, /* __sentinels = */ false>(
-          __seqs_begin, __seqs_end,
-          __target,
+	  </* __stable = */ false, /* __sentinels = */ false>
+	  (__seqs_begin, __seqs_end, __target,
 	   multiway_merge_exact_splitting</* __stable = */ false,
 	   typename std::iterator_traits<_RAIterPairIterator>
 	   ::value_type*, _Compare, _DifferenceTp>,
@@ -1511,13 +1495,13 @@ template<typename _RAIterPairIterator,
 	   __tag.__get_num_threads());
       else
 	return __sequential_multiway_merge
-                      </* __stable = */ false, /* __sentinels = */ false>(
-          __seqs_begin, __seqs_end,
-          __target, *(__seqs_begin->second), __length, __comp);
+	  </* __stable = */ false, /* __sentinels = */ false>
+	  (__seqs_begin, __seqs_end, __target,
+	   *(__seqs_begin->second), __length, __comp);
     }
 
-// public interface
-template<typename _RAIterPairIterator,
+  // public interface
+  template<typename _RAIterPairIterator,
 	   typename _RAIterOut,
 	   typename _DifferenceTp,
 	   typename _Compare>
@@ -1527,13 +1511,11 @@ template<typename _RAIterPairIterator,
 		   _RAIterOut __target,
 		   _DifferenceTp __length, _Compare __comp,
 		   parallel_tag __tag = parallel_tag(0))
-  {
-    return multiway_merge(__seqs_begin, __seqs_end, __target, __length,
-			  __comp, exact_tag(__tag.__get_num_threads()));
-  }
+    { return multiway_merge(__seqs_begin, __seqs_end, __target, __length,
+			    __comp, exact_tag(__tag.__get_num_threads())); }
 
-// public interface
-template<typename _RAIterPairIterator,
+  // public interface
+  template<typename _RAIterPairIterator,
 	   typename _RAIterOut,
 	   typename _DifferenceTp,
 	   typename _Compare>
@@ -1543,14 +1525,12 @@ template<typename _RAIterPairIterator,
 		   _RAIterOut __target,
 		   _DifferenceTp __length, _Compare __comp,
 		   default_parallel_tag __tag)
-  {
-    return multiway_merge(__seqs_begin, __seqs_end, __target, __length,
-			  __comp, exact_tag(__tag.__get_num_threads()));
-  }
+    { return multiway_merge(__seqs_begin, __seqs_end, __target, __length,
+			    __comp, exact_tag(__tag.__get_num_threads())); }
 
-// stable_multiway_merge
-// public interface
-template<typename _RAIterPairIterator,
+  // stable_multiway_merge
+  // public interface
+  template<typename _RAIterPairIterator,
 	   typename _RAIterOut,
 	   typename _DifferenceTp,
 	   typename _Compare>
@@ -1571,12 +1551,12 @@ template<typename _RAIterPairIterator,
       // Execute multiway merge *sequentially*.
       return __sequential_multiway_merge
 	</* __stable = */ true, /* __sentinels = */ false>
-        (__seqs_begin, __seqs_end, __target, *(__seqs_begin->second), __length,
-         __comp);
+          (__seqs_begin, __seqs_end, __target,
+	   *(__seqs_begin->second), __length, __comp);
     }
 
-// public interface
-template<typename _RAIterPairIterator,
+  // public interface
+  template<typename _RAIterPairIterator,
 	   typename _RAIterOut,
 	   typename _DifferenceTp,
 	   typename _Compare>
@@ -1597,30 +1577,29 @@ template<typename _RAIterPairIterator,
       // Execute merge; maybe parallel, depending on the number of merged
       // elements and the number of sequences and global thresholds in
       // Settings.
-    if ((__seqs_end - __seqs_begin > 1) &&
-          _GLIBCXX_PARALLEL_CONDITION(
+      if ((__seqs_end - __seqs_begin > 1)
+	  && _GLIBCXX_PARALLEL_CONDITION(
             ((__seqs_end - __seqs_begin) >=
               __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
             && ((_SequenceIndex)__length >=
               __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
 	return parallel_multiway_merge
-        </* __stable = */ true, /* __sentinels = */ false>(
-          __seqs_begin, __seqs_end,
-          __target,
+          </* __stable = */ true, /* __sentinels = */ false>
+	  (__seqs_begin, __seqs_end, __target,
 	   multiway_merge_exact_splitting</* __stable = */ true,
 	   typename std::iterator_traits<_RAIterPairIterator>
 	   ::value_type*, _Compare, _DifferenceTp>,
 	   static_cast<_DifferenceType>(__length), __comp,
 	   __tag.__get_num_threads());
       else
-      return __sequential_multiway_merge</* __stable = */ true,
-        /* __sentinels = */ false>(
-          __seqs_begin, __seqs_end,
-          __target, *(__seqs_begin->second), __length, __comp);
+	return __sequential_multiway_merge
+	  </* __stable = */ true, /* __sentinels = */ false>
+	  (__seqs_begin, __seqs_end, __target,
+	   *(__seqs_begin->second), __length, __comp);
     }
 
-// public interface
-template<typename _RAIterPairIterator,
+  // public interface
+  template<typename _RAIterPairIterator,
 	   typename _RAIterOut,
 	   typename _DifferenceTp,
 	   typename _Compare>
@@ -1641,16 +1620,15 @@ template<typename _RAIterPairIterator,
       // Execute merge; maybe parallel, depending on the number of merged
       // elements and the number of sequences and global thresholds in
       // Settings.
-    if ((__seqs_end - __seqs_begin > 1) &&
-          _GLIBCXX_PARALLEL_CONDITION(
+      if ((__seqs_end - __seqs_begin > 1)
+	  && _GLIBCXX_PARALLEL_CONDITION(
             ((__seqs_end - __seqs_begin) >=
               __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
             && ((_SequenceIndex)__length >=
               __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
 	return parallel_multiway_merge
-        </* __stable = */ true, /* __sentinels = */ false>(
-          __seqs_begin, __seqs_end,
-          __target,
+          </* __stable = */ true, /* __sentinels = */ false>
+	  (__seqs_begin, __seqs_end, __target,
 	   multiway_merge_sampling_splitting</* __stable = */ true,
 	   typename std::iterator_traits<_RAIterPairIterator>
 	   ::value_type*, _Compare, _DifferenceTp>,
@@ -1658,13 +1636,13 @@ template<typename _RAIterPairIterator,
 	   __tag.__get_num_threads());
       else
 	return __sequential_multiway_merge
-        </* __stable = */ true, /* __sentinels = */ false>(
-          __seqs_begin, __seqs_end,
-          __target, *(__seqs_begin->second), __length, __comp);
+          </* __stable = */ true, /* __sentinels = */ false>
+	  (__seqs_begin, __seqs_end, __target,
+	   *(__seqs_begin->second), __length, __comp);
     }
 
-// public interface
-template<typename _RAIterPairIterator,
+  // public interface
+  template<typename _RAIterPairIterator,
 	   typename _RAIterOut,
 	   typename _DifferenceTp,
 	   typename _Compare>
@@ -1680,8 +1658,8 @@ template<typename _RAIterPairIterator,
 	 exact_tag(__tag.__get_num_threads()));
     }
 
-// public interface
-template<typename _RAIterPairIterator,
+  // public interface
+  template<typename _RAIterPairIterator,
 	   typename _RAIterOut,
 	   typename _DifferenceTp,
 	   typename _Compare>
@@ -1697,7 +1675,7 @@ template<typename _RAIterPairIterator,
 	 exact_tag(__tag.__get_num_threads()));
     }
 
-/**
+  /**
    * @brief Multiway Merge Frontend.
    *
    * Merge the sequences specified by seqs_begin and __seqs_end into
@@ -1737,7 +1715,8 @@ template<typename _RAIterPairIterator,
    *   int __out[33];
    *   std::vector<std::pair<int*> > seqs;
    *   for (int __i = 0; __i < 10; ++__i)
- *     { seqs.push(std::make_pair<int*>(sequences[__i], sequences[__i] + 10)) }
+   *     { seqs.push(std::make_pair<int*>(sequences[__i],
+   *                                      sequences[__i] + 10)) }
    *
    *   multiway_merge(seqs.begin(), seqs.end(), __target, std::less<int>(), 33);
    * </pre>
@@ -1772,9 +1751,9 @@ template<typename _RAIterPairIterator,
    *
    * @return _M_end iterator of output sequence
    */
-// multiway_merge_sentinels
-// public interface
-template<typename _RAIterPairIterator,
+  // multiway_merge_sentinels
+  // public interface
+  template<typename _RAIterPairIterator,
 	   typename _RAIterOut,
 	   typename _DifferenceTp,
 	   typename _Compare>
@@ -1799,8 +1778,8 @@ template<typename _RAIterPairIterator,
            __target, *(__seqs_begin->second), __length, __comp);
     }
 
-// public interface
-template<typename _RAIterPairIterator,
+  // public interface
+  template<typename _RAIterPairIterator,
 	   typename _RAIterOut,
 	   typename _DifferenceTp,
 	   typename _Compare>
@@ -1821,16 +1800,15 @@ template<typename _RAIterPairIterator,
       // Execute merge; maybe parallel, depending on the number of merged
       // elements and the number of sequences and global thresholds in
       // Settings.
-    if ((__seqs_end - __seqs_begin > 1) &&
-          _GLIBCXX_PARALLEL_CONDITION(
+      if ((__seqs_end - __seqs_begin > 1)
+	  && _GLIBCXX_PARALLEL_CONDITION(
             ((__seqs_end - __seqs_begin) >=
               __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
             && ((_SequenceIndex)__length >=
               __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
 	return parallel_multiway_merge
-        </* __stable = */ false, /* __sentinels = */ true>(
-          __seqs_begin, __seqs_end,
-          __target,
+          </* __stable = */ false, /* __sentinels = */ true>
+	  (__seqs_begin, __seqs_end, __target,
 	   multiway_merge_exact_splitting</* __stable = */ false,
 	   typename std::iterator_traits<_RAIterPairIterator>
 	   ::value_type*, _Compare, _DifferenceTp>,
@@ -1838,13 +1816,13 @@ template<typename _RAIterPairIterator,
 	   __tag.__get_num_threads());
       else
 	return __sequential_multiway_merge
-        </* __stable = */ false, /* __sentinels = */ true>(
-          __seqs_begin, __seqs_end,
-          __target, *(__seqs_begin->second), __length, __comp);
+          </* __stable = */ false, /* __sentinels = */ true>
+	  (__seqs_begin, __seqs_end, __target,
+	   *(__seqs_begin->second), __length, __comp);
     }
 
-// public interface
-template<typename _RAIterPairIterator,
+  // public interface
+  template<typename _RAIterPairIterator,
 	   typename _RAIterOut,
 	   typename _DifferenceTp,
 	   typename _Compare>
@@ -1865,8 +1843,8 @@ template<typename _RAIterPairIterator,
       // Execute merge; maybe parallel, depending on the number of merged
       // elements and the number of sequences and global thresholds in
       // Settings.
-    if ((__seqs_end - __seqs_begin > 1) &&
-          _GLIBCXX_PARALLEL_CONDITION(
+      if ((__seqs_end - __seqs_begin > 1)
+	  && _GLIBCXX_PARALLEL_CONDITION(
             ((__seqs_end - __seqs_begin) >=
               __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
             && ((_SequenceIndex)__length >=
@@ -1882,12 +1860,12 @@ template<typename _RAIterPairIterator,
       else
 	return __sequential_multiway_merge
           </* __stable = */false, /* __sentinels = */ true>(
-          __seqs_begin, __seqs_end,
-          __target, *(__seqs_begin->second), __length, __comp);
+            __seqs_begin, __seqs_end, __target,
+	    *(__seqs_begin->second), __length, __comp);
     }
 
-// public interface
-template<typename _RAIterPairIterator,
+  // public interface
+  template<typename _RAIterPairIterator,
 	   typename _RAIterOut,
 	   typename _DifferenceTp,
 	   typename _Compare>
@@ -1903,8 +1881,8 @@ template<typename _RAIterPairIterator,
 	 exact_tag(__tag.__get_num_threads()));
     }
 
-// public interface
-template<typename _RAIterPairIterator,
+  // public interface
+  template<typename _RAIterPairIterator,
 	   typename _RAIterOut,
 	   typename _DifferenceTp,
 	   typename _Compare>
@@ -1920,9 +1898,9 @@ template<typename _RAIterPairIterator,
 	 exact_tag(__tag.__get_num_threads()));
     }
 
-// stable_multiway_merge_sentinels
-// public interface
-template<typename _RAIterPairIterator,
+  // stable_multiway_merge_sentinels
+  // public interface
+  template<typename _RAIterPairIterator,
 	   typename _RAIterOut,
 	   typename _DifferenceTp,
 	   typename _Compare>
@@ -1943,12 +1921,12 @@ template<typename _RAIterPairIterator,
       // Execute multiway merge *sequentially*.
       return __sequential_multiway_merge
 	</* __stable = */ true, /* __sentinels = */ true>
-        (__seqs_begin, __seqs_end, __target, *(__seqs_begin->second),
-	 __length, __comp);
+	(__seqs_begin, __seqs_end, __target,
+	 *(__seqs_begin->second), __length, __comp);
     }
 
-// public interface
-template<typename _RAIterPairIterator,
+  // public interface
+  template<typename _RAIterPairIterator,
 	   typename _RAIterOut,
 	   typename _DifferenceTp,
 	   typename _Compare>
@@ -1969,16 +1947,15 @@ template<typename _RAIterPairIterator,
       // Execute merge; maybe parallel, depending on the number of merged
       // elements and the number of sequences and global thresholds in
       // Settings.
-    if ((__seqs_end - __seqs_begin > 1) &&
-          _GLIBCXX_PARALLEL_CONDITION(
+      if ((__seqs_end - __seqs_begin > 1)
+	  && _GLIBCXX_PARALLEL_CONDITION(
             ((__seqs_end - __seqs_begin) >=
             __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
             && ((_SequenceIndex)__length >=
             __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
 	return parallel_multiway_merge
-        </* __stable = */ true, /* __sentinels = */ true>(
-          __seqs_begin, __seqs_end,
-          __target,
+          </* __stable = */ true, /* __sentinels = */ true>
+	  (__seqs_begin, __seqs_end, __target,
 	   multiway_merge_exact_splitting</* __stable = */ true,
 	   typename std::iterator_traits<_RAIterPairIterator>
 	   ::value_type*, _Compare, _DifferenceTp>,
@@ -1986,13 +1963,13 @@ template<typename _RAIterPairIterator,
 	   __tag.__get_num_threads());
       else
 	return __sequential_multiway_merge
-        </* __stable = */ true, /* __sentinels = */ true>(
-          __seqs_begin, __seqs_end, __target, *(__seqs_begin->second),
-          __length, __comp);
+          </* __stable = */ true, /* __sentinels = */ true>
+	  (__seqs_begin, __seqs_end, __target,
+	   *(__seqs_begin->second), __length, __comp);
     }
 
-// public interface
-template<typename _RAIterPairIterator,
+  // public interface
+  template<typename _RAIterPairIterator,
 	   typename _RAIterOut,
 	   typename _DifferenceTp,
 	   typename _Compare>
@@ -2014,16 +1991,15 @@ template<typename _RAIterPairIterator,
       // Execute merge; maybe parallel, depending on the number of merged
       // elements and the number of sequences and global thresholds in
       // Settings.
-    if ((__seqs_end - __seqs_begin > 1) &&
-          _GLIBCXX_PARALLEL_CONDITION(
+      if ((__seqs_end - __seqs_begin > 1)
+	  && _GLIBCXX_PARALLEL_CONDITION(
             ((__seqs_end - __seqs_begin) >=
               __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
             && ((_SequenceIndex)__length >=
               __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
 	return parallel_multiway_merge
-        </* __stable = */ true, /* __sentinels = */ true>(
-          __seqs_begin, __seqs_end,
-          __target,
+          </* __stable = */ true, /* __sentinels = */ true>
+	  (__seqs_begin, __seqs_end, __target,
 	   multiway_merge_sampling_splitting</* __stable = */ true,
 	   typename std::iterator_traits<_RAIterPairIterator>
 	   ::value_type*, _Compare, _DifferenceTp>,
@@ -2031,13 +2007,13 @@ template<typename _RAIterPairIterator,
 	   __tag.__get_num_threads());
       else
 	return __sequential_multiway_merge
-        </* __stable = */ true, /* __sentinels = */ true>(
-          __seqs_begin, __seqs_end,
-          __target, *(__seqs_begin->second), __length, __comp);
+          </* __stable = */ true, /* __sentinels = */ true>
+	  (__seqs_begin, __seqs_end, __target,
+	   *(__seqs_begin->second), __length, __comp);
     }
 
-// public interface
-template<typename _RAIterPairIterator,
+  // public interface
+  template<typename _RAIterPairIterator,
 	   typename _RAIterOut,
 	   typename _DifferenceTp,
 	   typename _Compare>
@@ -2054,8 +2030,8 @@ template<typename _RAIterPairIterator,
 	 exact_tag(__tag.__get_num_threads()));
     }
 
-// public interface
-template<typename _RAIterPairIterator,
+  // public interface
+  template<typename _RAIterPairIterator,
 	   typename _RAIterOut,
 	   typename _DifferenceTp,
 	   typename _Compare>
@@ -2070,7 +2046,6 @@ template<typename _RAIterPairIterator,
 	(__seqs_begin, __seqs_end, __target, __length, __comp,
 	 exact_tag(__tag.__get_num_threads()));
     }
-
 }; // namespace __gnu_parallel
 
 #endif /* _GLIBCXX_PARALLEL_MULTIWAY_MERGE_H */

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

@@ -125,8 +125,7 @@ namespace __gnu_parallel
   /** @brief Split by exact splitting. */
   template<typename _RAIter, typename _Compare,
 	   typename _SortingPlacesIterator>
-    struct _SplitConsistently<true, _RAIter,
-			      _Compare, _SortingPlacesIterator>
+    struct _SplitConsistently<true, _RAIter, _Compare, _SortingPlacesIterator>
     {
       void
       operator()(const _ThreadIndex __iam,
@@ -140,19 +139,19 @@ namespace __gnu_parallel
 
 	std::vector<std::pair<_SortingPlacesIterator,
 	                      _SortingPlacesIterator> >
-	  seqs(__sd->_M_num_threads);
+	  __seqs(__sd->_M_num_threads);
 	for (_ThreadIndex __s = 0; __s < __sd->_M_num_threads; __s++)
-	  seqs[__s] = std::make_pair(__sd->_M_temporary[__s],
+	  __seqs[__s] = std::make_pair(__sd->_M_temporary[__s],
 				       __sd->_M_temporary[__s]
 				       + (__sd->_M_starts[__s + 1]
 					  - __sd->_M_starts[__s]));
 
-	std::vector<_SortingPlacesIterator> _M_offsets(__sd->_M_num_threads);
+	std::vector<_SortingPlacesIterator> __offsets(__sd->_M_num_threads);
 
 	// if not last thread
 	if (__iam < __sd->_M_num_threads - 1)
-	  multiseq_partition(seqs.begin(), seqs.end(),
-			     __sd->_M_starts[__iam + 1], _M_offsets.begin(),
+	  multiseq_partition(__seqs.begin(), __seqs.end(),
+			     __sd->_M_starts[__iam + 1], __offsets.begin(),
 			     __comp);
 
 	for (int __seq = 0; __seq < __sd->_M_num_threads; __seq++)
@@ -160,7 +159,7 @@ namespace __gnu_parallel
 	    // for each sequence
 	    if (__iam < (__sd->_M_num_threads - 1))
 	      __sd->_M_pieces[__iam][__seq]._M_end
-		= _M_offsets[__seq] - seqs[__seq].first;
+		= __offsets[__seq] - __seqs[__seq].first;
 	    else
 	      // very end of this sequence
 	      __sd->_M_pieces[__iam][__seq]._M_end =
@@ -185,8 +184,7 @@ namespace __gnu_parallel
   /** @brief Split by sampling. */ 
   template<typename _RAIter, typename _Compare,
 	   typename _SortingPlacesIterator>
-    struct _SplitConsistently<false, _RAIter, _Compare,
-			      _SortingPlacesIterator>
+    struct _SplitConsistently<false, _RAIter, _Compare, _SortingPlacesIterator>
     {
       void
       operator()(const _ThreadIndex __iam,
@@ -282,10 +280,8 @@ namespace __gnu_parallel
 		      const _RAIter& __target,
 		      _Compare& __comp,
 		      _DiffType __length_am) const
-      {
-	stable_multiway_merge(__seqs_begin, __seqs_end, __target, __length_am,
-			      __comp, sequential_tag());
-      }
+      { stable_multiway_merge(__seqs_begin, __seqs_end, __target,
+			      __length_am, __comp, sequential_tag()); }
     };
 
   template<typename Seq_RAIter, typename _RAIter,
@@ -298,10 +294,8 @@ namespace __gnu_parallel
                       const _RAIter& __target,
                       _Compare& __comp,
                       _DiffType __length_am) const
-      {
-	multiway_merge(__seqs_begin, __seqs_end, __target, __length_am, __comp,
-                       sequential_tag());
-      }
+      { multiway_merge(__seqs_begin, __seqs_end, __target, __length_am,
+		       __comp, sequential_tag()); }
     };
 
   /** @brief PMWMS code executed by each thread.
@@ -321,8 +315,8 @@ namespace __gnu_parallel
       _ThreadIndex __iam = omp_get_thread_num();
 
       // Length of this thread's chunk, before merging.
-      _DifferenceType __length_local
-	= __sd->_M_starts[__iam + 1] - __sd->_M_starts[__iam];
+      _DifferenceType __length_local =
+	__sd->_M_starts[__iam + 1] - __sd->_M_starts[__iam];
 
       // Sort in temporary storage, leave space for sentinel.
 
@@ -350,8 +344,7 @@ namespace __gnu_parallel
 
       _DifferenceType __num_samples =
         _Settings::get().sort_mwms_oversampling * __sd->_M_num_threads - 1;
-      _SplitConsistently
-	<__exact, _RAIter, _Compare, _SortingPlacesIterator>()
+      _SplitConsistently<__exact, _RAIter, _Compare, _SortingPlacesIterator>()
         (__iam, __sd, __comp, __num_samples);
 
       // Offset from __target __begin, __length after merging.
@@ -366,22 +359,20 @@ namespace __gnu_parallel
       typedef std::vector<
         std::pair<_SortingPlacesIterator, _SortingPlacesIterator> >
         _SeqVector;
-      _SeqVector seqs(__sd->_M_num_threads);
+      _SeqVector __seqs(__sd->_M_num_threads);
 
       for (int __s = 0; __s < __sd->_M_num_threads; ++__s)
 	{
-	  seqs[__s] =
-	    std::make_pair
-	    (__sd->_M_temporary[__s] + __sd->_M_pieces[__iam][__s]._M_begin,
-	     __sd->_M_temporary[__s] + __sd->_M_pieces[__iam][__s]._M_end);
+	  __seqs[__s] =
+	    std::make_pair(__sd->_M_temporary[__s]
+			   + __sd->_M_pieces[__iam][__s]._M_begin,
+			   __sd->_M_temporary[__s]
+			   + __sd->_M_pieces[__iam][__s]._M_end);
 	}
 
       __possibly_stable_multiway_merge<
-        __stable,
-        typename _SeqVector::iterator,
-        _RAIter,
-        _Compare, _DifferenceType>()
-          (seqs.begin(), seqs.end(),
+        __stable, typename _SeqVector::iterator,
+	_RAIter, _Compare, _DifferenceType>()(__seqs.begin(), __seqs.end(),
 				     __sd->_M_source + __offset, __comp,
 				     __length_am);
 
@@ -421,7 +412,7 @@ namespace __gnu_parallel
 
       // shared variables
       _PMWMSSortingData<_RAIter> __sd;
-      _DifferenceType* _M_starts;
+      _DifferenceType* __starts;
 
 #     pragma omp parallel num_threads(__num_threads)
       {
@@ -450,26 +441,25 @@ namespace __gnu_parallel
 	    = new std::vector<_Piece<_DifferenceType> >[__num_threads];
 	  for (int __s = 0; __s < __num_threads; ++__s)
 	    __sd._M_pieces[__s].resize(__num_threads);
-	  _M_starts = __sd._M_starts
-	    = new _DifferenceType[__num_threads + 1];
+	  __starts = __sd._M_starts = new _DifferenceType[__num_threads + 1];
 
 	  _DifferenceType __chunk_length = __n / __num_threads;
 	  _DifferenceType __split = __n % __num_threads;
 	  _DifferenceType __pos = 0;
 	  for (int __i = 0; __i < __num_threads; ++__i)
 	    {
-	      _M_starts[__i] = __pos;
-	      __pos += (__i < __split)
-		? (__chunk_length + 1) : __chunk_length;
+	      __starts[__i] = __pos;
+	      __pos += ((__i < __split)
+			? (__chunk_length + 1) : __chunk_length);
 	    }
-	  _M_starts[__num_threads] = __pos;
+	  __starts[__num_threads] = __pos;
 	} //single
 
         // Now sort in parallel.
         parallel_sort_mwms_pu<__stable, __exact>(&__sd, __comp);
       } //parallel
 
-      delete[] _M_starts;
+      delete[] __starts;
       delete[] __sd._M_temporary;
 
       if (!__exact)

libstdc++-v3/include/parallel/numeric

@@ -69,7 +69,7 @@ namespace __parallel
     __accumulate_switch(_IIter __begin, _IIter __end,
                       _Tp __init, _IteratorTag) 
     { return accumulate(__begin, __end, __init,
-__gnu_parallel::sequential_tag()); }
+			__gnu_parallel::sequential_tag()); }
 
   template<typename _IIter, typename _Tp, typename _BinaryOperation,
            typename _IteratorTag>

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

@@ -74,8 +74,8 @@ namespace __gnu_parallel
         _DifferenceType;
 
       _DifferenceType __length = __end - __begin;
-      _ThreadIndex __num_threads =
-	__gnu_parallel::min<_DifferenceType>(__get_max_threads(), __length);
+      _ThreadIndex __num_threads = __gnu_parallel::min<_DifferenceType>
+	(__get_max_threads(), __length);
 
       _Result *__thread_results;
 
@@ -94,8 +94,8 @@ namespace __gnu_parallel
 
 #pragma omp for schedule(dynamic, _Settings::get().workstealing_chunk_size)
         for (_DifferenceType __pos = 0; __pos < __length; ++__pos)
-          __thread_results[__iam] =
-	    __r(__thread_results[__iam], __f(__o, __begin+__pos));
+          __thread_results[__iam] = __r(__thread_results[__iam],
+					__f(__o, __begin+__pos));
       } //parallel
 
       for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)

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

@@ -74,8 +74,8 @@ namespace __gnu_parallel
 	_DifferenceType;
 
       _DifferenceType __length = __end - __begin;
-      _ThreadIndex __num_threads =
-	std::min<_DifferenceType>(__get_max_threads(), __length);
+      _ThreadIndex __num_threads = std::min<_DifferenceType>
+	(__get_max_threads(), __length);
 
       _Result *__thread_results;
 

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

@@ -75,25 +75,24 @@ namespace __gnu_parallel
       _Result *__thread_results;
       bool* __constructed;
 
-      _ThreadIndex __num_threads =
-	__gnu_parallel::min<_DifferenceType>(__get_max_threads(), __length);
+      _ThreadIndex __num_threads = __gnu_parallel::min<_DifferenceType>
+	(__get_max_threads(), __length);
 
 #     pragma omp parallel num_threads(__num_threads)
       {
 #       pragma omp single
 	{
 	  __num_threads = omp_get_num_threads();
-	  __thread_results =
-	    static_cast<_Result*>(::operator new(__num_threads
-						 * sizeof(_Result)));
+	  __thread_results = static_cast<_Result*>
+	    (::operator new(__num_threads * sizeof(_Result)));
 	  __constructed = new bool[__num_threads];
 	}
 
 	_ThreadIndex __iam = omp_get_thread_num();
 
 	// Neutral element.
-	_Result* __reduct =
-	  static_cast<_Result*>(::operator new(sizeof(_Result)));
+	_Result* __reduct = static_cast<_Result*>
+	  (::operator new(sizeof(_Result)));
 
 	_DifferenceType
 	  __start = equally_split_point(__length, __num_threads, __iam),

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

@@ -149,8 +149,9 @@ namespace __gnu_parallel
         if (__iam == 0)
           {
             *__result = *__begin;
-            __parallel_partial_sum_basecase(
-                __begin + 1, __begin + __borders[1], __result + 1,
+            __parallel_partial_sum_basecase(__begin + 1,
+					    __begin + __borders[1],
+					    __result + 1,
 					    __bin_op, *__begin);
             ::new(&(__sums[__iam])) _ValueType(*(__result + __borders[1] - 1));
           }

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

@@ -44,13 +44,14 @@
 
 namespace __gnu_parallel
 {
-/** @brief Parallel implementation of std::partition.
+  /** @brief Parallel implementation of std::partition.
     *  @param __begin Begin iterator of input sequence to split.
     *  @param __end End iterator of input sequence to split.
-  *  @param __pred Partition predicate, possibly including some kind of pivot.
+    *  @param __pred Partition predicate, possibly including some kind
+    *         of pivot.
     *  @param __num_threads Maximum number of threads to use for this task.
     *  @return Number of elements not fulfilling the predicate. */
-template<typename _RAIter, typename _Predicate>
+  template<typename _RAIter, typename _Predicate>
     typename std::iterator_traits<_RAIter>::difference_type
     __parallel_partition(_RAIter __begin, _RAIter __end,
 			 _Predicate __pred, _ThreadIndex __num_threads)
@@ -78,7 +79,7 @@ template<typename _RAIter, typename _Predicate>
       omp_init_lock(&__result_lock);
 
       //at least two chunks per thread
-    if(__right - __left + 1 >= 2 * __num_threads * __chunk_size)
+      if (__right - __left + 1 >= 2 * __num_threads * __chunk_size)
 #       pragma omp parallel num_threads(__num_threads)
 	{
 #         pragma omp single
@@ -88,10 +89,9 @@ template<typename _RAIter, typename _Predicate>
 	    __reserved_right = new bool[__num_threads];
 
 	    if (__s.partition_chunk_share > 0.0)
-              __chunk_size = std::max<_DifferenceType>(
-                __s.partition_chunk_size,
-                (double)__n * __s.partition_chunk_share /
-                    (double)__num_threads);
+	      __chunk_size = std::max<_DifferenceType>
+		(__s.partition_chunk_size, (double)__n 
+		 * __s.partition_chunk_share / (double)__num_threads);
 	    else
 	      __chunk_size = __s.partition_chunk_size;
 	  }
@@ -100,8 +100,8 @@ template<typename _RAIter, typename _Predicate>
 	    {
 #             pragma omp single
 	      {
-                _DifferenceType __num_chunks
-                    = (__right - __left + 1) / __chunk_size;
+		_DifferenceType __num_chunks = ((__right - __left + 1) 
+						/ __chunk_size);
 
 		for (int __r = 0; __r < __num_threads; ++__r)
 		  {
@@ -171,7 +171,8 @@ template<typename _RAIter, typename _Predicate>
 			// Fetch new chunk(__s).
 			break;
 
-                    std::swap(__begin[__thread_left], __begin[__thread_right]);
+		      std::swap(__begin[__thread_left],
+				__begin[__thread_right]);
 		      ++__thread_left;
 		      --__thread_right;
 		    }
@@ -200,9 +201,8 @@ template<typename _RAIter, typename _Predicate>
 		  && __thread_left_border >= __leftnew)
 		{
 		  // Chunk already in place, reserve spot.
-                __reserved_left
-                  [(__left - (__thread_left_border + 1)) / __chunk_size]
-                    = true;
+		__reserved_left[(__left - (__thread_left_border + 1))
+				/ __chunk_size] = true;
 		}
 
 	      // <=> __thread_right_border - (__chunk_size - 1) <= __rightnew
@@ -260,10 +260,9 @@ template<typename _RAIter, typename _Predicate>
 		  _GLIBCXX_PARALLEL_ASSERT(__swapstart != -1);
 #endif
 
-                std::swap_ranges(
-                    __begin + __thread_right_border,
-                    __begin + __thread_right_border + __chunk_size,
-                    __begin + __swapstart);
+		  std::swap_ranges(__begin + __thread_right_border,
+				   __begin + __thread_right_border
+				   + __chunk_size, __begin + __swapstart);
 	      }
 #if _GLIBCXX_ASSERTIONS
 #             pragma omp barrier
@@ -284,6 +283,7 @@ template<typename _RAIter, typename _Predicate>
 	      __left = __leftnew;
 	      __right = __rightnew;
 	    }
+
 #           pragma omp flush(__left, __right)
 	} // end "recursion" //parallel
 
@@ -292,11 +292,13 @@ template<typename _RAIter, typename _Predicate>
 	while (__final_left < __final_right)
 	  {
 	    // Go right until key is geq than pivot.
-        while (__pred(__begin[__final_left]) && __final_left < __final_right)
+	    while (__pred(__begin[__final_left])
+		   && __final_left < __final_right)
 	      ++__final_left;
 
 	    // Go left until key is less than pivot.
-        while (!__pred(__begin[__final_right]) && __final_left < __final_right)
+	    while (!__pred(__begin[__final_right])
+		   && __final_left < __final_right)
 	      --__final_right;
 
 	    if (__final_left == __final_right)
@@ -322,14 +324,14 @@ template<typename _RAIter, typename _Predicate>
 	  return __final_left + 1;
     }
 
-/**
+  /**
     *  @brief Parallel implementation of std::nth_element().
     *  @param __begin Begin iterator of input sequence.
     *  @param __nth _Iterator of element that must be in position afterwards.
     *  @param __end End iterator of input sequence.
     *  @param __comp Comparator.
     */
-template<typename _RAIter, typename _Compare>
+  template<typename _RAIter, typename _Compare>
     void 
     __parallel_nth_element(_RAIter __begin, _RAIter __nth, 
 			   _RAIter __end, _Compare __comp)
@@ -361,15 +363,16 @@ template<typename _RAIter, typename _Compare>
           // _Compare must have first_value_type, second_value_type,
           // result_type
           // _Compare ==
-        // __gnu_parallel::_Lexicographic<S, int, __gnu_parallel::_Less<S, S> >
+          // __gnu_parallel::_Lexicographic<S, int,
+	  //                                __gnu_parallel::_Less<S, S> >
           // __pivot_pos == std::pair<S, int>*
           __gnu_parallel::binder2nd<_Compare, _ValueType, _ValueType, bool>
             __pred(__comp, *__pivot_pos);
 
           // Divide, leave pivot unchanged in last place.
           _RAIter __split_pos1, __split_pos2;
-        __split_pos1 = __begin
-                       + __parallel_partition(__begin, __end - 1, __pred,
+          __split_pos1 = __begin + __parallel_partition(__begin, __end - 1,
+							__pred,
 							__get_max_threads());
 
           // Left side: < __pivot_pos; __right side: >= __pivot_pos
@@ -386,7 +389,8 @@ template<typename _RAIter, typename _Compare>
               // Very unequal split, one part smaller than one 128th
               // elements not strictly larger than the pivot.
               __gnu_parallel::__unary_negate<__gnu_parallel::
-              __binder1st<_Compare, _ValueType, _ValueType, bool>, _ValueType>
+        	__binder1st<_Compare, _ValueType,
+		            _ValueType, bool>, _ValueType>
         	__pred(__gnu_parallel::__binder1st<_Compare, _ValueType,
 		       _ValueType, bool>(__comp, *__pivot_pos));
 
@@ -411,12 +415,12 @@ template<typename _RAIter, typename _Compare>
       __gnu_sequential::sort(__begin, __end, __comp);
     }
 
-/** @brief Parallel implementation of std::partial_sort().
-*  @param __begin Begin iterator of input sequence.
-*  @param __middle Sort until this position.
-*  @param __end End iterator of input sequence.
-*  @param __comp Comparator. */
-template<typename _RAIter, typename _Compare>
+  /** @brief Parallel implementation of std::partial_sort().
+  *  @param __begin Begin iterator of input sequence.
+  *  @param __middle Sort until this position.
+  *  @param __end End iterator of input sequence.
+  *  @param __comp Comparator. */
+  template<typename _RAIter, typename _Compare>
     void
     __parallel_partial_sort(_RAIter __begin,
 			    _RAIter __middle,

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

@@ -65,10 +65,10 @@ namespace __gnu_parallel
     public:
       /** @brief Constructor. Not to be called concurrent, of course.
        *  @param _M_max_size Maximal number of elements to be contained. */
-      _RestrictedBoundedConcurrentQueue(_SequenceIndex _M_max_size)
+      _RestrictedBoundedConcurrentQueue(_SequenceIndex __max_size)
       {
-        this->_M_max_size = _M_max_size;
-        _M_base = new _Tp[_M_max_size];
+        _M_max_size = __max_size;
+        _M_base = new _Tp[__max_size];
         _M_borders = __encode2(0, 0);
 #pragma omp flush
       }
@@ -105,12 +105,12 @@ namespace __gnu_parallel
         while (__former_front > __former_back)
           {
             // Chance.
-            _CASable
-                __former_borders = __encode2(__former_front, __former_back);
-            _CASable
-                __new_borders = __encode2(__former_front - 1, __former_back);
-            if (__compare_and_swap(
-                  &_M_borders, __former_borders, __new_borders))
+            _CASable __former_borders = __encode2(__former_front,
+						  __former_back);
+            _CASable __new_borders = __encode2(__former_front - 1,
+					       __former_back);
+            if (__compare_and_swap(&_M_borders, __former_borders,
+				   __new_borders))
               {
                 __t = *(_M_base + (__former_front - 1) % _M_max_size);
                 return true;
@@ -132,12 +132,12 @@ namespace __gnu_parallel
         while (__former_front > __former_back)
           {
             // Chance.
-            _CASable
-              __former_borders = __encode2(__former_front, __former_back);
-            _CASable
-              __new_borders = __encode2(__former_front, __former_back + 1);
-            if (__compare_and_swap(
-                  &_M_borders, __former_borders, __new_borders))
+            _CASable __former_borders = __encode2(__former_front,
+						  __former_back);
+            _CASable __new_borders = __encode2(__former_front,
+					       __former_back + 1);
+            if (__compare_and_swap(&_M_borders, __former_borders,
+				   __new_borders))
               {
                 __t = *(_M_base + __former_back % _M_max_size);
                 return true;

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

@@ -48,8 +48,7 @@ namespace __gnu_parallel
    */
   template<typename _RAIter, typename _Compare>
     typename std::iterator_traits<_RAIter>::difference_type
-    __parallel_sort_qs_divide(_RAIter __begin,
-                            _RAIter __end,
+    __parallel_sort_qs_divide(_RAIter __begin, _RAIter __end,
 			      _Compare __comp, typename std::iterator_traits
 			      <_RAIter>::difference_type __pivot_rank,
 			      typename std::iterator_traits
@@ -64,25 +63,24 @@ namespace __gnu_parallel
       __num_samples = std::min(__num_samples, __n);
 
       // Allocate uninitialized, to avoid default constructor.
-      _ValueType* __samples =
-        static_cast<_ValueType*>(::operator new(__num_samples
-                                                * sizeof(_ValueType)));
+      _ValueType* __samples = static_cast<_ValueType*>
+	(::operator new(__num_samples * sizeof(_ValueType)));
 
       for (_DifferenceType __s = 0; __s < __num_samples; ++__s)
         {
-          const unsigned long long __index
-            = static_cast<unsigned long long>(__s) * __n / __num_samples;
+          const unsigned long long __index = static_cast<unsigned long long>
+	    (__s) * __n / __num_samples;
           ::new(&(__samples[__s])) _ValueType(__begin[__index]);
         }
 
       __gnu_sequential::sort(__samples, __samples + __num_samples, __comp);
 
-      _ValueType& pivot = __samples[__pivot_rank * __num_samples / __n];
+      _ValueType& __pivot = __samples[__pivot_rank * __num_samples / __n];
 
       __gnu_parallel::binder2nd<_Compare, _ValueType, _ValueType, bool>
-        __pred(__comp, pivot);
-      _DifferenceType __split =
-          __parallel_partition(__begin, __end, __pred, __num_threads);
+        __pred(__comp, __pivot);
+      _DifferenceType __split = __parallel_partition(__begin, __end,
+						     __pred, __num_threads);
 
       ::operator delete(__samples);
 
@@ -98,8 +96,7 @@ namespace __gnu_parallel
    */
   template<typename _RAIter, typename _Compare>
     void
-    __parallel_sort_qs_conquer(_RAIter __begin,
-                             _RAIter __end,
+    __parallel_sort_qs_conquer(_RAIter __begin, _RAIter __end,
 			       _Compare __comp,
 			       _ThreadIndex __num_threads)
     {
@@ -127,10 +124,9 @@ namespace __gnu_parallel
 
       __pivot_rank = __n * __num_threads_left / __num_threads;
 
-      _DifferenceType __split =
-        __parallel_sort_qs_divide(__begin, __end, __comp, __pivot_rank,
-                                _Settings::get().sort_qs_num_samples_preset,
-                                __num_threads);
+      _DifferenceType __split = __parallel_sort_qs_divide
+	(__begin, __end, __comp, __pivot_rank,
+	 _Settings::get().sort_qs_num_samples_preset, __num_threads);
 
 #pragma omp parallel sections num_threads(2)
       {
@@ -144,7 +140,6 @@ namespace __gnu_parallel
     }
 
 
-
   /** @brief Unbalanced quicksort main call.
    *  @param __begin Begin iterator of input sequence.
    *  @param __end End iterator input sequence, ignored.
@@ -154,8 +149,7 @@ namespace __gnu_parallel
    */
   template<typename _RAIter, typename _Compare>
     void
-    __parallel_sort_qs(_RAIter __begin,
-                     _RAIter __end,
+    __parallel_sort_qs(_RAIter __begin, _RAIter __end,
 		       _Compare __comp,
 		       _ThreadIndex __num_threads)
     {

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

@@ -39,16 +39,16 @@
 
 namespace __gnu_parallel
 {
-/** @brief Type to hold the index of a bin.
+  /** @brief Type to hold the index of a bin.
     *
     *  Since many variables of this type are allocated, it should be
     *  chosen as small as possible.
     */
-typedef unsigned short _BinIndex;
+  typedef unsigned short _BinIndex;
 
-/** @brief Data known to every thread participating in
+  /** @brief Data known to every thread participating in
       __gnu_parallel::__parallel_random_shuffle(). */
-template<typename _RAIter>
+  template<typename _RAIter>
     struct _DRandomShufflingGlobalData
     {
       typedef std::iterator_traits<_RAIter> _TraitsType;
@@ -84,10 +84,10 @@ template<typename _RAIter>
       : _M_source(__source) { }
     };
 
-/** @brief Local data for a thread participating in
+  /** @brief Local data for a thread participating in
       __gnu_parallel::__parallel_random_shuffle().
     */
-template<typename _RAIter, typename _RandomNumberGenerator>
+  template<typename _RAIter, typename _RandomNumberGenerator>
     struct _DRSSorterPU
     {
       /** @brief Number of threads participating in total. */
@@ -106,18 +106,18 @@ template<typename _RAIter, typename _RandomNumberGenerator>
       _DRandomShufflingGlobalData<_RAIter>* _M_sd;
     };
 
-/** @brief Generate a random number in @__c [0,2^logp).
-  *  @param logp Logarithm (basis 2) of the upper range __bound.
+  /** @brief Generate a random number in @__c [0,2^__logp).
+    *  @param __logp Logarithm (basis 2) of the upper range __bound.
     *  @param __rng Random number generator to use.
     */
-template<typename _RandomNumberGenerator>
+  template<typename _RandomNumberGenerator>
     inline int
-  __random_number_pow2(int logp, _RandomNumberGenerator& __rng)
-  { return __rng.__genrand_bits(logp); }
+    __random_number_pow2(int __logp, _RandomNumberGenerator& __rng)
+    { return __rng.__genrand_bits(__logp); }
 
-/** @brief Random shuffle code executed by each thread.
+  /** @brief Random shuffle code executed by each thread.
     *  @param __pus Array of thread-local data records. */
-template<typename _RAIter, typename _RandomNumberGenerator>
+  template<typename _RAIter, typename _RandomNumberGenerator>
     void 
     __parallel_random_shuffle_drs_pu(_DRSSorterPU<_RAIter,
 				     _RandomNumberGenerator>* __pus)
@@ -127,121 +127,121 @@ template<typename _RAIter, typename _RandomNumberGenerator>
       typedef typename _TraitsType::difference_type _DifferenceType;
 
       _ThreadIndex __iam = omp_get_thread_num();
-    _DRSSorterPU<_RAIter, _RandomNumberGenerator>* d = &__pus[__iam];
-    _DRandomShufflingGlobalData<_RAIter>* _M_sd = d->_M_sd;
+      _DRSSorterPU<_RAIter, _RandomNumberGenerator>* __d = &__pus[__iam];
+      _DRandomShufflingGlobalData<_RAIter>* __sd = __d->_M_sd;
 
       // Indexing: _M_dist[bin][processor]
-    _DifferenceType __length = _M_sd->_M_starts[__iam + 1] -
-                               _M_sd->_M_starts[__iam];
+      _DifferenceType __length = (__sd->_M_starts[__iam + 1]
+				  - __sd->_M_starts[__iam]);
       _BinIndex* __oracles = new _BinIndex[__length];
-    _DifferenceType* _M_dist = new _DifferenceType[_M_sd->_M_num_bins + 1];
-    _BinIndex* _M_bin_proc = new _BinIndex[_M_sd->_M_num_bins];
-    _ValueType** _M_temporaries = new _ValueType*[d->_M_num_threads];
+      _DifferenceType* __dist = new _DifferenceType[__sd->_M_num_bins + 1];
+      _BinIndex* __bin_proc = new _BinIndex[__sd->_M_num_bins];
+      _ValueType** __temporaries = new _ValueType*[__d->_M_num_threads];
 
       // Compute oracles and count appearances.
-    for (_BinIndex __b = 0; __b < _M_sd->_M_num_bins + 1; ++__b)
-      _M_dist[__b] = 0;
-    int _M_num_bits = _M_sd->_M_num_bits;
+      for (_BinIndex __b = 0; __b < __sd->_M_num_bins + 1; ++__b)
+	__dist[__b] = 0;
+      int __num_bits = __sd->_M_num_bits;
 
-    _RandomNumber __rng(d->_M_seed);
+      _RandomNumber __rng(__d->_M_seed);
 
       // First main loop.
       for (_DifferenceType __i = 0; __i < __length; ++__i)
 	{
-        _BinIndex __oracle = __random_number_pow2(_M_num_bits, __rng);
+          _BinIndex __oracle = __random_number_pow2(__num_bits, __rng);
           __oracles[__i] = __oracle;
 
           // To allow prefix (partial) sum.
-        ++(_M_dist[__oracle + 1]);
+          ++(__dist[__oracle + 1]);
 	}
 
-    for (_BinIndex __b = 0; __b < _M_sd->_M_num_bins + 1; ++__b)
-      _M_sd->_M_dist[__b][__iam + 1] = _M_dist[__b];
+      for (_BinIndex __b = 0; __b < __sd->_M_num_bins + 1; ++__b)
+	__sd->_M_dist[__b][__iam + 1] = __dist[__b];
 
 #     pragma omp barrier
 
 #     pragma omp single
       {
-      // Sum up bins, _M_sd->_M_dist[__s + 1][d->_M_num_threads] now contains
-      // the total number of items in bin __s
-      for (_BinIndex __s = 0; __s < _M_sd->_M_num_bins; ++__s)
-        __gnu_sequential::partial_sum(
-          _M_sd->_M_dist[__s + 1],
-          _M_sd->_M_dist[__s + 1] + d->_M_num_threads + 1,
-          _M_sd->_M_dist[__s + 1]);
+	// Sum up bins, __sd->_M_dist[__s + 1][__d->_M_num_threads] now
+	// contains the total number of items in bin __s
+	for (_BinIndex __s = 0; __s < __sd->_M_num_bins; ++__s)
+          __gnu_sequential::partial_sum(__sd->_M_dist[__s + 1],
+					__sd->_M_dist[__s + 1]
+					+ __d->_M_num_threads + 1,
+					__sd->_M_dist[__s + 1]);
       }
 
 #     pragma omp barrier
 
       _SequenceIndex __offset = 0, __global_offset = 0;
-    for (_BinIndex __s = 0; __s < d->_M_bins_begin; ++__s)
-      __global_offset += _M_sd->_M_dist[__s + 1][d->_M_num_threads];
+      for (_BinIndex __s = 0; __s < __d->_M_bins_begin; ++__s)
+	__global_offset += __sd->_M_dist[__s + 1][__d->_M_num_threads];
 
 #     pragma omp barrier
 
-    for (_BinIndex __s = d->_M_bins_begin; __s < d->__bins_end; ++__s)
+      for (_BinIndex __s = __d->_M_bins_begin; __s < __d->__bins_end; ++__s)
 	{
-        for (int __t = 0; __t < d->_M_num_threads + 1; ++__t)
-          _M_sd->_M_dist[__s + 1][__t] += __offset;
-        __offset = _M_sd->_M_dist[__s + 1][d->_M_num_threads];
+          for (int __t = 0; __t < __d->_M_num_threads + 1; ++__t)
+            __sd->_M_dist[__s + 1][__t] += __offset;
+          __offset = __sd->_M_dist[__s + 1][__d->_M_num_threads];
 	}
 
-    _M_sd->_M_temporaries[__iam] = static_cast<_ValueType*>(
-      ::operator new(sizeof(_ValueType) * __offset));
+      __sd->_M_temporaries[__iam] = static_cast<_ValueType*>
+	(::operator new(sizeof(_ValueType) * __offset));
 
 #     pragma omp barrier
 
       // Draw local copies to avoid false sharing.
-    for (_BinIndex __b = 0; __b < _M_sd->_M_num_bins + 1; ++__b)
-      _M_dist[__b] = _M_sd->_M_dist[__b][__iam];
-    for (_BinIndex __b = 0; __b < _M_sd->_M_num_bins; ++__b)
-      _M_bin_proc[__b] = _M_sd->_M_bin_proc[__b];
-    for (_ThreadIndex __t = 0; __t < d->_M_num_threads; ++__t)
-      _M_temporaries[__t] = _M_sd->_M_temporaries[__t];
+      for (_BinIndex __b = 0; __b < __sd->_M_num_bins + 1; ++__b)
+	__dist[__b] = __sd->_M_dist[__b][__iam];
+      for (_BinIndex __b = 0; __b < __sd->_M_num_bins; ++__b)
+	__bin_proc[__b] = __sd->_M_bin_proc[__b];
+      for (_ThreadIndex __t = 0; __t < __d->_M_num_threads; ++__t)
+	__temporaries[__t] = __sd->_M_temporaries[__t];
 
-    _RAIter _M_source = _M_sd->_M_source;
-    _DifferenceType __start = _M_sd->_M_starts[__iam];
+      _RAIter __source = __sd->_M_source;
+      _DifferenceType __start = __sd->_M_starts[__iam];
 
       // Distribute according to oracles, second main loop.
       for (_DifferenceType __i = 0; __i < __length; ++__i)
 	{
-        _BinIndex target_bin = __oracles[__i];
-        _ThreadIndex target_p = _M_bin_proc[target_bin];
+          _BinIndex __target_bin = __oracles[__i];
+          _ThreadIndex __target_p = __bin_proc[__target_bin];
 
-        // Last column [d->_M_num_threads] stays unchanged.
-        ::new(&(_M_temporaries[target_p][_M_dist[target_bin + 1]++]))
-            _ValueType(*(_M_source + __i + __start));
+          // Last column [__d->_M_num_threads] stays unchanged.
+          ::new(&(__temporaries[__target_p][__dist[__target_bin + 1]++]))
+              _ValueType(*(__source + __i + __start));
 	}
 
       delete[] __oracles;
-    delete[] _M_dist;
-    delete[] _M_bin_proc;
-    delete[] _M_temporaries;
+      delete[] __dist;
+      delete[] __bin_proc;
+      delete[] __temporaries;
 
 #     pragma omp barrier
 
       // Shuffle bins internally.
-    for (_BinIndex __b = d->_M_bins_begin; __b < d->__bins_end; ++__b)
+      for (_BinIndex __b = __d->_M_bins_begin; __b < __d->__bins_end; ++__b)
 	{
           _ValueType* __begin =
-                    _M_sd->_M_temporaries[__iam] +
-                    ((__b == d->_M_bins_begin)
-                      ? 0 : _M_sd->_M_dist[__b][d->_M_num_threads]),
-                  * __end =
-                    _M_sd->_M_temporaries[__iam] +
-                      _M_sd->_M_dist[__b + 1][d->_M_num_threads];
+	    (__sd->_M_temporaries[__iam]
+	     + (__b == __d->_M_bins_begin
+		? 0 : __sd->_M_dist[__b][__d->_M_num_threads])),
+	  * __end = (__sd->_M_temporaries[__iam]
+		     + __sd->_M_dist[__b + 1][__d->_M_num_threads]);
+
           __sequential_random_shuffle(__begin, __end, __rng);
-        std::copy(__begin, __end, _M_sd->_M_source + __global_offset +
-                  ((__b == d->_M_bins_begin)
-                  ? 0 : _M_sd->_M_dist[__b][d->_M_num_threads]));
+          std::copy(__begin, __end, __sd->_M_source + __global_offset
+		    + (__b == __d->_M_bins_begin
+		       ? 0 : __sd->_M_dist[__b][__d->_M_num_threads]));
 	}
 
-    ::operator delete(_M_sd->_M_temporaries[__iam]);
+      ::operator delete(__sd->_M_temporaries[__iam]);
     }
 
-/** @brief Round up to the next greater power of 2.
+  /** @brief Round up to the next greater power of 2.
     *  @param __x _Integer to round up */
-template<typename _Tp>
+  template<typename _Tp>
     _Tp 
     __round_up_to_pow2(_Tp __x)
     {
@@ -251,17 +251,16 @@ template<typename _Tp>
 	return (_Tp)1 << (__rd_log2(__x - 1) + 1);
     }
 
-/** @brief Main parallel random shuffle step.
+  /** @brief Main parallel random shuffle step.
     *  @param __begin Begin iterator of sequence.
     *  @param __end End iterator of sequence.
     *  @param __n Length of sequence.
     *  @param __num_threads Number of threads to use.
     *  @param __rng Random number generator to use.
     */
-template<typename _RAIter, typename _RandomNumberGenerator>
+  template<typename _RAIter, typename _RandomNumberGenerator>
     void
-  __parallel_random_shuffle_drs(_RAIter __begin,
-                              _RAIter __end,
+    __parallel_random_shuffle_drs(_RAIter __begin, _RAIter __end,
 				  typename std::iterator_traits
 				  <_RAIter>::difference_type __n,
 				  _ThreadIndex __num_threads,
@@ -278,129 +277,129 @@ template<typename _RAIter, typename _RandomNumberGenerator>
       if (__num_threads > __n)
 	__num_threads = static_cast<_ThreadIndex>(__n);
 
-    _BinIndex _M_num_bins, __num_bins_cache;
+      _BinIndex __num_bins, __num_bins_cache;
 
 #if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_L1
       // Try the L1 cache first.
 
       // Must fit into L1.
-    __num_bins_cache = std::max<_DifferenceType>(
-        1, __n / (__s.L1_cache_size_lb / sizeof(_ValueType)));
+      __num_bins_cache =
+	std::max<_DifferenceType>(1, __n / (__s.L1_cache_size_lb
+					    / sizeof(_ValueType)));
       __num_bins_cache = __round_up_to_pow2(__num_bins_cache);
 
       // No more buckets than TLB entries, power of 2
       // Power of 2 and at least one element per bin, at most the TLB size.
-    _M_num_bins = std::min<_DifferenceType>(__n, __num_bins_cache);
+      __num_bins = std::min<_DifferenceType>(__n, __num_bins_cache);
 
 #if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_TLB
       // 2 TLB entries needed per bin.
-    _M_num_bins = std::min<_DifferenceType>(__s.TLB_size / 2, _M_num_bins);
+      __num_bins = std::min<_DifferenceType>(__s.TLB_size / 2, __num_bins);
 #endif
-    _M_num_bins = __round_up_to_pow2(_M_num_bins);
+      __num_bins = __round_up_to_pow2(__num_bins);
 
-    if (_M_num_bins < __num_bins_cache)
+      if (__num_bins < __num_bins_cache)
 	{
 #endif
           // Now try the L2 cache
           // Must fit into L2
-        __num_bins_cache = static_cast<_BinIndex>(std::max<_DifferenceType>(
-            1, __n / (__s.L2_cache_size / sizeof(_ValueType))));
+          __num_bins_cache = static_cast<_BinIndex>
+	    (std::max<_DifferenceType>(1, __n / (__s.L2_cache_size
+						 / sizeof(_ValueType))));
           __num_bins_cache = __round_up_to_pow2(__num_bins_cache);
 
           // No more buckets than TLB entries, power of 2.
-        _M_num_bins = static_cast<_BinIndex>(
-            std::min(__n, static_cast<_DifferenceType>(__num_bins_cache)));
+          __num_bins = static_cast<_BinIndex>
+	    (std::min(__n, static_cast<_DifferenceType>(__num_bins_cache)));
           // Power of 2 and at least one element per bin, at most the TLB size.
 #if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_TLB
           // 2 TLB entries needed per bin.
-        _M_num_bins = std::min(
-            static_cast<_DifferenceType>(__s.TLB_size / 2), _M_num_bins);
+          __num_bins = std::min(static_cast<_DifferenceType>(__s.TLB_size / 2),
+				__num_bins);
 #endif
-          _M_num_bins = __round_up_to_pow2(_M_num_bins);
+            __num_bins = __round_up_to_pow2(__num_bins);
 #if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_L1
 	}
 #endif
 
-    __num_threads = std::min<_BinIndex>(__num_threads, _M_num_bins);
+      __num_threads = std::min<_BinIndex>(__num_threads, __num_bins);
 
       if (__num_threads <= 1)
 	return __sequential_random_shuffle(__begin, __end, __rng);
 
-    _DRandomShufflingGlobalData<_RAIter> _M_sd(__begin);
+      _DRandomShufflingGlobalData<_RAIter> __sd(__begin);
       _DRSSorterPU<_RAIter, _RandomNumber >* __pus;
-    _DifferenceType* _M_starts;
+      _DifferenceType* __starts;
 
 #     pragma omp parallel num_threads(__num_threads)
       {
 	_ThreadIndex __num_threads = omp_get_num_threads();
 #       pragma omp single
 	{
-            __pus = new _DRSSorterPU<_RAIter, _RandomNumber>
-                [__num_threads];
-
-            _M_sd._M_temporaries = new _ValueType*[__num_threads];
-            _M_sd._M_dist = new _DifferenceType*[_M_num_bins + 1];
-            _M_sd._M_bin_proc = new _ThreadIndex[_M_num_bins];
-            for (_BinIndex __b = 0; __b < _M_num_bins + 1; ++__b)
-              _M_sd._M_dist[__b] = new _DifferenceType[__num_threads + 1];
-            for (_BinIndex __b = 0; __b < (_M_num_bins + 1); ++__b)
+	  __pus = new _DRSSorterPU<_RAIter, _RandomNumber>[__num_threads];
+	  
+	  __sd._M_temporaries = new _ValueType*[__num_threads];
+	  __sd._M_dist = new _DifferenceType*[__num_bins + 1];
+	  __sd._M_bin_proc = new _ThreadIndex[__num_bins];
+	  for (_BinIndex __b = 0; __b < __num_bins + 1; ++__b)
+	    __sd._M_dist[__b] = new _DifferenceType[__num_threads + 1];
+	  for (_BinIndex __b = 0; __b < (__num_bins + 1); ++__b)
 	    {
-                _M_sd._M_dist[0][0] = 0;
-                _M_sd._M_dist[__b][0] = 0;
+	      __sd._M_dist[0][0] = 0;
+	      __sd._M_dist[__b][0] = 0;
 	    }
-            _M_starts = _M_sd._M_starts
-              = new _DifferenceType[__num_threads + 1];
-            int bin_cursor = 0;
-            _M_sd._M_num_bins = _M_num_bins;
-            _M_sd._M_num_bits = __rd_log2(_M_num_bins);
+	  __starts = __sd._M_starts = new _DifferenceType[__num_threads + 1];
+	  int __bin_cursor = 0;
+	  __sd._M_num_bins = __num_bins;
+	  __sd._M_num_bits = __rd_log2(__num_bins);
 
 	  _DifferenceType __chunk_length = __n / __num_threads,
-                            __split = __n % __num_threads, __start = 0;
-            _DifferenceType bin_chunk_length = _M_num_bins / __num_threads,
-                            bin_split = _M_num_bins % __num_threads;
+	                         __split = __n % __num_threads,
+	                         __start = 0;
+	  _DifferenceType __bin_chunk_length = __num_bins / __num_threads,
+	                         __bin_split = __num_bins % __num_threads;
 	  for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)
 	    {
-                _M_starts[__i] = __start;
-                __start += (__i < __split)
-                           ? (__chunk_length + 1) : __chunk_length;
-                int __j = __pus[__i]._M_bins_begin = bin_cursor;
+	      __starts[__i] = __start;
+	      __start += (__i < __split
+			  ? (__chunk_length + 1) : __chunk_length);
+	      int __j = __pus[__i]._M_bins_begin = __bin_cursor;
 
 	      // Range of bins for this processor.
-                bin_cursor += (__i < bin_split) ?
-                    (bin_chunk_length + 1) : bin_chunk_length;
-                __pus[__i].__bins_end = bin_cursor;
-                for (; __j < bin_cursor; ++__j)
-                  _M_sd._M_bin_proc[__j] = __i;
+	      __bin_cursor += (__i < __bin_split
+			       ? (__bin_chunk_length + 1)
+			       : __bin_chunk_length);
+	      __pus[__i].__bins_end = __bin_cursor;
+	      for (; __j < __bin_cursor; ++__j)
+		__sd._M_bin_proc[__j] = __i;
 	      __pus[__i]._M_num_threads = __num_threads;
-                __pus[__i]._M_seed =
-                        __rng(std::numeric_limits<uint32_t>::max());
-                __pus[__i]._M_sd = &_M_sd;
+	      __pus[__i]._M_seed = __rng(std::numeric_limits<uint32_t>::max());
+	      __pus[__i]._M_sd = &__sd;
 	    }
-            _M_starts[__num_threads] = __start;
+	  __starts[__num_threads] = __start;
 	} //single
           // Now shuffle in parallel.
 	__parallel_random_shuffle_drs_pu(__pus);
       }  // parallel
 
-    delete[] _M_starts;
-    delete[] _M_sd._M_bin_proc;
-    for (int __s = 0; __s < (_M_num_bins + 1); ++__s)
-      delete[] _M_sd._M_dist[__s];
-    delete[] _M_sd._M_dist;
-    delete[] _M_sd._M_temporaries;
+      delete[] __starts;
+      delete[] __sd._M_bin_proc;
+      for (int __s = 0; __s < (__num_bins + 1); ++__s)
+	delete[] __sd._M_dist[__s];
+      delete[] __sd._M_dist;
+      delete[] __sd._M_temporaries;
 
       delete[] __pus;
     }
 
-/** @brief Sequential cache-efficient random shuffle.
+  /** @brief Sequential cache-efficient random shuffle.
    *  @param __begin Begin iterator of sequence.
    *  @param __end End iterator of sequence.
    *  @param __rng Random number generator to use.
    */
-template<typename _RAIter, typename _RandomNumberGenerator>
+  template<typename _RAIter, typename _RandomNumberGenerator>
     void
-  __sequential_random_shuffle(_RAIter __begin, 
-                            _RAIter __end,
+    __sequential_random_shuffle(_RAIter __begin, _RAIter __end,
 				_RandomNumberGenerator& __rng)
     {
       typedef std::iterator_traits<_RAIter> _TraitsType;
@@ -410,66 +409,64 @@ template<typename _RAIter, typename _RandomNumberGenerator>
       _DifferenceType __n = __end - __begin;
       const _Settings& __s = _Settings::get();
 
-    _BinIndex _M_num_bins, __num_bins_cache;
+      _BinIndex __num_bins, __num_bins_cache;
 
 #if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_L1
       // Try the L1 cache first, must fit into L1.
-    __num_bins_cache =
-        std::max<_DifferenceType>
+      __num_bins_cache = std::max<_DifferenceType>
 	(1, __n / (__s.L1_cache_size_lb / sizeof(_ValueType)));
       __num_bins_cache = __round_up_to_pow2(__num_bins_cache);
 
       // No more buckets than TLB entries, power of 2
       // Power of 2 and at least one element per bin, at most the TLB size
-    _M_num_bins = std::min(__n, (_DifferenceType)__num_bins_cache);
+      __num_bins = std::min(__n, (_DifferenceType)__num_bins_cache);
 #if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_TLB
       // 2 TLB entries needed per bin
-    _M_num_bins = std::min((_DifferenceType)__s.TLB_size / 2, _M_num_bins);
+      __num_bins = std::min((_DifferenceType)__s.TLB_size / 2, __num_bins);
 #endif
-    _M_num_bins = __round_up_to_pow2(_M_num_bins);
+      __num_bins = __round_up_to_pow2(__num_bins);
 
-    if (_M_num_bins < __num_bins_cache)
+      if (__num_bins < __num_bins_cache)
 	{
 #endif
           // Now try the L2 cache, must fit into L2.
-        __num_bins_cache =
-            static_cast<_BinIndex>(std::max<_DifferenceType>(
-                1, __n / (__s.L2_cache_size / sizeof(_ValueType))));
+          __num_bins_cache = static_cast<_BinIndex>
+	    (std::max<_DifferenceType>(1, __n / (__s.L2_cache_size
+						 / sizeof(_ValueType))));
           __num_bins_cache = __round_up_to_pow2(__num_bins_cache);
 
           // No more buckets than TLB entries, power of 2
           // Power of 2 and at least one element per bin, at most the TLB size.
-        _M_num_bins = static_cast<_BinIndex>
+          __num_bins = static_cast<_BinIndex>
 	    (std::min(__n, static_cast<_DifferenceType>(__num_bins_cache)));
 
 #if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_TLB
           // 2 TLB entries needed per bin
-        _M_num_bins =
-            std::min<_DifferenceType>(__s.TLB_size / 2, _M_num_bins);
+          __num_bins = std::min<_DifferenceType>(__s.TLB_size / 2, __num_bins);
 #endif
-        _M_num_bins = __round_up_to_pow2(_M_num_bins);
+          __num_bins = __round_up_to_pow2(__num_bins);
 #if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_L1
 	}
 #endif
 
-    int _M_num_bits = __rd_log2(_M_num_bins);
+      int __num_bits = __rd_log2(__num_bins);
 
-    if (_M_num_bins > 1)
+      if (__num_bins > 1)
 	{
-        _ValueType* __target = static_cast<_ValueType*>(
-          ::operator new(sizeof(_ValueType) * __n));
+          _ValueType* __target =
+	    static_cast<_ValueType*>(::operator new(sizeof(_ValueType) * __n));
           _BinIndex* __oracles = new _BinIndex[__n];
-        _DifferenceType* __dist0 = new _DifferenceType[_M_num_bins + 1],
-                       * __dist1 = new _DifferenceType[_M_num_bins + 1];
+          _DifferenceType* __dist0 = new _DifferenceType[__num_bins + 1],
+                	 * __dist1 = new _DifferenceType[__num_bins + 1];
 
-        for (int __b = 0; __b < _M_num_bins + 1; ++__b)
+          for (int __b = 0; __b < __num_bins + 1; ++__b)
             __dist0[__b] = 0;
 
-        _RandomNumber bitrng(__rng(0xFFFFFFFF));
+          _RandomNumber __bitrng(__rng(0xFFFFFFFF));
 
           for (_DifferenceType __i = 0; __i < __n; ++__i)
             {
-            _BinIndex __oracle = __random_number_pow2(_M_num_bits, bitrng);
+              _BinIndex __oracle = __random_number_pow2(__num_bits, __bitrng);
               __oracles[__i] = __oracle;
 
               // To allow prefix (partial) sum.
@@ -477,10 +474,10 @@ template<typename _RAIter, typename _RandomNumberGenerator>
             }
 
           // Sum up bins.
-        __gnu_sequential::
-            partial_sum(__dist0, __dist0 + _M_num_bins + 1, __dist0);
+          __gnu_sequential::partial_sum(__dist0, __dist0 + __num_bins + 1,
+					__dist0);
 
-        for (int __b = 0; __b < _M_num_bins + 1; ++__b)
+          for (int __b = 0; __b < __num_bins + 1; ++__b)
             __dist1[__b] = __dist0[__b];
 
           // Distribute according to oracles.
@@ -488,12 +485,9 @@ template<typename _RAIter, typename _RandomNumberGenerator>
             ::new(&(__target[(__dist0[__oracles[__i]])++])) 
 		_ValueType(*(__begin + __i));
 
-        for (int __b = 0; __b < _M_num_bins; ++__b)
-          {
+          for (int __b = 0; __b < __num_bins; ++__b)
 	    __sequential_random_shuffle(__target + __dist1[__b],
-                                      __target + __dist1[__b + 1],
-                                      __rng);
-          }
+					__target + __dist1[__b + 1], __rng);
 
           // Copy elements back.
           std::copy(__target, __target + __n, __begin);
@@ -507,24 +501,22 @@ template<typename _RAIter, typename _RandomNumberGenerator>
 	__gnu_sequential::random_shuffle(__begin, __end, __rng);
     }
 
-/** @brief Parallel random public call.
+  /** @brief Parallel random public call.
    *  @param __begin Begin iterator of sequence.
    *  @param __end End iterator of sequence.
    *  @param __rng Random number generator to use.
    */
-template<typename _RAIter, typename _RandomNumberGenerator>
+  template<typename _RAIter, typename _RandomNumberGenerator>
     inline void
-  __parallel_random_shuffle(_RAIter __begin,
-                          _RAIter __end,
+    __parallel_random_shuffle(_RAIter __begin, _RAIter __end,
 			      _RandomNumberGenerator __rng = _RandomNumber())
     {
       typedef std::iterator_traits<_RAIter> _TraitsType;
       typedef typename _TraitsType::difference_type _DifferenceType;
       _DifferenceType __n = __end - __begin;
-    __parallel_random_shuffle_drs(
-      __begin, __end, __n, __get_max_threads(), __rng) ;
+      __parallel_random_shuffle_drs(__begin, __end, __n,
+				    __get_max_threads(), __rng);
     }
-
 }
 
 #endif /* _GLIBCXX_PARALLEL_RANDOM_SHUFFLE_H */

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

@@ -38,7 +38,6 @@
 #include <parallel/parallel.h>
 #include <parallel/equally_split.h>
 
-
 namespace __gnu_parallel
 {
   /**
@@ -47,7 +46,7 @@ namespace __gnu_parallel
    *  @param __length Length of sequence to search for.
    *  @param __advances Returned __offsets. 
    */
-template<typename _RAIter, typename _DifferenceTp>
+  template<typename _RAIter, typename _DifferenceTp>
     void
     __calc_borders(_RAIter __elements, _DifferenceTp __length, 
 		   _DifferenceTp* __off)
@@ -75,7 +74,7 @@ template<typename _RAIter, typename _DifferenceTp>
    *  @param __end2 End iterator of second sequence.
    *  @param __pred Find predicate.
    *  @return Place of finding in first sequences. */
-template<typename __RAIter1,
+  template<typename __RAIter1,
            typename __RAIter2,
            typename _Pred>
     __RAIter1
@@ -108,9 +107,9 @@ template<typename __RAIter1,
       omp_lock_t __result_lock;
       omp_init_lock(&__result_lock);
 
-    _ThreadIndex __num_threads =
-        std::max<_DifferenceType>(1,
-            std::min<_DifferenceType>(__input_length, __get_max_threads()));
+      _ThreadIndex __num_threads = std::max<_DifferenceType>
+	(1, std::min<_DifferenceType>(__input_length,
+				      __get_max_threads()));
 
       _DifferenceType __advances[__pattern_length];
       __calc_borders(__begin2, __pattern_length, __advances);
@@ -135,7 +134,7 @@ template<typename __RAIter1,
 	while (__start <= __stop && !__found_pattern)
 	  {
 	    // Get new value of result.
-            #pragma omp flush(__result)
+#pragma omp flush(__result)
 	    // No chance for this thread to find first occurrence.
 	    if (__result < __start)
 	      break;
@@ -156,9 +155,8 @@ template<typename __RAIter1,
 	      }
 	    // Make safe jump.
 	    __start += (__pos_in_pattern - __advances[__pos_in_pattern]);
-            __pos_in_pattern =
-                (__advances[__pos_in_pattern] < 0) ?
-                  0 : __advances[__pos_in_pattern];
+	    __pos_in_pattern = (__advances[__pos_in_pattern] < 0
+				? 0 : __advances[__pos_in_pattern]);
 	  }
       } //parallel
 

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

@@ -41,9 +41,9 @@
 
 namespace __gnu_parallel
 {
-template<typename _IIter, typename _OutputIterator>
+  template<typename _IIter, typename _OutputIterator>
     _OutputIterator
-  copy_tail(std::pair<_IIter, _IIter> __b,
+    __copy_tail(std::pair<_IIter, _IIter> __b,
 		std::pair<_IIter, _IIter> __e, _OutputIterator __r)
     {
       if (__b.first != __e.first)
@@ -62,25 +62,24 @@ template<typename _IIter, typename _OutputIterator>
       return __r;
     }
 
-template<typename _IIter,
+  template<typename _IIter,
            typename _OutputIterator,
            typename _Compare>
-  struct symmetric_difference_func
+    struct __symmetric_difference_func
     {
       typedef std::iterator_traits<_IIter> _TraitsType;
       typedef typename _TraitsType::difference_type _DifferenceType;
       typedef typename std::pair<_IIter, _IIter> _IteratorPair;
 
-    symmetric_difference_func(_Compare __comp) : _M_comp(__comp) {}
+      __symmetric_difference_func(_Compare __comp) : _M_comp(__comp) {}
 
       _Compare _M_comp;
 
       _OutputIterator
-    _M_invoke(_IIter __a, _IIter __b,
-           _IIter __c, _IIter d,
+      _M_invoke(_IIter __a, _IIter __b, _IIter __c, _IIter __d,
 		_OutputIterator __r) const
       {
-      while (__a != __b && __c != d)
+	while (__a != __b && __c != __d)
           {
             if (_M_comp(*__a, *__c))
               {
@@ -100,12 +99,11 @@ template<typename _IIter,
         	++__c;
               }
           }
-      return std::copy(__c, d, std::copy(__a, __b, __r));
+	return std::copy(__c, __d, std::copy(__a, __b, __r));
       }
 
       _DifferenceType
-    __count(_IIter __a, _IIter __b,
-          _IIter __c, _IIter d) const
+      __count(_IIter __a, _IIter __b, _IIter __c, _IIter d) const
       {
 	_DifferenceType __counter = 0;
 
@@ -141,7 +139,7 @@ template<typename _IIter,
     };
 
 
-template<typename _IIter,
+  template<typename _IIter,
            typename _OutputIterator,
            typename _Compare>
     struct __difference_func
@@ -199,17 +197,17 @@ template<typename _IIter,
 	return __counter + (__b - __a);
       }
 
-    inline _OutputIterator
-    __first_empty(_IIter __c, _IIter d, _OutputIterator __out) const
+      _OutputIterator
+      __first_empty(_IIter, _IIter, _OutputIterator __out) const
       { return __out; }
 
-    inline _OutputIterator
+      _OutputIterator
       __second_empty(_IIter __a, _IIter __b, _OutputIterator __out) const
       { return std::copy(__a, __b, __out); }
     };
 
 
-template<typename _IIter,
+  template<typename _IIter,
            typename _OutputIterator,
            typename _Compare>
     struct __intersection_func
@@ -223,10 +221,10 @@ template<typename _IIter,
       _Compare _M_comp;
 
       _OutputIterator
-    _M_invoke(_IIter __a, _IIter __b, _IIter __c, _IIter d,
+      _M_invoke(_IIter __a, _IIter __b, _IIter __c, _IIter __d,
 		_OutputIterator __r) const
       {
-      while (__a != __b && __c != d)
+	while (__a != __b && __c != __d)
           {
             if (_M_comp(*__a, *__c))
               { ++__a; }
@@ -245,12 +243,11 @@ template<typename _IIter,
       }
 
       _DifferenceType
-    __count(_IIter __a, _IIter __b,
-          _IIter __c, _IIter d) const
+      __count(_IIter __a, _IIter __b, _IIter __c, _IIter __d) const
       {
 	_DifferenceType __counter = 0;
 
-      while (__a != __b && __c != d)
+	while (__a != __b && __c != __d)
           {
             if (_M_comp(*__a, *__c))
               { ++__a; }
@@ -267,16 +264,16 @@ template<typename _IIter,
 	return __counter;
       }
 
-    inline _OutputIterator
-    __first_empty(_IIter __c, _IIter d, _OutputIterator __out) const
+      _OutputIterator
+      __first_empty(_IIter, _IIter, _OutputIterator __out) const
       { return __out; }
 
-    inline _OutputIterator
-    __second_empty(_IIter __a, _IIter __b, _OutputIterator __out) const
+      _OutputIterator
+      __second_empty(_IIter, _IIter, _OutputIterator __out) const
       { return __out; }
     };
 
-template<class _IIter, class _OutputIterator, class _Compare>
+  template<class _IIter, class _OutputIterator, class _Compare>
     struct __union_func
     {
       typedef typename std::iterator_traits<_IIter>::difference_type
@@ -288,9 +285,9 @@ template<class _IIter, class _OutputIterator, class _Compare>
 
       _OutputIterator
       _M_invoke(_IIter __a, const _IIter __b, _IIter __c,
-          const _IIter d, _OutputIterator __r) const
+		const _IIter __d, _OutputIterator __r) const
       {
-      while (__a != __b && __c != d)
+	while (__a != __b && __c != __d)
           {
             if (_M_comp(*__a, *__c))
               {
@@ -310,16 +307,15 @@ template<class _IIter, class _OutputIterator, class _Compare>
               }
             ++__r;
           }
-      return std::copy(__c, d, std::copy(__a, __b, __r));
+	return std::copy(__c, __d, std::copy(__a, __b, __r));
       }
 
       _DifferenceType
-    __count(_IIter __a, _IIter __b,
-          _IIter __c, _IIter d) const
+      __count(_IIter __a, _IIter __b, _IIter __c, _IIter __d) const
       {
 	_DifferenceType __counter = 0;
 
-      while (__a != __b && __c != d)
+	while (__a != __b && __c != __d)
           {
             if (_M_comp(*__a, *__c))
               { ++__a; }
@@ -334,20 +330,20 @@ template<class _IIter, class _OutputIterator, class _Compare>
           }
 
 	__counter += (__b - __a);
-      __counter += (d - __c);
+	__counter += (__d - __c);
 	return __counter;
       }
 
-    inline _OutputIterator
-    __first_empty(_IIter __c, _IIter d, _OutputIterator __out) const
-    { return std::copy(__c, d, __out); }
+      _OutputIterator
+      __first_empty(_IIter __c, _IIter __d, _OutputIterator __out) const
+      { return std::copy(__c, __d, __out); }
 
-    inline _OutputIterator
+      _OutputIterator
       __second_empty(_IIter __a, _IIter __b, _OutputIterator __out) const
       { return std::copy(__a, __b, __out); }
     };
 
-template<typename _IIter,
+  template<typename _IIter,
            typename _OutputIterator,
            typename Operation>
     _OutputIterator
@@ -367,11 +363,11 @@ template<typename _IIter,
       if (__begin2 == __end2)
 	return __op.__second_empty(__begin1, __end1, __result);
 
-    const _DifferenceType size = (__end1 - __begin1) + (__end2 - __begin2);
+      const _DifferenceType __size = (__end1 - __begin1) + (__end2 - __begin2);
 
-    const _IteratorPair __sequence[ 2 ] =
-      { std::make_pair(__begin1, __end1), std::make_pair(__begin2, __end2) };
-    _OutputIterator return_value = __result;
+      const _IteratorPair __sequence[2] = { std::make_pair(__begin1, __end1),
+					    std::make_pair(__begin2, __end2) };
+      _OutputIterator __return_value = __result;
       _DifferenceType *__borders;
       _IteratorPair *__block_begins;
       _DifferenceType* __lengths;
@@ -387,7 +383,7 @@ template<typename _IIter,
 	  __num_threads = omp_get_num_threads();
 
 	  __borders = new _DifferenceType[__num_threads + 2];
-            equally_split(size, __num_threads + 1, __borders);
+	  equally_split(__size, __num_threads + 1, __borders);
 	  __block_begins = new _IteratorPair[__num_threads + 1];
 	  // Very __start.
 	  __block_begins[0] = std::make_pair(__begin1, __begin2);
@@ -406,22 +402,22 @@ template<typename _IIter,
 	// allowed to read?
 	// together
 	// *(__offset[ 0 ] - 1) == *__offset[ 1 ]
-        if (__offset[ 0 ] != __begin1 && __offset[ 1 ] != __end2
-            && !__op._M_comp(*(__offset[ 0 ] - 1), *__offset[ 1 ])
-            && !__op._M_comp(*__offset[ 1 ], *(__offset[ 0 ] - 1)))
+	if (__offset[ 0 ] != __begin1 && __offset[1] != __end2
+	    && !__op._M_comp(*(__offset[0] - 1), *__offset[1])
+	    && !__op._M_comp(*__offset[1], *(__offset[0] - 1)))
 	  {
 	    // Avoid split between globally equal elements: move one to
 	    // front in first sequence.
-            --__offset[ 0 ];
+              --__offset[0];
 	  }
 
-        _IteratorPair block_end = __block_begins[ __iam + 1 ] =
-            _IteratorPair(__offset[ 0 ], __offset[ 1 ]);
+	_IteratorPair __block_end = __block_begins[__iam + 1] =
+	  _IteratorPair(__offset[0], __offset[1]);
 
 	// Make sure all threads have their block_begin result written out.
 #       pragma omp barrier
 
-        _IteratorPair __block_begin = __block_begins[ __iam ];
+	_IteratorPair __block_begin = __block_begins[__iam];
 
 	// Begin working for the first block, while the others except
 	// the last start to count.
@@ -429,15 +425,15 @@ template<typename _IIter,
 	  {
 	    // The first thread can copy already.
 	    __lengths[ __iam ] =
-              __op._M_invoke(__block_begin.first, block_end.first,
-                             __block_begin.second, block_end.second, __result)
-                              - __result;
+	      __op._M_invoke(__block_begin.first, __block_end.first,
+			     __block_begin.second, __block_end.second,
+			     __result) - __result;
 	  }
 	else
 	  {
 	    __lengths[ __iam ] =
-              __op.__count(__block_begin.first, block_end.first,
-                           __block_begin.second, block_end.second);
+	      __op.__count(__block_begin.first, __block_end.first,
+			   __block_begin.second, __block_end.second);
 	  }
 
 	// Make sure everyone wrote their lengths.
@@ -454,8 +450,9 @@ template<typename _IIter,
 	    __block_begin = __block_begins[__num_threads];
 
 	    // Return the result iterator of the last block.
-            return_value = __op._M_invoke(
-              __block_begin.first, __end1, __block_begin.second, __end2, __r);
+	    __return_value =
+	      __op._M_invoke(__block_begin.first, __end1,
+			     __block_begin.second, __end2, __r);
 
 	  }
           else
@@ -464,67 +461,69 @@ template<typename _IIter,
         	__r += __lengths[ __i ];
 
               // Reset begins for copy pass.
-            __op._M_invoke(__block_begin.first, block_end.first,
-                  __block_begin.second, block_end.second, __r);
+              __op._M_invoke(__block_begin.first, __block_end.first,
+			     __block_begin.second, __block_end.second, __r);
             }
 	}
-    return return_value;
+      return __return_value;
     }
 
-
-template<typename _IIter,
+  template<typename _IIter,
            typename _OutputIterator,
            typename _Compare>
     inline _OutputIterator
     __parallel_set_union(_IIter __begin1, _IIter __end1,
 			 _IIter __begin2, _IIter __end2,
-                     _OutputIterator __result, _Compare _M_comp)
+			 _OutputIterator __result, _Compare __comp)
     {
       return __parallel_set_operation(__begin1, __end1, __begin2, __end2,
-        __result, __union_func< _IIter, _OutputIterator, _Compare>(_M_comp));
+				      __result,
+				      __union_func< _IIter, _OutputIterator,
+				      _Compare>(__comp));
     }
 
-template<typename _IIter,
+  template<typename _IIter,
            typename _OutputIterator,
            typename _Compare>
     inline _OutputIterator
     __parallel_set_intersection(_IIter __begin1, _IIter __end1,
                         	_IIter __begin2, _IIter __end2,
-                              _OutputIterator __result, _Compare _M_comp)
+                        	_OutputIterator __result, _Compare __comp)
     {
-    return __parallel_set_operation(
-             __begin1, __end1, __begin2, __end2, __result,
-             __intersection_func<_IIter, _OutputIterator, _Compare>(_M_comp));
+      return __parallel_set_operation(__begin1, __end1, __begin2, __end2,
+				      __result,
+				      __intersection_func<_IIter,
+				      _OutputIterator, _Compare>(__comp));
     }
 
-template<typename _IIter,
+  template<typename _IIter,
            typename _OutputIterator,
            typename _Compare>
     inline _OutputIterator
     __parallel_set_difference(_IIter __begin1, _IIter __end1,
                               _IIter __begin2, _IIter __end2,
-                            _OutputIterator __result, _Compare _M_comp)
+                              _OutputIterator __result, _Compare __comp)
     {
-    return __parallel_set_operation(
-             __begin1, __end1, __begin2, __end2, __result,
-             __difference_func<_IIter, _OutputIterator, _Compare>(_M_comp));
+      return __parallel_set_operation(__begin1, __end1, __begin2, __end2,
+				      __result,
+				      __difference_func<_IIter,
+				      _OutputIterator, _Compare>(__comp));
     }
 
-template<typename _IIter,
+  template<typename _IIter,
            typename _OutputIterator,
            typename _Compare>
     inline _OutputIterator
     __parallel_set_symmetric_difference(_IIter __begin1, _IIter __end1,
                                 	_IIter __begin2, _IIter __end2,
                                 	_OutputIterator __result,
-                                      _Compare _M_comp)
+                                	_Compare __comp)
     {
-    return __parallel_set_operation(
-             __begin1, __end1, __begin2, __end2, __result,
-            symmetric_difference_func<_IIter, _OutputIterator, _Compare>
-              (_M_comp));
+      return __parallel_set_operation(__begin1, __end1, __begin2, __end2,
+				      __result,
+				      __symmetric_difference_func<_IIter,
+				      _OutputIterator, _Compare>(__comp));
     }
-
 }
 
 #endif /* _GLIBCXX_PARALLEL_SET_OPERATIONS_H */

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

@@ -95,7 +95,8 @@ namespace __gnu_parallel
   template<bool __stable, typename _RAIter, typename _Compare>
     inline void
     __parallel_sort(_RAIter __begin, _RAIter __end,
-    _Compare __comp, multiway_mergesort_exact_tag __parallelism)
+		    _Compare __comp,
+		    multiway_mergesort_exact_tag __parallelism)
     {
       _GLIBCXX_CALL(__end - __begin)
 
@@ -114,7 +115,8 @@ namespace __gnu_parallel
   template<bool __stable, typename _RAIter, typename _Compare>
     inline void
     __parallel_sort(_RAIter __begin, _RAIter __end,
-    _Compare __comp, multiway_mergesort_sampling_tag __parallelism)
+		    _Compare __comp,
+		    multiway_mergesort_sampling_tag __parallelism)
     {
       _GLIBCXX_CALL(__end - __begin)
 
@@ -163,7 +165,6 @@ namespace __gnu_parallel
 			   __parallelism.__get_num_threads());
      }
 
-
   /** 
    *  @brief Choose multiway mergesort with exact splitting,
    *  for parallel sorting.
@@ -184,7 +185,6 @@ namespace __gnu_parallel
 	 multiway_mergesort_exact_tag(__parallelism.__get_num_threads()));
     }
 
-
   /**
    *  @brief Choose a parallel sorting algorithm.
    *  @param __begin Begin iterator of input sequence.

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

@@ -51,20 +51,16 @@ namespace __gnu_parallel
     public:
       /** @brief Default constructor. Use default number of threads. */
       parallel_tag()
-      {
-        this->_M_num_threads = 0;
-      }
+      { _M_num_threads = 0; }
 
       /** @brief Default constructor. Recommend number of threads to use.
        *  @param __num_threads Desired number of threads. */
       parallel_tag(_ThreadIndex __num_threads)
-      {
-        this->_M_num_threads = __num_threads;
-      }
+      { _M_num_threads = __num_threads; }
 
       /** @brief Find out desired number of threads.
        *  @return Desired number of threads. */
-      inline _ThreadIndex __get_num_threads()
+      _ThreadIndex __get_num_threads()
       {
         if(_M_num_threads == 0)
           return omp_get_max_threads();
@@ -74,10 +70,8 @@ namespace __gnu_parallel
 
       /** @brief Set the desired number of threads.
        *  @param __num_threads Desired number of threads. */
-      inline void set_num_threads(_ThreadIndex __num_threads)
-      {
-        this->_M_num_threads = __num_threads;
-      }
+      void set_num_threads(_ThreadIndex __num_threads)
+      { _M_num_threads = __num_threads; }
   };
 
   /** @brief Recommends parallel execution using the

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

@@ -37,19 +37,19 @@
 
 namespace __gnu_parallel
 {
-
-/** @brief Parallel std::unique_copy(), w/__o explicit equality predicate.
+  /** @brief Parallel std::unique_copy(), w/__o explicit equality predicate.
     *  @param __first Begin iterator of input sequence.
     *  @param __last End iterator of input sequence.
     *  @param __result Begin iterator of result __sequence.
     *  @param __binary_pred Equality predicate.
     *  @return End iterator of result __sequence. */
-template<typename _IIter,
+  template<typename _IIter,
            class _OutputIterator,
            class _BinaryPredicate>
     _OutputIterator
     __parallel_unique_copy(_IIter __first, _IIter __last,
-    _OutputIterator __result, _BinaryPredicate __binary_pred)
+			   _OutputIterator __result,
+			   _BinaryPredicate __binary_pred)
     {
       _GLIBCXX_CALL(__last - __first)
 
@@ -57,9 +57,9 @@ template<typename _IIter,
       typedef typename _TraitsType::value_type _ValueType;
       typedef typename _TraitsType::difference_type _DifferenceType;
 
-    _DifferenceType size = __last - __first;
+      _DifferenceType __size = __last - __first;
 
-    if (size == 0)
+      if (__size == 0)
 	return __result;
 
       // Let the first thread process two parts.
@@ -74,7 +74,7 @@ template<typename _IIter,
 	{
 	  __num_threads = omp_get_num_threads();
 	  __borders = new _DifferenceType[__num_threads + 2];
-            equally_split(size, __num_threads + 1, __borders);
+	  equally_split(__size, __num_threads + 1, __borders);
 	  __counter = new _DifferenceType[__num_threads + 1];
 	}
 
@@ -95,12 +95,13 @@ template<typename _IIter,
             ++__i;
             *__out++ = *__first;
 
-          for (_IIter iter = __first + __begin; iter < __first + __end; ++iter)
+            for (_IIter __iter = __first + __begin; __iter < __first + __end;
+		 ++__iter)
               {
-              if (!__binary_pred(*iter, *(iter-1)))
+        	if (!__binary_pred(*__iter, *(__iter - 1)))
                   {
                     ++__i;
-                  *__out++ = *iter;
+                    *__out++ = *__iter;
                   }
               }
           }
@@ -109,9 +110,10 @@ template<typename _IIter,
             __begin = __borders[__iam]; //one part
             __end = __borders[__iam + 1];
 
-          for (_IIter iter = __first + __begin; iter < __first + __end; ++iter)
+            for (_IIter __iter = __first + __begin; __iter < __first + __end;
+		 ++__iter)
               {
-              if (!__binary_pred(*iter, *(iter - 1)))
+        	if (!__binary_pred(*__iter, *(__iter - 1)))
                   ++__i;
               }
           }
@@ -135,14 +137,16 @@ template<typename _IIter,
             _OutputIterator __iter_out = __result + __begin_output;
 
             __begin = __borders[__num_threads];
-          __end = size;
+            __end = __size;
 
-          for (_IIter iter = __first + __begin; iter < __first + __end; ++iter)
+            for (_IIter __iter = __first + __begin; __iter < __first + __end;
+		 ++__iter)
               {
-              if (iter == __first || !__binary_pred(*iter, *(iter - 1)))
+        	if (__iter == __first
+		    || !__binary_pred(*__iter, *(__iter - 1)))
                   {
                     ++__i;
-                  *__iter_out++ = *iter;
+                    *__iter_out++ = *__iter;
                   }
               }
 
@@ -154,10 +158,11 @@ template<typename _IIter,
               __begin_output += __counter[__t];
 
             _OutputIterator __iter_out = __result + __begin_output;
-          for (_IIter iter = __first + __begin; iter < __first + __end; ++iter)
+            for (_IIter __iter = __first + __begin; __iter < __first + __end;
+		 ++__iter)
               {
-              if (!__binary_pred(*iter, *(iter-1)))
-                *__iter_out++ = *iter;
+        	if (!__binary_pred(*__iter, *(__iter - 1)))
+                  *__iter_out++ = *__iter;
               }
           }
       }
@@ -171,12 +176,12 @@ template<typename _IIter,
       return __result + __end_output;
     }
 
-/** @brief Parallel std::unique_copy(), without explicit equality predicate
+  /** @brief Parallel std::unique_copy(), without explicit equality predicate
     *  @param __first Begin iterator of input sequence.
     *  @param __last End iterator of input sequence.
     *  @param __result Begin iterator of result __sequence.
     *  @return End iterator of result __sequence. */
-template<typename _IIter, class _OutputIterator>
+  template<typename _IIter, class _OutputIterator>
     inline _OutputIterator
     __parallel_unique_copy(_IIter __first, _IIter __last,
 			   _OutputIterator __result)

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

@@ -49,8 +49,8 @@ namespace __gnu_parallel
 
 #define _GLIBCXX_JOB_VOLATILE volatile
 
-/** @brief One __job for a certain thread. */
-template<typename _DifferenceTp>
+  /** @brief One __job for a certain thread. */
+  template<typename _DifferenceTp>
     struct _Job
     {
       typedef _DifferenceTp _DifferenceType;
@@ -72,7 +72,7 @@ template<typename _DifferenceTp>
       _GLIBCXX_JOB_VOLATILE _DifferenceType _M_load;
     };
 
-/** @brief Work stealing algorithm for random access iterators.
+  /** @brief Work stealing algorithm for random access iterators.
     *
     *  Uses O(1) additional memory. Synchronization at job lists is
     *  done with atomic operations.
@@ -90,15 +90,17 @@ template<typename _DifferenceTp>
     *  std::count_n()).
     *  @return User-supplied functor (that may contain a part of the result).
     */
-template<typename _RAIter,
+  template<typename _RAIter,
            typename _Op,
            typename _Fu,
            typename _Red,
            typename _Result>
     _Op
-  __for_each_template_random_access_workstealing(
-    _RAIter __begin, _RAIter __end, _Op __op, _Fu& __f, _Red __r,
-    _Result __base, _Result& __output,
+    __for_each_template_random_access_workstealing(_RAIter __begin,
+						   _RAIter __end, _Op __op,
+						   _Fu& __f, _Red __r,
+						   _Result __base,
+						   _Result& __output,
       typename std::iterator_traits<_RAIter>::difference_type __bound)
     {
       _GLIBCXX_CALL(__end - __begin)
@@ -115,8 +117,8 @@ template<typename _RAIter,
       _DifferenceType __length = (__bound < 0) ? (__end - __begin) : __bound;
 
       // To avoid false sharing in a cache line.
-    const int __stride =
-                __s.cache_line_size * 10 / sizeof(_Job<_DifferenceType>) + 1;
+      const int __stride = (__s.cache_line_size * 10
+			    / sizeof(_Job<_DifferenceType>) + 1);
 
       // Total number of threads currently working.
       _ThreadIndex __busy = 0;
@@ -130,13 +132,12 @@ template<typename _RAIter,
       __output = __base;
 
       // No more threads than jobs, at least one thread.
-    _ThreadIndex __num_threads =
-      __gnu_parallel::max<_ThreadIndex>(1,
-        __gnu_parallel::min<_DifferenceType>(__length, __get_max_threads()));
+      _ThreadIndex __num_threads = __gnu_parallel::max<_ThreadIndex>
+	(1, __gnu_parallel::min<_DifferenceType>(__length,
+						 __get_max_threads()));
 
 #     pragma omp parallel shared(__busy) num_threads(__num_threads)
       {
-
 #       pragma omp single
 	{
 	  __num_threads = omp_get_num_threads();
@@ -167,7 +168,7 @@ template<typename _RAIter,
 
 	// Every thread has its own random number generator
 	// (modulo __num_threads).
-        _RandomNumber rand_gen(__iam, __num_threads);
+	_RandomNumber __rand_gen(__iam, __num_threads);
 
 	// This thread is currently working.
 #       pragma omp atomic
@@ -176,11 +177,12 @@ template<typename _RAIter,
 	__iam_working = true;
 
 	// How many jobs per thread? last thread gets the rest.
-        __my_job._M_first =
-            static_cast<_DifferenceType>(__iam * (__length / __num_threads));
+	__my_job._M_first = static_cast<_DifferenceType>
+	  (__iam * (__length / __num_threads));
 
-        __my_job._M_last = (__iam == (__num_threads - 1)) ?
-            (__length - 1) : ((__iam + 1) * (__length / __num_threads) - 1);
+	__my_job._M_last = (__iam == (__num_threads - 1)
+			    ? (__length - 1)
+			    : ((__iam + 1) * (__length / __num_threads) - 1));
 	__my_job._M_load = __my_job._M_last - __my_job._M_first + 1;
 
 	// Init result with _M_first value (to have a base value for reduction)
@@ -210,8 +212,8 @@ template<typename _RAIter,
 		// fetch-and-add call
 		// Reserve current job block (size __chunk_size) in my queue.
 		_DifferenceType __current_job =
-                  __fetch_and_add<_DifferenceType>(
-                    &(__my_job._M_first), __chunk_size);
+		  __fetch_and_add<_DifferenceType>(&(__my_job._M_first),
+						   __chunk_size);
 
 		// Update _M_load, to make the three values consistent,
 		// _M_first might have been changed in the meantime
@@ -242,13 +244,14 @@ template<typename _RAIter,
 		__iam_working = false;
 	      }
 
-            _DifferenceType __supposed_first, __supposed_last, __supposed_load;
+	    _DifferenceType __supposed_first, __supposed_last,
+	                    __supposed_load;
 	    do
 	      {
 		// Find random nonempty deque (not own), do consistency check.
 		__yield();
 #               pragma omp flush(__busy)
-                __victim = rand_gen();
+		__victim = __rand_gen();
 		__supposed_first = __job[__victim * __stride]._M_first;
 		__supposed_last = __job[__victim * __stride]._M_last;
 		__supposed_load = __job[__victim * __stride]._M_load;
@@ -269,14 +272,14 @@ template<typename _RAIter,
 
 		// Push __victim's current start forward.
 		_DifferenceType __stolen_first =
-                    __fetch_and_add<_DifferenceType>(
-                        &(__job[__victim * __stride]._M_first), __steal);
-                _DifferenceType __stolen_try =
-                    __stolen_first + __steal - _DifferenceType(1);
+		  __fetch_and_add<_DifferenceType>
+		  (&(__job[__victim * __stride]._M_first), __steal);
+		_DifferenceType __stolen_try = (__stolen_first + __steal
+						- _DifferenceType(1));
 
 		__my_job._M_first = __stolen_first;
-                __my_job._M_last =
-                  __gnu_parallel::min(__stolen_try, __supposed_last);
+		__my_job._M_last = __gnu_parallel::min(__stolen_try,
+						       __supposed_last);
 		__my_job._M_load = __my_job._M_last - __my_job._M_first + 1;
 
 		// Has potential work again.