algobase.h: Uglify internal identifiers.

2009-09-16  Johannes Singler  <singler@ira.uka.de>

        * include/parallel/algobase.h: Uglify internal identifiers.
        * include/parallel/algo.h: Likewise.
        * include/parallel/algorithmfwd.h: Likewise.
        * include/parallel/balanced_quicksort.h: Likewise.
        * include/parallel/base.h: Likewise.
        * include/parallel/checkers.h: Likewise.
        * include/parallel/compatibility.h: Likewise.
        * include/parallel/compiletime_settings.: Likewise.
        * include/parallel/equally_split.h: Likewise.
        * include/parallel/features.h: Likewise.
        * include/parallel/find.h: Likewise.
        * include/parallel/find_selectors.h: Likewise.
        * include/parallel/for_each.h: Likewise.
        * include/parallel/for_each_selectors.h: Likewise.
        * include/parallel/iterator.h: Likewise.
        * include/parallel/list_partition.h: Likewise.
        * include/parallel/losertree.h: Likewise.
        * include/parallel/merge.h: Likewise.
        * include/parallel/multiseq_selection.h: Likewise.
        * include/parallel/multiway_merge.h: Likewise.
        * include/parallel/multiway_mergesort.h: Likewise.
        * include/parallel/numeric: Likewise.
        * include/parallel/numericfwd.h: Likewise.
        * include/parallel/omp_loop.h: Likewise.
        * include/parallel/omp_loop_static.h: Likewise.
        * include/parallel/par_loop.h: Likewise.
        * include/parallel/partial_sum.h: Likewise.
        * include/parallel/partition.h: Likewise.
        * include/parallel/queue.h: Likewise.
        * include/parallel/quicksort.h: Likewise.
        * include/parallel/random_number.h: Likewise.
        * include/parallel/random_shuffle.h: Likewise.
        * include/parallel/search.h: Likewise.
        * include/parallel/set_operations.h: Likewise.
        * include/parallel/settings.h: Likewise.
        * include/parallel/sort.h: Likewise.
        * include/parallel/tags.h: Likewise.
        * include/parallel/types.h: Likewise.
        * include/parallel/unique_copy.h: Likewise.
        * include/parallel/workstealing.h: Likewise.

From-SVN: r151741

41 files changed, 7062 insertions, 7016 deletions

diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index f473566..9d46458 100644
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,3 +1,49 @@
+2009-09-16  Johannes Singler  <singler@ira.uka.de>
+
+        * include/parallel/algobase.h: Uglify internal identifiers.
+        * include/parallel/algo.h: Likewise.
+        * include/parallel/algorithm: Likewise.
+        * include/parallel/algorithmfwd.h: Likewise.
+        * include/parallel/balanced_quicksort.h: Likewise.
+        * include/parallel/base.h: Likewise.
+        * include/parallel/basic_iterator.h: Likewise.
+        * include/parallel/checkers.h: Likewise.
+        * include/parallel/compatibility.h: Likewise.
+        * include/parallel/compiletime_settings.: Likewise.
+        * include/parallel/equally_split.h: Likewise.
+        * include/parallel/features.h: Likewise.
+        * include/parallel/find.h: Likewise.
+        * include/parallel/find_selectors.h: Likewise.
+        * include/parallel/for_each.h: Likewise.
+        * include/parallel/for_each_selectors.h: Likewise.
+        * include/parallel/iterator.h: Likewise.
+        * include/parallel/list_partition.h: Likewise.
+        * include/parallel/losertree.h: Likewise.
+        * include/parallel/merge.h: Likewise.
+        * include/parallel/multiseq_selection.h: Likewise.
+        * include/parallel/multiway_merge.h: Likewise.
+        * include/parallel/multiway_mergesort.h: Likewise.
+        * include/parallel/numeric: Likewise.
+        * include/parallel/numericfwd.h: Likewise.
+        * include/parallel/omp_loop.h: Likewise.
+        * include/parallel/omp_loop_static.h: Likewise.
+        * include/parallel/parallel.h: Likewise.
+        * include/parallel/par_loop.h: Likewise.
+        * include/parallel/partial_sum.h: Likewise.
+        * include/parallel/partition.h: Likewise.
+        * include/parallel/queue.h: Likewise.
+        * include/parallel/quicksort.h: Likewise.
+        * include/parallel/random_number.h: Likewise.
+        * include/parallel/random_shuffle.h: Likewise.
+        * include/parallel/search.h: Likewise.
+        * include/parallel/set_operations.h: Likewise.
+        * include/parallel/settings.h: Likewise.
+        * include/parallel/sort.h: Likewise.
+        * include/parallel/tags.h: Likewise.
+        * include/parallel/types.h: Likewise.
+        * include/parallel/unique_copy.h: Likewise.
+        * include/parallel/workstealing.h: Likewise.
+
 2009-09-14  Paolo Carlini  <paolo.carlini@oracle.com>
 
 	PR libstdc++/41037
diff --git a/libstdc++-v3/include/parallel/algo.h b/libstdc++-v3/include/parallel/algo.h
index a0fbd8d..7f32036 100644
--- a/libstdc++-v3/include/parallel/algo.h
+++ b/libstdc++-v3/include/parallel/algo.h
@@ -63,1784 +63,1784 @@ namespace std
 namespace __parallel
 {
   // Sequential fallback
-  template<typename InputIterator, typename Function>
-    inline Function
-    for_each(InputIterator begin, InputIterator end, Function f, 
+  template<typename _IIter, typename _Function>
+    inline _Function
+    for_each(_IIter __begin, _IIter __end, _Function __f, 
              __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::for_each(begin, end, f); }
+    { return _GLIBCXX_STD_P::for_each(__begin, __end, __f); }
 
 
   // Sequential fallback for input iterator case
-  template<typename InputIterator, typename Function, typename IteratorTag>
-    inline Function
-    for_each_switch(InputIterator begin, InputIterator end, Function f, 
-                    IteratorTag)
-    { return for_each(begin, end, f, __gnu_parallel::sequential_tag()); }
+  template<typename _IIter, typename _Function, typename _IteratorTag>
+    inline _Function
+    __for_each_switch(_IIter __begin, _IIter __end, _Function __f, 
+                    _IteratorTag)
+    { return for_each(__begin, __end, __f, __gnu_parallel::sequential_tag()); }
 
   // Parallel algorithm for random access iterators
-  template<typename RandomAccessIterator, typename Function>
-    Function
-    for_each_switch(RandomAccessIterator begin, RandomAccessIterator end, 
-                    Function f, random_access_iterator_tag, 
-                    __gnu_parallel::_Parallelism parallelism_tag
+  template<typename _RAIter, typename _Function>
+    _Function
+    __for_each_switch(_RAIter __begin, _RAIter __end, 
+                    _Function __f, random_access_iterator_tag, 
+                    __gnu_parallel::_Parallelism __parallelism_tag
                     = __gnu_parallel::parallel_balanced)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(
-            static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
             >= __gnu_parallel::_Settings::get().for_each_minimal_n
-            && __gnu_parallel::is_parallel(parallelism_tag)))
+            && __gnu_parallel::__is_parallel(__parallelism_tag)))
         {
-          bool dummy;
-    __gnu_parallel::for_each_selector<RandomAccessIterator> functionality;
+          bool __dummy;
+    __gnu_parallel::__for_each_selector<_RAIter> __functionality;
 
           return __gnu_parallel::
-            for_each_template_random_access(begin, end, f, functionality,
-                                            __gnu_parallel::dummy_reduct(),
-                                            true, dummy, -1, parallelism_tag);
+            __for_each_template_random_access(__begin, __end, __f, __functionality,
+                                            __gnu_parallel::_DummyReduct(),
+                                            true, __dummy, -1, __parallelism_tag);
         }
       else
-        return for_each(begin, end, f, __gnu_parallel::sequential_tag());
+        return for_each(__begin, __end, __f, __gnu_parallel::sequential_tag());
     }
 
   // Public interface
-  template<typename Iterator, typename Function>
-    inline Function
-    for_each(Iterator begin, Iterator end, Function f, 
-             __gnu_parallel::_Parallelism parallelism_tag)
+  template<typename _Iterator, typename _Function>
+    inline _Function
+    for_each(_Iterator __begin, _Iterator __end, _Function __f, 
+             __gnu_parallel::_Parallelism __parallelism_tag)
     {
-      typedef std::iterator_traits<Iterator> iterator_traits;
-      typedef typename iterator_traits::iterator_category iterator_category;
-      return for_each_switch(begin, end, f, iterator_category(), 
-                             parallelism_tag);
+      typedef std::iterator_traits<_Iterator> _IteratorTraits;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+      return __for_each_switch(__begin, __end, __f, _IteratorCategory(), 
+                             __parallelism_tag);
     }
 
-  template<typename Iterator, typename Function>
-    inline Function
-    for_each(Iterator begin, Iterator end, Function f) 
+  template<typename _Iterator, typename _Function>
+    inline _Function
+    for_each(_Iterator __begin, _Iterator __end, _Function __f) 
     {
-      typedef std::iterator_traits<Iterator> iterator_traits;
-      typedef typename iterator_traits::iterator_category iterator_category;
-      return for_each_switch(begin, end, f, iterator_category());
+      typedef std::iterator_traits<_Iterator> _IteratorTraits;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+      return __for_each_switch(__begin, __end, __f, _IteratorCategory());
     }
 
 
   // Sequential fallback
-  template<typename InputIterator, typename T>
-    inline InputIterator
-    find(InputIterator begin, InputIterator end, const T& val, 
+  template<typename _IIter, typename _Tp>
+    inline _IIter
+    find(_IIter __begin, _IIter __end, const _Tp& __val, 
          __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::find(begin, end, val); }
+    { return _GLIBCXX_STD_P::find(__begin, __end, __val); }
 
   // Sequential fallback for input iterator case
-  template<typename InputIterator, typename T, typename IteratorTag>
-    inline InputIterator
-    find_switch(InputIterator begin, InputIterator end, const T& val,
-                IteratorTag)
-    { return _GLIBCXX_STD_P::find(begin, end, val); }
+  template<typename _IIter, typename _Tp, typename _IteratorTag>
+    inline _IIter
+    __find_switch(_IIter __begin, _IIter __end, const _Tp& __val,
+                _IteratorTag)
+    { return _GLIBCXX_STD_P::find(__begin, __end, __val); }
 
   // Parallel find for random access iterators
-  template<typename RandomAccessIterator, typename T>
-    RandomAccessIterator
-    find_switch(RandomAccessIterator begin, RandomAccessIterator end,
-                const T& val, random_access_iterator_tag)
+  template<typename _RAIter, typename _Tp>
+    _RAIter
+    __find_switch(_RAIter __begin, _RAIter __end,
+                const _Tp& __val, random_access_iterator_tag)
     {
-      typedef iterator_traits<RandomAccessIterator> traits_type;
-      typedef typename traits_type::value_type value_type;
+      typedef iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
 
       if (_GLIBCXX_PARALLEL_CONDITION(true))
         {
-          binder2nd<__gnu_parallel::equal_to<value_type, const T&> >
-            comp(__gnu_parallel::equal_to<value_type, const T&>(), val);
-          return __gnu_parallel::find_template(begin, end, begin, comp,
+          binder2nd<__gnu_parallel::equal_to<_ValueType, const _Tp&> >
+            __comp(__gnu_parallel::equal_to<_ValueType, const _Tp&>(), __val);
+          return __gnu_parallel::__find_template(__begin, __end, __begin, __comp,
                                                __gnu_parallel::
-                                               find_if_selector()).first;
+                                               __find_if_selector()).first;
         }
       else
-        return _GLIBCXX_STD_P::find(begin, end, val);
+        return _GLIBCXX_STD_P::find(__begin, __end, __val);
     }
 
   // Public interface
-  template<typename InputIterator, typename T>
-    inline InputIterator
-    find(InputIterator begin, InputIterator end, const T& val)
+  template<typename _IIter, typename _Tp>
+    inline _IIter
+    find(_IIter __begin, _IIter __end, const _Tp& __val)
     {
-      typedef std::iterator_traits<InputIterator> iterator_traits;
-      typedef typename iterator_traits::iterator_category iterator_category;
-      return find_switch(begin, end, val, iterator_category());
+      typedef std::iterator_traits<_IIter> _IteratorTraits;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+      return __find_switch(__begin, __end, __val, _IteratorCategory());
     }
 
   // Sequential fallback
-  template<typename InputIterator, typename Predicate>
-    inline InputIterator
-    find_if(InputIterator begin, InputIterator end, Predicate pred, 
+  template<typename _IIter, typename _Predicate>
+    inline _IIter
+    find_if(_IIter __begin, _IIter __end, _Predicate __pred, 
             __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::find_if(begin, end, pred); }
+    { return _GLIBCXX_STD_P::find_if(__begin, __end, __pred); }
 
   // Sequential fallback for input iterator case
-  template<typename InputIterator, typename Predicate, typename IteratorTag>
-    inline InputIterator
-    find_if_switch(InputIterator begin, InputIterator end, Predicate pred, 
-                   IteratorTag)
-    { return _GLIBCXX_STD_P::find_if(begin, end, pred); }
+  template<typename _IIter, typename _Predicate, typename _IteratorTag>
+    inline _IIter
+    __find_if_switch(_IIter __begin, _IIter __end, _Predicate __pred, 
+                   _IteratorTag)
+    { return _GLIBCXX_STD_P::find_if(__begin, __end, __pred); }
 
   // Parallel find_if for random access iterators
-  template<typename RandomAccessIterator, typename Predicate>
-    RandomAccessIterator
-    find_if_switch(RandomAccessIterator begin, RandomAccessIterator end, 
-                   Predicate pred, random_access_iterator_tag)
+  template<typename _RAIter, typename _Predicate>
+    _RAIter
+    __find_if_switch(_RAIter __begin, _RAIter __end, 
+                   _Predicate __pred, random_access_iterator_tag)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(true))
-        return __gnu_parallel::find_template(begin, end, begin, pred, 
+        return __gnu_parallel::__find_template(__begin, __end, __begin, __pred, 
                                              __gnu_parallel::
-                                             find_if_selector()).first;
+                                             __find_if_selector()).first;
       else
-        return _GLIBCXX_STD_P::find_if(begin, end, pred);
+        return _GLIBCXX_STD_P::find_if(__begin, __end, __pred);
     }
 
   // Public interface
-  template<typename InputIterator, typename Predicate>
-    inline InputIterator
-    find_if(InputIterator begin, InputIterator end, Predicate pred)
+  template<typename _IIter, typename _Predicate>
+    inline _IIter
+    find_if(_IIter __begin, _IIter __end, _Predicate __pred)
     {
-      typedef std::iterator_traits<InputIterator> iterator_traits;
-      typedef typename iterator_traits::iterator_category iterator_category;
-      return find_if_switch(begin, end, pred, iterator_category());
+      typedef std::iterator_traits<_IIter> _IteratorTraits;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+      return __find_if_switch(__begin, __end, __pred, _IteratorCategory());
     }
 
   // Sequential fallback
-  template<typename InputIterator, typename ForwardIterator>
-    inline InputIterator
-    find_first_of(InputIterator begin1, InputIterator end1, 
-                  ForwardIterator begin2, ForwardIterator end2, 
+  template<typename _IIter, typename _ForwardIterator>
+    inline _IIter
+    find_first_of(_IIter __begin1, _IIter __end1, 
+                  _ForwardIterator __begin2, _ForwardIterator __end2, 
                   __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::find_first_of(begin1, end1, begin2, end2); }
+    { return _GLIBCXX_STD_P::find_first_of(__begin1, __end1, __begin2, __end2); }
 
   // Sequential fallback
-  template<typename InputIterator, typename ForwardIterator,
-           typename BinaryPredicate>
-    inline InputIterator
-    find_first_of(InputIterator begin1, InputIterator end1,
-                  ForwardIterator begin2, ForwardIterator end2,
-                  BinaryPredicate comp, __gnu_parallel::sequential_tag)
-  { return _GLIBCXX_STD_P::find_first_of(begin1, end1, begin2, end2, comp); }
-
-  // Sequential fallback for input iterator type
-  template<typename InputIterator, typename ForwardIterator,
-           typename IteratorTag1, typename IteratorTag2>
-    inline InputIterator
-    find_first_of_switch(InputIterator begin1, InputIterator end1,
-                         ForwardIterator begin2, ForwardIterator end2, 
-                         IteratorTag1, IteratorTag2)
-    { return find_first_of(begin1, end1, begin2, end2, 
+  template<typename _IIter, typename _ForwardIterator,
+           typename _BinaryPredicate>
+    inline _IIter
+    find_first_of(_IIter __begin1, _IIter __end1,
+                  _ForwardIterator __begin2, _ForwardIterator __end2,
+                  _BinaryPredicate __comp, __gnu_parallel::sequential_tag)
+  { return _GLIBCXX_STD_P::find_first_of(__begin1, __end1, __begin2, __end2, __comp); }
+
+  // Sequential fallback for input iterator _Self
+  template<typename _IIter, typename _ForwardIterator,
+           typename _IteratorTag1, typename _IteratorTag2>
+    inline _IIter
+    __find_first_of_switch(_IIter __begin1, _IIter __end1,
+                         _ForwardIterator __begin2, _ForwardIterator __end2, 
+                         _IteratorTag1, _IteratorTag2)
+    { return find_first_of(__begin1, __end1, __begin2, __end2, 
                            __gnu_parallel::sequential_tag()); }
 
   // Parallel algorithm for random access iterators
-  template<typename RandomAccessIterator, typename ForwardIterator,
-           typename BinaryPredicate, typename IteratorTag>
-    inline RandomAccessIterator
-    find_first_of_switch(RandomAccessIterator begin1,
-                         RandomAccessIterator end1,
-                         ForwardIterator begin2, ForwardIterator end2, 
-                         BinaryPredicate comp, random_access_iterator_tag, 
-                         IteratorTag)
+  template<typename _RAIter, typename _ForwardIterator,
+           typename _BinaryPredicate, typename _IteratorTag>
+    inline _RAIter
+    __find_first_of_switch(_RAIter __begin1,
+                         _RAIter __end1,
+                         _ForwardIterator __begin2, _ForwardIterator __end2, 
+                         _BinaryPredicate __comp, random_access_iterator_tag, 
+                         _IteratorTag)
     {
       return __gnu_parallel::
-        find_template(begin1, end1, begin1, comp,
-                      __gnu_parallel::find_first_of_selector
-                      <ForwardIterator>(begin2, end2)).first;
-    }
-
-  // Sequential fallback for input iterator type
-  template<typename InputIterator, typename ForwardIterator,
-           typename BinaryPredicate, typename IteratorTag1,
-           typename IteratorTag2>
-    inline InputIterator
-    find_first_of_switch(InputIterator begin1, InputIterator end1,
-                         ForwardIterator begin2, ForwardIterator end2, 
-                         BinaryPredicate comp, IteratorTag1, IteratorTag2)
-    { return find_first_of(begin1, end1, begin2, end2, comp, 
+        __find_template(__begin1, __end1, __begin1, __comp,
+                      __gnu_parallel::__find_first_of_selector
+                      <_ForwardIterator>(__begin2, __end2)).first;
+    }
+
+  // Sequential fallback for input iterator _Self
+  template<typename _IIter, typename _ForwardIterator,
+           typename _BinaryPredicate, typename _IteratorTag1,
+           typename _IteratorTag2>
+    inline _IIter
+    __find_first_of_switch(_IIter __begin1, _IIter __end1,
+                         _ForwardIterator __begin2, _ForwardIterator __end2, 
+                         _BinaryPredicate __comp, _IteratorTag1, _IteratorTag2)
+    { return find_first_of(__begin1, __end1, __begin2, __end2, __comp, 
                            __gnu_parallel::sequential_tag()); }
 
   // Public interface
-  template<typename InputIterator, typename ForwardIterator,
-           typename BinaryPredicate>
-    inline InputIterator
-    find_first_of(InputIterator begin1, InputIterator end1,
-                  ForwardIterator begin2, ForwardIterator end2, 
-                  BinaryPredicate comp)
-    {
-      typedef std::iterator_traits<InputIterator> iteratori_traits;
-      typedef std::iterator_traits<ForwardIterator> iteratorf_traits;
-      typedef typename iteratori_traits::iterator_category iteratori_category;
+  template<typename _IIter, typename _ForwardIterator,
+           typename _BinaryPredicate>
+    inline _IIter
+    find_first_of(_IIter __begin1, _IIter __end1,
+                  _ForwardIterator __begin2, _ForwardIterator __end2, 
+                  _BinaryPredicate __comp)
+    {
+      typedef std::iterator_traits<_IIter> _IIterTraits;
+      typedef std::iterator_traits<_ForwardIterator> iteratorf_traits;
+      typedef typename _IIterTraits::iterator_category _IIteratorCategory;
       typedef typename iteratorf_traits::iterator_category iteratorf_category;
 
-      return find_first_of_switch(begin1, end1, begin2, end2, comp,
-                                  iteratori_category(), iteratorf_category());
+      return __find_first_of_switch(__begin1, __end1, __begin2, __end2, __comp,
+                                  _IIteratorCategory(), iteratorf_category());
     }
 
   // Public interface, insert default comparator
-  template<typename InputIterator, typename ForwardIterator>
-    inline InputIterator
-    find_first_of(InputIterator begin1, InputIterator end1, 
-                  ForwardIterator begin2, ForwardIterator end2)
+  template<typename _IIter, typename _ForwardIterator>
+    inline _IIter
+    find_first_of(_IIter __begin1, _IIter __end1, 
+                  _ForwardIterator __begin2, _ForwardIterator __end2)
     {
-      typedef std::iterator_traits<InputIterator> iteratori_traits;
-      typedef std::iterator_traits<ForwardIterator> iteratorf_traits;
-      typedef typename iteratori_traits::value_type valuei_type;
-      typedef typename iteratorf_traits::value_type valuef_type;
+      typedef std::iterator_traits<_IIter> _IIterTraits;
+      typedef std::iterator_traits<_ForwardIterator> iteratorf_traits;
+      typedef typename _IIterTraits::value_type _IValueType;
+      typedef typename iteratorf_traits::value_type _FValueType;
 
-      return find_first_of(begin1, end1, begin2, end2, __gnu_parallel::
-                           equal_to<valuei_type, valuef_type>());
+      return find_first_of(__begin1, __end1, __begin2, __end2, __gnu_parallel::
+                           equal_to<_IValueType, _FValueType>());
     }
 
   // Sequential fallback
-  template<typename InputIterator, typename OutputIterator>
-    inline OutputIterator
-    unique_copy(InputIterator begin1, InputIterator end1, OutputIterator out,
+  template<typename _IIter, typename _OutputIterator>
+    inline _OutputIterator
+    unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out,
                 __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::unique_copy(begin1, end1, out); }
+    { return _GLIBCXX_STD_P::unique_copy(__begin1, __end1, __out); }
 
   // Sequential fallback
-  template<typename InputIterator, typename OutputIterator,
-           typename Predicate>
-    inline OutputIterator
-    unique_copy(InputIterator begin1, InputIterator end1, OutputIterator out,
-                Predicate pred, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::unique_copy(begin1, end1, out, pred); }
+  template<typename _IIter, typename _OutputIterator,
+           typename _Predicate>
+    inline _OutputIterator
+    unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out,
+                _Predicate __pred, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::unique_copy(__begin1, __end1, __out, __pred); }
 
   // Sequential fallback for input iterator case
-  template<typename InputIterator, typename OutputIterator,
-           typename Predicate, typename IteratorTag1, typename IteratorTag2>
-    inline OutputIterator
-    unique_copy_switch(InputIterator begin, InputIterator last, 
-                       OutputIterator out, Predicate pred, 
-                       IteratorTag1, IteratorTag2)
-    { return _GLIBCXX_STD_P::unique_copy(begin, last, out, pred); }
+  template<typename _IIter, typename _OutputIterator,
+           typename _Predicate, typename _IteratorTag1, typename _IteratorTag2>
+    inline _OutputIterator
+    __unique_copy_switch(_IIter __begin, _IIter __last, 
+                       _OutputIterator __out, _Predicate __pred, 
+                       _IteratorTag1, _IteratorTag2)
+    { return _GLIBCXX_STD_P::unique_copy(__begin, __last, __out, __pred); }
 
   // Parallel unique_copy for random access iterators
-  template<typename RandomAccessIterator, typename RandomAccessOutputIterator,
-           typename Predicate>
+  template<typename _RAIter, typename RandomAccessOutputIterator,
+           typename _Predicate>
     RandomAccessOutputIterator
-    unique_copy_switch(RandomAccessIterator begin, RandomAccessIterator last, 
-                       RandomAccessOutputIterator out, Predicate pred, 
+    __unique_copy_switch(_RAIter __begin, _RAIter __last, 
+                       RandomAccessOutputIterator __out, _Predicate __pred, 
                        random_access_iterator_tag, random_access_iterator_tag)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(
-            static_cast<__gnu_parallel::sequence_index_t>(last - begin)
+            static_cast<__gnu_parallel::_SequenceIndex>(__last - __begin)
             > __gnu_parallel::_Settings::get().unique_copy_minimal_n))
-        return __gnu_parallel::parallel_unique_copy(begin, last, out, pred);
+        return __gnu_parallel::__parallel_unique_copy(__begin, __last, __out, __pred);
       else
-        return _GLIBCXX_STD_P::unique_copy(begin, last, out, pred);
+        return _GLIBCXX_STD_P::unique_copy(__begin, __last, __out, __pred);
     }
 
   // Public interface
-  template<typename InputIterator, typename OutputIterator>
-    inline OutputIterator
-    unique_copy(InputIterator begin1, InputIterator end1, OutputIterator out)
+  template<typename _IIter, typename _OutputIterator>
+    inline _OutputIterator
+    unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out)
     {
-      typedef std::iterator_traits<InputIterator> iteratori_traits;
-      typedef std::iterator_traits<OutputIterator> iteratoro_traits;
-      typedef typename iteratori_traits::iterator_category iteratori_category;
-      typedef typename iteratori_traits::value_type value_type;
-      typedef typename iteratoro_traits::iterator_category iteratoro_category;
+      typedef std::iterator_traits<_IIter> _IIterTraits;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits::iterator_category _IIteratorCategory;
+      typedef typename _IIterTraits::value_type _ValueType;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
 
-      return unique_copy_switch(begin1, end1, out, equal_to<value_type>(),
-                                iteratori_category(), iteratoro_category());
+      return __unique_copy_switch(__begin1, __end1, __out, equal_to<_ValueType>(),
+                                _IIteratorCategory(), _OIterCategory());
     }
 
   // Public interface
-  template<typename InputIterator, typename OutputIterator, typename Predicate>
-    inline OutputIterator
-    unique_copy(InputIterator begin1, InputIterator end1, OutputIterator out,
-                Predicate pred)
+  template<typename _IIter, typename _OutputIterator, typename _Predicate>
+    inline _OutputIterator
+    unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out,
+                _Predicate __pred)
     {
-      typedef std::iterator_traits<InputIterator> iteratori_traits;
-      typedef std::iterator_traits<OutputIterator> iteratoro_traits;
-      typedef typename iteratori_traits::iterator_category iteratori_category;
-      typedef typename iteratoro_traits::iterator_category iteratoro_category;
+      typedef std::iterator_traits<_IIter> _IIterTraits;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits::iterator_category _IIteratorCategory;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
 
-      return unique_copy_switch(begin1, end1, out, pred, iteratori_category(), 
-                                iteratoro_category());
+      return __unique_copy_switch(__begin1, __end1, __out, __pred, _IIteratorCategory(), 
+                                _OIterCategory());
     }
 
   // Sequential fallback
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator>
-    inline OutputIterator
-    set_union(InputIterator1 begin1, InputIterator1 end1,
-              InputIterator2 begin2, InputIterator2 end2,
-              OutputIterator out, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::set_union(begin1, end1, begin2, end2, out); }
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator>
+    inline _OutputIterator
+    set_union(_IIter1 __begin1, _IIter1 __end1,
+              _IIter2 __begin2, _IIter2 __end2,
+              _OutputIterator __out, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::set_union(__begin1, __end1, __begin2, __end2, __out); }
 
   // Sequential fallback
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator, typename Predicate>
-    inline OutputIterator
-    set_union(InputIterator1 begin1, InputIterator1 end1,
-              InputIterator2 begin2, InputIterator2 end2,
-              OutputIterator out, Predicate pred,
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _Predicate>
+    inline _OutputIterator
+    set_union(_IIter1 __begin1, _IIter1 __end1,
+              _IIter2 __begin2, _IIter2 __end2,
+              _OutputIterator __out, _Predicate __pred,
               __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::set_union(begin1, end1,
-                                       begin2, end2, out, pred); }
+    { return _GLIBCXX_STD_P::set_union(__begin1, __end1,
+                                       __begin2, __end2, __out, __pred); }
 
   // Sequential fallback for input iterator case
-  template<typename InputIterator1, typename InputIterator2,
-           typename Predicate, typename OutputIterator,
-           typename IteratorTag1, typename IteratorTag2, typename IteratorTag3>
-    inline OutputIterator
-    set_union_switch(InputIterator1 begin1, InputIterator1 end1, 
-                     InputIterator2 begin2, InputIterator2 end2, 
-                     OutputIterator result, Predicate pred, IteratorTag1,
-                     IteratorTag2, IteratorTag3)
-    { return _GLIBCXX_STD_P::set_union(begin1, end1,
-                                       begin2, end2, result, pred); }
+  template<typename _IIter1, typename _IIter2,
+           typename _Predicate, typename _OutputIterator,
+           typename _IteratorTag1, typename _IteratorTag2, typename _IteratorTag3>
+    inline _OutputIterator
+    __set_union_switch(_IIter1 __begin1, _IIter1 __end1, 
+                     _IIter2 __begin2, _IIter2 __end2, 
+                     _OutputIterator __result, _Predicate __pred, _IteratorTag1,
+                     _IteratorTag2, _IteratorTag3)
+    { return _GLIBCXX_STD_P::set_union(__begin1, __end1,
+                                       __begin2, __end2, __result, __pred); }
 
   // Parallel set_union for random access iterators
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-           typename OutputRandomAccessIterator, typename Predicate>
-    OutputRandomAccessIterator
-    set_union_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, 
-                     RandomAccessIterator2 begin2, RandomAccessIterator2 end2, 
-                     OutputRandomAccessIterator result, Predicate pred,
+  template<typename _RAIter1, typename _RAIter2,
+           typename _Output_RAIter, typename _Predicate>
+    _Output_RAIter
+    __set_union_switch(_RAIter1 __begin1, _RAIter1 __end1, 
+                     _RAIter2 __begin2, _RAIter2 __end2, 
+                     _Output_RAIter __result, _Predicate __pred,
                      random_access_iterator_tag, random_access_iterator_tag, 
                      random_access_iterator_tag)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(
-            static_cast<__gnu_parallel::sequence_index_t>(end1 - begin1)
+            static_cast<__gnu_parallel::_SequenceIndex>(__end1 - __begin1)
             >= __gnu_parallel::_Settings::get().set_union_minimal_n
-            || static_cast<__gnu_parallel::sequence_index_t>(end2 - begin2)
+            || static_cast<__gnu_parallel::_SequenceIndex>(__end2 - __begin2)
             >= __gnu_parallel::_Settings::get().set_union_minimal_n))
-        return __gnu_parallel::parallel_set_union(begin1, end1,
-                                                  begin2, end2, result, pred);
+        return __gnu_parallel::__parallel_set_union(__begin1, __end1,
+                                                  __begin2, __end2, __result, __pred);
       else
-        return _GLIBCXX_STD_P::set_union(begin1, end1,
-                                         begin2, end2, result, pred);
+        return _GLIBCXX_STD_P::set_union(__begin1, __end1,
+                                         __begin2, __end2, __result, __pred);
     }
 
   // Public interface
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator>
-    inline OutputIterator 
-    set_union(InputIterator1 begin1, InputIterator1 end1,
-              InputIterator2 begin2, InputIterator2 end2, OutputIterator out)
-    {
-      typedef std::iterator_traits<InputIterator1> iteratori1_traits;
-      typedef std::iterator_traits<InputIterator2> iteratori2_traits;
-      typedef std::iterator_traits<OutputIterator> iteratoro_traits;
-      typedef typename iteratori1_traits::iterator_category
-        iteratori1_category;
-      typedef typename iteratori2_traits::iterator_category
-        iteratori2_category;
-      typedef typename iteratoro_traits::iterator_category iteratoro_category;
-      typedef typename iteratori1_traits::value_type value1_type;
-      typedef typename iteratori2_traits::value_type value2_type;
-
-      return set_union_switch(begin1, end1, begin2, end2, out, 
-                              __gnu_parallel::less<value1_type, value2_type>(),
-                              iteratori1_category(), iteratori2_category(),
-                              iteratoro_category());
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator>
+    inline _OutputIterator 
+    set_union(_IIter1 __begin1, _IIter1 __end1,
+              _IIter2 __begin2, _IIter2 __end2, _OutputIterator __out)
+    {
+      typedef std::iterator_traits<_IIter1> _IIterTraits1;
+      typedef std::iterator_traits<_IIter2> _IIterTraits2;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits1::iterator_category
+        _IIterCategory1;
+      typedef typename _IIterTraits2::iterator_category
+        _IIterCategory2;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+      typedef typename _IIterTraits1::value_type _ValueType1;
+      typedef typename _IIterTraits2::value_type _ValueType2;
+
+      return __set_union_switch(__begin1, __end1, __begin2, __end2, __out, 
+                              __gnu_parallel::_Less<_ValueType1, _ValueType2>(),
+                              _IIterCategory1(), _IIterCategory2(),
+                              _OIterCategory());
     }
 
   // Public interface
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator, typename Predicate>
-    inline OutputIterator 
-    set_union(InputIterator1 begin1, InputIterator1 end1,
-              InputIterator2 begin2, InputIterator2 end2,
-              OutputIterator out, Predicate pred)
-    {
-      typedef std::iterator_traits<InputIterator1> iteratori1_traits;
-      typedef std::iterator_traits<InputIterator2> iteratori2_traits;
-      typedef std::iterator_traits<OutputIterator> iteratoro_traits;
-      typedef typename iteratori1_traits::iterator_category
-        iteratori1_category;
-      typedef typename iteratori2_traits::iterator_category
-        iteratori2_category;
-      typedef typename iteratoro_traits::iterator_category iteratoro_category;
-
-      return set_union_switch(begin1, end1, begin2, end2, out, pred,
-                              iteratori1_category(), iteratori2_category(),
-                              iteratoro_category());
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _Predicate>
+    inline _OutputIterator 
+    set_union(_IIter1 __begin1, _IIter1 __end1,
+              _IIter2 __begin2, _IIter2 __end2,
+              _OutputIterator __out, _Predicate __pred)
+    {
+      typedef std::iterator_traits<_IIter1> _IIterTraits1;
+      typedef std::iterator_traits<_IIter2> _IIterTraits2;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits1::iterator_category
+        _IIterCategory1;
+      typedef typename _IIterTraits2::iterator_category
+        _IIterCategory2;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+
+      return __set_union_switch(__begin1, __end1, __begin2, __end2, __out, __pred,
+                              _IIterCategory1(), _IIterCategory2(),
+                              _OIterCategory());
     }
 
   // Sequential fallback.
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator>
-    inline OutputIterator
-    set_intersection(InputIterator1 begin1, InputIterator1 end1,
-                     InputIterator2 begin2, InputIterator2 end2,
-                     OutputIterator out, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::set_intersection(begin1, end1,
-                                              begin2, end2, out); }
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator>
+    inline _OutputIterator
+    set_intersection(_IIter1 __begin1, _IIter1 __end1,
+                     _IIter2 __begin2, _IIter2 __end2,
+                     _OutputIterator __out, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::set_intersection(__begin1, __end1,
+                                              __begin2, __end2, __out); }
 
   // Sequential fallback.
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator, typename Predicate>
-    inline OutputIterator
-    set_intersection(InputIterator1 begin1, InputIterator1 end1,
-                     InputIterator2 begin2, InputIterator2 end2,
-                     OutputIterator out, Predicate pred, 
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _Predicate>
+    inline _OutputIterator
+    set_intersection(_IIter1 __begin1, _IIter1 __end1,
+                     _IIter2 __begin2, _IIter2 __end2,
+                     _OutputIterator __out, _Predicate __pred, 
                      __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::set_intersection(begin1, end1, begin2, end2, 
-                                              out, pred); }
+    { return _GLIBCXX_STD_P::set_intersection(__begin1, __end1, __begin2, __end2, 
+                                              __out, __pred); }
 
   // Sequential fallback for input iterator case
-  template<typename InputIterator1, typename InputIterator2,
-           typename Predicate, typename OutputIterator,
-           typename IteratorTag1, typename IteratorTag2,
-           typename IteratorTag3>
-    inline OutputIterator 
-    set_intersection_switch(InputIterator1 begin1, InputIterator1 end1, 
-                            InputIterator2 begin2, InputIterator2 end2, 
-                            OutputIterator result, Predicate pred, 
-                            IteratorTag1, IteratorTag2, IteratorTag3)
-    { return _GLIBCXX_STD_P::set_intersection(begin1, end1, begin2, 
-                                              end2, result, pred); }
+  template<typename _IIter1, typename _IIter2,
+           typename _Predicate, typename _OutputIterator,
+           typename _IteratorTag1, typename _IteratorTag2,
+           typename _IteratorTag3>
+    inline _OutputIterator 
+    __set_intersection_switch(_IIter1 __begin1, _IIter1 __end1, 
+                            _IIter2 __begin2, _IIter2 __end2, 
+                            _OutputIterator __result, _Predicate __pred, 
+                            _IteratorTag1, _IteratorTag2, _IteratorTag3)
+    { return _GLIBCXX_STD_P::set_intersection(__begin1, __end1, __begin2, 
+                                              __end2, __result, __pred); }
 
   // Parallel set_intersection for random access iterators
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-           typename OutputRandomAccessIterator, typename Predicate>
-    OutputRandomAccessIterator
-    set_intersection_switch(RandomAccessIterator1 begin1,
-                            RandomAccessIterator1 end1,
-                            RandomAccessIterator2 begin2,
-                            RandomAccessIterator2 end2,
-                            OutputRandomAccessIterator result,
-                            Predicate pred,
+  template<typename _RAIter1, typename _RAIter2,
+           typename _Output_RAIter, typename _Predicate>
+    _Output_RAIter
+    __set_intersection_switch(_RAIter1 __begin1,
+                            _RAIter1 __end1,
+                            _RAIter2 __begin2,
+                            _RAIter2 __end2,
+                            _Output_RAIter __result,
+                            _Predicate __pred,
                             random_access_iterator_tag,
                             random_access_iterator_tag,
                             random_access_iterator_tag)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(
-            static_cast<__gnu_parallel::sequence_index_t>(end1 - begin1)
+            static_cast<__gnu_parallel::_SequenceIndex>(__end1 - __begin1)
             >= __gnu_parallel::_Settings::get().set_union_minimal_n
-            || static_cast<__gnu_parallel::sequence_index_t>(end2 - begin2)
+            || static_cast<__gnu_parallel::_SequenceIndex>(__end2 - __begin2)
             >= __gnu_parallel::_Settings::get().set_union_minimal_n))
-        return __gnu_parallel::parallel_set_intersection(begin1, end1, begin2, 
-                                                         end2, result, pred);
+        return __gnu_parallel::__parallel_set_intersection(__begin1, __end1, __begin2, 
+                                                         __end2, __result, __pred);
       else
-        return _GLIBCXX_STD_P::set_intersection(begin1, end1, begin2, 
-                                                end2, result, pred);
+        return _GLIBCXX_STD_P::set_intersection(__begin1, __end1, __begin2, 
+                                                __end2, __result, __pred);
     }
 
   // Public interface
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator>
-    inline OutputIterator 
-    set_intersection(InputIterator1 begin1, InputIterator1 end1, 
-                     InputIterator2 begin2, InputIterator2 end2, 
-                     OutputIterator out)
-    {
-      typedef std::iterator_traits<InputIterator1> iteratori1_traits;
-      typedef std::iterator_traits<InputIterator2> iteratori2_traits;
-      typedef std::iterator_traits<OutputIterator> iteratoro_traits;
-      typedef typename iteratori1_traits::iterator_category
-        iteratori1_category;
-      typedef typename iteratori2_traits::iterator_category
-        iteratori2_category;
-      typedef typename iteratoro_traits::iterator_category iteratoro_category;
-      typedef typename iteratori1_traits::value_type value1_type;
-      typedef typename iteratori2_traits::value_type value2_type;
-
-      return set_intersection_switch(begin1, end1, begin2, end2, out,
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator>
+    inline _OutputIterator 
+    set_intersection(_IIter1 __begin1, _IIter1 __end1, 
+                     _IIter2 __begin2, _IIter2 __end2, 
+                     _OutputIterator __out)
+    {
+      typedef std::iterator_traits<_IIter1> _IIterTraits1;
+      typedef std::iterator_traits<_IIter2> _IIterTraits2;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits1::iterator_category
+        _IIterCategory1;
+      typedef typename _IIterTraits2::iterator_category
+        _IIterCategory2;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+      typedef typename _IIterTraits1::value_type _ValueType1;
+      typedef typename _IIterTraits2::value_type _ValueType2;
+
+      return __set_intersection_switch(__begin1, __end1, __begin2, __end2, __out,
                                      __gnu_parallel::
-                                     less<value1_type, value2_type>(),
-                                     iteratori1_category(),
-                                     iteratori2_category(), 
-                                     iteratoro_category());
-    }
-
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator, typename Predicate>
-    inline OutputIterator 
-    set_intersection(InputIterator1 begin1, InputIterator1 end1,
-                     InputIterator2 begin2, InputIterator2 end2,
-                     OutputIterator out, Predicate pred)
-    {
-      typedef std::iterator_traits<InputIterator1> iteratori1_traits;
-      typedef std::iterator_traits<InputIterator2> iteratori2_traits;
-      typedef std::iterator_traits<OutputIterator> iteratoro_traits;
-      typedef typename iteratori1_traits::iterator_category
-        iteratori1_category;
-      typedef typename iteratori2_traits::iterator_category
-        iteratori2_category;
-      typedef typename iteratoro_traits::iterator_category iteratoro_category;
-
-      return set_intersection_switch(begin1, end1, begin2, end2, out, pred,
-                                     iteratori1_category(),
-                                     iteratori2_category(),
-                                     iteratoro_category());
+                                     _Less<_ValueType1, _ValueType2>(),
+                                     _IIterCategory1(),
+                                     _IIterCategory2(), 
+                                     _OIterCategory());
+    }
+
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _Predicate>
+    inline _OutputIterator 
+    set_intersection(_IIter1 __begin1, _IIter1 __end1,
+                     _IIter2 __begin2, _IIter2 __end2,
+                     _OutputIterator __out, _Predicate __pred)
+    {
+      typedef std::iterator_traits<_IIter1> _IIterTraits1;
+      typedef std::iterator_traits<_IIter2> _IIterTraits2;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits1::iterator_category
+        _IIterCategory1;
+      typedef typename _IIterTraits2::iterator_category
+        _IIterCategory2;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+
+      return __set_intersection_switch(__begin1, __end1, __begin2, __end2, __out, __pred,
+                                     _IIterCategory1(),
+                                     _IIterCategory2(),
+                                     _OIterCategory());
     }
 
   // Sequential fallback
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator>
-    inline OutputIterator
-    set_symmetric_difference(InputIterator1 begin1, InputIterator1 end1,
-                             InputIterator2 begin2, InputIterator2 end2,
-                             OutputIterator out,
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator>
+    inline _OutputIterator
+    set_symmetric_difference(_IIter1 __begin1, _IIter1 __end1,
+                             _IIter2 __begin2, _IIter2 __end2,
+                             _OutputIterator __out,
                              __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::set_symmetric_difference(begin1,end1,
-                                                      begin2, end2, out); }
+    { return _GLIBCXX_STD_P::set_symmetric_difference(__begin1,__end1,
+                                                      __begin2, __end2, __out); }
 
   // Sequential fallback
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator, typename Predicate>
-    inline OutputIterator
-    set_symmetric_difference(InputIterator1 begin1, InputIterator1 end1,
-                             InputIterator2 begin2, InputIterator2 end2,
-                             OutputIterator out, Predicate pred,
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _Predicate>
+    inline _OutputIterator
+    set_symmetric_difference(_IIter1 __begin1, _IIter1 __end1,
+                             _IIter2 __begin2, _IIter2 __end2,
+                             _OutputIterator __out, _Predicate __pred,
                              __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::set_symmetric_difference(begin1, end1, begin2,
-                                                      end2, out, pred); }
+    { return _GLIBCXX_STD_P::set_symmetric_difference(__begin1, __end1, __begin2,
+                                                      __end2, __out, __pred); }
 
   // Sequential fallback for input iterator case
-  template<typename InputIterator1, typename InputIterator2,
-           typename Predicate, typename OutputIterator,
-           typename IteratorTag1, typename IteratorTag2,
-           typename IteratorTag3>
-    inline OutputIterator 
-    set_symmetric_difference_switch(InputIterator1 begin1,
-                                    InputIterator1 end1,
-                                    InputIterator2 begin2,
-                                    InputIterator2 end2,
-                                    OutputIterator result, Predicate pred,
-                                    IteratorTag1, IteratorTag2, IteratorTag3)
-    { return _GLIBCXX_STD_P::set_symmetric_difference(begin1, end1,
-                                                      begin2, end2,
-                                                      result, pred); }
+  template<typename _IIter1, typename _IIter2,
+           typename _Predicate, typename _OutputIterator,
+           typename _IteratorTag1, typename _IteratorTag2,
+           typename _IteratorTag3>
+    inline _OutputIterator 
+    __set_symmetric_difference_switch(_IIter1 __begin1,
+                                    _IIter1 __end1,
+                                    _IIter2 __begin2,
+                                    _IIter2 __end2,
+                                    _OutputIterator __result, _Predicate __pred,
+                                    _IteratorTag1, _IteratorTag2, _IteratorTag3)
+    { return _GLIBCXX_STD_P::set_symmetric_difference(__begin1, __end1,
+                                                      __begin2, __end2,
+                                                      __result, __pred); }
 
   // Parallel set_symmetric_difference for random access iterators
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-           typename OutputRandomAccessIterator, typename Predicate>
-    OutputRandomAccessIterator
-    set_symmetric_difference_switch(RandomAccessIterator1 begin1,
-                                    RandomAccessIterator1 end1,
-                                    RandomAccessIterator2 begin2,
-                                    RandomAccessIterator2 end2,
-                                    OutputRandomAccessIterator result,
-                                    Predicate pred,
+  template<typename _RAIter1, typename _RAIter2,
+           typename _Output_RAIter, typename _Predicate>
+    _Output_RAIter
+    __set_symmetric_difference_switch(_RAIter1 __begin1,
+                                    _RAIter1 __end1,
+                                    _RAIter2 __begin2,
+                                    _RAIter2 __end2,
+                                    _Output_RAIter __result,
+                                    _Predicate __pred,
                                     random_access_iterator_tag,
                                     random_access_iterator_tag,
                                     random_access_iterator_tag)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(
-      static_cast<__gnu_parallel::sequence_index_t>(end1 - begin1)
+      static_cast<__gnu_parallel::_SequenceIndex>(__end1 - __begin1)
       >= __gnu_parallel::_Settings::get().set_symmetric_difference_minimal_n
-      || static_cast<__gnu_parallel::sequence_index_t>(end2 - begin2)
+      || static_cast<__gnu_parallel::_SequenceIndex>(__end2 - __begin2)
       >= __gnu_parallel::_Settings::get().set_symmetric_difference_minimal_n))
-  return __gnu_parallel::parallel_set_symmetric_difference(begin1, end1,
-                                                                 begin2, end2,
-                                                                 result, pred);
+  return __gnu_parallel::__parallel_set_symmetric_difference(__begin1, __end1,
+                                                                 __begin2, __end2,
+                                                                 __result, __pred);
       else
-        return _GLIBCXX_STD_P::set_symmetric_difference(begin1, end1,
-                                                        begin2, end2,
-                                                        result, pred);
+        return _GLIBCXX_STD_P::set_symmetric_difference(__begin1, __end1,
+                                                        __begin2, __end2,
+                                                        __result, __pred);
     }
 
   // Public interface.
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator>
-    inline OutputIterator 
-    set_symmetric_difference(InputIterator1 begin1, InputIterator1 end1,
-                             InputIterator2 begin2, InputIterator2 end2,
-                             OutputIterator out)
-    {
-      typedef std::iterator_traits<InputIterator1> iteratori1_traits;
-      typedef std::iterator_traits<InputIterator2> iteratori2_traits;
-      typedef std::iterator_traits<OutputIterator> iteratoro_traits;
-      typedef typename iteratori1_traits::iterator_category
-        iteratori1_category;
-      typedef typename iteratori2_traits::iterator_category
-        iteratori2_category;
-      typedef typename iteratoro_traits::iterator_category iteratoro_category;
-      typedef typename iteratori1_traits::value_type value1_type;
-      typedef typename iteratori2_traits::value_type value2_type;
-
-      return set_symmetric_difference_switch(begin1, end1, begin2, end2, out,
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator>
+    inline _OutputIterator 
+    set_symmetric_difference(_IIter1 __begin1, _IIter1 __end1,
+                             _IIter2 __begin2, _IIter2 __end2,
+                             _OutputIterator __out)
+    {
+      typedef std::iterator_traits<_IIter1> _IIterTraits1;
+      typedef std::iterator_traits<_IIter2> _IIterTraits2;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits1::iterator_category
+        _IIterCategory1;
+      typedef typename _IIterTraits2::iterator_category
+        _IIterCategory2;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+      typedef typename _IIterTraits1::value_type _ValueType1;
+      typedef typename _IIterTraits2::value_type _ValueType2;
+
+      return __set_symmetric_difference_switch(__begin1, __end1, __begin2, __end2, __out,
                                              __gnu_parallel::
-                                             less<value1_type, value2_type>(),
-                                             iteratori1_category(),
-                                             iteratori2_category(),
-                                             iteratoro_category());
+                                             _Less<_ValueType1, _ValueType2>(),
+                                             _IIterCategory1(),
+                                             _IIterCategory2(),
+                                             _OIterCategory());
     }
 
   // Public interface.
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator, typename Predicate>
-    inline OutputIterator 
-    set_symmetric_difference(InputIterator1 begin1, InputIterator1 end1,
-                             InputIterator2 begin2, InputIterator2 end2,
-                             OutputIterator out, Predicate pred)
-    {
-      typedef std::iterator_traits<InputIterator1> iteratori1_traits;
-      typedef std::iterator_traits<InputIterator2> iteratori2_traits;
-      typedef std::iterator_traits<OutputIterator> iteratoro_traits;
-      typedef typename iteratori1_traits::iterator_category
-        iteratori1_category;
-      typedef typename iteratori2_traits::iterator_category
-        iteratori2_category;
-      typedef typename iteratoro_traits::iterator_category iteratoro_category;
-
-      return set_symmetric_difference_switch(begin1, end1, begin2, end2, out,
-                                             pred, iteratori1_category(),
-                                             iteratori2_category(),
-                                             iteratoro_category());
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _Predicate>
+    inline _OutputIterator 
+    set_symmetric_difference(_IIter1 __begin1, _IIter1 __end1,
+                             _IIter2 __begin2, _IIter2 __end2,
+                             _OutputIterator __out, _Predicate __pred)
+    {
+      typedef std::iterator_traits<_IIter1> _IIterTraits1;
+      typedef std::iterator_traits<_IIter2> _IIterTraits2;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits1::iterator_category
+        _IIterCategory1;
+      typedef typename _IIterTraits2::iterator_category
+        _IIterCategory2;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+
+      return __set_symmetric_difference_switch(__begin1, __end1, __begin2, __end2, __out,
+                                             __pred, _IIterCategory1(),
+                                             _IIterCategory2(),
+                                             _OIterCategory());
     }
 
   // Sequential fallback.
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator>
-    inline OutputIterator
-    set_difference(InputIterator1 begin1, InputIterator1 end1, 
-                   InputIterator2 begin2, InputIterator2 end2, 
-                   OutputIterator out, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::set_difference(begin1,end1, begin2, end2, out); }
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator>
+    inline _OutputIterator
+    set_difference(_IIter1 __begin1, _IIter1 __end1, 
+                   _IIter2 __begin2, _IIter2 __end2, 
+                   _OutputIterator __out, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::set_difference(__begin1,__end1, __begin2, __end2, __out); }
 
   // Sequential fallback.
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator, typename Predicate>
-    inline OutputIterator
-    set_difference(InputIterator1 begin1, InputIterator1 end1, 
-                   InputIterator2 begin2, InputIterator2 end2, 
-                   OutputIterator out, Predicate pred, 
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _Predicate>
+    inline _OutputIterator
+    set_difference(_IIter1 __begin1, _IIter1 __end1, 
+                   _IIter2 __begin2, _IIter2 __end2, 
+                   _OutputIterator __out, _Predicate __pred, 
                    __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::set_difference(begin1, end1,
-                                            begin2, end2, out, pred); }
+    { return _GLIBCXX_STD_P::set_difference(__begin1, __end1,
+                                            __begin2, __end2, __out, __pred); }
 
   // Sequential fallback for input iterator case.
-  template<typename InputIterator1, typename InputIterator2,
-           typename Predicate, typename OutputIterator,
-           typename IteratorTag1, typename IteratorTag2, typename IteratorTag3>
-    inline OutputIterator
-    set_difference_switch(InputIterator1 begin1, InputIterator1 end1, 
-                          InputIterator2 begin2, InputIterator2 end2, 
-                          OutputIterator result, Predicate pred, 
-                          IteratorTag1, IteratorTag2, IteratorTag3)
-    { return _GLIBCXX_STD_P::set_difference(begin1, end1,
-                                            begin2, end2, result, pred); }
+  template<typename _IIter1, typename _IIter2,
+           typename _Predicate, typename _OutputIterator,
+           typename _IteratorTag1, typename _IteratorTag2, typename _IteratorTag3>
+    inline _OutputIterator
+    __set_difference_switch(_IIter1 __begin1, _IIter1 __end1, 
+                          _IIter2 __begin2, _IIter2 __end2, 
+                          _OutputIterator __result, _Predicate __pred, 
+                          _IteratorTag1, _IteratorTag2, _IteratorTag3)
+    { return _GLIBCXX_STD_P::set_difference(__begin1, __end1,
+                                            __begin2, __end2, __result, __pred); }
 
   // Parallel set_difference for random access iterators
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-           typename OutputRandomAccessIterator, typename Predicate>
-    OutputRandomAccessIterator
-    set_difference_switch(RandomAccessIterator1 begin1,
-                          RandomAccessIterator1 end1,
-                          RandomAccessIterator2 begin2,
-                          RandomAccessIterator2 end2,
-                          OutputRandomAccessIterator result, Predicate pred,
+  template<typename _RAIter1, typename _RAIter2,
+           typename _Output_RAIter, typename _Predicate>
+    _Output_RAIter
+    __set_difference_switch(_RAIter1 __begin1,
+                          _RAIter1 __end1,
+                          _RAIter2 __begin2,
+                          _RAIter2 __end2,
+                          _Output_RAIter __result, _Predicate __pred,
                           random_access_iterator_tag,
                           random_access_iterator_tag,
                           random_access_iterator_tag)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(
-            static_cast<__gnu_parallel::sequence_index_t>(end1 - begin1)
+            static_cast<__gnu_parallel::_SequenceIndex>(__end1 - __begin1)
             >= __gnu_parallel::_Settings::get().set_difference_minimal_n
-            || static_cast<__gnu_parallel::sequence_index_t>(end2 - begin2)
+            || static_cast<__gnu_parallel::_SequenceIndex>(__end2 - __begin2)
             >= __gnu_parallel::_Settings::get().set_difference_minimal_n))
-        return __gnu_parallel::parallel_set_difference(begin1, end1,
-                                                       begin2, end2,
-                                                       result, pred);
+        return __gnu_parallel::__parallel_set_difference(__begin1, __end1,
+                                                       __begin2, __end2,
+                                                       __result, __pred);
       else
-        return _GLIBCXX_STD_P::set_difference(begin1, end1,
-                                              begin2, end2, result, pred);
+        return _GLIBCXX_STD_P::set_difference(__begin1, __end1,
+                                              __begin2, __end2, __result, __pred);
     }
 
   // Public interface
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator>
-    inline OutputIterator
-    set_difference(InputIterator1 begin1, InputIterator1 end1, 
-                   InputIterator2 begin2, InputIterator2 end2, 
-                   OutputIterator out)
-    {
-      typedef std::iterator_traits<InputIterator1> iteratori1_traits;
-      typedef std::iterator_traits<InputIterator2> iteratori2_traits;
-      typedef std::iterator_traits<OutputIterator> iteratoro_traits;
-      typedef typename iteratori1_traits::iterator_category
-        iteratori1_category;
-      typedef typename iteratori2_traits::iterator_category
-        iteratori2_category;
-      typedef typename iteratoro_traits::iterator_category iteratoro_category;
-      typedef typename iteratori1_traits::value_type value1_type;
-      typedef typename iteratori2_traits::value_type value2_type;
-
-      return set_difference_switch(begin1, end1, begin2, end2, out,
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator>
+    inline _OutputIterator
+    set_difference(_IIter1 __begin1, _IIter1 __end1, 
+                   _IIter2 __begin2, _IIter2 __end2, 
+                   _OutputIterator __out)
+    {
+      typedef std::iterator_traits<_IIter1> _IIterTraits1;
+      typedef std::iterator_traits<_IIter2> _IIterTraits2;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits1::iterator_category
+        _IIterCategory1;
+      typedef typename _IIterTraits2::iterator_category
+        _IIterCategory2;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+      typedef typename _IIterTraits1::value_type _ValueType1;
+      typedef typename _IIterTraits2::value_type _ValueType2;
+
+      return __set_difference_switch(__begin1, __end1, __begin2, __end2, __out,
                                    __gnu_parallel::
-                                   less<value1_type, value2_type>(), 
-                                   iteratori1_category(),
-                                   iteratori2_category(), 
-                                   iteratoro_category());
+                                   _Less<_ValueType1, _ValueType2>(), 
+                                   _IIterCategory1(),
+                                   _IIterCategory2(), 
+                                   _OIterCategory());
     }
 
   // Public interface
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator, typename Predicate>
-    inline OutputIterator
-    set_difference(InputIterator1 begin1, InputIterator1 end1, 
-                   InputIterator2 begin2, InputIterator2 end2, 
-                   OutputIterator out, Predicate pred)
-    {
-      typedef std::iterator_traits<InputIterator1> iteratori1_traits;
-      typedef std::iterator_traits<InputIterator2> iteratori2_traits;
-      typedef std::iterator_traits<OutputIterator> iteratoro_traits;
-      typedef typename iteratori1_traits::iterator_category
-        iteratori1_category;
-      typedef typename iteratori2_traits::iterator_category
-        iteratori2_category;
-      typedef typename iteratoro_traits::iterator_category iteratoro_category;
-
-      return set_difference_switch(begin1, end1, begin2, end2, out, pred,
-                                   iteratori1_category(),
-                                   iteratori2_category(), 
-                                   iteratoro_category());
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _Predicate>
+    inline _OutputIterator
+    set_difference(_IIter1 __begin1, _IIter1 __end1, 
+                   _IIter2 __begin2, _IIter2 __end2, 
+                   _OutputIterator __out, _Predicate __pred)
+    {
+      typedef std::iterator_traits<_IIter1> _IIterTraits1;
+      typedef std::iterator_traits<_IIter2> _IIterTraits2;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits1::iterator_category
+        _IIterCategory1;
+      typedef typename _IIterTraits2::iterator_category
+        _IIterCategory2;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+
+      return __set_difference_switch(__begin1, __end1, __begin2, __end2, __out, __pred,
+                                   _IIterCategory1(),
+                                   _IIterCategory2(), 
+                                   _OIterCategory());
     }
 
   // Sequential fallback
-  template<typename ForwardIterator>
-    inline ForwardIterator
-    adjacent_find(ForwardIterator begin, ForwardIterator end, 
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    adjacent_find(_ForwardIterator __begin, _ForwardIterator __end, 
                   __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::adjacent_find(begin, end); }
+    { return _GLIBCXX_STD_P::adjacent_find(__begin, __end); }
 
   // Sequential fallback
-  template<typename ForwardIterator, typename BinaryPredicate>
-    inline ForwardIterator
-    adjacent_find(ForwardIterator begin, ForwardIterator end, 
-                  BinaryPredicate binary_pred, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::adjacent_find(begin, end, binary_pred); }
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+    inline _ForwardIterator
+    adjacent_find(_ForwardIterator __begin, _ForwardIterator __end, 
+                  _BinaryPredicate __binary_pred, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::adjacent_find(__begin, __end, __binary_pred); }
 
   // Parallel algorithm for random access iterators
-  template<typename RandomAccessIterator>
-    RandomAccessIterator
-    adjacent_find_switch(RandomAccessIterator begin, RandomAccessIterator end, 
+  template<typename _RAIter>
+    _RAIter
+    __adjacent_find_switch(_RAIter __begin, _RAIter __end, 
                          random_access_iterator_tag)
     {
-      typedef iterator_traits<RandomAccessIterator> traits_type;
-      typedef typename traits_type::value_type value_type;
+      typedef iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
 
       if (_GLIBCXX_PARALLEL_CONDITION(true))
         {
-          RandomAccessIterator spot = __gnu_parallel::
-            find_template(begin, end - 1, begin, equal_to<value_type>(),
-                          __gnu_parallel::adjacent_find_selector()).first;
-          if (spot == (end - 1))
-            return end;
+          _RAIter spot = __gnu_parallel::
+            __find_template(__begin, __end - 1, __begin, equal_to<_ValueType>(),
+                          __gnu_parallel::__adjacent_find_selector()).first;
+          if (spot == (__end - 1))
+            return __end;
           else
             return spot;
         }
       else
-        return adjacent_find(begin, end, __gnu_parallel::sequential_tag());
+        return adjacent_find(__begin, __end, __gnu_parallel::sequential_tag());
     }
 
   // Sequential fallback for input iterator case
-  template<typename ForwardIterator, typename IteratorTag>
-    inline ForwardIterator
-    adjacent_find_switch(ForwardIterator begin, ForwardIterator end,
-                         IteratorTag)
-    { return adjacent_find(begin, end, __gnu_parallel::sequential_tag()); }
+  template<typename _ForwardIterator, typename _IteratorTag>
+    inline _ForwardIterator
+    __adjacent_find_switch(_ForwardIterator __begin, _ForwardIterator __end,
+                         _IteratorTag)
+    { return adjacent_find(__begin, __end, __gnu_parallel::sequential_tag()); }
 
   // Public interface
-  template<typename ForwardIterator>
-    inline ForwardIterator
-    adjacent_find(ForwardIterator begin, ForwardIterator end)
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    adjacent_find(_ForwardIterator __begin, _ForwardIterator __end)
     {
-      typedef iterator_traits<ForwardIterator> traits_type;
-      typedef typename traits_type::iterator_category iterator_category;
-      return adjacent_find_switch(begin, end, iterator_category());
+      typedef iterator_traits<_ForwardIterator> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      return __adjacent_find_switch(__begin, __end, _IteratorCategory());
     }
 
   // Sequential fallback for input iterator case
-  template<typename ForwardIterator, typename BinaryPredicate,
-           typename IteratorTag>
-    inline ForwardIterator
-    adjacent_find_switch(ForwardIterator begin, ForwardIterator end, 
-                         BinaryPredicate pred, IteratorTag)
-    { return adjacent_find(begin, end, pred,
+  template<typename _ForwardIterator, typename _BinaryPredicate,
+           typename _IteratorTag>
+    inline _ForwardIterator
+    __adjacent_find_switch(_ForwardIterator __begin, _ForwardIterator __end, 
+                         _BinaryPredicate __pred, _IteratorTag)
+    { return adjacent_find(__begin, __end, __pred,
                            __gnu_parallel::sequential_tag()); }
 
   // Parallel algorithm for random access iterators
-  template<typename RandomAccessIterator, typename BinaryPredicate>
-    RandomAccessIterator
-    adjacent_find_switch(RandomAccessIterator begin, RandomAccessIterator end, 
-                         BinaryPredicate pred, random_access_iterator_tag)
+  template<typename _RAIter, typename _BinaryPredicate>
+    _RAIter
+    __adjacent_find_switch(_RAIter __begin, _RAIter __end, 
+                         _BinaryPredicate __pred, random_access_iterator_tag)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(true))
-        return __gnu_parallel::find_template(begin, end, begin, pred, 
+        return __gnu_parallel::__find_template(__begin, __end, __begin, __pred, 
                                              __gnu_parallel::
-                                             adjacent_find_selector()).first;
+                                             __adjacent_find_selector()).first;
       else
-        return adjacent_find(begin, end, pred,
+        return adjacent_find(__begin, __end, __pred,
                              __gnu_parallel::sequential_tag());
     }
 
   // Public interface
-  template<typename ForwardIterator, typename BinaryPredicate>
-    inline ForwardIterator
-    adjacent_find(ForwardIterator begin, ForwardIterator end, 
-                  BinaryPredicate pred)
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+    inline _ForwardIterator
+    adjacent_find(_ForwardIterator __begin, _ForwardIterator __end, 
+                  _BinaryPredicate __pred)
     {
-      typedef iterator_traits<ForwardIterator> traits_type;
-      typedef typename traits_type::iterator_category iterator_category;
-      return adjacent_find_switch(begin, end, pred, iterator_category());
+      typedef iterator_traits<_ForwardIterator> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      return __adjacent_find_switch(__begin, __end, __pred, _IteratorCategory());
     }
 
   // Sequential fallback
-  template<typename InputIterator, typename T>
-    inline typename iterator_traits<InputIterator>::difference_type
-    count(InputIterator begin, InputIterator end, const T& value, 
+  template<typename _IIter, typename _Tp>
+    inline typename iterator_traits<_IIter>::difference_type
+    count(_IIter __begin, _IIter __end, const _Tp& __value, 
           __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::count(begin, end, value); }
+    { return _GLIBCXX_STD_P::count(__begin, __end, __value); }
 
   // Parallel code for random access iterators
-  template<typename RandomAccessIterator, typename T>
-    typename iterator_traits<RandomAccessIterator>::difference_type
-    count_switch(RandomAccessIterator begin, RandomAccessIterator end, 
-                 const T& value, random_access_iterator_tag, 
-                 __gnu_parallel::_Parallelism parallelism_tag 
+  template<typename _RAIter, typename _Tp>
+    typename iterator_traits<_RAIter>::difference_type
+    __count_switch(_RAIter __begin, _RAIter __end, 
+                 const _Tp& __value, random_access_iterator_tag, 
+                 __gnu_parallel::_Parallelism __parallelism_tag 
                  = __gnu_parallel::parallel_unbalanced)
     {
-      typedef iterator_traits<RandomAccessIterator> traits_type;
-      typedef typename traits_type::value_type value_type;
-      typedef typename traits_type::difference_type difference_type;
-      typedef __gnu_parallel::sequence_index_t sequence_index_t;
+      typedef iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+      typedef __gnu_parallel::_SequenceIndex _SequenceIndex;
 
       if (_GLIBCXX_PARALLEL_CONDITION(
-            static_cast<sequence_index_t>(end - begin)
+            static_cast<_SequenceIndex>(__end - __begin)
             >= __gnu_parallel::_Settings::get().count_minimal_n
-            && __gnu_parallel::is_parallel(parallelism_tag)))
+            && __gnu_parallel::__is_parallel(__parallelism_tag)))
         {
-          __gnu_parallel::count_selector<RandomAccessIterator, difference_type>
-            functionality;
-          difference_type res = 0;
+          __gnu_parallel::__count_selector<_RAIter, _DifferenceType>
+            __functionality;
+          _DifferenceType __res = 0;
           __gnu_parallel::
-            for_each_template_random_access(begin, end, value,
-                                            functionality,
-                                            std::plus<sequence_index_t>(),
-                                            res, res, -1, parallelism_tag);
-          return res;
+            __for_each_template_random_access(__begin, __end, __value,
+                                            __functionality,
+                                            std::plus<_SequenceIndex>(),
+                                            __res, __res, -1, __parallelism_tag);
+          return __res;
         }
       else
-        return count(begin, end, value, __gnu_parallel::sequential_tag());
+        return count(__begin, __end, __value, __gnu_parallel::sequential_tag());
     }
 
   // Sequential fallback for input iterator case.
-  template<typename InputIterator, typename T, typename IteratorTag>
-    inline typename iterator_traits<InputIterator>::difference_type
-    count_switch(InputIterator begin, InputIterator end, const T& value, 
-                 IteratorTag)
-    { return count(begin, end, value, __gnu_parallel::sequential_tag()); }
+  template<typename _IIter, typename _Tp, typename _IteratorTag>
+    inline typename iterator_traits<_IIter>::difference_type
+    __count_switch(_IIter __begin, _IIter __end, const _Tp& __value, 
+                 _IteratorTag)
+    { return count(__begin, __end, __value, __gnu_parallel::sequential_tag()); }
 
   // Public interface.
-  template<typename InputIterator, typename T>
-    inline typename iterator_traits<InputIterator>::difference_type
-    count(InputIterator begin, InputIterator end, const T& value, 
-          __gnu_parallel::_Parallelism parallelism_tag)
+  template<typename _IIter, typename _Tp>
+    inline typename iterator_traits<_IIter>::difference_type
+    count(_IIter __begin, _IIter __end, const _Tp& __value, 
+          __gnu_parallel::_Parallelism __parallelism_tag)
     {
-      typedef iterator_traits<InputIterator> traits_type;
-      typedef typename traits_type::iterator_category iterator_category;
-      return count_switch(begin, end, value, iterator_category(), 
-                          parallelism_tag);
+      typedef iterator_traits<_IIter> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      return __count_switch(__begin, __end, __value, _IteratorCategory(), 
+                          __parallelism_tag);
     }
 
-  template<typename InputIterator, typename T>
-    inline typename iterator_traits<InputIterator>::difference_type
-    count(InputIterator begin, InputIterator end, const T& value)
+  template<typename _IIter, typename _Tp>
+    inline typename iterator_traits<_IIter>::difference_type
+    count(_IIter __begin, _IIter __end, const _Tp& __value)
     {
-      typedef iterator_traits<InputIterator> traits_type;
-      typedef typename traits_type::iterator_category iterator_category;
-      return count_switch(begin, end, value, iterator_category());
+      typedef iterator_traits<_IIter> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      return __count_switch(__begin, __end, __value, _IteratorCategory());
     }
 
 
   // Sequential fallback.
-  template<typename InputIterator, typename Predicate>
-    inline typename iterator_traits<InputIterator>::difference_type
-    count_if(InputIterator begin, InputIterator end, Predicate pred, 
+  template<typename _IIter, typename _Predicate>
+    inline typename iterator_traits<_IIter>::difference_type
+    count_if(_IIter __begin, _IIter __end, _Predicate __pred, 
              __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::count_if(begin, end, pred); }
+    { return _GLIBCXX_STD_P::count_if(__begin, __end, __pred); }
 
   // Parallel count_if for random access iterators
-  template<typename RandomAccessIterator, typename Predicate>
-    typename iterator_traits<RandomAccessIterator>::difference_type
-    count_if_switch(RandomAccessIterator begin, RandomAccessIterator end, 
-                    Predicate pred, random_access_iterator_tag, 
-                    __gnu_parallel::_Parallelism parallelism_tag
+  template<typename _RAIter, typename _Predicate>
+    typename iterator_traits<_RAIter>::difference_type
+    __count_if_switch(_RAIter __begin, _RAIter __end, 
+                    _Predicate __pred, random_access_iterator_tag, 
+                    __gnu_parallel::_Parallelism __parallelism_tag
                     = __gnu_parallel::parallel_unbalanced)
     {
-      typedef iterator_traits<RandomAccessIterator> traits_type;
-      typedef typename traits_type::value_type value_type;
-      typedef typename traits_type::difference_type difference_type;
-      typedef __gnu_parallel::sequence_index_t sequence_index_t;
+      typedef iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
+      typedef __gnu_parallel::_SequenceIndex _SequenceIndex;
 
       if (_GLIBCXX_PARALLEL_CONDITION(
-            static_cast<sequence_index_t>(end - begin)
+            static_cast<_SequenceIndex>(__end - __begin)
             >= __gnu_parallel::_Settings::get().count_minimal_n
-            && __gnu_parallel::is_parallel(parallelism_tag)))
+            && __gnu_parallel::__is_parallel(__parallelism_tag)))
         {
-          difference_type res = 0;
+          _DifferenceType __res = 0;
           __gnu_parallel::
-            count_if_selector<RandomAccessIterator, difference_type>
-            functionality;
+            __count_if_selector<_RAIter, _DifferenceType>
+            __functionality;
           __gnu_parallel::
-            for_each_template_random_access(begin, end, pred,
-                                            functionality,
-                                            std::plus<sequence_index_t>(),
-                                            res, res, -1, parallelism_tag);
-          return res;
+            __for_each_template_random_access(__begin, __end, __pred,
+                                            __functionality,
+                                            std::plus<_SequenceIndex>(),
+                                            __res, __res, -1, __parallelism_tag);
+          return __res;
         }
       else
-        return count_if(begin, end, pred, __gnu_parallel::sequential_tag());
+        return count_if(__begin, __end, __pred, __gnu_parallel::sequential_tag());
     }
 
   // Sequential fallback for input iterator case.
-  template<typename InputIterator, typename Predicate, typename IteratorTag>
-    inline typename iterator_traits<InputIterator>::difference_type
-    count_if_switch(InputIterator begin, InputIterator end, Predicate pred, 
-                    IteratorTag)
-    { return count_if(begin, end, pred, __gnu_parallel::sequential_tag()); }
+  template<typename _IIter, typename _Predicate, typename _IteratorTag>
+    inline typename iterator_traits<_IIter>::difference_type
+    __count_if_switch(_IIter __begin, _IIter __end, _Predicate __pred, 
+                    _IteratorTag)
+    { return count_if(__begin, __end, __pred, __gnu_parallel::sequential_tag()); }
 
   // Public interface.
-  template<typename InputIterator, typename Predicate>
-    inline typename iterator_traits<InputIterator>::difference_type
-    count_if(InputIterator begin, InputIterator end, Predicate pred, 
-             __gnu_parallel::_Parallelism parallelism_tag)
+  template<typename _IIter, typename _Predicate>
+    inline typename iterator_traits<_IIter>::difference_type
+    count_if(_IIter __begin, _IIter __end, _Predicate __pred, 
+             __gnu_parallel::_Parallelism __parallelism_tag)
     {
-      typedef iterator_traits<InputIterator> traits_type;
-      typedef typename traits_type::iterator_category iterator_category;
-      return count_if_switch(begin, end, pred, iterator_category(), 
-                             parallelism_tag);
+      typedef iterator_traits<_IIter> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      return __count_if_switch(__begin, __end, __pred, _IteratorCategory(), 
+                             __parallelism_tag);
     }
 
-  template<typename InputIterator, typename Predicate>
-    inline typename iterator_traits<InputIterator>::difference_type
-    count_if(InputIterator begin, InputIterator end, Predicate pred)
+  template<typename _IIter, typename _Predicate>
+    inline typename iterator_traits<_IIter>::difference_type
+    count_if(_IIter __begin, _IIter __end, _Predicate __pred)
     {
-      typedef iterator_traits<InputIterator> traits_type;
-      typedef typename traits_type::iterator_category iterator_category;
-      return count_if_switch(begin, end, pred, iterator_category());
+      typedef iterator_traits<_IIter> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      return __count_if_switch(__begin, __end, __pred, _IteratorCategory());
     }
 
 
   // Sequential fallback.
   template<typename ForwardIterator1, typename ForwardIterator2>
     inline ForwardIterator1
-    search(ForwardIterator1 begin1, ForwardIterator1 end1,
-           ForwardIterator2 begin2, ForwardIterator2 end2,
+    search(ForwardIterator1 __begin1, ForwardIterator1 __end1,
+           ForwardIterator2 __begin2, ForwardIterator2 __end2,
            __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::search(begin1, end1, begin2, end2); }
+    { return _GLIBCXX_STD_P::search(__begin1, __end1, __begin2, __end2); }
 
   // Parallel algorithm for random access iterator
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2>
-    RandomAccessIterator1
-    search_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1,
-                  RandomAccessIterator2 begin2, RandomAccessIterator2 end2,
+  template<typename _RAIter1, typename _RAIter2>
+    _RAIter1
+    __search_switch(_RAIter1 __begin1, _RAIter1 __end1,
+                  _RAIter2 __begin2, _RAIter2 __end2,
                   random_access_iterator_tag, random_access_iterator_tag)
     {
-      typedef std::iterator_traits<RandomAccessIterator1> iterator1_traits;
-      typedef typename iterator1_traits::value_type value1_type;
-      typedef std::iterator_traits<RandomAccessIterator2> iterator2_traits;
-      typedef typename iterator2_traits::value_type value2_type;
+      typedef std::iterator_traits<_RAIter1> iterator1_traits;
+      typedef typename iterator1_traits::value_type _ValueType1;
+      typedef std::iterator_traits<_RAIter2> iterator2_traits;
+      typedef typename iterator2_traits::value_type _ValueType2;
 
       if (_GLIBCXX_PARALLEL_CONDITION(true))
         return __gnu_parallel::
-          search_template(begin1, end1, begin2, end2, __gnu_parallel::
-                          equal_to<value1_type, value2_type>());
+          __search_template(__begin1, __end1, __begin2, __end2, __gnu_parallel::
+                          equal_to<_ValueType1, _ValueType2>());
       else
-        return search(begin1, end1, begin2, end2,
+        return search(__begin1, __end1, __begin2, __end2,
                       __gnu_parallel::sequential_tag());
     }
 
   // Sequential fallback for input iterator case
   template<typename ForwardIterator1, typename ForwardIterator2,
-           typename IteratorTag1, typename IteratorTag2>
+           typename _IteratorTag1, typename _IteratorTag2>
     inline ForwardIterator1
-    search_switch(ForwardIterator1 begin1, ForwardIterator1 end1,
-                  ForwardIterator2 begin2, ForwardIterator2 end2,
-                  IteratorTag1, IteratorTag2)
-    { return search(begin1, end1, begin2, end2,
+    __search_switch(ForwardIterator1 __begin1, ForwardIterator1 __end1,
+                  ForwardIterator2 __begin2, ForwardIterator2 __end2,
+                  _IteratorTag1, _IteratorTag2)
+    { return search(__begin1, __end1, __begin2, __end2,
                     __gnu_parallel::sequential_tag()); }
 
   // Public interface.
   template<typename ForwardIterator1, typename ForwardIterator2>
     inline ForwardIterator1
-    search(ForwardIterator1 begin1, ForwardIterator1 end1,
-           ForwardIterator2 begin2, ForwardIterator2 end2)
+    search(ForwardIterator1 __begin1, ForwardIterator1 __end1,
+           ForwardIterator2 __begin2, ForwardIterator2 __end2)
     {
       typedef std::iterator_traits<ForwardIterator1> iterator1_traits;
-      typedef typename iterator1_traits::iterator_category iterator1_category;
+      typedef typename iterator1_traits::iterator_category _IteratorCategory1;
       typedef std::iterator_traits<ForwardIterator2> iterator2_traits;
-      typedef typename iterator2_traits::iterator_category iterator2_category;
+      typedef typename iterator2_traits::iterator_category _IteratorCategory2;
 
-      return search_switch(begin1, end1, begin2, end2,
-                           iterator1_category(), iterator2_category());
+      return __search_switch(__begin1, __end1, __begin2, __end2,
+                           _IteratorCategory1(), _IteratorCategory2());
     }
 
   // Public interface.
   template<typename ForwardIterator1, typename ForwardIterator2,
-           typename BinaryPredicate>
+           typename _BinaryPredicate>
     inline ForwardIterator1
-    search(ForwardIterator1 begin1, ForwardIterator1 end1,
-           ForwardIterator2 begin2, ForwardIterator2 end2,
-           BinaryPredicate pred, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::search(begin1, end1, begin2, end2, pred); }
+    search(ForwardIterator1 __begin1, ForwardIterator1 __end1,
+           ForwardIterator2 __begin2, ForwardIterator2 __end2,
+           _BinaryPredicate __pred, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::search(__begin1, __end1, __begin2, __end2, __pred); }
 
   // Parallel algorithm for random access iterator.
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-           typename BinaryPredicate>
-    RandomAccessIterator1
-    search_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1,
-                  RandomAccessIterator2 begin2, RandomAccessIterator2 end2,
-                  BinaryPredicate pred,
+  template<typename _RAIter1, typename _RAIter2,
+           typename _BinaryPredicate>
+    _RAIter1
+    __search_switch(_RAIter1 __begin1, _RAIter1 __end1,
+                  _RAIter2 __begin2, _RAIter2 __end2,
+                  _BinaryPredicate __pred,
                   random_access_iterator_tag, random_access_iterator_tag)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(true))
-        return __gnu_parallel::search_template(begin1, end1,
-                                               begin2, end2, pred);
+        return __gnu_parallel::__search_template(__begin1, __end1,
+                                               __begin2, __end2, __pred);
       else
-        return search(begin1, end1, begin2, end2, pred,
+        return search(__begin1, __end1, __begin2, __end2, __pred,
                       __gnu_parallel::sequential_tag());
     }
 
   // Sequential fallback for input iterator case
   template<typename ForwardIterator1, typename ForwardIterator2,
-           typename BinaryPredicate, typename IteratorTag1,
-           typename IteratorTag2>
+           typename _BinaryPredicate, typename _IteratorTag1,
+           typename _IteratorTag2>
     inline ForwardIterator1
-    search_switch(ForwardIterator1 begin1, ForwardIterator1 end1,
-                  ForwardIterator2 begin2, ForwardIterator2 end2,
-                  BinaryPredicate pred, IteratorTag1, IteratorTag2)
-    { return search(begin1, end1, begin2, end2, pred,
+    __search_switch(ForwardIterator1 __begin1, ForwardIterator1 __end1,
+                  ForwardIterator2 __begin2, ForwardIterator2 __end2,
+                  _BinaryPredicate __pred, _IteratorTag1, _IteratorTag2)
+    { return search(__begin1, __end1, __begin2, __end2, __pred,
                     __gnu_parallel::sequential_tag()); }
 
   // Public interface
   template<typename ForwardIterator1, typename ForwardIterator2,
-           typename BinaryPredicate>
+           typename _BinaryPredicate>
     inline ForwardIterator1
-    search(ForwardIterator1 begin1, ForwardIterator1 end1,
-           ForwardIterator2 begin2, ForwardIterator2 end2,
-           BinaryPredicate  pred)
+    search(ForwardIterator1 __begin1, ForwardIterator1 __end1,
+           ForwardIterator2 __begin2, ForwardIterator2 __end2,
+           _BinaryPredicate  __pred)
     {
       typedef std::iterator_traits<ForwardIterator1> iterator1_traits;
-      typedef typename iterator1_traits::iterator_category iterator1_category;
+      typedef typename iterator1_traits::iterator_category _IteratorCategory1;
       typedef std::iterator_traits<ForwardIterator2> iterator2_traits;
-      typedef typename iterator2_traits::iterator_category iterator2_category;
-      return search_switch(begin1, end1, begin2, end2, pred,
-                           iterator1_category(), iterator2_category());
+      typedef typename iterator2_traits::iterator_category _IteratorCategory2;
+      return __search_switch(__begin1, __end1, __begin2, __end2, __pred,
+                           _IteratorCategory1(), _IteratorCategory2());
     }
 
   // Sequential fallback
-  template<typename ForwardIterator, typename Integer, typename T>
-    inline ForwardIterator
-    search_n(ForwardIterator begin, ForwardIterator end, Integer count,
-             const T& val, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::search_n(begin, end, count, val); }
+  template<typename _ForwardIterator, typename _Integer, typename _Tp>
+    inline _ForwardIterator
+    search_n(_ForwardIterator __begin, _ForwardIterator __end, _Integer count,
+             const _Tp& __val, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::search_n(__begin, __end, count, __val); }
 
   // Sequential fallback
-  template<typename ForwardIterator, typename Integer, typename T,
-           typename BinaryPredicate>
-    inline ForwardIterator
-    search_n(ForwardIterator begin, ForwardIterator end, Integer count,
-             const T& val, BinaryPredicate binary_pred,
+  template<typename _ForwardIterator, typename _Integer, typename _Tp,
+           typename _BinaryPredicate>
+    inline _ForwardIterator
+    search_n(_ForwardIterator __begin, _ForwardIterator __end, _Integer count,
+             const _Tp& __val, _BinaryPredicate __binary_pred,
              __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::search_n(begin, end, count, val, binary_pred); }
+    { return _GLIBCXX_STD_P::search_n(__begin, __end, count, __val, __binary_pred); }
 
   // Public interface.
-  template<typename ForwardIterator, typename Integer, typename T>
-    inline ForwardIterator
-    search_n(ForwardIterator begin, ForwardIterator end, Integer count,
-             const T& val)
+  template<typename _ForwardIterator, typename _Integer, typename _Tp>
+    inline _ForwardIterator
+    search_n(_ForwardIterator __begin, _ForwardIterator __end, _Integer count,
+             const _Tp& __val)
     {
-      typedef typename iterator_traits<ForwardIterator>::value_type value_type;
-      return search_n(begin, end, count, val,
-                      __gnu_parallel::equal_to<value_type, T>());
+      typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+      return search_n(__begin, __end, count, __val,
+                      __gnu_parallel::equal_to<_ValueType, _Tp>());
     }
 
   // Parallel algorithm for random access iterators.
-  template<typename RandomAccessIterator, typename Integer,
-           typename T, typename BinaryPredicate>
-    RandomAccessIterator
-    search_n_switch(RandomAccessIterator begin, RandomAccessIterator end,
-                    Integer count, const T& val, BinaryPredicate binary_pred,
+  template<typename _RAIter, typename _Integer,
+           typename _Tp, typename _BinaryPredicate>
+    _RAIter
+    __search_n_switch(_RAIter __begin, _RAIter __end,
+                    _Integer count, const _Tp& __val, _BinaryPredicate __binary_pred,
                     random_access_iterator_tag)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(true))
         {
-          __gnu_parallel::pseudo_sequence<T, Integer> ps(val, count);
-          return __gnu_parallel::search_template(begin, end, ps.begin(),
-                                                 ps.end(), binary_pred);
+          __gnu_parallel::_PseudoSequence<_Tp, _Integer> __ps(__val, count);
+          return __gnu_parallel::__search_template(__begin, __end, __ps.begin(),
+                                                 __ps.end(), __binary_pred);
         }
       else
-        return std::__search_n(begin, end, count, val,
-                               binary_pred, random_access_iterator_tag());
+        return std::__search_n(__begin, __end, count, __val,
+                               __binary_pred, random_access_iterator_tag());
     }
 
   // Sequential fallback for input iterator case.
-  template<typename ForwardIterator, typename Integer, typename T,
-           typename BinaryPredicate, typename IteratorTag>
-    inline ForwardIterator
-    search_n_switch(ForwardIterator begin, ForwardIterator end, Integer count,
-                    const T& val, BinaryPredicate binary_pred, IteratorTag)
-    { return __search_n(begin, end, count, val, binary_pred, IteratorTag()); }
+  template<typename _ForwardIterator, typename _Integer, typename _Tp,
+           typename _BinaryPredicate, typename _IteratorTag>
+    inline _ForwardIterator
+    __search_n_switch(_ForwardIterator __begin, _ForwardIterator __end, _Integer count,
+                    const _Tp& __val, _BinaryPredicate __binary_pred, _IteratorTag)
+    { return __search_n(__begin, __end, count, __val, __binary_pred, _IteratorTag()); }
 
   // Public interface.
-  template<typename ForwardIterator, typename Integer, typename T,
-           typename BinaryPredicate>
-    inline ForwardIterator
-    search_n(ForwardIterator begin, ForwardIterator end, Integer count,
-             const T& val, BinaryPredicate binary_pred)
-    {
-      return search_n_switch(begin, end, count, val, binary_pred,
-                             typename std::iterator_traits<ForwardIterator>::
+  template<typename _ForwardIterator, typename _Integer, typename _Tp,
+           typename _BinaryPredicate>
+    inline _ForwardIterator
+    search_n(_ForwardIterator __begin, _ForwardIterator __end, _Integer count,
+             const _Tp& __val, _BinaryPredicate __binary_pred)
+    {
+      return __search_n_switch(__begin, __end, count, __val, __binary_pred,
+                             typename std::iterator_traits<_ForwardIterator>::
                              iterator_category());
     }
 
 
   // Sequential fallback.
-  template<typename InputIterator, typename OutputIterator,
-           typename UnaryOperation>
-    inline OutputIterator
-    transform(InputIterator begin, InputIterator end, OutputIterator result, 
-              UnaryOperation unary_op, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::transform(begin, end, result, unary_op); }
+  template<typename _IIter, typename _OutputIterator,
+           typename _UnaryOperation>
+    inline _OutputIterator
+    transform(_IIter __begin, _IIter __end, _OutputIterator __result, 
+              _UnaryOperation unary_op, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::transform(__begin, __end, __result, unary_op); }
 
   // Parallel unary transform for random access iterators.
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-           typename UnaryOperation>
-    RandomAccessIterator2
-    transform1_switch(RandomAccessIterator1 begin, RandomAccessIterator1 end,
-                      RandomAccessIterator2 result, UnaryOperation unary_op,
+  template<typename _RAIter1, typename _RAIter2,
+           typename _UnaryOperation>
+    _RAIter2
+    __transform1_switch(_RAIter1 __begin, _RAIter1 __end,
+                      _RAIter2 __result, _UnaryOperation unary_op,
                       random_access_iterator_tag, random_access_iterator_tag,
-                      __gnu_parallel::_Parallelism parallelism_tag
+                      __gnu_parallel::_Parallelism __parallelism_tag
                       = __gnu_parallel::parallel_balanced)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(
-            static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
             >= __gnu_parallel::_Settings::get().transform_minimal_n
-            && __gnu_parallel::is_parallel(parallelism_tag)))
+            && __gnu_parallel::__is_parallel(__parallelism_tag)))
         {
-          bool dummy = true;
-          typedef __gnu_parallel::iterator_pair<RandomAccessIterator1,
-            RandomAccessIterator2, random_access_iterator_tag> ip;
-          ip begin_pair(begin, result), end_pair(end, result + (end - begin));
-          __gnu_parallel::transform1_selector<ip> functionality;
+          bool __dummy = true;
+          typedef __gnu_parallel::_IteratorPair<_RAIter1,
+            _RAIter2, random_access_iterator_tag> _ItTrip;
+          _ItTrip begin_pair(__begin, __result), end_pair(__end, __result + (__end - __begin));
+          __gnu_parallel::__transform1_selector<_ItTrip> __functionality;
           __gnu_parallel::
-            for_each_template_random_access(begin_pair, end_pair,
-                                            unary_op, functionality,
-                                            __gnu_parallel::dummy_reduct(),
-                                            dummy, dummy, -1, parallelism_tag);
-          return functionality.finish_iterator;
+            __for_each_template_random_access(begin_pair, end_pair,
+                                            unary_op, __functionality,
+                                            __gnu_parallel::_DummyReduct(),
+                                            __dummy, __dummy, -1, __parallelism_tag);
+          return __functionality.finish_iterator;
         }
       else
-        return transform(begin, end, result, unary_op, 
+        return transform(__begin, __end, __result, unary_op, 
                          __gnu_parallel::sequential_tag());
     }
 
   // Sequential fallback for input iterator case.
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-           typename UnaryOperation, typename IteratorTag1,
-           typename IteratorTag2>
-    inline RandomAccessIterator2
-    transform1_switch(RandomAccessIterator1 begin, RandomAccessIterator1 end,
-                      RandomAccessIterator2 result, UnaryOperation unary_op,
-                      IteratorTag1, IteratorTag2)
-    { return transform(begin, end, result, unary_op, 
+  template<typename _RAIter1, typename _RAIter2,
+           typename _UnaryOperation, typename _IteratorTag1,
+           typename _IteratorTag2>
+    inline _RAIter2
+    __transform1_switch(_RAIter1 __begin, _RAIter1 __end,
+                      _RAIter2 __result, _UnaryOperation unary_op,
+                      _IteratorTag1, _IteratorTag2)
+    { return transform(__begin, __end, __result, unary_op, 
                        __gnu_parallel::sequential_tag()); }
 
   // Public interface.
-  template<typename InputIterator, typename OutputIterator,
-           typename UnaryOperation>
-    inline OutputIterator
-    transform(InputIterator begin, InputIterator end, OutputIterator result,
-              UnaryOperation unary_op, 
-              __gnu_parallel::_Parallelism parallelism_tag)
+  template<typename _IIter, typename _OutputIterator,
+           typename _UnaryOperation>
+    inline _OutputIterator
+    transform(_IIter __begin, _IIter __end, _OutputIterator __result,
+              _UnaryOperation unary_op, 
+              __gnu_parallel::_Parallelism __parallelism_tag)
     {
-      typedef std::iterator_traits<InputIterator> iteratori_traits;
-      typedef std::iterator_traits<OutputIterator> iteratoro_traits;
-      typedef typename iteratori_traits::iterator_category iteratori_category;
-      typedef typename iteratoro_traits::iterator_category iteratoro_category;
+      typedef std::iterator_traits<_IIter> _IIterTraits;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits::iterator_category _IIteratorCategory;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
 
-      return transform1_switch(begin, end, result, unary_op,
-                               iteratori_category(), iteratoro_category(), 
-                               parallelism_tag);
+      return __transform1_switch(__begin, __end, __result, unary_op,
+                               _IIteratorCategory(), _OIterCategory(), 
+                               __parallelism_tag);
     }
 
-  template<typename InputIterator, typename OutputIterator,
-           typename UnaryOperation>
-    inline OutputIterator
-    transform(InputIterator begin, InputIterator end, OutputIterator result,
-              UnaryOperation unary_op)
+  template<typename _IIter, typename _OutputIterator,
+           typename _UnaryOperation>
+    inline _OutputIterator
+    transform(_IIter __begin, _IIter __end, _OutputIterator __result,
+              _UnaryOperation unary_op)
     {
-      typedef std::iterator_traits<InputIterator> iteratori_traits;
-      typedef std::iterator_traits<OutputIterator> iteratoro_traits;
-      typedef typename iteratori_traits::iterator_category iteratori_category;
-      typedef typename iteratoro_traits::iterator_category iteratoro_category;
+      typedef std::iterator_traits<_IIter> _IIterTraits;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits::iterator_category _IIteratorCategory;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
 
-      return transform1_switch(begin, end, result, unary_op,
-                               iteratori_category(), iteratoro_category());
+      return __transform1_switch(__begin, __end, __result, unary_op,
+                               _IIteratorCategory(), _OIterCategory());
     }
 
 
   // Sequential fallback
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator, typename BinaryOperation>
-    inline OutputIterator
-    transform(InputIterator1 begin1, InputIterator1 end1,
-              InputIterator2 begin2, OutputIterator result,
-              BinaryOperation binary_op, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::transform(begin1, end1,
-                                       begin2, result, binary_op); }
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _BinaryOperation>
+    inline _OutputIterator
+    transform(_IIter1 __begin1, _IIter1 __end1,
+              _IIter2 __begin2, _OutputIterator __result,
+              _BinaryOperation __binary_op, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::transform(__begin1, __end1,
+                                       __begin2, __result, __binary_op); }
 
   // Parallel binary transform for random access iterators.
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-           typename RandomAccessIterator3, typename BinaryOperation>
-    RandomAccessIterator3
-    transform2_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1,
-                      RandomAccessIterator2 begin2,
-                      RandomAccessIterator3 result, BinaryOperation binary_op,
+  template<typename _RAIter1, typename _RAIter2,
+           typename _RAIter3, typename _BinaryOperation>
+    _RAIter3
+    __transform2_switch(_RAIter1 __begin1, _RAIter1 __end1,
+                      _RAIter2 __begin2,
+                      _RAIter3 __result, _BinaryOperation __binary_op,
                       random_access_iterator_tag, random_access_iterator_tag,
                       random_access_iterator_tag,
-                      __gnu_parallel::_Parallelism parallelism_tag 
+                      __gnu_parallel::_Parallelism __parallelism_tag 
                       = __gnu_parallel::parallel_balanced)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(
-            (end1 - begin1) >=
+            (__end1 - __begin1) >=
                 __gnu_parallel::_Settings::get().transform_minimal_n
-            && __gnu_parallel::is_parallel(parallelism_tag)))
+            && __gnu_parallel::__is_parallel(__parallelism_tag)))
         {
-          bool dummy = true;
-          typedef __gnu_parallel::iterator_triple<RandomAccessIterator1,
-            RandomAccessIterator2, RandomAccessIterator3,
-            random_access_iterator_tag> ip;
-          ip begin_triple(begin1, begin2, result),
-            end_triple(end1, begin2 + (end1 - begin1),
-                       result + (end1 - begin1));
-          __gnu_parallel::transform2_selector<ip> functionality;
+          bool __dummy = true;
+          typedef __gnu_parallel::_IteratorTriple<_RAIter1,
+            _RAIter2, _RAIter3,
+            random_access_iterator_tag> _ItTrip;
+          _ItTrip __begin_triple(__begin1, __begin2, __result),
+            __end_triple(__end1, __begin2 + (__end1 - __begin1),
+                       __result + (__end1 - __begin1));
+          __gnu_parallel::__transform2_selector<_ItTrip> __functionality;
           __gnu_parallel::
-            for_each_template_random_access(begin_triple, end_triple,
-                                            binary_op, functionality,
-                                            __gnu_parallel::dummy_reduct(),
-                                            dummy, dummy, -1,
-                                            parallelism_tag);
-          return functionality.finish_iterator;
+            __for_each_template_random_access(__begin_triple, __end_triple,
+                                            __binary_op, __functionality,
+                                            __gnu_parallel::_DummyReduct(),
+                                            __dummy, __dummy, -1,
+                                            __parallelism_tag);
+          return __functionality.finish_iterator;
         }
       else
-        return transform(begin1, end1, begin2, result, binary_op, 
+        return transform(__begin1, __end1, __begin2, __result, __binary_op, 
                          __gnu_parallel::sequential_tag());
     }
 
   // Sequential fallback for input iterator case.
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator, typename BinaryOperation,
-           typename tag1, typename tag2, typename tag3>
-    inline OutputIterator
-    transform2_switch(InputIterator1 begin1, InputIterator1 end1, 
-                      InputIterator2 begin2, OutputIterator result, 
-                      BinaryOperation binary_op, tag1, tag2, tag3)
-    { return transform(begin1, end1, begin2, result, binary_op,
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _BinaryOperation,
+           typename _Tag1, typename _Tag2, typename _Tag3>
+    inline _OutputIterator
+    __transform2_switch(_IIter1 __begin1, _IIter1 __end1, 
+                      _IIter2 __begin2, _OutputIterator __result, 
+                      _BinaryOperation __binary_op, _Tag1, _Tag2, _Tag3)
+    { return transform(__begin1, __end1, __begin2, __result, __binary_op,
                        __gnu_parallel::sequential_tag()); }
 
   // Public interface.
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator, typename BinaryOperation>
-    inline OutputIterator
-    transform(InputIterator1 begin1, InputIterator1 end1,
-              InputIterator2 begin2, OutputIterator result,
-              BinaryOperation binary_op, 
-              __gnu_parallel::_Parallelism parallelism_tag)
-    {
-      typedef std::iterator_traits<InputIterator1> iteratori1_traits;
-      typedef typename iteratori1_traits::iterator_category
-        iteratori1_category;
-      typedef std::iterator_traits<InputIterator2> iteratori2_traits;
-      typedef typename iteratori2_traits::iterator_category
-        iteratori2_category;
-      typedef std::iterator_traits<OutputIterator> iteratoro_traits;
-      typedef typename iteratoro_traits::iterator_category iteratoro_category;
-
-      return transform2_switch(begin1, end1, begin2, result, binary_op,
-                               iteratori1_category(), iteratori2_category(), 
-                               iteratoro_category(), parallelism_tag);
-    }
-
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator, typename BinaryOperation>
-    inline OutputIterator
-    transform(InputIterator1 begin1, InputIterator1 end1,
-              InputIterator2 begin2, OutputIterator result,
-              BinaryOperation binary_op)
-    {
-      typedef std::iterator_traits<InputIterator1> iteratori1_traits;
-      typedef typename iteratori1_traits::iterator_category
-        iteratori1_category;
-      typedef std::iterator_traits<InputIterator2> iteratori2_traits;
-      typedef typename iteratori2_traits::iterator_category
-        iteratori2_category;
-      typedef std::iterator_traits<OutputIterator> iteratoro_traits;
-      typedef typename iteratoro_traits::iterator_category iteratoro_category;
-
-      return transform2_switch(begin1, end1, begin2, result, binary_op,
-                               iteratori1_category(), iteratori2_category(),
-                               iteratoro_category());
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _BinaryOperation>
+    inline _OutputIterator
+    transform(_IIter1 __begin1, _IIter1 __end1,
+              _IIter2 __begin2, _OutputIterator __result,
+              _BinaryOperation __binary_op, 
+              __gnu_parallel::_Parallelism __parallelism_tag)
+    {
+      typedef std::iterator_traits<_IIter1> _IIterTraits1;
+      typedef typename _IIterTraits1::iterator_category
+        _IIterCategory1;
+      typedef std::iterator_traits<_IIter2> _IIterTraits2;
+      typedef typename _IIterTraits2::iterator_category
+        _IIterCategory2;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+
+      return __transform2_switch(__begin1, __end1, __begin2, __result, __binary_op,
+                               _IIterCategory1(), _IIterCategory2(), 
+                               _OIterCategory(), __parallelism_tag);
+    }
+
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _BinaryOperation>
+    inline _OutputIterator
+    transform(_IIter1 __begin1, _IIter1 __end1,
+              _IIter2 __begin2, _OutputIterator __result,
+              _BinaryOperation __binary_op)
+    {
+      typedef std::iterator_traits<_IIter1> _IIterTraits1;
+      typedef typename _IIterTraits1::iterator_category
+        _IIterCategory1;
+      typedef std::iterator_traits<_IIter2> _IIterTraits2;
+      typedef typename _IIterTraits2::iterator_category
+        _IIterCategory2;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+
+      return __transform2_switch(__begin1, __end1, __begin2, __result, __binary_op,
+                               _IIterCategory1(), _IIterCategory2(),
+                               _OIterCategory());
     }
 
   // Sequential fallback
-  template<typename ForwardIterator, typename T>
+  template<typename _ForwardIterator, typename _Tp>
     inline void
-    replace(ForwardIterator begin, ForwardIterator end, const T& old_value, 
-            const T& new_value, __gnu_parallel::sequential_tag)
-    { _GLIBCXX_STD_P::replace(begin, end, old_value, new_value); }
+    replace(_ForwardIterator __begin, _ForwardIterator __end, const _Tp& __old_value, 
+            const _Tp& __new_value, __gnu_parallel::sequential_tag)
+    { _GLIBCXX_STD_P::replace(__begin, __end, __old_value, __new_value); }
 
   // Sequential fallback for input iterator case
-  template<typename ForwardIterator, typename T, typename IteratorTag>
+  template<typename _ForwardIterator, typename _Tp, typename _IteratorTag>
     inline void
-    replace_switch(ForwardIterator begin, ForwardIterator end, 
-                   const T& old_value, const T& new_value, IteratorTag)
-    { replace(begin, end, old_value, new_value, 
+    __replace_switch(_ForwardIterator __begin, _ForwardIterator __end, 
+                   const _Tp& __old_value, const _Tp& __new_value, _IteratorTag)
+    { replace(__begin, __end, __old_value, __new_value, 
               __gnu_parallel::sequential_tag()); }
 
   // Parallel replace for random access iterators
-  template<typename RandomAccessIterator, typename T>
+  template<typename _RAIter, typename _Tp>
     inline void
-    replace_switch(RandomAccessIterator begin, RandomAccessIterator end, 
-                   const T& old_value, const T& new_value, 
+    __replace_switch(_RAIter __begin, _RAIter __end, 
+                   const _Tp& __old_value, const _Tp& __new_value, 
                    random_access_iterator_tag, 
-                   __gnu_parallel::_Parallelism parallelism_tag
+                   __gnu_parallel::_Parallelism __parallelism_tag
                    = __gnu_parallel::parallel_balanced)
     {
       // XXX parallel version is where?
-      replace(begin, end, old_value, new_value, 
+      replace(__begin, __end, __old_value, __new_value, 
               __gnu_parallel::sequential_tag()); 
     }
 
   // Public interface
-  template<typename ForwardIterator, typename T>
+  template<typename _ForwardIterator, typename _Tp>
     inline void
-    replace(ForwardIterator begin, ForwardIterator end, const T& old_value, 
-            const T& new_value, __gnu_parallel::_Parallelism parallelism_tag)
+    replace(_ForwardIterator __begin, _ForwardIterator __end, const _Tp& __old_value, 
+            const _Tp& __new_value, __gnu_parallel::_Parallelism __parallelism_tag)
     {
-      typedef iterator_traits<ForwardIterator> traits_type;
-      typedef typename traits_type::iterator_category iterator_category;
-      replace_switch(begin, end, old_value, new_value, iterator_category(), 
-                     parallelism_tag);
+      typedef iterator_traits<_ForwardIterator> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      __replace_switch(__begin, __end, __old_value, __new_value, _IteratorCategory(), 
+                     __parallelism_tag);
     }
 
-  template<typename ForwardIterator, typename T>
+  template<typename _ForwardIterator, typename _Tp>
     inline void
-    replace(ForwardIterator begin, ForwardIterator end, const T& old_value, 
-            const T& new_value)
+    replace(_ForwardIterator __begin, _ForwardIterator __end, const _Tp& __old_value, 
+            const _Tp& __new_value)
     {
-      typedef iterator_traits<ForwardIterator> traits_type;
-      typedef typename traits_type::iterator_category iterator_category;
-      replace_switch(begin, end, old_value, new_value, iterator_category());
+      typedef iterator_traits<_ForwardIterator> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      __replace_switch(__begin, __end, __old_value, __new_value, _IteratorCategory());
     }
 
 
   // Sequential fallback
-  template<typename ForwardIterator, typename Predicate, typename T>
+  template<typename _ForwardIterator, typename _Predicate, typename _Tp>
     inline void
-    replace_if(ForwardIterator begin, ForwardIterator end, Predicate pred, 
-               const T& new_value, __gnu_parallel::sequential_tag)
-    { _GLIBCXX_STD_P::replace_if(begin, end, pred, new_value); }
+    replace_if(_ForwardIterator __begin, _ForwardIterator __end, _Predicate __pred, 
+               const _Tp& __new_value, __gnu_parallel::sequential_tag)
+    { _GLIBCXX_STD_P::replace_if(__begin, __end, __pred, __new_value); }
 
   // Sequential fallback for input iterator case
-  template<typename ForwardIterator, typename Predicate, typename T,
-           typename IteratorTag>
+  template<typename _ForwardIterator, typename _Predicate, typename _Tp,
+           typename _IteratorTag>
     inline void
-    replace_if_switch(ForwardIterator begin, ForwardIterator end,
-                      Predicate pred, const T& new_value, IteratorTag)
-    { replace_if(begin, end, pred, new_value,
+    __replace_if_switch(_ForwardIterator __begin, _ForwardIterator __end,
+                      _Predicate __pred, const _Tp& __new_value, _IteratorTag)
+    { replace_if(__begin, __end, __pred, __new_value,
                  __gnu_parallel::sequential_tag()); }
 
   // Parallel algorithm for random access iterators.
-  template<typename RandomAccessIterator, typename Predicate, typename T>
+  template<typename _RAIter, typename _Predicate, typename _Tp>
     void
-    replace_if_switch(RandomAccessIterator begin, RandomAccessIterator end,
-                      Predicate pred, const T& new_value,
+    __replace_if_switch(_RAIter __begin, _RAIter __end,
+                      _Predicate __pred, const _Tp& __new_value,
                       random_access_iterator_tag,
-                      __gnu_parallel::_Parallelism parallelism_tag
+                      __gnu_parallel::_Parallelism __parallelism_tag
                       = __gnu_parallel::parallel_balanced)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(
-            static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
             >= __gnu_parallel::_Settings::get().replace_minimal_n
-            && __gnu_parallel::is_parallel(parallelism_tag)))
+            && __gnu_parallel::__is_parallel(__parallelism_tag)))
         {
-          bool dummy;
+          bool __dummy;
           __gnu_parallel::
-            replace_if_selector<RandomAccessIterator, Predicate, T>
-            functionality(new_value);
+            __replace_if_selector<_RAIter, _Predicate, _Tp>
+            __functionality(__new_value);
           __gnu_parallel::
-            for_each_template_random_access(begin, end, pred,
-                                            functionality,
-                                            __gnu_parallel::dummy_reduct(),
-                                            true, dummy, -1, parallelism_tag);
+            __for_each_template_random_access(__begin, __end, __pred,
+                                            __functionality,
+                                            __gnu_parallel::_DummyReduct(),
+                                            true, __dummy, -1, __parallelism_tag);
         }
       else
-        replace_if(begin, end, pred, new_value, 
+        replace_if(__begin, __end, __pred, __new_value, 
                    __gnu_parallel::sequential_tag());
     }
 
   // Public interface.
-  template<typename ForwardIterator, typename Predicate, typename T>
+  template<typename _ForwardIterator, typename _Predicate, typename _Tp>
     inline void
-    replace_if(ForwardIterator begin, ForwardIterator end,
-               Predicate pred, const T& new_value, 
-               __gnu_parallel::_Parallelism parallelism_tag)
+    replace_if(_ForwardIterator __begin, _ForwardIterator __end,
+               _Predicate __pred, const _Tp& __new_value, 
+               __gnu_parallel::_Parallelism __parallelism_tag)
     {
-      typedef std::iterator_traits<ForwardIterator> iterator_traits;
-      typedef typename iterator_traits::iterator_category iterator_category;
-      replace_if_switch(begin, end, pred, new_value, iterator_category(), 
-                        parallelism_tag);
+      typedef std::iterator_traits<_ForwardIterator> _IteratorTraits;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+      __replace_if_switch(__begin, __end, __pred, __new_value, _IteratorCategory(), 
+                        __parallelism_tag);
     }
 
-  template<typename ForwardIterator, typename Predicate, typename T>
+  template<typename _ForwardIterator, typename _Predicate, typename _Tp>
     inline void
-    replace_if(ForwardIterator begin, ForwardIterator end,
-               Predicate pred, const T& new_value)
+    replace_if(_ForwardIterator __begin, _ForwardIterator __end,
+               _Predicate __pred, const _Tp& __new_value)
     {
-      typedef std::iterator_traits<ForwardIterator> iterator_traits;
-      typedef typename iterator_traits::iterator_category iterator_category;
-      replace_if_switch(begin, end, pred, new_value, iterator_category());
+      typedef std::iterator_traits<_ForwardIterator> _IteratorTraits;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+      __replace_if_switch(__begin, __end, __pred, __new_value, _IteratorCategory());
     }
 
   // Sequential fallback
-  template<typename ForwardIterator, typename Generator>
+  template<typename _ForwardIterator, typename Generator>
     inline void
-    generate(ForwardIterator begin, ForwardIterator end, Generator gen, 
+    generate(_ForwardIterator __begin, _ForwardIterator __end, Generator __gen, 
              __gnu_parallel::sequential_tag)
-    { _GLIBCXX_STD_P::generate(begin, end, gen); }
+    { _GLIBCXX_STD_P::generate(__begin, __end, __gen); }
 
   // Sequential fallback for input iterator case.
-  template<typename ForwardIterator, typename Generator, typename IteratorTag>
+  template<typename _ForwardIterator, typename Generator, typename _IteratorTag>
     inline void
-    generate_switch(ForwardIterator begin, ForwardIterator end, Generator gen, 
-                    IteratorTag)
-    { generate(begin, end, gen, __gnu_parallel::sequential_tag()); }
+    __generate_switch(_ForwardIterator __begin, _ForwardIterator __end, Generator __gen, 
+                    _IteratorTag)
+    { generate(__begin, __end, __gen, __gnu_parallel::sequential_tag()); }
 
   // Parallel algorithm for random access iterators.
-  template<typename RandomAccessIterator, typename Generator>
+  template<typename _RAIter, typename Generator>
     void
-    generate_switch(RandomAccessIterator begin, RandomAccessIterator end,
-                    Generator gen, random_access_iterator_tag, 
-                    __gnu_parallel::_Parallelism parallelism_tag
+    __generate_switch(_RAIter __begin, _RAIter __end,
+                    Generator __gen, random_access_iterator_tag, 
+                    __gnu_parallel::_Parallelism __parallelism_tag
                     = __gnu_parallel::parallel_balanced)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(
-            static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
             >= __gnu_parallel::_Settings::get().generate_minimal_n
-            && __gnu_parallel::is_parallel(parallelism_tag)))
+            && __gnu_parallel::__is_parallel(__parallelism_tag)))
         {
-          bool dummy;
-          __gnu_parallel::generate_selector<RandomAccessIterator>
-            functionality;
+          bool __dummy;
+          __gnu_parallel::__generate_selector<_RAIter>
+            __functionality;
           __gnu_parallel::
-            for_each_template_random_access(begin, end, gen, functionality,
-                                            __gnu_parallel::dummy_reduct(),
-                                            true, dummy, -1, parallelism_tag);
+            __for_each_template_random_access(__begin, __end, __gen, __functionality,
+                                            __gnu_parallel::_DummyReduct(),
+                                            true, __dummy, -1, __parallelism_tag);
         }
       else
-        generate(begin, end, gen, __gnu_parallel::sequential_tag());
+        generate(__begin, __end, __gen, __gnu_parallel::sequential_tag());
     }
 
   // Public interface.
-  template<typename ForwardIterator, typename Generator>
+  template<typename _ForwardIterator, typename Generator>
     inline void
-    generate(ForwardIterator begin, ForwardIterator end,
-             Generator gen, __gnu_parallel::_Parallelism parallelism_tag)
+    generate(_ForwardIterator __begin, _ForwardIterator __end,
+             Generator __gen, __gnu_parallel::_Parallelism __parallelism_tag)
     {
-      typedef std::iterator_traits<ForwardIterator> iterator_traits;
-      typedef typename iterator_traits::iterator_category iterator_category;
-      generate_switch(begin, end, gen, iterator_category(), parallelism_tag);
+      typedef std::iterator_traits<_ForwardIterator> _IteratorTraits;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+      __generate_switch(__begin, __end, __gen, _IteratorCategory(), __parallelism_tag);
     }
 
-  template<typename ForwardIterator, typename Generator>
+  template<typename _ForwardIterator, typename Generator>
     inline void
-    generate(ForwardIterator begin, ForwardIterator end, Generator gen)
+    generate(_ForwardIterator __begin, _ForwardIterator __end, Generator __gen)
     {
-      typedef std::iterator_traits<ForwardIterator> iterator_traits;
-      typedef typename iterator_traits::iterator_category iterator_category;
-      generate_switch(begin, end, gen, iterator_category());
+      typedef std::iterator_traits<_ForwardIterator> _IteratorTraits;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+      __generate_switch(__begin, __end, __gen, _IteratorCategory());
     }
 
 
   // Sequential fallback.
-  template<typename OutputIterator, typename Size, typename Generator>
-    inline OutputIterator
-    generate_n(OutputIterator begin, Size n, Generator gen, 
+  template<typename _OutputIterator, typename _Size, typename Generator>
+    inline _OutputIterator
+    generate_n(_OutputIterator __begin, _Size __n, Generator __gen, 
                __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::generate_n(begin, n, gen); }
+    { return _GLIBCXX_STD_P::generate_n(__begin, __n, __gen); }
 
   // Sequential fallback for input iterator case.
-  template<typename OutputIterator, typename Size, typename Generator,
-           typename IteratorTag>
-    inline OutputIterator
-    generate_n_switch(OutputIterator begin, Size n, Generator gen, IteratorTag)
-    { return generate_n(begin, n, gen, __gnu_parallel::sequential_tag()); }
+  template<typename _OutputIterator, typename _Size, typename Generator,
+           typename _IteratorTag>
+    inline _OutputIterator
+    __generate_n_switch(_OutputIterator __begin, _Size __n, Generator __gen, _IteratorTag)
+    { return generate_n(__begin, __n, __gen, __gnu_parallel::sequential_tag()); }
 
   // Parallel algorithm for random access iterators.
-  template<typename RandomAccessIterator, typename Size, typename Generator>
-    inline RandomAccessIterator
-    generate_n_switch(RandomAccessIterator begin, Size n, Generator gen, 
+  template<typename _RAIter, typename _Size, typename Generator>
+    inline _RAIter
+    __generate_n_switch(_RAIter __begin, _Size __n, Generator __gen, 
                       random_access_iterator_tag, 
-                      __gnu_parallel::_Parallelism parallelism_tag
+                      __gnu_parallel::_Parallelism __parallelism_tag
                       = __gnu_parallel::parallel_balanced)
     {
       // XXX parallel version is where?
-      return generate_n(begin, n, gen, __gnu_parallel::sequential_tag()); 
+      return generate_n(__begin, __n, __gen, __gnu_parallel::sequential_tag()); 
     }
 
   // Public interface.
-  template<typename OutputIterator, typename Size, typename Generator>
-    inline OutputIterator
-    generate_n(OutputIterator begin, Size n, Generator gen, 
-               __gnu_parallel::_Parallelism parallelism_tag)
+  template<typename _OutputIterator, typename _Size, typename Generator>
+    inline _OutputIterator
+    generate_n(_OutputIterator __begin, _Size __n, Generator __gen, 
+               __gnu_parallel::_Parallelism __parallelism_tag)
     {
-      typedef std::iterator_traits<OutputIterator> iterator_traits;
-      typedef typename iterator_traits::iterator_category iterator_category;
-      return generate_n_switch(begin, n, gen, iterator_category(), 
-                               parallelism_tag); 
+      typedef std::iterator_traits<_OutputIterator> _IteratorTraits;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+      return __generate_n_switch(__begin, __n, __gen, _IteratorCategory(), 
+                               __parallelism_tag); 
     }
 
-  template<typename OutputIterator, typename Size, typename Generator>
-    inline OutputIterator
-    generate_n(OutputIterator begin, Size n, Generator gen)
+  template<typename _OutputIterator, typename _Size, typename Generator>
+    inline _OutputIterator
+    generate_n(_OutputIterator __begin, _Size __n, Generator __gen)
     {
-      typedef std::iterator_traits<OutputIterator> iterator_traits;
-      typedef typename iterator_traits::iterator_category iterator_category;
-      return generate_n_switch(begin, n, gen, iterator_category());
+      typedef std::iterator_traits<_OutputIterator> _IteratorTraits;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+      return __generate_n_switch(__begin, __n, __gen, _IteratorCategory());
     }
 
 
   // Sequential fallback.
-  template<typename RandomAccessIterator>
+  template<typename _RAIter>
     inline void
-    random_shuffle(RandomAccessIterator begin, RandomAccessIterator end, 
+    random_shuffle(_RAIter __begin, _RAIter __end, 
                    __gnu_parallel::sequential_tag)
-    { _GLIBCXX_STD_P::random_shuffle(begin, end); }
+    { _GLIBCXX_STD_P::random_shuffle(__begin, __end); }
 
   // Sequential fallback.
-  template<typename RandomAccessIterator, typename RandomNumberGenerator>
+  template<typename _RAIter, typename RandomNumberGenerator>
     inline void
-    random_shuffle(RandomAccessIterator begin, RandomAccessIterator end, 
-                   RandomNumberGenerator& rand, __gnu_parallel::sequential_tag)
-    { _GLIBCXX_STD_P::random_shuffle(begin, end, rand); }
+    random_shuffle(_RAIter __begin, _RAIter __end, 
+                   RandomNumberGenerator& __rand, __gnu_parallel::sequential_tag)
+    { _GLIBCXX_STD_P::random_shuffle(__begin, __end, __rand); }
 
 
   /** @brief Functor wrapper for std::rand(). */
-  template<typename must_be_int = int>
+  template<typename _MustBeInt = int>
     struct c_rand_number
     {
       int
-      operator()(int limit)
-      { return rand() % limit; }
+      operator()(int __limit)
+      { return rand() % __limit; }
     };
 
   // Fill in random number generator.
-  template<typename RandomAccessIterator>
+  template<typename _RAIter>
     inline void
-    random_shuffle(RandomAccessIterator begin, RandomAccessIterator end)
+    random_shuffle(_RAIter __begin, _RAIter __end)
     {
-      c_rand_number<> r;
+      c_rand_number<> __r;
       // Parallelization still possible.
-      __gnu_parallel::random_shuffle(begin, end, r);
+      __gnu_parallel::random_shuffle(__begin, __end, __r);
     }
 
   // Parallel algorithm for random access iterators.
-  template<typename RandomAccessIterator, typename RandomNumberGenerator>
+  template<typename _RAIter, typename RandomNumberGenerator>
     void
-    random_shuffle(RandomAccessIterator begin, RandomAccessIterator end, 
-                   RandomNumberGenerator& rand)
+    random_shuffle(_RAIter __begin, _RAIter __end, 
+                   RandomNumberGenerator& __rand)
     {
-      if (begin == end)
+      if (__begin == __end)
         return;
       if (_GLIBCXX_PARALLEL_CONDITION(
-            static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
             >= __gnu_parallel::_Settings::get().random_shuffle_minimal_n))
-        __gnu_parallel::parallel_random_shuffle(begin, end, rand);
+        __gnu_parallel::__parallel_random_shuffle(__begin, __end, __rand);
       else
-        __gnu_parallel::sequential_random_shuffle(begin, end, rand);
+        __gnu_parallel::__sequential_random_shuffle(__begin, __end, __rand);
     }
 
   // Sequential fallback.
-  template<typename ForwardIterator, typename Predicate>
-    inline ForwardIterator
-    partition(ForwardIterator begin, ForwardIterator end,
-              Predicate pred, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::partition(begin, end, pred); }
+  template<typename _ForwardIterator, typename _Predicate>
+    inline _ForwardIterator
+    partition(_ForwardIterator __begin, _ForwardIterator __end,
+              _Predicate __pred, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::partition(__begin, __end, __pred); }
 
   // Sequential fallback for input iterator case.
-  template<typename ForwardIterator, typename Predicate, typename IteratorTag>
-    inline ForwardIterator
-    partition_switch(ForwardIterator begin, ForwardIterator end,
-                     Predicate pred, IteratorTag)
-    { return partition(begin, end, pred, __gnu_parallel::sequential_tag()); }
+  template<typename _ForwardIterator, typename _Predicate, typename _IteratorTag>
+    inline _ForwardIterator
+    __partition_switch(_ForwardIterator __begin, _ForwardIterator __end,
+                     _Predicate __pred, _IteratorTag)
+    { return partition(__begin, __end, __pred, __gnu_parallel::sequential_tag()); }
 
   // Parallel algorithm for random access iterators.
-  template<typename RandomAccessIterator, typename Predicate>
-    RandomAccessIterator
-    partition_switch(RandomAccessIterator begin, RandomAccessIterator end,
-                     Predicate pred, random_access_iterator_tag)
+  template<typename _RAIter, typename _Predicate>
+    _RAIter
+    __partition_switch(_RAIter __begin, _RAIter __end,
+                     _Predicate __pred, random_access_iterator_tag)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(
-            static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
             >= __gnu_parallel::_Settings::get().partition_minimal_n))
         {
-          typedef typename std::iterator_traits<RandomAccessIterator>::
-            difference_type difference_type;
-          difference_type middle = __gnu_parallel::
-            parallel_partition(begin, end, pred,
-                               __gnu_parallel::get_max_threads());
-          return begin + middle;
+          typedef typename std::iterator_traits<_RAIter>::
+            difference_type _DifferenceType;
+          _DifferenceType __middle = __gnu_parallel::
+            __parallel_partition(__begin, __end, __pred,
+                               __gnu_parallel::__get_max_threads());
+          return __begin + __middle;
         }
       else
-        return partition(begin, end, pred, __gnu_parallel::sequential_tag());
+        return partition(__begin, __end, __pred, __gnu_parallel::sequential_tag());
     }
 
   // Public interface.
-  template<typename ForwardIterator, typename Predicate>
-    inline ForwardIterator
-    partition(ForwardIterator begin, ForwardIterator end, Predicate pred)
+  template<typename _ForwardIterator, typename _Predicate>
+    inline _ForwardIterator
+    partition(_ForwardIterator __begin, _ForwardIterator __end, _Predicate __pred)
     {
-      typedef iterator_traits<ForwardIterator> traits_type;
-      typedef typename traits_type::iterator_category iterator_category;
-      return partition_switch(begin, end, pred, iterator_category());
+      typedef iterator_traits<_ForwardIterator> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      return __partition_switch(__begin, __end, __pred, _IteratorCategory());
     }
 
   // sort interface
 
   // Sequential fallback
-  template<typename RandomAccessIterator>
+  template<typename _RAIter>
     inline void
-    sort(RandomAccessIterator begin, RandomAccessIterator end, 
+    sort(_RAIter __begin, _RAIter __end, 
          __gnu_parallel::sequential_tag)
-    { _GLIBCXX_STD_P::sort(begin, end); }
+    { _GLIBCXX_STD_P::sort(__begin, __end); }
 
   // Sequential fallback
-  template<typename RandomAccessIterator, typename Comparator>
+  template<typename _RAIter, typename _Compare>
     inline void
-    sort(RandomAccessIterator begin, RandomAccessIterator end, Comparator comp,
+    sort(_RAIter __begin, _RAIter __end, _Compare __comp,
          __gnu_parallel::sequential_tag)
-    { _GLIBCXX_STD_P::sort<RandomAccessIterator, Comparator>(begin, end,
-                                                             comp); }
+    { _GLIBCXX_STD_P::sort<_RAIter, _Compare>(__begin, __end,
+                                                             __comp); }
 
   // Public interface
-  template<typename RandomAccessIterator, typename Comparator,
-           typename Parallelism>
+  template<typename _RAIter, typename _Compare,
+           typename _Parallelism>
   void
-  sort(RandomAccessIterator begin, RandomAccessIterator end, Comparator comp,
-       Parallelism parallelism)
+  sort(_RAIter __begin, _RAIter __end, _Compare __comp,
+       _Parallelism __parallelism)
   {
-    typedef iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
 
-    if (begin != end)
+    if (__begin != __end)
       {
         if (_GLIBCXX_PARALLEL_CONDITION(
-            static_cast<__gnu_parallel::sequence_index_t>(end - begin) >=
+            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) >=
               __gnu_parallel::_Settings::get().sort_minimal_n))
-          __gnu_parallel::parallel_sort<false>(begin, end, comp, parallelism);
+          __gnu_parallel::parallel_sort<false>(__begin, __end, __comp, __parallelism);
         else
-          sort(begin, end, comp, __gnu_parallel::sequential_tag());
+          sort(__begin, __end, __comp, __gnu_parallel::sequential_tag());
       }
   }
 
   // Public interface, insert default comparator
-  template<typename RandomAccessIterator>
+  template<typename _RAIter>
     inline void
-    sort(RandomAccessIterator begin, RandomAccessIterator end)
+    sort(_RAIter __begin, _RAIter __end)
     {
-      typedef iterator_traits<RandomAccessIterator> traits_type;
-      typedef typename traits_type::value_type value_type;
-      sort(begin, end, std::less<value_type>(),
+      typedef iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      sort(__begin, __end, std::less<_ValueType>(),
            __gnu_parallel::default_parallel_tag());
     }
 
   // Public interface, insert default comparator
-  template<typename RandomAccessIterator>
+  template<typename _RAIter>
   inline void
-  sort(RandomAccessIterator begin, RandomAccessIterator end,
-       __gnu_parallel::default_parallel_tag parallelism)
+  sort(_RAIter __begin, _RAIter __end,
+       __gnu_parallel::default_parallel_tag __parallelism)
   {
-    typedef iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    sort(begin, end, std::less<value_type>(), parallelism);
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    sort(__begin, __end, std::less<_ValueType>(), __parallelism);
   }
 
   // Public interface, insert default comparator
-  template<typename RandomAccessIterator>
+  template<typename _RAIter>
   inline void
-  sort(RandomAccessIterator begin, RandomAccessIterator end,
-       __gnu_parallel::parallel_tag parallelism)
+  sort(_RAIter __begin, _RAIter __end,
+       __gnu_parallel::parallel_tag __parallelism)
   {
-    typedef iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    sort(begin, end, std::less<value_type>(), parallelism);
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    sort(__begin, __end, std::less<_ValueType>(), __parallelism);
   }
 
   // Public interface, insert default comparator
-  template<typename RandomAccessIterator>
+  template<typename _RAIter>
   inline void
-  sort(RandomAccessIterator begin, RandomAccessIterator end,
-       __gnu_parallel::multiway_mergesort_tag parallelism)
+  sort(_RAIter __begin, _RAIter __end,
+       __gnu_parallel::multiway_mergesort_tag __parallelism)
   {
-    typedef iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    sort(begin, end, std::less<value_type>(), parallelism);
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    sort(__begin, __end, std::less<_ValueType>(), __parallelism);
   }
 
   // Public interface, insert default comparator
-  template<typename RandomAccessIterator>
+  template<typename _RAIter>
   inline void
-  sort(RandomAccessIterator begin, RandomAccessIterator end,
-       __gnu_parallel::multiway_mergesort_sampling_tag parallelism)
+  sort(_RAIter __begin, _RAIter __end,
+       __gnu_parallel::multiway_mergesort_sampling_tag __parallelism)
   {
-    typedef iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    sort(begin, end, std::less<value_type>(), parallelism);
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    sort(__begin, __end, std::less<_ValueType>(), __parallelism);
   }
 
   // Public interface, insert default comparator
-  template<typename RandomAccessIterator>
+  template<typename _RAIter>
   inline void
-  sort(RandomAccessIterator begin, RandomAccessIterator end,
-       __gnu_parallel::multiway_mergesort_exact_tag parallelism)
+  sort(_RAIter __begin, _RAIter __end,
+       __gnu_parallel::multiway_mergesort_exact_tag __parallelism)
   {
-    typedef iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    sort(begin, end, std::less<value_type>(), parallelism);
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    sort(__begin, __end, std::less<_ValueType>(), __parallelism);
   }
 
   // Public interface, insert default comparator
-  template<typename RandomAccessIterator>
+  template<typename _RAIter>
   inline void
-  sort(RandomAccessIterator begin, RandomAccessIterator end,
-       __gnu_parallel::quicksort_tag parallelism)
+  sort(_RAIter __begin, _RAIter __end,
+       __gnu_parallel::quicksort_tag __parallelism)
   {
-    typedef iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    sort(begin, end, std::less<value_type>(), parallelism);
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    sort(__begin, __end, std::less<_ValueType>(), __parallelism);
   }
 
   // Public interface, insert default comparator
-  template<typename RandomAccessIterator>
+  template<typename _RAIter>
   inline void
-  sort(RandomAccessIterator begin, RandomAccessIterator end,
-       __gnu_parallel::balanced_quicksort_tag parallelism)
+  sort(_RAIter __begin, _RAIter __end,
+       __gnu_parallel::balanced_quicksort_tag __parallelism)
   {
-    typedef iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    sort(begin, end, std::less<value_type>(), parallelism);
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    sort(__begin, __end, std::less<_ValueType>(), __parallelism);
   }
 
   // Public interface
-  template<typename RandomAccessIterator, typename Comparator>
+  template<typename _RAIter, typename _Compare>
     void
-    sort(RandomAccessIterator begin, RandomAccessIterator end, Comparator comp)
+    sort(_RAIter __begin, _RAIter __end, _Compare __comp)
     {
-      typedef iterator_traits<RandomAccessIterator> traits_type;
-      typedef typename traits_type::value_type value_type;
-    sort(begin, end, comp, __gnu_parallel::default_parallel_tag());
+      typedef iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+    sort(__begin, __end, __comp, __gnu_parallel::default_parallel_tag());
   }
 
 
@@ -1848,515 +1848,515 @@ namespace __parallel
 
 
   // Sequential fallback
-  template<typename RandomAccessIterator>
+  template<typename _RAIter>
   inline void
-  stable_sort(RandomAccessIterator begin, RandomAccessIterator end,
+  stable_sort(_RAIter __begin, _RAIter __end,
        __gnu_parallel::sequential_tag)
-  { _GLIBCXX_STD_P::stable_sort(begin, end); }
+  { _GLIBCXX_STD_P::stable_sort(__begin, __end); }
 
   // Sequential fallback
-  template<typename RandomAccessIterator, typename Comparator>
+  template<typename _RAIter, typename _Compare>
   inline void
-  stable_sort(RandomAccessIterator begin, RandomAccessIterator end,
-              Comparator comp, __gnu_parallel::sequential_tag)
-  { _GLIBCXX_STD_P::stable_sort<RandomAccessIterator, Comparator>(
-      begin, end, comp); }
+  stable_sort(_RAIter __begin, _RAIter __end,
+              _Compare __comp, __gnu_parallel::sequential_tag)
+  { _GLIBCXX_STD_P::stable_sort<_RAIter, _Compare>(
+      __begin, __end, __comp); }
 
   // Public interface
-  template<typename RandomAccessIterator, typename Comparator,
-           typename Parallelism>
+  template<typename _RAIter, typename _Compare,
+           typename _Parallelism>
   void
-  stable_sort(RandomAccessIterator begin, RandomAccessIterator end,
-              Comparator comp, Parallelism parallelism)
+  stable_sort(_RAIter __begin, _RAIter __end,
+              _Compare __comp, _Parallelism __parallelism)
   {
-    typedef iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
 
-    if (begin != end)
+    if (__begin != __end)
       {
         if (_GLIBCXX_PARALLEL_CONDITION(
-              static_cast<__gnu_parallel::sequence_index_t>(end - begin) >=
+              static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) >=
               __gnu_parallel::_Settings::get().sort_minimal_n))
-          __gnu_parallel::parallel_sort<true>(begin, end, comp, parallelism);
+          __gnu_parallel::parallel_sort<true>(__begin, __end, __comp, __parallelism);
         else
-          stable_sort(begin, end, comp, __gnu_parallel::sequential_tag());
+          stable_sort(__begin, __end, __comp, __gnu_parallel::sequential_tag());
       }
   }
 
   // Public interface, insert default comparator
-  template<typename RandomAccessIterator>
+  template<typename _RAIter>
   inline void
-  stable_sort(RandomAccessIterator begin, RandomAccessIterator end)
+  stable_sort(_RAIter __begin, _RAIter __end)
   {
-    typedef iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    stable_sort(begin, end, std::less<value_type>(),
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    stable_sort(__begin, __end, std::less<_ValueType>(),
                 __gnu_parallel::default_parallel_tag());
   }
 
   // Public interface, insert default comparator
-  template<typename RandomAccessIterator>
+  template<typename _RAIter>
   inline void
-  stable_sort(RandomAccessIterator begin, RandomAccessIterator end,
-              __gnu_parallel::default_parallel_tag parallelism)
+  stable_sort(_RAIter __begin, _RAIter __end,
+              __gnu_parallel::default_parallel_tag __parallelism)
   {
-    typedef iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    stable_sort(begin, end, std::less<value_type>(), parallelism);
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    stable_sort(__begin, __end, std::less<_ValueType>(), __parallelism);
   }
 
   // Public interface, insert default comparator
-  template<typename RandomAccessIterator>
+  template<typename _RAIter>
   inline void
-  stable_sort(RandomAccessIterator begin, RandomAccessIterator end,
-              __gnu_parallel::parallel_tag parallelism)
+  stable_sort(_RAIter __begin, _RAIter __end,
+              __gnu_parallel::parallel_tag __parallelism)
   {
-    typedef iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    stable_sort(begin, end, std::less<value_type>(), parallelism);
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    stable_sort(__begin, __end, std::less<_ValueType>(), __parallelism);
   }
 
   // Public interface, insert default comparator
-  template<typename RandomAccessIterator>
+  template<typename _RAIter>
   inline void
-  stable_sort(RandomAccessIterator begin, RandomAccessIterator end,
-              __gnu_parallel::multiway_mergesort_tag parallelism)
+  stable_sort(_RAIter __begin, _RAIter __end,
+              __gnu_parallel::multiway_mergesort_tag __parallelism)
   {
-    typedef iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    stable_sort(begin, end, std::less<value_type>(), parallelism);
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    stable_sort(__begin, __end, std::less<_ValueType>(), __parallelism);
   }
 
   // Public interface, insert default comparator
-  template<typename RandomAccessIterator>
+  template<typename _RAIter>
   inline void
-  stable_sort(RandomAccessIterator begin, RandomAccessIterator end,
-              __gnu_parallel::quicksort_tag parallelism)
+  stable_sort(_RAIter __begin, _RAIter __end,
+              __gnu_parallel::quicksort_tag __parallelism)
   {
-    typedef iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    stable_sort(begin, end, std::less<value_type>(), parallelism);
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    stable_sort(__begin, __end, std::less<_ValueType>(), __parallelism);
   }
 
   // Public interface, insert default comparator
-  template<typename RandomAccessIterator>
+  template<typename _RAIter>
   inline void
-  stable_sort(RandomAccessIterator begin, RandomAccessIterator end,
-              __gnu_parallel::balanced_quicksort_tag parallelism)
+  stable_sort(_RAIter __begin, _RAIter __end,
+              __gnu_parallel::balanced_quicksort_tag __parallelism)
   {
-    typedef iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    stable_sort(begin, end, std::less<value_type>(), parallelism);
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    stable_sort(__begin, __end, std::less<_ValueType>(), __parallelism);
   }
 
   // Public interface
-  template<typename RandomAccessIterator, typename Comparator>
+  template<typename _RAIter, typename _Compare>
   void
-  stable_sort(RandomAccessIterator begin, RandomAccessIterator end,
-              Comparator comp)
+  stable_sort(_RAIter __begin, _RAIter __end,
+              _Compare __comp)
   {
-    typedef iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    stable_sort(begin, end, comp, __gnu_parallel::default_parallel_tag());
+    typedef iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    stable_sort(__begin, __end, __comp, __gnu_parallel::default_parallel_tag());
   }
 
 
 //   // Sequential fallback
-//   template<typename RandomAccessIterator>
+//   template<typename _RAIter>
 //   inline void
-//   stable_sort(RandomAccessIterator begin, RandomAccessIterator end, 
+//   stable_sort(_RAIter __begin, _RAIter __end, 
 //            __gnu_parallel::sequential_tag)
-//   { return _GLIBCXX_STD_P::stable_sort(begin, end); }
+//   { return _GLIBCXX_STD_P::stable_sort(__begin, __end); }
 // 
 //   // Sequential fallback
-//   template<typename RandomAccessIterator, typename Comparator>
+//   template<typename _RAIter, typename _Compare>
 //   inline void
-//   stable_sort(RandomAccessIterator begin, RandomAccessIterator end, 
-//            Comparator comp, __gnu_parallel::sequential_tag)
-//   { return _GLIBCXX_STD_P::stable_sort(begin, end, comp); }
+//   stable_sort(_RAIter __begin, _RAIter __end, 
+//            _Compare __comp, __gnu_parallel::sequential_tag)
+//   { return _GLIBCXX_STD_P::stable_sort(__begin, __end, __comp); }
 // 
-//   template<typename RandomAccessIterator>
+//   template<typename _RAIter>
 //   void
-//   stable_sort(RandomAccessIterator begin, RandomAccessIterator end)
+//   stable_sort(_RAIter __begin, _RAIter __end)
 //   {
-//     typedef iterator_traits<RandomAccessIterator> traits_type;
-//     typedef typename traits_type::value_type value_type;
-//     stable_sort(begin, end, std::less<value_type>());
+//     typedef iterator_traits<_RAIter> _TraitsType;
+//     typedef typename _TraitsType::value_type _ValueType;
+//     stable_sort(__begin, __end, std::less<_ValueType>());
 //   }
 // 
 //   // Parallel algorithm for random access iterators
-//   template<typename RandomAccessIterator, typename Comparator>
+//   template<typename _RAIter, typename _Compare>
 //   void
-//   stable_sort(RandomAccessIterator begin, RandomAccessIterator end, 
-//            Comparator comp)
+//   stable_sort(_RAIter __begin, _RAIter __end, 
+//            _Compare __comp)
 //   {
-//     if (begin != end)
+//     if (__begin != __end)
 //       {
 //      if (_GLIBCXX_PARALLEL_CONDITION(
-//            static_cast<__gnu_parallel::sequence_index_t>(end - begin) >=
+//            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) >=
 //                __gnu_parallel::_Settings::get().sort_minimal_n))
-//        __gnu_parallel::parallel_sort(begin, end, comp,
+//        __gnu_parallel::parallel_sort(__begin, __end, __comp,
 //                                      __gnu_parallel::parallel_tag());
 //      else
-//        stable_sort(begin, end, comp, __gnu_parallel::sequential_tag());
+//        stable_sort(__begin, __end, __comp, __gnu_parallel::sequential_tag());
 //       }
 //   }
 
   // Sequential fallback
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator>
-    inline OutputIterator
-    merge(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, 
-          InputIterator2 end2, OutputIterator result,
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator>
+    inline _OutputIterator
+    merge(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, 
+          _IIter2 __end2, _OutputIterator __result,
           __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::merge(begin1, end1, begin2, end2, result); }
+    { return _GLIBCXX_STD_P::merge(__begin1, __end1, __begin2, __end2, __result); }
 
   // Sequential fallback
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator, typename Comparator>
-    inline OutputIterator
-    merge(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2,
-          InputIterator2 end2, OutputIterator result, Comparator comp,
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _Compare>
+    inline _OutputIterator
+    merge(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2,
+          _IIter2 __end2, _OutputIterator __result, _Compare __comp,
           __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::merge(begin1, end1, begin2, end2, result, comp); }
+    { return _GLIBCXX_STD_P::merge(__begin1, __end1, __begin2, __end2, __result, __comp); }
 
   // Sequential fallback for input iterator case
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator, typename Comparator,
-           typename IteratorTag1, typename IteratorTag2, typename IteratorTag3>
-    inline OutputIterator
-    merge_switch(InputIterator1 begin1, InputIterator1 end1,
-                 InputIterator2 begin2, InputIterator2 end2,
-                 OutputIterator result, Comparator comp,
-                 IteratorTag1, IteratorTag2, IteratorTag3)
-     { return _GLIBCXX_STD_P::merge(begin1, end1, begin2, end2,
-                                    result, comp); }
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _Compare,
+           typename _IteratorTag1, typename _IteratorTag2, typename _IteratorTag3>
+    inline _OutputIterator
+    __merge_switch(_IIter1 __begin1, _IIter1 __end1,
+                 _IIter2 __begin2, _IIter2 __end2,
+                 _OutputIterator __result, _Compare __comp,
+                 _IteratorTag1, _IteratorTag2, _IteratorTag3)
+     { return _GLIBCXX_STD_P::merge(__begin1, __end1, __begin2, __end2,
+                                    __result, __comp); }
 
   // Parallel algorithm for random access iterators
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator, typename Comparator>
-    OutputIterator
-    merge_switch(InputIterator1 begin1, InputIterator1 end1, 
-                 InputIterator2 begin2, InputIterator2 end2, 
-                 OutputIterator result, Comparator comp, 
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _Compare>
+    _OutputIterator
+    __merge_switch(_IIter1 __begin1, _IIter1 __end1, 
+                 _IIter2 __begin2, _IIter2 __end2, 
+                 _OutputIterator __result, _Compare __comp, 
                  random_access_iterator_tag, random_access_iterator_tag, 
                  random_access_iterator_tag)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(
-            (static_cast<__gnu_parallel::sequence_index_t>(end1 - begin1)
+            (static_cast<__gnu_parallel::_SequenceIndex>(__end1 - __begin1)
              >= __gnu_parallel::_Settings::get().merge_minimal_n
-             || static_cast<__gnu_parallel::sequence_index_t>(end2 - begin2)
+             || static_cast<__gnu_parallel::_SequenceIndex>(__end2 - __begin2)
              >= __gnu_parallel::_Settings::get().merge_minimal_n)))
-        return __gnu_parallel::parallel_merge_advance(begin1, end1,
-                                                      begin2, end2,
-                                                      result, (end1 - begin1)
-                                                      + (end2 - begin2), comp);
+        return __gnu_parallel::__parallel_merge_advance(__begin1, __end1,
+                                                      __begin2, __end2,
+                                                      __result, (__end1 - __begin1)
+                                                      + (__end2 - __begin2), __comp);
       else
-        return __gnu_parallel::merge_advance(begin1, end1, begin2, end2,
-                                             result, (end1 - begin1)
-                                             + (end2 - begin2), comp);
+        return __gnu_parallel::__merge_advance(__begin1, __end1, __begin2, __end2,
+                                             __result, (__end1 - __begin1)
+                                             + (__end2 - __begin2), __comp);
   }
 
   // Public interface
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator, typename Comparator>
-    inline OutputIterator
-    merge(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, 
-          InputIterator2 end2, OutputIterator result, Comparator comp)
-    {
-      typedef typename iterator_traits<InputIterator1>::value_type value_type;
-
-      typedef std::iterator_traits<InputIterator1> iteratori1_traits;
-      typedef std::iterator_traits<InputIterator2> iteratori2_traits;
-      typedef std::iterator_traits<OutputIterator> iteratoro_traits;
-      typedef typename iteratori1_traits::iterator_category
-        iteratori1_category;
-      typedef typename iteratori2_traits::iterator_category
-        iteratori2_category;
-      typedef typename iteratoro_traits::iterator_category iteratoro_category;
-
-      return merge_switch(begin1, end1, begin2, end2, result, comp, 
-                          iteratori1_category(), iteratori2_category(), 
-                          iteratoro_category());
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator, typename _Compare>
+    inline _OutputIterator
+    merge(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, 
+          _IIter2 __end2, _OutputIterator __result, _Compare __comp)
+    {
+      typedef typename iterator_traits<_IIter1>::value_type _ValueType;
+
+      typedef std::iterator_traits<_IIter1> _IIterTraits1;
+      typedef std::iterator_traits<_IIter2> _IIterTraits2;
+      typedef std::iterator_traits<_OutputIterator> _OIterTraits;
+      typedef typename _IIterTraits1::iterator_category
+        _IIterCategory1;
+      typedef typename _IIterTraits2::iterator_category
+        _IIterCategory2;
+      typedef typename _OIterTraits::iterator_category _OIterCategory;
+
+      return __merge_switch(__begin1, __end1, __begin2, __end2, __result, __comp, 
+                          _IIterCategory1(), _IIterCategory2(), 
+                          _OIterCategory());
   }
 
 
   // Public interface, insert default comparator
-  template<typename InputIterator1, typename InputIterator2,
-           typename OutputIterator>
-    inline OutputIterator
-    merge(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, 
-          InputIterator2 end2, OutputIterator result)
+  template<typename _IIter1, typename _IIter2,
+           typename _OutputIterator>
+    inline _OutputIterator
+    merge(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, 
+          _IIter2 __end2, _OutputIterator __result)
     {
-      typedef std::iterator_traits<InputIterator1> iterator1_traits;
-      typedef std::iterator_traits<InputIterator2> iterator2_traits;
-      typedef typename iterator1_traits::value_type value1_type;
-      typedef typename iterator2_traits::value_type value2_type;
+      typedef std::iterator_traits<_IIter1> iterator1_traits;
+      typedef std::iterator_traits<_IIter2> iterator2_traits;
+      typedef typename iterator1_traits::value_type _ValueType1;
+      typedef typename iterator2_traits::value_type _ValueType2;
 
-      return merge(begin1, end1, begin2, end2, result, 
-                   __gnu_parallel::less<value1_type, value2_type>());
+      return merge(__begin1, __end1, __begin2, __end2, __result, 
+                   __gnu_parallel::_Less<_ValueType1, _ValueType2>());
     }
 
   // Sequential fallback
-  template<typename RandomAccessIterator>
+  template<typename _RAIter>
     inline void
-    nth_element(RandomAccessIterator begin, RandomAccessIterator nth, 
-                RandomAccessIterator end, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::nth_element(begin, nth, end); }
+    nth_element(_RAIter __begin, _RAIter __nth, 
+                _RAIter __end, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::nth_element(__begin, __nth, __end); }
 
   // Sequential fallback
-  template<typename RandomAccessIterator, typename Comparator>
+  template<typename _RAIter, typename _Compare>
     inline void
-    nth_element(RandomAccessIterator begin, RandomAccessIterator nth, 
-                RandomAccessIterator end, Comparator comp, 
+    nth_element(_RAIter __begin, _RAIter __nth, 
+                _RAIter __end, _Compare __comp, 
               __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::nth_element(begin, nth, end, comp); }
+    { return _GLIBCXX_STD_P::nth_element(__begin, __nth, __end, __comp); }
 
   // Public interface
-  template<typename RandomAccessIterator, typename Comparator>
+  template<typename _RAIter, typename _Compare>
     inline void
-    nth_element(RandomAccessIterator begin, RandomAccessIterator nth, 
-                RandomAccessIterator end, Comparator comp)
+    nth_element(_RAIter __begin, _RAIter __nth, 
+                _RAIter __end, _Compare __comp)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(
-            static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
             >= __gnu_parallel::_Settings::get().nth_element_minimal_n))
-        __gnu_parallel::parallel_nth_element(begin, nth, end, comp);
+        __gnu_parallel::parallel_nth_element(__begin, __nth, __end, __comp);
       else
-        nth_element(begin, nth, end, comp, __gnu_parallel::sequential_tag());
+        nth_element(__begin, __nth, __end, __comp, __gnu_parallel::sequential_tag());
     }
 
   // Public interface, insert default comparator
-  template<typename RandomAccessIterator>
+  template<typename _RAIter>
     inline void
-    nth_element(RandomAccessIterator begin, RandomAccessIterator nth, 
-                RandomAccessIterator end)
+    nth_element(_RAIter __begin, _RAIter __nth, 
+                _RAIter __end)
     {
-      typedef iterator_traits<RandomAccessIterator> traits_type;
-      typedef typename traits_type::value_type value_type;
-      nth_element(begin, nth, end, std::less<value_type>());
+      typedef iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      nth_element(__begin, __nth, __end, std::less<_ValueType>());
     }
 
   // Sequential fallback
-  template<typename RandomAccessIterator, typename _Compare>
+  template<typename _RAIter, typename _Compare>
     inline void
-    partial_sort(RandomAccessIterator begin, RandomAccessIterator middle, 
-                 RandomAccessIterator end, _Compare comp,
+    partial_sort(_RAIter __begin, _RAIter __middle, 
+                 _RAIter __end, _Compare __comp,
                  __gnu_parallel::sequential_tag)
-    { _GLIBCXX_STD_P::partial_sort(begin, middle, end, comp); }
+    { _GLIBCXX_STD_P::partial_sort(__begin, __middle, __end, __comp); }
 
   // Sequential fallback
-  template<typename RandomAccessIterator>
+  template<typename _RAIter>
     inline void
-    partial_sort(RandomAccessIterator begin, RandomAccessIterator middle, 
-                 RandomAccessIterator end, __gnu_parallel::sequential_tag)
-    { _GLIBCXX_STD_P::partial_sort(begin, middle, end); }
+    partial_sort(_RAIter __begin, _RAIter __middle, 
+                 _RAIter __end, __gnu_parallel::sequential_tag)
+    { _GLIBCXX_STD_P::partial_sort(__begin, __middle, __end); }
 
   // Public interface, parallel algorithm for random access iterators
-  template<typename RandomAccessIterator, typename _Compare>
+  template<typename _RAIter, typename _Compare>
     void
-    partial_sort(RandomAccessIterator begin, RandomAccessIterator middle, 
-                 RandomAccessIterator end, _Compare comp)
+    partial_sort(_RAIter __begin, _RAIter __middle, 
+                 _RAIter __end, _Compare __comp)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(
-            static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
             >= __gnu_parallel::_Settings::get().partial_sort_minimal_n))
-        __gnu_parallel::parallel_partial_sort(begin, middle, end, comp);
+        __gnu_parallel::parallel_partial_sort(__begin, __middle, __end, __comp);
       else
-        partial_sort(begin, middle, end, comp,
+        partial_sort(__begin, __middle, __end, __comp,
                      __gnu_parallel::sequential_tag());
     }
 
   // Public interface, insert default comparator
-  template<typename RandomAccessIterator>
+  template<typename _RAIter>
     inline void
-    partial_sort(RandomAccessIterator begin, RandomAccessIterator middle, 
-                 RandomAccessIterator end)
+    partial_sort(_RAIter __begin, _RAIter __middle, 
+                 _RAIter __end)
     {
-      typedef iterator_traits<RandomAccessIterator> traits_type;
-      typedef typename traits_type::value_type value_type;
-      partial_sort(begin, middle, end, std::less<value_type>());
+      typedef iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      partial_sort(__begin, __middle, __end, std::less<_ValueType>());
     }
 
   // Sequential fallback
-  template<typename ForwardIterator>
-    inline ForwardIterator
-    max_element(ForwardIterator begin, ForwardIterator end, 
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    max_element(_ForwardIterator __begin, _ForwardIterator __end, 
                 __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::max_element(begin, end); }
+    { return _GLIBCXX_STD_P::max_element(__begin, __end); }
 
   // Sequential fallback
-  template<typename ForwardIterator, typename Comparator>
-    inline ForwardIterator
-    max_element(ForwardIterator begin, ForwardIterator end, Comparator comp, 
+  template<typename _ForwardIterator, typename _Compare>
+    inline _ForwardIterator
+    max_element(_ForwardIterator __begin, _ForwardIterator __end, _Compare __comp, 
                 __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::max_element(begin, end, comp); }
+    { return _GLIBCXX_STD_P::max_element(__begin, __end, __comp); }
 
   // Sequential fallback for input iterator case
-  template<typename ForwardIterator, typename Comparator, typename IteratorTag>
-    inline ForwardIterator
-    max_element_switch(ForwardIterator begin, ForwardIterator end, 
-                       Comparator comp, IteratorTag)
-    { return max_element(begin, end, comp, __gnu_parallel::sequential_tag()); }
+  template<typename _ForwardIterator, typename _Compare, typename _IteratorTag>
+    inline _ForwardIterator
+    __max_element_switch(_ForwardIterator __begin, _ForwardIterator __end, 
+                       _Compare __comp, _IteratorTag)
+    { return max_element(__begin, __end, __comp, __gnu_parallel::sequential_tag()); }
 
   // Parallel algorithm for random access iterators
-  template<typename RandomAccessIterator, typename Comparator>
-    RandomAccessIterator
-    max_element_switch(RandomAccessIterator begin, RandomAccessIterator end, 
-                       Comparator comp, random_access_iterator_tag, 
-                       __gnu_parallel::_Parallelism parallelism_tag
+  template<typename _RAIter, typename _Compare>
+    _RAIter
+    __max_element_switch(_RAIter __begin, _RAIter __end, 
+                       _Compare __comp, random_access_iterator_tag, 
+                       __gnu_parallel::_Parallelism __parallelism_tag
                        = __gnu_parallel::parallel_balanced)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(
-            static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
             >= __gnu_parallel::_Settings::get().max_element_minimal_n
-            && __gnu_parallel::is_parallel(parallelism_tag)))
+            && __gnu_parallel::__is_parallel(__parallelism_tag)))
         {
-          RandomAccessIterator res(begin);
-          __gnu_parallel::identity_selector<RandomAccessIterator>
-            functionality;
+          _RAIter __res(__begin);
+          __gnu_parallel::__identity_selector<_RAIter>
+            __functionality;
           __gnu_parallel::
-            for_each_template_random_access(begin, end,
-                                            __gnu_parallel::nothing(),
-                                            functionality,
+            __for_each_template_random_access(__begin, __end,
+                                            __gnu_parallel::_Nothing(),
+                                            __functionality,
                                             __gnu_parallel::
-                                            max_element_reduct<Comparator,
-                                            RandomAccessIterator>(comp),
-                                            res, res, -1, parallelism_tag);
-          return res;
+                                            __max_element_reduct<_Compare,
+                                            _RAIter>(__comp),
+                                            __res, __res, -1, __parallelism_tag);
+          return __res;
         }
       else
-        return max_element(begin, end, comp, __gnu_parallel::sequential_tag());
+        return max_element(__begin, __end, __comp, __gnu_parallel::sequential_tag());
     }
 
   // Public interface, insert default comparator
-  template<typename ForwardIterator>
-    inline ForwardIterator
-    max_element(ForwardIterator begin, ForwardIterator end, 
-                __gnu_parallel::_Parallelism parallelism_tag)
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    max_element(_ForwardIterator __begin, _ForwardIterator __end, 
+                __gnu_parallel::_Parallelism __parallelism_tag)
     {
-      typedef typename iterator_traits<ForwardIterator>::value_type value_type;
-      return max_element(begin, end, std::less<value_type>(), parallelism_tag);
+      typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+      return max_element(__begin, __end, std::less<_ValueType>(), __parallelism_tag);
     }
 
-  template<typename ForwardIterator>
-    inline ForwardIterator
-    max_element(ForwardIterator begin, ForwardIterator end)
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    max_element(_ForwardIterator __begin, _ForwardIterator __end)
     {
-      typedef typename iterator_traits<ForwardIterator>::value_type value_type;
-      return max_element(begin, end, std::less<value_type>());
+      typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+      return max_element(__begin, __end, std::less<_ValueType>());
     }
 
   // Public interface
-  template<typename ForwardIterator, typename Comparator>
-    inline ForwardIterator
-    max_element(ForwardIterator begin, ForwardIterator end, Comparator comp,
-                __gnu_parallel::_Parallelism parallelism_tag)
+  template<typename _ForwardIterator, typename _Compare>
+    inline _ForwardIterator
+    max_element(_ForwardIterator __begin, _ForwardIterator __end, _Compare __comp,
+                __gnu_parallel::_Parallelism __parallelism_tag)
     {
-      typedef iterator_traits<ForwardIterator> traits_type;
-      typedef typename traits_type::iterator_category iterator_category;
-      return max_element_switch(begin, end, comp, iterator_category(), 
-                                parallelism_tag);
+      typedef iterator_traits<_ForwardIterator> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      return __max_element_switch(__begin, __end, __comp, _IteratorCategory(), 
+                                __parallelism_tag);
     }
 
-  template<typename ForwardIterator, typename Comparator>
-    inline ForwardIterator
-    max_element(ForwardIterator begin, ForwardIterator end, Comparator comp)
+  template<typename _ForwardIterator, typename _Compare>
+    inline _ForwardIterator
+    max_element(_ForwardIterator __begin, _ForwardIterator __end, _Compare __comp)
     {
-      typedef iterator_traits<ForwardIterator> traits_type;
-      typedef typename traits_type::iterator_category iterator_category;
-      return max_element_switch(begin, end, comp, iterator_category());
+      typedef iterator_traits<_ForwardIterator> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      return __max_element_switch(__begin, __end, __comp, _IteratorCategory());
     }
 
 
   // Sequential fallback
-  template<typename ForwardIterator>
-    inline ForwardIterator
-    min_element(ForwardIterator begin, ForwardIterator end, 
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    min_element(_ForwardIterator __begin, _ForwardIterator __end, 
                 __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::min_element(begin, end); }
+    { return _GLIBCXX_STD_P::min_element(__begin, __end); }
 
   // Sequential fallback
-  template<typename ForwardIterator, typename Comparator>
-    inline ForwardIterator
-    min_element(ForwardIterator begin, ForwardIterator end, Comparator comp, 
+  template<typename _ForwardIterator, typename _Compare>
+    inline _ForwardIterator
+    min_element(_ForwardIterator __begin, _ForwardIterator __end, _Compare __comp, 
                 __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::min_element(begin, end, comp); }
+    { return _GLIBCXX_STD_P::min_element(__begin, __end, __comp); }
 
   // Sequential fallback for input iterator case
-  template<typename ForwardIterator, typename Comparator, typename IteratorTag>
-    inline ForwardIterator
-    min_element_switch(ForwardIterator begin, ForwardIterator end, 
-                       Comparator comp, IteratorTag)
-    { return min_element(begin, end, comp, __gnu_parallel::sequential_tag()); }
+  template<typename _ForwardIterator, typename _Compare, typename _IteratorTag>
+    inline _ForwardIterator
+    __min_element_switch(_ForwardIterator __begin, _ForwardIterator __end, 
+                       _Compare __comp, _IteratorTag)
+    { return min_element(__begin, __end, __comp, __gnu_parallel::sequential_tag()); }
 
   // Parallel algorithm for random access iterators
-  template<typename RandomAccessIterator, typename Comparator>
-    RandomAccessIterator
-    min_element_switch(RandomAccessIterator begin, RandomAccessIterator end, 
-                       Comparator comp, random_access_iterator_tag, 
-                       __gnu_parallel::_Parallelism parallelism_tag
+  template<typename _RAIter, typename _Compare>
+    _RAIter
+    __min_element_switch(_RAIter __begin, _RAIter __end, 
+                       _Compare __comp, random_access_iterator_tag, 
+                       __gnu_parallel::_Parallelism __parallelism_tag
                        = __gnu_parallel::parallel_balanced)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(
-            static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+            static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
             >= __gnu_parallel::_Settings::get().min_element_minimal_n
-            && __gnu_parallel::is_parallel(parallelism_tag)))
+            && __gnu_parallel::__is_parallel(__parallelism_tag)))
         {
-          RandomAccessIterator res(begin);
-          __gnu_parallel::identity_selector<RandomAccessIterator>
-            functionality;
+          _RAIter __res(__begin);
+          __gnu_parallel::__identity_selector<_RAIter>
+            __functionality;
           __gnu_parallel::
-            for_each_template_random_access(begin, end,
-                                            __gnu_parallel::nothing(),
-                                            functionality,
+            __for_each_template_random_access(__begin, __end,
+                                            __gnu_parallel::_Nothing(),
+                                            __functionality,
                                             __gnu_parallel::
-                                            min_element_reduct<Comparator,
-                                            RandomAccessIterator>(comp),
-                                            res, res, -1, parallelism_tag);
-          return res;
+                                            __min_element_reduct<_Compare,
+                                            _RAIter>(__comp),
+                                            __res, __res, -1, __parallelism_tag);
+          return __res;
         }
       else
-        return min_element(begin, end, comp, __gnu_parallel::sequential_tag());
+        return min_element(__begin, __end, __comp, __gnu_parallel::sequential_tag());
     }
 
   // Public interface, insert default comparator
-  template<typename ForwardIterator>
-    inline ForwardIterator
-    min_element(ForwardIterator begin, ForwardIterator end, 
-                __gnu_parallel::_Parallelism parallelism_tag)
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    min_element(_ForwardIterator __begin, _ForwardIterator __end, 
+                __gnu_parallel::_Parallelism __parallelism_tag)
     {
-      typedef typename iterator_traits<ForwardIterator>::value_type value_type;
-      return min_element(begin, end, std::less<value_type>(), parallelism_tag);
+      typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+      return min_element(__begin, __end, std::less<_ValueType>(), __parallelism_tag);
     }
 
-  template<typename ForwardIterator>
-    inline ForwardIterator
-    min_element(ForwardIterator begin, ForwardIterator end)
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    min_element(_ForwardIterator __begin, _ForwardIterator __end)
     {
-      typedef typename iterator_traits<ForwardIterator>::value_type value_type;
-      return min_element(begin, end, std::less<value_type>());
+      typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+      return min_element(__begin, __end, std::less<_ValueType>());
     }
 
   // Public interface
-  template<typename ForwardIterator, typename Comparator>
-    inline ForwardIterator
-    min_element(ForwardIterator begin, ForwardIterator end, Comparator comp,
-                __gnu_parallel::_Parallelism parallelism_tag)
+  template<typename _ForwardIterator, typename _Compare>
+    inline _ForwardIterator
+    min_element(_ForwardIterator __begin, _ForwardIterator __end, _Compare __comp,
+                __gnu_parallel::_Parallelism __parallelism_tag)
     {
-      typedef iterator_traits<ForwardIterator> traits_type;
-      typedef typename traits_type::iterator_category iterator_category;
-      return min_element_switch(begin, end, comp, iterator_category(), 
-                                parallelism_tag);
+      typedef iterator_traits<_ForwardIterator> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      return __min_element_switch(__begin, __end, __comp, _IteratorCategory(), 
+                                __parallelism_tag);
     }
 
-  template<typename ForwardIterator, typename Comparator>
-    inline ForwardIterator
-    min_element(ForwardIterator begin, ForwardIterator end, Comparator comp)
+  template<typename _ForwardIterator, typename _Compare>
+    inline _ForwardIterator
+    min_element(_ForwardIterator __begin, _ForwardIterator __end, _Compare __comp)
     {
-      typedef iterator_traits<ForwardIterator> traits_type;
-      typedef typename traits_type::iterator_category iterator_category;
-      return min_element_switch(begin, end, comp, iterator_category());
+      typedef iterator_traits<_ForwardIterator> _TraitsType;
+      typedef typename _TraitsType::iterator_category _IteratorCategory;
+      return __min_element_switch(__begin, __end, __comp, _IteratorCategory());
     }
 } // end namespace
 } // end namespace
diff --git a/libstdc++-v3/include/parallel/algobase.h b/libstdc++-v3/include/parallel/algobase.h
index aaffb3e..b50068d 100644
--- a/libstdc++-v3/include/parallel/algobase.h
+++ b/libstdc++-v3/include/parallel/algobase.h
@@ -50,230 +50,230 @@ namespace __parallel
   // NB: equal and lexicographical_compare require mismatch.
 
   // Sequential fallback
-  template<typename InputIterator1, typename InputIterator2>
-    inline pair<InputIterator1, InputIterator2>
-    mismatch(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2,
+  template<typename _IIter1, typename _IIter2>
+    inline pair<_IIter1, _IIter2>
+    mismatch(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2,
 	     __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::mismatch(begin1, end1, begin2); }
+    { return _GLIBCXX_STD_P::mismatch(__begin1, __end1, __begin2); }
 
   // Sequential fallback
-  template<typename InputIterator1, typename InputIterator2,
-	   typename Predicate>
-    inline pair<InputIterator1, InputIterator2>
-    mismatch(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2,
-	     Predicate pred, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::mismatch(begin1, end1, begin2, pred); }
+  template<typename _IIter1, typename _IIter2,
+	   typename _Predicate>
+    inline pair<_IIter1, _IIter2>
+    mismatch(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2,
+	     _Predicate __pred, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::mismatch(__begin1, __end1, __begin2, __pred); }
 
   // Sequential fallback for input iterator case
-  template<typename InputIterator1, typename InputIterator2,
-	   typename Predicate, typename IteratorTag1, typename IteratorTag2>
-    inline pair<InputIterator1, InputIterator2>
-    mismatch_switch(InputIterator1 begin1, InputIterator1 end1, 
-		    InputIterator2 begin2, Predicate pred, IteratorTag1, 
-		    IteratorTag2)
-    { return _GLIBCXX_STD_P::mismatch(begin1, end1, begin2, pred); }
+  template<typename _IIter1, typename _IIter2,
+	   typename _Predicate, typename _IteratorTag1, typename _IteratorTag2>
+    inline pair<_IIter1, _IIter2>
+    __mismatch_switch(_IIter1 __begin1, _IIter1 __end1, 
+		    _IIter2 __begin2, _Predicate __pred, _IteratorTag1, 
+		    _IteratorTag2)
+    { return _GLIBCXX_STD_P::mismatch(__begin1, __end1, __begin2, __pred); }
 
   // Parallel mismatch for random access iterators
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-	   typename Predicate>
-    pair<RandomAccessIterator1, RandomAccessIterator2>
-    mismatch_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1,
-		    RandomAccessIterator2 begin2, Predicate pred, 
+  template<typename _RAIter1, typename _RAIter2,
+	   typename _Predicate>
+    pair<_RAIter1, _RAIter2>
+    __mismatch_switch(_RAIter1 __begin1, _RAIter1 __end1,
+		    _RAIter2 __begin2, _Predicate __pred, 
 		    random_access_iterator_tag, random_access_iterator_tag)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(true))
 	{
-	  RandomAccessIterator1 res =
-	    __gnu_parallel::find_template(begin1, end1, begin2, pred,
+	  _RAIter1 __res =
+	    __gnu_parallel::__find_template(__begin1, __end1, __begin2, __pred,
 					  __gnu_parallel::
-					  mismatch_selector()).first;
-	  return make_pair(res , begin2 + (res - begin1));
+					  __mismatch_selector()).first;
+	  return make_pair(__res , __begin2 + (__res - __begin1));
 	}
       else
-	return _GLIBCXX_STD_P::mismatch(begin1, end1, begin2, pred);
+	return _GLIBCXX_STD_P::mismatch(__begin1, __end1, __begin2, __pred);
     }
 
   // Public interface
-  template<typename InputIterator1, typename InputIterator2>
-    inline pair<InputIterator1, InputIterator2>
-    mismatch(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2)
+  template<typename _IIter1, typename _IIter2>
+    inline pair<_IIter1, _IIter2>
+    mismatch(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2)
     {
-      typedef std::iterator_traits<InputIterator1> iterator1_traits;
-      typedef std::iterator_traits<InputIterator2> iterator2_traits;
-      typedef typename iterator1_traits::value_type value1_type;
-      typedef typename iterator2_traits::value_type value2_type;
-      typedef typename iterator1_traits::iterator_category iterator1_category;
-      typedef typename iterator2_traits::iterator_category iterator2_category;
+      typedef std::iterator_traits<_IIter1> iterator1_traits;
+      typedef std::iterator_traits<_IIter2> iterator2_traits;
+      typedef typename iterator1_traits::value_type _ValueType1;
+      typedef typename iterator2_traits::value_type _ValueType2;
+      typedef typename iterator1_traits::iterator_category _IteratorCategory1;
+      typedef typename iterator2_traits::iterator_category _IteratorCategory2;
 
-      typedef __gnu_parallel::equal_to<value1_type, value2_type> equal_to_type;
+      typedef __gnu_parallel::equal_to<_ValueType1, _ValueType2> equal_to_type;
 
-      return mismatch_switch(begin1, end1, begin2, equal_to_type(),
-			     iterator1_category(), iterator2_category());
+      return __mismatch_switch(__begin1, __end1, __begin2, equal_to_type(),
+			     _IteratorCategory1(), _IteratorCategory2());
     }
 
   // Public interface
-  template<typename InputIterator1, typename InputIterator2,
-	   typename Predicate>
-    inline pair<InputIterator1, InputIterator2>
-    mismatch(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2,
-	     Predicate pred)
+  template<typename _IIter1, typename _IIter2,
+	   typename _Predicate>
+    inline pair<_IIter1, _IIter2>
+    mismatch(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2,
+	     _Predicate __pred)
     {
-      typedef std::iterator_traits<InputIterator1> iterator1_traits;
-      typedef std::iterator_traits<InputIterator2> iterator2_traits;
-      typedef typename iterator1_traits::iterator_category iterator1_category;
-      typedef typename iterator2_traits::iterator_category iterator2_category;
+      typedef std::iterator_traits<_IIter1> iterator1_traits;
+      typedef std::iterator_traits<_IIter2> iterator2_traits;
+      typedef typename iterator1_traits::iterator_category _IteratorCategory1;
+      typedef typename iterator2_traits::iterator_category _IteratorCategory2;
 
-      return mismatch_switch(begin1, end1, begin2, pred, iterator1_category(), 
-			     iterator2_category());
+      return __mismatch_switch(__begin1, __end1, __begin2, __pred, _IteratorCategory1(), 
+			     _IteratorCategory2());
     }
 
   // Sequential fallback
-  template<typename InputIterator1, typename InputIterator2>
+  template<typename _IIter1, typename _IIter2>
     inline bool
-    equal(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, 
+    equal(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, 
 	  __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::equal(begin1, end1, begin2); }
+    { return _GLIBCXX_STD_P::equal(__begin1, __end1, __begin2); }
 
   // Sequential fallback
-  template<typename InputIterator1, typename InputIterator2,
-	   typename Predicate>
+  template<typename _IIter1, typename _IIter2,
+	   typename _Predicate>
     inline bool
-    equal(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, 
-	  Predicate pred, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::equal(begin1, end1, begin2, pred); }
+    equal(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, 
+	  _Predicate __pred, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::equal(__begin1, __end1, __begin2, __pred); }
 
   // Public interface
-  template<typename InputIterator1, typename InputIterator2>
+  template<typename _IIter1, typename _IIter2>
     inline bool
-    equal(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2)
-    { return mismatch(begin1, end1, begin2).first == end1; }
+    equal(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2)
+    { return mismatch(__begin1, __end1, __begin2).first == __end1; }
 
   // Public interface
-  template<typename InputIterator1, typename InputIterator2,
-	   typename Predicate>
+  template<typename _IIter1, typename _IIter2,
+	   typename _Predicate>
     inline bool
-    equal(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, 
-	  Predicate pred)
-    { return mismatch(begin1, end1, begin2, pred).first == end1; }
+    equal(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, 
+	  _Predicate __pred)
+    { return mismatch(__begin1, __end1, __begin2, __pred).first == __end1; }
 
   // Sequential fallback
-  template<typename InputIterator1, typename InputIterator2>
+  template<typename _IIter1, typename _IIter2>
     inline bool
-    lexicographical_compare(InputIterator1 begin1, InputIterator1 end1, 
-			    InputIterator2 begin2, InputIterator2 end2, 
+    lexicographical_compare(_IIter1 __begin1, _IIter1 __end1, 
+			    _IIter2 __begin2, _IIter2 __end2, 
 			    __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1,
-						     begin2, end2); }
+    { return _GLIBCXX_STD_P::lexicographical_compare(__begin1, __end1,
+						     __begin2, __end2); }
 
   // Sequential fallback
-  template<typename InputIterator1, typename InputIterator2,
-	   typename Predicate>
+  template<typename _IIter1, typename _IIter2,
+	   typename _Predicate>
     inline bool
-    lexicographical_compare(InputIterator1 begin1, InputIterator1 end1, 
-			    InputIterator2 begin2, InputIterator2 end2, 
-			    Predicate pred, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1, 
-						     begin2, end2, pred); }
+    lexicographical_compare(_IIter1 __begin1, _IIter1 __end1, 
+			    _IIter2 __begin2, _IIter2 __end2, 
+			    _Predicate __pred, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::lexicographical_compare(__begin1, __end1, 
+						     __begin2, __end2, __pred); }
 
   // Sequential fallback for input iterator case
-  template<typename InputIterator1, typename InputIterator2,
-	   typename Predicate, typename IteratorTag1, typename IteratorTag2>
+  template<typename _IIter1, typename _IIter2,
+	   typename _Predicate, typename _IteratorTag1, typename _IteratorTag2>
     inline bool
-    lexicographical_compare_switch(InputIterator1 begin1, InputIterator1 end1, 
-				   InputIterator2 begin2, InputIterator2 end2, 
-				   Predicate pred, IteratorTag1, IteratorTag2)
-    { return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1, 
-						     begin2, end2, pred); }
+    __lexicographical_compare_switch(_IIter1 __begin1, _IIter1 __end1, 
+				   _IIter2 __begin2, _IIter2 __end2, 
+				   _Predicate __pred, _IteratorTag1, _IteratorTag2)
+    { return _GLIBCXX_STD_P::lexicographical_compare(__begin1, __end1, 
+						     __begin2, __end2, __pred); }
 
   // Parallel lexicographical_compare for random access iterators
   // Limitation: Both valuetypes must be the same
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-	   typename Predicate>
+  template<typename _RAIter1, typename _RAIter2,
+	   typename _Predicate>
     bool
-    lexicographical_compare_switch(RandomAccessIterator1 begin1, 
-				   RandomAccessIterator1 end1, 
-				   RandomAccessIterator2 begin2, 
-				   RandomAccessIterator2 end2, Predicate pred, 
+    __lexicographical_compare_switch(_RAIter1 __begin1, 
+				   _RAIter1 __end1, 
+				   _RAIter2 __begin2, 
+				   _RAIter2 __end2, _Predicate __pred, 
 				   random_access_iterator_tag, 
 				   random_access_iterator_tag)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(true))
 	{
-	  typedef iterator_traits<RandomAccessIterator1> traits1_type;
-	  typedef typename traits1_type::value_type value1_type;
+	  typedef iterator_traits<_RAIter1> _TraitsType1;
+	  typedef typename _TraitsType1::value_type _ValueType1;
 
-	  typedef iterator_traits<RandomAccessIterator2> traits2_type;
-	  typedef typename traits2_type::value_type value2_type;
+	  typedef iterator_traits<_RAIter2> _TraitsType2;
+	  typedef typename _TraitsType2::value_type _ValueType2;
 
-	  typedef __gnu_parallel::equal_from_less<Predicate, value1_type,
-	                                          value2_type> equal_type;
+	  typedef __gnu_parallel::_EqualFromLess<_Predicate, _ValueType1,
+	                                          _ValueType2> _EqualFromLessCompare;
 
 	  // Longer sequence in first place.
-	  if ((end1 - begin1) < (end2 - begin2))
+	  if ((__end1 - __begin1) < (__end2 - __begin2))
 	    {
-	      typedef pair<RandomAccessIterator1, RandomAccessIterator2>
-		pair_type;
-	      pair_type mm = mismatch_switch(begin1, end1, begin2, 
-					     equal_type(pred), 
+	      typedef pair<_RAIter1, _RAIter2>
+		_SpotType;
+	      _SpotType __mm = __mismatch_switch(__begin1, __end1, __begin2, 
+					     _EqualFromLessCompare(__pred), 
 					     random_access_iterator_tag(), 
 					     random_access_iterator_tag());
 
-	      return (mm.first == end1) || bool(pred(*mm.first, *mm.second));
+	      return (__mm.first == __end1) || bool(__pred(*__mm.first, *__mm.second));
 	    }
 	  else
 	    {
-	      typedef pair<RandomAccessIterator2, RandomAccessIterator1>
-		pair_type;
-	      pair_type mm = mismatch_switch(begin2, end2, begin1, 
-					     equal_type(pred), 
+	      typedef pair<_RAIter2, _RAIter1>
+		_SpotType;
+	      _SpotType __mm = __mismatch_switch(__begin2, __end2, __begin1, 
+					     _EqualFromLessCompare(__pred), 
 					     random_access_iterator_tag(), 
 					     random_access_iterator_tag());
 
-	      return (mm.first != end2) && bool(pred(*mm.second, *mm.first));
+	      return (__mm.first != __end2) && bool(__pred(*__mm.second, *__mm.first));
 	    }
 	}
       else
-	return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1,
-						       begin2, end2, pred);
+	return _GLIBCXX_STD_P::lexicographical_compare(__begin1, __end1,
+						       __begin2, __end2, __pred);
     }
 
   // Public interface
-  template<typename InputIterator1, typename InputIterator2>
+  template<typename _IIter1, typename _IIter2>
     inline bool
-    lexicographical_compare(InputIterator1 begin1, InputIterator1 end1,
-			    InputIterator2 begin2, InputIterator2 end2)
+    lexicographical_compare(_IIter1 __begin1, _IIter1 __end1,
+			    _IIter2 __begin2, _IIter2 __end2)
     {
-      typedef iterator_traits<InputIterator1> traits1_type;
-      typedef typename traits1_type::value_type value1_type;
-      typedef typename traits1_type::iterator_category iterator1_category;
-
-      typedef iterator_traits<InputIterator2> traits2_type;
-      typedef typename traits2_type::value_type value2_type;
-      typedef typename traits2_type::iterator_category iterator2_category;
-      typedef __gnu_parallel::less<value1_type, value2_type> less_type;
-
-      return lexicographical_compare_switch(begin1, end1, begin2, end2, 
-					    less_type(), iterator1_category(), 
-					    iterator2_category());
+      typedef iterator_traits<_IIter1> _TraitsType1;
+      typedef typename _TraitsType1::value_type _ValueType1;
+      typedef typename _TraitsType1::iterator_category _IteratorCategory1;
+
+      typedef iterator_traits<_IIter2> _TraitsType2;
+      typedef typename _TraitsType2::value_type _ValueType2;
+      typedef typename _TraitsType2::iterator_category _IteratorCategory2;
+      typedef __gnu_parallel::_Less<_ValueType1, _ValueType2> _LessType;
+
+      return __lexicographical_compare_switch(__begin1, __end1, __begin2, __end2, 
+					    _LessType(), _IteratorCategory1(), 
+					    _IteratorCategory2());
     }
 
   // Public interface
-  template<typename InputIterator1, typename InputIterator2,
-	   typename Predicate>
+  template<typename _IIter1, typename _IIter2,
+	   typename _Predicate>
     inline bool
-    lexicographical_compare(InputIterator1 begin1, InputIterator1 end1,
-			    InputIterator2 begin2, InputIterator2 end2,
-			    Predicate pred)
+    lexicographical_compare(_IIter1 __begin1, _IIter1 __end1,
+			    _IIter2 __begin2, _IIter2 __end2,
+			    _Predicate __pred)
     {
-      typedef iterator_traits<InputIterator1> traits1_type;
-      typedef typename traits1_type::iterator_category iterator1_category;
+      typedef iterator_traits<_IIter1> _TraitsType1;
+      typedef typename _TraitsType1::iterator_category _IteratorCategory1;
 
-      typedef iterator_traits<InputIterator2> traits2_type;
-      typedef typename traits2_type::iterator_category iterator2_category;
+      typedef iterator_traits<_IIter2> _TraitsType2;
+      typedef typename _TraitsType2::iterator_category _IteratorCategory2;
 
-      return lexicographical_compare_switch(begin1, end1, begin2, end2, pred, 
-					    iterator1_category(), 
-					    iterator2_category());
+      return __lexicographical_compare_switch(__begin1, __end1, __begin2, __end2, __pred, 
+					    _IteratorCategory1(), 
+					    _IteratorCategory2());
     }
 } // end namespace
 } // end namespace
diff --git a/libstdc++-v3/include/parallel/algorithmfwd.h b/libstdc++-v3/include/parallel/algorithmfwd.h
index 7c3b3f2..c85959e 100644
--- a/libstdc++-v3/include/parallel/algorithmfwd.h
+++ b/libstdc++-v3/include/parallel/algorithmfwd.h
@@ -48,11 +48,11 @@ namespace __parallel
 
   template<typename _FIter, typename _IterTag>
     _FIter
-    adjacent_find_switch(_FIter, _FIter, _IterTag);
+    __adjacent_find_switch(_FIter, _FIter, _IterTag);
 
   template<typename _RAIter>
     _RAIter
-    adjacent_find_switch(_RAIter, _RAIter, random_access_iterator_tag);
+    __adjacent_find_switch(_RAIter, _RAIter, random_access_iterator_tag);
 
 
   template<typename _FIter, typename _BiPredicate>
@@ -66,11 +66,11 @@ namespace __parallel
 
   template<typename _FIter, typename _BiPredicate, typename _IterTag>
     _FIter
-    adjacent_find_switch(_FIter, _FIter, _BiPredicate, _IterTag);
+    __adjacent_find_switch(_FIter, _FIter, _BiPredicate, _IterTag);
 
   template<typename _RAIter, typename _BiPredicate>
     _RAIter
-    adjacent_find_switch(_RAIter, _RAIter, _BiPredicate, 
+    __adjacent_find_switch(_RAIter, _RAIter, _BiPredicate, 
 			 random_access_iterator_tag);
 
 
@@ -88,12 +88,12 @@ namespace __parallel
 
   template<typename _IIter, typename _Tp, typename _IterTag>
     typename iterator_traits<_IIter>::difference_type
-    count_switch(_IIter, _IIter, const _Tp&, _IterTag);
+    __count_switch(_IIter, _IIter, const _Tp&, _IterTag);
 
   template<typename _RAIter, typename _Tp>
     typename iterator_traits<_RAIter>::difference_type
-    count_switch(_RAIter, _RAIter, const _Tp&, random_access_iterator_tag,
-		 __gnu_parallel::_Parallelism parallelism
+    __count_switch(_RAIter, _RAIter, const _Tp&, random_access_iterator_tag,
+		 __gnu_parallel::_Parallelism __parallelism
 		 = __gnu_parallel::parallel_unbalanced);
 
 
@@ -111,12 +111,12 @@ namespace __parallel
 
   template<typename _IIter, typename _Predicate, typename _IterTag>
     typename iterator_traits<_IIter>::difference_type
-    count_if_switch(_IIter, _IIter, _Predicate, _IterTag);
+    __count_if_switch(_IIter, _IIter, _Predicate, _IterTag);
 
   template<typename _RAIter, typename _Predicate>
     typename iterator_traits<_RAIter>::difference_type
-    count_if_switch(_RAIter, _RAIter, _Predicate, random_access_iterator_tag,
-		    __gnu_parallel::_Parallelism parallelism
+    __count_if_switch(_RAIter, _RAIter, _Predicate, random_access_iterator_tag,
+		    __gnu_parallel::_Parallelism __parallelism
 		    = __gnu_parallel::parallel_unbalanced);
 
   // algobase.h
@@ -124,18 +124,18 @@ namespace __parallel
     bool
     equal(_IIter1, _IIter1, _IIter2, __gnu_parallel::sequential_tag);
 
-  template<typename _IIter1, typename _IIter2, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _Predicate>
     bool
-    equal(_IIter1, _IIter1, _IIter2, Predicate,
+    equal(_IIter1, _IIter1, _IIter2, _Predicate,
 	  __gnu_parallel::sequential_tag);
 
   template<typename _IIter1, typename _IIter2>
     bool
     equal(_IIter1, _IIter1, _IIter2);
 
-  template<typename _IIter1, typename _IIter2, typename Predicate>
+  template<typename _IIter1, typename _IIter2, typename _Predicate>
     bool
-    equal(_IIter1, _IIter1, _IIter2, Predicate);
+    equal(_IIter1, _IIter1, _IIter2, _Predicate);
 
   template<typename _IIter, typename _Tp>
     _IIter
@@ -143,15 +143,15 @@ namespace __parallel
 
   template<typename _IIter, typename _Tp>
     _IIter
-    find(_IIter, _IIter, const _Tp& val);
+    find(_IIter, _IIter, const _Tp& __val);
 
   template<typename _IIter, typename _Tp, typename _IterTag>
     _IIter
-    find_switch(_IIter, _IIter, const _Tp&, _IterTag);
+    __find_switch(_IIter, _IIter, const _Tp&, _IterTag);
 
   template<typename _RAIter, typename _Tp>
     _RAIter
-    find_switch(_RAIter, _RAIter, const _Tp&, random_access_iterator_tag);
+    __find_switch(_RAIter, _RAIter, const _Tp&, random_access_iterator_tag);
 
   template<typename _IIter, typename _Predicate>
     _IIter
@@ -163,11 +163,11 @@ namespace __parallel
 
   template<typename _IIter, typename _Predicate, typename _IterTag>
     _IIter
-    find_if_switch(_IIter, _IIter, _Predicate, _IterTag);
+    __find_if_switch(_IIter, _IIter, _Predicate, _IterTag);
 
   template<typename _RAIter, typename _Predicate>
     _RAIter
-    find_if_switch(_RAIter, _RAIter, _Predicate, random_access_iterator_tag);
+    __find_if_switch(_RAIter, _RAIter, _Predicate, random_access_iterator_tag);
 
   template<typename _IIter, typename _FIter>
     _IIter
@@ -190,18 +190,18 @@ namespace __parallel
   template<typename _IIter, typename _FIter,
 	   typename _IterTag1, typename _IterTag2>
     _IIter
-    find_first_of_switch(_IIter, _IIter, _FIter, _FIter, _IterTag1, _IterTag2);
+    __find_first_of_switch(_IIter, _IIter, _FIter, _FIter, _IterTag1, _IterTag2);
 
   template<typename _RAIter, typename _FIter, typename _BiPredicate,
 	   typename _IterTag>
     _RAIter
-    find_first_of_switch(_RAIter, _RAIter, _FIter, _FIter, _BiPredicate,
+    __find_first_of_switch(_RAIter, _RAIter, _FIter, _FIter, _BiPredicate,
 			 random_access_iterator_tag, _IterTag);
 
   template<typename _IIter, typename _FIter, typename _BiPredicate,
 	   typename _IterTag1, typename _IterTag2>
     _IIter
-    find_first_of_switch(_IIter, _IIter, _FIter, _FIter, _BiPredicate,
+    __find_first_of_switch(_IIter, _IIter, _FIter, _FIter, _BiPredicate,
 			 _IterTag1, _IterTag2);
 
 
@@ -219,12 +219,12 @@ namespace __parallel
 
   template<typename _IIter, typename _Function, typename _IterTag>
     _Function
-    for_each_switch(_IIter, _IIter, _Function, _IterTag);
+    __for_each_switch(_IIter, _IIter, _Function, _IterTag);
 
   template<typename _RAIter, typename _Function>
     _Function
-    for_each_switch(_RAIter, _RAIter, _Function, random_access_iterator_tag, 
-		    __gnu_parallel::_Parallelism  parallelism
+    __for_each_switch(_RAIter, _RAIter, _Function, random_access_iterator_tag, 
+		    __gnu_parallel::_Parallelism  __parallelism
 		    = __gnu_parallel::parallel_balanced);
 
 
@@ -242,12 +242,12 @@ namespace __parallel
 
   template<typename _FIter, typename _Generator, typename _IterTag>
     void
-    generate_switch(_FIter, _FIter, _Generator, _IterTag);
+    __generate_switch(_FIter, _FIter, _Generator, _IterTag);
 
   template<typename _RAIter, typename _Generator>
     void
-    generate_switch(_RAIter, _RAIter, _Generator, random_access_iterator_tag, 
-		    __gnu_parallel::_Parallelism parallelism
+    __generate_switch(_RAIter, _RAIter, _Generator, random_access_iterator_tag, 
+		    __gnu_parallel::_Parallelism __parallelism
 		    = __gnu_parallel::parallel_balanced);
 
   template<typename _OIter, typename _Size, typename _Generator>
@@ -265,12 +265,12 @@ namespace __parallel
   template<typename _OIter, typename _Size, typename _Generator,
 	   typename _IterTag>
     _OIter
-    generate_n_switch(_OIter, _Size, _Generator, _IterTag);
+    __generate_n_switch(_OIter, _Size, _Generator, _IterTag);
 
   template<typename _RAIter, typename _Size, typename _Generator>
     _RAIter
-    generate_n_switch(_RAIter, _Size, _Generator, random_access_iterator_tag, 
-		      __gnu_parallel::_Parallelism parallelism
+    __generate_n_switch(_RAIter, _Size, _Generator, random_access_iterator_tag, 
+		      __gnu_parallel::_Parallelism __parallelism
 		      = __gnu_parallel::parallel_balanced);
 
   template<typename _IIter1, typename _IIter2>
@@ -294,12 +294,12 @@ namespace __parallel
   template<typename _IIter1, typename _IIter2,
 	   typename _Predicate, typename _IterTag1, typename _IterTag2>
     bool
-    lexicographical_compare_switch(_IIter1, _IIter1, _IIter2, _IIter2,
+    __lexicographical_compare_switch(_IIter1, _IIter1, _IIter2, _IIter2,
 				   _Predicate, _IterTag1, _IterTag2);
 
   template<typename _RAIter1, typename _RAIter2, typename _Predicate>
     bool
-    lexicographical_compare_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
+    __lexicographical_compare_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
 				   _Predicate, random_access_iterator_tag,
 				   random_access_iterator_tag);
 
@@ -324,12 +324,12 @@ namespace __parallel
   template<typename _IIter1, typename _IIter2, typename _Predicate,
 	   typename _IterTag1, typename _IterTag2>
     pair<_IIter1, _IIter2>
-    mismatch_switch(_IIter1, _IIter1, _IIter2, _Predicate,
+    __mismatch_switch(_IIter1, _IIter1, _IIter2, _Predicate,
 		    _IterTag1, _IterTag2);
 
   template<typename _RAIter1, typename _RAIter2, typename _Predicate>
     pair<_RAIter1, _RAIter2>
-    mismatch_switch(_RAIter1, _RAIter1, _RAIter2, _Predicate,
+    __mismatch_switch(_RAIter1, _RAIter1, _RAIter2, _Predicate,
 		    random_access_iterator_tag, random_access_iterator_tag);
 
   template<typename _FIter1, typename _FIter2>
@@ -351,23 +351,23 @@ namespace __parallel
 
   template<typename _RAIter1, typename _RAIter2>
     _RAIter1
-    search_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
+    __search_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
 		  random_access_iterator_tag, random_access_iterator_tag);
 
   template<typename _FIter1, typename _FIter2, typename _IterTag1,
 	   typename _IterTag2>
     _FIter1
-    search_switch(_FIter1, _FIter1, _FIter2, _FIter2, _IterTag1, _IterTag2);
+    __search_switch(_FIter1, _FIter1, _FIter2, _FIter2, _IterTag1, _IterTag2);
 
   template<typename _RAIter1, typename _RAIter2, typename _BiPredicate>
     _RAIter1
-    search_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, _BiPredicate,
+    __search_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, _BiPredicate,
 		  random_access_iterator_tag, random_access_iterator_tag);
 
   template<typename _FIter1, typename _FIter2, typename _BiPredicate,
 	   typename _IterTag1, typename _IterTag2>
     _FIter1
-    search_switch(_FIter1, _FIter1, _FIter2, _FIter2, _BiPredicate,
+    __search_switch(_FIter1, _FIter1, _FIter2, _FIter2, _BiPredicate,
 		  _IterTag1, _IterTag2);
 
   template<typename _FIter, typename _Integer, typename _Tp>
@@ -393,42 +393,42 @@ namespace __parallel
   template<typename _RAIter, typename _Integer, typename _Tp,
 	   typename _BiPredicate>
     _RAIter
-    search_n_switch(_RAIter, _RAIter, _Integer, const _Tp&,
+    __search_n_switch(_RAIter, _RAIter, _Integer, const _Tp&,
 		    _BiPredicate, random_access_iterator_tag);
 
   template<typename _FIter, typename _Integer, typename _Tp,
 	   typename _BiPredicate, typename _IterTag>
     _FIter
-    search_n_switch(_FIter, _FIter, _Integer, const _Tp&,
+    __search_n_switch(_FIter, _FIter, _Integer, const _Tp&,
 		    _BiPredicate, _IterTag);
 
 
-  template<typename _IIter, typename _OIter, typename UnaryOperation>
+  template<typename _IIter, typename _OIter, typename _UnaryOperation>
     _OIter
-    transform(_IIter, _IIter, _OIter, UnaryOperation);
+    transform(_IIter, _IIter, _OIter, _UnaryOperation);
 
-  template<typename _IIter, typename _OIter, typename UnaryOperation>
+  template<typename _IIter, typename _OIter, typename _UnaryOperation>
     _OIter
-    transform(_IIter, _IIter, _OIter, UnaryOperation, 
+    transform(_IIter, _IIter, _OIter, _UnaryOperation, 
 	      __gnu_parallel::sequential_tag);
 
-  template<typename _IIter, typename _OIter, typename UnaryOperation>
+  template<typename _IIter, typename _OIter, typename _UnaryOperation>
     _OIter
-    transform(_IIter, _IIter, _OIter, UnaryOperation, 
+    transform(_IIter, _IIter, _OIter, _UnaryOperation, 
 	      __gnu_parallel::_Parallelism);
 
-  template<typename _IIter, typename _OIter, typename UnaryOperation,
+  template<typename _IIter, typename _OIter, typename _UnaryOperation,
 	   typename _IterTag1, typename _IterTag2>
     _OIter
-    transform1_switch(_IIter, _IIter, _OIter, UnaryOperation, 
+    __transform1_switch(_IIter, _IIter, _OIter, _UnaryOperation, 
 		      _IterTag1, _IterTag2);
     
 
-  template<typename _RAIIter, typename _RAOIter, typename UnaryOperation>
+  template<typename _RAIIter, typename _RAOIter, typename _UnaryOperation>
     _RAOIter
-    transform1_switch(_RAIIter, _RAIIter, _RAOIter, UnaryOperation, 
+    __transform1_switch(_RAIIter, _RAIIter, _RAOIter, _UnaryOperation, 
 		      random_access_iterator_tag, random_access_iterator_tag, 
-		      __gnu_parallel::_Parallelism parallelism
+		      __gnu_parallel::_Parallelism __parallelism
 		      = __gnu_parallel::parallel_balanced);
 
 
@@ -452,17 +452,17 @@ namespace __parallel
   template<typename _RAIter1, typename _RAIter2, typename _RAIter3,
 	   typename _BiOperation>
     _RAIter3
-    transform2_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter3, _BiOperation, 
+    __transform2_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter3, _BiOperation, 
 		      random_access_iterator_tag, random_access_iterator_tag, 
 		      random_access_iterator_tag,
-		      __gnu_parallel::_Parallelism parallelism
+		      __gnu_parallel::_Parallelism __parallelism
 		      = __gnu_parallel::parallel_balanced);
 
   template<typename _IIter1, typename _IIter2, typename _OIter,
 	   typename _BiOperation, typename _Tag1,
 	   typename _Tag2, typename _Tag3>
     _OIter
-    transform2_switch(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation, 
+    __transform2_switch(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation, 
 		      _Tag1, _Tag2, _Tag3);
 
 
@@ -482,11 +482,11 @@ namespace __parallel
 
   template<typename _FIter, typename _Tp, typename _IterTag>
     void
-    replace_switch(_FIter, _FIter, const _Tp&, const _Tp&, _IterTag);
+    __replace_switch(_FIter, _FIter, const _Tp&, const _Tp&, _IterTag);
 
   template<typename _RAIter, typename _Tp>
     void
-    replace_switch(_RAIter, _RAIter, const _Tp&, const _Tp&, 
+    __replace_switch(_RAIter, _RAIter, const _Tp&, const _Tp&, 
 		   random_access_iterator_tag, __gnu_parallel::_Parallelism);
 
 
@@ -507,11 +507,11 @@ namespace __parallel
   template<typename _FIter, typename _Predicate, typename _Tp,
 	   typename _IterTag>
     void
-    replace_if_switch(_FIter, _FIter, _Predicate, const _Tp&, _IterTag);
+    __replace_if_switch(_FIter, _FIter, _Predicate, const _Tp&, _IterTag);
  
   template<typename _RAIter, typename _Predicate, typename _Tp>
     void
-    replace_if_switch(_RAIter, _RAIter, _Predicate, const _Tp&,
+    __replace_if_switch(_RAIter, _RAIter, _Predicate, const _Tp&,
 		      random_access_iterator_tag,
 		      __gnu_parallel::_Parallelism);
 
@@ -542,12 +542,12 @@ namespace __parallel
 
   template<typename _FIter, typename _Compare, typename _IterTag>
     _FIter
-    max_element_switch(_FIter, _FIter, _Compare, _IterTag);
+    __max_element_switch(_FIter, _FIter, _Compare, _IterTag);
 
   template<typename _RAIter, typename _Compare>
     _RAIter
-    max_element_switch(_RAIter, _RAIter, _Compare, random_access_iterator_tag, 
-		       __gnu_parallel::_Parallelism parallelism
+    __max_element_switch(_RAIter, _RAIter, _Compare, random_access_iterator_tag, 
+		       __gnu_parallel::_Parallelism __parallelism
 		       = __gnu_parallel::parallel_balanced);
 
 
@@ -575,13 +575,13 @@ namespace __parallel
 	   typename _Compare, typename _IterTag1, typename _IterTag2,
 	   typename _IterTag3>
     _OIter
-    merge_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare, 
+    __merge_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare, 
 		 _IterTag1, _IterTag2, _IterTag3);
 
   template<typename _IIter1, typename _IIter2, typename _OIter,
 	   typename _Compare>
     _OIter
-    merge_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare, 
+    __merge_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare, 
 		 random_access_iterator_tag, random_access_iterator_tag, 
 		 random_access_iterator_tag);
 
@@ -596,7 +596,7 @@ namespace __parallel
 
   template<typename _FIter>
     _FIter
-    min_element(_FIter, _FIter, __gnu_parallel::_Parallelism parallelism_tag);
+    min_element(_FIter, _FIter, __gnu_parallel::_Parallelism __parallelism_tag);
 
   template<typename _FIter, typename _Compare>
     _FIter
@@ -612,12 +612,12 @@ namespace __parallel
 
   template<typename _FIter, typename _Compare, typename _IterTag>
     _FIter
-    min_element_switch(_FIter, _FIter, _Compare, _IterTag);
+    __min_element_switch(_FIter, _FIter, _Compare, _IterTag);
 
   template<typename _RAIter, typename _Compare>
     _RAIter
-    min_element_switch(_RAIter, _RAIter, _Compare, random_access_iterator_tag, 
-		       __gnu_parallel::_Parallelism parallelism
+    __min_element_switch(_RAIter, _RAIter, _Compare, random_access_iterator_tag, 
+		       __gnu_parallel::_Parallelism __parallelism
 		       = __gnu_parallel::parallel_balanced);
 
   template<typename _RAIter>
@@ -654,21 +654,21 @@ namespace __parallel
     void
     partial_sort(_RAIter, _RAIter, _RAIter);
 
-  template<typename _FIter, typename Predicate>
+  template<typename _FIter, typename _Predicate>
     _FIter
-    partition(_FIter, _FIter, Predicate, __gnu_parallel::sequential_tag);
+    partition(_FIter, _FIter, _Predicate, __gnu_parallel::sequential_tag);
     
-  template<typename _FIter, typename Predicate>
+  template<typename _FIter, typename _Predicate>
     _FIter
-    partition(_FIter, _FIter, Predicate);
+    partition(_FIter, _FIter, _Predicate);
 
-  template<typename _FIter, typename Predicate, typename _IterTag>
+  template<typename _FIter, typename _Predicate, typename _IterTag>
     _FIter
-    partition_switch(_FIter, _FIter, Predicate, _IterTag);
+    __partition_switch(_FIter, _FIter, _Predicate, _IterTag);
     
-  template<typename _RAIter, typename Predicate>
+  template<typename _RAIter, typename _Predicate>
     _RAIter
-    partition_switch(_RAIter, _RAIter, Predicate, random_access_iterator_tag);
+    __partition_switch(_RAIter, _RAIter, _Predicate, random_access_iterator_tag);
 
   template<typename _RAIter>
     void
@@ -693,9 +693,9 @@ namespace __parallel
 	    __gnu_parallel::sequential_tag);
 
   template<typename _IIter1, typename _IIter2, typename _OIter,
-	   typename Predicate>
+	   typename _Predicate>
     _OIter
-    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate,
+    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate,
 	      __gnu_parallel::sequential_tag);
 
   template<typename _IIter1, typename _IIter2, typename _OIter>
@@ -711,13 +711,13 @@ namespace __parallel
 	   typename _OIter, typename _IterTag1, typename _IterTag2,
 	   typename _IterTag3>
     _OIter
-    set_union_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+    __set_union_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
 		     _Predicate, _IterTag1, _IterTag2, _IterTag3);
 
   template<typename _RAIter1, typename _RAIter2, typename _Output_RAIter,
 	   typename _Predicate>
     _Output_RAIter
-    set_union_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, _Output_RAIter,
+    __set_union_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, _Output_RAIter,
 		     _Predicate, random_access_iterator_tag,
 		     random_access_iterator_tag, random_access_iterator_tag);
 
@@ -745,13 +745,13 @@ namespace __parallel
 	   typename _OIter, typename _IterTag1, typename _IterTag2,
 	   typename _IterTag3>
     _OIter
-    set_intersection_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+    __set_intersection_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
 			    _Predicate, _IterTag1, _IterTag2, _IterTag3);
 
   template<typename _RAIter1, typename _RAIter2, typename _Output_RAIter,
 	   typename _Predicate>
     _Output_RAIter
-    set_intersection_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
+    __set_intersection_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
 			    _Output_RAIter, _Predicate,
 			    random_access_iterator_tag,
 			    random_access_iterator_tag,
@@ -782,14 +782,14 @@ namespace __parallel
 	   typename _OIter, typename _IterTag1, typename _IterTag2,
 	   typename _IterTag3>
     _OIter
-    set_symmetric_difference_switch(_IIter1, _IIter1, _IIter2, _IIter2,
+    __set_symmetric_difference_switch(_IIter1, _IIter1, _IIter2, _IIter2,
 				    _OIter, _Predicate, _IterTag1, _IterTag2,
 				    _IterTag3);
 
   template<typename _RAIter1, typename _RAIter2, typename _Output_RAIter,
 	   typename _Predicate>
     _Output_RAIter
-    set_symmetric_difference_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
+    __set_symmetric_difference_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
 				    _Output_RAIter, _Predicate,
 				    random_access_iterator_tag,
 				    random_access_iterator_tag,
@@ -820,13 +820,13 @@ namespace __parallel
 	   typename _OIter, typename _IterTag1, typename _IterTag2,
 	   typename _IterTag3>
     _OIter
-    set_difference_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
+    __set_difference_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
 			  _Predicate, _IterTag1, _IterTag2, _IterTag3);
 
   template<typename _RAIter1, typename _RAIter2, typename _Output_RAIter,
 	   typename _Predicate>
     _Output_RAIter
-    set_difference_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
+    __set_difference_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
 			  _Output_RAIter, _Predicate,
 			  random_access_iterator_tag,
 			  random_access_iterator_tag,
@@ -885,12 +885,12 @@ namespace __parallel
   template<typename _IIter, typename _OIter, typename _Predicate,
 	   typename _IterTag1, typename _IterTag2>
     _OIter
-    unique_copy_switch(_IIter, _IIter, _OIter, _Predicate,
+    __unique_copy_switch(_IIter, _IIter, _OIter, _Predicate,
 		       _IterTag1, _IterTag2);
 
   template<typename _RAIter, typename _RandomAccess_OIter, typename _Predicate>
     _RandomAccess_OIter
-    unique_copy_switch(_RAIter, _RAIter, _RandomAccess_OIter, _Predicate,
+    __unique_copy_switch(_RAIter, _RAIter, _RandomAccess_OIter, _Predicate,
 		       random_access_iterator_tag, random_access_iterator_tag);
 } // end namespace __parallel
 } // end namespace std
diff --git a/libstdc++-v3/include/parallel/balanced_quicksort.h b/libstdc++-v3/include/parallel/balanced_quicksort.h
index 2310110..2e93914 100644
--- a/libstdc++-v3/include/parallel/balanced_quicksort.h
+++ b/libstdc++-v3/include/parallel/balanced_quicksort.h
@@ -58,171 +58,171 @@
 namespace __gnu_parallel
 {
 /** @brief Information local to one thread in the parallel quicksort run. */
-template<typename RandomAccessIterator>
-  struct QSBThreadLocal
+template<typename _RAIter>
+  struct _QSBThreadLocal
   {
-    typedef std::iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::difference_type difference_type;
+    typedef std::iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
 
     /** @brief Continuous part of the sequence, described by an
     iterator pair. */
-    typedef std::pair<RandomAccessIterator, RandomAccessIterator> Piece;
+    typedef std::pair<_RAIter, _RAIter> _Piece;
 
     /** @brief Initial piece to work on. */
-    Piece initial;
+    _Piece _M_initial;
 
     /** @brief Work-stealing queue. */
-    RestrictedBoundedConcurrentQueue<Piece> leftover_parts;
+    _RestrictedBoundedConcurrentQueue<_Piece> _M_leftover_parts;
 
     /** @brief Number of threads involved in this algorithm. */
-    thread_index_t num_threads;
+    _ThreadIndex __num_threads;
 
     /** @brief Pointer to a counter of elements left over to sort. */
-    volatile difference_type* elements_leftover;
+    volatile _DifferenceType* _M_elements_leftover;
 
     /** @brief The complete sequence to sort. */
-    Piece global;
+    _Piece _M_global;
 
     /** @brief Constructor.
-     *  @param queue_size Size of the work-stealing queue. */
-    QSBThreadLocal(int queue_size) : leftover_parts(queue_size) { }
+     *  @param __queue_size size of the work-stealing queue. */
+    _QSBThreadLocal(int __queue_size) : _M_leftover_parts(__queue_size) { }
   };
 
 /** @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
+  *  @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 RandomAccessIterator, typename Comparator>
-  typename std::iterator_traits<RandomAccessIterator>::difference_type
-  qsb_divide(RandomAccessIterator begin, RandomAccessIterator end,
-             Comparator comp, thread_index_t num_threads)
+  *  @pre @__c (__end-__begin)>=1 */
+template<typename _RAIter, typename _Compare>
+  typename std::iterator_traits<_RAIter>::difference_type
+  __qsb_divide(_RAIter __begin, _RAIter __end,
+             _Compare __comp, _ThreadIndex __num_threads)
   {
-    _GLIBCXX_PARALLEL_ASSERT(num_threads > 0);
+    _GLIBCXX_PARALLEL_ASSERT(__num_threads > 0);
 
-    typedef std::iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    typedef typename traits_type::difference_type difference_type;
+    typedef std::iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
 
-    RandomAccessIterator pivot_pos =
-      median_of_three_iterators(begin, begin + (end - begin) / 2,
-				end  - 1, comp);
+    _RAIter __pivot_pos =
+      __median_of_three_iterators(__begin, __begin + (__end - __begin) / 2,
+				__end  - 1, __comp);
 
 #if defined(_GLIBCXX_ASSERTIONS)
     // Must be in between somewhere.
-    difference_type n = end - begin;
+    _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)));
+           (!__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.
-    if (pivot_pos != (end - 1))
-      std::swap(*pivot_pos, *(end - 1));
-    pivot_pos = end - 1;
+    if (__pivot_pos != (__end - 1))
+      std::swap(*__pivot_pos, *(__end - 1));
+    __pivot_pos = __end - 1;
 
-    __gnu_parallel::binder2nd<Comparator, value_type, value_type, bool>
-        pred(comp, *pivot_pos);
+    __gnu_parallel::binder2nd<_Compare, _ValueType, _ValueType, bool>
+        __pred(__comp, *__pivot_pos);
 
-    // Divide, returning end - begin - 1 in the worst case.
-    difference_type split_pos = parallel_partition(
-        begin, end - 1, pred, num_threads);
+    // Divide, returning __end - __begin - 1 in the worst case.
+    _DifferenceType __split_pos = __parallel_partition(
+        __begin, __end - 1, __pred, __num_threads);
 
     // Swap back pivot to middle.
-    std::swap(*(begin + split_pos), *pivot_pos);
-    pivot_pos = begin + split_pos;
+    std::swap(*(__begin + __split_pos), *__pivot_pos);
+    __pivot_pos = __begin + __split_pos;
 
 #if _GLIBCXX_ASSERTIONS
-    RandomAccessIterator r;
-    for (r = begin; r != pivot_pos; ++r)
-      _GLIBCXX_PARALLEL_ASSERT(comp(*r, *pivot_pos));
-    for (; r != end; ++r)
-      _GLIBCXX_PARALLEL_ASSERT(!comp(*r, *pivot_pos));
+    _RAIter __r;
+    for (__r = __begin; __r != __pivot_pos; ++__r)
+      _GLIBCXX_PARALLEL_ASSERT(__comp(*__r, *__pivot_pos));
+    for (; __r != __end; ++__r)
+      _GLIBCXX_PARALLEL_ASSERT(!__comp(*__r, *__pivot_pos));
 #endif
 
-    return split_pos;
+    return __split_pos;
   }
 
 /** @brief Quicksort conquer step.
-  *  @param tls Array of thread-local storages.
-  *  @param begin Begin iterator of subsequence.
-  *  @param end End iterator of subsequence.
-  *  @param comp Comparator.
-  *  @param iam Number of the thread processing this function.
-  *  @param num_threads
+  *  @param __tls Array of thread-local storages.
+  *  @param __begin Begin iterator of subsequence.
+  *  @param __end End iterator of subsequence.
+  *  @param __comp Comparator.
+  *  @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 RandomAccessIterator, typename Comparator>
+template<typename _RAIter, typename _Compare>
   void
-  qsb_conquer(QSBThreadLocal<RandomAccessIterator>** tls,
-              RandomAccessIterator begin, RandomAccessIterator end,
-              Comparator comp,
-              thread_index_t iam, thread_index_t num_threads,
-              bool parent_wait)
+  __qsb_conquer(_QSBThreadLocal<_RAIter>** __tls,
+              _RAIter __begin, _RAIter __end,
+              _Compare __comp,
+              _ThreadIndex __iam, _ThreadIndex __num_threads,
+              bool __parent_wait)
   {
-    typedef std::iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    typedef typename traits_type::difference_type difference_type;
+    typedef std::iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
 
-    difference_type n = end - begin;
+    _DifferenceType __n = __end - __begin;
 
-    if (num_threads <= 1 || n <= 1)
+    if (__num_threads <= 1 || __n <= 1)
       {
-        tls[iam]->initial.first  = begin;
-        tls[iam]->initial.second = end;
+        __tls[__iam]->_M_initial.first  = __begin;
+        __tls[__iam]->_M_initial.second = __end;
 
-        qsb_local_sort_with_helping(tls, comp, iam, parent_wait);
+        __qsb_local_sort_with_helping(__tls, __comp, __iam, __parent_wait);
 
         return;
       }
 
     // Divide step.
-    difference_type split_pos = qsb_divide(begin, end, comp, num_threads);
+    _DifferenceType __split_pos = __qsb_divide(__begin, __end, __comp, __num_threads);
 
 #if _GLIBCXX_ASSERTIONS
-    _GLIBCXX_PARALLEL_ASSERT(0 <= split_pos && split_pos < (end - begin));
+    _GLIBCXX_PARALLEL_ASSERT(0 <= __split_pos && __split_pos < (__end - __begin));
 #endif
 
-    thread_index_t num_threads_leftside =
-        std::max<thread_index_t>(1, std::min<thread_index_t>(
-                          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]->elements_leftover -= (difference_type)1;
+    *__tls[__iam]->_M_elements_leftover -= (_DifferenceType)1;
 
     // Conquer step.
 #   pragma omp parallel num_threads(2)
     {
-      bool wait;
+      bool __wait;
       if(omp_get_num_threads() < 2)
-        wait = false;
+        __wait = false;
       else
-        wait = parent_wait;
+        __wait = __parent_wait;
 
 #     pragma omp sections
         {
 #         pragma omp section
             {
-              qsb_conquer(tls, begin, begin + split_pos, comp,
-                          iam,
-                          num_threads_leftside,
-                          wait);
-              wait = parent_wait;
+              __qsb_conquer(__tls, __begin, __begin + __split_pos, __comp,
+                          __iam,
+                          __num_threads_leftside,
+                          __wait);
+              __wait = __parent_wait;
             }
           // The pivot_pos is left in place, to ensure termination.
 #         pragma omp section
             {
-              qsb_conquer(tls, begin + split_pos + 1, end, comp,
-                          iam + num_threads_leftside,
-                          num_threads - num_threads_leftside,
-                          wait);
-              wait = parent_wait;
+              __qsb_conquer(__tls, __begin + __split_pos + 1, __end, __comp,
+                          __iam + __num_threads_leftside,
+                          __num_threads - __num_threads_leftside,
+                          __wait);
+              __wait = __parent_wait;
             }
         }
     }
@@ -230,175 +230,175 @@ template<typename RandomAccessIterator, typename Comparator>
 
 /**
   *  @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.
+  *  @param __tls Array of thread-local storages.
+  *  @param __comp Comparator.
+  *  @param __iam Number of the thread processing this function.
   */
-template<typename RandomAccessIterator, typename Comparator>
+template<typename _RAIter, typename _Compare>
   void
-  qsb_local_sort_with_helping(QSBThreadLocal<RandomAccessIterator>** tls,
-                              Comparator& comp, int iam, bool wait)
+  __qsb_local_sort_with_helping(_QSBThreadLocal<_RAIter>** __tls,
+                              _Compare& __comp, int __iam, bool __wait)
   {
-    typedef std::iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    typedef typename traits_type::difference_type difference_type;
-    typedef std::pair<RandomAccessIterator, RandomAccessIterator> Piece;
+    typedef std::iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
+    typedef std::pair<_RAIter, _RAIter> _Piece;
 
-    QSBThreadLocal<RandomAccessIterator>& tl = *tls[iam];
+    _QSBThreadLocal<_RAIter>& __tl = *__tls[__iam];
 
-    difference_type base_case_n =
+    _DifferenceType __base_case_n =
         _Settings::get().sort_qsb_base_case_maximal_n;
-    if (base_case_n < 2)
-      base_case_n = 2;
-    thread_index_t num_threads = tl.num_threads;
+    if (__base_case_n < 2)
+      __base_case_n = 2;
+    _ThreadIndex __num_threads = __tl.__num_threads;
 
     // Every thread has its own random number generator.
-    random_number rng(iam + 1);
+    _RandomNumber __rng(__iam + 1);
 
-    Piece current = tl.initial;
+    _Piece __current = __tl._M_initial;
 
-    difference_type elements_done = 0;
+    _DifferenceType __elements_done = 0;
 #if _GLIBCXX_ASSERTIONS
-    difference_type total_elements_done = 0;
+    _DifferenceType __total_elements_done = 0;
 #endif
 
     for (;;)
       {
-        // Invariant: current must be a valid (maybe empty) range.
-        RandomAccessIterator begin = current.first, end = current.second;
-        difference_type n = end - begin;
+        // Invariant: __current must be a valid (maybe empty) range.
+        _RAIter __begin = __current.first, __end = __current.second;
+        _DifferenceType __n = __end - __begin;
 
-        if (n > base_case_n)
+        if (__n > __base_case_n)
           {
             // Divide.
-            RandomAccessIterator pivot_pos = begin +  rng(n);
+            _RAIter __pivot_pos = __begin +  __rng(__n);
 
-            // Swap pivot_pos value to end.
-            if (pivot_pos != (end - 1))
-              std::swap(*pivot_pos, *(end - 1));
-            pivot_pos = end - 1;
+            // Swap __pivot_pos value to end.
+            if (__pivot_pos != (__end - 1))
+              std::swap(*__pivot_pos, *(__end - 1));
+            __pivot_pos = __end - 1;
 
             __gnu_parallel::binder2nd
-                <Comparator, value_type, value_type, bool>
-                pred(comp, *pivot_pos);
+                <_Compare, _ValueType, _ValueType, bool>
+                __pred(__comp, *__pivot_pos);
 
             // Divide, leave pivot unchanged in last place.
-            RandomAccessIterator split_pos1, split_pos2;
-            split_pos1 = __gnu_sequential::partition(begin, end - 1, pred);
+            _RAIter __split_pos1, __split_pos2;
+            __split_pos1 = __gnu_sequential::partition(__begin, __end - 1, __pred);
 
-            // Left side: < pivot_pos; right side: >= pivot_pos.
+            // Left side: < __pivot_pos; __right side: >= __pivot_pos.
 #if _GLIBCXX_ASSERTIONS
-            _GLIBCXX_PARALLEL_ASSERT(begin <= split_pos1 && split_pos1 < end);
+            _GLIBCXX_PARALLEL_ASSERT(__begin <= __split_pos1 && __split_pos1 < __end);
 #endif
             // Swap pivot back to middle.
-            if (split_pos1 != pivot_pos)
-              std::swap(*split_pos1, *pivot_pos);
-            pivot_pos = split_pos1;
+            if (__split_pos1 != __pivot_pos)
+              std::swap(*__split_pos1, *__pivot_pos);
+            __pivot_pos = __split_pos1;
 
-            // In case all elements are equal, split_pos1 == 0.
-            if ((split_pos1 + 1 - begin) < (n >> 7)
-            || (end - split_pos1) < (n >> 7))
+            // In case all elements are equal, __split_pos1 == 0.
+            if ((__split_pos1 + 1 - __begin) < (__n >> 7)
+            || (__end - __split_pos1) < (__n >> 7))
               {
                 // Very unequal split, one part smaller than one 128th
                 // elements not strictly larger than the pivot.
-                __gnu_parallel::unary_negate<__gnu_parallel::binder1st
-		  <Comparator, value_type, value_type, bool>, value_type>
-		  pred(__gnu_parallel::binder1st
-		       <Comparator, value_type, value_type, bool>(comp,
-								  *pivot_pos));
+                __gnu_parallel::__unary_negate<__gnu_parallel::__binder1st
+		  <_Compare, _ValueType, _ValueType, bool>, _ValueType>
+		  __pred(__gnu_parallel::__binder1st
+		       <_Compare, _ValueType, _ValueType, bool>(__comp,
+								  *__pivot_pos));
 
                 // Find other end of pivot-equal range.
-                split_pos2 = __gnu_sequential::partition(split_pos1 + 1,
-							 end, pred);
+                __split_pos2 = __gnu_sequential::partition(__split_pos1 + 1,
+							 __end, __pred);
               }
             else
               // Only skip the pivot.
-              split_pos2 = split_pos1 + 1;
+              __split_pos2 = __split_pos1 + 1;
 
             // Elements equal to pivot are done.
-            elements_done += (split_pos2 - split_pos1);
+            __elements_done += (__split_pos2 - __split_pos1);
 #if _GLIBCXX_ASSERTIONS
-            total_elements_done += (split_pos2 - split_pos1);
+            __total_elements_done += (__split_pos2 - __split_pos1);
 #endif
             // Always push larger part onto stack.
-            if (((split_pos1 + 1) - begin) < (end - (split_pos2)))
+            if (((__split_pos1 + 1) - __begin) < (__end - (__split_pos2)))
               {
                 // Right side larger.
-                if ((split_pos2) != end)
-                  tl.leftover_parts.push_front(std::make_pair(split_pos2,
-							      end));
+                if ((__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;
+                //__current.first = __begin;	//already set anyway
+                __current.second = __split_pos1;
                 continue;
               }
             else
               {
                 // Left side larger.
-                if (begin != split_pos1)
-                  tl.leftover_parts.push_front(std::make_pair(begin,
-							      split_pos1));
+                if (__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
+                __current.first = __split_pos2;
+                //__current.second = __end;	//already set anyway
                 continue;
               }
           }
         else
           {
-            __gnu_sequential::sort(begin, end, comp);
-            elements_done += n;
+            __gnu_sequential::sort(__begin, __end, __comp);
+            __elements_done += __n;
 #if _GLIBCXX_ASSERTIONS
-            total_elements_done += n;
+            __total_elements_done += __n;
 #endif
 
             // Prefer own stack, small pieces.
-            if (tl.leftover_parts.pop_front(current))
+            if (__tl._M_leftover_parts.pop_front(__current))
               continue;
 
 #           pragma omp atomic
-            *tl.elements_leftover -= elements_done;
+            *__tl._M_elements_leftover -= __elements_done;
 
-            elements_done = 0;
+            __elements_done = 0;
 
 #if _GLIBCXX_ASSERTIONS
-            double search_start = omp_get_wtime();
+            double __search_start = omp_get_wtime();
 #endif
 
             // Look for new work.
-            bool successfully_stolen = false;
-            while (wait && *tl.elements_leftover > 0 && !successfully_stolen
+            bool __successfully_stolen = false;
+            while (__wait && *__tl._M_elements_leftover > 0 && !__successfully_stolen
 #if _GLIBCXX_ASSERTIONS
               // Possible dead-lock.
-              && (omp_get_wtime() < (search_start + 1.0))
+              && (omp_get_wtime() < (__search_start + 1.0))
 #endif
               )
               {
-                thread_index_t victim;
-                victim = rng(num_threads);
+                _ThreadIndex __victim;
+                __victim = __rng(__num_threads);
 
                 // Large pieces.
-                successfully_stolen = (victim != iam)
-                    && tls[victim]->leftover_parts.pop_back(current);
-                if (!successfully_stolen)
-                  yield();
+                __successfully_stolen = (__victim != __iam)
+                    && __tls[__victim]->_M_leftover_parts.pop_back(__current);
+                if (!__successfully_stolen)
+                  __yield();
 #if !defined(__ICC) && !defined(__ECC)
 #               pragma omp flush
 #endif
               }
 
 #if _GLIBCXX_ASSERTIONS
-            if (omp_get_wtime() >= (search_start + 1.0))
+            if (omp_get_wtime() >= (__search_start + 1.0))
               {
                 sleep(1);
                 _GLIBCXX_PARALLEL_ASSERT(omp_get_wtime()
-					 < (search_start + 1.0));
+					 < (__search_start + 1.0));
               }
 #endif
-            if (!successfully_stolen)
+            if (!__successfully_stolen)
               {
 #if _GLIBCXX_ASSERTIONS
-                _GLIBCXX_PARALLEL_ASSERT(*tl.elements_leftover == 0);
+                _GLIBCXX_PARALLEL_ASSERT(*__tl._M_elements_leftover == 0);
 #endif
                 return;
               }
@@ -407,70 +407,70 @@ template<typename RandomAccessIterator, typename Comparator>
   }
 
 /** @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
+  *  @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 RandomAccessIterator, typename Comparator>
+template<typename _RAIter, typename _Compare>
   void
-  parallel_sort_qsb(RandomAccessIterator begin, RandomAccessIterator end,
-                    Comparator comp,
-                    thread_index_t num_threads)
+  __parallel_sort_qsb(_RAIter __begin, _RAIter __end,
+                    _Compare __comp,
+                    _ThreadIndex __num_threads)
   {
-    _GLIBCXX_CALL(end - begin)
+    _GLIBCXX_CALL(__end - __begin)
 
-    typedef std::iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    typedef typename traits_type::difference_type difference_type;
-    typedef std::pair<RandomAccessIterator, RandomAccessIterator> Piece;
+    typedef std::iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
+    typedef std::pair<_RAIter, _RAIter> _Piece;
 
-    typedef QSBThreadLocal<RandomAccessIterator> tls_type;
+    typedef _QSBThreadLocal<_RAIter> _TLSType;
 
-    difference_type n = end - begin;
+    _DifferenceType __n = __end - __begin;
 
-    if (n <= 1)
+    if (__n <= 1)
       return;
 
     // At least one element per processor.
-    if (num_threads > n)
-      num_threads = static_cast<thread_index_t>(n);
+    if (__num_threads > __n)
+      __num_threads = static_cast<_ThreadIndex>(__n);
 
     // Initialize thread local storage
-    tls_type** tls = new tls_type*[num_threads];
-    difference_type queue_size = num_threads * (thread_index_t)(log2(n) + 1);
-    for (thread_index_t t = 0; t < num_threads; ++t)
-      tls[t] = new QSBThreadLocal<RandomAccessIterator>(queue_size);
+    _TLSType** __tls = new _TLSType*[__num_threads];
+    _DifferenceType __queue_size = __num_threads * (_ThreadIndex)(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(log2(__n)) ranges on the stack, because
     // 1. Only one processor pushes onto the stack
-    // 2. The largest range has at most length n
+    // 2. The largest range has at most length __n
     // 3. Each range is larger than half of the range remaining
-    volatile difference_type elements_leftover = n;
-    for (int i = 0; i < num_threads; ++i)
+    volatile _DifferenceType _M_elements_leftover = __n;
+    for (int __i = 0; __i < __num_threads; ++__i)
       {
-        tls[i]->elements_leftover = &elements_leftover;
-        tls[i]->num_threads = num_threads;
-        tls[i]->global = std::make_pair(begin, end);
+        __tls[__i]->_M_elements_leftover = &_M_elements_leftover;
+        __tls[__i]->__num_threads = __num_threads;
+        __tls[__i]->_M_global = std::make_pair(__begin, __end);
 
         // Just in case nothing is left to assign.
-        tls[i]->initial = std::make_pair(end, end);
+        __tls[__i]->_M_initial = std::make_pair(__end, __end);
       }
 
     // 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.
-    Piece dummy;
-    for (int i = 1; i < num_threads; ++i)
-      _GLIBCXX_PARALLEL_ASSERT(!tls[i]->leftover_parts.pop_back(dummy));
+    _Piece __dummy;
+    for (int __i = 1; __i < __num_threads; ++__i)
+      _GLIBCXX_PARALLEL_ASSERT(!__tls[__i]->_M_leftover_parts.pop_back(__dummy));
 #endif
 
-    for (int i = 0; i < num_threads; ++i)
-      delete tls[i];
-    delete[] tls;
+    for (int __i = 0; __i < __num_threads; ++__i)
+      delete __tls[__i];
+    delete[] __tls;
   }
 } // namespace __gnu_parallel
 
diff --git a/libstdc++-v3/include/parallel/base.h b/libstdc++-v3/include/parallel/base.h
index 7f855df..e09f05c 100644
--- a/libstdc++-v3/include/parallel/base.h
+++ b/libstdc++-v3/include/parallel/base.h
@@ -82,7 +82,7 @@ namespace __gnu_parallel
   // and active, which imples that the OpenMP runtime is actually
   // going to be linked in.
   inline int
-  get_max_threads() 
+  __get_max_threads() 
   { 
     int __i = omp_get_max_threads();
     return __i > 1 ? __i : 1; 
@@ -90,91 +90,91 @@ namespace __gnu_parallel
 
   
   inline bool 
-  is_parallel(const _Parallelism __p) { return __p != sequential; }
+  __is_parallel(const _Parallelism __p) { return __p != sequential; }
 
 
   // XXX remove std::duplicates from here if possible,
   // XXX but keep minimal dependencies.
 
-/** @brief Calculates the rounded-down logarithm of @c n for base 2.
-  *  @param n Argument.
+/** @brief Calculates the rounded-down logarithm of @__c __n for base 2.
+  *  @param __n Argument.
   *  @return Returns 0 for any argument <1.
   */
-template<typename Size>
-  inline Size
-  __log2(Size n)
+template<typename _Size>
+  inline _Size
+  __log2(_Size __n)
     {
-      Size k;
-      for (k = 0; n > 1; n >>= 1)
-        ++k;
-      return k;
+      _Size __k;
+      for (__k = 0; __n > 1; __n >>= 1)
+        ++__k;
+      return __k;
     }
 
-/** @brief Encode two integers into one __gnu_parallel::lcas_t.
-  *  @param a First integer, to be encoded in the most-significant @c
-  *  lcas_t_bits/2 bits.
-  *  @param b Second integer, to be encoded in the least-significant
-  *  @c lcas_t_bits/2 bits.
-  *  @return __gnu_parallel::lcas_t value encoding @c a and @c b.
+/** @brief Encode two integers into one __gnu_parallel::_CASable.
+  *  @param __a First integer, to be encoded in the most-significant @__c
+  *  _CASable_bits/2 bits.
+  *  @param __b Second integer, to be encoded in the least-significant
+  *  @__c _CASable_bits/2 bits.
+  *  @return __gnu_parallel::_CASable _M_value encoding @__c __a and @__c __b.
   *  @see decode2
   */
-inline lcas_t
-encode2(int a, int b)	//must all be non-negative, actually
+inline _CASable
+__encode2(int __a, int __b)	//must all be non-negative, actually
 {
-  return (((lcas_t)a) << (lcas_t_bits / 2)) | (((lcas_t)b) << 0);
+  return (((_CASable)__a) << (_CASable_bits / 2)) | (((_CASable)__b) << 0);
 }
 
-/** @brief Decode two integers from one __gnu_parallel::lcas_t.
-  *  @param x __gnu_parallel::lcas_t to decode integers from.
-  *  @param a First integer, to be decoded from the most-significant
-  *  @c lcas_t_bits/2 bits of @c x.
-  *  @param b Second integer, to be encoded in the least-significant
-  *  @c lcas_t_bits/2 bits of @c x.
-  *  @see encode2
+/** @brief Decode two integers from one __gnu_parallel::_CASable.
+  *  @param __x __gnu_parallel::_CASable to decode integers from.
+  *  @param __a First integer, to be decoded from the most-significant
+  *  @__c _CASable_bits/2 bits of @__c __x.
+  *  @param __b Second integer, to be encoded in the least-significant
+  *  @__c _CASable_bits/2 bits of @__c __x.
+  *  @see __encode2
   */
 inline void
-decode2(lcas_t x, int& a, int& b)
+decode2(_CASable __x, int& __a, int& __b)
 {
-  a = (int)((x >> (lcas_t_bits / 2)) & lcas_t_mask);
-  b = (int)((x >>               0 ) & lcas_t_mask);
+  __a = (int)((__x >> (_CASable_bits / 2)) & _CASable_mask);
+  __b = (int)((__x >>               0 ) & _CASable_mask);
 }
 
 /** @brief Equivalent to std::min. */
-template<typename T>
-  const T&
-  min(const T& a, const T& b)
-  { return (a < b) ? a : b; }
+template<typename _Tp>
+  const _Tp&
+  min(const _Tp& __a, const _Tp& __b)
+  { return (__a < __b) ? __a : __b; }
 
 /** @brief Equivalent to std::max. */
-template<typename T>
-  const T&
-  max(const T& a, const T& b)
-  { return (a > b) ? a : b; }
+template<typename _Tp>
+  const _Tp&
+  max(const _Tp& __a, const _Tp& __b)
+  { return (__a > __b) ? __a : __b; }
 
 /** @brief Constructs predicate for equality from strict weak
   *  ordering predicate
   */
 // XXX comparator at the end, as per others
-template<typename Comparator, typename T1, typename T2>
-  class equal_from_less : public std::binary_function<T1, T2, bool>
+template<typename _Compare, typename _T1, typename _T2>
+  class _EqualFromLess : public std::binary_function<_T1, _T2, bool>
   {
   private:
-    Comparator& comp;
+    _Compare& __comp;
 
   public:
-    equal_from_less(Comparator& _comp) : comp(_comp) { }
+    _EqualFromLess(_Compare& _comp) : __comp(_comp) { }
 
-    bool operator()(const T1& a, const T2& b)
+    bool operator()(const _T1& __a, const _T2& __b)
     {
-      return !comp(a, b) && !comp(b, a);
+      return !__comp(__a, __b) && !__comp(__b, __a);
     }
   };
 
 
-/** @brief Similar to std::binder1st,
+/** @brief Similar to std::__binder1st,
   *  but giving the argument types explicitly. */
 template<typename _Predicate, typename argument_type>
-  class unary_negate
+  class __unary_negate
   : public std::unary_function<argument_type, bool>
   {
   protected:
@@ -182,93 +182,93 @@ template<typename _Predicate, typename argument_type>
 
   public:
     explicit
-    unary_negate(const _Predicate& __x) : _M_pred(__x) { }
+    __unary_negate(const _Predicate& __x) : _M_pred(__x) { }
 
     bool
     operator()(const argument_type& __x)
     { return !_M_pred(__x); }
   };
 
-/** @brief Similar to std::binder1st,
+/** @brief Similar to std::__binder1st,
   *  but giving the argument types explicitly. */
-template<typename _Operation, typename first_argument_type,
-	 typename second_argument_type, typename result_type>
-  class binder1st
-  : public std::unary_function<second_argument_type, result_type>
+template<typename _Operation, typename _FirstArgumentType,
+	 typename _SecondArgumentType, typename _ResultType>
+  class __binder1st
+  : public std::unary_function<_SecondArgumentType, _ResultType>
   {
   protected:
-    _Operation op;
-    first_argument_type value;
+    _Operation _M_op;
+    _FirstArgumentType _M_value;
 
   public:
-    binder1st(const _Operation& __x,
-              const first_argument_type& __y)
-    : op(__x), value(__y) { }
+    __binder1st(const _Operation& __x,
+              const _FirstArgumentType& __y)
+    : _M_op(__x), _M_value(__y) { }
 
-    result_type
-    operator()(const second_argument_type& __x)
-    { return op(value, __x); }
+    _ResultType
+    operator()(const _SecondArgumentType& __x)
+    { return _M_op(_M_value, __x); }
 
     // _GLIBCXX_RESOLVE_LIB_DEFECTS
-    // 109.  Missing binders for non-const sequence elements
-    result_type
-    operator()(second_argument_type& __x) const
-    { return op(value, __x); }
+    // 109.  Missing binders for non-const __sequence __elements
+    _ResultType
+    operator()(_SecondArgumentType& __x) const
+    { return _M_op(_M_value, __x); }
   };
 
 /**
   *  @brief Similar to std::binder2nd, but giving the argument types
   *  explicitly.
   */
-template<typename _Operation, typename first_argument_type,
-	 typename second_argument_type, typename result_type>
+template<typename _Operation, typename _FirstArgumentType,
+	 typename _SecondArgumentType, typename _ResultType>
   class binder2nd
-  : public std::unary_function<first_argument_type, result_type>
+  : public std::unary_function<_FirstArgumentType, _ResultType>
   {
   protected:
-    _Operation op;
-    second_argument_type value;
+    _Operation _M_op;
+    _SecondArgumentType _M_value;
 
   public:
     binder2nd(const _Operation& __x,
-              const second_argument_type& __y)
-    : op(__x), value(__y) { }
+              const _SecondArgumentType& __y)
+    : _M_op(__x), _M_value(__y) { }
 
-    result_type
-    operator()(const first_argument_type& __x) const
-    { return op(__x, value); }
+    _ResultType
+    operator()(const _FirstArgumentType& __x) const
+    { return _M_op(__x, _M_value); }
 
     // _GLIBCXX_RESOLVE_LIB_DEFECTS
-    // 109.  Missing binders for non-const sequence elements
-    result_type
-    operator()(first_argument_type& __x)
-    { return op(__x, value); }
+    // 109.  Missing binders for non-const __sequence __elements
+    _ResultType
+    operator()(_FirstArgumentType& __x)
+    { return _M_op(__x, _M_value); }
   };
 
 /** @brief Similar to std::equal_to, but allows two different types. */
-template<typename T1, typename T2>
-  struct equal_to : std::binary_function<T1, T2, bool>
+template<typename _T1, typename _T2>
+  struct equal_to : std::binary_function<_T1, _T2, bool>
   {
-    bool operator()(const T1& t1, const T2& t2) const
-    { return t1 == t2; }
+    bool operator()(const _T1& __t1, const _T2& __t2) const
+    { return __t1 == __t2; }
   };
 
 /** @brief Similar to std::less, but allows two different types. */
-template<typename T1, typename T2>
-  struct less : std::binary_function<T1, T2, bool>
+template<typename _T1, typename _T2>
+  struct _Less : std::binary_function<_T1, _T2, bool>
   {
     bool
-    operator()(const T1& t1, const T2& t2) const
-    { return t1 < t2; }
+    operator()(const _T1& __t1, const _T2& __t2) const
+    { return __t1 < __t2; }
 
     bool
-    operator()(const T2& t2, const T1& t1) const
-    { return t2 < t1; }
+    operator()(const _T2& __t2, const _T1& __t1) const
+    { return __t2 < __t1; }
   };
 
 // Partial specialization for one type. Same as std::less.
 template<typename _Tp>
-struct less<_Tp, _Tp> : public std::binary_function<_Tp, _Tp, bool>
+struct _Less<_Tp, _Tp> : public std::binary_function<_Tp, _Tp, bool>
   {
     bool
     operator()(const _Tp& __x, const _Tp& __y) const
@@ -278,24 +278,24 @@ struct less<_Tp, _Tp> : public std::binary_function<_Tp, _Tp, bool>
 
   /** @brief Similar to std::plus, but allows two different types. */
 template<typename _Tp1, typename _Tp2>
-  struct plus : public std::binary_function<_Tp1, _Tp2, _Tp1>
+  struct _Plus : public std::binary_function<_Tp1, _Tp2, _Tp1>
   {
     typedef __typeof__(*static_cast<_Tp1*>(NULL)
-		       + *static_cast<_Tp2*>(NULL)) result;
+		       + *static_cast<_Tp2*>(NULL)) __result;
 
-    result
+    __result
     operator()(const _Tp1& __x, const _Tp2& __y) const
     { return __x + __y; }
   };
 
 // Partial specialization for one type. Same as std::plus.
 template<typename _Tp>
-  struct plus<_Tp, _Tp> : public std::binary_function<_Tp, _Tp, _Tp>
+  struct _Plus<_Tp, _Tp> : public std::binary_function<_Tp, _Tp, _Tp>
   {
     typedef __typeof__(*static_cast<_Tp*>(NULL)
-		       + *static_cast<_Tp*>(NULL)) result;
+		       + *static_cast<_Tp*>(NULL)) __result;
 
-    result
+    __result
     operator()(const _Tp& __x, const _Tp& __y) const
     { return __x + __y; }
   };
@@ -303,164 +303,164 @@ template<typename _Tp>
 
 /** @brief Similar to std::multiplies, but allows two different types. */
 template<typename _Tp1, typename _Tp2>
-  struct multiplies : public std::binary_function<_Tp1, _Tp2, _Tp1>
+  struct _Multiplies : public std::binary_function<_Tp1, _Tp2, _Tp1>
   {
     typedef __typeof__(*static_cast<_Tp1*>(NULL)
-		       * *static_cast<_Tp2*>(NULL)) result;
+		       * *static_cast<_Tp2*>(NULL)) __result;
 
-    result
+    __result
     operator()(const _Tp1& __x, const _Tp2& __y) const
     { return __x * __y; }
   };
 
 // Partial specialization for one type. Same as std::multiplies.
 template<typename _Tp>
-  struct multiplies<_Tp, _Tp> : public std::binary_function<_Tp, _Tp, _Tp>
+  struct _Multiplies<_Tp, _Tp> : public std::binary_function<_Tp, _Tp, _Tp>
   {
     typedef __typeof__(*static_cast<_Tp*>(NULL)
-		       * *static_cast<_Tp*>(NULL)) result;
+		       * *static_cast<_Tp*>(NULL)) __result;
 
-    result
+    __result
     operator()(const _Tp& __x, const _Tp& __y) const
     { return __x * __y; }
   };
 
 
-template<typename T, typename _DifferenceTp>
-  class pseudo_sequence;
+template<typename _Tp, typename _DifferenceTp>
+  class _PseudoSequence;
 
-/** @brief Iterator associated with __gnu_parallel::pseudo_sequence.
+/** @brief _Iterator associated with __gnu_parallel::_PseudoSequence.
   *  If features the usual random-access iterator functionality.
-  *  @param T Sequence value type.
-  *  @param difference_type Sequence difference type.
+  *  @param _Tp Sequence _M_value type.
+  *  @param _DifferenceType Sequence difference type.
   */
-template<typename T, typename _DifferenceTp>
-  class pseudo_sequence_iterator
+template<typename _Tp, typename _DifferenceTp>
+  class _PseudoSequenceIterator
   {
   public:
-    typedef _DifferenceTp difference_type;
+    typedef _DifferenceTp _DifferenceType;
 
   private:
-    typedef pseudo_sequence_iterator<T, _DifferenceTp> type;
+    typedef _PseudoSequenceIterator<_Tp, _DifferenceTp> _Self;
 
-    const T& val;
-    difference_type pos;
+    const _Tp& _M_val;
+    _DifferenceType _M_pos;
 
   public:
-    pseudo_sequence_iterator(const T& val, difference_type pos)
-    : val(val), pos(pos) { }
+    _PseudoSequenceIterator(const _Tp& _M_val, _DifferenceType _M_pos)
+    : _M_val(_M_val), _M_pos(_M_pos) { }
 
     // Pre-increment operator.
-    type&
+    _Self&
     operator++()
     {
-      ++pos;
+      ++_M_pos;
       return *this;
     }
 
     // Post-increment operator.
-    const type
+    const _Self
     operator++(int)
-    { return type(pos++); }
+    { return _Self(_M_pos++); }
 
-    const T&
+    const _Tp&
     operator*() const
-    { return val; }
+    { return _M_val; }
 
-    const T&
-    operator[](difference_type) const
-    { return val; }
+    const _Tp&
+    operator[](_DifferenceType) const
+    { return _M_val; }
 
     bool
-    operator==(const type& i2)
-    { return pos == i2.pos; }
+    operator==(const _Self& __i2)
+    { return _M_pos == __i2._M_pos; }
 
-    difference_type
-    operator!=(const type& i2)
-    { return pos != i2.pos; }
+    _DifferenceType
+    operator!=(const _Self& __i2)
+    { return _M_pos != __i2._M_pos; }
 
-    difference_type
-    operator-(const type& i2)
-    { return pos - i2.pos; }
+    _DifferenceType
+    operator-(const _Self& __i2)
+    { return _M_pos - __i2._M_pos; }
   };
 
 /** @brief Sequence that conceptually consists of multiple copies of
     the same element.
   *  The copies are not stored explicitly, of course.
-  *  @param T Sequence value type.
-  *  @param difference_type Sequence difference type.
+  *  @param _Tp Sequence _M_value type.
+  *  @param _DifferenceType Sequence difference type.
   */
-template<typename T, typename _DifferenceTp>
-  class pseudo_sequence
+template<typename _Tp, typename _DifferenceTp>
+  class _PseudoSequence
   {
-    typedef pseudo_sequence<T, _DifferenceTp> type;
+    typedef _PseudoSequence<_Tp, _DifferenceTp> _Self;
 
   public:
-    typedef _DifferenceTp difference_type;
+    typedef _DifferenceTp _DifferenceType;
 
     // Better case down to uint64, than up to _DifferenceTp.
-    typedef pseudo_sequence_iterator<T, uint64> iterator;
+    typedef _PseudoSequenceIterator<_Tp, uint64> iterator;
 
     /** @brief Constructor.
-      *  @param val Element of the sequence.
-      *  @param count Number of (virtual) copies.
+      *  @param _M_val Element of the sequence.
+      *  @param __count Number of (virtual) copies.
       */
-    pseudo_sequence(const T& val, difference_type count)
-    : val(val), count(count)  { }
+    _PseudoSequence(const _Tp& _M_val, _DifferenceType __count)
+    : _M_val(_M_val), __count(__count)  { }
 
     /** @brief Begin iterator. */
     iterator
     begin() const
-    { return iterator(val, 0); }
+    { return iterator(_M_val, 0); }
 
     /** @brief End iterator. */
     iterator
     end() const
-    { return iterator(val, count); }
+    { return iterator(_M_val, __count); }
 
   private:
-    const T& val;
-    difference_type count;
+    const _Tp& _M_val;
+    _DifferenceType __count;
   };
 
 /** @brief Functor that does nothing */
 template<typename _ValueTp>
-  class void_functor
+  class _VoidFunctor
   {
     inline void
-    operator()(const _ValueTp& v) const { }
+    operator()(const _ValueTp& __v) const { }
   };
 
 /** @brief Compute the median of three referenced elements,
-    according to @c comp.
-  *  @param a First iterator.
-  *  @param b Second iterator.
-  *  @param c Third iterator.
-  *  @param comp Comparator.
+    according to @__c __comp.
+  *  @param __a First iterator.
+  *  @param __b Second iterator.
+  *  @param __c Third iterator.
+  *  @param __comp Comparator.
   */
-template<typename RandomAccessIterator, typename Comparator>
-  RandomAccessIterator
-  median_of_three_iterators(RandomAccessIterator a, RandomAccessIterator b,
-                            RandomAccessIterator c, Comparator& comp)
+template<typename _RAIter, typename _Compare>
+  _RAIter
+  __median_of_three_iterators(_RAIter __a, _RAIter __b,
+                            _RAIter __c, _Compare& __comp)
   {
-    if (comp(*a, *b))
-      if (comp(*b, *c))
-        return b;
+    if (__comp(*__a, *__b))
+      if (__comp(*__b, *__c))
+        return __b;
       else
-        if (comp(*a, *c))
-          return c;
+        if (__comp(*__a, *__c))
+          return __c;
         else
-          return a;
+          return __a;
     else
       {
-        // Just swap a and b.
-        if (comp(*a, *c))
-          return a;
+        // Just swap __a and __b.
+        if (__comp(*__a, *__c))
+          return __a;
         else
-          if (comp(*b, *c))
-            return c;
+          if (__comp(*__b, *__c))
+            return __c;
           else
-            return b;
+            return __b;
       }
   }
 
diff --git a/libstdc++-v3/include/parallel/checkers.h b/libstdc++-v3/include/parallel/checkers.h
index 819e8ad..47d2174 100644
--- a/libstdc++-v3/include/parallel/checkers.h
+++ b/libstdc++-v3/include/parallel/checkers.h
@@ -39,115 +39,115 @@
 namespace __gnu_parallel
 {
   /**
-   * @brief Check whether @c [begin, @c end) is sorted according to @c comp.
-   * @param begin Begin iterator of sequence.
-   * @param end End iterator of sequence.
-   * @param comp Comparator.
-   * @return @c true if sorted, @c false otherwise.
+   * @brief Check whether @__c [__begin, @__c __end) is sorted according to @__c __comp.
+   * @param __begin Begin iterator of sequence.
+   * @param __end End iterator of sequence.
+   * @param __comp Comparator.
+   * @return @__c true if sorted, @__c false otherwise.
    */
-  // XXX Comparator default template argument
-  template<typename InputIterator, typename Comparator>
+  // XXX Compare default template argument
+  template<typename _IIter, typename _Compare>
     bool
-    is_sorted(InputIterator begin, InputIterator end,
-	      Comparator comp
-	      = std::less<typename std::iterator_traits<InputIterator>::
-	      value_type>())
+    __is_sorted(_IIter __begin, _IIter __end,
+	      _Compare __comp
+	      = std::less<typename std::iterator_traits<_IIter>::
+	      _ValueType>())
     {
-      if (begin == end)
+      if (__begin == __end)
 	return true;
 
-      InputIterator current(begin), recent(begin);
+      _IIter __current(__begin), __recent(__begin);
 
-      unsigned long long position = 1;
-      for (current++; current != end; current++)
+      unsigned long long __position = 1;
+      for (__current++; __current != __end; __current++)
 	{
-	  if (comp(*current, *recent))
+	  if (__comp(*__current, *__recent))
 	    {
-	      printf("is_sorted: check failed before position %i.\n",
-		     position);
+	      printf("__is_sorted: check failed before position %__i.\n",
+		     __position);
 	      return false;
 	    }
-	  recent = current;
-	  position++;
+	  __recent = __current;
+	  __position++;
 	}
 
       return true;
     }
 
   /**
-   * @brief Check whether @c [begin, @c end) is sorted according to @c comp.
+   * @brief Check whether @__c [__begin, @__c __end) is sorted according to @__c __comp.
    * Prints the position in case an unordered pair is found.
-   * @param begin Begin iterator of sequence.
-   * @param end End iterator of sequence.
-   * @param first_failure The first failure is returned in this variable.
-   * @param comp Comparator.
-   * @return @c true if sorted, @c false otherwise.
+   * @param __begin Begin iterator of sequence.
+   * @param __end End iterator of sequence.
+   * @param __first_failure The first failure is returned in this variable.
+   * @param __comp Comparator.
+   * @return @__c true if sorted, @__c false otherwise.
    */
-  // XXX Comparator default template argument
-  template<typename InputIterator, typename Comparator>
+  // XXX Compare default template argument
+  template<typename _IIter, typename _Compare>
     bool
-    is_sorted_failure(InputIterator begin, InputIterator end,
-		      InputIterator& first_failure,
-		      Comparator comp
-		      = std::less<typename std::iterator_traits<InputIterator>::
-		      value_type>())
+    is_sorted_failure(_IIter __begin, _IIter __end,
+		      _IIter& __first_failure,
+		      _Compare __comp
+		      = std::less<typename std::iterator_traits<_IIter>::
+		      _ValueType>())
     {
-      if (begin == end)
+      if (__begin == __end)
 	return true;
 
-      InputIterator current(begin), recent(begin);
+      _IIter __current(__begin), __recent(__begin);
 
-      unsigned long long position = 1;
-      for (current++; current != end; current++)
+      unsigned long long __position = 1;
+      for (__current++; __current != __end; __current++)
 	{
-	  if (comp(*current, *recent))
+	  if (__comp(*__current, *__recent))
 	    {
-	      first_failure = current;
-	      printf("is_sorted: check failed before position %lld.\n",
-		     position);
+	      __first_failure = __current;
+	      printf("__is_sorted: check failed before position %lld.\n",
+		     __position);
 	      return false;
 	    }
-	  recent = current;
-	  position++;
+	  __recent = __current;
+	  __position++;
 	}
 
-      first_failure = end;
+      __first_failure = __end;
       return true;
     }
 
   /**
-   * @brief Check whether @c [begin, @c end) is sorted according to @c comp.
+   * @brief Check whether @__c [__begin, @__c __end) is sorted according to @__c __comp.
    * Prints all unordered pair, including the surrounding two elements.
-   * @param begin Begin iterator of sequence.
-   * @param end End iterator of sequence.
-   * @param comp Comparator.
-   * @return @c true if sorted, @c false otherwise.
+   * @param __begin Begin iterator of sequence.
+   * @param __end End iterator of sequence.
+   * @param __comp Comparator.
+   * @return @__c true if sorted, @__c false otherwise.
    */
-  template<typename InputIterator, typename Comparator>
+  template<typename _IIter, typename _Compare>
     bool
-    // XXX Comparator default template argument
-    is_sorted_print_failures(InputIterator begin, InputIterator end,
-			     Comparator comp
+    // XXX Compare default template argument
+    is_sorted_print_failures(_IIter __begin, _IIter __end,
+			     _Compare __comp
 			     = std::less<typename std::iterator_traits
-			     <InputIterator>::value_type>())
+			     <_IIter>::value_type>())
     {
-      if (begin == end)
+      if (__begin == __end)
 	return true;
 
-      InputIterator recent(begin);
-      bool ok = true;
+      _IIter __recent(__begin);
+      bool __ok = true;
 
-      for (InputIterator pos(begin + 1); pos != end; pos++)
+      for (_IIter __pos(__begin + 1); __pos != __end; __pos++)
 	{
-	  if (comp(*pos, *recent))
+	  if (__comp(*__pos, *__recent))
 	    {
-	      printf("%ld: %d %d %d %d\n", pos - begin, *(pos - 2),
-		     *(pos- 1), *pos, *(pos + 1));
-	      ok = false;
+	      printf("%ld: %d %d %d %d\n", __pos - __begin, *(__pos - 2),
+		     *(__pos- 1), *__pos, *(__pos + 1));
+	      __ok = false;
 	    }
-	  recent = pos;
+	  __recent = __pos;
 	}
-      return ok;
+      return __ok;
     }
 }
 
diff --git a/libstdc++-v3/include/parallel/compatibility.h b/libstdc++-v3/include/parallel/compatibility.h
index a5726dd..2dc02a8 100644
--- a/libstdc++-v3/include/parallel/compatibility.h
+++ b/libstdc++-v3/include/parallel/compatibility.h
@@ -61,24 +61,24 @@ __attribute((dllimport)) void __attribute__((stdcall)) Sleep (unsigned long);
 namespace __gnu_parallel
 {
 #if defined(__ICC)
-  template<typename must_be_int = int>
-  int32 faa32(int32* x, int32 inc)
+  template<typename _MustBeInt = int>
+  int32 __faa32(int32* __x, int32 __inc)
   {
     asm volatile("lock xadd %0,%1"
-		 : "=r" (inc), "=m" (*x)
-		 : "0" (inc)
+		 : "=__r" (__inc), "=__m" (*__x)
+		 : "0" (__inc)
 		 : "memory");
-    return inc;
+    return __inc;
   }
 #if defined(__x86_64)
-  template<typename must_be_int = int>
-  int64 faa64(int64* x, int64 inc)
+  template<typename _MustBeInt = int>
+  int64 __faa64(int64* __x, int64 __inc)
   {
     asm volatile("lock xadd %0,%1"
-		 : "=r" (inc), "=m" (*x)
-		 : "0" (inc)
+		 : "=__r" (__inc), "=__m" (*__x)
+		 : "0" (__inc)
 		 : "memory");
-    return inc;
+    return __inc;
   }
 #endif
 #endif
@@ -88,106 +88,106 @@ namespace __gnu_parallel
   /** @brief Add a value to a variable, atomically.
    *
    *  Implementation is heavily platform-dependent.
-   *  @param ptr Pointer to a 32-bit signed integer.
-   *  @param addend Value to add.
+   *  @param __ptr Pointer to a 32-bit signed integer.
+   *  @param __addend Value to add.
    */
   inline int32
-  fetch_and_add_32(volatile int32* ptr, int32 addend)
+  __fetch_and_add_32(volatile int32* __ptr, int32 __addend)
   {
 #if defined(__ICC)	//x86 version
-    return _InterlockedExchangeAdd((void*)ptr, addend);
+    return _InterlockedExchangeAdd((void*)__ptr, __addend);
 #elif defined(__ECC)	//IA-64 version
-    return _InterlockedExchangeAdd((void*)ptr, addend);
+    return _InterlockedExchangeAdd((void*)__ptr, __addend);
 #elif defined(__ICL) || defined(_MSC_VER)
-    return _InterlockedExchangeAdd(reinterpret_cast<volatile long*>(ptr),
-				   addend);
+    return _InterlockedExchangeAdd(reinterpret_cast<volatile long*>(__ptr),
+				   __addend);
 #elif defined(__GNUC__)
-    return __sync_fetch_and_add(ptr, addend);
+    return __sync_fetch_and_add(__ptr, __addend);
 #elif defined(__SUNPRO_CC) && defined(__sparc)
-    volatile int32 before, after;
+    volatile int32 __before, __after;
     do
       {
-	before = *ptr;
-	after = before + addend;
-      } while (atomic_cas_32((volatile unsigned int*)ptr, before,
-			     after) != before);
-    return before;
+	__before = *__ptr;
+	__after = __before + __addend;
+      } while (atomic_cas_32((volatile unsigned int*)__ptr, __before,
+			     __after) != __before);
+    return __before;
 #else	//fallback, slow
-#pragma message("slow fetch_and_add_32")
-    int32 res;
+#pragma message("slow __fetch_and_add_32")
+    int32 __res;
 #pragma omp critical
     {
-      res = *ptr;
-      *(ptr) += addend;
+      __res = *__ptr;
+      *(__ptr) += __addend;
     }
-    return res;
+    return __res;
 #endif
   }
 
   /** @brief Add a value to a variable, atomically.
    *
    *  Implementation is heavily platform-dependent.
-   *  @param ptr Pointer to a 64-bit signed integer.
-   *  @param addend Value to add.
+   *  @param __ptr Pointer to a 64-bit signed integer.
+   *  @param __addend Value to add.
    */
   inline int64
-  fetch_and_add_64(volatile int64* ptr, int64 addend)
+  __fetch_and_add_64(volatile int64* __ptr, int64 __addend)
   {
 #if defined(__ICC) && defined(__x86_64)	//x86 version
-    return faa64<int>((int64*)ptr, addend);
+    return __faa64<int>((int64*)__ptr, __addend);
 #elif defined(__ECC)	//IA-64 version
-    return _InterlockedExchangeAdd64((void*)ptr, addend);
+    return _InterlockedExchangeAdd64((void*)__ptr, __addend);
 #elif defined(__ICL) || defined(_MSC_VER)
 #ifndef _WIN64
     _GLIBCXX_PARALLEL_ASSERT(false);	//not available in this case
     return 0;
 #else
-    return _InterlockedExchangeAdd64(ptr, addend);
+    return _InterlockedExchangeAdd64(__ptr, __addend);
 #endif
 #elif defined(__GNUC__) && defined(__x86_64)
-    return __sync_fetch_and_add(ptr, addend);
+    return __sync_fetch_and_add(__ptr, __addend);
 #elif defined(__GNUC__) && defined(__i386) &&			\
   (defined(__i686) || defined(__pentium4) || defined(__athlon))
-    return __sync_fetch_and_add(ptr, addend);
+    return __sync_fetch_and_add(__ptr, __addend);
 #elif defined(__SUNPRO_CC) && defined(__sparc)
-    volatile int64 before, after;
+    volatile int64 __before, __after;
     do
       {
-	before = *ptr;
-	after = before + addend;
-      } while (atomic_cas_64((volatile unsigned long long*)ptr, before,
-			     after) != before);
-    return before;
+	__before = *__ptr;
+	__after = __before + __addend;
+      } while (atomic_cas_64((volatile unsigned long long*)__ptr, __before,
+			     __after) != __before);
+    return __before;
 #else	//fallback, slow
 #if defined(__GNUC__) && defined(__i386)
-    // XXX doesn't work with -march=native
+    // XXX doesn'__t work with -march=native
     //#warning "please compile with -march=i686 or better"
 #endif
-#pragma message("slow fetch_and_add_64")
-    int64 res;
+#pragma message("slow __fetch_and_add_64")
+    int64 __res;
 #pragma omp critical
     {
-      res = *ptr;
-      *(ptr) += addend;
+      __res = *__ptr;
+      *(__ptr) += __addend;
     }
-    return res;
+    return __res;
 #endif
   }
 
   /** @brief Add a value to a variable, atomically.
    *
    *  Implementation is heavily platform-dependent.
-   *  @param ptr Pointer to a signed integer.
-   *  @param addend Value to add.
+   *  @param __ptr Pointer to a signed integer.
+   *  @param __addend Value to add.
    */
-  template<typename T>
-  inline T
-  fetch_and_add(volatile T* ptr, T addend)
+  template<typename _Tp>
+  inline _Tp
+  __fetch_and_add(volatile _Tp* __ptr, _Tp __addend)
   {
-    if (sizeof(T) == sizeof(int32))
-      return (T)fetch_and_add_32((volatile int32*) ptr, (int32)addend);
-    else if (sizeof(T) == sizeof(int64))
-      return (T)fetch_and_add_64((volatile int64*) ptr, (int64)addend);
+    if (sizeof(_Tp) == sizeof(int32))
+      return (_Tp)__fetch_and_add_32((volatile int32*) __ptr, (int32)__addend);
+    else if (sizeof(_Tp) == sizeof(int64))
+      return (_Tp)__fetch_and_add_64((volatile int64*) __ptr, (int64)__addend);
     else
       _GLIBCXX_PARALLEL_ASSERT(false);
   }
@@ -195,141 +195,141 @@ namespace __gnu_parallel
 
 #if defined(__ICC)
 
-  template<typename must_be_int = int>
+  template<typename _MustBeInt = int>
   inline int32
-  cas32(volatile int32* ptr, int32 old, int32 nw)
+  __cas32(volatile int32* __ptr, int32 __old, int32 __nw)
   {
-    int32 before;
+    int32 __before;
     __asm__ __volatile__("lock; cmpxchgl %1,%2"
-			 : "=a"(before)
-			 : "q"(nw), "m"(*(volatile long long*)(ptr)), "0"(old)
+			 : "=a"(__before)
+			 : "q"(__nw), "__m"(*(volatile long long*)(__ptr)), "0"(__old)
 			 : "memory");
-    return before;
+    return __before;
   }
 
 #if defined(__x86_64)
-  template<typename must_be_int = int>
+  template<typename _MustBeInt = int>
   inline int64
-  cas64(volatile int64 *ptr, int64 old, int64 nw)
+  __cas64(volatile int64 *__ptr, int64 __old, int64 __nw)
   {
-    int64 before;
+    int64 __before;
     __asm__ __volatile__("lock; cmpxchgq %1,%2"
-			 : "=a"(before)
-			 : "q"(nw), "m"(*(volatile long long*)(ptr)), "0"(old)
+			 : "=a"(__before)
+			 : "q"(__nw), "__m"(*(volatile long long*)(__ptr)), "0"(__old)
 			 : "memory");
-    return before;
+    return __before;
   }
 #endif
 
 #endif
 
-  /** @brief Compare @c *ptr and @c comparand. If equal, let @c
-   * *ptr=replacement and return @c true, return @c false otherwise.
+  /** @brief Compare @__c *__ptr and @__c __comparand. If equal, let @__c
+   * *__ptr=__replacement and return @__c true, return @__c false otherwise.
    *
    *  Implementation is heavily platform-dependent.
-   *  @param ptr Pointer to 32-bit signed integer.
-   *  @param comparand Compare value.
-   *  @param replacement Replacement value.
+   *  @param __ptr Pointer to 32-bit signed integer.
+   *  @param __comparand Compare value.
+   *  @param __replacement Replacement value.
    */
   inline bool
-  compare_and_swap_32(volatile int32* ptr, int32 comparand, int32 replacement)
+  __compare_and_swap_32(volatile int32* __ptr, int32 __comparand, int32 __replacement)
   {
 #if defined(__ICC)	//x86 version
-    return _InterlockedCompareExchange((void*)ptr, replacement,
-				       comparand) == comparand;
+    return _InterlockedCompareExchange((void*)__ptr, __replacement,
+				       __comparand) == __comparand;
 #elif defined(__ECC)	//IA-64 version
-    return _InterlockedCompareExchange((void*)ptr, replacement,
-				       comparand) == comparand;
+    return _InterlockedCompareExchange((void*)__ptr, __replacement,
+				       __comparand) == __comparand;
 #elif defined(__ICL) || defined(_MSC_VER)
-    return _InterlockedCompareExchange(reinterpret_cast<volatile long*>(ptr),
-				       replacement, comparand) == comparand;
+    return _InterlockedCompareExchange(reinterpret_cast<volatile long*>(__ptr),
+				       __replacement, __comparand) == __comparand;
 #elif defined(__GNUC__)
-    return __sync_bool_compare_and_swap(ptr, comparand, replacement);
+    return __sync_bool_compare_and_swap(__ptr, __comparand, __replacement);
 #elif defined(__SUNPRO_CC) && defined(__sparc)
-    return atomic_cas_32((volatile unsigned int*)ptr, comparand,
-			 replacement) == comparand;
+    return atomic_cas_32((volatile unsigned int*)__ptr, __comparand,
+			 __replacement) == __comparand;
 #else
-#pragma message("slow compare_and_swap_32")
-    bool res = false;
+#pragma message("slow __compare_and_swap_32")
+    bool __res = false;
 #pragma omp critical
     {
-      if (*ptr == comparand)
+      if (*__ptr == __comparand)
 	{
-	  *ptr = replacement;
-	  res = true;
+	  *__ptr = __replacement;
+	  __res = true;
 	}
     }
-    return res;
+    return __res;
 #endif
   }
 
-  /** @brief Compare @c *ptr and @c comparand. If equal, let @c
-   * *ptr=replacement and return @c true, return @c false otherwise.
+  /** @brief Compare @__c *__ptr and @__c __comparand. If equal, let @__c
+   * *__ptr=__replacement and return @__c true, return @__c false otherwise.
    *
    *  Implementation is heavily platform-dependent.
-   *  @param ptr Pointer to 64-bit signed integer.
-   *  @param comparand Compare value.
-   *  @param replacement Replacement value.
+   *  @param __ptr Pointer to 64-bit signed integer.
+   *  @param __comparand Compare value.
+   *  @param __replacement Replacement value.
    */
   inline bool
-  compare_and_swap_64(volatile int64* ptr, int64 comparand, int64 replacement)
+  __compare_and_swap_64(volatile int64* __ptr, int64 __comparand, int64 __replacement)
   {
 #if defined(__ICC) && defined(__x86_64)	//x86 version
-    return cas64<int>(ptr, comparand, replacement) == comparand;
+    return __cas64<int>(__ptr, __comparand, __replacement) == __comparand;
 #elif defined(__ECC)	//IA-64 version
-    return _InterlockedCompareExchange64((void*)ptr, replacement,
-					 comparand) == comparand;
+    return _InterlockedCompareExchange64((void*)__ptr, __replacement,
+					 __comparand) == __comparand;
 #elif defined(__ICL) || defined(_MSC_VER)
 #ifndef _WIN64
     _GLIBCXX_PARALLEL_ASSERT(false);	//not available in this case
     return 0;
 #else
-    return _InterlockedCompareExchange64(ptr, replacement,
-					 comparand) == comparand;
+    return _InterlockedCompareExchange64(__ptr, __replacement,
+					 __comparand) == __comparand;
 #endif
 
 #elif defined(__GNUC__) && defined(__x86_64)
-    return __sync_bool_compare_and_swap(ptr, comparand, replacement);
+    return __sync_bool_compare_and_swap(__ptr, __comparand, __replacement);
 #elif defined(__GNUC__) && defined(__i386) &&			\
   (defined(__i686) || defined(__pentium4) || defined(__athlon))
-    return __sync_bool_compare_and_swap(ptr, comparand, replacement);
+    return __sync_bool_compare_and_swap(__ptr, __comparand, __replacement);
 #elif defined(__SUNPRO_CC) && defined(__sparc)
-    return atomic_cas_64((volatile unsigned long long*)ptr,
-			 comparand, replacement) == comparand;
+    return atomic_cas_64((volatile unsigned long long*)__ptr,
+			 __comparand, __replacement) == __comparand;
 #else
 #if defined(__GNUC__) && defined(__i386)
     // XXX -march=native
     //#warning "please compile with -march=i686 or better"
 #endif
-#pragma message("slow compare_and_swap_64")
-    bool res = false;
+#pragma message("slow __compare_and_swap_64")
+    bool __res = false;
 #pragma omp critical
     {
-      if (*ptr == comparand)
+      if (*__ptr == __comparand)
 	{
-	  *ptr = replacement;
-	  res = true;
+	  *__ptr = __replacement;
+	  __res = true;
 	}
     }
-    return res;
+    return __res;
 #endif
   }
 
-  /** @brief Compare @c *ptr and @c comparand. If equal, let @c
-   * *ptr=replacement and return @c true, return @c false otherwise.
+  /** @brief Compare @__c *__ptr and @__c __comparand. If equal, let @__c
+   * *__ptr=__replacement and return @__c true, return @__c false otherwise.
    *
    *  Implementation is heavily platform-dependent.
-   *  @param ptr Pointer to signed integer.
-   *  @param comparand Compare value.
-   *  @param replacement Replacement value. */
-  template<typename T>
+   *  @param __ptr Pointer to signed integer.
+   *  @param __comparand Compare value.
+   *  @param __replacement Replacement value. */
+  template<typename _Tp>
   inline bool
-  compare_and_swap(volatile T* ptr, T comparand, T replacement)
+  __compare_and_swap(volatile _Tp* __ptr, _Tp __comparand, _Tp __replacement)
   {
-    if (sizeof(T) == sizeof(int32))
-      return compare_and_swap_32((volatile int32*) ptr, (int32)comparand, (int32)replacement);
-    else if (sizeof(T) == sizeof(int64))
-      return compare_and_swap_64((volatile int64*) ptr, (int64)comparand, (int64)replacement);
+    if (sizeof(_Tp) == sizeof(int32))
+      return __compare_and_swap_32((volatile int32*) __ptr, (int32)__comparand, (int32)__replacement);
+    else if (sizeof(_Tp) == sizeof(int64))
+      return __compare_and_swap_64((volatile int64*) __ptr, (int64)__comparand, (int64)__replacement);
     else
       _GLIBCXX_PARALLEL_ASSERT(false);
   }
@@ -337,7 +337,7 @@ namespace __gnu_parallel
   /** @brief Yield the control to another thread, without waiting for
       the end to the time slice. */
   inline void
-  yield()
+  __yield()
   {
 #if defined (_WIN32) && !defined (__CYGWIN__)
     Sleep(0);
diff --git a/libstdc++-v3/include/parallel/compiletime_settings.h b/libstdc++-v3/include/parallel/compiletime_settings.h
index e7e31d0..e375a94 100644
--- a/libstdc++-v3/include/parallel/compiletime_settings.h
+++ b/libstdc++-v3/include/parallel/compiletime_settings.h
@@ -38,15 +38,15 @@
 
 /** @def _GLIBCXX_CALL
  *  @brief Macro to produce log message when entering a function.
- *  @param n Input size.
+ *  @param __n Input size.
  *  @see _GLIBCXX_VERBOSE_LEVEL */
 #if (_GLIBCXX_VERBOSE_LEVEL == 0)
-#define _GLIBCXX_CALL(n)
+#define _GLIBCXX_CALL(__n)
 #endif
 #if (_GLIBCXX_VERBOSE_LEVEL == 1)
-#define _GLIBCXX_CALL(n) \
-  printf("   %s:\niam = %d, n = %ld, num_threads = %d\n", \
-  __PRETTY_FUNCTION__, omp_get_thread_num(), (n), get_max_threads());
+#define _GLIBCXX_CALL(__n) \
+  printf("   %__s:\niam = %d, __n = %ld, __num_threads = %d\n", \
+  __PRETTY_FUNCTION__, omp_get_thread_num(), (__n), __get_max_threads());
 #endif
 
 #ifndef _GLIBCXX_SCALE_DOWN_FPU
@@ -64,12 +64,12 @@
 #ifndef _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_L1
 /** @brief Switch on many _GLIBCXX_PARALLEL_ASSERTions in parallel code.
  *  Consider the size of the L1 cache for
- *  __gnu_parallel::parallel_random_shuffle(). */
+*  gnu_parallel::__parallel_random_shuffle(). */
 #define _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_L1 0
 #endif
 #ifndef _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_TLB
 /** @brief Switch on many _GLIBCXX_PARALLEL_ASSERTions in parallel code.
  *  Consider the size of the TLB for
- *  __gnu_parallel::parallel_random_shuffle(). */
+*  gnu_parallel::__parallel_random_shuffle(). */
 #define _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_TLB 0
 #endif
diff --git a/libstdc++-v3/include/parallel/equally_split.h b/libstdc++-v3/include/parallel/equally_split.h
index ee4bfee..11672c4 100644
--- a/libstdc++-v3/include/parallel/equally_split.h
+++ b/libstdc++-v3/include/parallel/equally_split.h
@@ -33,54 +33,54 @@
 
 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
+ *  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 difference_type, typename OutputIterator>
-  OutputIterator
-  equally_split(difference_type n, thread_index_t num_threads, OutputIterator s)
+*  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>
+  _OutputIterator
+  equally_split(_DifferenceType __n, _ThreadIndex __num_threads, _OutputIterator __s)
   {
-    difference_type chunk_length = n / num_threads;
-    difference_type num_longer_chunks = n % num_threads;
-    difference_type pos = 0;
-    for (thread_index_t i = 0; i < num_threads; ++i)
+    _DifferenceType __chunk_length = __n / __num_threads;
+    _DifferenceType __num_longer_chunks = __n % __num_threads;
+    _DifferenceType __pos = 0;
+    for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)
       {
-        *s++ = pos;
-        pos += (i < num_longer_chunks) ? (chunk_length + 1) : chunk_length;
+        *__s++ = __pos;
+        __pos += (__i < __num_longer_chunks) ? (__chunk_length + 1) : __chunk_length;
       }
-    *s++ = n;
-    return s;
+    *__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
- *  thread number thread_no+1 (excluded).
- *  @param n Number of elements
- *  @param num_threads Number of parts
- *  @returns _SplittingAlgorithm point */
-template<typename difference_type>
-  difference_type
-  equally_split_point(difference_type n,
-                      thread_index_t num_threads,
-                      thread_index_t thread_no)
+ *  thread number __thread_no (included) and
+ *  thread number __thread_no+1 (excluded).
+ *  @param __n Number of elements
+ *  @param __num_threads Number of parts
+ *  @returns splitting point */
+template<typename _DifferenceType>
+  _DifferenceType
+  equally_split_point(_DifferenceType __n,
+                      _ThreadIndex __num_threads,
+                      _ThreadIndex __thread_no)
   {
-    difference_type chunk_length = n / num_threads;
-    difference_type num_longer_chunks = n % num_threads;
-    if (thread_no < num_longer_chunks)
-      return thread_no * (chunk_length + 1);
+    _DifferenceType __chunk_length = __n / __num_threads;
+    _DifferenceType __num_longer_chunks = __n % __num_threads;
+    if (__thread_no < __num_longer_chunks)
+      return __thread_no * (__chunk_length + 1);
     else
-      return num_longer_chunks * (chunk_length + 1)
-          + (thread_no - num_longer_chunks) * chunk_length;
+      return __num_longer_chunks * (__chunk_length + 1)
+          + (__thread_no - __num_longer_chunks) * __chunk_length;
   }
 }
 
diff --git a/libstdc++-v3/include/parallel/features.h b/libstdc++-v3/include/parallel/features.h
index 417606e..077429f 100644
--- a/libstdc++-v3/include/parallel/features.h
+++ b/libstdc++-v3/include/parallel/features.h
@@ -78,7 +78,7 @@
 #ifndef _GLIBCXX_TREE_INITIAL_SPLITTING
 /** @def _GLIBCXX_TREE_INITIAL_SPLITTING
  *  @brief Include the initial splitting variant for
- *  _Rb_tree::insert_unique(InputIterator beg, InputIterator end).
+ *  _Rb_tree::insert_unique(_IIter beg, _IIter __end).
  *  @see __gnu_parallel::_Rb_tree */
 #define _GLIBCXX_TREE_INITIAL_SPLITTING 1
 #endif
@@ -86,7 +86,7 @@
 #ifndef _GLIBCXX_TREE_DYNAMIC_BALANCING
 /** @def _GLIBCXX_TREE_DYNAMIC_BALANCING
  *  @brief Include the dynamic balancing variant for
- *  _Rb_tree::insert_unique(InputIterator beg, InputIterator end).
+ *  _Rb_tree::insert_unique(_IIter beg, _IIter __end).
  *  @see __gnu_parallel::_Rb_tree */
 #define _GLIBCXX_TREE_DYNAMIC_BALANCING 1
 #endif
@@ -94,7 +94,7 @@
 #ifndef _GLIBCXX_TREE_FULL_COPY
 /** @def _GLIBCXX_TREE_FULL_COPY
  *  @brief In order to sort the input sequence of
- *  _Rb_tree::insert_unique(InputIterator beg, InputIterator end) a
+ *  _Rb_tree::insert_unique(_IIter beg, _IIter __end) a
  *  full copy of the input elements is done.
  *  @see __gnu_parallel::_Rb_tree */
 #define _GLIBCXX_TREE_FULL_COPY 1
diff --git a/libstdc++-v3/include/parallel/find.h b/libstdc++-v3/include/parallel/find.h
index 0597cc5..da442f9 100644
--- a/libstdc++-v3/include/parallel/find.h
+++ b/libstdc++-v3/include/parallel/find.h
@@ -23,7 +23,7 @@
 // <http://www.gnu.org/licenses/>.
 
 /** @file parallel/find.h
- *  @brief Parallel implementation base for std::find(), std::equal()
+ *  @brief Parallel implementation __base for std::find(), std::equal()
  *  and related functions.
  *  This file is a GNU parallel extension to the Standard C++ Library.
  */
@@ -44,36 +44,36 @@ 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
+ *  @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 __pred Find predicate.
+ *  @param __selector _Functionality (e. g. std::find_if (), std::equal(),...)
  *  @return Place of finding in both sequences.
  */
-template<typename RandomAccessIterator1,
-	 typename RandomAccessIterator2,
-	 typename Pred,
-	 typename Selector>
-  inline std::pair<RandomAccessIterator1, RandomAccessIterator2>
-  find_template(RandomAccessIterator1 begin1, RandomAccessIterator1 end1,
-                RandomAccessIterator2 begin2, Pred pred, Selector selector)
+template<typename _RAIter1,
+	 typename _RAIter2,
+	 typename _Pred,
+	 typename _Selector>
+  inline std::pair<_RAIter1, _RAIter2>
+  __find_template(_RAIter1 __begin1, _RAIter1 __end1,
+                _RAIter2 __begin2, _Pred __pred, _Selector __selector)
   {
     switch (_Settings::get().find_algorithm)
       {
       case GROWING_BLOCKS:
-        return find_template(begin1, end1, begin2, pred, selector,
+        return __find_template(__begin1, __end1, __begin2, __pred, __selector,
 			     growing_blocks_tag());
       case CONSTANT_SIZE_BLOCKS:
-        return find_template(begin1, end1, begin2, pred, selector,
+        return __find_template(__begin1, __end1, __begin2, __pred, __selector,
 			     constant_size_blocks_tag());
       case EQUAL_SPLIT:
-        return find_template(begin1, end1, begin2, pred, selector,
+        return __find_template(__begin1, __end1, __begin2, __pred, __selector,
 			     equal_split_tag());
       default:
         _GLIBCXX_PARALLEL_ASSERT(false);
-        return std::make_pair(begin1, begin2);
+        return std::make_pair(__begin1, __begin2);
       }
   }
 
@@ -81,80 +81,80 @@ template<typename RandomAccessIterator1,
 
 /**
  *  @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
+ *  @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 __pred Find predicate.
+ *  @param __selector _Functionality (e. g. std::find_if (), std::equal(),...)
  *  @return Place of finding in both sequences.
  */
-template<typename RandomAccessIterator1,
-	 typename RandomAccessIterator2,
-	 typename Pred,
-	 typename Selector>
-  std::pair<RandomAccessIterator1, RandomAccessIterator2>
-  find_template(RandomAccessIterator1 begin1,
-                RandomAccessIterator1 end1,
-                RandomAccessIterator2 begin2,
-                Pred pred,
-                Selector selector,
+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)
   {
-    _GLIBCXX_CALL(end1 - begin1)
+    _GLIBCXX_CALL(__end1 - __begin1)
 
-    typedef std::iterator_traits<RandomAccessIterator1> traits_type;
-    typedef typename traits_type::difference_type difference_type;
-    typedef typename traits_type::value_type value_type;
+    typedef std::iterator_traits<_RAIter1> _TraitsType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
+    typedef typename _TraitsType::value_type _ValueType;
 
-    difference_type length = end1 - begin1;
-    difference_type result = length;
-    difference_type* borders;
+    _DifferenceType __length = __end1 - __begin1;
+    _DifferenceType __result = __length;
+    _DifferenceType* __borders;
 
-    omp_lock_t result_lock;
-    omp_init_lock(&result_lock);
+    omp_lock_t __result_lock;
+    omp_init_lock(&__result_lock);
 
-    thread_index_t num_threads = get_max_threads();
-#   pragma omp parallel num_threads(num_threads)
+    _ThreadIndex __num_threads = __get_max_threads();
+#   pragma omp parallel num_threads(__num_threads)
       {
 #       pragma omp single
           {
-            num_threads = omp_get_num_threads();
-            borders = new difference_type[num_threads + 1];
-            equally_split(length, num_threads, borders);
+            __num_threads = omp_get_num_threads();
+            __borders = new _DifferenceType[__num_threads + 1];
+            equally_split(__length, __num_threads, __borders);
           } //single
 
-        thread_index_t iam = omp_get_thread_num();
-        difference_type start = borders[iam], stop = borders[iam + 1];
+        _ThreadIndex __iam = omp_get_thread_num();
+        _DifferenceType __start = __borders[__iam], __stop = __borders[__iam + 1];
 
-        RandomAccessIterator1 i1 = begin1 + start;
-        RandomAccessIterator2 i2 = begin2 + start;
-        for (difference_type pos = start; pos < stop; ++pos)
+        _RAIter1 __i1 = __begin1 + __start;
+        _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)
+            if (__result < __pos)
               break;
 
-            if (selector(i1, i2, pred))
+            if (__selector(__i1, __i2, __pred))
               {
-                omp_set_lock(&result_lock);
-                if (pos < result)
-                  result = pos;
-                omp_unset_lock(&result_lock);
+                omp_set_lock(&__result_lock);
+                if (__pos < __result)
+                  __result = __pos;
+                omp_unset_lock(&__result_lock);
                 break;
               }
-            ++i1;
-            ++i2;
+            ++__i1;
+            ++__i2;
           }
       } //parallel
 
-    omp_destroy_lock(&result_lock);
-    delete[] borders;
+    omp_destroy_lock(&__result_lock);
+    delete[] __borders;
 
     return
-      std::pair<RandomAccessIterator1, RandomAccessIterator2>(begin1 + result,
-							      begin2 + result);
+      std::pair<_RAIter1, _RAIter2>(__begin1 + __result,
+							      __begin2 + __result);
   }
 
 #endif
@@ -163,12 +163,12 @@ template<typename RandomAccessIterator1,
 
 /**
  *  @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
+ *  @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 __pred Find predicate.
+ *  @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
@@ -183,105 +183,105 @@ template<typename RandomAccessIterator1,
  *     for CSB, the blocks are allocated in a predetermined manner,
  *     namely spacial round-robin.
  */
-template<typename RandomAccessIterator1,
-	 typename RandomAccessIterator2,
-	 typename Pred,
-	 typename Selector>
-  std::pair<RandomAccessIterator1, RandomAccessIterator2>
-  find_template(RandomAccessIterator1 begin1, RandomAccessIterator1 end1,
-                RandomAccessIterator2 begin2, Pred pred, Selector selector,
+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,
                 growing_blocks_tag)
   {
-    _GLIBCXX_CALL(end1 - begin1)
+    _GLIBCXX_CALL(__end1 - __begin1)
 
-    typedef std::iterator_traits<RandomAccessIterator1> traits_type;
-    typedef typename traits_type::difference_type difference_type;
-    typedef typename traits_type::value_type value_type;
+    typedef std::iterator_traits<_RAIter1> _TraitsType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
+    typedef typename _TraitsType::value_type _ValueType;
 
     const _Settings& __s = _Settings::get();
 
-    difference_type length = end1 - begin1;
+    _DifferenceType __length = __end1 - __begin1;
 
-    difference_type sequential_search_size =
-      std::min<difference_type>(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<RandomAccessIterator1, RandomAccessIterator2> find_seq_result =
-      selector.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;
+    if (__find_seq_result.first != (__begin1 + __sequential_search_size))
+      return __find_seq_result;
 
     // Index of beginning of next free block (after sequential find).
-    difference_type next_block_start = sequential_search_size;
-    difference_type result = length;
+    _DifferenceType __next_block_start = __sequential_search_size;
+    _DifferenceType __result = __length;
 
-    omp_lock_t result_lock;
-    omp_init_lock(&result_lock);
+    omp_lock_t __result_lock;
+    omp_init_lock(&__result_lock);
 
-    thread_index_t num_threads = get_max_threads();
-#   pragma omp parallel shared(result) num_threads(num_threads)
+    _ThreadIndex __num_threads = __get_max_threads();
+#   pragma omp parallel shared(__result) num_threads(__num_threads)
       {
 #       pragma omp single
-          num_threads = omp_get_num_threads();
+          __num_threads = omp_get_num_threads();
 
-        // Not within first k elements -> start parallel.
-        thread_index_t iam = omp_get_thread_num();
+        // Not within first __k __elements -> start parallel.
+        _ThreadIndex __iam = omp_get_thread_num();
 
-        difference_type block_size = __s.find_initial_block_size;
-        difference_type start =
-            fetch_and_add<difference_type>(&next_block_start, block_size);
+        _DifferenceType __block_size = __s.find_initial_block_size;
+        _DifferenceType __start =
+            __fetch_and_add<_DifferenceType>(&__next_block_start, __block_size);
 
         // Get new block, update pointer to next block.
-        difference_type stop =
-            std::min<difference_type>(length, start + block_size);
+        _DifferenceType __stop =
+            std::min<_DifferenceType>(__length, __start + __block_size);
 
-        std::pair<RandomAccessIterator1, RandomAccessIterator2> local_result;
+        std::pair<_RAIter1, _RAIter2> __local_result;
 
-        while (start < length)
+        while (__start < __length)
           {
-#           pragma omp flush(result)
+#           pragma omp flush(__result)
             // Get new value of result.
-            if (result < start)
+            if (__result < __start)
               {
                 // No chance to find first element.
                 break;
               }
 
-            local_result = selector.sequential_algorithm(
-                begin1 + start, begin1 + stop, begin2 + start, pred);
-            if (local_result.first != (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);
-                if ((local_result.first - begin1) < result)
+                omp_set_lock(&__result_lock);
+                if ((__local_result.first - __begin1) < __result)
                   {
-                    result = local_result.first - begin1;
+                    __result = __local_result.first - __begin1;
 
                     // Result cannot be in future blocks, stop algorithm.
-                    fetch_and_add<difference_type>(&next_block_start, length);
+                    __fetch_and_add<_DifferenceType>(&__next_block_start, __length);
                   }
-                  omp_unset_lock(&result_lock);
+                  omp_unset_lock(&__result_lock);
               }
 
-            block_size =
-	      std::min<difference_type>(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<difference_type>(&next_block_start, block_size);
-            stop = ((length < (start + block_size))
-		    ? length : (start + block_size));
+            __start =
+	      __fetch_and_add<_DifferenceType>(&__next_block_start, __block_size);
+            __stop = ((__length < (__start + __block_size))
+		    ? __length : (__start + __block_size));
           }
       } //parallel
 
-    omp_destroy_lock(&result_lock);
+    omp_destroy_lock(&__result_lock);
 
     // Return iterator on found element.
     return
-      std::pair<RandomAccessIterator1, RandomAccessIterator2>(begin1 + result,
-							      begin2 + result);
+      std::pair<_RAIter1, _RAIter2>(__begin1 + __result,
+							      __begin2 + __result);
   }
 
 #endif
@@ -290,12 +290,12 @@ template<typename RandomAccessIterator1,
 
 /**
  *   @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
+ *  @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 __pred Find predicate.
+ *  @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
@@ -306,94 +306,94 @@ template<typename RandomAccessIterator1,
  *  blocks are allocated in a predetermined manner, namely spacial
  *  round-robin.
  */
-template<typename RandomAccessIterator1,
-	 typename RandomAccessIterator2,
-	 typename Pred,
-	 typename Selector>
-  std::pair<RandomAccessIterator1, RandomAccessIterator2>
-  find_template(RandomAccessIterator1 begin1, RandomAccessIterator1 end1,
-                RandomAccessIterator2 begin2, Pred pred, Selector selector,
+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,
                 constant_size_blocks_tag)
   {
-    _GLIBCXX_CALL(end1 - begin1)
-    typedef std::iterator_traits<RandomAccessIterator1> traits_type;
-    typedef typename traits_type::difference_type difference_type;
-    typedef typename traits_type::value_type value_type;
+    _GLIBCXX_CALL(__end1 - __begin1)
+    typedef std::iterator_traits<_RAIter1> _TraitsType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
+    typedef typename _TraitsType::value_type _ValueType;
 
     const _Settings& __s = _Settings::get();
 
-    difference_type length = end1 - begin1;
+    _DifferenceType __length = __end1 - __begin1;
 
-    difference_type sequential_search_size = std::min<difference_type>(
-        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<RandomAccessIterator1, RandomAccessIterator2> find_seq_result =
-      selector.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;
+    if (__find_seq_result.first != (__begin1 + __sequential_search_size))
+      return __find_seq_result;
 
-    difference_type result = length;
-    omp_lock_t result_lock;
-    omp_init_lock(&result_lock);
+    _DifferenceType __result = __length;
+    omp_lock_t __result_lock;
+    omp_init_lock(&__result_lock);
 
-    // Not within first sequential_search_size elements -> start parallel.
+    // Not within first __sequential_search_size elements -> start parallel.
 
-    thread_index_t num_threads = get_max_threads();
-#   pragma omp parallel shared(result) num_threads(num_threads)
+    _ThreadIndex __num_threads = __get_max_threads();
+#   pragma omp parallel shared(__result) num_threads(__num_threads)
       {
 #       pragma omp single
-          num_threads = omp_get_num_threads();
+          __num_threads = omp_get_num_threads();
 
-        thread_index_t iam = omp_get_thread_num();
-        difference_type block_size = __s.find_initial_block_size;
+        _ThreadIndex __iam = omp_get_thread_num();
+        _DifferenceType __block_size = __s.find_initial_block_size;
 
         // First element of thread's current iteration.
-        difference_type iteration_start = sequential_search_size;
+        _DifferenceType __iteration_start = __sequential_search_size;
 
         // Where to work (initialization).
-        difference_type start = iteration_start + iam * block_size;
-        difference_type stop =
-            std::min<difference_type>(length, start + block_size);
+        _DifferenceType __start = __iteration_start + __iam * __block_size;
+        _DifferenceType __stop =
+            std::min<_DifferenceType>(__length, __start + __block_size);
 
-        std::pair<RandomAccessIterator1, RandomAccessIterator2> local_result;
+        std::pair<_RAIter1, _RAIter2> __local_result;
 
-        while (start < length)
+        while (__start < __length)
           {
             // Get new value of result.
-#           pragma omp flush(result)
+#           pragma omp flush(__result)
             // No chance to find first element.
-            if (result < start)
+            if (__result < __start)
               break;
-            local_result = selector.sequential_algorithm(
-                begin1 + start, begin1 + stop,
-                begin2 + start, pred);
-            if (local_result.first != (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);
-                if ((local_result.first - begin1) < result)
-                  result = local_result.first - begin1;
-                omp_unset_lock(&result_lock);
+                omp_set_lock(&__result_lock);
+                if ((__local_result.first - __begin1) < __result)
+                  __result = __local_result.first - __begin1;
+                omp_unset_lock(&__result_lock);
                 // Will not find better value in its interval.
                 break;
               }
 
-            iteration_start += num_threads * block_size;
+            __iteration_start += __num_threads * __block_size;
 
             // Where to work.
-            start = iteration_start + iam * block_size;
-            stop = std::min<difference_type>(length, start + block_size);
+            __start = __iteration_start + __iam * __block_size;
+            __stop = std::min<_DifferenceType>(__length, __start + __block_size);
           }
       } //parallel
 
-    omp_destroy_lock(&result_lock);
+    omp_destroy_lock(&__result_lock);
 
     // Return iterator on found element.
     return
-      std::pair<RandomAccessIterator1, RandomAccessIterator2>(begin1 + result,
-							      begin2 + result);
+      std::pair<_RAIter1, _RAIter2>(__begin1 + __result,
+							      __begin2 + __result);
   }
 #endif
 } // end namespace
diff --git a/libstdc++-v3/include/parallel/find_selectors.h b/libstdc++-v3/include/parallel/find_selectors.h
index 3cbc1b8..8f6db75 100644
--- a/libstdc++-v3/include/parallel/find_selectors.h
+++ b/libstdc++-v3/include/parallel/find_selectors.h
@@ -23,7 +23,7 @@
 // <http://www.gnu.org/licenses/>.
 
 /** @file parallel/find_selectors.h
- *  @brief Function objects representing different tasks to be plugged
+ *  @brief _Function objects representing different tasks to be plugged
  *  into the parallel find algorithm.
  *  This file is a GNU parallel extension to the Standard C++ Library.
  */
@@ -39,153 +39,153 @@
 
 namespace __gnu_parallel
 {
-  /** @brief Base class of all __gnu_parallel::find_template selectors. */
-  struct generic_find_selector
+  /** @brief Base class of all __gnu_parallel::__find_template selectors. */
+  struct __generic_find_selector
   { };
 
   /** 
    *  @brief Test predicate on a single element, used for std::find()
    *  and std::find_if ().
    */
-  struct find_if_selector : public generic_find_selector
+  struct __find_if_selector : public __generic_find_selector
   {
-    /** @brief Test on one position.
-     * @param i1 Iterator on first sequence.
-     * @param i2 Iterator on second sequence (unused).
-     * @param pred Find predicate.
+    /** @brief Test on one __position.
+     * @param __i1 _Iterator on first sequence.
+     * @param __i2 _Iterator on second sequence (unused).
+     * @param __pred Find predicate.
      */
-    template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-	     typename Pred>
+    template<typename _RAIter1, typename _RAIter2,
+	     typename _Pred>
       bool 
-      operator()(RandomAccessIterator1 i1, RandomAccessIterator2 i2, Pred pred)
-      { return pred(*i1); }
+      operator()(_RAIter1 __i1, _RAIter2 __i2, _Pred __pred)
+      { return __pred(*__i1); }
 
     /** @brief Corresponding sequential algorithm on a sequence.
-     *  @param begin1 Begin iterator of first sequence.
-     *  @param end1 End iterator of first sequence.
-     *  @param begin2 Begin iterator of second sequence.
-     *  @param pred Find predicate.
+     *  @param __begin1 Begin iterator of first sequence.
+     *  @param __end1 End iterator of first sequence.
+     *  @param __begin2 Begin iterator of second sequence.
+     *  @param __pred Find predicate.
      */
-    template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-	     typename Pred>
-      std::pair<RandomAccessIterator1, RandomAccessIterator2> 
-      sequential_algorithm(RandomAccessIterator1 begin1,
-			   RandomAccessIterator1 end1,
-			   RandomAccessIterator2 begin2, Pred pred)
-      { return std::make_pair(find_if(begin1, end1, pred,
-				      sequential_tag()), begin2); }
+    template<typename _RAIter1, typename _RAIter2,
+	     typename _Pred>
+      std::pair<_RAIter1, _RAIter2> 
+      _M_sequential_algorithm(_RAIter1 __begin1,
+			   _RAIter1 __end1,
+			   _RAIter2 __begin2, _Pred __pred)
+      { return std::make_pair(find_if(__begin1, __end1, __pred,
+				      sequential_tag()), __begin2); }
   };
 
-  /** @brief Test predicate on two adjacent elements. */
-  struct adjacent_find_selector : public generic_find_selector
+  /** @brief Test predicate on two adjacent __elements. */
+  struct __adjacent_find_selector : public __generic_find_selector
   {
-    /** @brief Test on one position.
-     *  @param i1 Iterator on first sequence.
-     *  @param i2 Iterator on second sequence (unused).
-     *  @param pred Find predicate.
+    /** @brief Test on one __position.
+     *  @param __i1 _Iterator on first sequence.
+     *  @param __i2 _Iterator on second sequence (unused).
+     *  @param __pred Find predicate.
      */
-    template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-	     typename Pred>
+    template<typename _RAIter1, typename _RAIter2,
+	     typename _Pred>
       bool 
-      operator()(RandomAccessIterator1 i1, RandomAccessIterator2 i2, Pred pred)
+      operator()(_RAIter1 __i1, _RAIter2 __i2, _Pred __pred)
       {
 	// Passed end iterator is one short.
-	return pred(*i1, *(i1 + 1));
+	return __pred(*__i1, *(__i1 + 1));
       }
 
     /** @brief Corresponding sequential algorithm on a sequence.
-     *  @param begin1 Begin iterator of first sequence.
-     *  @param end1 End iterator of first sequence.
-     *  @param begin2 Begin iterator of second sequence.
-     *  @param pred Find predicate.
+     *  @param __begin1 Begin iterator of first sequence.
+     *  @param __end1 End iterator of first sequence.
+     *  @param __begin2 Begin iterator of second sequence.
+     *  @param __pred Find predicate.
      */
-    template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-	     typename Pred>
-      std::pair<RandomAccessIterator1, RandomAccessIterator2>
-      sequential_algorithm(RandomAccessIterator1 begin1,
-			   RandomAccessIterator1 end1,
-			   RandomAccessIterator2 begin2, Pred pred)
+    template<typename _RAIter1, typename _RAIter2,
+	     typename _Pred>
+      std::pair<_RAIter1, _RAIter2>
+      _M_sequential_algorithm(_RAIter1 __begin1,
+			   _RAIter1 __end1,
+			   _RAIter2 __begin2, _Pred __pred)
       {
 	// Passed end iterator is one short.
-	RandomAccessIterator1 spot = adjacent_find(begin1, end1 + 1,
-						   pred, sequential_tag());
-	if (spot == (end1 + 1))
-	  spot = end1;
-	return std::make_pair(spot, begin2);
+	_RAIter1 spot = adjacent_find(__begin1, __end1 + 1,
+						   __pred, sequential_tag());
+	if (spot == (__end1 + 1))
+	  spot = __end1;
+	return std::make_pair(spot, __begin2);
       }
   };
 
   /** @brief Test inverted predicate on a single element. */
-  struct mismatch_selector : public generic_find_selector
+  struct __mismatch_selector : public __generic_find_selector
   {
     /** 
-     *  @brief Test on one position.
-     *  @param i1 Iterator on first sequence.
-     *  @param i2 Iterator on second sequence (unused).
-     *  @param pred Find predicate. 
+     *  @brief Test on one __position.
+     *  @param __i1 _Iterator on first sequence.
+     *  @param __i2 _Iterator on second sequence (unused).
+     *  @param __pred Find predicate. 
      */
-    template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-	     typename Pred>
+    template<typename _RAIter1, typename _RAIter2,
+	     typename _Pred>
       bool 
-      operator()(RandomAccessIterator1 i1, RandomAccessIterator2 i2, Pred pred)
-      { return !pred(*i1, *i2); }
+      operator()(_RAIter1 __i1, _RAIter2 __i2, _Pred __pred)
+      { return !__pred(*__i1, *__i2); }
 
     /** 
      *  @brief Corresponding sequential algorithm on a sequence.
-     *  @param begin1 Begin iterator of first sequence.
-     *  @param end1 End iterator of first sequence.
-     *  @param begin2 Begin iterator of second sequence.
-     *  @param pred Find predicate. 
+     *  @param __begin1 Begin iterator of first sequence.
+     *  @param __end1 End iterator of first sequence.
+     *  @param __begin2 Begin iterator of second sequence.
+     *  @param __pred Find predicate. 
      */
-    template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-	     typename Pred>
-      std::pair<RandomAccessIterator1, RandomAccessIterator2>
-      sequential_algorithm(RandomAccessIterator1 begin1,
-			   RandomAccessIterator1 end1,
-			   RandomAccessIterator2 begin2, Pred pred)
-      { return mismatch(begin1, end1, begin2, pred, sequential_tag()); }
+    template<typename _RAIter1, typename _RAIter2,
+	     typename _Pred>
+      std::pair<_RAIter1, _RAIter2>
+      _M_sequential_algorithm(_RAIter1 __begin1,
+			   _RAIter1 __end1,
+			   _RAIter2 __begin2, _Pred __pred)
+      { return mismatch(__begin1, __end1, __begin2, __pred, sequential_tag()); }
   };
 
 
-  /** @brief Test predicate on several elements. */
-  template<typename ForwardIterator>
-  struct find_first_of_selector : public generic_find_selector
+  /** @brief Test predicate on several __elements. */
+  template<typename _ForwardIterator>
+  struct __find_first_of_selector : public __generic_find_selector
   {
-    ForwardIterator begin;
-    ForwardIterator end;
-
-    explicit find_first_of_selector(ForwardIterator begin, ForwardIterator end)
-    : begin(begin), end(end) { }
-
-    /** @brief Test on one position.
-     *  @param i1 Iterator on first sequence.
-     *  @param i2 Iterator on second sequence (unused).
-     *  @param pred Find predicate. */
-    template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-	     typename Pred>
+    _ForwardIterator __begin;
+    _ForwardIterator __end;
+
+    explicit __find_first_of_selector(_ForwardIterator __begin, _ForwardIterator __end)
+    : __begin(__begin), __end(__end) { }
+
+    /** @brief Test on one __position.
+     *  @param __i1 _Iterator on first sequence.
+     *  @param __i2 _Iterator on second sequence (unused).
+     *  @param __pred Find predicate. */
+    template<typename _RAIter1, typename _RAIter2,
+	     typename _Pred>
       bool 
-      operator()(RandomAccessIterator1 i1, RandomAccessIterator2 i2, Pred pred)
+      operator()(_RAIter1 __i1, _RAIter2 __i2, _Pred __pred)
       {
-	for (ForwardIterator pos_in_candidates = begin;
-	     pos_in_candidates != end; ++pos_in_candidates)
-	  if (pred(*i1, *pos_in_candidates))
+	for (_ForwardIterator __pos_in_candidates = __begin;
+	     __pos_in_candidates != __end; ++__pos_in_candidates)
+	  if (__pred(*__i1, *__pos_in_candidates))
 	    return true;
 	return false;
       }
 
     /** @brief Corresponding sequential algorithm on a sequence.
-     *  @param begin1 Begin iterator of first sequence.
-     *  @param end1 End iterator of first sequence.
-     *  @param begin2 Begin iterator of second sequence.
-     *  @param pred Find predicate. */
-    template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-	     typename Pred>
-      std::pair<RandomAccessIterator1, RandomAccessIterator2>
-      sequential_algorithm(RandomAccessIterator1 begin1,
-			   RandomAccessIterator1 end1,
-			   RandomAccessIterator2 begin2, Pred pred)
-      { return std::make_pair(find_first_of(begin1, end1, begin, end, pred,
-					    sequential_tag()), begin2); }
+     *  @param __begin1 Begin iterator of first sequence.
+     *  @param __end1 End iterator of first sequence.
+     *  @param __begin2 Begin iterator of second sequence.
+     *  @param __pred Find predicate. */
+    template<typename _RAIter1, typename _RAIter2,
+	     typename _Pred>
+      std::pair<_RAIter1, _RAIter2>
+      _M_sequential_algorithm(_RAIter1 __begin1,
+			   _RAIter1 __end1,
+			   _RAIter2 __begin2, _Pred __pred)
+      { return std::make_pair(find_first_of(__begin1, __end1, __begin, __end, __pred,
+					    sequential_tag()), __begin2); }
   };
 }
 
diff --git a/libstdc++-v3/include/parallel/for_each.h b/libstdc++-v3/include/parallel/for_each.h
index 61158f8..77162ed 100644
--- a/libstdc++-v3/include/parallel/for_each.h
+++ b/libstdc++-v3/include/parallel/for_each.h
@@ -42,55 +42,55 @@
 
 namespace __gnu_parallel
 {
-  /** @brief Chose the desired algorithm by evaluating @c parallelism_tag.
-   *  @param begin Begin iterator of input sequence.
-   *  @param end End iterator of input sequence.
-   *  @param user_op A user-specified functor (comparator, predicate,
+  /** @brief Chose the desired algorithm by evaluating @__c __parallelism_tag.
+   *  @param __begin Begin iterator of input sequence.
+   *  @param __end End iterator of input sequence.
+   *  @param __user_op A user-specified functor (comparator, predicate,
    *  associative operator,...)
-   *  @param functionality functor to "process" an element with
-   *  user_op (depends on desired functionality, e. g. accumulate,
+   *  @param __functionality functor to "process" an element with
+   *  __user_op (depends on desired functionality, e. g. accumulate,
    *  for_each,...
-   *  @param reduction Reduction functor.
-   *  @param reduction_start Initial value for reduction.
-   *  @param output Output iterator.
-   *  @param bound Maximum number of elements processed.
-   *  @param parallelism_tag Parallelization method */
-  template<typename InputIterator, typename UserOp,
-	   typename Functionality, typename Red, typename Result>
-    UserOp
-    for_each_template_random_access(InputIterator begin, InputIterator end,
-				    UserOp user_op,
-				    Functionality& functionality,
-				    Red reduction, Result reduction_start,
-				    Result& output, typename
-				    std::iterator_traits<InputIterator>::
-				    difference_type bound,
-				    _Parallelism parallelism_tag)
+   *  @param __reduction Reduction functor.
+   *  @param __reduction_start Initial value for reduction.
+   *  @param __output Output iterator.
+   *  @param __bound Maximum number of elements processed.
+   *  @param __parallelism_tag Parallelization method */
+  template<typename _IIter, typename _UserOp,
+	   typename _Functionality, typename _Red, typename _Result>
+    _UserOp
+    __for_each_template_random_access(_IIter __begin, _IIter __end,
+				    _UserOp __user_op,
+				    _Functionality& __functionality,
+				    _Red __reduction, _Result __reduction_start,
+				    _Result& __output, typename
+				    std::iterator_traits<_IIter>::
+				    difference_type __bound,
+				    _Parallelism __parallelism_tag)
     {
-      if (parallelism_tag == parallel_unbalanced)
-	return for_each_template_random_access_ed(begin, end, user_op,
-						  functionality, reduction,
-						  reduction_start,
-						  output, bound);
-      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);
-      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);
+      if (__parallelism_tag == parallel_unbalanced)
+	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);
+      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);
       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);
   }
 }
 
diff --git a/libstdc++-v3/include/parallel/for_each_selectors.h b/libstdc++-v3/include/parallel/for_each_selectors.h
index b46d30f..ed8728d 100644
--- a/libstdc++-v3/include/parallel/for_each_selectors.h
+++ b/libstdc++-v3/include/parallel/for_each_selectors.h
@@ -38,192 +38,192 @@
 namespace __gnu_parallel
 {
 
-  /** @brief Generic selector for embarrassingly parallel functions. */
-  template<typename It>
-  struct generic_for_each_selector
+  /** @brief Generic __selector for embarrassingly parallel functions. */
+  template<typename _It>
+  struct __generic_for_each_selector
   {
-    /** @brief Iterator on last element processed; needed for some
+    /** @brief _Iterator on last element processed; needed for some
      *  algorithms (e. g. std::transform()).
      */
-    It finish_iterator;
+    _It finish_iterator;
   };
 
 
   /** @brief std::for_each() selector. */
-  template<typename It>
-    struct for_each_selector : public generic_for_each_selector<It>
+  template<typename _It>
+    struct __for_each_selector : public __generic_for_each_selector<_It>
     {
       /** @brief Functor execution.
-       *  @param o Operator.
-       *  @param i Iterator referencing object. */
-      template<typename Op>
+       *  @param __o Operator.
+       *  @param __i iterator referencing object. */
+      template<typename _Op>
         bool
-        operator()(Op& o, It i)
+        operator()(_Op& __o, _It __i)
 	{
-	  o(*i);
+	  __o(*__i);
 	  return true;
 	}
     };
 
   /** @brief std::generate() selector. */
-  template<typename It>
-    struct generate_selector : public generic_for_each_selector<It>
+  template<typename _It>
+    struct __generate_selector : public __generic_for_each_selector<_It>
     {
       /** @brief Functor execution.
-       *  @param o Operator.
-       *  @param i Iterator referencing object. */
-      template<typename Op>
+       *  @param __o Operator.
+       *  @param __i iterator referencing object. */
+      template<typename _Op>
         bool
-        operator()(Op& o, It i)
+        operator()(_Op& __o, _It __i)
         {
-	  *i = o();
+	  *__i = __o();
 	  return true;
 	}
     };
 
   /** @brief std::fill() selector. */
-  template<typename It>
-    struct fill_selector : public generic_for_each_selector<It>
+  template<typename _It>
+    struct __fill_selector : public __generic_for_each_selector<_It>
     {
       /** @brief Functor execution.
-       *  @param v Current value.
-       *  @param i Iterator referencing object. */
+       *  @param __v Current value.
+       *  @param __i iterator referencing object. */
       template<typename Val>
         bool
-        operator()(Val& v, It i)
+        operator()(Val& __v, _It __i)
 	{
-	  *i = v;
+	  *__i = __v;
 	  return true;
 	}
     };
 
-  /** @brief std::transform() selector, one input sequence variant. */
-  template<typename It>
-    struct transform1_selector : public generic_for_each_selector<It>
+  /** @brief std::transform() __selector, one input sequence variant. */
+  template<typename _It>
+    struct __transform1_selector : public __generic_for_each_selector<_It>
     {
       /** @brief Functor execution.
-       *  @param o Operator.
-       *  @param i Iterator referencing object. */
-      template<typename Op>
+       *  @param __o Operator.
+       *  @param __i iterator referencing object. */
+      template<typename _Op>
         bool
-        operator()(Op& o, It i)
+        operator()(_Op& __o, _It __i)
 	{
-	  *i.second = o(*i.first);
+	  *__i.second = __o(*__i.first);
 	  return true;
 	}
     };
 
-  /** @brief std::transform() selector, two input sequences variant. */
-  template<typename It>
-    struct transform2_selector : public generic_for_each_selector<It>
+  /** @brief std::transform() __selector, two input sequences variant. */
+  template<typename _It>
+    struct __transform2_selector : public __generic_for_each_selector<_It>
     {
       /** @brief Functor execution.
-       *  @param o Operator.
-       *  @param i Iterator referencing object. */
-      template<typename Op>
+       *  @param __o Operator.
+       *  @param __i iterator referencing object. */
+      template<typename _Op>
         bool
-        operator()(Op& o, It i)
+        operator()(_Op& __o, _It __i)
 	{
-	  *i.third = o(*i.first, *i.second);
+	  *__i.__third = __o(*__i.__first, *__i.__second);
 	  return true;
 	}
     };
 
   /** @brief std::replace() selector. */
-  template<typename It, typename T>
-    struct replace_selector : public generic_for_each_selector<It>
+  template<typename _It, typename _Tp>
+    struct __replace_selector : public __generic_for_each_selector<_It>
     {
       /** @brief Value to replace with. */
-      const T& new_val;
+      const _Tp& __new_val;
 
       /** @brief Constructor
-       *  @param new_val Value to replace with. */
+       *  @param __new_val Value to replace with. */
       explicit
-      replace_selector(const T &new_val) : new_val(new_val) {}
+      __replace_selector(const _Tp &__new_val) : __new_val(__new_val) {}
 
       /** @brief Functor execution.
-       *  @param v Current value.
-       *  @param i Iterator referencing object. */
+       *  @param __v Current value.
+       *  @param __i iterator referencing object. */
       bool
-      operator()(T& v, It i)
+      operator()(_Tp& __v, _It __i)
       {
-	if (*i == v)
-	  *i = new_val;
+	if (*__i == __v)
+	  *__i = __new_val;
 	return true;
       }
     };
 
   /** @brief std::replace() selector. */
-  template<typename It, typename Op, typename T>
-    struct replace_if_selector : public generic_for_each_selector<It>
+  template<typename _It, typename _Op, typename _Tp>
+    struct __replace_if_selector : public __generic_for_each_selector<_It>
     {
       /** @brief Value to replace with. */
-      const T& new_val;
+      const _Tp& __new_val;
 
       /** @brief Constructor.
-       *  @param new_val Value to replace with. */
+       *  @param __new_val Value to replace with. */
       explicit
-      replace_if_selector(const T &new_val) : new_val(new_val) { }
+      __replace_if_selector(const _Tp &__new_val) : __new_val(__new_val) { }
 
       /** @brief Functor execution.
-       *  @param o Operator.
-       *  @param i Iterator referencing object. */
+       *  @param __o Operator.
+       *  @param __i iterator referencing object. */
       bool
-      operator()(Op& o, It i)
+      operator()(_Op& __o, _It __i)
       {
-	if (o(*i))
-	  *i = new_val;
+	if (__o(*__i))
+	  *__i = __new_val;
 	return true;
       }
     };
 
   /** @brief std::count() selector. */
-  template<typename It, typename Diff>
-    struct count_selector : public generic_for_each_selector<It>
+  template<typename _It, typename _Diff>
+    struct __count_selector : public __generic_for_each_selector<_It>
     {
       /** @brief Functor execution.
-       *  @param v Current value.
-       *  @param i Iterator referencing object.
+       *  @param __v Current value.
+       *  @param __i iterator referencing object.
        *  @return 1 if count, 0 if does not count. */
       template<typename Val>
-        Diff
-        operator()(Val& v, It i)
-	{ return (v == *i) ? 1 : 0; }
+        _Diff
+        operator()(Val& __v, _It __i)
+	{ return (__v == *__i) ? 1 : 0; }
     };
 
   /** @brief std::count_if () selector. */
-  template<typename It, typename Diff>
-    struct count_if_selector : public generic_for_each_selector<It>
+  template<typename _It, typename _Diff>
+    struct __count_if_selector : public __generic_for_each_selector<_It>
     {
       /** @brief Functor execution.
-       *  @param o Operator.
-       *  @param i Iterator referencing object.
+       *  @param __o Operator.
+       *  @param __i iterator referencing object.
        *  @return 1 if count, 0 if does not count. */
-      template<typename Op>
-        Diff
-        operator()(Op& o, It i)
-	{ return (o(*i)) ? 1 : 0; }
+      template<typename _Op>
+        _Diff
+        operator()(_Op& __o, _It __i)
+	{ return (__o(*__i)) ? 1 : 0; }
     };
 
   /** @brief std::accumulate() selector. */
-  template<typename It>
-    struct accumulate_selector : public generic_for_each_selector<It>
+  template<typename _It>
+    struct __accumulate_selector : public __generic_for_each_selector<_It>
     {
       /** @brief Functor execution.
-       *  @param o Operator (unused).
-       *  @param i Iterator referencing object.
+       *  @param __o Operator (unused).
+       *  @param __i iterator referencing object.
        *  @return The current value. */
-      template<typename Op>
-        typename std::iterator_traits<It>::value_type operator()(Op o, It i)
-	{ return *i; }
+      template<typename _Op>
+        typename std::iterator_traits<_It>::value_type operator()(_Op __o, _It __i)
+	{ return *__i; }
     };
 
   /** @brief std::inner_product() selector. */
-  template<typename It, typename It2, typename T>
-    struct inner_product_selector : public generic_for_each_selector<It>
+  template<typename _It, typename It2, typename _Tp>
+    struct __inner_product_selector : public __generic_for_each_selector<_It>
     {
       /** @brief Begin iterator of first sequence. */
-      It begin1_iterator;
+      _It __begin1_iterator;
 
       /** @brief Begin iterator of second sequence. */
       It2 begin2_iterator;
@@ -232,50 +232,50 @@ namespace __gnu_parallel
        *  @param b1 Begin iterator of first sequence.
        *  @param b2 Begin iterator of second sequence. */
       explicit
-      inner_product_selector(It b1, It2 b2)
-      : begin1_iterator(b1), begin2_iterator(b2) { }
+      __inner_product_selector(_It b1, It2 b2)
+      : __begin1_iterator(b1), begin2_iterator(b2) { }
 
       /** @brief Functor execution.
-       *  @param mult Multiplication functor.
-       *  @param current Iterator referencing object.
-       *  @return Inner product elemental result. */
-      template<typename Op>
-        T
-        operator()(Op mult, It current)
+       *  @param __mult Multiplication functor.
+       *  @param __current iterator referencing object.
+       *  @return Inner product elemental __result. */
+      template<typename _Op>
+        _Tp
+        operator()(_Op __mult, _It __current)
 	{
-	  typename std::iterator_traits<It>::difference_type position
-	    = current - begin1_iterator;
-	  return mult(*current, *(begin2_iterator + position));
+	  typename std::iterator_traits<_It>::difference_type __position
+	    = __current - __begin1_iterator;
+	  return __mult(*__current, *(begin2_iterator + __position));
 	}
     };
 
   /** @brief Selector that just returns the passed iterator. */
-  template<typename It>
-    struct identity_selector : public generic_for_each_selector<It>
+  template<typename _It>
+    struct __identity_selector : public __generic_for_each_selector<_It>
     {
       /** @brief Functor execution.
-       *  @param o Operator (unused).
-       *  @param i Iterator referencing object.
+       *  @param __o Operator (unused).
+       *  @param __i iterator referencing object.
        *  @return Passed iterator. */
-      template<typename Op>
-        It
-        operator()(Op o, It i)
-	{ return i; }
+      template<typename _Op>
+        _It
+        operator()(_Op __o, _It __i)
+	{ return __i; }
     };
 
   /** @brief Selector that returns the difference between two adjacent
-   *  elements.
+   *  __elements.
    */
-  template<typename It>
-    struct adjacent_difference_selector : public generic_for_each_selector<It>
+  template<typename _It>
+    struct __adjacent_difference_selector : public __generic_for_each_selector<_It>
     {
-      template<typename Op>
+      template<typename _Op>
         bool
-        operator()(Op& o, It i)
+        operator()(_Op& __o, _It __i)
 	{
-	  typename It::first_type go_back_one = i.first;
-	  --go_back_one;
-	  *i.second = o(*i.first, *go_back_one);
+	  typename _It::first_type __go_back_one = __i.first;
+	  --__go_back_one;
+	  *__i.__second = __o(*__i.__first, *__go_back_one);
 	  return true;
 	}
     };
@@ -283,77 +283,77 @@ namespace __gnu_parallel
   // XXX move into type_traits?
   /** @brief Functor doing nothing
    *
-   *  For some reduction tasks (this is not a function object, but is
-   *  passed as selector dummy parameter.
+   *  For some __reduction tasks (this is not a function object, but is
+   *  passed as __selector __dummy parameter.
    */
-  struct nothing
+  struct _Nothing
   {
     /** @brief Functor execution.
-     *  @param i Iterator referencing object. */
-    template<typename It>
+     *  @param __i iterator referencing object. */
+    template<typename _It>
       void
-      operator()(It i) { }
+      operator()(_It __i) { }
   };
 
   /** @brief Reduction function doing nothing. */
-  struct dummy_reduct
+  struct _DummyReduct
   {
     bool
-    operator()(bool /*x*/, bool /*y*/) const
+    operator()(bool /*__x*/, bool /*__y*/) const
     { return true; }
   };
 
   /** @brief Reduction for finding the maximum element, using a comparator. */
-  template<typename Comp, typename It>
-    struct min_element_reduct
+  template<typename _Compare, typename _It>
+    struct __min_element_reduct
     {
-      Comp& comp;
+      _Compare& __comp;
 
       explicit
-      min_element_reduct(Comp &c) : comp(c) { }
+      __min_element_reduct(_Compare &__c) : __comp(__c) { }
 
-      It
-      operator()(It x, It y)
+      _It
+      operator()(_It __x, _It __y)
       {
-	if (comp(*x, *y))
-	  return x;
+	if (__comp(*__x, *__y))
+	  return __x;
 	else
-	  return y;
+	  return __y;
       }
     };
 
   /** @brief Reduction for finding the maximum element, using a comparator. */
-  template<typename Comp, typename It>
-    struct max_element_reduct
+  template<typename _Compare, typename _It>
+    struct __max_element_reduct
     {
-      Comp& comp;
+      _Compare& __comp;
 
       explicit
-      max_element_reduct(Comp& c) : comp(c) { }
+      __max_element_reduct(_Compare& __c) : __comp(__c) { }
 
-      It
-      operator()(It x, It y)
+      _It
+      operator()(_It __x, _It __y)
       {
-	if (comp(*x, *y))
-	  return y;
+	if (__comp(*__x, *__y))
+	  return __y;
 	else
-	  return x;
+	  return __x;
       }
     };
 
   /** @brief General reduction, using a binary operator. */
-  template<typename BinOp>
-    struct accumulate_binop_reduct
+  template<typename _BinOp>
+    struct __accumulate_binop_reduct
     {
-      BinOp& binop;
+      _BinOp& __binop;
 
       explicit
-      accumulate_binop_reduct(BinOp& b) : binop(b) { }
+      __accumulate_binop_reduct(_BinOp& __b) : __binop(__b) { }
 
-      template<typename Result, typename Addend>
-        Result
-        operator()(const Result& x, const Addend& y)
-	{ return binop(x, y); }
+      template<typename _Result, typename _Addend>
+        _Result
+        operator()(const _Result& __x, const _Addend& __y)
+	{ return __binop(__x, __y); }
     };
 }
 
diff --git a/libstdc++-v3/include/parallel/iterator.h b/libstdc++-v3/include/parallel/iterator.h
index c9bfd5a..1baade8 100644
--- a/libstdc++-v3/include/parallel/iterator.h
+++ b/libstdc++-v3/include/parallel/iterator.h
@@ -40,160 +40,160 @@ namespace __gnu_parallel
   /** @brief A pair of iterators. The usual iterator operations are
    *  applied to both child iterators.
    */
-  template<typename Iterator1, typename Iterator2, typename IteratorCategory>
-    class iterator_pair : public std::pair<Iterator1, Iterator2>
+  template<typename _Iterator1, typename _Iterator2, typename _IteratorCategory>
+    class _IteratorPair : public std::pair<_Iterator1, _Iterator2>
     {
     private:
-      typedef iterator_pair<Iterator1, Iterator2, IteratorCategory> type;
-      typedef std::pair<Iterator1, Iterator2> base_type;
+      typedef _IteratorPair<_Iterator1, _Iterator2, _IteratorCategory> _Self;
+      typedef std::pair<_Iterator1, _Iterator2> _Base;
 
     public:
-      typedef IteratorCategory iterator_category;
+      typedef _IteratorCategory iterator_category;
       typedef void value_type;
 
-      typedef std::iterator_traits<Iterator1> traits_type;
-      typedef typename traits_type::difference_type difference_type;
-      typedef type* pointer;
-      typedef type& reference;
+      typedef std::iterator_traits<_Iterator1> _TraitsType;
+      typedef typename _TraitsType::difference_type difference_type;
+      typedef _Self* pointer;
+      typedef _Self& reference;
 
-      iterator_pair() { }
+      _IteratorPair() { }
 
-      iterator_pair(const Iterator1& first, const Iterator2& second) 
-      : base_type(first, second) { }
+      _IteratorPair(const _Iterator1& __first, const _Iterator2& __second) 
+      : _Base(__first, __second) { }
 
       // Pre-increment operator.
-      type&
+      _Self&
       operator++()
       {
-	++base_type::first;
-	++base_type::second;
+	++_Base::first;
+	++_Base::second;
 	return *this;
       }
 
       // Post-increment operator.
-      const type
+      const _Self
       operator++(int)
-      { return type(base_type::first++, base_type::second++); }
+      { return _Self(_Base::first++, _Base::second++); }
 
       // Pre-decrement operator.
-      type&
+      _Self&
       operator--()
       {
-	--base_type::first;
-	--base_type::second;
+	--_Base::first;
+	--_Base::second;
 	return *this;
       }
 
       // Post-decrement operator.
-      const type
+      const _Self
       operator--(int)
-      { return type(base_type::first--, base_type::second--); }
+      { return _Self(_Base::first--, _Base::second--); }
 
       // Type conversion.
-      operator Iterator2() const
-      { return base_type::second; }
+      operator _Iterator2() const
+      { return _Base::second; }
 
-      type&
-      operator=(const type& other)
+      _Self&
+      operator=(const _Self& __other)
       {
-	base_type::first = other.first;
-	base_type::second = other.second;
+	_Base::first = __other.first;
+	_Base::second = __other.second;
 	return *this;
       }
 
-      type
-      operator+(difference_type delta) const
-      { return type(base_type::first + delta, base_type::second + delta); }
+      _Self
+      operator+(difference_type __delta) const
+      { return _Self(_Base::first + __delta, _Base::second + __delta); }
 
       difference_type
-      operator-(const type& other) const
-      { return base_type::first - other.first; }
+      operator-(const _Self& __other) const
+      { return _Base::first - __other.first; }
   };
 
 
   /** @brief A triple of iterators. The usual iterator operations are
       applied to all three child iterators.
    */
-  template<typename Iterator1, typename Iterator2, typename Iterator3,
-	   typename IteratorCategory>
-    class iterator_triple
+  template<typename _Iterator1, typename _Iterator2, typename _Iterator3,
+	   typename _IteratorCategory>
+    class _IteratorTriple
     {
     private:
-      typedef iterator_triple<Iterator1, Iterator2, Iterator3,
-			      IteratorCategory> type;
+      typedef _IteratorTriple<_Iterator1, _Iterator2, _Iterator3,
+			      _IteratorCategory> _Self;
 
     public:
-      typedef IteratorCategory iterator_category;
+      typedef _IteratorCategory iterator_category;
       typedef void value_type;
-      typedef typename std::iterator_traits<Iterator1>::difference_type
+      typedef typename std::iterator_traits<_Iterator1>::difference_type
                                                             difference_type;
-      typedef type* pointer;
-      typedef type& reference;
+      typedef _Self* pointer;
+      typedef _Self& reference;
 
-      Iterator1 first;
-      Iterator2 second;
-      Iterator3 third;
+      _Iterator1 __first;
+      _Iterator2 __second;
+      _Iterator3 __third;
 
-      iterator_triple() { }
+      _IteratorTriple() { }
 
-      iterator_triple(const Iterator1& _first, const Iterator2& _second,
-		      const Iterator3& _third)
+      _IteratorTriple(const _Iterator1& _first, const _Iterator2& _second,
+		      const _Iterator3& _third)
       {
-	first = _first;
-	second = _second;
-	third = _third;
+	__first = _first;
+	__second = _second;
+	__third = _third;
       }
 
       // Pre-increment operator.
-      type&
+      _Self&
       operator++()
       {
-	++first;
-	++second;
-	++third;
+	++__first;
+	++__second;
+	++__third;
 	return *this;
       }
 
       // Post-increment operator.
-      const type
+      const _Self
       operator++(int)
-      { return type(first++, second++, third++); }
+      { return _Self(__first++, __second++, __third++); }
 
       // Pre-decrement operator.
-      type&
+      _Self&
       operator--()
       {
-	--first;
-	--second;
-	--third;
+	--__first;
+	--__second;
+	--__third;
 	return *this;
       }
 
       // Post-decrement operator.
-      const type
+      const _Self
       operator--(int)
-      { return type(first--, second--, third--); }
+      { return _Self(__first--, __second--, __third--); }
 
       // Type conversion.
-      operator Iterator3() const
-      { return third; }
+      operator _Iterator3() const
+      { return __third; }
 
-      type&
-      operator=(const type& other)
+      _Self&
+      operator=(const _Self& __other)
       {
-	first = other.first;
-	second = other.second;
-	third = other.third;
+	__first = __other.__first;
+	__second = __other.__second;
+	__third = __other.__third;
 	return *this;
       }
 
-      type
-      operator+(difference_type delta) const
-      { return type(first + delta, second + delta, third + delta); }
+      _Self
+      operator+(difference_type __delta) const
+      { return _Self(__first + __delta, __second + __delta, __third + __delta); }
 
       difference_type
-      operator-(const type& other) const
-      { return first - other.first; }
+      operator-(const _Self& __other) const
+      { return __first - __other.__first; }
   };
 }
 
diff --git a/libstdc++-v3/include/parallel/list_partition.h b/libstdc++-v3/include/parallel/list_partition.h
index a359a3f..5065a86 100644
--- a/libstdc++-v3/include/parallel/list_partition.h
+++ b/libstdc++-v3/include/parallel/list_partition.h
@@ -3,12 +3,12 @@
 // 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
+// software; you can redistribute __it and/or modify __it under the terms
 // of the GNU General Public License as published by the Free Software
 // Foundation; either version 3, or (at your option) any later
 // version.
 
-// This library is distributed in the hope that it will be useful, but
+// This library is distributed in the hope that __it will be useful, but
 // WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 // General Public License for more details.
@@ -23,7 +23,7 @@
 // <http://www.gnu.org/licenses/>.
 
 /** @file parallel/list_partition.h
- *  @brief Functionality to split sequence referenced by only input
+ *  @brief _Functionality to split __sequence referenced by only input
  *  iterators.
  *  This file is a GNU parallel extension to the Standard C++ Library.
  */
@@ -39,137 +39,137 @@
 namespace __gnu_parallel
 {
   /** @brief Shrinks and doubles the ranges.
-   *  @param os_starts Start positions worked on (oversampled).
-   *  @param count_to_two Counts up to 2.
-   *  @param range_length Current length of a chunk.
-   *  @param make_twice Whether the @c os_starts is allowed to be
+   *  @param __os_starts Start positions worked on (oversampled).
+   *  @param __count_to_two Counts up to 2.
+   *  @param __range_length Current length of a chunk.
+   *  @param __make_twice Whether the @__c __os_starts is allowed to be
    *  grown or not
    */
-  template<typename InputIterator>
+  template<typename _IIter>
     void
-    shrink_and_double(std::vector<InputIterator>& os_starts,
-		      size_t& count_to_two, size_t& range_length,
-		      const bool make_twice)
+    __shrink_and_double(std::vector<_IIter>& __os_starts,
+		      size_t& __count_to_two, size_t& __range_length,
+		      const bool __make_twice)
     {
-      ++count_to_two;
-      if (not make_twice or count_to_two < 2)
-	shrink(os_starts, count_to_two, range_length);
+      ++__count_to_two;
+      if (not __make_twice or __count_to_two < 2)
+	__shrink(__os_starts, __count_to_two, __range_length);
       else
 	{
-	  os_starts.resize((os_starts.size() - 1) * 2 + 1);
-	  count_to_two = 0;
+	  __os_starts.resize((__os_starts.size() - 1) * 2 + 1);
+	  __count_to_two = 0;
 	}
     }
 
   /** @brief Combines two ranges into one and thus halves the number of ranges.
-   *  @param os_starts Start positions worked on (oversampled).
-   *  @param count_to_two Counts up to 2.
-   *  @param range_length Current length of a chunk. */
-  template<typename InputIterator>
+   *  @param __os_starts Start positions worked on (oversampled).
+   *  @param __count_to_two Counts up to 2.
+   *  @param __range_length Current length of a chunk. */
+  template<typename _IIter>
     void
-    shrink(std::vector<InputIterator>& os_starts, size_t& count_to_two,
-	   size_t& range_length)
+    __shrink(std::vector<_IIter>& __os_starts, size_t& __count_to_two,
+	   size_t& __range_length)
     {
-      for (typename std::vector<InputIterator>::size_type i = 0;
-	   i <= (os_starts.size() / 2); ++i)
-	os_starts[i] = os_starts[i * 2];
-      range_length *= 2;
+      for (typename std::vector<_IIter>::size_type __i = 0;
+	   __i <= (__os_starts.size() / 2); ++__i)
+	__os_starts[__i] = __os_starts[__i * 2];
+      __range_length *= 2;
     }
 
   /** @brief Splits a sequence given by input iterators into parts of
    * almost equal size
    *
    *  The function needs only one pass over the sequence.
-   *  @param begin Begin iterator of input sequence.
-   *  @param end End iterator of input sequence.
-   *  @param starts Start iterators for the resulting parts, dimension
-   *  @c num_parts+1. For convenience, @c starts @c [num_parts]
+   *  @param __begin Begin iterator of input sequence.
+   *  @param __end End iterator of input sequence.
+   *  @param __starts Start iterators for the resulting parts, dimension
+   *  @__c __num_parts+1. For convenience, @__c __starts @__c [__num_parts]
    *  contains the end iterator of the sequence.
-   *  @param lengths Length of the resulting parts.
-   *  @param num_parts Number of parts to split the sequence into.
-   *  @param f Functor to be applied to each element by traversing it
-   *  @param oversampling Oversampling factor. If 0, then the
-   *  partitions will differ in at most @f$ \sqrt{\mathrm{end} -
-   *  \mathrm{begin}} @f$ elements. Otherwise, the ratio between the
-   *  longest and the shortest part is bounded by @f$
-   *  1/(\mathrm{oversampling} \cdot \mathrm{num\_parts}) @f$.
+   *  @param __lengths Length of the resulting parts.
+   *  @param __num_parts Number of parts to split the sequence into.
+   *  @param __f Functor to be applied to each element by traversing __it
+   *  @param __oversampling Oversampling factor. If 0, then the
+   *  partitions will differ in at most @__f$ \sqrt{\mathrm{__end} -
+   *  \mathrm{__begin}} @__f$ __elements. Otherwise, the ratio between the
+   *  longest and the shortest part is bounded by @__f$
+   *  1/(\mathrm{__oversampling} \cdot \mathrm{num\_parts}) @__f$.
    *  @return Length of the whole sequence.
    */
-  template<typename InputIterator, typename FunctorType>
+  template<typename _IIter, typename _FunctorType>
     size_t
-    list_partition(const InputIterator begin, const InputIterator end,
-		   InputIterator* starts, size_t* lengths, const int num_parts,
-		   FunctorType& f, int oversampling = 0)
+    list_partition(const _IIter __begin, const _IIter __end,
+		   _IIter* __starts, size_t* __lengths, const int __num_parts,
+		   _FunctorType& __f, int __oversampling = 0)
     {
-      bool make_twice = false;
+      bool __make_twice = false;
 
       // The resizing algorithm is chosen according to the oversampling factor.
-      if (oversampling == 0)
+      if (__oversampling == 0)
 	{
-	  make_twice = true;
-	  oversampling = 1;
+	  __make_twice = true;
+	  __oversampling = 1;
 	}
 
-      std::vector<InputIterator> os_starts(2 * oversampling * num_parts + 1);
+      std::vector<_IIter> __os_starts(2 * __oversampling * __num_parts + 1);
 
-      os_starts[0]= begin;
-      InputIterator prev = begin, it = begin;
-      size_t dist_limit = 0, dist = 0;
-      size_t cur = 1, next = 1;
-      size_t range_length = 1;
-      size_t count_to_two = 0;
-      while (it != end)
+      __os_starts[0]= __begin;
+      _IIter __prev = __begin, __it = __begin;
+      size_t __dist_limit = 0, __dist = 0;
+      size_t __cur = 1, __next = 1;
+      size_t __range_length = 1;
+      size_t __count_to_two = 0;
+      while (__it != __end)
 	{
-	  cur = next;
-	  for (; cur < os_starts.size() and it != end; ++cur)
+	  __cur = __next;
+	  for (; __cur < __os_starts.size() and __it != __end; ++__cur)
 	    {
-	      for (dist_limit += range_length;
-		   dist < dist_limit and it != end; ++dist)
+	      for (__dist_limit += __range_length;
+		   __dist < __dist_limit and __it != __end; ++__dist)
 		{
-		  f(it);
-		  ++it;
+		  __f(__it);
+		  ++__it;
 		}
-	      os_starts[cur] = it;
+	      __os_starts[__cur] = __it;
 	    }
 
-	  // Must compare for end and not cur < os_starts.size() , because
-	  // cur could be == os_starts.size() as well
-	  if (it == end)
+	  // Must compare for end and not __cur < __os_starts.size() , because
+	  // __cur could be == __os_starts.size() as well
+	  if (__it == __end)
 	    break;
 
-	  shrink_and_double(os_starts, count_to_two, range_length, make_twice);
-	  next = os_starts.size() / 2 + 1;
+	  __shrink_and_double(__os_starts, __count_to_two, __range_length, __make_twice);
+	  __next = __os_starts.size() / 2 + 1;
 	}
 
-      // Calculation of the parts (one must be extracted from current
-      // because the partition beginning at end, consists only of
+      // Calculation of the parts (one must be extracted from __current
+      // because the partition beginning at __end, consists only of
       // itself).
-      size_t size_part = (cur - 1) / num_parts;
-      int size_greater = static_cast<int>((cur - 1) % num_parts);
-      starts[0] = os_starts[0];
+      size_t __size_part = (__cur - 1) / __num_parts;
+      int __size_greater = static_cast<int>((__cur - 1) % __num_parts);
+      __starts[0] = __os_starts[0];
 
-      size_t index = 0;
+      size_t __index = 0;
 
       // Smallest partitions.
-      for (int i = 1; i < (num_parts + 1 - size_greater); ++i)
+      for (int __i = 1; __i < (__num_parts + 1 - __size_greater); ++__i)
 	{
-	  lengths[i - 1] =  size_part * range_length;
-	  index += size_part;
-	  starts[i] = os_starts[index];
+	  __lengths[__i - 1] =  __size_part * __range_length;
+	  __index += __size_part;
+	  __starts[__i] = __os_starts[__index];
 	}
 
       // Biggest partitions.
-      for (int i = num_parts + 1 - size_greater; i <= num_parts; ++i)
+      for (int __i = __num_parts + 1 - __size_greater; __i <= __num_parts; ++__i)
 	{
-	  lengths[i - 1] =  (size_part+1) * range_length;
-	  index += (size_part+1);
-	  starts[i] = os_starts[index];
+	  __lengths[__i - 1] =  (__size_part+1) * __range_length;
+	  __index += (__size_part+1);
+	  __starts[__i] = __os_starts[__index];
 	}
 
       // Correction of the end size (the end iteration has not finished).
-      lengths[num_parts - 1] -= (dist_limit - dist);
+      __lengths[__num_parts - 1] -= (__dist_limit - __dist);
 
-      return dist;
+      return __dist;
     }
 }
 
diff --git a/libstdc++-v3/include/parallel/losertree.h b/libstdc++-v3/include/parallel/losertree.h
index 6dbd592..b981025 100644
--- a/libstdc++-v3/include/parallel/losertree.h
+++ b/libstdc++-v3/include/parallel/losertree.h
@@ -46,45 +46,45 @@ namespace __gnu_parallel
  *
  * The smallest element is at the top.
  *
- * Guarding is done explicitly through one flag sup per element,
+ * Guarding is done explicitly through one flag _M_sup per element,
  * inf is not needed due to a better initialization routine.  This
  * is a well-performing variant.
  *
- * @param T the element type
- * @param Comparator the comparator to use, defaults to std::less<T>
+ * @param _Tp the element _Self
+ * @param _Compare the comparator to use, defaults to std::less<_Tp>
  */
-template<typename T, typename Comparator>
+template<typename _Tp, typename _Compare>
 class LoserTreeBase
 {
 protected:
   /** @brief Internal representation of a LoserTree element. */
-  struct Loser
-  {
-    /** @brief flag, true iff this is a "maximum" sentinel. */
-    bool sup;
-    /** @brief index of the source sequence. */
-    int source;
-    /** @brief key of the element in the LoserTree. */
-    T key;
+  struct _Loser
+  {
+    /** @brief flag, true iff this is a "maximum" __sentinel. */
+    bool _M_sup;
+    /** @brief __index of the _M_source __sequence. */
+    int _M_source;
+    /** @brief _M_key of the element in the LoserTree. */
+    _Tp _M_key;
   };
 
-  unsigned int ik, k, offset;
+  unsigned int __ik, __k, __offset;
 
-  /** log_2{k} */
+  /** log_2{__k} */
   unsigned int _M_log_k;
 
-  /** @brief LoserTree elements. */
-  Loser* losers;
+  /** @brief LoserTree __elements. */
+  _Loser* __losers;
 
-  /** @brief Comparator to use. */
-  Comparator comp;
+  /** @brief _Compare to use. */
+  _Compare __comp;
 
   /**
    * @brief State flag that determines whether the LoserTree is empty.
    *
    * Only used for building the LoserTree.
    */
-  bool first_insert;
+  bool __first_insert;
 
 public:
   /**
@@ -93,117 +93,117 @@ public:
    * @param _k The number of sequences to merge.
    * @param _comp The comparator to use.
    */
-  LoserTreeBase(unsigned int _k, Comparator _comp)
-  : comp(_comp)
+  LoserTreeBase(unsigned int _k, _Compare _comp)
+  : __comp(_comp)
   {
-    ik = _k;
+    __ik = _k;
 
-    // Compute log_2{k} for the Loser Tree
-    _M_log_k = __log2(ik - 1) + 1;
+    // Compute log_2{__k} for the _Loser Tree
+    _M_log_k = __log2(__ik - 1) + 1;
 
     // Next greater power of 2.
-    k = 1 << _M_log_k;
-    offset = k;
+    __k = 1 << _M_log_k;
+    __offset = __k;
 
-    // Avoid default-constructing losers[].key
-    losers = static_cast<Loser*>(::operator new(2 * k * sizeof(Loser)));
-    for (unsigned int i = ik - 1; i < k; ++i)
-      losers[i + k].sup = true;
+    // Avoid default-constructing __losers[]._M_key
+    __losers = static_cast<_Loser*>(::operator new(2 * __k * sizeof(_Loser)));
+    for (unsigned int __i = __ik - 1; __i < __k; ++__i)
+      __losers[__i + __k]._M_sup = true;
 
-    first_insert = true;
+    __first_insert = true;
   }
 
   /**
    * @brief The destructor.
    */
   ~LoserTreeBase()
-  { ::operator delete(losers); }
+  { ::operator delete(__losers); }
 
   /**
-   * @brief Initializes the sequence "source" with the element "key".
+   * @brief Initializes the sequence "_M_source" with the element "_M_key".
    *
-   * @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.
+   * @param _M_key the element to insert
+   * @param _M_source __index of the _M_source __sequence
+   * @param _M_sup flag that determines whether the value to insert is an
+   *   explicit __supremum.
    */
   inline void
-  insert_start(const T& key, int source, bool sup)
+  __insert_start(const _Tp& _M_key, int _M_source, bool _M_sup)
   {
-    unsigned int pos = k + source;
+    unsigned int __pos = __k + _M_source;
 
-    if(first_insert)
+    if(__first_insert)
       {
         // Construct all keys, so we can easily deconstruct them.
-        for (unsigned int i = 0; i < (2 * k); ++i)
-          new(&(losers[i].key)) T(key);
-        first_insert = false;
+        for (unsigned int __i = 0; __i < (2 * __k); ++__i)
+          new(&(__losers[__i]._M_key)) _Tp(_M_key);
+        __first_insert = false;
       }
     else
-      new(&(losers[pos].key)) T(key);
+      new(&(__losers[__pos]._M_key)) _Tp(_M_key);
 
-    losers[pos].sup = sup;
-    losers[pos].source = source;
+    __losers[__pos]._M_sup = _M_sup;
+    __losers[__pos]._M_source = _M_source;
   }
 
   /**
    * @return the index of the sequence with the smallest element.
    */
-  int get_min_source()
-  { return losers[0].source; }
+  int __get_min_source()
+  { return __losers[0]._M_source; }
 };
 
 /**
  * @brief Stable LoserTree variant.
  *
- * Provides the stable implementations of insert_start, init_winner,
- * init and delete_min_insert.
+ * Provides the stable implementations of insert_start, __init_winner,
+ * __init and __delete_min_insert.
  *
  * Unstable variant is done using partial specialisation below.
  */
-template<bool stable/* default == true */, typename T, typename Comparator>
-class LoserTree : public LoserTreeBase<T, Comparator>
+template<bool __stable/* default == true */, typename _Tp, typename _Compare>
+class LoserTree : public LoserTreeBase<_Tp, _Compare>
 {
-  typedef LoserTreeBase<T, Comparator> Base;
-  using Base::k;
-  using Base::losers;
-  using Base::first_insert;
+  typedef LoserTreeBase<_Tp, _Compare> Base;
+  using Base::__k;
+  using Base::__losers;
+  using Base::__first_insert;
 
 public:
-  LoserTree(unsigned int _k, Comparator _comp)
+  LoserTree(unsigned int _k, _Compare _comp)
   : Base::LoserTreeBase(_k, _comp)
   {}
 
   unsigned int
-  init_winner(unsigned int root)
+  __init_winner(unsigned int __root)
   {
-    if (root >= k)
+    if (__root >= __k)
       {
-        return root;
+        return __root;
       }
     else
       {
-        unsigned int left = init_winner (2 * root);
-        unsigned int right = init_winner (2 * root + 1);
-        if (losers[right].sup
-            || (!losers[left].sup
-              && !comp(losers[right].key, losers[left].key)))
+        unsigned int __left = __init_winner (2 * __root);
+        unsigned int __right = __init_winner (2 * __root + 1);
+        if (__losers[__right]._M_sup
+            || (!__losers[__left]._M_sup
+              && !__comp(__losers[__right]._M_key, __losers[__left]._M_key)))
           {
             // Left one is less or equal.
-            losers[root] = losers[right];
-            return left;
+            __losers[__root] = __losers[__right];
+            return __left;
           }
         else
           {
             // Right one is less.
-            losers[root] = losers[left];
-            return right;
+            __losers[__root] = __losers[__left];
+            return __right;
           }
       }
   }
 
-  void init()
-  { losers[0] = losers[init_winner(1)]; }
+  void __init()
+  { __losers[0] = __losers[__init_winner(1)]; }
 
   /**
    * @brief Delete the smallest element and insert a new element from
@@ -211,34 +211,34 @@ public:
    *
    * This implementation is stable.
    */
-  // Do not pass a const reference since key will be used as local variable.
-  void delete_min_insert(T key, bool sup)
+  // Do not pass a const reference since _M_key will be used as local variable.
+  void __delete_min_insert(_Tp _M_key, bool _M_sup)
   {
 #if _GLIBCXX_ASSERTIONS
     // no dummy sequence can ever be at the top!
-    _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1);
+    _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1);
 #endif
 
-    int source = losers[0].source;
-    for (unsigned int pos = (k + source) / 2; pos > 0; pos /= 2)
+    int _M_source = __losers[0]._M_source;
+    for (unsigned int __pos = (__k + _M_source) / 2; __pos > 0; __pos /= 2)
       {
-        // The smaller one gets promoted, ties are broken by source.
-        if ((sup && (!losers[pos].sup || losers[pos].source < source))
-              || (!sup && !losers[pos].sup
-                && ((comp(losers[pos].key, key))
-                  || (!comp(key, losers[pos].key)
-                    && losers[pos].source < source))))
+        // The smaller one gets promoted, ties are broken by _M_source.
+        if ((_M_sup && (!__losers[__pos]._M_sup || __losers[__pos]._M_source < _M_source))
+              || (!_M_sup && !__losers[__pos]._M_sup
+                && ((__comp(__losers[__pos]._M_key, _M_key))
+                  || (!__comp(_M_key, __losers[__pos]._M_key)
+                    && __losers[__pos]._M_source < _M_source))))
           {
             // The other one is smaller.
-            std::swap(losers[pos].sup, sup);
-            std::swap(losers[pos].source, source);
-            std::swap(losers[pos].key, key);
+            std::swap(__losers[__pos]._M_sup, _M_sup);
+            std::swap(__losers[__pos]._M_source, _M_source);
+            std::swap(__losers[__pos]._M_key, _M_key);
           }
       }
 
-    losers[0].sup = sup;
-    losers[0].source = source;
-    losers[0].key = key;
+    __losers[0]._M_sup = _M_sup;
+    __losers[0]._M_source = _M_source;
+    __losers[0]._M_key = _M_key;
   }
 };
 
@@ -247,141 +247,141 @@ public:
  *
  * Stability (non-stable here) is selected with partial specialization.
  */
-template<typename T, typename Comparator>
-class LoserTree</* stable == */false, T, Comparator> :
-    public LoserTreeBase<T, Comparator>
+template<typename _Tp, typename _Compare>
+class LoserTree</* __stable == */false, _Tp, _Compare> :
+    public LoserTreeBase<_Tp, _Compare>
 {
-  typedef LoserTreeBase<T, Comparator> Base;
+  typedef LoserTreeBase<_Tp, _Compare> Base;
   using Base::_M_log_k;
-  using Base::k;
-  using Base::losers;
-  using Base::first_insert;
+  using Base::__k;
+  using Base::__losers;
+  using Base::__first_insert;
 
 public:
-  LoserTree(unsigned int _k, Comparator _comp)
+  LoserTree(unsigned int _k, _Compare _comp)
   : Base::LoserTreeBase(_k, _comp)
   {}
 
   /**
-   * Computes the winner of the competition at position "root".
+   * Computes the winner of the competition at __position "__root".
    *
    * Called recursively (starting at 0) to build the initial tree.
    *
-   * @param root index of the "game" to start.
+   * @param __root __index of the "game" to start.
    */
   unsigned int
-  init_winner (unsigned int root)
+  __init_winner (unsigned int __root)
   {
-    if (root >= k)
+    if (__root >= __k)
       {
-        return root;
+        return __root;
       }
     else
       {
-        unsigned int left = init_winner (2 * root);
-        unsigned int right = init_winner (2 * root + 1);
-        if (losers[right].sup ||
-            (!losers[left].sup
-              && !comp(losers[right].key, losers[left].key)))
+        unsigned int __left = __init_winner (2 * __root);
+        unsigned int __right = __init_winner (2 * __root + 1);
+        if (__losers[__right]._M_sup ||
+            (!__losers[__left]._M_sup
+              && !__comp(__losers[__right]._M_key, __losers[__left]._M_key)))
           {
             // Left one is less or equal.
-            losers[root] = losers[right];
-            return left;
+            __losers[__root] = __losers[__right];
+            return __left;
           }
         else
           {
             // Right one is less.
-            losers[root] = losers[left];
-            return right;
+            __losers[__root] = __losers[__left];
+            return __right;
           }
       }
   }
 
   inline void
-  init()
-  { losers[0] = losers[init_winner(1)]; }
+  __init()
+  { __losers[0] = __losers[__init_winner(1)]; }
 
   /**
-   * Delete the key smallest element and insert the element key instead.
+   * Delete the _M_key smallest element and insert the element _M_key instead.
    *
-   * @param key the key to insert
-   * @param sup true iff key is an explicitly marked supremum
+   * @param _M_key the _M_key to insert
+   * @param _M_sup true iff _M_key is an explicitly marked supremum
    */
-  // Do not pass a const reference since key will be used as local variable.
+  // Do not pass a const reference since _M_key will be used as local variable.
   inline void
-  delete_min_insert(T key, bool sup)
+  __delete_min_insert(_Tp _M_key, bool _M_sup)
   {
 #if _GLIBCXX_ASSERTIONS
     // no dummy sequence can ever be at the top!
-    _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1);
+    _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1);
 #endif
 
-    int source = losers[0].source;
-    for (unsigned int pos = (k + source) / 2; pos > 0; pos /= 2)
+    int _M_source = __losers[0]._M_source;
+    for (unsigned int __pos = (__k + _M_source) / 2; __pos > 0; __pos /= 2)
     {
         // The smaller one gets promoted.
-      if (sup || (!losers[pos].sup && comp(losers[pos].key, key)))
+      if (_M_sup || (!__losers[__pos]._M_sup && __comp(__losers[__pos]._M_key, _M_key)))
       {
             // The other one is smaller.
-        std::swap(losers[pos].sup, sup);
-        std::swap(losers[pos].source, source);
-        std::swap(losers[pos].key, key);
+        std::swap(__losers[__pos]._M_sup, _M_sup);
+        std::swap(__losers[__pos]._M_source, _M_source);
+        std::swap(__losers[__pos]._M_key, _M_key);
       }
     }
 
-    losers[0].sup = sup;
-    losers[0].source = source;
-    losers[0].key = key;
+    __losers[0]._M_sup = _M_sup;
+    __losers[0]._M_source = _M_source;
+    __losers[0]._M_key = _M_key;
   }
 };
 
 
 /**
- * @brief Base class of Loser Tree implementation using pointers.
+ * @brief Base class of _Loser Tree implementation using pointers.
  */
-template<typename T, typename Comparator>
-class LoserTreePointerBase
+template<typename _Tp, typename _Compare>
+class _LoserTreePointerBase
 {
 protected:
-  /** @brief Internal representation of LoserTree elements. */
-  struct Loser
+  /** @brief Internal representation of LoserTree __elements. */
+  struct _Loser
   {
-    bool sup;
-    int source;
-    const T* keyp;
+    bool _M_sup;
+    int _M_source;
+    const _Tp* _M_keyp;
   };
 
-  unsigned int ik, k, offset;
-  Loser* losers;
-  Comparator comp;
+  unsigned int __ik, __k, __offset;
+  _Loser* __losers;
+  _Compare __comp;
 
 public:
-  LoserTreePointerBase(unsigned int _k, Comparator _comp = std::less<T>())
-    : comp(_comp)
+  _LoserTreePointerBase(unsigned int _k, _Compare _comp = std::less<_Tp>())
+    : __comp(_comp)
   {
-    ik = _k;
+    __ik = _k;
 
     // Next greater power of 2.
-    k = 1 << (__log2(ik - 1) + 1);
-    offset = k;
-    losers = new Loser[k * 2];
-    for (unsigned int i = ik - 1; i < k; i++)
-      losers[i + k].sup = true;
+    __k = 1 << (__log2(__ik - 1) + 1);
+    __offset = __k;
+    __losers = new _Loser[__k * 2];
+    for (unsigned int __i = __ik - 1; __i < __k; __i++)
+      __losers[__i + __k]._M_sup = true;
   }
 
-  ~LoserTreePointerBase()
-  { ::operator delete[](losers); }
+  ~_LoserTreePointerBase()
+  { ::operator delete[](__losers); }
 
-  int get_min_source()
-  { return losers[0].source; }
+  int __get_min_source()
+  { return __losers[0]._M_source; }
 
-  void insert_start(const T& key, int source, bool sup)
+  void __insert_start(const _Tp& _M_key, int _M_source, bool _M_sup)
   {
-    unsigned int pos = k + source;
+    unsigned int __pos = __k + _M_source;
 
-    losers[pos].sup = sup;
-    losers[pos].source = source;
-    losers[pos].keyp = &key;
+    __losers[__pos]._M_sup = _M_sup;
+    __losers[__pos]._M_source = _M_source;
+    __losers[__pos]._M_keyp = &_M_key;
   }
 };
 
@@ -390,77 +390,77 @@ public:
  *
  * The unstable variant is implemented using partial instantiation below.
  */
-template<bool stable/* default == true */, typename T, typename Comparator>
-class LoserTreePointer : public LoserTreePointerBase<T, Comparator>
+template<bool __stable/* default == true */, typename _Tp, typename _Compare>
+class _LoserTreePointer : public _LoserTreePointerBase<_Tp, _Compare>
 {
-  typedef LoserTreePointerBase<T, Comparator> Base;
-  using Base::k;
-  using Base::losers;
+  typedef _LoserTreePointerBase<_Tp, _Compare> Base;
+  using Base::__k;
+  using Base::__losers;
 
 public:
-  LoserTreePointer(unsigned int _k, Comparator _comp = std::less<T>())
-    : Base::LoserTreePointerBase(_k, _comp)
+  _LoserTreePointer(unsigned int _k, _Compare _comp = std::less<_Tp>())
+    : Base::_LoserTreePointerBase(_k, _comp)
   {}
 
   unsigned int
-  init_winner(unsigned int root)
+  __init_winner(unsigned int __root)
   {
-    if (root >= k)
+    if (__root >= __k)
       {
-        return root;
+        return __root;
       }
     else
       {
-        unsigned int left = init_winner (2 * root);
-        unsigned int right = init_winner (2 * root + 1);
-        if (losers[right].sup
-            || (!losers[left].sup && !comp(*losers[right].keyp,
-                                          *losers[left].keyp)))
+        unsigned int __left = __init_winner (2 * __root);
+        unsigned int __right = __init_winner (2 * __root + 1);
+        if (__losers[__right]._M_sup
+            || (!__losers[__left]._M_sup && !__comp(*__losers[__right]._M_keyp,
+                                          *__losers[__left]._M_keyp)))
           {
             // Left one is less or equal.
-            losers[root] = losers[right];
-            return left;
+            __losers[__root] = __losers[__right];
+            return __left;
           }
         else
           {
             // Right one is less.
-            losers[root] = losers[left];
-            return right;
+            __losers[__root] = __losers[__left];
+            return __right;
           }
       }
   }
 
-  void init()
-  { losers[0] = losers[init_winner(1)]; }
+  void __init()
+  { __losers[0] = __losers[__init_winner(1)]; }
 
-  void delete_min_insert(const T& key, bool sup)
+  void __delete_min_insert(const _Tp& _M_key, bool _M_sup)
   {
 #if _GLIBCXX_ASSERTIONS
     // no dummy sequence can ever be at the top!
-    _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1);
+    _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1);
 #endif
 
-    const T* keyp = &key;
-    int source = losers[0].source;
-    for (unsigned int pos = (k + source) / 2; pos > 0; pos /= 2)
+    const _Tp* _M_keyp = &_M_key;
+    int _M_source = __losers[0]._M_source;
+    for (unsigned int __pos = (__k + _M_source) / 2; __pos > 0; __pos /= 2)
       {
-        // The smaller one gets promoted, ties are broken by source.
-        if ((sup && (!losers[pos].sup || losers[pos].source < source)) ||
-              (!sup && !losers[pos].sup &&
-              ((comp(*losers[pos].keyp, *keyp)) ||
-                (!comp(*keyp, *losers[pos].keyp)
-                && losers[pos].source < source))))
+        // The smaller one gets promoted, ties are broken by _M_source.
+        if ((_M_sup && (!__losers[__pos]._M_sup || __losers[__pos]._M_source < _M_source)) ||
+              (!_M_sup && !__losers[__pos]._M_sup &&
+              ((__comp(*__losers[__pos]._M_keyp, *_M_keyp)) ||
+                (!__comp(*_M_keyp, *__losers[__pos]._M_keyp)
+                && __losers[__pos]._M_source < _M_source))))
           {
             // The other one is smaller.
-            std::swap(losers[pos].sup, sup);
-            std::swap(losers[pos].source, source);
-            std::swap(losers[pos].keyp, keyp);
+            std::swap(__losers[__pos]._M_sup, _M_sup);
+            std::swap(__losers[__pos]._M_source, _M_source);
+            std::swap(__losers[__pos]._M_keyp, _M_keyp);
           }
       }
 
-    losers[0].sup = sup;
-    losers[0].source = source;
-    losers[0].keyp = keyp;
+    __losers[0]._M_sup = _M_sup;
+    __losers[0]._M_source = _M_source;
+    __losers[0]._M_keyp = _M_keyp;
   }
 };
 
@@ -469,74 +469,74 @@ public:
  *
  * The stable variant is above.
  */
-template<typename T, typename Comparator>
-class LoserTreePointer</* stable == */false, T, Comparator> :
-    public LoserTreePointerBase<T, Comparator>
+template<typename _Tp, typename _Compare>
+class _LoserTreePointer</* __stable == */false, _Tp, _Compare> :
+    public _LoserTreePointerBase<_Tp, _Compare>
 {
-  typedef LoserTreePointerBase<T, Comparator> Base;
-  using Base::k;
-  using Base::losers;
+  typedef _LoserTreePointerBase<_Tp, _Compare> Base;
+  using Base::__k;
+  using Base::__losers;
 
 public:
-  LoserTreePointer(unsigned int _k, Comparator _comp = std::less<T>())
-    : Base::LoserTreePointerBase(_k, _comp)
+  _LoserTreePointer(unsigned int _k, _Compare _comp = std::less<_Tp>())
+    : Base::_LoserTreePointerBase(_k, _comp)
   {}
 
   unsigned int
-  init_winner(unsigned int root)
+  __init_winner(unsigned int __root)
   {
-    if (root >= k)
+    if (__root >= __k)
       {
-        return root;
+        return __root;
       }
     else
       {
-        unsigned int left = init_winner (2 * root);
-        unsigned int right = init_winner (2 * root + 1);
-        if (losers[right].sup
-              || (!losers[left].sup
-                && !comp(*losers[right].keyp, *losers[left].keyp)))
+        unsigned int __left = __init_winner (2 * __root);
+        unsigned int __right = __init_winner (2 * __root + 1);
+        if (__losers[__right]._M_sup
+              || (!__losers[__left]._M_sup
+                && !__comp(*__losers[__right]._M_keyp, *__losers[__left]._M_keyp)))
           {
             // Left one is less or equal.
-            losers[root] = losers[right];
-            return left;
+            __losers[__root] = __losers[__right];
+            return __left;
           }
         else
           {
             // Right one is less.
-            losers[root] = losers[left];
-            return right;
+            __losers[__root] = __losers[__left];
+            return __right;
           }
       }
   }
 
-  void init()
-  { losers[0] = losers[init_winner(1)]; }
+  void __init()
+  { __losers[0] = __losers[__init_winner(1)]; }
 
-  void delete_min_insert(const T& key, bool sup)
+  void __delete_min_insert(const _Tp& _M_key, bool _M_sup)
   {
 #if _GLIBCXX_ASSERTIONS
     // no dummy sequence can ever be at the top!
-    _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1);
+    _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1);
 #endif
 
-    const T* keyp = &key;
-    int source = losers[0].source;
-    for (unsigned int pos = (k + source) / 2; pos > 0; pos /= 2)
+    const _Tp* _M_keyp = &_M_key;
+    int _M_source = __losers[0]._M_source;
+    for (unsigned int __pos = (__k + _M_source) / 2; __pos > 0; __pos /= 2)
       {
         // The smaller one gets promoted.
-        if (sup || (!losers[pos].sup && comp(*losers[pos].keyp, *keyp)))
+        if (_M_sup || (!__losers[__pos]._M_sup && __comp(*__losers[__pos]._M_keyp, *_M_keyp)))
           {
             // The other one is smaller.
-            std::swap(losers[pos].sup, sup);
-            std::swap(losers[pos].source, source);
-            std::swap(losers[pos].keyp, keyp);
+            std::swap(__losers[__pos]._M_sup, _M_sup);
+            std::swap(__losers[__pos]._M_source, _M_source);
+            std::swap(__losers[__pos]._M_keyp, _M_keyp);
           }
       }
 
-    losers[0].sup = sup;
-    losers[0].source = source;
-    losers[0].keyp = keyp;
+    __losers[0]._M_sup = _M_sup;
+    __losers[0]._M_source = _M_source;
+    __losers[0]._M_keyp = _M_keyp;
   }
 };
 
@@ -545,66 +545,66 @@ public:
  * The whole element is copied into the tree structure.
  *
  * No guarding is done, therefore not a single input sequence must
- * run empty.  Unused sequence heads are marked with a sentinel which
+ * run empty.  Unused __sequence heads are marked with a sentinel which
  * is &gt; all elements that are to be merged.
  *
  * This is a very fast variant.
  */
-template<typename T, typename Comparator>
-class LoserTreeUnguardedBase
+template<typename _Tp, typename _Compare>
+class _LoserTreeUnguardedBase
 {
 protected:
-  struct Loser
+  struct _Loser
   {
-    int source;
-    T key;
+    int _M_source;
+    _Tp _M_key;
   };
 
-  unsigned int ik, k, offset;
-  Loser* losers;
-  Comparator comp;
+  unsigned int __ik, __k, __offset;
+  _Loser* __losers;
+  _Compare __comp;
 
 public:
   inline
-  LoserTreeUnguardedBase(unsigned int _k, const T _sentinel,
-                         Comparator _comp = std::less<T>())
-    : comp(_comp)
+  _LoserTreeUnguardedBase(unsigned int _k, const _Tp _sentinel,
+                         _Compare _comp = std::less<_Tp>())
+    : __comp(_comp)
   {
-    ik = _k;
+    __ik = _k;
 
     // Next greater power of 2.
-    k = 1 << (__log2(ik - 1) + 1);
-    offset = k;
-    // Avoid default-constructing losers[].key
-    losers = static_cast<Loser*>(::operator new(2 * k * sizeof(Loser)));
+    __k = 1 << (__log2(__ik - 1) + 1);
+    __offset = __k;
+    // Avoid default-constructing __losers[]._M_key
+    __losers = static_cast<_Loser*>(::operator new(2 * __k * sizeof(_Loser)));
 
-    for (unsigned int i = k + ik - 1; i < (2 * k); ++i)
+    for (unsigned int __i = __k + __ik - 1; __i < (2 * __k); ++__i)
       {
-        losers[i].key = _sentinel;
-        losers[i].source = -1;
+        __losers[__i]._M_key = _sentinel;
+        __losers[__i]._M_source = -1;
       }
   }
 
-  inline ~LoserTreeUnguardedBase()
-  { ::operator delete(losers); }
+  inline ~_LoserTreeUnguardedBase()
+  { ::operator delete(__losers); }
 
   inline int
-  get_min_source()
+  __get_min_source()
   {
 #if _GLIBCXX_ASSERTIONS
     // no dummy sequence can ever be at the top!
-    _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1);
+    _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1);
 #endif
-    return losers[0].source;
+    return __losers[0]._M_source;
   }
 
   inline void
-  insert_start(const T& key, int source, bool)
+  __insert_start(const _Tp& _M_key, int _M_source, bool)
   {
-    unsigned int pos = k + source;
+    unsigned int __pos = __k + _M_source;
 
-    new(&(losers[pos].key)) T(key);
-    losers[pos].source = source;
+    new(&(__losers[__pos]._M_key)) _Tp(_M_key);
+    __losers[__pos]._M_source = _M_source;
   }
 };
 
@@ -613,80 +613,80 @@ public:
  *
  * Unstable variant is selected below with partial specialization.
  */
-template<bool stable/* default == true */, typename T, typename Comparator>
-class LoserTreeUnguarded : public LoserTreeUnguardedBase<T, Comparator>
+template<bool __stable/* default == true */, typename _Tp, typename _Compare>
+class _LoserTreeUnguarded : public _LoserTreeUnguardedBase<_Tp, _Compare>
 {
-  typedef LoserTreeUnguardedBase<T, Comparator> Base;
-  using Base::k;
-  using Base::losers;
+  typedef _LoserTreeUnguardedBase<_Tp, _Compare> Base;
+  using Base::__k;
+  using Base::__losers;
 
 public:
-  LoserTreeUnguarded(unsigned int _k, const T _sentinel,
-                     Comparator _comp = std::less<T>())
-    : Base::LoserTreeUnguardedBase(_k, _sentinel, _comp)
+  _LoserTreeUnguarded(unsigned int _k, const _Tp _sentinel,
+                     _Compare _comp = std::less<_Tp>())
+    : Base::_LoserTreeUnguardedBase(_k, _sentinel, _comp)
   {}
 
   unsigned int
-  init_winner(unsigned int root)
+  __init_winner(unsigned int __root)
   {
-    if (root >= k)
+    if (__root >= __k)
       {
-        return root;
+        return __root;
       }
     else
       {
-        unsigned int left = init_winner (2 * root);
-        unsigned int right = init_winner (2 * root + 1);
-        if (!comp(losers[right].key, losers[left].key))
+        unsigned int __left = __init_winner (2 * __root);
+        unsigned int __right = __init_winner (2 * __root + 1);
+        if (!__comp(__losers[__right]._M_key, __losers[__left]._M_key))
           {
             // Left one is less or equal.
-            losers[root] = losers[right];
-            return left;
+            __losers[__root] = __losers[__right];
+            return __left;
           }
         else
           {
             // Right one is less.
-            losers[root] = losers[left];
-            return right;
+            __losers[__root] = __losers[__left];
+            return __right;
           }
       }
   }
 
   inline void
-  init()
+  __init()
   {
-    losers[0] = losers[init_winner(1)];
+    __losers[0] = __losers[__init_winner(1)];
 
 #if _GLIBCXX_ASSERTIONS
     // no dummy sequence can ever be at the top at the beginning (0 sequences!)
-    _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1);
+    _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1);
 #endif
   }
 
-  // Do not pass a const reference since key will be used as local variable.
+  // Do not pass a const reference since _M_key will be used as local variable.
   inline void
-  delete_min_insert(T key, bool)
+  __delete_min_insert(_Tp _M_key, bool)
   {
 #if _GLIBCXX_ASSERTIONS
     // no dummy sequence can ever be at the top!
-    _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1);
+    _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1);
 #endif
 
-    int source = losers[0].source;
-    for (unsigned int pos = (k + source) / 2; pos > 0; pos /= 2)
+    int _M_source = __losers[0]._M_source;
+    for (unsigned int __pos = (__k + _M_source) / 2; __pos > 0; __pos /= 2)
       {
-        // The smaller one gets promoted, ties are broken by source.
-        if (comp(losers[pos].key, key)
-              || (!comp(key, losers[pos].key) && losers[pos].source < source))
+        // The smaller one gets promoted, ties are broken by _M_source.
+        if (__comp(__losers[__pos]._M_key, _M_key)
+              || (!__comp(_M_key, __losers[__pos]._M_key) && __losers[__pos]._M_source < _M_source))
           {
             // The other one is smaller.
-            std::swap(losers[pos].source, source);
-            std::swap(losers[pos].key, key);
+            std::swap(__losers[__pos]._M_source, _M_source);
+            std::swap(__losers[__pos]._M_key, _M_key);
           }
       }
 
-    losers[0].source = source;
-    losers[0].key = key;
+    __losers[0]._M_source = _M_source;
+    __losers[0]._M_key = _M_key;
   }
 };
 
@@ -695,152 +695,152 @@ public:
  *
  * Stable implementation is above.
  */
-template<typename T, typename Comparator>
-class LoserTreeUnguarded</* stable == */false, T, Comparator> :
-    public LoserTreeUnguardedBase<T, Comparator>
+template<typename _Tp, typename _Compare>
+class _LoserTreeUnguarded</* __stable == */false, _Tp, _Compare> :
+    public _LoserTreeUnguardedBase<_Tp, _Compare>
 {
-  typedef LoserTreeUnguardedBase<T, Comparator> Base;
-  using Base::k;
-  using Base::losers;
+  typedef _LoserTreeUnguardedBase<_Tp, _Compare> Base;
+  using Base::__k;
+  using Base::__losers;
 
 public:
-  LoserTreeUnguarded(unsigned int _k, const T _sentinel,
-                     Comparator _comp = std::less<T>())
-    : Base::LoserTreeUnguardedBase(_k, _sentinel, _comp)
+  _LoserTreeUnguarded(unsigned int _k, const _Tp _sentinel,
+                     _Compare _comp = std::less<_Tp>())
+    : Base::_LoserTreeUnguardedBase(_k, _sentinel, _comp)
   {}
 
   unsigned int
-  init_winner (unsigned int root)
+  __init_winner (unsigned int __root)
   {
-    if (root >= k)
+    if (__root >= __k)
       {
-        return root;
+        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.
-        if (losers[left].source == -1)
-          _GLIBCXX_PARALLEL_ASSERT(losers[right].source == -1);
+        // If __left one is sentinel then __right one must be, too.
+        if (__losers[__left]._M_source == -1)
+          _GLIBCXX_PARALLEL_ASSERT(__losers[__right]._M_source == -1);
 #endif
 
-        if (!comp(losers[right].key, losers[left].key))
+        if (!__comp(__losers[__right]._M_key, __losers[__left]._M_key))
           {
             // Left one is less or equal.
-            losers[root] = losers[right];
-            return left;
+            __losers[__root] = __losers[__right];
+            return __left;
           }
         else
           {
             // Right one is less.
-            losers[root] = losers[left];
-            return right;
+            __losers[__root] = __losers[__left];
+            return __right;
           }
       }
   }
 
   inline void
-  init()
+  __init()
   {
-    losers[0] = losers[init_winner(1)];
+    __losers[0] = __losers[__init_winner(1)];
 
 #if _GLIBCXX_ASSERTIONS
     // no dummy sequence can ever be at the top at the beginning (0 sequences!)
-    _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1);
+    _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1);
 #endif
   }
 
-  // Do not pass a const reference since key will be used as local variable.
+  // Do not pass a const reference since _M_key will be used as local variable.
   inline void
-  delete_min_insert(T key, bool)
+  __delete_min_insert(_Tp _M_key, bool)
   {
 #if _GLIBCXX_ASSERTIONS
     // no dummy sequence can ever be at the top!
-    _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1);
+    _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1);
 #endif
 
-    int source = losers[0].source;
-    for (unsigned int pos = (k + source) / 2; pos > 0; pos /= 2)
+    int _M_source = __losers[0]._M_source;
+    for (unsigned int __pos = (__k + _M_source) / 2; __pos > 0; __pos /= 2)
       {
         // The smaller one gets promoted.
-        if (comp(losers[pos].key, key))
+        if (__comp(__losers[__pos]._M_key, _M_key))
           {
             // The other one is smaller.
-            std::swap(losers[pos].source, source);
-            std::swap(losers[pos].key, key);
+            std::swap(__losers[__pos]._M_source, _M_source);
+            std::swap(__losers[__pos]._M_key, _M_key);
           }
       }
 
-    losers[0].source = source;
-    losers[0].key = key;
+    __losers[0]._M_source = _M_source;
+    __losers[0]._M_key = _M_key;
   }
 };
 
 /** @brief Unguarded loser tree, keeping only pointers to the
-* elements in the tree structure.
+* __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 T, typename Comparator>
+template<typename _Tp, typename _Compare>
 class LoserTreePointerUnguardedBase
 {
 protected:
-  struct Loser
+  struct _Loser
   {
-    int source;
-    const T* keyp;
+    int _M_source;
+    const _Tp* _M_keyp;
   };
 
-  unsigned int ik, k, offset;
-  Loser* losers;
-  Comparator comp;
+  unsigned int __ik, __k, __offset;
+  _Loser* __losers;
+  _Compare __comp;
 
 public:
 
   inline
-  LoserTreePointerUnguardedBase(unsigned int _k, const T& _sentinel,
-      Comparator _comp = std::less<T>())
-    : comp(_comp)
+  LoserTreePointerUnguardedBase(unsigned int _k, const _Tp& _sentinel,
+      _Compare _comp = std::less<_Tp>())
+    : __comp(_comp)
   {
-    ik = _k;
+    __ik = _k;
 
     // Next greater power of 2.
-    k = 1 << (__log2(ik - 1) + 1);
-    offset = k;
-    // Avoid default-constructing losers[].key
-    losers = new Loser[2 * k];
+    __k = 1 << (__log2(__ik - 1) + 1);
+    __offset = __k;
+    // Avoid default-constructing __losers[]._M_key
+    __losers = new _Loser[2 * __k];
 
-    for (unsigned int i = k + ik - 1; i < (2 * k); ++i)
+    for (unsigned int __i = __k + __ik - 1; __i < (2 * __k); ++__i)
       {
-        losers[i].keyp = &_sentinel;
-        losers[i].source = -1;
+        __losers[__i]._M_keyp = &_sentinel;
+        __losers[__i]._M_source = -1;
       }
   }
 
   inline ~LoserTreePointerUnguardedBase()
-  { delete[] losers; }
+  { delete[] __losers; }
 
   inline int
-  get_min_source()
+  __get_min_source()
   {
 #if _GLIBCXX_ASSERTIONS
     // no dummy sequence can ever be at the top!
-    _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1);
+    _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1);
 #endif
-    return losers[0].source;
+    return __losers[0]._M_source;
   }
 
   inline void
-  insert_start(const T& key, int source, bool)
+  __insert_start(const _Tp& _M_key, int _M_source, bool)
   {
-    unsigned int pos = k + source;
+    unsigned int __pos = __k + _M_source;
 
-    losers[pos].keyp = &key;
-    losers[pos].source = source;
+    __losers[__pos]._M_keyp = &_M_key;
+    __losers[__pos]._M_source = _M_source;
   }
 };
 
@@ -849,81 +849,81 @@ public:
  *
  * Unstable variant is implemented below using partial specialization.
  */
-template<bool stable/* default == true */, typename T, typename Comparator>
+template<bool __stable/* default == true */, typename _Tp, typename _Compare>
 class LoserTreePointerUnguarded :
-    public LoserTreePointerUnguardedBase<T, Comparator>
+    public LoserTreePointerUnguardedBase<_Tp, _Compare>
 {
-  typedef LoserTreePointerUnguardedBase<T, Comparator> Base;
-  using Base::k;
-  using Base::losers;
+  typedef LoserTreePointerUnguardedBase<_Tp, _Compare> Base;
+  using Base::__k;
+  using Base::__losers;
 
 public:
-  LoserTreePointerUnguarded(unsigned int _k, const T& _sentinel,
-      Comparator _comp = std::less<T>())
+  LoserTreePointerUnguarded(unsigned int _k, const _Tp& _sentinel,
+      _Compare _comp = std::less<_Tp>())
     : Base::LoserTreePointerUnguardedBase(_k, _sentinel, _comp)
   {}
 
   unsigned int
-  init_winner(unsigned int root)
+  __init_winner(unsigned int __root)
   {
-    if (root >= k)
+    if (__root >= __k)
       {
-        return root;
+        return __root;
       }
     else
       {
-        unsigned int left = init_winner (2 * root);
-        unsigned int right = init_winner (2 * root + 1);
-        if (!comp(*losers[right].keyp, *losers[left].keyp))
+        unsigned int __left = __init_winner (2 * __root);
+        unsigned int __right = __init_winner (2 * __root + 1);
+        if (!__comp(*__losers[__right]._M_keyp, *__losers[__left]._M_keyp))
           {
             // Left one is less or equal.
-            losers[root] = losers[right];
-            return left;
+            __losers[__root] = __losers[__right];
+            return __left;
           }
         else
           {
             // Right one is less.
-            losers[root] = losers[left];
-            return right;
+            __losers[__root] = __losers[__left];
+            return __right;
           }
       }
   }
 
   inline void
-  init()
+  __init()
   {
-    losers[0] = losers[init_winner(1)];
+    __losers[0] = __losers[__init_winner(1)];
 
 #if _GLIBCXX_ASSERTIONS
     // no dummy sequence can ever be at the top at the beginning (0 sequences!)
-    _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1);
+    _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1);
 #endif
   }
 
   inline void
-  delete_min_insert(const T& key, bool sup)
+  __delete_min_insert(const _Tp& _M_key, bool _M_sup)
   {
 #if _GLIBCXX_ASSERTIONS
     // no dummy sequence can ever be at the top!
-    _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1);
+    _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1);
 #endif
 
-    const T* keyp = &key;
-    int source = losers[0].source;
-    for (unsigned int pos = (k + source) / 2; pos > 0; pos /= 2)
+    const _Tp* _M_keyp = &_M_key;
+    int _M_source = __losers[0]._M_source;
+    for (unsigned int __pos = (__k + _M_source) / 2; __pos > 0; __pos /= 2)
       {
-        // The smaller one gets promoted, ties are broken by source.
-        if (comp(*losers[pos].keyp, *keyp)
-          || (!comp(*keyp, *losers[pos].keyp) && losers[pos].source < source))
+        // The smaller one gets promoted, ties are broken by _M_source.
+        if (__comp(*__losers[__pos]._M_keyp, *_M_keyp)
+          || (!__comp(*_M_keyp, *__losers[__pos]._M_keyp) && __losers[__pos]._M_source < _M_source))
           {
             // The other one is smaller.
-            std::swap(losers[pos].source, source);
-            std::swap(losers[pos].keyp, keyp);
+            std::swap(__losers[__pos]._M_source, _M_source);
+            std::swap(__losers[__pos]._M_keyp, _M_keyp);
           }
       }
 
-    losers[0].source = source;
-    losers[0].keyp = keyp;
+    __losers[0]._M_source = _M_source;
+    __losers[0]._M_keyp = _M_keyp;
   }
 };
 
@@ -932,87 +932,87 @@ public:
  *
  * Stable variant is above.
  */
-template<typename T, typename Comparator>
-class LoserTreePointerUnguarded</* stable == */false, T, Comparator> :
-    public LoserTreePointerUnguardedBase<T, Comparator>
+template<typename _Tp, typename _Compare>
+class LoserTreePointerUnguarded</* __stable == */false, _Tp, _Compare> :
+    public LoserTreePointerUnguardedBase<_Tp, _Compare>
 {
-  typedef LoserTreePointerUnguardedBase<T, Comparator> Base;
-  using Base::k;
-  using Base::losers;
+  typedef LoserTreePointerUnguardedBase<_Tp, _Compare> Base;
+  using Base::__k;
+  using Base::__losers;
 
 public:
-  LoserTreePointerUnguarded(unsigned int _k, const T& _sentinel,
-      Comparator _comp = std::less<T>())
+  LoserTreePointerUnguarded(unsigned int _k, const _Tp& _sentinel,
+      _Compare _comp = std::less<_Tp>())
     : Base::LoserTreePointerUnguardedBase(_k, _sentinel, _comp)
   {}
 
   unsigned int
-  init_winner(unsigned int root)
+  __init_winner(unsigned int __root)
   {
-    if (root >= k)
+    if (__root >= __k)
       {
-        return root;
+        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.
-        if (losers[left].source == -1)
-          _GLIBCXX_PARALLEL_ASSERT(losers[right].source == -1);
+        // If __left one is sentinel then __right one must be, too.
+        if (__losers[__left]._M_source == -1)
+          _GLIBCXX_PARALLEL_ASSERT(__losers[__right]._M_source == -1);
 #endif
 
-        if (!comp(*losers[right].keyp, *losers[left].keyp))
+        if (!__comp(*__losers[__right]._M_keyp, *__losers[__left]._M_keyp))
           {
             // Left one is less or equal.
-            losers[root] = losers[right];
-            return left;
+            __losers[__root] = __losers[__right];
+            return __left;
           }
         else
           {
             // Right one is less.
-            losers[root] = losers[left];
-            return right;
+            __losers[__root] = __losers[__left];
+            return __right;
           }
       }
   }
 
   inline void
-  init()
+  __init()
   {
-    losers[0] = losers[init_winner(1)];
+    __losers[0] = __losers[__init_winner(1)];
 
 #if _GLIBCXX_ASSERTIONS
     // no dummy sequence can ever be at the top at the beginning (0 sequences!)
-    _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1);
+    _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1);
 #endif
   }
 
   inline void
-  delete_min_insert(const T& key, bool sup)
+  __delete_min_insert(const _Tp& _M_key, bool _M_sup)
   {
 #if _GLIBCXX_ASSERTIONS
     // no dummy sequence can ever be at the top!
-    _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1);
+    _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1);
 #endif
 
-    const T* keyp = &key;
-    int source = losers[0].source;
-    for (unsigned int pos = (k + source) / 2; pos > 0; pos /= 2)
+    const _Tp* _M_keyp = &_M_key;
+    int _M_source = __losers[0]._M_source;
+    for (unsigned int __pos = (__k + _M_source) / 2; __pos > 0; __pos /= 2)
       {
         // The smaller one gets promoted.
-        if (comp(*(losers[pos].keyp), *keyp))
+        if (__comp(*(__losers[__pos]._M_keyp), *_M_keyp))
           {
             // The other one is smaller.
-            std::swap(losers[pos].source, source);
-            std::swap(losers[pos].keyp, keyp);
+            std::swap(__losers[__pos]._M_source, _M_source);
+            std::swap(__losers[__pos]._M_keyp, _M_keyp);
           }
       }
 
-    losers[0].source = source;
-    losers[0].keyp = keyp;
+    __losers[0]._M_source = _M_source;
+    __losers[0]._M_keyp = _M_keyp;
   }
 };
 
diff --git a/libstdc++-v3/include/parallel/merge.h b/libstdc++-v3/include/parallel/merge.h
index d947e25..7b61ca6 100644
--- a/libstdc++-v3/include/parallel/merge.h
+++ b/libstdc++-v3/include/parallel/merge.h
@@ -37,224 +37,224 @@
 
 namespace __gnu_parallel
 {
-  /** @brief Merge routine being able to merge only the @c max_length
+  /** @brief Merge routine being able to merge only the @__c __max_length
    * smallest elements.
    *
-   * The @c begin iterators are advanced accordingly, they might not
-   * reach @c end, in contrast to the usual variant.
-   * @param begin1 Begin iterator of first sequence.
-   * @param end1 End iterator of first sequence.
-   * @param begin2 Begin iterator of second sequence.
-   * @param end2 End iterator of second sequence.
-   * @param target Target begin iterator.
-   * @param max_length Maximum number of elements to merge.
-   * @param comp Comparator.
+   * The @__c __begin iterators are advanced accordingly, they might not
+   * reach @__c __end, in contrast to the usual variant.
+   * @param __begin1 Begin iterator of first sequence.
+   * @param __end1 End iterator of first sequence.
+   * @param __begin2 Begin iterator of second sequence.
+   * @param __end2 End iterator of second sequence.
+   * @param __target Target begin iterator.
+   * @param __max_length Maximum number of elements to merge.
+   * @param __comp Comparator.
    * @return Output end iterator. */
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-	   typename OutputIterator, typename _DifferenceTp,
-	   typename Comparator>
-    OutputIterator
-    merge_advance_usual(RandomAccessIterator1& begin1,
-			RandomAccessIterator1 end1,
-			RandomAccessIterator2& begin2,
-			RandomAccessIterator2 end2, OutputIterator target,
-			_DifferenceTp max_length, Comparator comp)
+  template<typename _RAIter1, typename _RAIter2,
+	   typename _OutputIterator, typename _DifferenceTp,
+	   typename _Compare>
+    _OutputIterator
+    __merge_advance_usual(_RAIter1& __begin1,
+			_RAIter1 __end1,
+			_RAIter2& __begin2,
+			_RAIter2 __end2, _OutputIterator __target,
+			_DifferenceTp __max_length, _Compare __comp)
     {
-      typedef _DifferenceTp difference_type;
-      while (begin1 != end1 && begin2 != end2 && max_length > 0)
+      typedef _DifferenceTp _DifferenceType;
+      while (__begin1 != __end1 && __begin2 != __end2 && __max_length > 0)
 	{
-	  // array1[i1] < array0[i0]
-	  if (comp(*begin2, *begin1))
-	    *target++ = *begin2++;
+	  // array1[__i1] < array0[i0]
+	  if (__comp(*__begin2, *__begin1))
+	    *__target++ = *__begin2++;
 	  else
-	    *target++ = *begin1++;
-	  --max_length;
+	    *__target++ = *__begin1++;
+	  --__max_length;
 	}
 
-      if (begin1 != end1)
+      if (__begin1 != __end1)
 	{
-	  target = std::copy(begin1, begin1 + max_length, target);
-	  begin1 += max_length;
+	  __target = std::copy(__begin1, __begin1 + __max_length, __target);
+	  __begin1 += __max_length;
 	}
       else
 	{
-	  target = std::copy(begin2, begin2 + max_length, target);
-	  begin2 += max_length;
+	  __target = std::copy(__begin2, __begin2 + __max_length, __target);
+	  __begin2 += __max_length;
 	}
-      return target;
+      return __target;
     }
 
-  /** @brief Merge routine being able to merge only the @c max_length
+  /** @brief Merge routine being able to merge only the @__c __max_length
    * smallest elements.
    *
-   * The @c begin iterators are advanced accordingly, they might not
-   * reach @c end, in contrast to the usual variant.
+   * The @__c __begin iterators are advanced accordingly, they might not
+   * reach @__c __end, in contrast to the usual variant.
    * Specially designed code should allow the compiler to generate
    * conditional moves instead of branches.
-   * @param begin1 Begin iterator of first sequence.
-   * @param end1 End iterator of first sequence.
-   * @param begin2 Begin iterator of second sequence.
-   * @param end2 End iterator of second sequence.
-   * @param target Target begin iterator.
-   * @param max_length Maximum number of elements to merge.
-   * @param comp Comparator.
+   * @param __begin1 Begin iterator of first sequence.
+   * @param __end1 End iterator of first sequence.
+   * @param __begin2 Begin iterator of second sequence.
+   * @param __end2 End iterator of second sequence.
+   * @param __target Target begin iterator.
+   * @param __max_length Maximum number of elements to merge.
+   * @param __comp Comparator.
    * @return Output end iterator. */
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-	   typename OutputIterator, typename _DifferenceTp,
-	   typename Comparator>
-    OutputIterator
-    merge_advance_movc(RandomAccessIterator1& begin1,
-		       RandomAccessIterator1 end1,
-		       RandomAccessIterator2& begin2,
-		       RandomAccessIterator2 end2,
-		       OutputIterator target,
-		       _DifferenceTp max_length, Comparator comp)
+  template<typename _RAIter1, typename _RAIter2,
+	   typename _OutputIterator, typename _DifferenceTp,
+	   typename _Compare>
+    _OutputIterator
+    __merge_advance_movc(_RAIter1& __begin1,
+		       _RAIter1 __end1,
+		       _RAIter2& __begin2,
+		       _RAIter2 __end2,
+		       _OutputIterator __target,
+		       _DifferenceTp __max_length, _Compare __comp)
     {
-      typedef _DifferenceTp difference_type;
-      typedef typename std::iterator_traits<RandomAccessIterator1>::value_type
+      typedef _DifferenceTp _DifferenceType;
+      typedef typename std::iterator_traits<_RAIter1>::value_type
 	value_type1;
-      typedef typename std::iterator_traits<RandomAccessIterator2>::value_type
+      typedef typename std::iterator_traits<_RAIter2>::value_type
 	value_type2;
 
 #if _GLIBCXX_ASSERTIONS
-      _GLIBCXX_PARALLEL_ASSERT(max_length >= 0);
+      _GLIBCXX_PARALLEL_ASSERT(__max_length >= 0);
 #endif
 
-      while (begin1 != end1 && begin2 != end2 && max_length > 0)
+      while (__begin1 != __end1 && __begin2 != __end2 && __max_length > 0)
 	{
-	  RandomAccessIterator1 next1 = begin1 + 1;
-	  RandomAccessIterator2 next2 = begin2 + 1;
-	  value_type1 element1 = *begin1;
-	  value_type2 element2 = *begin2;
+	  _RAIter1 __next1 = __begin1 + 1;
+	  _RAIter2 __next2 = __begin2 + 1;
+	  value_type1 __element1 = *__begin1;
+	  value_type2 __element2 = *__begin2;
 
-	  if (comp(element2, element1))
+	  if (__comp(__element2, __element1))
 	    {
-	      element1 = element2;
-	      begin2 = next2;
+	      __element1 = __element2;
+	      __begin2 = __next2;
 	    }
 	  else
-	    begin1 = next1;
+	    __begin1 = __next1;
 
-	  *target = element1;
+	  *__target = __element1;
 
-	  ++target;
-	  --max_length;
+	  ++__target;
+	  --__max_length;
 	}
-      if (begin1 != end1)
+      if (__begin1 != __end1)
 	{
-	  target = std::copy(begin1, begin1 + max_length, target);
-	  begin1 += max_length;
+	  __target = std::copy(__begin1, __begin1 + __max_length, __target);
+	  __begin1 += __max_length;
 	}
       else
 	{
-	  target = std::copy(begin2, begin2 + max_length, target);
-	  begin2 += max_length;
+	  __target = std::copy(__begin2, __begin2 + __max_length, __target);
+	  __begin2 += __max_length;
 	}
-      return target;
+      return __target;
     }
 
-  /** @brief Merge routine being able to merge only the @c max_length
+  /** @brief Merge routine being able to merge only the @__c __max_length
    * smallest elements.
    *
-   *  The @c begin iterators are advanced accordingly, they might not
-   *  reach @c end, in contrast to the usual variant.
+   *  The @__c __begin iterators are advanced accordingly, they might not
+   *  reach @__c __end, in contrast to the usual variant.
    *  Static switch on whether to use the conditional-move variant.
-   *  @param begin1 Begin iterator of first sequence.
-   *  @param end1 End iterator of first sequence.
-   *  @param begin2 Begin iterator of second sequence.
-   *  @param end2 End iterator of second sequence.
-   *  @param target Target begin iterator.
-   *  @param max_length Maximum number of elements to merge.
-   *  @param comp Comparator.
+   *  @param __begin1 Begin iterator of first sequence.
+   *  @param __end1 End iterator of first sequence.
+   *  @param __begin2 Begin iterator of second sequence.
+   *  @param __end2 End iterator of second sequence.
+   *  @param __target Target begin iterator.
+   *  @param __max_length Maximum number of elements to merge.
+   *  @param __comp Comparator.
    *  @return Output end iterator. */
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-	   typename OutputIterator, typename _DifferenceTp,
-	   typename Comparator>
-    inline OutputIterator
-    merge_advance(RandomAccessIterator1& begin1, RandomAccessIterator1 end1,
-		  RandomAccessIterator2& begin2, RandomAccessIterator2 end2,
-		  OutputIterator target, _DifferenceTp max_length,
-		  Comparator comp)
+  template<typename _RAIter1, typename _RAIter2,
+	   typename _OutputIterator, typename _DifferenceTp,
+	   typename _Compare>
+    inline _OutputIterator
+    __merge_advance(_RAIter1& __begin1, _RAIter1 __end1,
+		  _RAIter2& __begin2, _RAIter2 __end2,
+		  _OutputIterator __target, _DifferenceTp __max_length,
+		  _Compare __comp)
     {
-      _GLIBCXX_CALL(max_length)
+      _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
       iterators of the two input sequences are of different type.
-      *  @param begin1 Begin iterator of first sequence.
-      *  @param end1 End iterator of first sequence.
-      *  @param begin2 Begin iterator of second sequence.
-      *  @param end2 End iterator of second sequence.
-      *  @param target Target begin iterator.
-      *  @param max_length Maximum number of elements to merge.
-      *  @param comp Comparator.
+      *  @param __begin1 Begin iterator of first sequence.
+      *  @param __end1 End iterator of first sequence.
+      *  @param __begin2 Begin iterator of second sequence.
+      *  @param __end2 End iterator of second sequence.
+      *  @param __target Target begin iterator.
+      *  @param __max_length Maximum number of elements to merge.
+      *  @param __comp Comparator.
       *  @return Output end iterator. */
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-	   typename RandomAccessIterator3, typename Comparator>
-    inline RandomAccessIterator3
-    parallel_merge_advance(RandomAccessIterator1& begin1,
-			   RandomAccessIterator1 end1,
-			   RandomAccessIterator2& begin2,
+  template<typename _RAIter1, typename _RAIter2,
+	   typename _RAIter3, typename _Compare>
+    inline _RAIter3
+    __parallel_merge_advance(_RAIter1& __begin1,
+			   _RAIter1 __end1,
+			   _RAIter2& __begin2,
 			   // different iterators, parallel implementation
 			   // not available			   
-			   RandomAccessIterator2 end2,
-			   RandomAccessIterator3 target, typename
-			   std::iterator_traits<RandomAccessIterator1>::
-			   difference_type max_length, Comparator comp)
-    { return merge_advance(begin1, end1, begin2, end2, target,
-			   max_length, comp); }
+			   _RAIter2 __end2,
+			   _RAIter3 __target, typename
+			   std::iterator_traits<_RAIter1>::
+			   difference_type __max_length, _Compare __comp)
+    { return __merge_advance(__begin1, __end1, __begin2, __end2, __target,
+			   __max_length, __comp); }
 
-  /** @brief Parallel merge routine being able to merge only the @c
-   * max_length smallest elements.
+  /** @brief Parallel merge routine being able to merge only the @__c
+   * __max_length smallest elements.
    *
-   *  The @c begin iterators are advanced accordingly, they might not
-   *  reach @c end, in contrast to the usual variant.
+   *  The @__c __begin iterators are advanced accordingly, they might not
+   *  reach @__c __end, in contrast to the usual variant.
    *  The functionality is projected onto parallel_multiway_merge.
-   *  @param begin1 Begin iterator of first sequence.
-   *  @param end1 End iterator of first sequence.
-   *  @param begin2 Begin iterator of second sequence.
-   *  @param end2 End iterator of second sequence.
-   *  @param target Target begin iterator.
-   *  @param max_length Maximum number of elements to merge.
-   *  @param comp Comparator.
+   *  @param __begin1 Begin iterator of first sequence.
+   *  @param __end1 End iterator of first sequence.
+   *  @param __begin2 Begin iterator of second sequence.
+   *  @param __end2 End iterator of second sequence.
+   *  @param __target Target begin iterator.
+   *  @param __max_length Maximum number of elements to merge.
+   *  @param __comp Comparator.
    *  @return Output end iterator.
    */
-  template<typename RandomAccessIterator1, typename RandomAccessIterator3,
-	   typename Comparator>
-    inline RandomAccessIterator3
-    parallel_merge_advance(RandomAccessIterator1& begin1,
-			   RandomAccessIterator1 end1,
-			   RandomAccessIterator1& begin2,
-			   RandomAccessIterator1 end2,
-			   RandomAccessIterator3 target, typename
-			   std::iterator_traits<RandomAccessIterator1>::
-			   difference_type max_length, Comparator comp)
+  template<typename _RAIter1, typename _RAIter3,
+	   typename _Compare>
+    inline _RAIter3
+    __parallel_merge_advance(_RAIter1& __begin1,
+			   _RAIter1 __end1,
+			   _RAIter1& __begin2,
+			   _RAIter1 __end2,
+			   _RAIter3 __target, typename
+			   std::iterator_traits<_RAIter1>::
+			   difference_type __max_length, _Compare __comp)
     {
       typedef typename
-          std::iterator_traits<RandomAccessIterator1>::value_type value_type;
-      typedef typename std::iterator_traits<RandomAccessIterator1>::
-	difference_type difference_type1 /* == difference_type2 */;
-      typedef typename std::iterator_traits<RandomAccessIterator3>::
-	difference_type difference_type3;
-      typedef typename std::pair<RandomAccessIterator1, RandomAccessIterator1>
-        iterator_pair;
+          std::iterator_traits<_RAIter1>::value_type _ValueType;
+      typedef typename std::iterator_traits<_RAIter1>::
+	difference_type _DifferenceType1 /* == difference_type2 */;
+      typedef typename std::iterator_traits<_RAIter3>::
+	difference_type _DifferenceType3;
+      typedef typename std::pair<_RAIter1, _RAIter1>
+        _IteratorPair;
 
-      iterator_pair
-	seqs[2] = { std::make_pair(begin1, end1),
-		    std::make_pair(begin2, end2) };
-      RandomAccessIterator3
-        target_end = parallel_multiway_merge
-          < /* stable = */ true, /* sentinels = */ false>(
-            seqs, seqs + 2, target,
+      _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
-              < /* stable = */ true, iterator_pair*,
-                Comparator, difference_type1>,
-            max_length, comp, omp_get_max_threads());
+              < /* __stable = */ true, _IteratorPair*,
+                _Compare, _DifferenceType1>,
+            __max_length, __comp, omp_get_max_threads());
 
-      return target_end;
+      return __target_end;
     }
 }	//namespace __gnu_parallel
 
diff --git a/libstdc++-v3/include/parallel/multiseq_selection.h b/libstdc++-v3/include/parallel/multiseq_selection.h
index 6ef3d22..353330e 100644
--- a/libstdc++-v3/include/parallel/multiseq_selection.h
+++ b/libstdc++-v3/include/parallel/multiseq_selection.h
@@ -23,7 +23,7 @@
 // <http://www.gnu.org/licenses/>.
 
 /** @file parallel/multiseq_selection.h
- *  @brief Functions to find elements of a certain global rank in
+ *  @brief Functions to find elements of a certain global __rank in
  *  multiple sorted sequences.  Also serves for splitting such
  *  sequence sets.
  *
@@ -50,275 +50,275 @@
 
 namespace __gnu_parallel
 {
-  /** @brief Compare a pair of types lexicographically, ascending. */
-  template<typename T1, typename T2, typename Comparator>
-    class lexicographic
-    : public std::binary_function<std::pair<T1, T2>, std::pair<T1, T2>, bool>
+  /** @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>
     {
     private:
-      Comparator& comp;
+      _Compare& __comp;
 
     public:
-      lexicographic(Comparator& _comp) : comp(_comp) { }
+      _Lexicographic(_Compare& _comp) : __comp(_comp) { }
 
       bool
-      operator()(const std::pair<T1, T2>& p1,
-		 const std::pair<T1, T2>& p2) const
+      operator()(const std::pair<_T1, _T2>& __p1,
+		 const std::pair<_T1, _T2>& __p2) const
       {
-	if (comp(p1.first, p2.first))
+	if (__comp(__p1.first, __p2.first))
 	  return true;
 
-	if (comp(p2.first, p1.first))
+	if (__comp(__p2.first, __p1.first))
 	  return false;
 
 	// Firsts are equal.
-	return p1.second < p2.second;
+	return __p1.second < __p2.second;
       }
     };
 
-  /** @brief Compare a pair of types lexicographically, descending. */
-  template<typename T1, typename T2, typename Comparator>
-    class lexicographic_reverse : public std::binary_function<T1, T2, bool>
+  /** @brief Compare __a pair of types lexicographically, descending. */
+  template<typename _T1, typename _T2, typename _Compare>
+    class _LexicographicReverse : public std::binary_function<_T1, _T2, bool>
     {
     private:
-      Comparator& comp;
+      _Compare& __comp;
 
     public:
-      lexicographic_reverse(Comparator& _comp) : comp(_comp) { }
+      _LexicographicReverse(_Compare& _comp) : __comp(_comp) { }
 
       bool
-      operator()(const std::pair<T1, T2>& p1,
-		 const std::pair<T1, T2>& p2) const
+      operator()(const std::pair<_T1, _T2>& __p1,
+		 const std::pair<_T1, _T2>& __p2) const
       {
-	if (comp(p2.first, p1.first))
+	if (__comp(__p2.first, __p1.first))
 	  return true;
 
-	if (comp(p1.first, p2.first))
+	if (__comp(__p1.first, __p2.first))
 	  return false;
 
 	// Firsts are equal.
-	return p2.second < p1.second;
+	return __p2.second < __p1.second;
       }
     };
 
   /** 
-   *  @brief Splits several sorted sequences at a certain global rank,
+   *  @brief Splits several sorted sequences at __a certain global __rank,
    *  resulting in a splitting point for each sequence.
-   *  The sequences are passed via a sequence of random-access
+   *  The sequences are passed via __a __sequence of random-access
    *  iterator pairs, none of the sequences may be empty.  If there
    *  are several equal elements across the split, the ones on the
-   *  left side will be chosen from sequences with smaller number.
-   *  @param begin_seqs Begin of the sequence of iterator pairs.
-   *  @param end_seqs End of the sequence of iterator pairs.
-   *  @param rank The global rank to partition at.
-   *  @param begin_offsets A random-access sequence begin where the
-   *  result will be stored in. Each element of the sequence is an
+   *  __left side will be chosen from sequences with smaller number.
+   *  @param __begin_seqs Begin of the sequence of iterator pairs.
+   *  @param __end_seqs End of the sequence of iterator pairs.
+   *  @param __rank The global __rank to partition at.
+   *  @param __begin_offsets A random-access __sequence __begin where the
+   *  __result will be stored in. Each element of the sequence is an
    *  iterator that points to the first element on the greater part of
-   *  the respective sequence.
-   *  @param comp The ordering functor, defaults to std::less<T>. 
+   *  the respective __sequence.
+   *  @param __comp The ordering functor, defaults to std::less<_Tp>. 
    */
-  template<typename RanSeqs, typename RankType, typename RankIterator,
-            typename Comparator>
+  template<typename _RanSeqs, typename _RankType, typename _RankIterator,
+            typename _Compare>
     void
-    multiseq_partition(RanSeqs begin_seqs, RanSeqs end_seqs,
-                       RankType rank,
-                       RankIterator begin_offsets,
-                       Comparator comp = std::less<
+    multiseq_partition(_RanSeqs __begin_seqs, _RanSeqs __end_seqs,
+                       _RankType __rank,
+                       _RankIterator __begin_offsets,
+                       _Compare __comp = std::less<
                        typename std::iterator_traits<typename
-                       std::iterator_traits<RanSeqs>::value_type::
-                       first_type>::value_type>()) // std::less<T>
+                       std::iterator_traits<_RanSeqs>::value_type::
+                       first_type>::value_type>()) // std::less<_Tp>
     {
-      _GLIBCXX_CALL(end_seqs - begin_seqs)
+      _GLIBCXX_CALL(__end_seqs - __begin_seqs)
 
-      typedef typename std::iterator_traits<RanSeqs>::value_type::first_type
-        It;
-      typedef typename std::iterator_traits<It>::difference_type
-	       difference_type;
-      typedef typename std::iterator_traits<It>::value_type value_type;
+      typedef typename std::iterator_traits<_RanSeqs>::value_type::first_type
+        _It;
+      typedef typename std::iterator_traits<_It>::difference_type
+	       _DifferenceType;
+      typedef typename std::iterator_traits<_It>::value_type _ValueType;
 
-      lexicographic<value_type, int, Comparator> lcomp(comp);
-      lexicographic_reverse<value_type, int, Comparator> lrcomp(comp);
+      _Lexicographic<_ValueType, int, _Compare> __lcomp(__comp);
+      _LexicographicReverse<_ValueType, int, _Compare> __lrcomp(__comp);
 
       // Number of sequences, number of elements in total (possibly
       // including padding).
-      difference_type m = std::distance(begin_seqs, end_seqs), N = 0,
-                      nmax, n, r;
+      _DifferenceType __m = std::distance(__begin_seqs, __end_seqs), __N = 0,
+                      __nmax, __n, __r;
 
-      for (int i = 0; i < m; i++)
+      for (int __i = 0; __i < __m; __i++)
         {
-          N += std::distance(begin_seqs[i].first, begin_seqs[i].second);
+          __N += std::distance(__begin_seqs[__i].first, __begin_seqs[__i].second);
           _GLIBCXX_PARALLEL_ASSERT(
-            std::distance(begin_seqs[i].first, begin_seqs[i].second) > 0);
+            std::distance(__begin_seqs[__i].first, __begin_seqs[__i].second) > 0);
         }
 
-      if (rank == N)
+      if (__rank == __N)
         {
-          for (int i = 0; i < m; i++)
-            begin_offsets[i] = begin_seqs[i].second; // Very end.
-          // Return m - 1;
+          for (int __i = 0; __i < __m; __i++)
+            __begin_offsets[__i] = __begin_seqs[__i].second; // Very end.
+          // Return __m - 1;
           return;
         }
 
-      _GLIBCXX_PARALLEL_ASSERT(m != 0);
-      _GLIBCXX_PARALLEL_ASSERT(N != 0);
-      _GLIBCXX_PARALLEL_ASSERT(rank >= 0);
-      _GLIBCXX_PARALLEL_ASSERT(rank < N);
+      _GLIBCXX_PARALLEL_ASSERT(__m != 0);
+      _GLIBCXX_PARALLEL_ASSERT(__N != 0);
+      _GLIBCXX_PARALLEL_ASSERT(__rank >= 0);
+      _GLIBCXX_PARALLEL_ASSERT(__rank < __N);
 
-      difference_type* ns = new difference_type[m];
-      difference_type* a = new difference_type[m];
-      difference_type* b = new difference_type[m];
-      difference_type l;
+      _DifferenceType* __ns = new _DifferenceType[__m];
+      _DifferenceType* __a = new _DifferenceType[__m];
+      _DifferenceType* __b = new _DifferenceType[__m];
+      _DifferenceType __l;
 
-      ns[0] = std::distance(begin_seqs[0].first, begin_seqs[0].second);
-      nmax = ns[0];
-      for (int i = 0; i < m; i++)
+      __ns[0] = std::distance(__begin_seqs[0].first, __begin_seqs[0].second);
+      __nmax = __ns[0];
+      for (int __i = 0; __i < __m; __i++)
 	{
-	  ns[i] = std::distance(begin_seqs[i].first, begin_seqs[i].second);
-	  nmax = std::max(nmax, ns[i]);
+	  __ns[__i] = std::distance(__begin_seqs[__i].first, __begin_seqs[__i].second);
+	  __nmax = std::max(__nmax, __ns[__i]);
 	}
 
-      r = __log2(nmax) + 1;
+      __r = __log2(__nmax) + 1;
 
-      // Pad all lists to this length, at least as long as any ns[i],
-      // equality iff nmax = 2^k - 1.
-      l = (1ULL << r) - 1;
+      // Pad all lists to this length, at least as long as any ns[__i],
+      // equality iff __nmax = 2^__k - 1.
+      __l = (1ULL << __r) - 1;
 
       // From now on, including padding.
-      N = l * m;
+      __N = __l * __m;
 
-      for (int i = 0; i < m; i++)
+      for (int __i = 0; __i < __m; __i++)
 	{
-	  a[i] = 0;
-	  b[i] = l;
+	  __a[__i] = 0;
+	  __b[__i] = __l;
 	}
-      n = l / 2;
+      __n = __l / 2;
 
       // Invariants:
-      // 0 <= a[i] <= ns[i], 0 <= b[i] <= l
+      // 0 <= __a[__i] <= __ns[__i], 0 <= __b[__i] <= __l
 
-#define S(i) (begin_seqs[i].first)
+#define __S(__i) (__begin_seqs[__i].first)
 
       // Initial partition.
-      std::vector<std::pair<value_type, int> > sample;
+      std::vector<std::pair<_ValueType, int> > __sample;
 
-      for (int i = 0; i < m; i++)
-	if (n < ns[i])	//sequence long enough
-	  sample.push_back(std::make_pair(S(i)[n], i));
-      __gnu_sequential::sort(sample.begin(), sample.end(), lcomp);
+      for (int __i = 0; __i < __m; __i++)
+	if (__n < __ns[__i])	//__sequence long enough
+	  __sample.push_back(std::make_pair(__S(__i)[__n], __i));
+      __gnu_sequential::sort(__sample.begin(), __sample.end(), __lcomp);
 
-      for (int i = 0; i < m; i++)	//conceptual infinity
-	if (n >= ns[i])	//sequence too short, conceptual infinity
-	  sample.push_back(std::make_pair(S(i)[0] /*dummy element*/, i));
+      for (int __i = 0; __i < __m; __i++)	//conceptual infinity
+	if (__n >= __ns[__i])	//__sequence too short, conceptual infinity
+	  __sample.push_back(std::make_pair(__S(__i)[0] /*__dummy element*/, __i));
 
-      difference_type localrank = rank * m / N ;
+      _DifferenceType localrank = __rank * __m / __N ;
 
-      int j;
-      for (j = 0; j < localrank && ((n + 1) <= ns[sample[j].second]); ++j)
-	a[sample[j].second] += n + 1;
-      for (; j < m; j++)
-	b[sample[j].second] -= n + 1;
+      int __j;
+      for (__j = 0; __j < localrank && ((__n + 1) <= __ns[__sample[__j].second]); ++__j)
+	__a[__sample[__j].second] += __n + 1;
+      for (; __j < __m; __j++)
+	__b[__sample[__j].second] -= __n + 1;
       
       // Further refinement.
-      while (n > 0)
+      while (__n > 0)
 	{
-	  n /= 2;
+	  __n /= 2;
 
-	  int lmax_seq = -1;	// to avoid warning
-	  const value_type* lmax = NULL; // impossible to avoid the warning?
-	  for (int i = 0; i < m; i++)
+	  int __lmax_seq = -1;	// to avoid warning
+	  const _ValueType* __lmax = NULL; // impossible to avoid the warning?
+	  for (int __i = 0; __i < __m; __i++)
 	    {
-	      if (a[i] > 0)
+	      if (__a[__i] > 0)
 		{
-		  if (!lmax)
+		  if (!__lmax)
 		    {
-		      lmax = &(S(i)[a[i] - 1]);
-		      lmax_seq = i;
+		      __lmax = &(__S(__i)[__a[__i] - 1]);
+		      __lmax_seq = __i;
 		    }
 		  else
 		    {
 		      // Max, favor rear sequences.
-		      if (!comp(S(i)[a[i] - 1], *lmax))
+		      if (!__comp(__S(__i)[__a[__i] - 1], *__lmax))
 			{
-			  lmax = &(S(i)[a[i] - 1]);
-			  lmax_seq = i;
+			  __lmax = &(__S(__i)[__a[__i] - 1]);
+			  __lmax_seq = __i;
 			}
 		    }
 		}
 	    }
 
-	  int i;
-	  for (i = 0; i < m; i++)
+	  int __i;
+	  for (__i = 0; __i < __m; __i++)
 	    {
-	      difference_type middle = (b[i] + a[i]) / 2;
-	      if (lmax && middle < ns[i] &&
-		  lcomp(std::make_pair(S(i)[middle], i),
-			std::make_pair(*lmax, lmax_seq)))
-		a[i] = std::min(a[i] + n + 1, ns[i]);
+	      _DifferenceType __middle = (__b[__i] + __a[__i]) / 2;
+	      if (__lmax && __middle < __ns[__i] &&
+		  __lcomp(std::make_pair(__S(__i)[__middle], __i),
+			std::make_pair(*__lmax, __lmax_seq)))
+		__a[__i] = std::min(__a[__i] + __n + 1, __ns[__i]);
 	      else
-		b[i] -= n + 1;
+		__b[__i] -= __n + 1;
 	    }
 
-	  difference_type leftsize = 0, total = 0;
-	  for (int i = 0; i < m; i++)
+	  _DifferenceType __leftsize = 0, __total = 0;
+	  for (int __i = 0; __i < __m; __i++)
 	    {
-	      leftsize += a[i] / (n + 1);
-	      total += l / (n + 1);
+	      __leftsize += __a[__i] / (__n + 1);
+	      __total += __l / (__n + 1);
 	    }
 	  
-	  difference_type skew = static_cast<difference_type>
-	    (static_cast<uint64>(total) * rank / N - leftsize);
+	  _DifferenceType __skew = static_cast<_DifferenceType>
+	    (static_cast<uint64>(__total) * __rank / __N - __leftsize);
 
-	  if (skew > 0)
+	  if (__skew > 0)
 	    {
 	      // Move to the left, find smallest.
-	      std::priority_queue<std::pair<value_type, int>,
-		std::vector<std::pair<value_type, int> >,
-		lexicographic_reverse<value_type, int, Comparator> >
-		pq(lrcomp);
+	      std::priority_queue<std::pair<_ValueType, int>,
+		std::vector<std::pair<_ValueType, int> >,
+		_LexicographicReverse<_ValueType, int, _Compare> >
+		__pq(__lrcomp);
 	      
-	      for (int i = 0; i < m; i++)
-		if (b[i] < ns[i])
-		  pq.push(std::make_pair(S(i)[b[i]], i));
+	      for (int __i = 0; __i < __m; __i++)
+		if (__b[__i] < __ns[__i])
+		  __pq.push(std::make_pair(__S(__i)[__b[__i]], __i));
 
-	      for (; skew != 0 && !pq.empty(); --skew)
+	      for (; __skew != 0 && !__pq.empty(); --__skew)
 		{
-		  int source = pq.top().second;
-		  pq.pop();
+		  int source = __pq.top().second;
+		  __pq.pop();
 
-		  a[source] = std::min(a[source] + n + 1, ns[source]);
-		  b[source] += n + 1;
+		  __a[source] = std::min(__a[source] + __n + 1, __ns[source]);
+		  __b[source] += __n + 1;
 
-		  if (b[source] < ns[source])
-		    pq.push(std::make_pair(S(source)[b[source]], source));
+		  if (__b[source] < __ns[source])
+		    __pq.push(std::make_pair(__S(source)[__b[source]], source));
 		}
 	    }
-	  else if (skew < 0)
+	  else if (__skew < 0)
 	    {
 	      // Move to the right, find greatest.
-	      std::priority_queue<std::pair<value_type, int>,
-		std::vector<std::pair<value_type, int> >,
-		lexicographic<value_type, int, Comparator> > pq(lcomp);
+	      std::priority_queue<std::pair<_ValueType, int>,
+		std::vector<std::pair<_ValueType, int> >,
+		_Lexicographic<_ValueType, int, _Compare> > __pq(__lcomp);
 
-	      for (int i = 0; i < m; i++)
-		if (a[i] > 0)
-		  pq.push(std::make_pair(S(i)[a[i] - 1], i));
+	      for (int __i = 0; __i < __m; __i++)
+		if (__a[__i] > 0)
+		  __pq.push(std::make_pair(__S(__i)[__a[__i] - 1], __i));
 
-	      for (; skew != 0; ++skew)
+	      for (; __skew != 0; ++__skew)
 		{
-		  int source = pq.top().second;
-		  pq.pop();
+		  int source = __pq.top().second;
+		  __pq.pop();
 
-		  a[source] -= n + 1;
-		  b[source] -= n + 1;
+		  __a[source] -= __n + 1;
+		  __b[source] -= __n + 1;
 
-		  if (a[source] > 0)
-		    pq.push(std::make_pair(S(source)[a[source] - 1], source));
+		  if (__a[source] > 0)
+		    __pq.push(std::make_pair(__S(source)[__a[source] - 1], source));
 		}
 	    }
 	}
 
       // Postconditions:
-      // a[i] == b[i] in most cases, except when a[i] has been clamped
+      // __a[__i] == __b[__i] in most cases, except when __a[__i] has been clamped
       // because of having reached the boundary
 
       // Now return the result, calculate the offset.
@@ -326,236 +326,236 @@ namespace __gnu_parallel
       // Compare the keys on both edges of the border.
 
       // Maximum of left edge, minimum of right edge.
-      value_type* maxleft = NULL;
-      value_type* minright = NULL;
-      for (int i = 0; i < m; i++)
+      _ValueType* __maxleft = NULL;
+      _ValueType* __minright = NULL;
+      for (int __i = 0; __i < __m; __i++)
 	{
-	  if (a[i] > 0)
+	  if (__a[__i] > 0)
 	    {
-	      if (!maxleft)
-		maxleft = &(S(i)[a[i] - 1]);
+	      if (!__maxleft)
+		__maxleft = &(__S(__i)[__a[__i] - 1]);
 	      else
 		{
 		  // Max, favor rear sequences.
-		  if (!comp(S(i)[a[i] - 1], *maxleft))
-		    maxleft = &(S(i)[a[i] - 1]);
+		  if (!__comp(__S(__i)[__a[__i] - 1], *__maxleft))
+		    __maxleft = &(__S(__i)[__a[__i] - 1]);
 		}
 	    }
-	  if (b[i] < ns[i])
+	  if (__b[__i] < __ns[__i])
 	    {
-	      if (!minright)
-		minright = &(S(i)[b[i]]);
+	      if (!__minright)
+		__minright = &(__S(__i)[__b[__i]]);
 	      else
 		{
 		  // Min, favor fore sequences.
-		  if (comp(S(i)[b[i]], *minright))
-		    minright = &(S(i)[b[i]]);
+		  if (__comp(__S(__i)[__b[__i]], *__minright))
+		    __minright = &(__S(__i)[__b[__i]]);
 		}
 	    }
 	}
 
-      int seq = 0;
-      for (int i = 0; i < m; i++)
-	begin_offsets[i] = S(i) + a[i];
+      int __seq = 0;
+      for (int __i = 0; __i < __m; __i++)
+	__begin_offsets[__i] = __S(__i) + __a[__i];
 
-      delete[] ns;
-      delete[] a;
-      delete[] b;
+      delete[] __ns;
+      delete[] __a;
+      delete[] __b;
     }
 
 
   /** 
-   *  @brief Selects the element at a certain global rank from several
+   *  @brief Selects the element at __a certain global __rank from several
    *  sorted sequences.
    *
-   *  The sequences are passed via a sequence of random-access
+   *  The sequences are passed via __a __sequence of random-access
    *  iterator pairs, none of the sequences may be empty.
-   *  @param begin_seqs Begin of the sequence of iterator pairs.
-   *  @param end_seqs End of the sequence of iterator pairs.
-   *  @param rank The global rank to partition at.
-   *  @param offset The rank of the selected element in the global
+   *  @param __begin_seqs Begin of the sequence of iterator pairs.
+   *  @param __end_seqs End of the sequence of iterator pairs.
+   *  @param __rank The global __rank to partition at.
+   *  @param __offset The rank of the selected element in the global
    *  subsequence of elements equal to the selected element. If the
    *  selected element is unique, this number is 0.
-   *  @param comp The ordering functor, defaults to std::less. 
+   *  @param __comp The ordering functor, defaults to std::less. 
    */
-  template<typename T, typename RanSeqs, typename RankType,
-	   typename Comparator>
-    T
-    multiseq_selection(RanSeqs begin_seqs, RanSeqs end_seqs, RankType rank,
-		       RankType& offset, Comparator comp = std::less<T>())
+  template<typename _Tp, typename _RanSeqs, typename _RankType,
+	   typename _Compare>
+    _Tp
+    multiseq_selection(_RanSeqs __begin_seqs, _RanSeqs __end_seqs, _RankType __rank,
+		       _RankType& __offset, _Compare __comp = std::less<_Tp>())
     {
-      _GLIBCXX_CALL(end_seqs - begin_seqs)
+      _GLIBCXX_CALL(__end_seqs - __begin_seqs)
 
-      typedef typename std::iterator_traits<RanSeqs>::value_type::first_type
-	It;
-      typedef typename std::iterator_traits<It>::difference_type
-	difference_type;
+      typedef typename std::iterator_traits<_RanSeqs>::value_type::first_type
+	_It;
+      typedef typename std::iterator_traits<_It>::difference_type
+	_DifferenceType;
 
-      lexicographic<T, int, Comparator> lcomp(comp);
-      lexicographic_reverse<T, int, Comparator> lrcomp(comp);
+      _Lexicographic<_Tp, int, _Compare> __lcomp(__comp);
+      _LexicographicReverse<_Tp, int, _Compare> __lrcomp(__comp);
 
       // Number of sequences, number of elements in total (possibly
       // including padding).
-      difference_type m = std::distance(begin_seqs, end_seqs);
-      difference_type N = 0;
-      difference_type nmax, n, r;
+      _DifferenceType __m = std::distance(__begin_seqs, __end_seqs);
+      _DifferenceType __N = 0;
+      _DifferenceType __nmax, __n, __r;
 
-      for (int i = 0; i < m; i++)
-	N += std::distance(begin_seqs[i].first, begin_seqs[i].second);
+      for (int __i = 0; __i < __m; __i++)
+	__N += std::distance(__begin_seqs[__i].first, __begin_seqs[__i].second);
 
-      if (m == 0 || N == 0 || rank < 0 || rank >= N)
+      if (__m == 0 || __N == 0 || __rank < 0 || __rank >= __N)
 	{
-	  // Result undefined when there is no data or rank is outside bounds.
+	  // _Result undefined when there is no data or __rank is outside bounds.
 	  throw std::exception();
 	}
 
 
-      difference_type* ns = new difference_type[m];
-      difference_type* a = new difference_type[m];
-      difference_type* b = new difference_type[m];
-      difference_type l;
+      _DifferenceType* __ns = new _DifferenceType[__m];
+      _DifferenceType* __a = new _DifferenceType[__m];
+      _DifferenceType* __b = new _DifferenceType[__m];
+      _DifferenceType __l;
 
-      ns[0] = std::distance(begin_seqs[0].first, begin_seqs[0].second);
-      nmax = ns[0];
-      for (int i = 0; i < m; ++i)
+      __ns[0] = std::distance(__begin_seqs[0].first, __begin_seqs[0].second);
+      __nmax = __ns[0];
+      for (int __i = 0; __i < __m; ++__i)
 	{
-	  ns[i] = std::distance(begin_seqs[i].first, begin_seqs[i].second);
-	  nmax = std::max(nmax, ns[i]);
+	  __ns[__i] = std::distance(__begin_seqs[__i].first, __begin_seqs[__i].second);
+	  __nmax = std::max(__nmax, __ns[__i]);
 	}
 
-      r = __log2(nmax) + 1;
+      __r = __log2(__nmax) + 1;
 
-      // Pad all lists to this length, at least as long as any ns[i],
-      // equality iff nmax = 2^k - 1
-      l = pow2(r) - 1;
+      // Pad all lists to this length, at least as long as any ns[__i],
+      // equality iff __nmax = 2^__k - 1
+      __l = pow2(__r) - 1;
 
       // From now on, including padding.
-      N = l * m;
+      __N = __l * __m;
 
-      for (int i = 0; i < m; ++i)
+      for (int __i = 0; __i < __m; ++__i)
 	{
-	  a[i] = 0;
-	  b[i] = l;
+	  __a[__i] = 0;
+	  __b[__i] = __l;
 	}
-      n = l / 2;
+      __n = __l / 2;
 
       // Invariants:
-      // 0 <= a[i] <= ns[i], 0 <= b[i] <= l
+      // 0 <= __a[__i] <= __ns[__i], 0 <= __b[__i] <= __l
 
-#define S(i) (begin_seqs[i].first)
+#define __S(__i) (__begin_seqs[__i].first)
 
       // Initial partition.
-      std::vector<std::pair<T, int> > sample;
+      std::vector<std::pair<_Tp, int> > __sample;
 
-      for (int i = 0; i < m; i++)
-	if (n < ns[i])
-	  sample.push_back(std::make_pair(S(i)[n], i));
-      __gnu_sequential::sort(sample.begin(), sample.end(),
-			     lcomp, sequential_tag());
+      for (int __i = 0; __i < __m; __i++)
+	if (__n < __ns[__i])
+	  __sample.push_back(std::make_pair(__S(__i)[__n], __i));
+      __gnu_sequential::sort(__sample.begin(), __sample.end(),
+			     __lcomp, sequential_tag());
 
       // Conceptual infinity.
-      for (int i = 0; i < m; i++)
-	if (n >= ns[i])
-	  sample.push_back(std::make_pair(S(i)[0] /*dummy element*/, i));
+      for (int __i = 0; __i < __m; __i++)
+	if (__n >= __ns[__i])
+	  __sample.push_back(std::make_pair(__S(__i)[0] /*__dummy element*/, __i));
 
-      difference_type localrank = rank * m / N ;
+      _DifferenceType localrank = __rank * __m / __N ;
 
-      int j;
-      for (j = 0; j < localrank && ((n + 1) <= ns[sample[j].second]); ++j)
-	a[sample[j].second] += n + 1;
-      for (; j < m; ++j)
-	b[sample[j].second] -= n + 1;
+      int __j;
+      for (__j = 0; __j < localrank && ((__n + 1) <= __ns[__sample[__j].second]); ++__j)
+	__a[__sample[__j].second] += __n + 1;
+      for (; __j < __m; ++__j)
+	__b[__sample[__j].second] -= __n + 1;
 
       // Further refinement.
-      while (n > 0)
+      while (__n > 0)
 	{
-	  n /= 2;
+	  __n /= 2;
 
-	  const T* lmax = NULL;
-	  for (int i = 0; i < m; ++i)
+	  const _Tp* __lmax = NULL;
+	  for (int __i = 0; __i < __m; ++__i)
 	    {
-	      if (a[i] > 0)
+	      if (__a[__i] > 0)
 		{
-		  if (!lmax)
-		    lmax = &(S(i)[a[i] - 1]);
+		  if (!__lmax)
+		    __lmax = &(__S(__i)[__a[__i] - 1]);
 		  else
 		    {
-		      if (comp(*lmax, S(i)[a[i] - 1]))	//max
-			lmax = &(S(i)[a[i] - 1]);
+		      if (__comp(*__lmax, __S(__i)[__a[__i] - 1]))	//max
+			__lmax = &(__S(__i)[__a[__i] - 1]);
 		    }
 		}
 	    }
 
-	  int i;
-	  for (i = 0; i < m; i++)
+	  int __i;
+	  for (__i = 0; __i < __m; __i++)
 	    {
-	      difference_type middle = (b[i] + a[i]) / 2;
-	      if (lmax && middle < ns[i] && comp(S(i)[middle], *lmax))
-		a[i] = std::min(a[i] + n + 1, ns[i]);
+	      _DifferenceType __middle = (__b[__i] + __a[__i]) / 2;
+	      if (__lmax && __middle < __ns[__i] && __comp(__S(__i)[__middle], *__lmax))
+		__a[__i] = std::min(__a[__i] + __n + 1, __ns[__i]);
 	      else
-		b[i] -= n + 1;
+		__b[__i] -= __n + 1;
 	    }
 
-	  difference_type leftsize = 0, total = 0;
-	  for (int i = 0; i < m; ++i)
+	  _DifferenceType __leftsize = 0, __total = 0;
+	  for (int __i = 0; __i < __m; ++__i)
 	    {
-	      leftsize += a[i] / (n + 1);
-	      total += l / (n + 1);
+	      __leftsize += __a[__i] / (__n + 1);
+	      __total += __l / (__n + 1);
 	    }
 
-	  difference_type skew = ((unsigned long long)total * rank / N
-				  - leftsize);
+	  _DifferenceType __skew = ((unsigned long long)__total * __rank / __N
+				  - __leftsize);
 
-	  if (skew > 0)
+	  if (__skew > 0)
 	    {
 	      // Move to the left, find smallest.
-	      std::priority_queue<std::pair<T, int>,
-		std::vector<std::pair<T, int> >,
-		lexicographic_reverse<T, int, Comparator> > pq(lrcomp);
+	      std::priority_queue<std::pair<_Tp, int>,
+		std::vector<std::pair<_Tp, int> >,
+		_LexicographicReverse<_Tp, int, _Compare> > __pq(__lrcomp);
 
-	      for (int i = 0; i < m; ++i)
-		if (b[i] < ns[i])
-		  pq.push(std::make_pair(S(i)[b[i]], i));
+	      for (int __i = 0; __i < __m; ++__i)
+		if (__b[__i] < __ns[__i])
+		  __pq.push(std::make_pair(__S(__i)[__b[__i]], __i));
 
-	      for (; skew != 0 && !pq.empty(); --skew)
+	      for (; __skew != 0 && !__pq.empty(); --__skew)
 		{
-		  int source = pq.top().second;
-		  pq.pop();
+		  int source = __pq.top().second;
+		  __pq.pop();
 		  
-		  a[source] = std::min(a[source] + n + 1, ns[source]);
-		  b[source] += n + 1;
+		  __a[source] = std::min(__a[source] + __n + 1, __ns[source]);
+		  __b[source] += __n + 1;
 		  
-		  if (b[source] < ns[source])
-		    pq.push(std::make_pair(S(source)[b[source]], source));
+		  if (__b[source] < __ns[source])
+		    __pq.push(std::make_pair(__S(source)[__b[source]], source));
 		}
 	    }
-	  else if (skew < 0)
+	  else if (__skew < 0)
 	    {
 	      // Move to the right, find greatest.
-	      std::priority_queue<std::pair<T, int>,
-		std::vector<std::pair<T, int> >,
-		lexicographic<T, int, Comparator> > pq(lcomp);
+	      std::priority_queue<std::pair<_Tp, int>,
+		std::vector<std::pair<_Tp, int> >,
+		_Lexicographic<_Tp, int, _Compare> > __pq(__lcomp);
 
-	      for (int i = 0; i < m; ++i)
-		if (a[i] > 0)
-		  pq.push(std::make_pair(S(i)[a[i] - 1], i));
+	      for (int __i = 0; __i < __m; ++__i)
+		if (__a[__i] > 0)
+		  __pq.push(std::make_pair(__S(__i)[__a[__i] - 1], __i));
 
-	      for (; skew != 0; ++skew)
+	      for (; __skew != 0; ++__skew)
 		{
-		  int source = pq.top().second;
-		  pq.pop();
+		  int source = __pq.top().second;
+		  __pq.pop();
 
-		  a[source] -= n + 1;
-		  b[source] -= n + 1;
+		  __a[source] -= __n + 1;
+		  __b[source] -= __n + 1;
 
-		  if (a[source] > 0)
-		    pq.push(std::make_pair(S(source)[a[source] - 1], source));
+		  if (__a[source] > 0)
+		    __pq.push(std::make_pair(__S(source)[__a[source] - 1], source));
 		}
 	    }
 	}
 
       // Postconditions:
-      // a[i] == b[i] in most cases, except when a[i] has been clamped
+      // __a[__i] == __b[__i] in most cases, except when __a[__i] has been clamped
       // because of having reached the boundary
 
       // Now return the result, calculate the offset.
@@ -563,71 +563,71 @@ namespace __gnu_parallel
       // Compare the keys on both edges of the border.
 
       // Maximum of left edge, minimum of right edge.
-      bool maxleftset = false, minrightset = false;
+      bool __maxleftset = false, __minrightset = false;
 
       // Impossible to avoid the warning?
-      T maxleft, minright;
-      for (int i = 0; i < m; ++i)
+      _Tp __maxleft, __minright;
+      for (int __i = 0; __i < __m; ++__i)
 	{
-	  if (a[i] > 0)
+	  if (__a[__i] > 0)
 	    {
-	      if (!maxleftset)
+	      if (!__maxleftset)
 		{
-		  maxleft = S(i)[a[i] - 1];
-		  maxleftset = true;
+		  __maxleft = __S(__i)[__a[__i] - 1];
+		  __maxleftset = true;
 		}
 	      else
 		{
 		  // Max.
-		  if (comp(maxleft, S(i)[a[i] - 1]))
-		    maxleft = S(i)[a[i] - 1];
+		  if (__comp(__maxleft, __S(__i)[__a[__i] - 1]))
+		    __maxleft = __S(__i)[__a[__i] - 1];
 		}
 	    }
-	  if (b[i] < ns[i])
+	  if (__b[__i] < __ns[__i])
 	    {
-	      if (!minrightset)
+	      if (!__minrightset)
 		{
-		  minright = S(i)[b[i]];
-		  minrightset = true;
+		  __minright = __S(__i)[__b[__i]];
+		  __minrightset = true;
 		}
 	      else
 		{
 		  // Min.
-		  if (comp(S(i)[b[i]], minright))
-		    minright = S(i)[b[i]];
+		  if (__comp(__S(__i)[__b[__i]], __minright))
+		    __minright = __S(__i)[__b[__i]];
 		}
 	    }
       }
 
       // Minright is the splitter, in any case.
 
-      if (!maxleftset || comp(minright, maxleft))
+      if (!__maxleftset || __comp(__minright, __maxleft))
 	{
 	  // Good luck, everything is split unambiguously.
-	  offset = 0;
+	  __offset = 0;
 	}
       else
 	{
 	  // We have to calculate an offset.
-	  offset = 0;
+	  __offset = 0;
 
-	  for (int i = 0; i < m; ++i)
+	  for (int __i = 0; __i < __m; ++__i)
 	    {
-	      difference_type lb = std::lower_bound(S(i), S(i) + ns[i],
-						    minright,
-						    comp) - S(i);
-	      offset += a[i] - lb;
+	      _DifferenceType lb = std::lower_bound(__S(__i), __S(__i) + __ns[__i],
+						    __minright,
+						    __comp) - __S(__i);
+	      __offset += __a[__i] - lb;
 	    }
 	}
 
-      delete[] ns;
-      delete[] a;
-      delete[] b;
+      delete[] __ns;
+      delete[] __a;
+      delete[] __b;
 
-      return minright;
+      return __minright;
     }
 }
 
-#undef S
+#undef __S
 
 #endif /* _GLIBCXX_PARALLEL_MULTISEQ_SELECTION_H */
diff --git a/libstdc++-v3/include/parallel/multiway_merge.h b/libstdc++-v3/include/parallel/multiway_merge.h
index fe32053..0aa661f 100644
--- a/libstdc++-v3/include/parallel/multiway_merge.h
+++ b/libstdc++-v3/include/parallel/multiway_merge.h
@@ -50,303 +50,303 @@
 #endif
 
 /** @brief Length of a sequence described by a pair of iterators. */
-#define _GLIBCXX_PARALLEL_LENGTH(s) ((s).second - (s).first)
+#define _GLIBCXX_PARALLEL_LENGTH(__s) ((__s).second - (__s).first)
 
 namespace __gnu_parallel
 {
 
 // Announce guarded and unguarded iterator.
 
-template<typename RandomAccessIterator, typename Comparator>
-  class guarded_iterator;
+template<typename _RAIter, typename _Compare>
+  class _GuardedIterator;
 
 // Making the arguments const references seems to dangerous,
 // the user-defined comparator might not be const.
-template<typename RandomAccessIterator, typename Comparator>
+template<typename _RAIter, typename _Compare>
   inline bool
-  operator<(guarded_iterator<RandomAccessIterator, Comparator>& bi1,
-             guarded_iterator<RandomAccessIterator, Comparator>& bi2);
+  operator<(_GuardedIterator<_RAIter, _Compare>& __bi1,
+             _GuardedIterator<_RAIter, _Compare>& __bi2);
 
-template<typename RandomAccessIterator, typename Comparator>
+template<typename _RAIter, typename _Compare>
   inline bool
-  operator<=(guarded_iterator<RandomAccessIterator, Comparator>& bi1,
-              guarded_iterator<RandomAccessIterator, Comparator>& bi2);
+  operator<=(_GuardedIterator<_RAIter, _Compare>& __bi1,
+              _GuardedIterator<_RAIter, _Compare>& __bi2);
 
-/** @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.
+ * The implicit __supremum comes with __a performance cost.
  *
- * Deriving from RandomAccessIterator is not possible since
- * RandomAccessIterator need not be a class.
+ * Deriving from _RAIter is not possible since
+ * _RAIter need not be __a class.
  */
-template<typename RandomAccessIterator, typename Comparator>
-  class guarded_iterator
+template<typename _RAIter, typename _Compare>
+  class _GuardedIterator
   {
   private:
-    /** @brief Current iterator position. */
-    RandomAccessIterator current;
+    /** @brief Current iterator __position. */
+    _RAIter _M_current;
 
     /** @brief End iterator of the sequence. */
-    RandomAccessIterator end;
+    _RAIter _M_end;
 
-    /** @brief Comparator. */
-    Comparator& comp;
+    /** @brief _Compare. */
+    _Compare& __comp;
 
   public:
     /** @brief Constructor. Sets iterator to beginning of sequence.
-    *  @param begin Begin iterator of sequence.
-    *  @param end End iterator of sequence.
-    *  @param comp Comparator provided for associated overloaded
+    *  @param __begin Begin iterator of sequence.
+    *  @param _M_end End iterator of sequence.
+    *  @param __comp Comparator provided for associated overloaded
     *  compare operators. */
-    guarded_iterator(RandomAccessIterator begin,
-                     RandomAccessIterator end, Comparator& comp)
-    : current(begin), end(end), comp(comp)
+    _GuardedIterator(_RAIter __begin,
+                     _RAIter _M_end, _Compare& __comp)
+    : _M_current(__begin), _M_end(_M_end), __comp(__comp)
     { }
 
     /** @brief Pre-increment operator.
     *  @return This. */
-    guarded_iterator<RandomAccessIterator, Comparator>&
+    _GuardedIterator<_RAIter, _Compare>&
     operator++()
     {
-      ++current;
+      ++_M_current;
       return *this;
     }
 
     /** @brief Dereference operator.
     *  @return Referenced element. */
-    typename std::iterator_traits<RandomAccessIterator>::value_type&
+    typename std::iterator_traits<_RAIter>::value_type&
     operator*()
-    { return *current; }
+    { return *_M_current; }
 
     /** @brief Convert to wrapped iterator.
     *  @return Wrapped iterator. */
-    operator RandomAccessIterator()
-    { return current; }
+    operator _RAIter()
+    { return _M_current; }
 
     friend bool
-    operator< <RandomAccessIterator, Comparator>(
-      guarded_iterator<RandomAccessIterator, Comparator>& bi1,
-      guarded_iterator<RandomAccessIterator, Comparator>& bi2);
+    operator< <_RAIter, _Compare>(
+      _GuardedIterator<_RAIter, _Compare>& __bi1,
+      _GuardedIterator<_RAIter, _Compare>& __bi2);
 
     friend bool
-    operator<= <RandomAccessIterator, Comparator>(
-      guarded_iterator<RandomAccessIterator, Comparator>& bi1,
-      guarded_iterator<RandomAccessIterator, Comparator>& bi2);
+    operator<= <_RAIter, _Compare>(
+      _GuardedIterator<_RAIter, _Compare>& __bi1,
+      _GuardedIterator<_RAIter, _Compare>& __bi2);
   };
 
 /** @brief Compare two elements referenced by guarded iterators.
- *  @param bi1 First iterator.
- *  @param bi2 Second iterator.
- *  @return @c True if less. */
-template<typename RandomAccessIterator, typename Comparator>
+ *  @param __bi1 First iterator.
+ *  @param __bi2 Second iterator.
+ *  @return @__c true if less. */
+template<typename _RAIter, typename _Compare>
   inline bool
-  operator<(guarded_iterator<RandomAccessIterator, Comparator>& bi1,
-            guarded_iterator<RandomAccessIterator, Comparator>& bi2)
+  operator<(_GuardedIterator<_RAIter, _Compare>& __bi1,
+            _GuardedIterator<_RAIter, _Compare>& __bi2)
   {
-    if (bi1.current == bi1.end)	//bi1 is sup
-      return bi2.current == bi2.end;	//bi2 is not sup
-    if (bi2.current == bi2.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.
- *  @param bi1 First iterator.
- *  @param bi2 Second iterator.
- *  @return @c True if less equal. */
-template<typename RandomAccessIterator, typename Comparator>
+ *  @param __bi1 First iterator.
+ *  @param __bi2 Second iterator.
+ *  @return @__c True if less equal. */
+template<typename _RAIter, typename _Compare>
   inline bool
-  operator<=(guarded_iterator<RandomAccessIterator, Comparator>& bi1,
-               guarded_iterator<RandomAccessIterator, Comparator>& bi2)
+  operator<=(_GuardedIterator<_RAIter, _Compare>& __bi1,
+               _GuardedIterator<_RAIter, _Compare>& __bi2)
   {
-    if (bi2.current == bi2.end)	//bi1 is sup
-      return bi1.current != bi1.end;	//bi2 is not sup
-    if (bi1.current == bi1.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 RandomAccessIterator, typename Comparator>
+template<typename _RAIter, typename _Compare>
   class unguarded_iterator;
 
-template<typename RandomAccessIterator, typename Comparator>
+template<typename _RAIter, typename _Compare>
   inline bool
-  operator<(unguarded_iterator<RandomAccessIterator, Comparator>& bi1,
-            unguarded_iterator<RandomAccessIterator, Comparator>& bi2);
+  operator<(unguarded_iterator<_RAIter, _Compare>& __bi1,
+            unguarded_iterator<_RAIter, _Compare>& __bi2);
 
-template<typename RandomAccessIterator, typename Comparator>
+template<typename _RAIter, typename _Compare>
   inline bool
-  operator<=(unguarded_iterator<RandomAccessIterator, Comparator>& bi1,
-             unguarded_iterator<RandomAccessIterator, Comparator>& bi2);
+  operator<=(unguarded_iterator<_RAIter, _Compare>& __bi1,
+             unguarded_iterator<_RAIter, _Compare>& __bi2);
 
-template<typename RandomAccessIterator, typename Comparator>
+template<typename _RAIter, typename _Compare>
   class unguarded_iterator
   {
   private:
-    /** @brief Current iterator position. */
-    RandomAccessIterator current;
-    /** @brief Comparator. */
-    mutable Comparator& comp;
+    /** @brief Current iterator __position. */
+    _RAIter _M_current;
+    /** @brief _Compare. */
+    mutable _Compare& __comp;
 
   public:
     /** @brief Constructor. Sets iterator to beginning of sequence.
-    *  @param begin Begin iterator of sequence.
-    *  @param end Unused, only for compatibility.
-    *  @param comp Unused, only for compatibility. */
-    unguarded_iterator(RandomAccessIterator begin,
-                       RandomAccessIterator end, Comparator& comp)
-    : current(begin), comp(comp)
+    *  @param __begin Begin iterator of sequence.
+    *  @param _M_end Unused, only for compatibility.
+    *  @param __comp Unused, only for compatibility. */
+    unguarded_iterator(_RAIter __begin,
+                       _RAIter _M_end, _Compare& __comp)
+    : _M_current(__begin), __comp(__comp)
     { }
 
     /** @brief Pre-increment operator.
     *  @return This. */
-    unguarded_iterator<RandomAccessIterator, Comparator>&
+    unguarded_iterator<_RAIter, _Compare>&
     operator++()
     {
-      ++current;
+      ++_M_current;
       return *this;
     }
 
     /** @brief Dereference operator.
     *  @return Referenced element. */
-    typename std::iterator_traits<RandomAccessIterator>::value_type&
+    typename std::iterator_traits<_RAIter>::value_type&
     operator*()
-    { return *current; }
+    { return *_M_current; }
 
     /** @brief Convert to wrapped iterator.
     *  @return Wrapped iterator. */
-    operator RandomAccessIterator()
-    { return current; }
+    operator _RAIter()
+    { return _M_current; }
 
     friend bool
-    operator< <RandomAccessIterator, Comparator>(
-      unguarded_iterator<RandomAccessIterator, Comparator>& bi1,
-      unguarded_iterator<RandomAccessIterator, Comparator>& bi2);
+    operator< <_RAIter, _Compare>(
+      unguarded_iterator<_RAIter, _Compare>& __bi1,
+      unguarded_iterator<_RAIter, _Compare>& __bi2);
 
     friend bool
-    operator<= <RandomAccessIterator, Comparator>(
-      unguarded_iterator<RandomAccessIterator, Comparator>& bi1,
-      unguarded_iterator<RandomAccessIterator, Comparator>& bi2);
+    operator<= <_RAIter, _Compare>(
+      unguarded_iterator<_RAIter, _Compare>& __bi1,
+      unguarded_iterator<_RAIter, _Compare>& __bi2);
   };
 
 /** @brief Compare two elements referenced by unguarded iterators.
- *  @param bi1 First iterator.
- *  @param bi2 Second iterator.
- *  @return @c True if less. */
-template<typename RandomAccessIterator, typename Comparator>
+ *  @param __bi1 First iterator.
+ *  @param __bi2 Second iterator.
+ *  @return @__c true if less. */
+template<typename _RAIter, typename _Compare>
   inline bool
-  operator<(unguarded_iterator<RandomAccessIterator, Comparator>& bi1,
-            unguarded_iterator<RandomAccessIterator, Comparator>& bi2)
+  operator<(unguarded_iterator<_RAIter, _Compare>& __bi1,
+            unguarded_iterator<_RAIter, _Compare>& __bi2)
   {
     // Normal compare.
-    return (bi1.comp)(*bi1, *bi2);
+    return (__bi1.__comp)(*__bi1, *__bi2);
   }
 
 /** @brief Compare two elements referenced by unguarded iterators.
- *  @param bi1 First iterator.
- *  @param bi2 Second iterator.
- *  @return @c True if less equal. */
-template<typename RandomAccessIterator, typename Comparator>
+ *  @param __bi1 First iterator.
+ *  @param __bi2 Second iterator.
+ *  @return @__c True if less equal. */
+template<typename _RAIter, typename _Compare>
   inline bool
-  operator<=(unguarded_iterator<RandomAccessIterator, Comparator>& bi1,
-            unguarded_iterator<RandomAccessIterator, Comparator>& bi2)
+  operator<=(unguarded_iterator<_RAIter, _Compare>& __bi1,
+            unguarded_iterator<_RAIter, _Compare>& __bi2)
   {
     // Normal compare.
-    return !(bi1.comp)(*bi2, *bi1);
+    return !(__bi1.__comp)(*__bi2, *__bi1);
   }
 
 /** @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
- * comparison after merging out an element.  The implementation trick
+ * comparison after merging an element.  The implementation trick
  * that makes this fast is that the order of the sequences is stored
  * in the instruction pointer (translated into labels in C++).
  *
  * This works well for merging up to 4 sequences.
  *
- * Note that making the merging stable does <em>not</em> come at a
+ * Note that making the merging stable does <em>not</em> come at __a
  * performance hit.
  *
  * Whether the merging is done guarded or unguarded is selected by the
  * used iterator class.
  *
- * @param seqs_begin Begin iterator of iterator pair input sequence.
- * @param seqs_end End iterator of iterator pair input sequence.
- * @param target Begin iterator out output sequence.
- * @param comp Comparator.
- * @param length Maximum length to merge, less equal than the
+ * @param __seqs_begin Begin iterator of iterator pair input sequence.
+ * @param __seqs_end End iterator of iterator pair input sequence.
+ * @param __target Begin iterator of __output sequence.
+ * @param __comp Comparator.
+ * @param __length Maximum length to merge, less equal than the
  * total number of elements available.
  *
  * @return End iterator of output sequence.
  */
 template<template<typename RAI, typename C> class iterator,
-	 typename RandomAccessIteratorIterator,
-	 typename RandomAccessIterator3,
+	 typename _RAIterIterator,
+	 typename _RAIter3,
 	 typename _DifferenceTp,
-	 typename Comparator>
-  RandomAccessIterator3
+	 typename _Compare>
+  _RAIter3
   multiway_merge_3_variant(
-      RandomAccessIteratorIterator seqs_begin,
-      RandomAccessIteratorIterator seqs_end,
-      RandomAccessIterator3 target,
-      _DifferenceTp length, Comparator comp)
+      _RAIterIterator __seqs_begin,
+      _RAIterIterator __seqs_end,
+      _RAIter3 __target,
+      _DifferenceTp __length, _Compare __comp)
   {
-    _GLIBCXX_CALL(length);
+    _GLIBCXX_CALL(__length);
 
-    typedef _DifferenceTp difference_type;
+    typedef _DifferenceTp _DifferenceType;
 
-    typedef typename std::iterator_traits<RandomAccessIteratorIterator>
+    typedef typename std::iterator_traits<_RAIterIterator>
       ::value_type::first_type
-      RandomAccessIterator1;
-    typedef typename std::iterator_traits<RandomAccessIterator1>::value_type
-      value_type;
+      _RAIter1;
+    typedef typename std::iterator_traits<_RAIter1>::value_type
+      _ValueType;
 
-    if (length == 0)
-      return target;
+    if (__length == 0)
+      return __target;
 
 #if _GLIBCXX_ASSERTIONS
-    _DifferenceTp orig_length = length;
+    _DifferenceTp orig_length = __length;
 #endif
 
-    iterator<RandomAccessIterator1, Comparator>
-      seq0(seqs_begin[0].first, seqs_begin[0].second, comp),
-      seq1(seqs_begin[1].first, seqs_begin[1].second, comp),
-      seq2(seqs_begin[2].first, seqs_begin[2].second, comp);
+    iterator<_RAIter1, _Compare>
+      __seq0(__seqs_begin[0].first, __seqs_begin[0].second, __comp),
+      __seq1(__seqs_begin[1].first, __seqs_begin[1].second, __comp),
+      __seq2(__seqs_begin[2].first, __seqs_begin[2].second, __comp);
 
-    if (seq0 <= seq1)
+    if (__seq0 <= __seq1)
       {
-        if (seq1 <= seq2)
-          goto s012;
+        if (__seq1 <= __seq2)
+          goto __s012;
         else
-          if (seq2 <  seq0)
-            goto s201;
+          if (__seq2 <  __seq0)
+            goto __s201;
           else
-            goto s021;
+            goto __s021;
       }
     else
       {
-        if (seq1 <= seq2)
+        if (__seq1 <= __seq2)
           {
-            if (seq0 <= seq2)
-              goto s102;
+            if (__seq0 <= __seq2)
+              goto __s102;
             else
-              goto s120;
+              goto __s120;
           }
         else
-          goto s210;
+          goto __s210;
       }
-#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;  \
-      goto s ## b ## c ## a;
+#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;  \
+      goto __s ## __b ## __c ## __a;
 
     _GLIBCXX_PARALLEL_MERGE_3_CASE(0, 1, 2, <=, <=);
     _GLIBCXX_PARALLEL_MERGE_3_CASE(1, 2, 0, <=, < );
@@ -362,17 +362,17 @@ template<template<typename RAI, typename C> class iterator,
 
 #if _GLIBCXX_ASSERTIONS
   _GLIBCXX_PARALLEL_ASSERT(
-      ((RandomAccessIterator1)seq0 - seqs_begin[0].first) +
-      ((RandomAccessIterator1)seq1 - seqs_begin[1].first) +
-      ((RandomAccessIterator1)seq2 - seqs_begin[2].first)
+      ((_RAIter1)__seq0 - __seqs_begin[0].first) +
+      ((_RAIter1)__seq1 - __seqs_begin[1].first) +
+      ((_RAIter1)__seq2 - __seqs_begin[2].first)
       == orig_length);
 #endif
 
-    seqs_begin[0].first = seq0;
-    seqs_begin[1].first = seq1;
-    seqs_begin[2].first = seq2;
+    __seqs_begin[0].first = __seq0;
+    __seqs_begin[1].first = __seq1;
+    __seqs_begin[2].first = __seq2;
 
-    return target;
+    return __target;
   }
 
 /**
@@ -380,74 +380,74 @@ template<template<typename RAI, typename C> class iterator,
  *
  * Merging is done with the algorithm implementation described by Peter
  * Sanders. Basically, the idea is to minimize the number of necessary
- * comparison after merging out an element.  The implementation trick
+ * comparison after merging an element.  The implementation trick
  * that makes this fast is that the order of the sequences is stored
  * in the instruction pointer (translated into goto labels in C++).
  *
  * This works well for merging up to 4 sequences.
  *
- * Note that making the merging stable does <em>not</em> come at a
+ * Note that making the merging stable does <em>not</em> come at __a
  * performance hit.
  *
  * Whether the merging is done guarded or unguarded is selected by the
  * used iterator class.
  *
- * @param seqs_begin Begin iterator of iterator pair input sequence.
- * @param seqs_end End iterator of iterator pair input sequence.
- * @param target Begin iterator out output sequence.
- * @param comp Comparator.
- * @param length Maximum length to merge, less equal than the
+ * @param __seqs_begin Begin iterator of iterator pair input sequence.
+ * @param __seqs_end End iterator of iterator pair input sequence.
+ * @param __target Begin iterator of __output sequence.
+ * @param __comp Comparator.
+ * @param __length Maximum length to merge, less equal than the
  * total number of elements available.
  *
  * @return End iterator of output sequence.
  */
 template<template<typename RAI, typename C> class iterator,
-	 typename RandomAccessIteratorIterator,
-	 typename RandomAccessIterator3,
+	 typename _RAIterIterator,
+	 typename _RAIter3,
 	 typename _DifferenceTp,
-	 typename Comparator>
-  RandomAccessIterator3
-  multiway_merge_4_variant(RandomAccessIteratorIterator seqs_begin,
-                           RandomAccessIteratorIterator seqs_end,
-                           RandomAccessIterator3 target,
-                           _DifferenceTp length, Comparator comp)
+	 typename _Compare>
+  _RAIter3
+  multiway_merge_4_variant(_RAIterIterator __seqs_begin,
+                           _RAIterIterator __seqs_end,
+                           _RAIter3 __target,
+                           _DifferenceTp __length, _Compare __comp)
   {
-    _GLIBCXX_CALL(length);
-    typedef _DifferenceTp difference_type;
+    _GLIBCXX_CALL(__length);
+    typedef _DifferenceTp _DifferenceType;
 
-    typedef typename std::iterator_traits<RandomAccessIteratorIterator>
+    typedef typename std::iterator_traits<_RAIterIterator>
       ::value_type::first_type
-      RandomAccessIterator1;
-    typedef typename std::iterator_traits<RandomAccessIterator1>::value_type
-      value_type;
-
-    iterator<RandomAccessIterator1, Comparator>
-      seq0(seqs_begin[0].first, seqs_begin[0].second, comp),
-      seq1(seqs_begin[1].first, seqs_begin[1].second, comp),
-      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;  }
-
-    if (seq0 <= seq1)
+      _RAIter1;
+    typedef typename std::iterator_traits<_RAIter1>::value_type
+      _ValueType;
+
+    iterator<_RAIter1, _Compare>
+      __seq0(__seqs_begin[0].first, __seqs_begin[0].second, __comp),
+      __seq1(__seqs_begin[1].first, __seqs_begin[1].second, __comp),
+      __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;  }
+
+    if (__seq0 <= __seq1)
       {
-        if (seq1 <= seq2)
+        if (__seq1 <= __seq2)
           _GLIBCXX_PARALLEL_DECISION(0,1,2,3)
           else
-            if (seq2 < seq0)
+            if (__seq2 < __seq0)
               _GLIBCXX_PARALLEL_DECISION(2,0,1,3)
               else
                 _GLIBCXX_PARALLEL_DECISION(0,2,1,3)
                   }
     else
       {
-        if (seq1 <= seq2)
+        if (__seq1 <= __seq2)
           {
-            if (seq0 <= seq2)
+            if (__seq0 <= __seq2)
               _GLIBCXX_PARALLEL_DECISION(1,0,2,3)
               else
                 _GLIBCXX_PARALLEL_DECISION(1,2,0,3)
@@ -456,17 +456,17 @@ 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;                             \
-    *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;
+#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;
 
     _GLIBCXX_PARALLEL_MERGE_4_CASE(0, 1, 2, 3, <=, <=, <=);
     _GLIBCXX_PARALLEL_MERGE_4_CASE(0, 1, 3, 2, <=, <=, <=);
@@ -499,94 +499,94 @@ template<template<typename RAI, typename C> class iterator,
   finish:
     ;
 
-    seqs_begin[0].first = seq0;
-    seqs_begin[1].first = seq1;
-    seqs_begin[2].first = seq2;
-    seqs_begin[3].first = seq3;
+    __seqs_begin[0].first = __seq0;
+    __seqs_begin[1].first = __seq1;
+    __seqs_begin[2].first = __seq2;
+    __seqs_begin[3].first = __seq3;
 
-    return target;
+    return __target;
   }
 
 /** @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>.
+ * This merging variant uses __a LoserTree class as selected by <tt>LT</tt>.
  *
  * Stability is selected through the used LoserTree class <tt>LT</tt>.
  *
- * At least one non-empty sequence is required.
+ * At least one non-empty __sequence is required.
  *
- * @param seqs_begin Begin iterator of iterator pair input sequence.
- * @param seqs_end End iterator of iterator pair input sequence.
- * @param target Begin iterator out output sequence.
- * @param comp Comparator.
- * @param length Maximum length to merge, less equal than the
+ * @param __seqs_begin Begin iterator of iterator pair input sequence.
+ * @param __seqs_end End iterator of iterator pair input sequence.
+ * @param __target Begin iterator of __output sequence.
+ * @param __comp Comparator.
+ * @param __length Maximum length to merge, less equal than the
  * total number of elements available.
  *
  * @return End iterator of output sequence.
  */
 template<typename LT,
-	 typename RandomAccessIteratorIterator,
-	 typename RandomAccessIterator3,
+	 typename _RAIterIterator,
+	 typename _RAIter3,
 	 typename _DifferenceTp,
-	 typename Comparator>
-  RandomAccessIterator3
-  multiway_merge_loser_tree(RandomAccessIteratorIterator seqs_begin,
-                            RandomAccessIteratorIterator seqs_end,
-                            RandomAccessIterator3 target,
-                            _DifferenceTp length, Comparator comp)
+	 typename _Compare>
+  _RAIter3
+  multiway_merge_loser_tree(_RAIterIterator __seqs_begin,
+                            _RAIterIterator __seqs_end,
+                            _RAIter3 __target,
+                            _DifferenceTp __length, _Compare __comp)
   {
-    _GLIBCXX_CALL(length)
+    _GLIBCXX_CALL(__length)
 
-    typedef _DifferenceTp difference_type;
-    typedef typename std::iterator_traits<RandomAccessIteratorIterator>
+    typedef _DifferenceTp _DifferenceType;
+    typedef typename std::iterator_traits<_RAIterIterator>
       ::value_type::first_type
-      RandomAccessIterator1;
-    typedef typename std::iterator_traits<RandomAccessIterator1>::value_type
-      value_type;
+      _RAIter1;
+    typedef typename std::iterator_traits<_RAIter1>::value_type
+      _ValueType;
 
-    int k = static_cast<int>(seqs_end - seqs_begin);
+    int __k = static_cast<int>(__seqs_end - __seqs_begin);
 
-    LT lt(k, comp);
+    LT __lt(__k, __comp);
 
     // Default value for potentially non-default-constructible types.
-    value_type* arbitrary_element = NULL;
+    _ValueType* __arbitrary_element = NULL;
 
-    for (int t = 0; t < k; ++t)
+    for (int __t = 0; __t < __k; ++__t)
       {
-        if(arbitrary_element == NULL
-            && _GLIBCXX_PARALLEL_LENGTH(seqs_begin[t]) > 0)
-          arbitrary_element = &(*seqs_begin[t].first);
+        if(__arbitrary_element == NULL
+            && _GLIBCXX_PARALLEL_LENGTH(__seqs_begin[__t]) > 0)
+          __arbitrary_element = &(*__seqs_begin[__t].first);
       }
 
-    for (int t = 0; t < k; ++t)
+    for (int __t = 0; __t < __k; ++__t)
       {
-        if (seqs_begin[t].first == seqs_begin[t].second)
-          lt.insert_start(*arbitrary_element, t, true);
+        if (__seqs_begin[__t].first == __seqs_begin[__t].second)
+          __lt.__insert_start(*__arbitrary_element, __t, true);
         else
-          lt.insert_start(*seqs_begin[t].first, t, false);
+          __lt.__insert_start(*__seqs_begin[__t].first, __t, false);
       }
 
-    lt.init();
+    __lt.__init();
 
     int source;
 
-    for (difference_type i = 0; i < length; ++i)
+    for (_DifferenceType __i = 0; __i < __length; ++__i)
       {
-        //take out
-        source = lt.get_min_source();
+        //take __out
+        source = __lt.__get_min_source();
 
-        *(target++) = *(seqs_begin[source].first++);
+        *(__target++) = *(__seqs_begin[source].first++);
 
         // Feed.
-        if (seqs_begin[source].first == seqs_begin[source].second)
-          lt.delete_min_insert(*arbitrary_element, true);
+        if (__seqs_begin[source].first == __seqs_begin[source].second)
+          __lt.__delete_min_insert(*__arbitrary_element, true);
         else
           // Replace from same source.
-          lt.delete_min_insert(*seqs_begin[source].first, false);
+          __lt.__delete_min_insert(*__seqs_begin[source].first, false);
       }
 
-    return target;
+    return __target;
   }
 
 /** @brief Multi-way merging procedure for a high branching factor,
@@ -598,360 +598,360 @@ template<typename LT,
  *
  * @pre No input will run out of elements during the merge.
  *
- * @param seqs_begin Begin iterator of iterator pair input sequence.
- * @param seqs_end End iterator of iterator pair input sequence.
- * @param target Begin iterator out output sequence.
- * @param comp Comparator.
- * @param length Maximum length to merge, less equal than the
+ * @param __seqs_begin Begin iterator of iterator pair input sequence.
+ * @param __seqs_end End iterator of iterator pair input sequence.
+ * @param __target Begin iterator of __output sequence.
+ * @param __comp Comparator.
+ * @param __length Maximum length to merge, less equal than the
  * total number of elements available.
  *
  * @return End iterator of output sequence.
  */
 template<typename LT,
-    typename RandomAccessIteratorIterator,
-    typename RandomAccessIterator3,
-    typename _DifferenceTp, typename Comparator>
-  RandomAccessIterator3
+    typename _RAIterIterator,
+    typename _RAIter3,
+    typename _DifferenceTp, typename _Compare>
+  _RAIter3
   multiway_merge_loser_tree_unguarded(
-    RandomAccessIteratorIterator seqs_begin,
-    RandomAccessIteratorIterator seqs_end,
-    RandomAccessIterator3 target,
+    _RAIterIterator __seqs_begin,
+    _RAIterIterator __seqs_end,
+    _RAIter3 __target,
     const typename std::iterator_traits<typename std::iterator_traits<
-      RandomAccessIteratorIterator>::value_type::first_type>::value_type&
-        sentinel,
-    _DifferenceTp length,
-    Comparator comp)
+      _RAIterIterator>::value_type::first_type>::value_type&
+        __sentinel,
+    _DifferenceTp __length,
+    _Compare __comp)
   {
-    _GLIBCXX_CALL(length)
-    typedef _DifferenceTp difference_type;
+    _GLIBCXX_CALL(__length)
+    typedef _DifferenceTp _DifferenceType;
 
-    typedef typename std::iterator_traits<RandomAccessIteratorIterator>
+    typedef typename std::iterator_traits<_RAIterIterator>
       ::value_type::first_type
-      RandomAccessIterator1;
-    typedef typename std::iterator_traits<RandomAccessIterator1>::value_type
-      value_type;
+      _RAIter1;
+    typedef typename std::iterator_traits<_RAIter1>::value_type
+      _ValueType;
 
-    int k = seqs_end - seqs_begin;
+    int __k = __seqs_end - __seqs_begin;
 
-    LT lt(k, sentinel, comp);
+    LT __lt(__k, __sentinel, __comp);
 
-    for (int t = 0; t < k; ++t)
+    for (int __t = 0; __t < __k; ++__t)
       {
 #if _GLIBCXX_ASSERTIONS
-        _GLIBCXX_PARALLEL_ASSERT(seqs_begin[t].first != seqs_begin[t].second);
+        _GLIBCXX_PARALLEL_ASSERT(__seqs_begin[__t].first != __seqs_begin[__t].second);
 #endif
-        lt.insert_start(*seqs_begin[t].first, t, false);
+        __lt.__insert_start(*__seqs_begin[__t].first, __t, false);
       }
 
-    lt.init();
+    __lt.__init();
 
     int source;
 
 #if _GLIBCXX_ASSERTIONS
-    difference_type i = 0;
+    _DifferenceType __i = 0;
 #endif
 
-    RandomAccessIterator3 target_end = target + length;
-    while (target < target_end)
+    _RAIter3 __target_end = __target + __length;
+    while (__target < __target_end)
       {
         // Take out.
-        source = lt.get_min_source();
+        source = __lt.__get_min_source();
 
 #if _GLIBCXX_ASSERTIONS
-        _GLIBCXX_PARALLEL_ASSERT(0 <= source && source < k);
-        _GLIBCXX_PARALLEL_ASSERT(i == 0
-            || !comp(*(seqs_begin[source].first), *(target - 1)));
+        _GLIBCXX_PARALLEL_ASSERT(0 <= source && source < __k);
+        _GLIBCXX_PARALLEL_ASSERT(__i == 0
+            || !__comp(*(__seqs_begin[source].first), *(__target - 1)));
 #endif
 
         // Feed.
-        *(target++) = *(seqs_begin[source].first++);
+        *(__target++) = *(__seqs_begin[source].first++);
 
 #if _GLIBCXX_ASSERTIONS
-        ++i;
+        ++__i;
 #endif
         // Replace from same source.
-        lt.delete_min_insert(*seqs_begin[source].first, false);
+        __lt.__delete_min_insert(*__seqs_begin[source].first, false);
       }
 
-    return target;
+    return __target;
   }
 
 
 /** @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.
- * @param UnguardedLoserTree Loser Tree variant to use for the unguarded
+ * @param __stable The value must the same as for the used LoserTrees.
+ * @param UnguardedLoserTree _Loser Tree variant to use for the unguarded
  *   merging.
- * @param GuardedLoserTree Loser Tree variant to use for the guarded
+ * @param GuardedLoserTree _Loser Tree variant to use for the guarded
  *   merging.
  *
- * @param seqs_begin Begin iterator of iterator pair input sequence.
- * @param seqs_end End iterator of iterator pair input sequence.
- * @param target Begin iterator out output sequence.
- * @param comp Comparator.
- * @param length Maximum length to merge, less equal than the
+ * @param __seqs_begin Begin iterator of iterator pair input sequence.
+ * @param __seqs_end End iterator of iterator pair input sequence.
+ * @param __target Begin iterator of __output sequence.
+ * @param __comp Comparator.
+ * @param __length Maximum length to merge, less equal than the
  * total number of elements available.
  *
  * @return End iterator of output sequence.
  */
 template<
     typename UnguardedLoserTree,
-    typename RandomAccessIteratorIterator,
-    typename RandomAccessIterator3,
+    typename _RAIterIterator,
+    typename _RAIter3,
     typename _DifferenceTp,
-    typename Comparator>
-  RandomAccessIterator3
+    typename _Compare>
+  _RAIter3
   multiway_merge_loser_tree_sentinel(
-    RandomAccessIteratorIterator seqs_begin,
-    RandomAccessIteratorIterator seqs_end,
-    RandomAccessIterator3 target,
+    _RAIterIterator __seqs_begin,
+    _RAIterIterator __seqs_end,
+    _RAIter3 __target,
     const typename std::iterator_traits<typename std::iterator_traits<
-      RandomAccessIteratorIterator>::value_type::first_type>::value_type&
-        sentinel,
-    _DifferenceTp length,
-    Comparator comp)
+      _RAIterIterator>::value_type::first_type>::value_type&
+        __sentinel,
+    _DifferenceTp __length,
+    _Compare __comp)
   {
-    _GLIBCXX_CALL(length)
+    _GLIBCXX_CALL(__length)
 
-    typedef _DifferenceTp difference_type;
-    typedef std::iterator_traits<RandomAccessIteratorIterator> traits_type;
-    typedef typename std::iterator_traits<RandomAccessIteratorIterator>
+    typedef _DifferenceTp _DifferenceType;
+    typedef std::iterator_traits<_RAIterIterator> _TraitsType;
+    typedef typename std::iterator_traits<_RAIterIterator>
       ::value_type::first_type
-      RandomAccessIterator1;
-    typedef typename std::iterator_traits<RandomAccessIterator1>::value_type
-      value_type;
+      _RAIter1;
+    typedef typename std::iterator_traits<_RAIter1>::value_type
+      _ValueType;
 
-    RandomAccessIterator3 target_end;
+    _RAIter3 __target_end;
 
-    for (RandomAccessIteratorIterator s = seqs_begin; s != seqs_end; ++s)
-      // Move the sequends end behind the sentinel spots.  This has the
+    for (_RAIterIterator __s = __seqs_begin; __s != __seqs_end; ++__s)
+      // Move the sequends _M_end behind the sentinel spots.  This has the
       // effect that the sentinel appears to be within the sequence. Then,
       // we can use the unguarded variant if we merge out as many
       // non-sentinel elements as we have.
-      ++((*s).second);
+      ++((*__s).second);
 
-    target_end = multiway_merge_loser_tree_unguarded
+    __target_end = multiway_merge_loser_tree_unguarded
         <UnguardedLoserTree>
-      (seqs_begin, seqs_end, target, sentinel, length, comp);
+      (__seqs_begin, __seqs_end, __target, __sentinel, __length, __comp);
 
 #if _GLIBCXX_ASSERTIONS
-    _GLIBCXX_PARALLEL_ASSERT(target_end == target + length);
-    _GLIBCXX_PARALLEL_ASSERT(is_sorted(target, target_end, comp));
+    _GLIBCXX_PARALLEL_ASSERT(__target_end == __target + __length);
+    _GLIBCXX_PARALLEL_ASSERT(__is_sorted(__target, __target_end, __comp));
 #endif
 
     // Restore the sequence ends so the sentinels are not contained in the
     // sequence any more (see comment in loop above).
-    for (RandomAccessIteratorIterator s = seqs_begin; s != seqs_end; ++s)
-      --((*s).second);
+    for (_RAIterIterator __s = __seqs_begin; __s != __seqs_end; ++__s)
+      --((*__s).second);
 
-    return target_end;
+    return __target_end;
   }
 
 /**
  * @brief Traits for determining whether the loser tree should
  *   use pointers or copies.
  *
- * The field "use_pointer" is used to determine whether to use pointers in
+ * 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 default behavior is to use pointers if the data type is 4 times as
+ * The default behavior is to use pointers if the data _Self is 4 times as
  * big as the pointer to it.
  *
- * Specialize for your data type to customize the behavior.
+ * Specialize for your data _Self to customize the behavior.
  *
  * Example:
  *
  *   template<>
- *   struct loser_tree_traits<int>
- *   { static const bool use_pointer = false; };
+ *   struct _LoserTreeTraits<int>
+ *   { static const bool _M_use_pointer = false; };
  *
  *   template<>
- *   struct loser_tree_traits<heavyweight_type>
- *   { static const bool use_pointer = true; };
+ *   struct _LoserTreeTraits<heavyweight_type>
+ *   { static const bool _M_use_pointer = true; };
  *
- * @param T type to give the loser tree traits for.
+ * @param _Tp _Self to give the loser tree traits for.
  */
-template <typename T>
-struct loser_tree_traits
+template <typename _Tp>
+struct _LoserTreeTraits
 {
   /**
    * @brief True iff to use pointers instead of values in loser trees.
    *
-   * The default behavior is to use pointers if the data type is four
+   * The default behavior is to use pointers if the data _Self is four
    * times as big as the pointer to it.
    */
-  static const bool use_pointer = (sizeof(T) > 4 * sizeof(T*));
+  static const bool _M_use_pointer = (sizeof(_Tp) > 4 * sizeof(_Tp*));
 };
 
 /**
- * @brief Switch for 3-way merging with sentinels turned off.
+ * @brief Switch for 3-way merging with __sentinels turned __off.
  *
- * Note that 3-way merging is always stable!
+ * Note that 3-way merging is always __stable!
  */
 template<
-  bool sentinels /*default == false*/,
-  typename RandomAccessIteratorIterator,
-  typename RandomAccessIterator3,
+  bool __sentinels /*default == false*/,
+  typename _RAIterIterator,
+  typename _RAIter3,
   typename _DifferenceTp,
-  typename Comparator>
-struct multiway_merge_3_variant_sentinel_switch
+  typename _Compare>
+struct __multiway_merge_3_variant_sentinel_switch
 {
-  RandomAccessIterator3 operator()(
-      RandomAccessIteratorIterator seqs_begin,
-      RandomAccessIteratorIterator seqs_end,
-      RandomAccessIterator3 target,
-      _DifferenceTp length, Comparator comp)
+  _RAIter3 operator()(
+      _RAIterIterator __seqs_begin,
+      _RAIterIterator __seqs_end,
+      _RAIter3 __target,
+      _DifferenceTp __length, _Compare __comp)
   {
-    return multiway_merge_3_variant<guarded_iterator>(
-        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.
+ * @brief Switch for 3-way merging with __sentinels turned on.
  *
- * Note that 3-way merging is always stable!
+ * Note that 3-way merging is always __stable!
  */
 template<
-  typename RandomAccessIteratorIterator,
-  typename RandomAccessIterator3,
+  typename _RAIterIterator,
+  typename _RAIter3,
   typename _DifferenceTp,
-  typename Comparator>
-struct multiway_merge_3_variant_sentinel_switch
-    <true, RandomAccessIteratorIterator, RandomAccessIterator3,
-     _DifferenceTp, Comparator>
+  typename _Compare>
+struct __multiway_merge_3_variant_sentinel_switch
+    <true, _RAIterIterator, _RAIter3,
+     _DifferenceTp, _Compare>
 {
-  RandomAccessIterator3 operator()(
-      RandomAccessIteratorIterator seqs_begin,
-      RandomAccessIteratorIterator seqs_end,
-      RandomAccessIterator3 target,
-      _DifferenceTp length, Comparator comp)
+  _RAIter3 operator()(
+      _RAIterIterator __seqs_begin,
+      _RAIterIterator __seqs_end,
+      _RAIter3 __target,
+      _DifferenceTp __length, _Compare __comp)
   {
     return multiway_merge_3_variant<unguarded_iterator>(
-        seqs_begin, seqs_end, target, length, comp);
+        __seqs_begin, __seqs_end, __target, __length, __comp);
   }
 };
 
 /**
- * @brief Switch for 4-way merging with sentinels turned off.
+ * @brief Switch for 4-way merging with __sentinels turned __off.
  *
- * Note that 4-way merging is always stable!
+ * Note that 4-way merging is always __stable!
  */
 template<
-  bool sentinels /*default == false*/,
-  typename RandomAccessIteratorIterator,
-  typename RandomAccessIterator3,
+  bool __sentinels /*default == false*/,
+  typename _RAIterIterator,
+  typename _RAIter3,
   typename _DifferenceTp,
-  typename Comparator>
-struct multiway_merge_4_variant_sentinel_switch
+  typename _Compare>
+struct __multiway_merge_4_variant_sentinel_switch
 {
-  RandomAccessIterator3 operator()(
-      RandomAccessIteratorIterator seqs_begin,
-      RandomAccessIteratorIterator seqs_end,
-      RandomAccessIterator3 target,
-      _DifferenceTp length, Comparator comp)
+  _RAIter3 operator()(
+      _RAIterIterator __seqs_begin,
+      _RAIterIterator __seqs_end,
+      _RAIter3 __target,
+      _DifferenceTp __length, _Compare __comp)
   {
-    return multiway_merge_4_variant<guarded_iterator>(
-        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.
+ * @brief Switch for 4-way merging with __sentinels turned on.
  *
- * Note that 4-way merging is always stable!
+ * Note that 4-way merging is always __stable!
  */
 template<
-  typename RandomAccessIteratorIterator,
-  typename RandomAccessIterator3,
+  typename _RAIterIterator,
+  typename _RAIter3,
   typename _DifferenceTp,
-  typename Comparator>
-struct multiway_merge_4_variant_sentinel_switch
-    <true, RandomAccessIteratorIterator, RandomAccessIterator3,
-     _DifferenceTp, Comparator>
+  typename _Compare>
+struct __multiway_merge_4_variant_sentinel_switch
+    <true, _RAIterIterator, _RAIter3,
+     _DifferenceTp, _Compare>
 {
-  RandomAccessIterator3 operator()(
-      RandomAccessIteratorIterator seqs_begin,
-      RandomAccessIteratorIterator seqs_end,
-      RandomAccessIterator3 target,
-      _DifferenceTp length, Comparator comp)
+  _RAIter3 operator()(
+      _RAIterIterator __seqs_begin,
+      _RAIterIterator __seqs_end,
+      _RAIter3 __target,
+      _DifferenceTp __length, _Compare __comp)
   {
     return multiway_merge_4_variant<unguarded_iterator>(
-        seqs_begin, seqs_end, target, length, comp);
+        __seqs_begin, __seqs_end, __target, __length, __comp);
   }
 };
 
 /**
- * @brief Switch for k-way merging with sentinels turned on.
+ * @brief Switch for k-way merging with __sentinels turned on.
  */
 template<
-  bool sentinels,
-  bool stable,
-  typename RandomAccessIteratorIterator,
-  typename RandomAccessIterator3,
+  bool __sentinels,
+  bool __stable,
+  typename _RAIterIterator,
+  typename _RAIter3,
   typename _DifferenceTp,
-  typename Comparator>
-struct multiway_merge_k_variant_sentinel_switch
+  typename _Compare>
+struct __multiway_merge_k_variant_sentinel_switch
 {
-  RandomAccessIterator3 operator()(
-      RandomAccessIteratorIterator seqs_begin,
-      RandomAccessIteratorIterator seqs_end,
-      RandomAccessIterator3 target,
+  _RAIter3 operator()(
+      _RAIterIterator __seqs_begin,
+      _RAIterIterator __seqs_end,
+      _RAIter3 __target,
       const typename std::iterator_traits<typename std::iterator_traits<
-        RandomAccessIteratorIterator>::value_type::first_type>::value_type&
-          sentinel,
-      _DifferenceTp length, Comparator comp)
+        _RAIterIterator>::value_type::first_type>::value_type&
+          __sentinel,
+      _DifferenceTp __length, _Compare __comp)
   {
-    typedef typename std::iterator_traits<RandomAccessIteratorIterator>
+    typedef typename std::iterator_traits<_RAIterIterator>
       ::value_type::first_type
-      RandomAccessIterator1;
-    typedef typename std::iterator_traits<RandomAccessIterator1>::value_type
-      value_type;
+      _RAIter1;
+    typedef typename std::iterator_traits<_RAIter1>::value_type
+      _ValueType;
 
     return multiway_merge_loser_tree_sentinel<
         typename __gnu_cxx::__conditional_type<
-            loser_tree_traits<value_type>::use_pointer
-          , LoserTreePointerUnguarded<stable, value_type, Comparator>
-          , LoserTreeUnguarded<stable, value_type, Comparator>
-        >::__type>(seqs_begin, seqs_end, target, sentinel, length, comp);
+            _LoserTreeTraits<_ValueType>::_M_use_pointer
+          , LoserTreePointerUnguarded<__stable, _ValueType, _Compare>
+          , _LoserTreeUnguarded<__stable, _ValueType, _Compare>
+        >::__type>(__seqs_begin, __seqs_end, __target, __sentinel, __length, __comp);
   }
 };
 
 /**
- * @brief Switch for k-way merging with sentinels turned off.
+ * @brief Switch for k-way merging with __sentinels turned __off.
  */
 template<
-  bool stable,
-  typename RandomAccessIteratorIterator,
-  typename RandomAccessIterator3,
+  bool __stable,
+  typename _RAIterIterator,
+  typename _RAIter3,
   typename _DifferenceTp,
-  typename Comparator>
-struct multiway_merge_k_variant_sentinel_switch
-    <false, stable, RandomAccessIteratorIterator, RandomAccessIterator3,
-     _DifferenceTp, Comparator>
+  typename _Compare>
+struct __multiway_merge_k_variant_sentinel_switch
+    <false, __stable, _RAIterIterator, _RAIter3,
+     _DifferenceTp, _Compare>
 {
-  RandomAccessIterator3 operator()(
-      RandomAccessIteratorIterator seqs_begin,
-      RandomAccessIteratorIterator seqs_end,
-      RandomAccessIterator3 target,
+  _RAIter3 operator()(
+      _RAIterIterator __seqs_begin,
+      _RAIterIterator __seqs_end,
+      _RAIter3 __target,
       const typename std::iterator_traits<typename std::iterator_traits<
-        RandomAccessIteratorIterator>::value_type::first_type>::value_type&
-          sentinel,
-      _DifferenceTp length, Comparator comp)
+        _RAIterIterator>::value_type::first_type>::value_type&
+          __sentinel,
+      _DifferenceTp __length, _Compare __comp)
   {
-    typedef typename std::iterator_traits<RandomAccessIteratorIterator>
+    typedef typename std::iterator_traits<_RAIterIterator>
       ::value_type::first_type
-      RandomAccessIterator1;
-    typedef typename std::iterator_traits<RandomAccessIterator1>::value_type
-      value_type;
+      _RAIter1;
+    typedef typename std::iterator_traits<_RAIter1>::value_type
+      _ValueType;
 
     return multiway_merge_loser_tree<
         typename __gnu_cxx::__conditional_type<
-            loser_tree_traits<value_type>::use_pointer
-          , LoserTreePointer<stable, value_type, Comparator>
-          , LoserTree<stable, value_type, Comparator>
-        >::__type >(seqs_begin, seqs_end, target, length, comp);
+            _LoserTreeTraits<_ValueType>::_M_use_pointer
+          , _LoserTreePointer<__stable, _ValueType, _Compare>
+          , LoserTree<__stable, _ValueType, _Compare>
+        >::__type >(__seqs_begin, __seqs_end, __target, __length, __comp);
   }
 };
 
@@ -959,108 +959,108 @@ struct multiway_merge_k_variant_sentinel_switch
  *
  *  The _GLIBCXX_PARALLEL_DECISION is based on the branching factor and
  *  runtime settings.
- *  @param seqs_begin Begin iterator of iterator pair input sequence.
- *  @param seqs_end End iterator of iterator pair input sequence.
- *  @param target Begin iterator out output sequence.
- *  @param comp Comparator.
- *  @param length Maximum length to merge, possibly larger than the
+ *  @param __seqs_begin Begin iterator of iterator pair input sequence.
+ *  @param __seqs_end End iterator of iterator pair input sequence.
+ *  @param __target Begin iterator of __output sequence.
+ *  @param __comp Comparator.
+ *  @param __length Maximum length to merge, possibly larger than the
  *  number of elements available.
- *  @param stable Stable merging incurs a performance penalty.
- *  @param sentinel The sequences have a sentinel element.
+ *  @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,
-    bool sentinels,
-    typename RandomAccessIteratorIterator,
-    typename RandomAccessIterator3,
+    bool __stable,
+    bool __sentinels,
+    typename _RAIterIterator,
+    typename _RAIter3,
     typename _DifferenceTp,
-    typename Comparator>
-  RandomAccessIterator3
-  sequential_multiway_merge(
-    RandomAccessIteratorIterator seqs_begin,
-    RandomAccessIteratorIterator seqs_end,
-    RandomAccessIterator3 target,
+    typename _Compare>
+  _RAIter3
+  __sequential_multiway_merge(
+    _RAIterIterator __seqs_begin,
+    _RAIterIterator __seqs_end,
+    _RAIter3 __target,
     const typename std::iterator_traits<typename std::iterator_traits<
-      RandomAccessIteratorIterator>::value_type::first_type>::value_type&
-        sentinel,
-    _DifferenceTp length, Comparator comp)
+      _RAIterIterator>::value_type::first_type>::value_type&
+        __sentinel,
+    _DifferenceTp __length, _Compare __comp)
   {
-    _GLIBCXX_CALL(length)
+    _GLIBCXX_CALL(__length)
 
-    typedef _DifferenceTp difference_type;
-    typedef typename std::iterator_traits<RandomAccessIteratorIterator>
+    typedef _DifferenceTp _DifferenceType;
+    typedef typename std::iterator_traits<_RAIterIterator>
       ::value_type::first_type
-      RandomAccessIterator1;
-    typedef typename std::iterator_traits<RandomAccessIterator1>::value_type
-      value_type;
+      _RAIter1;
+    typedef typename std::iterator_traits<_RAIter1>::value_type
+      _ValueType;
 
 #if _GLIBCXX_ASSERTIONS
-    for (RandomAccessIteratorIterator s = seqs_begin; s != seqs_end; ++s)
+    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
 
-    _DifferenceTp total_length = 0;
-    for (RandomAccessIteratorIterator s = seqs_begin; s != seqs_end; ++s)
-      total_length += _GLIBCXX_PARALLEL_LENGTH(*s);
+    _DifferenceTp __total_length = 0;
+    for (_RAIterIterator __s = __seqs_begin; __s != __seqs_end; ++__s)
+      __total_length += _GLIBCXX_PARALLEL_LENGTH(*__s);
 
-    length = std::min<_DifferenceTp>(length, total_length);
+    __length = std::min<_DifferenceTp>(__length, __total_length);
 
-    if(length == 0)
-      return target;
+    if(__length == 0)
+      return __target;
 
-    RandomAccessIterator3 return_target = target;
-    int k = static_cast<int>(seqs_end - seqs_begin);
+    _RAIter3 __return_target = __target;
+    int __k = static_cast<int>(__seqs_end - __seqs_begin);
 
-    switch (k)
+    switch (__k)
       {
       case 0:
         break;
       case 1:
-        return_target = std::copy(seqs_begin[0].first,
-                                  seqs_begin[0].first + length,
-                                  target);
-        seqs_begin[0].first += length;
+        __return_target = std::copy(__seqs_begin[0].first,
+                                  __seqs_begin[0].first + __length,
+                                  __target);
+        __seqs_begin[0].first += __length;
         break;
       case 2:
-        return_target = merge_advance(seqs_begin[0].first,
-                                      seqs_begin[0].second,
-                                      seqs_begin[1].first,
-                                      seqs_begin[1].second,
-                                      target, length, comp);
+        __return_target = __merge_advance(__seqs_begin[0].first,
+                                      __seqs_begin[0].second,
+                                      __seqs_begin[1].first,
+                                      __seqs_begin[1].second,
+                                      __target, __length, __comp);
         break;
       case 3:
-        return_target = multiway_merge_3_variant_sentinel_switch<
-            sentinels
-          , RandomAccessIteratorIterator
-          , RandomAccessIterator3
+        __return_target = __multiway_merge_3_variant_sentinel_switch<
+            __sentinels
+          , _RAIterIterator
+          , _RAIter3
           , _DifferenceTp
-          , Comparator>()(seqs_begin, seqs_end, target, length, comp);
+          , _Compare>()(__seqs_begin, __seqs_end, __target, __length, __comp);
         break;
       case 4:
-        return_target = multiway_merge_4_variant_sentinel_switch<
-            sentinels
-          , RandomAccessIteratorIterator
-          , RandomAccessIterator3
+        __return_target = __multiway_merge_4_variant_sentinel_switch<
+            __sentinels
+          , _RAIterIterator
+          , _RAIter3
           , _DifferenceTp
-          , Comparator>()(seqs_begin, seqs_end, target, length, comp);
+          , _Compare>()(__seqs_begin, __seqs_end, __target, __length, __comp);
         break;
       default:
-          return_target = multiway_merge_k_variant_sentinel_switch<
-              sentinels
-            , stable
-            , RandomAccessIteratorIterator
-            , RandomAccessIterator3
+          __return_target = __multiway_merge_k_variant_sentinel_switch<
+              __sentinels
+            , __stable
+            , _RAIterIterator
+            , _RAIter3
             , _DifferenceTp
-            , Comparator>()(seqs_begin, seqs_end, target, sentinel, length, comp);
+            , _Compare>()(__seqs_begin, __seqs_end, __target, __sentinel, __length, __comp);
           break;
       }
 #if _GLIBCXX_ASSERTIONS
-    _GLIBCXX_PARALLEL_ASSERT(is_sorted(target, target + length, comp));
+    _GLIBCXX_PARALLEL_ASSERT(__is_sorted(__target, __target + __length, __comp));
 #endif
 
-    return return_target;
+    return __return_target;
   }
 
 /**
@@ -1068,104 +1068,104 @@ template<
  *
  * Used to reduce code instanciation in multiway_merge_sampling_splitting.
  */
-template<bool stable, class RandomAccessIterator, class StrictWeakOrdering>
-struct sampling_sorter
+template<bool __stable, class _RAIter, class _StrictWeakOrdering>
+struct _SamplingSorter
 {
-  void operator()(RandomAccessIterator first, RandomAccessIterator last,
-                  StrictWeakOrdering comp)
-  { __gnu_sequential::stable_sort(first, last, comp); }
+  void operator()(_RAIter __first, _RAIter __last,
+                  _StrictWeakOrdering __comp)
+  { __gnu_sequential::stable_sort(__first, __last, __comp); }
 };
 
 /**
- * @brief Non-stable sorting functor.
+ * @brief Non-__stable sorting functor.
  *
  * Used to reduce code instantiation in multiway_merge_sampling_splitting.
  */
-template<class RandomAccessIterator, class StrictWeakOrdering>
-struct sampling_sorter<false, RandomAccessIterator, StrictWeakOrdering>
+template<class _RAIter, class _StrictWeakOrdering>
+struct _SamplingSorter<false, _RAIter, _StrictWeakOrdering>
 {
-  void operator()(RandomAccessIterator first, RandomAccessIterator last,
-                  StrictWeakOrdering comp)
-  { __gnu_sequential::sort(first, last, comp); }
+  void operator()(_RAIter __first, _RAIter __last,
+                  _StrictWeakOrdering __comp)
+  { __gnu_sequential::sort(__first, __last, __comp); }
 };
 
 /**
  * @brief Sampling based splitting for parallel multiway-merge routine.
  */
 template<
-    bool stable
-  , typename RandomAccessIteratorIterator
-  , typename Comparator
-  , typename difference_type>
+    bool __stable
+  , typename _RAIterIterator
+  , typename _Compare
+  , typename _DifferenceType>
 void multiway_merge_sampling_splitting(
-    RandomAccessIteratorIterator seqs_begin,
-    RandomAccessIteratorIterator seqs_end,
-    difference_type length, difference_type total_length, Comparator comp,
-    std::vector<std::pair<difference_type, difference_type> > *pieces)
+    _RAIterIterator __seqs_begin,
+    _RAIterIterator __seqs_end,
+    _DifferenceType __length, _DifferenceType __total_length, _Compare __comp,
+    std::vector<std::pair<_DifferenceType, _DifferenceType> > *__pieces)
 {
-  typedef typename std::iterator_traits<RandomAccessIteratorIterator>
+  typedef typename std::iterator_traits<_RAIterIterator>
     ::value_type::first_type
-    RandomAccessIterator1;
-  typedef typename std::iterator_traits<RandomAccessIterator1>::value_type
-    value_type;
+    _RAIter1;
+  typedef typename std::iterator_traits<_RAIter1>::value_type
+    _ValueType;
 
-  // k sequences.
-  int k = static_cast<int>(seqs_end - seqs_begin);
+  // __k sequences.
+  int __k = static_cast<int>(__seqs_end - __seqs_begin);
 
-  int num_threads = omp_get_num_threads();
+  int __num_threads = omp_get_num_threads();
 
-  difference_type num_samples =
-      __gnu_parallel::_Settings::get().merge_oversampling * num_threads;
+  _DifferenceType __num_samples =
+      __gnu_parallel::_Settings::get().merge_oversampling * __num_threads;
 
-  value_type* samples = static_cast<value_type*>(
-    ::operator new(sizeof(value_type) * k * num_samples));
+  _ValueType* __samples = static_cast<_ValueType*>(
+    ::operator new(sizeof(_ValueType) * __k * __num_samples));
   // Sample.
-  for (int s = 0; s < k; ++s)
-    for (difference_type i = 0; i < num_samples; ++i)
+  for (int __s = 0; __s < __k; ++__s)
+    for (_DifferenceType __i = 0; __i < __num_samples; ++__i)
       {
-        difference_type sample_index =
-            static_cast<difference_type>(
-                _GLIBCXX_PARALLEL_LENGTH(seqs_begin[s])
-                    * (double(i + 1) / (num_samples + 1))
-                    * (double(length) / total_length));
-        new(&(samples[s * num_samples + i]))
-            value_type(seqs_begin[s].first[sample_index]);
+        _DifferenceType sample_index =
+            static_cast<_DifferenceType>(
+                _GLIBCXX_PARALLEL_LENGTH(__seqs_begin[__s])
+                    * (double(__i + 1) / (__num_samples + 1))
+                    * (double(__length) / __total_length));
+        new(&(__samples[__s * __num_samples + __i]))
+            _ValueType(__seqs_begin[__s].first[sample_index]);
       }
 
   // Sort stable or non-stable, depending on value of template parameter
-  // "stable".
-  sampling_sorter<stable, value_type*, Comparator>()(
-      samples, samples + (num_samples * k), comp);
+  // "__stable".
+  _SamplingSorter<__stable, _ValueType*, _Compare>()(
+      __samples, __samples + (__num_samples * __k), __comp);
 
-  for (int slab = 0; slab < num_threads; ++slab)
+  for (int __slab = 0; __slab < __num_threads; ++__slab)
     // For each slab / processor.
-    for (int seq = 0; seq < k; ++seq)
+    for (int __seq = 0; __seq < __k; ++__seq)
       {
         // For each sequence.
-        if (slab > 0)
-          pieces[slab][seq].first =
+        if (__slab > 0)
+          __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;
+                __seqs_begin[__seq].first,
+                __seqs_begin[__seq].second,
+                __samples[__num_samples * __k * __slab / __num_threads],
+                  __comp)
+              - __seqs_begin[__seq].first;
         else
           // Absolute beginning.
-          pieces[slab][seq].first = 0;
-        if ((slab + 1) < num_threads)
-          pieces[slab][seq].second =
+          __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)
-              - seqs_begin[seq].first;
+                  __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);
+    ::operator delete(__samples);
 }
 
 /**
@@ -1174,84 +1174,84 @@ void multiway_merge_sampling_splitting(
  * None of the passed sequences may be empty.
  */
 template<
-    bool stable
-  , typename RandomAccessIteratorIterator
-  , typename Comparator
-  , typename difference_type>
+    bool __stable
+  , typename _RAIterIterator
+  , typename _Compare
+  , typename _DifferenceType>
 void multiway_merge_exact_splitting(
-    RandomAccessIteratorIterator seqs_begin,
-    RandomAccessIteratorIterator seqs_end,
-    difference_type length, difference_type total_length, Comparator comp,
-    std::vector<std::pair<difference_type, difference_type> > *pieces)
+    _RAIterIterator __seqs_begin,
+    _RAIterIterator __seqs_end,
+    _DifferenceType __length, _DifferenceType __total_length, _Compare __comp,
+    std::vector<std::pair<_DifferenceType, _DifferenceType> > *__pieces)
 {
-  typedef typename std::iterator_traits<RandomAccessIteratorIterator>
+  typedef typename std::iterator_traits<_RAIterIterator>
     ::value_type::first_type
-    RandomAccessIterator1;
+    _RAIter1;
 
-  const bool tight = (total_length == length);
+  const bool __tight = (__total_length == __length);
 
-  // k sequences.
-  const int k = static_cast<int>(seqs_end - seqs_begin);
+  // __k sequences.
+  const int __k = static_cast<int>(__seqs_end - __seqs_begin);
 
-  const int num_threads = omp_get_num_threads();
+  const int __num_threads = omp_get_num_threads();
 
   // (Settings::multiway_merge_splitting == __gnu_parallel::_Settings::EXACT).
-  std::vector<RandomAccessIterator1>* offsets =
-      new std::vector<RandomAccessIterator1>[num_threads];
+  std::vector<_RAIter1>* __offsets =
+      new std::vector<_RAIter1>[__num_threads];
   std::vector<
-      std::pair<RandomAccessIterator1, RandomAccessIterator1>
-      > se(k);
+      std::pair<_RAIter1, _RAIter1>
+      > __se(__k);
 
-  copy(seqs_begin, seqs_end, se.begin());
+  copy(__seqs_begin, __seqs_end, __se.begin());
 
-  difference_type* borders =
-      new difference_type[num_threads + 1];
-  equally_split(length, num_threads, borders);
+  _DifferenceType* __borders =
+      new _DifferenceType[__num_threads + 1];
+  equally_split(__length, __num_threads, __borders);
 
-  for (int s = 0; s < (num_threads - 1); ++s)
+  for (int __s = 0; __s < (__num_threads - 1); ++__s)
     {
-      offsets[s].resize(k);
+      __offsets[__s].resize(__k);
       multiseq_partition(
-          se.begin(), se.end(), borders[s + 1],
-          offsets[s].begin(), comp);
+          __se.begin(), __se.end(), __borders[__s + 1],
+          __offsets[__s].begin(), __comp);
 
       // Last one also needed and available.
-      if (!tight)
+      if (!__tight)
         {
-          offsets[num_threads - 1].resize(k);
-          multiseq_partition(se.begin(), se.end(),
-                difference_type(length),
-                offsets[num_threads - 1].begin(),  comp);
+          __offsets[__num_threads - 1].resize(__k);
+          multiseq_partition(__se.begin(), __se.end(),
+                _DifferenceType(__length),
+                __offsets[__num_threads - 1].begin(),  __comp);
         }
     }
-  delete[] borders;
+  delete[] __borders;
 
-  for (int slab = 0; slab < num_threads; ++slab)
+  for (int __slab = 0; __slab < __num_threads; ++__slab)
     {
       // For each slab / processor.
-      for (int seq = 0; seq < k; ++seq)
+      for (int __seq = 0; __seq < __k; ++__seq)
         {
           // For each sequence.
-          if (slab == 0)
+          if (__slab == 0)
             {
               // Absolute beginning.
-              pieces[slab][seq].first = 0;
+              __pieces[__slab][__seq].first = 0;
             }
           else
-            pieces[slab][seq].first =
-                pieces[slab - 1][seq].second;
-          if (!tight || slab < (num_threads - 1))
-            pieces[slab][seq].second =
-                offsets[slab][seq] - seqs_begin[seq].first;
+            __pieces[__slab][__seq].first =
+                __pieces[__slab - 1][__seq].second;
+          if (!__tight || __slab < (__num_threads - 1))
+            __pieces[__slab][__seq].second =
+                __offsets[__slab][__seq] - __seqs_begin[__seq].first;
           else
             {
-              // slab == num_threads - 1
-              pieces[slab][seq].second =
-                  _GLIBCXX_PARALLEL_LENGTH(seqs_begin[seq]);
+              // __slab == __num_threads - 1
+              __pieces[__slab][__seq].second =
+                  _GLIBCXX_PARALLEL_LENGTH(__seqs_begin[__seq]);
             }
         }
     }
-  delete[] offsets;
+  delete[] __offsets;
 }
 
 /** @brief Parallel multi-way merge routine.
@@ -1261,150 +1261,150 @@ void multiway_merge_exact_splitting(
  *
  * Must not be called if the number of sequences is 1.
  *
- * @param Splitter functor to split input (either exact or sampling based)
+ * @param Splitter functor to split input (either __exact or sampling based)
  *
- * @param seqs_begin Begin iterator of iterator pair input sequence.
- * @param seqs_end End iterator of iterator pair input sequence.
- * @param target Begin iterator out output sequence.
- * @param comp Comparator.
- * @param length Maximum length to merge, possibly larger than the
+ * @param __seqs_begin Begin iterator of iterator pair input sequence.
+ * @param __seqs_end End iterator of iterator pair input sequence.
+ * @param __target Begin iterator of __output sequence.
+ * @param __comp Comparator.
+ * @param __length Maximum length to merge, possibly larger than the
  * number of elements available.
- * @param stable Stable merging incurs a performance penalty.
- * @param sentinel Ignored.
+ * @param __stable Stable merging incurs __a performance penalty.
+ * @param __sentinel Ignored.
  * @return End iterator of output sequence.
  */
 template<
-    bool stable,
-    bool sentinels,
-    typename RandomAccessIteratorIterator,
-    typename RandomAccessIterator3,
+    bool __stable,
+    bool __sentinels,
+    typename _RAIterIterator,
+    typename _RAIter3,
     typename _DifferenceTp,
     typename Splitter,
-    typename Comparator
+    typename _Compare
     >
-  RandomAccessIterator3
-  parallel_multiway_merge(RandomAccessIteratorIterator seqs_begin,
-                          RandomAccessIteratorIterator seqs_end,
-                          RandomAccessIterator3 target,
+  _RAIter3
+  parallel_multiway_merge(_RAIterIterator __seqs_begin,
+                          _RAIterIterator __seqs_end,
+                          _RAIter3 __target,
                           Splitter splitter,
-                          _DifferenceTp length,
-                          Comparator comp,
-                          thread_index_t num_threads)
+                          _DifferenceTp __length,
+                          _Compare __comp,
+                          _ThreadIndex __num_threads)
     {
 #if _GLIBCXX_ASSERTIONS
-      _GLIBCXX_PARALLEL_ASSERT(seqs_end - seqs_begin > 1);
+      _GLIBCXX_PARALLEL_ASSERT(__seqs_end - __seqs_begin > 1);
 #endif
 
-      _GLIBCXX_CALL(length)
+      _GLIBCXX_CALL(__length)
 
-      typedef _DifferenceTp difference_type;
-      typedef typename std::iterator_traits<RandomAccessIteratorIterator>
+      typedef _DifferenceTp _DifferenceType;
+      typedef typename std::iterator_traits<_RAIterIterator>
         ::value_type::first_type
-        RandomAccessIterator1;
+        _RAIter1;
       typedef typename
-        std::iterator_traits<RandomAccessIterator1>::value_type value_type;
+        std::iterator_traits<_RAIter1>::value_type _ValueType;
 
       // Leave only non-empty sequences.
-      typedef std::pair<RandomAccessIterator1, RandomAccessIterator1> seq_type;
-      seq_type* ne_seqs = new seq_type[seqs_end - seqs_begin];
-      int k = 0;
-      difference_type total_length = 0;
-      for (RandomAccessIteratorIterator raii = seqs_begin;
-           raii != seqs_end; ++raii)
+      typedef std::pair<_RAIter1, _RAIter1> seq_type;
+      seq_type* __ne_seqs = new seq_type[__seqs_end - __seqs_begin];
+      int __k = 0;
+      _DifferenceType __total_length = 0;
+      for (_RAIterIterator __raii = __seqs_begin;
+           __raii != __seqs_end; ++__raii)
         {
-          _DifferenceTp seq_length = _GLIBCXX_PARALLEL_LENGTH(*raii);
-          if(seq_length > 0)
+          _DifferenceTp __seq_length = _GLIBCXX_PARALLEL_LENGTH(*__raii);
+          if(__seq_length > 0)
             {
-              total_length += seq_length;
-              ne_seqs[k++] = *raii;
+              __total_length += __seq_length;
+              __ne_seqs[__k++] = *__raii;
             }
         }
 
-      _GLIBCXX_CALL(total_length)
+      _GLIBCXX_CALL(__total_length)
 
-      length = std::min<_DifferenceTp>(length, total_length);
+      __length = std::min<_DifferenceTp>(__length, __total_length);
 
-      if (total_length == 0 || k == 0)
+      if (__total_length == 0 || __k == 0)
       {
-        delete[] ne_seqs;
-        return target;
+        delete[] __ne_seqs;
+        return __target;
       }
 
-      std::vector<std::pair<difference_type, difference_type> >* pieces;
+      std::vector<std::pair<_DifferenceType, _DifferenceType> >* __pieces;
 
-      num_threads = static_cast<thread_index_t>
-        (std::min<difference_type>(num_threads, total_length));
+      __num_threads = static_cast<_ThreadIndex>
+        (std::min<_DifferenceType>(__num_threads, __total_length));
 
-#     pragma omp parallel num_threads (num_threads)
+#     pragma omp parallel num_threads (__num_threads)
         {
 #         pragma omp single
             {
-              num_threads = omp_get_num_threads();
-              // Thread t will have to merge pieces[iam][0..k - 1]
-              pieces = new std::vector<
-                  std::pair<difference_type, difference_type> >[num_threads];
-              for (int s = 0; s < num_threads; ++s)
-                pieces[s].resize(k);
-
-              difference_type num_samples =
+              __num_threads = omp_get_num_threads();
+              // Thread __t will have to merge pieces[__iam][0..__k - 1]
+              __pieces = new std::vector<
+                  std::pair<_DifferenceType, _DifferenceType> >[__num_threads];
+              for (int __s = 0; __s < __num_threads; ++__s)
+                __pieces[__s].resize(__k);
+
+              _DifferenceType __num_samples =
                   __gnu_parallel::_Settings::get().merge_oversampling *
-                    num_threads;
+                    __num_threads;
 
-              splitter(ne_seqs, ne_seqs + k, length, total_length,
-                       comp, pieces);
+              splitter(__ne_seqs, __ne_seqs + __k, __length, __total_length,
+                       __comp, __pieces);
             } //single
 
-          thread_index_t iam = omp_get_thread_num();
+          _ThreadIndex __iam = omp_get_thread_num();
 
-          difference_type target_position = 0;
+          _DifferenceType __target_position = 0;
 
-          for (int c = 0; c < k; ++c)
-            target_position += pieces[iam][c].first;
+          for (int __c = 0; __c < __k; ++__c)
+            __target_position += __pieces[__iam][__c].first;
 
-          seq_type* chunks = new seq_type[k];
+          seq_type* __chunks = new seq_type[__k];
 
-          for (int s = 0; s < k; ++s)
+          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,
-               *(seqs_begin->second), length - target_position, comp);
+          if(__length > __target_position)
+            __sequential_multiway_merge<__stable, __sentinels>(
+              __chunks, __chunks + __k, __target + __target_position,
+               *(__seqs_begin->second), __length - __target_position, __comp);
 
-          delete[] chunks;
+          delete[] __chunks;
         } // parallel
 
 #if _GLIBCXX_ASSERTIONS
-      _GLIBCXX_PARALLEL_ASSERT(is_sorted(target, target + length, comp));
+      _GLIBCXX_PARALLEL_ASSERT(__is_sorted(__target, __target + __length, __comp));
 #endif
 
-      k = 0;
+      __k = 0;
       // Update ends of sequences.
-      for (RandomAccessIteratorIterator raii = seqs_begin;
-           raii != seqs_end; ++raii)
+      for (_RAIterIterator __raii = __seqs_begin;
+           __raii != __seqs_end; ++__raii)
         {
-          _DifferenceTp length = _GLIBCXX_PARALLEL_LENGTH(*raii);
-          if(length > 0)
-            (*raii).first += pieces[num_threads - 1][k++].second;
+          _DifferenceTp __length = _GLIBCXX_PARALLEL_LENGTH(*__raii);
+          if(__length > 0)
+            (*__raii).first += __pieces[__num_threads - 1][__k++].second;
         }
 
-      delete[] pieces;
-      delete[] ne_seqs;
+      delete[] __pieces;
+      delete[] __ne_seqs;
 
-      return target + length;
+      return __target + __length;
     }
 
 /**
  * @brief Multiway Merge Frontend.
  *
- * Merge the sequences specified by seqs_begin and seqs_end into
- * target.  seqs_begin and seqs_end must point to a sequence of
+ * Merge the sequences specified by seqs_begin and __seqs_end into
+ * __target.  __seqs_begin and __seqs_end must point to a sequence of
  * pairs.  These pairs must contain an iterator to the beginning
- * of a sequence in their first entry and an iterator the end of
+ * of a sequence in their first entry and an iterator the _M_end of
  * the same sequence in their second entry.
  *
  * Ties are broken arbitrarily.  See stable_multiway_merge for a variant
@@ -1427,349 +1427,349 @@ template<
  *
  * <pre>
  *   int sequences[10][10];
- *   for (int i = 0; i < 10; ++i)
- *     for (int j = 0; i < 10; ++j)
- *       sequences[i][j] = j;
+ *   for (int __i = 0; __i < 10; ++__i)
+ *     for (int __j = 0; __i < 10; ++__j)
+ *       sequences[__i][__j] = __j;
  *
- *   int out[33];
+ *   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)) }
+ *   for (int __i = 0; __i < 10; ++__i)
+ *     { seqs.push(std::make_pair<int*>(sequences[__i], sequences[__i] + 10)) }
  *
- *   multiway_merge(seqs.begin(), seqs.end(), target, std::less<int>(), 33);
+ *   multiway_merge(seqs.begin(), seqs.end(), __target, std::less<int>(), 33);
  * </pre>
  *
  * @see stable_multiway_merge
  *
  * @pre All input sequences must be sorted.
- * @pre Target must provide enough space to merge out length elements or
+ * @pre Target must provide enough space to merge out __length __elements or
  *    the number of elements in all sequences, whichever is smaller.
  *
- * @post [target, return value) contains merged elements from the
+ * @post [__target, return __value) contains merged __elements from the
  *    input sequences.
- * @post return value - target = min(length, number of elements in all
+ * @post return __value - __target = min(__length, number of elements in all
  *    sequences).
  *
- * @param RandomAccessIteratorPairIterator iterator over sequence
+ * @param _RAIterPairIterator iterator over __sequence
  *    of pairs of iterators
- * @param RandomAccessIteratorOut iterator over target sequence
- * @param _DifferenceTp difference type for the sequence
- * @param Comparator strict weak ordering type to compare elements
+ * @param _RAIterOut iterator over target sequence
+ * @param _DifferenceTp difference _Self for the sequence
+ * @param _Compare strict weak ordering _Self to compare __elements
  *    in sequences
  *
- * @param seqs_begin  begin of sequence sequence
- * @param seqs_end    end of sequence sequence
- * @param target      target sequence to merge to.
- * @param comp        strict weak ordering to use for element comparison.
- * @param length Maximum length to merge, possibly larger than the
+ * @param __seqs_begin  __begin of sequence __sequence
+ * @param __seqs_end    _M_end of sequence __sequence
+ * @param __target      target sequence to merge to.
+ * @param __comp        strict weak ordering to use for element comparison.
+ * @param __length Maximum length to merge, possibly larger than the
  * number of elements available.
  *
- * @return end iterator of output sequence
+ * @return _M_end iterator of output sequence
  */
 // multiway_merge
 // public interface
 template<
-    typename RandomAccessIteratorPairIterator
-  , typename RandomAccessIteratorOut
+    typename _RAIterPairIterator
+  , typename _RAIterOut
   , typename _DifferenceTp
-  , typename Comparator>
-RandomAccessIteratorOut
-multiway_merge(RandomAccessIteratorPairIterator seqs_begin
-    , RandomAccessIteratorPairIterator seqs_end
-    , RandomAccessIteratorOut target
-    , _DifferenceTp length, Comparator comp
+  , typename _Compare>
+_RAIterOut
+multiway_merge(_RAIterPairIterator __seqs_begin
+    , _RAIterPairIterator __seqs_end
+    , _RAIterOut __target
+    , _DifferenceTp __length, _Compare __comp
     , __gnu_parallel::sequential_tag)
 {
-  typedef _DifferenceTp difference_type;
-  _GLIBCXX_CALL(seqs_end - seqs_begin)
+  typedef _DifferenceTp _DifferenceType;
+  _GLIBCXX_CALL(__seqs_end - __seqs_begin)
 
   // catch special case: no sequences
-  if (seqs_begin == seqs_end)
-    return target;
+  if (__seqs_begin == __seqs_end)
+    return __target;
 
   // Execute multiway merge *sequentially*.
-  return sequential_multiway_merge
-    </* stable = */ false, /* sentinels = */ false>
-      (seqs_begin, seqs_end, target, *(seqs_begin->second), length, comp);
+  return __sequential_multiway_merge
+    </* __stable = */ false, /* __sentinels = */ false>
+      (__seqs_begin, __seqs_end, __target, *(__seqs_begin->second), __length, __comp);
 }
 
 // public interface
 template<
-    typename RandomAccessIteratorPairIterator
-  , typename RandomAccessIteratorOut
+    typename _RAIterPairIterator
+  , typename _RAIterOut
   , typename _DifferenceTp
-  , typename Comparator>
-RandomAccessIteratorOut
-multiway_merge(RandomAccessIteratorPairIterator seqs_begin
-    , RandomAccessIteratorPairIterator seqs_end
-    , RandomAccessIteratorOut target
-    , _DifferenceTp length, Comparator comp
-    , __gnu_parallel::exact_tag tag)
+  , typename _Compare>
+_RAIterOut
+multiway_merge(_RAIterPairIterator __seqs_begin
+    , _RAIterPairIterator __seqs_end
+    , _RAIterOut __target
+    , _DifferenceTp __length, _Compare __comp
+    , __gnu_parallel::exact_tag __tag)
 {
-    typedef _DifferenceTp difference_type;
-    _GLIBCXX_CALL(seqs_end - seqs_begin)
+    typedef _DifferenceTp _DifferenceType;
+    _GLIBCXX_CALL(__seqs_end - __seqs_begin)
 
     // catch special case: no sequences
-    if (seqs_begin == seqs_end)
-      return target;
+    if (__seqs_begin == __seqs_end)
+      return __target;
 
     // 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) &&
+    if ((__seqs_end - __seqs_begin > 1) &&
           _GLIBCXX_PARALLEL_CONDITION(
-          ((seqs_end - seqs_begin) >=
+          ((__seqs_end - __seqs_begin) >=
              __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
-          && ((sequence_index_t)length >=
+          && ((_SequenceIndex)__length >=
             __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
       return parallel_multiway_merge
-                    </* stable = */ false, /* sentinels = */ false>(
-          seqs_begin, seqs_end, target,
-          multiway_merge_exact_splitting</* stable = */ false,
-            typename std::iterator_traits<RandomAccessIteratorPairIterator>
-              ::value_type*, Comparator, _DifferenceTp>,
-          static_cast<difference_type>(length), comp, tag.get_num_threads());
+                    </* __stable = */ false, /* __sentinels = */ false>(
+          __seqs_begin, __seqs_end, __target,
+          multiway_merge_exact_splitting</* __stable = */ false,
+            typename std::iterator_traits<_RAIterPairIterator>
+              ::value_type*, _Compare, _DifferenceTp>,
+          static_cast<_DifferenceType>(__length), __comp, __tag.__get_num_threads());
     else
-      return sequential_multiway_merge
-                      </* stable = */ false, /* sentinels = */ false>(
-          seqs_begin, seqs_end, target, *(seqs_begin->second), length, comp);
+      return __sequential_multiway_merge
+                      </* __stable = */ false, /* __sentinels = */ false>(
+          __seqs_begin, __seqs_end, __target, *(__seqs_begin->second), __length, __comp);
 }
 
 // public interface
 template<
-    typename RandomAccessIteratorPairIterator
-  , typename RandomAccessIteratorOut
+    typename _RAIterPairIterator
+  , typename _RAIterOut
   , typename _DifferenceTp
-  , typename Comparator>
-RandomAccessIteratorOut
-multiway_merge(RandomAccessIteratorPairIterator seqs_begin
-    , RandomAccessIteratorPairIterator seqs_end
-    , RandomAccessIteratorOut target
-    , _DifferenceTp length, Comparator comp
-    , __gnu_parallel::sampling_tag tag)
+  , typename _Compare>
+_RAIterOut
+multiway_merge(_RAIterPairIterator __seqs_begin
+    , _RAIterPairIterator __seqs_end
+    , _RAIterOut __target
+    , _DifferenceTp __length, _Compare __comp
+    , __gnu_parallel::sampling_tag __tag)
 {
-    typedef _DifferenceTp difference_type;
-    _GLIBCXX_CALL(seqs_end - seqs_begin)
+    typedef _DifferenceTp _DifferenceType;
+    _GLIBCXX_CALL(__seqs_end - __seqs_begin)
 
     // catch special case: no sequences
-    if (seqs_begin == seqs_end)
-      return target;
+    if (__seqs_begin == __seqs_end)
+      return __target;
 
     // 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) &&
+    if ((__seqs_end - __seqs_begin > 1) &&
           _GLIBCXX_PARALLEL_CONDITION(
-          ((seqs_end - seqs_begin) >=
+          ((__seqs_end - __seqs_begin) >=
              __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
-          && ((sequence_index_t)length >=
+          && ((_SequenceIndex)__length >=
             __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
       return parallel_multiway_merge
-                    </* stable = */ false, /* sentinels = */ false>(
-          seqs_begin, seqs_end,
-          target,
-          multiway_merge_exact_splitting</* stable = */ false,
-            typename std::iterator_traits<RandomAccessIteratorPairIterator>
-              ::value_type*, Comparator, _DifferenceTp>,
-          static_cast<difference_type>(length), comp, tag.get_num_threads());
+                    </* __stable = */ false, /* __sentinels = */ false>(
+          __seqs_begin, __seqs_end,
+          __target,
+          multiway_merge_exact_splitting</* __stable = */ false,
+            typename std::iterator_traits<_RAIterPairIterator>
+              ::value_type*, _Compare, _DifferenceTp>,
+          static_cast<_DifferenceType>(__length), __comp, __tag.__get_num_threads());
     else
-      return sequential_multiway_merge
-                      </* stable = */ false, /* sentinels = */ false>(
-          seqs_begin, seqs_end,
-          target, *(seqs_begin->second), length, comp);
+      return __sequential_multiway_merge
+                      </* __stable = */ false, /* __sentinels = */ false>(
+          __seqs_begin, __seqs_end,
+          __target, *(__seqs_begin->second), __length, __comp);
 }
 
 // public interface
 template<
-    typename RandomAccessIteratorPairIterator
-  , typename RandomAccessIteratorOut
+    typename _RAIterPairIterator
+  , typename _RAIterOut
   , typename _DifferenceTp
-  , typename Comparator>
-RandomAccessIteratorOut
-multiway_merge(RandomAccessIteratorPairIterator seqs_begin
-    , RandomAccessIteratorPairIterator seqs_end
-    , RandomAccessIteratorOut target
-    , _DifferenceTp length, Comparator comp
-    , parallel_tag tag = parallel_tag(0))
+  , typename _Compare>
+_RAIterOut
+multiway_merge(_RAIterPairIterator __seqs_begin
+    , _RAIterPairIterator __seqs_end
+    , _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 RandomAccessIteratorPairIterator
-  , typename RandomAccessIteratorOut
+    typename _RAIterPairIterator
+  , typename _RAIterOut
   , typename _DifferenceTp
-  , typename Comparator>
-RandomAccessIteratorOut
-multiway_merge(RandomAccessIteratorPairIterator seqs_begin
-    , RandomAccessIteratorPairIterator seqs_end
-    , RandomAccessIteratorOut target
-    , _DifferenceTp length, Comparator comp
-    , default_parallel_tag tag)
+  , typename _Compare>
+_RAIterOut
+multiway_merge(_RAIterPairIterator __seqs_begin
+    , _RAIterPairIterator __seqs_end
+    , _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 RandomAccessIteratorPairIterator
-  , typename RandomAccessIteratorOut
+    typename _RAIterPairIterator
+  , typename _RAIterOut
   , typename _DifferenceTp
-  , typename Comparator>
-RandomAccessIteratorOut
-stable_multiway_merge(RandomAccessIteratorPairIterator seqs_begin
-    , RandomAccessIteratorPairIterator seqs_end
-    , RandomAccessIteratorOut target
-    , _DifferenceTp length, Comparator comp
+  , typename _Compare>
+_RAIterOut
+stable_multiway_merge(_RAIterPairIterator __seqs_begin
+    , _RAIterPairIterator __seqs_end
+    , _RAIterOut __target
+    , _DifferenceTp __length, _Compare __comp
     , __gnu_parallel::sequential_tag)
 {
-    typedef _DifferenceTp difference_type;
-    _GLIBCXX_CALL(seqs_end - seqs_begin)
+    typedef _DifferenceTp _DifferenceType;
+    _GLIBCXX_CALL(__seqs_end - __seqs_begin)
 
     // catch special case: no sequences
-    if (seqs_begin == seqs_end)
-      return target;
+    if (__seqs_begin == __seqs_end)
+      return __target;
 
     // Execute multiway merge *sequentially*.
-    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 RandomAccessIteratorPairIterator
-  , typename RandomAccessIteratorOut
+    typename _RAIterPairIterator
+  , typename _RAIterOut
   , typename _DifferenceTp
-  , typename Comparator>
-RandomAccessIteratorOut
-stable_multiway_merge(RandomAccessIteratorPairIterator seqs_begin
-    , RandomAccessIteratorPairIterator seqs_end
-    , RandomAccessIteratorOut target
-    , _DifferenceTp length, Comparator comp
-    , __gnu_parallel::exact_tag tag)
+  , typename _Compare>
+_RAIterOut
+stable_multiway_merge(_RAIterPairIterator __seqs_begin
+    , _RAIterPairIterator __seqs_end
+    , _RAIterOut __target
+    , _DifferenceTp __length, _Compare __comp
+    , __gnu_parallel::exact_tag __tag)
 {
-    typedef _DifferenceTp difference_type;
-    _GLIBCXX_CALL(seqs_end - seqs_begin)
+    typedef _DifferenceTp _DifferenceType;
+    _GLIBCXX_CALL(__seqs_end - __seqs_begin)
 
     // catch special case: no sequences
-    if (seqs_begin == seqs_end)
-      return target;
+    if (__seqs_begin == __seqs_end)
+      return __target;
 
     // 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) &&
+    if ((__seqs_end - __seqs_begin > 1) &&
           _GLIBCXX_PARALLEL_CONDITION(
-          ((seqs_end - seqs_begin) >=
+          ((__seqs_end - __seqs_begin) >=
             __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
-          && ((sequence_index_t)length >=
+          && ((_SequenceIndex)__length >=
             __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
       return parallel_multiway_merge
-        </* stable = */ true, /* sentinels = */ false>(
-          seqs_begin, seqs_end,
-          target,
-          multiway_merge_exact_splitting</* stable = */ true,
-            typename std::iterator_traits<RandomAccessIteratorPairIterator>
-              ::value_type*, Comparator, _DifferenceTp>,
-          static_cast<difference_type>(length), comp, tag.get_num_threads());
+        </* __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 RandomAccessIteratorPairIterator
-  , typename RandomAccessIteratorOut
+    typename _RAIterPairIterator
+  , typename _RAIterOut
   , typename _DifferenceTp
-  , typename Comparator>
-RandomAccessIteratorOut
-stable_multiway_merge(RandomAccessIteratorPairIterator seqs_begin
-    , RandomAccessIteratorPairIterator seqs_end
-    , RandomAccessIteratorOut target
-    , _DifferenceTp length, Comparator comp
-    , sampling_tag tag)
+  , typename _Compare>
+_RAIterOut
+stable_multiway_merge(_RAIterPairIterator __seqs_begin
+    , _RAIterPairIterator __seqs_end
+    , _RAIterOut __target
+    , _DifferenceTp __length, _Compare __comp
+    , sampling_tag __tag)
 {
-    typedef _DifferenceTp difference_type;
-    _GLIBCXX_CALL(seqs_end - seqs_begin)
+    typedef _DifferenceTp _DifferenceType;
+    _GLIBCXX_CALL(__seqs_end - __seqs_begin)
 
     // catch special case: no sequences
-    if (seqs_begin == seqs_end)
-      return target;
+    if (__seqs_begin == __seqs_end)
+      return __target;
 
     // 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) &&
+    if ((__seqs_end - __seqs_begin > 1) &&
           _GLIBCXX_PARALLEL_CONDITION(
-          ((seqs_end - seqs_begin) >=
+          ((__seqs_end - __seqs_begin) >=
             __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
-          && ((sequence_index_t)length >=
+          && ((_SequenceIndex)__length >=
             __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
       return parallel_multiway_merge
-        </* stable = */ true, /* sentinels = */ false>(
-          seqs_begin, seqs_end,
-          target,
-          multiway_merge_sampling_splitting</* stable = */ true,
-            typename std::iterator_traits<RandomAccessIteratorPairIterator>
-              ::value_type*, Comparator, _DifferenceTp>,
-          static_cast<difference_type>(length), comp, tag.get_num_threads());
+        </* __stable = */ true, /* __sentinels = */ false>(
+          __seqs_begin, __seqs_end,
+          __target,
+          multiway_merge_sampling_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 RandomAccessIteratorPairIterator
-  , typename RandomAccessIteratorOut
+    typename _RAIterPairIterator
+  , typename _RAIterOut
   , typename _DifferenceTp
-  , typename Comparator>
-RandomAccessIteratorOut
-stable_multiway_merge(RandomAccessIteratorPairIterator seqs_begin
-    , RandomAccessIteratorPairIterator seqs_end
-    , RandomAccessIteratorOut target
-    , _DifferenceTp length, Comparator comp
-    , parallel_tag tag = parallel_tag(0))
+  , typename _Compare>
+_RAIterOut
+stable_multiway_merge(_RAIterPairIterator __seqs_begin
+    , _RAIterPairIterator __seqs_end
+    , _RAIterOut __target
+    , _DifferenceTp __length, _Compare __comp
+    , parallel_tag __tag = parallel_tag(0))
 {
-  return stable_multiway_merge(seqs_begin, seqs_end, target, length, comp,
-                         exact_tag(tag.get_num_threads()));
+  return stable_multiway_merge(__seqs_begin, __seqs_end, __target, __length, __comp,
+                         exact_tag(__tag.__get_num_threads()));
 }
 
 // public interface
 template<
-    typename RandomAccessIteratorPairIterator
-  , typename RandomAccessIteratorOut
+    typename _RAIterPairIterator
+  , typename _RAIterOut
   , typename _DifferenceTp
-  , typename Comparator>
-RandomAccessIteratorOut
-stable_multiway_merge(RandomAccessIteratorPairIterator seqs_begin
-    , RandomAccessIteratorPairIterator seqs_end
-    , RandomAccessIteratorOut target
-    , _DifferenceTp length, Comparator comp
-    , default_parallel_tag tag)
+  , typename _Compare>
+_RAIterOut
+stable_multiway_merge(_RAIterPairIterator __seqs_begin
+    , _RAIterPairIterator __seqs_end
+    , _RAIterOut __target
+    , _DifferenceTp __length, _Compare __comp
+    , default_parallel_tag __tag)
 {
-  return stable_multiway_merge(seqs_begin, seqs_end, target, length, comp,
-                         exact_tag(tag.get_num_threads()));
+  return stable_multiway_merge(__seqs_begin, __seqs_end, __target, __length, __comp,
+                         exact_tag(__tag.__get_num_threads()));
 }
 
 /**
  * @brief Multiway Merge Frontend.
  *
- * Merge the sequences specified by seqs_begin and seqs_end into
- * target.  seqs_begin and seqs_end must point to a sequence of
+ * Merge the sequences specified by seqs_begin and __seqs_end into
+ * __target.  __seqs_begin and __seqs_end must point to a sequence of
  * pairs.  These pairs must contain an iterator to the beginning
- * of a sequence in their first entry and an iterator the end of
+ * of a sequence in their first entry and an iterator the _M_end of
  * the same sequence in their second entry.
  *
  * Ties are broken arbitrarily.  See stable_multiway_merge for a variant
@@ -1788,7 +1788,7 @@ stable_multiway_merge(RandomAccessIteratorPairIterator seqs_begin
  * - using sampling for splitting
  * - using sentinels
  *
- * You have to take care that the element the end iterator points to is
+ * You have to take care that the element the _M_end iterator points to is
  * readable and contains a value that is greater than any other non-sentinel
  * value in all sequences.
  *
@@ -1796,343 +1796,343 @@ stable_multiway_merge(RandomAccessIteratorPairIterator seqs_begin
  *
  * <pre>
  *   int sequences[10][11];
- *   for (int i = 0; i < 10; ++i)
- *     for (int j = 0; i < 11; ++j)
- *       sequences[i][j] = j; // last one is sentinel!
+ *   for (int __i = 0; __i < 10; ++__i)
+ *     for (int __j = 0; __i < 11; ++__j)
+ *       sequences[__i][__j] = __j; // __last one is sentinel!
  *
- *   int out[33];
+ *   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)) }
+ *   for (int __i = 0; __i < 10; ++__i)
+ *     { seqs.push(std::make_pair<int*>(sequences[__i], sequences[__i] + 10)) }
  *
- *   multiway_merge(seqs.begin(), seqs.end(), target, std::less<int>(), 33);
+ *   multiway_merge(seqs.begin(), seqs.end(), __target, std::less<int>(), 33);
  * </pre>
  *
  * @pre All input sequences must be sorted.
- * @pre Target must provide enough space to merge out length elements or
+ * @pre Target must provide enough space to merge out __length __elements or
  *    the number of elements in all sequences, whichever is smaller.
- * @pre For each @c i, @c seqs_begin[i].second must be the end
- *    marker of the sequence, but also reference the one more sentinel
+ * @pre For each @__c __i, @__c __seqs_begin[__i].second must be the end
+ *    marker of the sequence, but also reference the one more __sentinel
  *    element.
  *
- * @post [target, return value) contains merged elements from the
+ * @post [__target, return __value) contains merged __elements from the
  *    input sequences.
- * @post return value - target = min(length, number of elements in all
+ * @post return __value - __target = min(__length, number of elements in all
  *    sequences).
  *
  * @see stable_multiway_merge_sentinels
  *
- * @param RandomAccessIteratorPairIterator iterator over sequence
+ * @param _RAIterPairIterator iterator over __sequence
  *    of pairs of iterators
- * @param RandomAccessIteratorOut iterator over target sequence
- * @param _DifferenceTp difference type for the sequence
- * @param Comparator strict weak ordering type to compare elements
+ * @param _RAIterOut iterator over target sequence
+ * @param _DifferenceTp difference _Self for the sequence
+ * @param _Compare strict weak ordering _Self to compare __elements
  *    in sequences
  *
- * @param seqs_begin  begin of sequence sequence
- * @param seqs_end    end of sequence sequence
- * @param target      target sequence to merge to.
- * @param comp        strict weak ordering to use for element comparison.
- * @param length Maximum length to merge, possibly larger than the
+ * @param __seqs_begin  __begin of sequence __sequence
+ * @param __seqs_end    _M_end of sequence __sequence
+ * @param __target      target sequence to merge to.
+ * @param __comp        strict weak ordering to use for element comparison.
+ * @param __length Maximum length to merge, possibly larger than the
  * number of elements available.
  *
- * @return end iterator of output sequence
+ * @return _M_end iterator of output sequence
  */
 // multiway_merge_sentinels
 // public interface
 template<
-    typename RandomAccessIteratorPairIterator
-  , typename RandomAccessIteratorOut
+    typename _RAIterPairIterator
+  , typename _RAIterOut
   , typename _DifferenceTp
-  , typename Comparator>
-RandomAccessIteratorOut
-multiway_merge_sentinels(RandomAccessIteratorPairIterator seqs_begin
-    , RandomAccessIteratorPairIterator seqs_end
-    , RandomAccessIteratorOut target
-    , _DifferenceTp length, Comparator comp
+  , typename _Compare>
+_RAIterOut
+multiway_merge_sentinels(_RAIterPairIterator __seqs_begin
+    , _RAIterPairIterator __seqs_end
+    , _RAIterOut __target
+    , _DifferenceTp __length, _Compare __comp
     , __gnu_parallel::sequential_tag)
 {
-    typedef _DifferenceTp difference_type;
-    _GLIBCXX_CALL(seqs_end - seqs_begin)
+    typedef _DifferenceTp _DifferenceType;
+    _GLIBCXX_CALL(__seqs_end - __seqs_begin)
 
     // catch special case: no sequences
-    if (seqs_begin == seqs_end)
-      return target;
+    if (__seqs_begin == __seqs_end)
+      return __target;
 
     // Execute multiway merge *sequentially*.
-    return sequential_multiway_merge
-      </* stable = */ false, /* sentinels = */ true>
-        (seqs_begin, seqs_end,
-         target, *(seqs_begin->second), length, comp);
+    return __sequential_multiway_merge
+      </* __stable = */ false, /* __sentinels = */ true>
+        (__seqs_begin, __seqs_end,
+         __target, *(__seqs_begin->second), __length, __comp);
 }
 
 // public interface
 template<
-    typename RandomAccessIteratorPairIterator
-  , typename RandomAccessIteratorOut
+    typename _RAIterPairIterator
+  , typename _RAIterOut
   , typename _DifferenceTp
-  , typename Comparator>
-RandomAccessIteratorOut
-multiway_merge_sentinels(RandomAccessIteratorPairIterator seqs_begin
-    , RandomAccessIteratorPairIterator seqs_end
-    , RandomAccessIteratorOut target
-    , _DifferenceTp length, Comparator comp
-    , __gnu_parallel::exact_tag tag)
+  , typename _Compare>
+_RAIterOut
+multiway_merge_sentinels(_RAIterPairIterator __seqs_begin
+    , _RAIterPairIterator __seqs_end
+    , _RAIterOut __target
+    , _DifferenceTp __length, _Compare __comp
+    , __gnu_parallel::exact_tag __tag)
 {
-    typedef _DifferenceTp difference_type;
-    _GLIBCXX_CALL(seqs_end - seqs_begin)
+    typedef _DifferenceTp _DifferenceType;
+    _GLIBCXX_CALL(__seqs_end - __seqs_begin)
 
     // catch special case: no sequences
-    if (seqs_begin == seqs_end)
-      return target;
+    if (__seqs_begin == __seqs_end)
+      return __target;
 
     // 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) &&
+    if ((__seqs_end - __seqs_begin > 1) &&
           _GLIBCXX_PARALLEL_CONDITION(
-          ((seqs_end - seqs_begin) >=
+          ((__seqs_end - __seqs_begin) >=
             __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
-          && ((sequence_index_t)length >=
+          && ((_SequenceIndex)__length >=
             __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
       return parallel_multiway_merge
-        </* stable = */ false, /* sentinels = */ true>(
-          seqs_begin, seqs_end,
-          target,
-          multiway_merge_exact_splitting</* stable = */ false,
-            typename std::iterator_traits<RandomAccessIteratorPairIterator>
-              ::value_type*, Comparator, _DifferenceTp>,
-          static_cast<difference_type>(length), comp, tag.get_num_threads());
+        </* __stable = */ false, /* __sentinels = */ true>(
+          __seqs_begin, __seqs_end,
+          __target,
+          multiway_merge_exact_splitting</* __stable = */ false,
+            typename std::iterator_traits<_RAIterPairIterator>
+              ::value_type*, _Compare, _DifferenceTp>,
+          static_cast<_DifferenceType>(__length), __comp, __tag.__get_num_threads());
     else
-      return sequential_multiway_merge
-        </* stable = */ false, /* sentinels = */ true>(
-          seqs_begin, seqs_end,
-          target, *(seqs_begin->second), length, comp);
+      return __sequential_multiway_merge
+        </* __stable = */ false, /* __sentinels = */ true>(
+          __seqs_begin, __seqs_end,
+          __target, *(__seqs_begin->second), __length, __comp);
 }
 
 // public interface
 template<
-    typename RandomAccessIteratorPairIterator
-  , typename RandomAccessIteratorOut
+    typename _RAIterPairIterator
+  , typename _RAIterOut
   , typename _DifferenceTp
-  , typename Comparator>
-RandomAccessIteratorOut
-multiway_merge_sentinels(RandomAccessIteratorPairIterator seqs_begin
-    , RandomAccessIteratorPairIterator seqs_end
-    , RandomAccessIteratorOut target
-    , _DifferenceTp length, Comparator comp
-    , sampling_tag tag)
+  , typename _Compare>
+_RAIterOut
+multiway_merge_sentinels(_RAIterPairIterator __seqs_begin
+    , _RAIterPairIterator __seqs_end
+    , _RAIterOut __target
+    , _DifferenceTp __length, _Compare __comp
+    , sampling_tag __tag)
 {
-    typedef _DifferenceTp difference_type;
-    _GLIBCXX_CALL(seqs_end - seqs_begin)
+    typedef _DifferenceTp _DifferenceType;
+    _GLIBCXX_CALL(__seqs_end - __seqs_begin)
 
     // catch special case: no sequences
-    if (seqs_begin == seqs_end)
-      return target;
+    if (__seqs_begin == __seqs_end)
+      return __target;
 
     // 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) &&
+    if ((__seqs_end - __seqs_begin > 1) &&
           _GLIBCXX_PARALLEL_CONDITION(
-          ((seqs_end - seqs_begin) >=
+          ((__seqs_end - __seqs_begin) >=
             __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
-          && ((sequence_index_t)length >=
+          && ((_SequenceIndex)__length >=
             __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
       return parallel_multiway_merge
-        </* stable = */ false, /* sentinels = */ true>
-          (seqs_begin, seqs_end, target,
-          multiway_merge_sampling_splitting</* stable = */ false,
-            typename std::iterator_traits<RandomAccessIteratorPairIterator>
-              ::value_type*, Comparator, _DifferenceTp>,
-          static_cast<difference_type>(length), comp, tag.get_num_threads());
+        </* __stable = */ false, /* __sentinels = */ true>
+          (__seqs_begin, __seqs_end, __target,
+          multiway_merge_sampling_splitting</* __stable = */ false,
+            typename std::iterator_traits<_RAIterPairIterator>
+              ::value_type*, _Compare, _DifferenceTp>,
+          static_cast<_DifferenceType>(__length), __comp, __tag.__get_num_threads());
     else
-      return sequential_multiway_merge
-        </* stable = */false, /* sentinels = */ true>(
-          seqs_begin, seqs_end,
-          target, *(seqs_begin->second), length, comp);
+      return __sequential_multiway_merge
+        </* __stable = */false, /* __sentinels = */ true>(
+          __seqs_begin, __seqs_end,
+          __target, *(__seqs_begin->second), __length, __comp);
 }
 
 // public interface
 template<
-    typename RandomAccessIteratorPairIterator
-  , typename RandomAccessIteratorOut
+    typename _RAIterPairIterator
+  , typename _RAIterOut
   , typename _DifferenceTp
-  , typename Comparator>
-RandomAccessIteratorOut
-multiway_merge_sentinels(RandomAccessIteratorPairIterator seqs_begin
-    , RandomAccessIteratorPairIterator seqs_end
-    , RandomAccessIteratorOut target
-    , _DifferenceTp length, Comparator comp
-    , parallel_tag tag = parallel_tag(0))
+  , typename _Compare>
+_RAIterOut
+multiway_merge_sentinels(_RAIterPairIterator __seqs_begin
+    , _RAIterPairIterator __seqs_end
+    , _RAIterOut __target
+    , _DifferenceTp __length, _Compare __comp
+    , parallel_tag __tag = parallel_tag(0))
 {
-  return multiway_merge_sentinels(seqs_begin, seqs_end, target, length, comp,
-                         exact_tag(tag.get_num_threads()));
+  return multiway_merge_sentinels(__seqs_begin, __seqs_end, __target, __length, __comp,
+                         exact_tag(__tag.__get_num_threads()));
 }
 
 // public interface
 template<
-    typename RandomAccessIteratorPairIterator
-  , typename RandomAccessIteratorOut
+    typename _RAIterPairIterator
+  , typename _RAIterOut
   , typename _DifferenceTp
-  , typename Comparator>
-RandomAccessIteratorOut
-multiway_merge_sentinels(RandomAccessIteratorPairIterator seqs_begin
-    , RandomAccessIteratorPairIterator seqs_end
-    , RandomAccessIteratorOut target
-    , _DifferenceTp length, Comparator comp
-    , default_parallel_tag tag)
+  , typename _Compare>
+_RAIterOut
+multiway_merge_sentinels(_RAIterPairIterator __seqs_begin
+    , _RAIterPairIterator __seqs_end
+    , _RAIterOut __target
+    , _DifferenceTp __length, _Compare __comp
+    , default_parallel_tag __tag)
 {
-  return multiway_merge_sentinels(seqs_begin, seqs_end, target, length, comp,
-                         exact_tag(tag.get_num_threads()));
+  return multiway_merge_sentinels(__seqs_begin, __seqs_end, __target, __length, __comp,
+                         exact_tag(__tag.__get_num_threads()));
 }
 
 // stable_multiway_merge_sentinels
 // public interface
 template<
-    typename RandomAccessIteratorPairIterator
-  , typename RandomAccessIteratorOut
+    typename _RAIterPairIterator
+  , typename _RAIterOut
   , typename _DifferenceTp
-  , typename Comparator>
-RandomAccessIteratorOut
-stable_multiway_merge_sentinels(RandomAccessIteratorPairIterator seqs_begin
-    , RandomAccessIteratorPairIterator seqs_end
-    , RandomAccessIteratorOut target
-    , _DifferenceTp length, Comparator comp
+  , typename _Compare>
+_RAIterOut
+stable_multiway_merge_sentinels(_RAIterPairIterator __seqs_begin
+    , _RAIterPairIterator __seqs_end
+    , _RAIterOut __target
+    , _DifferenceTp __length, _Compare __comp
     , __gnu_parallel::sequential_tag)
 {
-    typedef _DifferenceTp difference_type;
-    _GLIBCXX_CALL(seqs_end - seqs_begin)
+    typedef _DifferenceTp _DifferenceType;
+    _GLIBCXX_CALL(__seqs_end - __seqs_begin)
 
     // catch special case: no sequences
-    if (seqs_begin == seqs_end)
-      return target;
+    if (__seqs_begin == __seqs_end)
+      return __target;
 
     // Execute multiway merge *sequentially*.
-    return sequential_multiway_merge
-      </* stable = */ true, /* sentinels = */ true>
-        (seqs_begin, seqs_end, target, *(seqs_begin->second), length, comp);
+    return __sequential_multiway_merge
+      </* __stable = */ true, /* __sentinels = */ true>
+        (__seqs_begin, __seqs_end, __target, *(__seqs_begin->second), __length, __comp);
 }
 
 // public interface
 template<
-    typename RandomAccessIteratorPairIterator
-  , typename RandomAccessIteratorOut
+    typename _RAIterPairIterator
+  , typename _RAIterOut
   , typename _DifferenceTp
-  , typename Comparator>
-RandomAccessIteratorOut
-stable_multiway_merge_sentinels(RandomAccessIteratorPairIterator seqs_begin
-    , RandomAccessIteratorPairIterator seqs_end
-    , RandomAccessIteratorOut target
-    , _DifferenceTp length, Comparator comp
-    , __gnu_parallel::exact_tag tag)
+  , typename _Compare>
+_RAIterOut
+stable_multiway_merge_sentinels(_RAIterPairIterator __seqs_begin
+    , _RAIterPairIterator __seqs_end
+    , _RAIterOut __target
+    , _DifferenceTp __length, _Compare __comp
+    , __gnu_parallel::exact_tag __tag)
 {
-    typedef _DifferenceTp difference_type;
-    _GLIBCXX_CALL(seqs_end - seqs_begin)
+    typedef _DifferenceTp _DifferenceType;
+    _GLIBCXX_CALL(__seqs_end - __seqs_begin)
 
     // catch special case: no sequences
-    if (seqs_begin == seqs_end)
-      return target;
+    if (__seqs_begin == __seqs_end)
+      return __target;
 
     // 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) &&
+    if ((__seqs_end - __seqs_begin > 1) &&
           _GLIBCXX_PARALLEL_CONDITION(
-          ((seqs_end - seqs_begin) >=
+          ((__seqs_end - __seqs_begin) >=
           __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
-          && ((sequence_index_t)length >=
+          && ((_SequenceIndex)__length >=
           __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
       return parallel_multiway_merge
-        </* stable = */ true, /* sentinels = */ true>(
-          seqs_begin, seqs_end,
-          target,
-          multiway_merge_exact_splitting</* stable = */ true,
-            typename std::iterator_traits<RandomAccessIteratorPairIterator>
-              ::value_type*, Comparator, _DifferenceTp>,
-          static_cast<difference_type>(length), comp, tag.get_num_threads());
+        </* __stable = */ true, /* __sentinels = */ true>(
+          __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 = */ true>(
-          seqs_begin, seqs_end, target, *(seqs_begin->second), length, comp);
+      return __sequential_multiway_merge
+        </* __stable = */ true, /* __sentinels = */ true>(
+          __seqs_begin, __seqs_end, __target, *(__seqs_begin->second), __length, __comp);
 }
 
 // public interface
 template<
-    typename RandomAccessIteratorPairIterator
-  , typename RandomAccessIteratorOut
+    typename _RAIterPairIterator
+  , typename _RAIterOut
   , typename _DifferenceTp
-  , typename Comparator>
-RandomAccessIteratorOut
-stable_multiway_merge_sentinels(RandomAccessIteratorPairIterator seqs_begin
-    , RandomAccessIteratorPairIterator seqs_end
-    , RandomAccessIteratorOut target
-    , _DifferenceTp length, Comparator comp
-    , sampling_tag tag)
+  , typename _Compare>
+_RAIterOut
+stable_multiway_merge_sentinels(_RAIterPairIterator __seqs_begin
+    , _RAIterPairIterator __seqs_end
+    , _RAIterOut __target
+    , _DifferenceTp __length, _Compare __comp
+    , sampling_tag __tag)
 {
-    typedef _DifferenceTp difference_type;
-    _GLIBCXX_CALL(seqs_end - seqs_begin)
+    typedef _DifferenceTp _DifferenceType;
+    _GLIBCXX_CALL(__seqs_end - __seqs_begin)
 
     // catch special case: no sequences
-    if (seqs_begin == seqs_end)
-      return target;
+    if (__seqs_begin == __seqs_end)
+      return __target;
 
     // 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) &&
+    if ((__seqs_end - __seqs_begin > 1) &&
           _GLIBCXX_PARALLEL_CONDITION(
-          ((seqs_end - seqs_begin) >=
+          ((__seqs_end - __seqs_begin) >=
             __gnu_parallel::_Settings::get().multiway_merge_minimal_k)
-          && ((sequence_index_t)length >=
+          && ((_SequenceIndex)__length >=
             __gnu_parallel::_Settings::get().multiway_merge_minimal_n)))
       return parallel_multiway_merge
-        </* stable = */ true, /* sentinels = */ true>(
-          seqs_begin, seqs_end,
-          target,
-          multiway_merge_sampling_splitting</* stable = */ true,
-            typename std::iterator_traits<RandomAccessIteratorPairIterator>
-              ::value_type*, Comparator, _DifferenceTp>,
-          static_cast<difference_type>(length), comp, tag.get_num_threads());
+        </* __stable = */ true, /* __sentinels = */ true>(
+          __seqs_begin, __seqs_end,
+          __target,
+          multiway_merge_sampling_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 = */ true>(
-          seqs_begin, seqs_end,
-          target, *(seqs_begin->second), length, comp);
+      return __sequential_multiway_merge
+        </* __stable = */ true, /* __sentinels = */ true>(
+          __seqs_begin, __seqs_end,
+          __target, *(__seqs_begin->second), __length, __comp);
 }
 
 // public interface
 template<
-    typename RandomAccessIteratorPairIterator
-  , typename RandomAccessIteratorOut
+    typename _RAIterPairIterator
+  , typename _RAIterOut
   , typename _DifferenceTp
-  , typename Comparator>
-RandomAccessIteratorOut
-stable_multiway_merge_sentinels(RandomAccessIteratorPairIterator seqs_begin
-    , RandomAccessIteratorPairIterator seqs_end
-    , RandomAccessIteratorOut target
-    , _DifferenceTp length, Comparator comp
-    , parallel_tag tag = parallel_tag(0))
+  , typename _Compare>
+_RAIterOut
+stable_multiway_merge_sentinels(_RAIterPairIterator __seqs_begin
+    , _RAIterPairIterator __seqs_end
+    , _RAIterOut __target
+    , _DifferenceTp __length, _Compare __comp
+    , parallel_tag __tag = parallel_tag(0))
 {
-  return stable_multiway_merge_sentinels(seqs_begin, seqs_end, target, length, comp,
-                         exact_tag(tag.get_num_threads()));
+  return stable_multiway_merge_sentinels(__seqs_begin, __seqs_end, __target, __length, __comp,
+                         exact_tag(__tag.__get_num_threads()));
 }
 
 // public interface
 template<
-    typename RandomAccessIteratorPairIterator
-  , typename RandomAccessIteratorOut
+    typename _RAIterPairIterator
+  , typename _RAIterOut
   , typename _DifferenceTp
-  , typename Comparator>
-RandomAccessIteratorOut
-stable_multiway_merge_sentinels(RandomAccessIteratorPairIterator seqs_begin
-    , RandomAccessIteratorPairIterator seqs_end
-    , RandomAccessIteratorOut target
-    , _DifferenceTp length, Comparator comp
-    , default_parallel_tag tag)
+  , typename _Compare>
+_RAIterOut
+stable_multiway_merge_sentinels(_RAIterPairIterator __seqs_begin
+    , _RAIterPairIterator __seqs_end
+    , _RAIterOut __target
+    , _DifferenceTp __length, _Compare __comp
+    , default_parallel_tag __tag)
 {
-  return stable_multiway_merge_sentinels(seqs_begin, seqs_end, target, length, comp,
-                         exact_tag(tag.get_num_threads()));
+  return stable_multiway_merge_sentinels(__seqs_begin, __seqs_end, __target, __length, __comp,
+                         exact_tag(__tag.__get_num_threads()));
 }
 
 }; // namespace __gnu_parallel
diff --git a/libstdc++-v3/include/parallel/multiway_mergesort.h b/libstdc++-v3/include/parallel/multiway_mergesort.h
index 11dd885..1c2c7e4 100644
--- a/libstdc++-v3/include/parallel/multiway_mergesort.h
+++ b/libstdc++-v3/include/parallel/multiway_mergesort.h
@@ -44,431 +44,431 @@ namespace __gnu_parallel
 
 /** @brief Subsequence description. */
 template<typename _DifferenceTp>
-  struct Piece
+  struct _Piece
   {
-    typedef _DifferenceTp difference_type;
+    typedef _DifferenceTp _DifferenceType;
 
     /** @brief Begin of subsequence. */
-    difference_type begin;
+    _DifferenceType __begin;
 
     /** @brief End of subsequence. */
-    difference_type end;
+    _DifferenceType __end;
   };
 
 /** @brief Data accessed by all threads.
   *
   *  PMWMS = parallel multiway mergesort */
-template<typename RandomAccessIterator>
-  struct PMWMSSortingData
+template<typename _RAIter>
+  struct _PMWMSSortingData
   {
-    typedef std::iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    typedef typename traits_type::difference_type difference_type;
+    typedef std::iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
 
     /** @brief Number of threads involved. */
-    thread_index_t num_threads;
+    _ThreadIndex __num_threads;
 
-    /** @brief Input begin. */
-    RandomAccessIterator source;
+    /** @brief Input __begin. */
+    _RAIter _M_source;
 
     /** @brief Start indices, per thread. */
-    difference_type* starts;
+    _DifferenceType* _M_starts;
 
     /** @brief Storage in which to sort. */
-    value_type** temporary;
+    _ValueType** _M_temporary;
 
     /** @brief Samples. */
-    value_type* samples;
+    _ValueType* _M_samples;
 
     /** @brief Offsets to add to the found positions. */
-    difference_type* offsets;
+    _DifferenceType* _M_offsets;
 
-    /** @brief Pieces of data to merge @c [thread][sequence] */
-    std::vector<Piece<difference_type> >* pieces;
+    /** @brief Pieces of data to merge @__c [thread][__sequence] */
+    std::vector<_Piece<_DifferenceType> >* _M_pieces;
 };
 
 /**
-  *  @brief Select samples from a sequence.
-  *  @param sd Pointer to algorithm data. Result will be placed in
-  *  @c sd->samples.
-  *  @param num_samples Number of samples to select.
+  *  @brief Select _M_samples from a sequence.
+  *  @param __sd Pointer to algorithm data. _Result will be placed in
+  *  @__c __sd->_M_samples.
+  *  @param __num_samples Number of _M_samples to select.
   */
-template<typename RandomAccessIterator, typename _DifferenceTp>
+template<typename _RAIter, typename _DifferenceTp>
   void 
-  determine_samples(PMWMSSortingData<RandomAccessIterator>* sd,
-                    _DifferenceTp num_samples)
+  __determine_samples(_PMWMSSortingData<_RAIter>* __sd,
+                    _DifferenceTp __num_samples)
   {
-    typedef std::iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    typedef _DifferenceTp difference_type;
+    typedef std::iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    typedef _DifferenceTp _DifferenceType;
 
-    thread_index_t iam = omp_get_thread_num();
+    _ThreadIndex __iam = omp_get_thread_num();
 
-    difference_type* es = new difference_type[num_samples + 2];
+    _DifferenceType* __es = new _DifferenceType[__num_samples + 2];
 
-    equally_split(sd->starts[iam + 1] - sd->starts[iam], 
-                  num_samples + 1, es);
+    equally_split(__sd->_M_starts[__iam + 1] - __sd->_M_starts[__iam], 
+                  __num_samples + 1, __es);
 
-    for (difference_type i = 0; i < num_samples; ++i)
-      ::new(&(sd->samples[iam * num_samples + i]))
-	  value_type(sd->source[sd->starts[iam] + es[i + 1]]);
+    for (_DifferenceType __i = 0; __i < __num_samples; ++__i)
+      ::new(&(__sd->_M_samples[__iam * __num_samples + __i]))
+	  _ValueType(__sd->_M_source[__sd->_M_starts[__iam] + __es[__i + 1]]);
 
-    delete[] es;
+    delete[] __es;
   }
 
 /** @brief Split consistently. */
-template<bool exact, typename RandomAccessIterator,
-          typename Comparator, typename SortingPlacesIterator>
-  struct split_consistently
+template<bool __exact, typename _RAIter,
+          typename _Compare, typename _SortingPlacesIterator>
+  struct _SplitConsistently
   {
   };
 
 /** @brief Split by exact splitting. */
-template<typename RandomAccessIterator, typename Comparator,
-          typename SortingPlacesIterator>
-  struct split_consistently
-    <true, RandomAccessIterator, Comparator, SortingPlacesIterator>
+template<typename _RAIter, typename _Compare,
+          typename _SortingPlacesIterator>
+  struct _SplitConsistently
+    <true, _RAIter, _Compare, _SortingPlacesIterator>
   {
     void operator()(
-      const thread_index_t iam,
-      PMWMSSortingData<RandomAccessIterator>* sd,
-      Comparator& comp,
+      const _ThreadIndex __iam,
+      _PMWMSSortingData<_RAIter>* __sd,
+      _Compare& __comp,
       const typename
-        std::iterator_traits<RandomAccessIterator>::difference_type
-          num_samples)
+        std::iterator_traits<_RAIter>::difference_type
+          __num_samples)
       const
   {
 #   pragma omp barrier
 
-    std::vector<std::pair<SortingPlacesIterator, SortingPlacesIterator> >
-        seqs(sd->num_threads);
-    for (thread_index_t s = 0; s < sd->num_threads; s++)
-      seqs[s] = std::make_pair(sd->temporary[s],
-                                sd->temporary[s]
-                                    + (sd->starts[s + 1] - sd->starts[s]));
+    std::vector<std::pair<_SortingPlacesIterator, _SortingPlacesIterator> >
+        seqs(__sd->__num_threads);
+    for (_ThreadIndex __s = 0; __s < __sd->__num_threads; __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> offsets(sd->num_threads);
+    std::vector<_SortingPlacesIterator> _M_offsets(__sd->__num_threads);
 
     // if not last thread
-    if (iam < sd->num_threads - 1)
+    if (__iam < __sd->__num_threads - 1)
       multiseq_partition(seqs.begin(), seqs.end(),
-                          sd->starts[iam + 1], offsets.begin(), comp);
+                          __sd->_M_starts[__iam + 1], _M_offsets.begin(), __comp);
 
-    for (int seq = 0; seq < sd->num_threads; seq++)
+    for (int __seq = 0; __seq < __sd->__num_threads; __seq++)
       {
         // for each sequence
-        if (iam < (sd->num_threads - 1))
-          sd->pieces[iam][seq].end = offsets[seq] - seqs[seq].first;
+        if (__iam < (__sd->__num_threads - 1))
+          __sd->_M_pieces[__iam][__seq].__end = _M_offsets[__seq] - seqs[__seq].first;
         else
           // very end of this sequence
-          sd->pieces[iam][seq].end =
-              sd->starts[seq + 1] - sd->starts[seq];
+          __sd->_M_pieces[__iam][__seq].__end =
+              __sd->_M_starts[__seq + 1] - __sd->_M_starts[__seq];
       }
 
 #   pragma omp barrier
 
-    for (thread_index_t seq = 0; seq < sd->num_threads; seq++)
+    for (_ThreadIndex __seq = 0; __seq < __sd->__num_threads; __seq++)
       {
         // For each sequence.
-        if (iam > 0)
-          sd->pieces[iam][seq].begin = sd->pieces[iam - 1][seq].end;
+        if (__iam > 0)
+          __sd->_M_pieces[__iam][__seq].__begin = __sd->_M_pieces[__iam - 1][__seq].__end;
         else
           // Absolute beginning.
-          sd->pieces[iam][seq].begin = 0;
+          __sd->_M_pieces[__iam][__seq].__begin = 0;
       }
   }   
   };
 
 /** @brief Split by sampling. */ 
-template<typename RandomAccessIterator, typename Comparator,
-          typename SortingPlacesIterator>
-  struct split_consistently<false, RandomAccessIterator, Comparator,
-                             SortingPlacesIterator>
+template<typename _RAIter, typename _Compare,
+          typename _SortingPlacesIterator>
+  struct _SplitConsistently<false, _RAIter, _Compare,
+                             _SortingPlacesIterator>
   {
     void operator()(
-        const thread_index_t iam,
-        PMWMSSortingData<RandomAccessIterator>* sd,
-        Comparator& comp,
+        const _ThreadIndex __iam,
+        _PMWMSSortingData<_RAIter>* __sd,
+        _Compare& __comp,
         const typename
-          std::iterator_traits<RandomAccessIterator>::difference_type
-            num_samples)
+          std::iterator_traits<_RAIter>::difference_type
+            __num_samples)
         const
     {
-      typedef std::iterator_traits<RandomAccessIterator> traits_type;
-      typedef typename traits_type::value_type value_type;
-      typedef typename traits_type::difference_type difference_type;
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
 
-      determine_samples(sd, num_samples);
+      __determine_samples(__sd, __num_samples);
 
 #     pragma omp barrier
 
 #     pragma omp single
-      __gnu_sequential::sort(sd->samples,
-                             sd->samples + (num_samples * sd->num_threads),
-                             comp);
+      __gnu_sequential::sort(__sd->_M_samples,
+                             __sd->_M_samples + (__num_samples * __sd->__num_threads),
+                             __comp);
 
 #     pragma omp barrier
 
-      for (thread_index_t s = 0; s < sd->num_threads; ++s)
+      for (_ThreadIndex __s = 0; __s < __sd->__num_threads; ++__s)
         {
           // For each sequence.
-          if (num_samples * iam > 0)
-            sd->pieces[iam][s].begin =
-                std::lower_bound(sd->temporary[s],
-                    sd->temporary[s]
-                        + (sd->starts[s + 1] - sd->starts[s]),
-                    sd->samples[num_samples * iam],
-                    comp)
-                - sd->temporary[s];
+          if (__num_samples * __iam > 0)
+            __sd->_M_pieces[__iam][__s].__begin =
+                std::lower_bound(__sd->_M_temporary[__s],
+                    __sd->_M_temporary[__s]
+                        + (__sd->_M_starts[__s + 1] - __sd->_M_starts[__s]),
+                    __sd->_M_samples[__num_samples * __iam],
+                    __comp)
+                - __sd->_M_temporary[__s];
           else
             // Absolute beginning.
-            sd->pieces[iam][s].begin = 0;
-
-          if ((num_samples * (iam + 1)) < (num_samples * sd->num_threads))
-            sd->pieces[iam][s].end =
-                std::lower_bound(sd->temporary[s],
-                        sd->temporary[s]
-                            + (sd->starts[s + 1] - sd->starts[s]),
-                        sd->samples[num_samples * (iam + 1)],
-                        comp)
-                - sd->temporary[s];
+            __sd->_M_pieces[__iam][__s].__begin = 0;
+
+          if ((__num_samples * (__iam + 1)) < (__num_samples * __sd->__num_threads))
+            __sd->_M_pieces[__iam][__s].__end =
+                std::lower_bound(__sd->_M_temporary[__s],
+                        __sd->_M_temporary[__s]
+                            + (__sd->_M_starts[__s + 1] - __sd->_M_starts[__s]),
+                        __sd->_M_samples[__num_samples * (__iam + 1)],
+                        __comp)
+                - __sd->_M_temporary[__s];
           else
-            // Absolute end.
-            sd->pieces[iam][s].end = sd->starts[s + 1] - sd->starts[s];
+            // Absolute __end.
+            __sd->_M_pieces[__iam][__s].__end = __sd->_M_starts[__s + 1] - __sd->_M_starts[__s];
         }
     }
   };
   
-template<bool stable, typename RandomAccessIterator, typename Comparator>
-  struct possibly_stable_sort
+template<bool __stable, typename _RAIter, typename _Compare>
+  struct __possibly_stable_sort
   {
   };
 
-template<typename RandomAccessIterator, typename Comparator>
-  struct possibly_stable_sort<true, RandomAccessIterator, Comparator>
+template<typename _RAIter, typename _Compare>
+  struct __possibly_stable_sort<true, _RAIter, _Compare>
   {
-    void operator()(const RandomAccessIterator& begin,
-                     const RandomAccessIterator& end, Comparator& comp) const
+    void operator()(const _RAIter& __begin,
+                     const _RAIter& __end, _Compare& __comp) const
     {
-      __gnu_sequential::stable_sort(begin, end, comp); 
+      __gnu_sequential::stable_sort(__begin, __end, __comp); 
     }
   };
 
-template<typename RandomAccessIterator, typename Comparator>
-  struct possibly_stable_sort<false, RandomAccessIterator, Comparator>
+template<typename _RAIter, typename _Compare>
+  struct __possibly_stable_sort<false, _RAIter, _Compare>
   {
-    void operator()(const RandomAccessIterator begin,
-                     const RandomAccessIterator end, Comparator& comp) const
+    void operator()(const _RAIter __begin,
+                     const _RAIter __end, _Compare& __comp) const
     {
-      __gnu_sequential::sort(begin, end, comp); 
+      __gnu_sequential::sort(__begin, __end, __comp); 
     }
   };
 
-template<bool stable, typename SeqRandomAccessIterator,
-          typename RandomAccessIterator, typename Comparator,
+template<bool __stable, typename Seq_RAIter,
+          typename _RAIter, typename _Compare,
           typename DiffType>
-  struct possibly_stable_multiway_merge
+  struct __possibly_stable_multiway_merge
   {
   };
 
-template<typename SeqRandomAccessIterator, typename RandomAccessIterator,
-          typename Comparator, typename DiffType>
-  struct possibly_stable_multiway_merge
-    <true, SeqRandomAccessIterator, RandomAccessIterator, Comparator,
+template<typename Seq_RAIter, typename _RAIter,
+          typename _Compare, typename DiffType>
+  struct __possibly_stable_multiway_merge
+    <true, Seq_RAIter, _RAIter, _Compare,
     DiffType>
   {
-    void operator()(const SeqRandomAccessIterator& seqs_begin,
-                      const SeqRandomAccessIterator& seqs_end,
-                      const RandomAccessIterator& target,
-                      Comparator& comp,
-                      DiffType length_am) const
+    void operator()(const Seq_RAIter& __seqs_begin,
+                      const Seq_RAIter& __seqs_end,
+                      const _RAIter& __target,
+                      _Compare& __comp,
+                      DiffType __length_am) const
     {
-      stable_multiway_merge(seqs_begin, seqs_end, target, length_am, comp,
+      stable_multiway_merge(__seqs_begin, __seqs_end, __target, __length_am, __comp,
                        sequential_tag());
     }
   };
 
-template<typename SeqRandomAccessIterator, typename RandomAccessIterator,
-          typename Comparator, typename DiffType>
-  struct possibly_stable_multiway_merge
-    <false, SeqRandomAccessIterator, RandomAccessIterator, Comparator,
+template<typename Seq_RAIter, typename _RAIter,
+          typename _Compare, typename DiffType>
+  struct __possibly_stable_multiway_merge
+    <false, Seq_RAIter, _RAIter, _Compare,
     DiffType>
   {
-    void operator()(const SeqRandomAccessIterator& seqs_begin,
-                      const SeqRandomAccessIterator& seqs_end,
-                      const RandomAccessIterator& target,
-                      Comparator& comp,
-                      DiffType length_am) const
+    void operator()(const Seq_RAIter& __seqs_begin,
+                      const Seq_RAIter& __seqs_end,
+                      const _RAIter& __target,
+                      _Compare& __comp,
+                      DiffType __length_am) const
     {
-      multiway_merge(seqs_begin, seqs_end, target, length_am, comp,
+      multiway_merge(__seqs_begin, __seqs_end, __target, __length_am, __comp,
                        sequential_tag());
     }
   };
 
 /** @brief PMWMS code executed by each thread.
-  *  @param sd Pointer to algorithm data.
-  *  @param comp Comparator.
+  *  @param __sd Pointer to algorithm data.
+  *  @param __comp Comparator.
   */
-template<bool stable, bool exact, typename RandomAccessIterator,
-          typename Comparator>
+template<bool __stable, bool __exact, typename _RAIter,
+          typename _Compare>
   void 
-  parallel_sort_mwms_pu(PMWMSSortingData<RandomAccessIterator>* sd,
-                        Comparator& comp)
+  parallel_sort_mwms_pu(_PMWMSSortingData<_RAIter>* __sd,
+                        _Compare& __comp)
   {
-    typedef std::iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    typedef typename traits_type::difference_type difference_type;
+    typedef std::iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
 
-    thread_index_t iam = omp_get_thread_num();
+    _ThreadIndex __iam = omp_get_thread_num();
 
     // Length of this thread's chunk, before merging.
-    difference_type length_local = sd->starts[iam + 1] - sd->starts[iam];
+    _DifferenceType __length_local = __sd->_M_starts[__iam + 1] - __sd->_M_starts[__iam];
 
     // Sort in temporary storage, leave space for sentinel.
 
-    typedef value_type* SortingPlacesIterator;
+    typedef _ValueType* _SortingPlacesIterator;
 
-    sd->temporary[iam] =
-        static_cast<value_type*>(
-        ::operator new(sizeof(value_type) * (length_local + 1)));
+    __sd->_M_temporary[__iam] =
+        static_cast<_ValueType*>(
+        ::operator new(sizeof(_ValueType) * (__length_local + 1)));
 
     // Copy there.
-    std::uninitialized_copy(sd->source + sd->starts[iam],
-                            sd->source + sd->starts[iam] + length_local,
-                            sd->temporary[iam]);
+    std::uninitialized_copy(__sd->_M_source + __sd->_M_starts[__iam],
+                            __sd->_M_source + __sd->_M_starts[__iam] + __length_local,
+                            __sd->_M_temporary[__iam]);
 
-    possibly_stable_sort<stable, SortingPlacesIterator, Comparator>()
-        (sd->temporary[iam], sd->temporary[iam] + length_local, comp);
+    __possibly_stable_sort<__stable, _SortingPlacesIterator, _Compare>()
+        (__sd->_M_temporary[__iam], __sd->_M_temporary[__iam] + __length_local, __comp);
 
-    // Invariant: locally sorted subsequence in sd->temporary[iam],
-    // sd->temporary[iam] + length_local.
+    // Invariant: locally sorted subsequence in sd->_M_temporary[__iam],
+    // __sd->_M_temporary[__iam] + __length_local.
 
     // No barrier here: Synchronization is done by the splitting routine.
 
-    difference_type num_samples =
-        _Settings::get().sort_mwms_oversampling * sd->num_threads - 1;
-    split_consistently
-      <exact, RandomAccessIterator, Comparator, SortingPlacesIterator>()
-        (iam, sd, comp, num_samples);
+    _DifferenceType __num_samples =
+        _Settings::get().sort_mwms_oversampling * __sd->__num_threads - 1;
+    _SplitConsistently
+      <__exact, _RAIter, _Compare, _SortingPlacesIterator>()
+        (__iam, __sd, __comp, __num_samples);
 
-    // Offset from target begin, length after merging.
-    difference_type offset = 0, length_am = 0;
-    for (thread_index_t s = 0; s < sd->num_threads; s++)
+    // Offset from __target __begin, __length after merging.
+    _DifferenceType __offset = 0, __length_am = 0;
+    for (_ThreadIndex __s = 0; __s < __sd->__num_threads; __s++)
       {
-        length_am += sd->pieces[iam][s].end - sd->pieces[iam][s].begin;
-        offset += sd->pieces[iam][s].begin;
+        __length_am += __sd->_M_pieces[__iam][__s].__end - __sd->_M_pieces[__iam][__s].__begin;
+        __offset += __sd->_M_pieces[__iam][__s].__begin;
       }
 
     typedef std::vector<
-      std::pair<SortingPlacesIterator, SortingPlacesIterator> >
+      std::pair<_SortingPlacesIterator, _SortingPlacesIterator> >
         seq_vector_type;
-    seq_vector_type seqs(sd->num_threads);
+    seq_vector_type seqs(__sd->__num_threads);
 
-    for (int s = 0; s < sd->num_threads; ++s)
+    for (int __s = 0; __s < __sd->__num_threads; ++__s)
       {
-        seqs[s] =
-          std::make_pair(sd->temporary[s] + sd->pieces[iam][s].begin,
-        sd->temporary[s] + sd->pieces[iam][s].end);
+        seqs[__s] =
+          std::make_pair(__sd->_M_temporary[__s] + __sd->_M_pieces[__iam][__s].__begin,
+        __sd->_M_temporary[__s] + __sd->_M_pieces[__iam][__s].__end);
       }
 
-    possibly_stable_multiway_merge<
-        stable,
+    __possibly_stable_multiway_merge<
+        __stable,
         typename seq_vector_type::iterator,
-        RandomAccessIterator,
-        Comparator, difference_type>()
+        _RAIter,
+        _Compare, _DifferenceType>()
           (seqs.begin(), seqs.end(),
-           sd->source + offset, comp,
-           length_am);
+           __sd->_M_source + __offset, __comp,
+           __length_am);
 
 #   pragma omp barrier
 
-    ::operator delete(sd->temporary[iam]);
+    ::operator delete(__sd->_M_temporary[__iam]);
   }
 
 /** @brief PMWMS main call.
-  *  @param begin Begin iterator of sequence.
-  *  @param end End iterator of sequence.
-  *  @param comp Comparator.
-  *  @param n Length of sequence.
-  *  @param num_threads Number of threads to use.
+  *  @param __begin Begin iterator of sequence.
+  *  @param __end End iterator of sequence.
+  *  @param __comp Comparator.
+  *  @param __n Length of sequence.
+  *  @param __num_threads Number of threads to use.
   */
-template<bool stable, bool exact, typename RandomAccessIterator,
-           typename Comparator>
+template<bool __stable, bool __exact, typename _RAIter,
+           typename _Compare>
   void
-  parallel_sort_mwms(RandomAccessIterator begin, RandomAccessIterator end,
-                     Comparator comp,
-                     thread_index_t num_threads)
+  parallel_sort_mwms(_RAIter __begin, _RAIter __end,
+                     _Compare __comp,
+                     _ThreadIndex __num_threads)
   {
-    _GLIBCXX_CALL(end - begin)
+    _GLIBCXX_CALL(__end - __begin)
 
-    typedef std::iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    typedef typename traits_type::difference_type difference_type;
+    typedef std::iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
 
-    difference_type n = end - begin;
+    _DifferenceType __n = __end - __begin;
 
-    if (n <= 1)
+    if (__n <= 1)
       return;
 
     // at least one element per thread
-    if (num_threads > n)
-      num_threads = static_cast<thread_index_t>(n);
+    if (__num_threads > __n)
+      __num_threads = static_cast<_ThreadIndex>(__n);
 
     // shared variables
-    PMWMSSortingData<RandomAccessIterator> sd;
-    difference_type* starts;
+    _PMWMSSortingData<_RAIter> __sd;
+    _DifferenceType* _M_starts;
 
-#   pragma omp parallel num_threads(num_threads)
+#   pragma omp parallel num_threads(__num_threads)
       {
-        num_threads = omp_get_num_threads();  //no more threads than requested
+        __num_threads = omp_get_num_threads();  //no more threads than requested
 
 #       pragma omp single
           {
-            sd.num_threads = num_threads;
-            sd.source = begin;
+            __sd.__num_threads = __num_threads;
+            __sd._M_source = __begin;
 
-            sd.temporary = new value_type*[num_threads];
+            __sd._M_temporary = new _ValueType*[__num_threads];
 
-            if (!exact)
+            if (!__exact)
               {
-                difference_type size =
-                    (_Settings::get().sort_mwms_oversampling * num_threads - 1)
-                        * num_threads;
-                sd.samples = static_cast<value_type*>(
-                              ::operator new(size * sizeof(value_type)));
+                _DifferenceType size =
+                    (_Settings::get().sort_mwms_oversampling * __num_threads - 1)
+                        * __num_threads;
+                __sd._M_samples = static_cast<_ValueType*>(
+                              ::operator new(size * sizeof(_ValueType)));
               }
             else
-              sd.samples = NULL;
-
-            sd.offsets = new difference_type[num_threads - 1];
-            sd.pieces = new std::vector<Piece<difference_type> >[num_threads];
-            for (int s = 0; s < num_threads; ++s)
-              sd.pieces[s].resize(num_threads);
-            starts = sd.starts = new difference_type[num_threads + 1];
-
-            difference_type chunk_length = n / num_threads;
-            difference_type split = n % num_threads;
-            difference_type pos = 0;
-            for (int i = 0; i < num_threads; ++i)
+              __sd._M_samples = NULL;
+
+            __sd._M_offsets = new _DifferenceType[__num_threads - 1];
+            __sd._M_pieces = 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];
+
+            _DifferenceType __chunk_length = __n / __num_threads;
+            _DifferenceType __split = __n % __num_threads;
+            _DifferenceType __pos = 0;
+            for (int __i = 0; __i < __num_threads; ++__i)
               {
-                starts[i] = pos;
-                pos += (i < split) ? (chunk_length + 1) : chunk_length;
+                _M_starts[__i] = __pos;
+                __pos += (__i < __split) ? (__chunk_length + 1) : __chunk_length;
               }
-            starts[num_threads] = pos;
+            _M_starts[__num_threads] = __pos;
           } //single
 
         // Now sort in parallel.
-        parallel_sort_mwms_pu<stable, exact>(&sd, comp);
+        parallel_sort_mwms_pu<__stable, __exact>(&__sd, __comp);
       } //parallel
 
-    delete[] starts;
-    delete[] sd.temporary;
+    delete[] _M_starts;
+    delete[] __sd._M_temporary;
 
-    if (!exact)
-      ::operator delete(sd.samples);
+    if (!__exact)
+      ::operator delete(__sd._M_samples);
 
-    delete[] sd.offsets;
-    delete[] sd.pieces;
+    delete[] __sd._M_offsets;
+    delete[] __sd._M_pieces;
   }
 } //namespace __gnu_parallel
 
diff --git a/libstdc++-v3/include/parallel/numeric b/libstdc++-v3/include/parallel/numeric
index 33b1411..e355097 100644
--- a/libstdc++-v3/include/parallel/numeric
+++ b/libstdc++-v3/include/parallel/numeric
@@ -51,448 +51,448 @@ namespace std
 namespace __parallel
 {
   // Sequential fallback.
-  template<typename InputIterator, typename T>
-    inline T
-    accumulate(InputIterator begin, InputIterator end, T init, 
+  template<typename _IIter, typename _Tp>
+    inline _Tp
+    accumulate(_IIter __begin, _IIter __end, _Tp __init, 
 	       __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::accumulate(begin, end, init); }
+    { return _GLIBCXX_STD_P::accumulate(__begin, __end, __init); }
 
-  template<typename InputIterator, typename T, typename BinaryOperation>
-    inline T
-    accumulate(InputIterator begin, InputIterator end, T init,
-	       BinaryOperation binary_op, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::accumulate(begin, end, init, binary_op); }
+  template<typename _IIter, typename _Tp, typename _BinaryOperation>
+    inline _Tp
+    accumulate(_IIter __begin, _IIter __end, _Tp __init,
+	       _BinaryOperation __binary_op, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::accumulate(__begin, __end, __init, __binary_op); }
 
   // Sequential fallback for input iterator case.
-  template<typename InputIterator, typename T, typename IteratorTag>
-    inline T
-    accumulate_switch(InputIterator begin, InputIterator end,
-		      T init, IteratorTag) 
-    { return accumulate(begin, end, init, __gnu_parallel::sequential_tag()); }
-
-  template<typename InputIterator, typename T, typename BinaryOperation,
-	   typename IteratorTag>
-    inline T
-    accumulate_switch(InputIterator begin, InputIterator end, T init, 
-		      BinaryOperation binary_op, IteratorTag)
-    { return accumulate(begin, end, init, binary_op, 
+  template<typename _IIter, typename _Tp, typename _IteratorTag>
+    inline _Tp
+    __accumulate_switch(_IIter __begin, _IIter __end,
+		      _Tp __init, _IteratorTag) 
+    { return accumulate(__begin, __end, __init, __gnu_parallel::sequential_tag()); }
+
+  template<typename _IIter, typename _Tp, typename _BinaryOperation,
+	   typename _IteratorTag>
+    inline _Tp
+    __accumulate_switch(_IIter __begin, _IIter __end, _Tp __init, 
+		      _BinaryOperation __binary_op, _IteratorTag)
+    { return accumulate(__begin, __end, __init, __binary_op, 
 			__gnu_parallel::sequential_tag()); }
 
   // Parallel algorithm for random access iterators.
-  template<typename _RandomAccessIterator, typename T,
-	   typename BinaryOperation>
-    T
-    accumulate_switch(_RandomAccessIterator begin, _RandomAccessIterator end, 
-		      T init, BinaryOperation binary_op, 
+  template<typename __RAIter, typename _Tp,
+	   typename _BinaryOperation>
+    _Tp
+    __accumulate_switch(__RAIter __begin, __RAIter __end, 
+		      _Tp __init, _BinaryOperation __binary_op, 
 		      random_access_iterator_tag, 
-		      __gnu_parallel::_Parallelism parallelism_tag  
+		      __gnu_parallel::_Parallelism __parallelism_tag  
 		      = __gnu_parallel::parallel_unbalanced)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(
-	    static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+	    static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
 	    >= __gnu_parallel::_Settings::get().accumulate_minimal_n
-	    && __gnu_parallel::is_parallel(parallelism_tag)))
+	    && __gnu_parallel::__is_parallel(__parallelism_tag)))
 	{
-	  T res = init;
-	  __gnu_parallel::accumulate_selector<_RandomAccessIterator>
-	    my_selector;
+	  _Tp __res = __init;
+	  __gnu_parallel::__accumulate_selector<__RAIter>
+	    __my_selector;
 	  __gnu_parallel::
-	    for_each_template_random_access_ed(begin, end,
-					    __gnu_parallel::nothing(),
-					    my_selector,
+	    for_each_template_random_access_ed(__begin, __end,
+					    __gnu_parallel::_Nothing(),
+					    __my_selector,
 					    __gnu_parallel::
-					    accumulate_binop_reduct
-					    <BinaryOperation>(binary_op),
-					    res, res, -1);
-	  return res;
+					    __accumulate_binop_reduct
+					    <_BinaryOperation>(__binary_op),
+					    __res, __res, -1);
+	  return __res;
 	}
       else
-	return accumulate(begin, end, init, binary_op, 
+	return accumulate(__begin, __end, __init, __binary_op, 
 			  __gnu_parallel::sequential_tag());
     }
 
   // Public interface.
-  template<typename InputIterator, typename T>
-    inline T
-    accumulate(InputIterator begin, InputIterator end, T init, 
-	       __gnu_parallel::_Parallelism parallelism_tag)
+  template<typename _IIter, typename _Tp>
+    inline _Tp
+    accumulate(_IIter __begin, _IIter __end, _Tp __init, 
+	       __gnu_parallel::_Parallelism __parallelism_tag)
     {
-      typedef std::iterator_traits<InputIterator> iterator_traits;
-      typedef typename iterator_traits::value_type value_type;
-      typedef typename iterator_traits::iterator_category iterator_category;
+      typedef std::iterator_traits<_IIter> _IteratorTraits;
+      typedef typename _IteratorTraits::value_type _ValueType;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
 
-      return accumulate_switch(begin, end, init,
-			       __gnu_parallel::plus<T, value_type>(),
-			       iterator_category(), parallelism_tag);
+      return __accumulate_switch(__begin, __end, __init,
+			       __gnu_parallel::_Plus<_Tp, _ValueType>(),
+			       _IteratorCategory(), __parallelism_tag);
     }
 
-  template<typename InputIterator, typename T>
-    inline T
-    accumulate(InputIterator begin, InputIterator end, T init)
+  template<typename _IIter, typename _Tp>
+    inline _Tp
+    accumulate(_IIter __begin, _IIter __end, _Tp __init)
     {
-      typedef std::iterator_traits<InputIterator> iterator_traits;
-      typedef typename iterator_traits::value_type value_type;
-      typedef typename iterator_traits::iterator_category iterator_category;
+      typedef std::iterator_traits<_IIter> _IteratorTraits;
+      typedef typename _IteratorTraits::value_type _ValueType;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
 
-      return accumulate_switch(begin, end, init,
-			       __gnu_parallel::plus<T, value_type>(),
-			       iterator_category());
+      return __accumulate_switch(__begin, __end, __init,
+			       __gnu_parallel::_Plus<_Tp, _ValueType>(),
+			       _IteratorCategory());
     }
 
-  template<typename InputIterator, typename T, typename BinaryOperation>
-    inline T
-    accumulate(InputIterator begin, InputIterator end, T init, 
-	       BinaryOperation binary_op, 
-	       __gnu_parallel::_Parallelism parallelism_tag)
+  template<typename _IIter, typename _Tp, typename _BinaryOperation>
+    inline _Tp
+    accumulate(_IIter __begin, _IIter __end, _Tp __init, 
+	       _BinaryOperation __binary_op, 
+	       __gnu_parallel::_Parallelism __parallelism_tag)
     {
-      typedef iterator_traits<InputIterator> iterator_traits;
-      typedef typename iterator_traits::iterator_category iterator_category;
-      return accumulate_switch(begin, end, init, binary_op, 
-			       iterator_category(), parallelism_tag);
+      typedef iterator_traits<_IIter> _IteratorTraits;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+      return __accumulate_switch(__begin, __end, __init, __binary_op, 
+			       _IteratorCategory(), __parallelism_tag);
     }
 
-  template<typename InputIterator, typename T, typename BinaryOperation>
-    inline T
-    accumulate(InputIterator begin, InputIterator end, T init, 
-	       BinaryOperation binary_op) 
+  template<typename _IIter, typename _Tp, typename _BinaryOperation>
+    inline _Tp
+    accumulate(_IIter __begin, _IIter __end, _Tp __init, 
+	       _BinaryOperation __binary_op) 
     {
-      typedef iterator_traits<InputIterator> iterator_traits;
-      typedef typename iterator_traits::iterator_category iterator_category;
-      return accumulate_switch(begin, end, init, binary_op, 
-			       iterator_category());
+      typedef iterator_traits<_IIter> _IteratorTraits;
+      typedef typename _IteratorTraits::iterator_category _IteratorCategory;
+      return __accumulate_switch(__begin, __end, __init, __binary_op, 
+			       _IteratorCategory());
     }
 
 
   // Sequential fallback.
-  template<typename InputIterator1, typename InputIterator2, typename T>
-    inline T
-    inner_product(InputIterator1 first1, InputIterator1 last1, 
-		  InputIterator2 first2, T init,
+  template<typename _IIter1, typename _IIter2, typename _Tp>
+    inline _Tp
+    inner_product(_IIter1 __first1, _IIter1 __last1, 
+		  _IIter2 __first2, _Tp __init,
 		  __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::inner_product(first1, last1, first2, init); }
+    { return _GLIBCXX_STD_P::inner_product(__first1, __last1, __first2, __init); }
 
-  template<typename InputIterator1, typename InputIterator2, typename T,
+  template<typename _IIter1, typename _IIter2, typename _Tp,
 	   typename BinaryFunction1, typename BinaryFunction2>
-    inline T
-    inner_product(InputIterator1 first1, InputIterator1 last1, 
-		  InputIterator2 first2, T init, BinaryFunction1 binary_op1, 
-		  BinaryFunction2 binary_op2, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::inner_product(first1, last1, first2, init, 
-					   binary_op1, binary_op2); }
+    inline _Tp
+    inner_product(_IIter1 __first1, _IIter1 __last1, 
+		  _IIter2 __first2, _Tp __init, BinaryFunction1 __binary_op1, 
+		  BinaryFunction2 __binary_op2, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::inner_product(__first1, __last1, __first2, __init, 
+					   __binary_op1, __binary_op2); }
 
   // Parallel algorithm for random access iterators.
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
-	   typename T, typename BinaryFunction1, typename BinaryFunction2>
-    T
-    inner_product_switch(RandomAccessIterator1 first1,
-			 RandomAccessIterator1 last1,
-			 RandomAccessIterator2 first2, T init,
-			 BinaryFunction1 binary_op1,
-			 BinaryFunction2 binary_op2,
+  template<typename _RAIter1, typename _RAIter2,
+	   typename _Tp, typename BinaryFunction1, typename BinaryFunction2>
+    _Tp
+    __inner_product_switch(_RAIter1 __first1,
+			 _RAIter1 __last1,
+			 _RAIter2 __first2, _Tp __init,
+			 BinaryFunction1 __binary_op1,
+			 BinaryFunction2 __binary_op2,
 			 random_access_iterator_tag,
 			 random_access_iterator_tag,
-			 __gnu_parallel::_Parallelism parallelism_tag
+			 __gnu_parallel::_Parallelism __parallelism_tag
 			 = __gnu_parallel::parallel_unbalanced)
     {
-      if (_GLIBCXX_PARALLEL_CONDITION((last1 - first1)
+      if (_GLIBCXX_PARALLEL_CONDITION((__last1 - __first1)
 				      >= __gnu_parallel::_Settings::get().
 				      accumulate_minimal_n
 				      && __gnu_parallel::
-				      is_parallel(parallelism_tag)))
+				      __is_parallel(__parallelism_tag)))
 	{
-	  T res = init;
+	  _Tp __res = __init;
 	  __gnu_parallel::
-	    inner_product_selector<RandomAccessIterator1,
-	    RandomAccessIterator2, T> my_selector(first1, first2);
+	    __inner_product_selector<_RAIter1,
+	    _RAIter2, _Tp> __my_selector(__first1, __first2);
 	  __gnu_parallel::
-	    for_each_template_random_access_ed(first1, last1, binary_op2,
-					    my_selector, binary_op1,
-					    res, res, -1);
-	  return res;
+	    for_each_template_random_access_ed(__first1, __last1, __binary_op2,
+					    __my_selector, __binary_op1,
+					    __res, __res, -1);
+	  return __res;
 	}
       else
-	return inner_product(first1, last1, first2, init, 
+	return inner_product(__first1, __last1, __first2, __init, 
 			     __gnu_parallel::sequential_tag());
     }
 
   // No parallelism for input iterators.
-  template<typename InputIterator1, typename InputIterator2, typename T,
+  template<typename _IIter1, typename _IIter2, typename _Tp,
 	   typename BinaryFunction1, typename BinaryFunction2,
-	   typename IteratorTag1, typename IteratorTag2>
-    inline T
-    inner_product_switch(InputIterator1 first1, InputIterator1 last1, 
-			 InputIterator2 first2, T init, 
-			 BinaryFunction1 binary_op1,
-			 BinaryFunction2 binary_op2, 
-			 IteratorTag1, IteratorTag2)
-    { return inner_product(first1, last1, first2, init,
-			   binary_op1, binary_op2,
+	   typename _IteratorTag1, typename _IteratorTag2>
+    inline _Tp
+    __inner_product_switch(_IIter1 __first1, _IIter1 __last1, 
+			 _IIter2 __first2, _Tp __init, 
+			 BinaryFunction1 __binary_op1,
+			 BinaryFunction2 __binary_op2, 
+			 _IteratorTag1, _IteratorTag2)
+    { return inner_product(__first1, __last1, __first2, __init,
+			   __binary_op1, __binary_op2,
 			   __gnu_parallel::sequential_tag()); }
 
-  template<typename InputIterator1, typename InputIterator2, typename T,
+  template<typename _IIter1, typename _IIter2, typename _Tp,
 	   typename BinaryFunction1, typename BinaryFunction2>
-    inline T
-    inner_product(InputIterator1 first1, InputIterator1 last1, 
-		  InputIterator2 first2, T init, BinaryFunction1 binary_op1, 
-		  BinaryFunction2 binary_op2, 
-		  __gnu_parallel::_Parallelism parallelism_tag)
+    inline _Tp
+    inner_product(_IIter1 __first1, _IIter1 __last1, 
+		  _IIter2 __first2, _Tp __init, BinaryFunction1 __binary_op1, 
+		  BinaryFunction2 __binary_op2, 
+		  __gnu_parallel::_Parallelism __parallelism_tag)
     {
-      typedef iterator_traits<InputIterator1> traits1_type;
-      typedef typename traits1_type::iterator_category iterator1_category;
+      typedef iterator_traits<_IIter1> _TraitsType1;
+      typedef typename _TraitsType1::iterator_category _IteratorCategory1;
 
-      typedef iterator_traits<InputIterator2> traits2_type;
-      typedef typename traits2_type::iterator_category iterator2_category;
+      typedef iterator_traits<_IIter2> _TraitsType2;
+      typedef typename _TraitsType2::iterator_category _IteratorCategory2;
 
-      return inner_product_switch(first1, last1, first2, init, binary_op1, 
-				  binary_op2, iterator1_category(), 
-				  iterator2_category(), parallelism_tag);
+      return __inner_product_switch(__first1, __last1, __first2, __init, __binary_op1, 
+				  __binary_op2, _IteratorCategory1(), 
+				  _IteratorCategory2(), __parallelism_tag);
     }
 
-  template<typename InputIterator1, typename InputIterator2, typename T,
+  template<typename _IIter1, typename _IIter2, typename _Tp,
 	   typename BinaryFunction1, typename BinaryFunction2>
-    inline T
-    inner_product(InputIterator1 first1, InputIterator1 last1, 
-		  InputIterator2 first2, T init, BinaryFunction1 binary_op1, 
-		  BinaryFunction2 binary_op2)
+    inline _Tp
+    inner_product(_IIter1 __first1, _IIter1 __last1, 
+		  _IIter2 __first2, _Tp __init, BinaryFunction1 __binary_op1, 
+		  BinaryFunction2 __binary_op2)
     {
-      typedef iterator_traits<InputIterator1> traits1_type;
-      typedef typename traits1_type::iterator_category iterator1_category;
+      typedef iterator_traits<_IIter1> _TraitsType1;
+      typedef typename _TraitsType1::iterator_category _IteratorCategory1;
 
-      typedef iterator_traits<InputIterator2> traits2_type;
-      typedef typename traits2_type::iterator_category iterator2_category;
+      typedef iterator_traits<_IIter2> _TraitsType2;
+      typedef typename _TraitsType2::iterator_category _IteratorCategory2;
 
-      return inner_product_switch(first1, last1, first2, init, binary_op1, 
-				  binary_op2, iterator1_category(),
-				  iterator2_category());
+      return __inner_product_switch(__first1, __last1, __first2, __init, __binary_op1, 
+				  __binary_op2, _IteratorCategory1(),
+				  _IteratorCategory2());
     }
 
-  template<typename InputIterator1, typename InputIterator2, typename T>
-    inline T
-    inner_product(InputIterator1 first1, InputIterator1 last1, 
-		  InputIterator2 first2, T init, 
-		  __gnu_parallel::_Parallelism parallelism_tag)
+  template<typename _IIter1, typename _IIter2, typename _Tp>
+    inline _Tp
+    inner_product(_IIter1 __first1, _IIter1 __last1, 
+		  _IIter2 __first2, _Tp __init, 
+		  __gnu_parallel::_Parallelism __parallelism_tag)
     {
-      typedef iterator_traits<InputIterator1> traits_type1;
+      typedef iterator_traits<_IIter1> traits_type1;
       typedef typename traits_type1::value_type value_type1;
-      typedef iterator_traits<InputIterator2> traits_type2;
+      typedef iterator_traits<_IIter2> traits_type2;
       typedef typename traits_type2::value_type value_type2;
 
       typedef typename
-	__gnu_parallel::multiplies<value_type1, value_type2>::result
-        multiplies_result_type;
-      return inner_product(first1, last1, first2, init,
-                           __gnu_parallel::plus<T, multiplies_result_type>(),
+	__gnu_parallel::_Multiplies<value_type1, value_type2>::__result
+        _MultipliesResultType;
+      return inner_product(__first1, __last1, __first2, __init,
+                           __gnu_parallel::_Plus<_Tp, _MultipliesResultType>(),
                            __gnu_parallel::
-			   multiplies<value_type1, value_type2>(),
-                           parallelism_tag);
+			   _Multiplies<value_type1, value_type2>(),
+                           __parallelism_tag);
     }
 
-  template<typename InputIterator1, typename InputIterator2, typename T>
-    inline T
-    inner_product(InputIterator1 first1, InputIterator1 last1, 
-		  InputIterator2 first2, T init)
+  template<typename _IIter1, typename _IIter2, typename _Tp>
+    inline _Tp
+    inner_product(_IIter1 __first1, _IIter1 __last1, 
+		  _IIter2 __first2, _Tp __init)
     {
-      typedef iterator_traits<InputIterator1> traits_type1;
+      typedef iterator_traits<_IIter1> traits_type1;
       typedef typename traits_type1::value_type value_type1;
-      typedef iterator_traits<InputIterator2> traits_type2;
+      typedef iterator_traits<_IIter2> traits_type2;
       typedef typename traits_type2::value_type value_type2;
 
       typedef typename
-	__gnu_parallel::multiplies<value_type1, value_type2>::result
-        multiplies_result_type;
-      return inner_product(first1, last1, first2, init,
-                           __gnu_parallel::plus<T, multiplies_result_type>(),
+	__gnu_parallel::_Multiplies<value_type1, value_type2>::__result
+        _MultipliesResultType;
+      return inner_product(__first1, __last1, __first2, __init,
+                           __gnu_parallel::_Plus<_Tp, _MultipliesResultType>(),
                            __gnu_parallel::
-			   multiplies<value_type1, value_type2>());
+			   _Multiplies<value_type1, value_type2>());
     }
 
   // Sequential fallback.
-  template<typename InputIterator, typename OutputIterator>
-    inline OutputIterator
-    partial_sum(InputIterator begin, InputIterator end, OutputIterator result,
+  template<typename _IIter, typename _OutputIterator>
+    inline _OutputIterator
+    partial_sum(_IIter __begin, _IIter __end, _OutputIterator __result,
 		__gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::partial_sum(begin, end, result); }
+    { return _GLIBCXX_STD_P::partial_sum(__begin, __end, __result); }
 
   // Sequential fallback.
-  template<typename InputIterator, typename OutputIterator,
-	   typename BinaryOperation>
-    inline OutputIterator
-    partial_sum(InputIterator begin, InputIterator end, OutputIterator result,
-		BinaryOperation bin_op, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::partial_sum(begin, end, result, bin_op); }
+  template<typename _IIter, typename _OutputIterator,
+	   typename _BinaryOperation>
+    inline _OutputIterator
+    partial_sum(_IIter __begin, _IIter __end, _OutputIterator __result,
+		_BinaryOperation __bin_op, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::partial_sum(__begin, __end, __result, __bin_op); }
 
   // Sequential fallback for input iterator case.
-  template<typename InputIterator, typename OutputIterator,
-	   typename BinaryOperation, typename IteratorTag1,
-	   typename IteratorTag2>
-    inline OutputIterator
-    partial_sum_switch(InputIterator begin, InputIterator end,
-		       OutputIterator result, BinaryOperation bin_op,
-		       IteratorTag1, IteratorTag2)
-    { return _GLIBCXX_STD_P::partial_sum(begin, end, result, bin_op); }
+  template<typename _IIter, typename _OutputIterator,
+	   typename _BinaryOperation, typename _IteratorTag1,
+	   typename _IteratorTag2>
+    inline _OutputIterator
+    __partial_sum_switch(_IIter __begin, _IIter __end,
+		       _OutputIterator __result, _BinaryOperation __bin_op,
+		       _IteratorTag1, _IteratorTag2)
+    { return _GLIBCXX_STD_P::partial_sum(__begin, __end, __result, __bin_op); }
 
   // Parallel algorithm for random access iterators.
-  template<typename InputIterator, typename OutputIterator,
-	   typename BinaryOperation>
-    OutputIterator
-    partial_sum_switch(InputIterator begin, InputIterator end,
-		       OutputIterator result, BinaryOperation bin_op,
+  template<typename _IIter, typename _OutputIterator,
+	   typename _BinaryOperation>
+    _OutputIterator
+    __partial_sum_switch(_IIter __begin, _IIter __end,
+		       _OutputIterator __result, _BinaryOperation __bin_op,
 		       random_access_iterator_tag, random_access_iterator_tag)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(
-	    static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+	    static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
 	    >= __gnu_parallel::_Settings::get().partial_sum_minimal_n))
-	return __gnu_parallel::parallel_partial_sum(begin, end,
-						    result, bin_op);
+	return __gnu_parallel::__parallel_partial_sum(__begin, __end,
+						    __result, __bin_op);
       else
-	return partial_sum(begin, end, result, bin_op,
+	return partial_sum(__begin, __end, __result, __bin_op,
 			   __gnu_parallel::sequential_tag());
     }
 
   // Public interface.
-  template<typename InputIterator, typename OutputIterator>
-    inline OutputIterator
-    partial_sum(InputIterator begin, InputIterator end, OutputIterator result)
+  template<typename _IIter, typename _OutputIterator>
+    inline _OutputIterator
+    partial_sum(_IIter __begin, _IIter __end, _OutputIterator __result)
     {
-      typedef typename iterator_traits<InputIterator>::value_type value_type;
-      return partial_sum(begin, end, result, std::plus<value_type>());
+      typedef typename iterator_traits<_IIter>::value_type _ValueType;
+      return partial_sum(__begin, __end, __result, std::plus<_ValueType>());
     }
 
   // Public interface
-  template<typename InputIterator, typename OutputIterator,
-	   typename BinaryOperation>
-    inline OutputIterator
-    partial_sum(InputIterator begin, InputIterator end, OutputIterator result,
-		BinaryOperation binary_op)
+  template<typename _IIter, typename _OutputIterator,
+	   typename _BinaryOperation>
+    inline _OutputIterator
+    partial_sum(_IIter __begin, _IIter __end, _OutputIterator __result,
+		_BinaryOperation __binary_op)
     {
-      typedef iterator_traits<InputIterator> traitsi_type;
-      typedef typename traitsi_type::iterator_category iteratori_category;
+      typedef iterator_traits<_IIter> traitsi_type;
+      typedef typename traitsi_type::iterator_category _IIteratorCategory;
 
-      typedef iterator_traits<OutputIterator> traitso_type;
-      typedef typename traitso_type::iterator_category iteratoro_category;
+      typedef iterator_traits<_OutputIterator> _OTraitsType;
+      typedef typename _OTraitsType::iterator_category _OIterCategory;
 
-      return partial_sum_switch(begin, end, result, binary_op,
-				iteratori_category(), iteratoro_category());
+      return __partial_sum_switch(__begin, __end, __result, __binary_op,
+				_IIteratorCategory(), _OIterCategory());
     }
 
   // Sequential fallback.
-  template<typename InputIterator, typename OutputIterator>
-    inline OutputIterator
-    adjacent_difference(InputIterator begin, InputIterator end,
-			OutputIterator result, __gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::adjacent_difference(begin, end, result); }
+  template<typename _IIter, typename _OutputIterator>
+    inline _OutputIterator
+    adjacent_difference(_IIter __begin, _IIter __end,
+			_OutputIterator __result, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::adjacent_difference(__begin, __end, __result); }
 
   // Sequential fallback.
-  template<typename InputIterator, typename OutputIterator,
-	   typename BinaryOperation>
-    inline OutputIterator
-    adjacent_difference(InputIterator begin, InputIterator end,
-			OutputIterator result, BinaryOperation bin_op,
+  template<typename _IIter, typename _OutputIterator,
+	   typename _BinaryOperation>
+    inline _OutputIterator
+    adjacent_difference(_IIter __begin, _IIter __end,
+			_OutputIterator __result, _BinaryOperation __bin_op,
 			__gnu_parallel::sequential_tag)
-    { return _GLIBCXX_STD_P::adjacent_difference(begin, end, result, bin_op); }
+    { return _GLIBCXX_STD_P::adjacent_difference(__begin, __end, __result, __bin_op); }
 
   // Sequential fallback for input iterator case.
-  template<typename InputIterator, typename OutputIterator,
-	   typename BinaryOperation, typename IteratorTag1,
-	   typename IteratorTag2>
-    inline OutputIterator
-    adjacent_difference_switch(InputIterator begin, InputIterator end,
-			       OutputIterator result, BinaryOperation bin_op,
-			     IteratorTag1, IteratorTag2)
-    { return adjacent_difference(begin, end, result, bin_op,  
+  template<typename _IIter, typename _OutputIterator,
+	   typename _BinaryOperation, typename _IteratorTag1,
+	   typename _IteratorTag2>
+    inline _OutputIterator
+    __adjacent_difference_switch(_IIter __begin, _IIter __end,
+			       _OutputIterator __result, _BinaryOperation __bin_op,
+			     _IteratorTag1, _IteratorTag2)
+    { return adjacent_difference(__begin, __end, __result, __bin_op,  
 				 __gnu_parallel::sequential_tag()); }
 
   // Parallel algorithm for random access iterators.
-  template<typename InputIterator, typename OutputIterator,
-	   typename BinaryOperation>
-    OutputIterator
-    adjacent_difference_switch(InputIterator begin, InputIterator end,
-			       OutputIterator result, BinaryOperation bin_op,
+  template<typename _IIter, typename _OutputIterator,
+	   typename _BinaryOperation>
+    _OutputIterator
+    __adjacent_difference_switch(_IIter __begin, _IIter __end,
+			       _OutputIterator __result, _BinaryOperation __bin_op,
 			       random_access_iterator_tag, 
 			       random_access_iterator_tag,
-			       __gnu_parallel::_Parallelism parallelism_tag
+			       __gnu_parallel::_Parallelism __parallelism_tag
 			       = __gnu_parallel::parallel_balanced)
     {
       if (_GLIBCXX_PARALLEL_CONDITION(
-	    static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+	    static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin)
 	    >= __gnu_parallel::_Settings::get().adjacent_difference_minimal_n
-	    && __gnu_parallel::is_parallel(parallelism_tag)))
+	    && __gnu_parallel::__is_parallel(__parallelism_tag)))
 	{
-	  bool dummy = true;
-	  typedef __gnu_parallel::iterator_pair<InputIterator, OutputIterator,
-	    random_access_iterator_tag> ip;
-	  *result = *begin;
-	  ip begin_pair(begin + 1, result + 1),
-	    end_pair(end, result + (end - begin));
-	  __gnu_parallel::adjacent_difference_selector<ip> functionality;
+	  bool __dummy = true;
+	  typedef __gnu_parallel::_IteratorPair<_IIter, _OutputIterator,
+	    random_access_iterator_tag> _ItTrip;
+	  *__result = *__begin;
+	  _ItTrip begin_pair(__begin + 1, __result + 1),
+	    end_pair(__end, __result + (__end - __begin));
+	  __gnu_parallel::__adjacent_difference_selector<_ItTrip> __functionality;
 	  __gnu_parallel::
-	    for_each_template_random_access_ed(begin_pair, end_pair, bin_op,
-					    functionality,
-					    __gnu_parallel::dummy_reduct(),
-					    dummy, dummy, -1);
-	  return functionality.finish_iterator;
+	    for_each_template_random_access_ed(begin_pair, end_pair, __bin_op,
+					    __functionality,
+					    __gnu_parallel::_DummyReduct(),
+					    __dummy, __dummy, -1);
+	  return __functionality.finish_iterator;
 	}
       else
-	return adjacent_difference(begin, end, result, bin_op, 
+	return adjacent_difference(__begin, __end, __result, __bin_op, 
 				   __gnu_parallel::sequential_tag());
     }
 
   // Public interface.
-  template<typename InputIterator, typename OutputIterator>
-    inline OutputIterator
-    adjacent_difference(InputIterator begin, InputIterator end,
-			OutputIterator result,
-			__gnu_parallel::_Parallelism parallelism_tag)
+  template<typename _IIter, typename _OutputIterator>
+    inline _OutputIterator
+    adjacent_difference(_IIter __begin, _IIter __end,
+			_OutputIterator __result,
+			__gnu_parallel::_Parallelism __parallelism_tag)
     {
-      typedef iterator_traits<InputIterator> traits_type;
-      typedef typename traits_type::value_type value_type;
-      return adjacent_difference(begin, end, result, std::minus<value_type>(),
-				 parallelism_tag);
+      typedef iterator_traits<_IIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      return adjacent_difference(__begin, __end, __result, std::minus<_ValueType>(),
+				 __parallelism_tag);
     }
 
-  template<typename InputIterator, typename OutputIterator>
-    inline OutputIterator
-    adjacent_difference(InputIterator begin, InputIterator end,
-			OutputIterator result)
+  template<typename _IIter, typename _OutputIterator>
+    inline _OutputIterator
+    adjacent_difference(_IIter __begin, _IIter __end,
+			_OutputIterator __result)
     {
-      typedef iterator_traits<InputIterator> traits_type;
-      typedef typename traits_type::value_type value_type;
-      return adjacent_difference(begin, end, result, std::minus<value_type>());
+      typedef iterator_traits<_IIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      return adjacent_difference(__begin, __end, __result, std::minus<_ValueType>());
     }
 
-  template<typename InputIterator, typename OutputIterator,
-	   typename BinaryOperation>
-    inline OutputIterator
-    adjacent_difference(InputIterator begin, InputIterator end,
-			OutputIterator result, BinaryOperation binary_op,
-			__gnu_parallel::_Parallelism parallelism_tag)
+  template<typename _IIter, typename _OutputIterator,
+	   typename _BinaryOperation>
+    inline _OutputIterator
+    adjacent_difference(_IIter __begin, _IIter __end,
+			_OutputIterator __result, _BinaryOperation __binary_op,
+			__gnu_parallel::_Parallelism __parallelism_tag)
     {
-      typedef iterator_traits<InputIterator> traitsi_type;
-      typedef typename traitsi_type::iterator_category iteratori_category;
+      typedef iterator_traits<_IIter> traitsi_type;
+      typedef typename traitsi_type::iterator_category _IIteratorCategory;
 
-      typedef iterator_traits<OutputIterator> traitso_type;
-      typedef typename traitso_type::iterator_category iteratoro_category;
+      typedef iterator_traits<_OutputIterator> _OTraitsType;
+      typedef typename _OTraitsType::iterator_category _OIterCategory;
 
-      return adjacent_difference_switch(begin, end, result, binary_op,
-					iteratori_category(), 
-					iteratoro_category(), parallelism_tag);
+      return __adjacent_difference_switch(__begin, __end, __result, __binary_op,
+					_IIteratorCategory(), 
+					_OIterCategory(), __parallelism_tag);
     }
 
-  template<typename InputIterator, typename OutputIterator,
-	   typename BinaryOperation>
-    inline OutputIterator
-    adjacent_difference(InputIterator begin, InputIterator end,
-			OutputIterator result, BinaryOperation binary_op)
+  template<typename _IIter, typename _OutputIterator,
+	   typename _BinaryOperation>
+    inline _OutputIterator
+    adjacent_difference(_IIter __begin, _IIter __end,
+			_OutputIterator __result, _BinaryOperation __binary_op)
     {
-      typedef iterator_traits<InputIterator> traitsi_type;
-      typedef typename traitsi_type::iterator_category iteratori_category;
+      typedef iterator_traits<_IIter> traitsi_type;
+      typedef typename traitsi_type::iterator_category _IIteratorCategory;
 
-      typedef iterator_traits<OutputIterator> traitso_type;
-      typedef typename traitso_type::iterator_category iteratoro_category;
+      typedef iterator_traits<_OutputIterator> _OTraitsType;
+      typedef typename _OTraitsType::iterator_category _OIterCategory;
 
-      return adjacent_difference_switch(begin, end, result, binary_op,
-					iteratori_category(), 
-					iteratoro_category());
+      return __adjacent_difference_switch(__begin, __end, __result, __binary_op,
+					_IIteratorCategory(), 
+					_OIterCategory());
     }
 } // end namespace
 } // end namespace
diff --git a/libstdc++-v3/include/parallel/numericfwd.h b/libstdc++-v3/include/parallel/numericfwd.h
index af2d041..754d5ba 100644
--- a/libstdc++-v3/include/parallel/numericfwd.h
+++ b/libstdc++-v3/include/parallel/numericfwd.h
@@ -52,7 +52,7 @@ namespace __parallel
 
   template<typename _IIter, typename _Tp, typename _Tag>
     _Tp
-    accumulate_switch(_IIter, _IIter, _Tp, _Tag);
+    __accumulate_switch(_IIter, _IIter, _Tp, _Tag);
 
   template<typename _IIter, typename _Tp, typename _BinaryOper>
     _Tp
@@ -71,13 +71,13 @@ namespace __parallel
   template<typename _IIter, typename _Tp, typename _BinaryOper,
 	   typename _Tag>
     _Tp
-    accumulate_switch(_IIter, _IIter, _Tp, _BinaryOper, _Tag);
+    __accumulate_switch(_IIter, _IIter, _Tp, _BinaryOper, _Tag);
 
   template<typename _RAIter, typename _Tp, typename _BinaryOper>
     _Tp
-    accumulate_switch(_RAIter, _RAIter, _Tp, _BinaryOper,
+    __accumulate_switch(_RAIter, _RAIter, _Tp, _BinaryOper,
 		      random_access_iterator_tag,
-		      __gnu_parallel::_Parallelism parallelism
+		      __gnu_parallel::_Parallelism __parallelism
 		      = __gnu_parallel::parallel_unbalanced);
 
   template<typename _IIter, typename _OIter>
@@ -111,15 +111,15 @@ namespace __parallel
   template<typename _IIter, typename _OIter, typename _BinaryOper,
 	   typename _Tag1, typename _Tag2>
     _OIter
-    adjacent_difference_switch(_IIter, _IIter, _OIter, _BinaryOper,
+    __adjacent_difference_switch(_IIter, _IIter, _OIter, _BinaryOper,
 			       _Tag1, _Tag2);
 
   template<typename _IIter, typename _OIter, typename _BinaryOper>
     _OIter
-    adjacent_difference_switch(_IIter, _IIter, _OIter, _BinaryOper, 
+    __adjacent_difference_switch(_IIter, _IIter, _OIter, _BinaryOper, 
 			       random_access_iterator_tag, 
 			       random_access_iterator_tag, 
-			       __gnu_parallel::_Parallelism parallelism
+			       __gnu_parallel::_Parallelism __parallelism
 			       = __gnu_parallel::parallel_unbalanced);
 
   template<typename _IIter1, typename _IIter2, typename _Tp>
@@ -157,7 +157,7 @@ namespace __parallel
   template<typename _RAIter1, typename _RAIter2, typename _Tp,
 	   typename BinaryFunction1, typename BinaryFunction2>
     _Tp
-    inner_product_switch(_RAIter1, _RAIter1, _RAIter2, _Tp, BinaryFunction1, 
+    __inner_product_switch(_RAIter1, _RAIter1, _RAIter2, _Tp, BinaryFunction1, 
 			 BinaryFunction2, random_access_iterator_tag, 
 			 random_access_iterator_tag, 
 			 __gnu_parallel::_Parallelism
@@ -167,7 +167,7 @@ namespace __parallel
 	   typename _BinaryFunction1, typename _BinaryFunction2,
 	   typename _Tag1, typename _Tag2>
     _Tp
-    inner_product_switch(_IIter1, _IIter1, _IIter2, _Tp, _BinaryFunction1, 
+    __inner_product_switch(_IIter1, _IIter1, _IIter2, _Tp, _BinaryFunction1, 
 			 _BinaryFunction2, _Tag1, _Tag2);
 
 
@@ -182,7 +182,7 @@ namespace __parallel
 
   template<typename _IIter, typename _OIter>
     _OIter
-    partial_sum(_IIter, _IIter, _OIter result);
+    partial_sum(_IIter, _IIter, _OIter __result);
 
   template<typename _IIter, typename _OIter, typename _BinaryOper>
     _OIter
@@ -191,11 +191,11 @@ namespace __parallel
   template<typename _IIter, typename _OIter, typename _BinaryOper,
 	   typename _Tag1, typename _Tag2>
     _OIter
-    partial_sum_switch(_IIter, _IIter, _OIter, _BinaryOper, _Tag1, _Tag2);
+    __partial_sum_switch(_IIter, _IIter, _OIter, _BinaryOper, _Tag1, _Tag2);
 
   template<typename _IIter, typename _OIter, typename _BinaryOper>
     _OIter
-    partial_sum_switch(_IIter, _IIter, _OIter, _BinaryOper,
+    __partial_sum_switch(_IIter, _IIter, _OIter, _BinaryOper,
 		       random_access_iterator_tag, random_access_iterator_tag);
 } // end namespace
 } // end namespace
diff --git a/libstdc++-v3/include/parallel/omp_loop.h b/libstdc++-v3/include/parallel/omp_loop.h
index 66f6d44..55191d4 100644
--- a/libstdc++-v3/include/parallel/omp_loop.h
+++ b/libstdc++-v3/include/parallel/omp_loop.h
@@ -44,73 +44,73 @@ namespace __gnu_parallel
 /** @brief Embarrassingly parallel algorithm for random access
   * iterators, using an OpenMP for loop.
   *
-  *  @param begin Begin iterator of element sequence.
-  *  @param end End iterator of element sequence.
-  *  @param o User-supplied functor (comparator, predicate, adding
+  *  @param __begin Begin iterator of element __sequence.
+  *  @param __end End iterator of element __sequence.
+  *  @param __o User-supplied functor (comparator, predicate, adding
   *  functor, etc.).
-  *  @param f Functor to "process" an element with op (depends on
+  *  @param __f Functor to "process" an element with __op (depends on
   *  desired functionality, e. g. for std::for_each(), ...).
-  *  @param r Functor to "add" a single result to the already
-  *  processed elements (depends on functionality).
-  *  @param base Base value for reduction.
-  *  @param output Pointer to position where final result is written to
-  *  @param bound Maximum number of elements processed (e. g. for
+  *  @param __r Functor to "add" a single __result to the already
+  *  processed __elements (depends on functionality).
+  *  @param __base Base value for reduction.
+  *  @param __output Pointer to position where final result is written to
+  *  @param __bound Maximum number of elements processed (e. g. for
   *  std::count_n()).
   *  @return User-supplied functor (that may contain a part of the result).
   */
-template<typename RandomAccessIterator,
-	 typename Op,
-	 typename Fu,
-	 typename Red,
-	 typename Result>
-  Op
-  for_each_template_random_access_omp_loop(RandomAccessIterator begin,
-					   RandomAccessIterator end,
-					   Op o, Fu& f, Red r, Result base,
-					   Result& output,
+template<typename _RAIter,
+	 typename _Op,
+	 typename _Fu,
+	 typename _Red,
+	 typename _Result>
+  _Op
+  for_each_template_random_access_omp_loop(_RAIter __begin,
+					   _RAIter __end,
+					   _Op __o, _Fu& __f, _Red __r, _Result __base,
+					   _Result& __output,
 					   typename std::iterator_traits
-					   <RandomAccessIterator>::
-					   difference_type bound)
+					   <_RAIter>::
+					   difference_type __bound)
   {
     typedef typename
-        std::iterator_traits<RandomAccessIterator>::difference_type
-        difference_type;
+        std::iterator_traits<_RAIter>::difference_type
+        _DifferenceType;
 
-    difference_type length = end - begin;
-    thread_index_t num_threads =
-      __gnu_parallel::min<difference_type>(get_max_threads(), length);
+    _DifferenceType __length = __end - __begin;
+    _ThreadIndex __num_threads =
+      __gnu_parallel::min<_DifferenceType>(__get_max_threads(), __length);
 
-    Result *thread_results;
+    _Result *__thread_results;
 
-#   pragma omp parallel num_threads(num_threads)
+#   pragma omp parallel num_threads(__num_threads)
       {
 #       pragma omp single
           {
-            num_threads = omp_get_num_threads();
-            thread_results = new Result[num_threads];
+            __num_threads = omp_get_num_threads();
+            __thread_results = new _Result[__num_threads];
 
-            for (thread_index_t i = 0; i < num_threads; ++i)
-              thread_results[i] = Result();
+            for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)
+              __thread_results[__i] = _Result();
           }
 
-        thread_index_t iam = omp_get_thread_num();
+        _ThreadIndex __iam = omp_get_thread_num();
 
 #      pragma omp for schedule(dynamic, _Settings::get().workstealing_chunk_size)
-        for (difference_type pos = 0; pos < length; ++pos)
-          thread_results[iam] =
-              r(thread_results[iam], f(o, begin+pos));
+        for (_DifferenceType __pos = 0; __pos < __length; ++__pos)
+          __thread_results[__iam] =
+              __r(__thread_results[__iam], __f(__o, __begin+__pos));
       } //parallel
 
-    for (thread_index_t i = 0; i < num_threads; ++i)
-        output = r(output, thread_results[i]);
+    for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)
+        __output = __r(__output, __thread_results[__i]);
 
-    delete [] thread_results;
+    delete [] __thread_results;
 
     // Points to last element processed (needed as return value for
     // some algorithms like transform).
-    f.finish_iterator = begin + length;
+    __f.finish_iterator = __begin + __length;
 
-    return o;
+    return __o;
   }
 
 } // end namespace
diff --git a/libstdc++-v3/include/parallel/omp_loop_static.h b/libstdc++-v3/include/parallel/omp_loop_static.h
index 5236183..5244d11 100644
--- a/libstdc++-v3/include/parallel/omp_loop_static.h
+++ b/libstdc++-v3/include/parallel/omp_loop_static.h
@@ -44,72 +44,72 @@ namespace __gnu_parallel
   /** @brief Embarrassingly parallel algorithm for random access
    * iterators, using an OpenMP for loop with static scheduling.
    *
-   *  @param begin Begin iterator of element sequence.
-   *  @param end End iterator of element sequence.
-   *  @param o User-supplied functor (comparator, predicate, adding
+   *  @param __begin Begin iterator of element __sequence.
+   *  @param __end End iterator of element __sequence.
+   *  @param __o User-supplied functor (comparator, predicate, adding
    *  functor, ...).
-   *  @param f Functor to "process" an element with op (depends on
+   *  @param __f Functor to "process" an element with __op (depends on
    *  desired functionality, e. g. for std::for_each(), ...).
-   *  @param r Functor to "add" a single result to the already processed
-   *  elements (depends on functionality).
-   *  @param base Base value for reduction.
-   *  @param output Pointer to position where final result is written to
-   *  @param bound Maximum number of elements processed (e. g. for
+   *  @param __r Functor to "add" a single __result to the already processed
+   *  __elements (depends on functionality).
+   *  @param __base Base value for reduction.
+   *  @param __output Pointer to position where final result is written to
+   *  @param __bound Maximum number of elements processed (e. g. for
    *  std::count_n()).
    *  @return User-supplied functor (that may contain a part of the result).
    */
-template<typename RandomAccessIterator,
-	 typename Op,
-	 typename Fu,
-	 typename Red,
-	 typename Result>
-  Op
-  for_each_template_random_access_omp_loop_static(RandomAccessIterator begin,
-						  RandomAccessIterator end,
-						  Op o, Fu& f, Red r,
-						  Result base, Result& output,
+template<typename _RAIter,
+	 typename _Op,
+	 typename _Fu,
+	 typename _Red,
+	 typename _Result>
+  _Op
+  for_each_template_random_access_omp_loop_static(_RAIter __begin,
+						  _RAIter __end,
+						  _Op __o, _Fu& __f, _Red __r,
+						  _Result __base, _Result& __output,
 						  typename std::iterator_traits
-						  <RandomAccessIterator>::
-						  difference_type bound)
+						  <_RAIter>::
+						  difference_type __bound)
   {
     typedef typename
-      std::iterator_traits<RandomAccessIterator>::difference_type
-      difference_type;
+      std::iterator_traits<_RAIter>::difference_type
+      _DifferenceType;
 
-    difference_type length = end - begin;
-    thread_index_t num_threads =
-      std::min<difference_type>(get_max_threads(), length);
+    _DifferenceType __length = __end - __begin;
+    _ThreadIndex __num_threads =
+      std::min<_DifferenceType>(__get_max_threads(), __length);
 
-    Result *thread_results;
+    _Result *__thread_results;
 
-#   pragma omp parallel num_threads(num_threads)
+#   pragma omp parallel num_threads(__num_threads)
       {
 #       pragma omp single
           {
-            num_threads = omp_get_num_threads();
-            thread_results = new Result[num_threads];
+            __num_threads = omp_get_num_threads();
+            __thread_results = new _Result[__num_threads];
 
-            for (thread_index_t i = 0; i < num_threads; ++i)
-              thread_results[i] = Result();
+            for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)
+              __thread_results[__i] = _Result();
           }
 
-        thread_index_t iam = omp_get_thread_num();
+        _ThreadIndex __iam = omp_get_thread_num();
 
 #       pragma omp for schedule(static, _Settings::get().workstealing_chunk_size)
-        for (difference_type pos = 0; pos < length; ++pos)
-          thread_results[iam] = r(thread_results[iam], f(o, begin+pos));
+        for (_DifferenceType __pos = 0; __pos < __length; ++__pos)
+          __thread_results[__iam] = __r(__thread_results[__iam], __f(__o, __begin+__pos));
       } //parallel
 
-    for (thread_index_t i = 0; i < num_threads; ++i)
-      output = r(output, thread_results[i]);
+    for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)
+      __output = __r(__output, __thread_results[__i]);
 
-    delete [] thread_results;
+    delete [] __thread_results;
 
     // Points to last element processed (needed as return value for
     // some algorithms like transform).
-    f.finish_iterator = begin + length;
+    __f.finish_iterator = __begin + __length;
 
-    return o;
+    return __o;
   }
 
 } // end namespace
diff --git a/libstdc++-v3/include/parallel/par_loop.h b/libstdc++-v3/include/parallel/par_loop.h
index be61d4c..0b5e47a 100644
--- a/libstdc++-v3/include/parallel/par_loop.h
+++ b/libstdc++-v3/include/parallel/par_loop.h
@@ -45,89 +45,89 @@ namespace __gnu_parallel
   * iterators, using hand-crafted parallelization by equal splitting
   * the work.
   *
-  *  @param begin Begin iterator of element sequence.
-  *  @param end End iterator of element sequence.
-  *  @param o User-supplied functor (comparator, predicate, adding
+  *  @param __begin Begin iterator of element __sequence.
+  *  @param __end End iterator of element __sequence.
+  *  @param __o User-supplied functor (comparator, predicate, adding
   *  functor, ...)
-  *  @param f Functor to "process" an element with op (depends on
+  *  @param __f Functor to "process" an element with __op (depends on
   *  desired functionality, e. g. for std::for_each(), ...).
-  *  @param r Functor to "add" a single result to the already
-  *  processed elements (depends on functionality).
-  *  @param base Base value for reduction.
-  *  @param output Pointer to position where final result is written to
-  *  @param bound Maximum number of elements processed (e. g. for
+  *  @param __r Functor to "add" a single __result to the already
+  *  processed __elements (depends on functionality).
+  *  @param __base Base value for reduction.
+  *  @param __output Pointer to position where final result is written to
+  *  @param __bound Maximum number of elements processed (e. g. for
   *  std::count_n()).
   *  @return User-supplied functor (that may contain a part of the result).
   */
-template<typename RandomAccessIterator,
-	 typename Op,
-	 typename Fu,
-	 typename Red,
-	 typename Result>
-  Op
-  for_each_template_random_access_ed(RandomAccessIterator begin,
-				     RandomAccessIterator end,
-				     Op o, Fu& f, Red r, Result base,
-				     Result& output,
+template<typename _RAIter,
+	 typename _Op,
+	 typename _Fu,
+	 typename _Red,
+	 typename _Result>
+  _Op
+  for_each_template_random_access_ed(_RAIter __begin,
+				     _RAIter __end,
+				     _Op __o, _Fu& __f, _Red __r, _Result __base,
+				     _Result& __output,
 				     typename std::iterator_traits
-				     <RandomAccessIterator>::
-				     difference_type bound)
+				     <_RAIter>::
+				     difference_type __bound)
   {
-    typedef std::iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::difference_type difference_type;
-    const difference_type length = end - begin;
-    Result *thread_results;
-    bool* constructed;
+    typedef std::iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
+    const _DifferenceType __length = __end - __begin;
+    _Result *__thread_results;
+    bool* __constructed;
 
-    thread_index_t num_threads =
-      __gnu_parallel::min<difference_type>(get_max_threads(), length);
+    _ThreadIndex __num_threads =
+      __gnu_parallel::min<_DifferenceType>(__get_max_threads(), __length);
 
-#   pragma omp parallel num_threads(num_threads)
+#   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)));
-            constructed = new bool[num_threads];
+            __num_threads = omp_get_num_threads();
+            __thread_results = static_cast<_Result*>(
+                                ::operator new(__num_threads * sizeof(_Result)));
+            __constructed = new bool[__num_threads];
           }
 
-        thread_index_t iam = omp_get_thread_num();
+        _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)));
 
-        difference_type
-            start = equally_split_point(length, num_threads, iam),
-            stop = equally_split_point(length, num_threads, iam + 1);
+        _DifferenceType
+            __start = equally_split_point(__length, __num_threads, __iam),
+            __stop = equally_split_point(__length, __num_threads, __iam + 1);
 
-        if (start < stop)
+        if (__start < __stop)
           {
-            new(reduct) Result(f(o, begin + start));
-            ++start;
-            constructed[iam] = true;
+            new(__reduct) _Result(__f(__o, __begin + __start));
+            ++__start;
+            __constructed[__iam] = true;
           }
         else
-          constructed[iam] = false;
+          __constructed[__iam] = false;
 
-        for (; start < stop; ++start)
-          *reduct = r(*reduct, f(o, begin + start));
+        for (; __start < __stop; ++__start)
+          *__reduct = __r(*__reduct, __f(__o, __begin + __start));
 
-        thread_results[iam] = *reduct;
+        __thread_results[__iam] = *__reduct;
       } //parallel
 
-    for (thread_index_t i = 0; i < num_threads; ++i)
-        if (constructed[i])
-            output = r(output, thread_results[i]);
+    for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)
+        if (__constructed[__i])
+            __output = __r(__output, __thread_results[__i]);
 
     // Points to last element processed (needed as return value for
     // some algorithms like transform).
-    f.finish_iterator = begin + length;
+    __f.finish_iterator = __begin + __length;
 
-    delete[] thread_results;
-    delete[] constructed;
+    delete[] __thread_results;
+    delete[] __constructed;
 
-    return o;
+    return __o;
   }
 
 } // end namespace
diff --git a/libstdc++-v3/include/parallel/partial_sum.h b/libstdc++-v3/include/parallel/partial_sum.h
index 9263093..40f6299 100644
--- a/libstdc++-v3/include/parallel/partial_sum.h
+++ b/libstdc++-v3/include/parallel/partial_sum.h
@@ -23,8 +23,8 @@
 // <http://www.gnu.org/licenses/>.
 
 /** @file parallel/partial_sum.h
- *  @brief Parallel implementation of std::partial_sum(), i. e. prefix
- *  sums.
+ *  @brief Parallel implementation of std::partial_sum(), i.e. prefix
+*  sums.
  *  This file is a GNU parallel extension to the Standard C++ Library.
  */
 
@@ -44,175 +44,175 @@ namespace __gnu_parallel
   // Problem: there is no 0-element given.
 
 /** @brief Base case prefix sum routine.
-  *  @param begin Begin iterator of input sequence.
-  *  @param end End iterator of input sequence.
-  *  @param result Begin iterator of output sequence.
-  *  @param bin_op Associative binary function.
-  *  @param value Start value. Must be passed since the neutral
+  *  @param __begin Begin iterator of input sequence.
+  *  @param __end End iterator of input sequence.
+  *  @param __result Begin iterator of output sequence.
+  *  @param __bin_op Associative binary function.
+  *  @param __value Start value. Must be passed since the neutral
   *  element is unknown in general.
   *  @return End iterator of output sequence. */
-template<typename InputIterator,
-	 typename OutputIterator,
-	 typename BinaryOperation>
-  OutputIterator
-  parallel_partial_sum_basecase(InputIterator begin, InputIterator end,
-				OutputIterator result, BinaryOperation bin_op,
+template<typename _IIter,
+	 typename _OutputIterator,
+	 typename _BinaryOperation>
+  _OutputIterator
+  __parallel_partial_sum_basecase(_IIter __begin, _IIter __end,
+				_OutputIterator __result, _BinaryOperation __bin_op,
 				typename std::iterator_traits
-				<InputIterator>::value_type value)
+				<_IIter>::value_type __value)
   {
-    if (begin == end)
-      return result;
+    if (__begin == __end)
+      return __result;
 
-    while (begin != end)
+    while (__begin != __end)
       {
-        value = bin_op(value, *begin);
-        *result = value;
-        ++result;
-        ++begin;
+        __value = __bin_op(__value, *__begin);
+        *__result = __value;
+        ++__result;
+        ++__begin;
       }
-    return result;
+    return __result;
   }
 
 /** @brief Parallel partial sum implementation, two-phase approach,
     no recursion.
-    *  @param begin Begin iterator of input sequence.
-    *  @param end End iterator of input sequence.
-    *  @param result Begin iterator of output sequence.
-    *  @param bin_op Associative binary function.
-    *  @param n Length of sequence.
-    *  @param num_threads Number of threads to use.
+    *  @param __begin Begin iterator of input sequence.
+    *  @param __end End iterator of input sequence.
+    *  @param __result Begin iterator of output sequence.
+    *  @param __bin_op Associative binary function.
+    *  @param __n Length of sequence.
+    *  @param __num_threads Number of threads to use.
     *  @return End iterator of output sequence.
     */
-template<typename InputIterator,
-	 typename OutputIterator,
-	 typename BinaryOperation>
-  OutputIterator
-  parallel_partial_sum_linear(InputIterator begin, InputIterator end,
-			      OutputIterator result, BinaryOperation bin_op,
+template<typename _IIter,
+	 typename _OutputIterator,
+	 typename _BinaryOperation>
+  _OutputIterator
+  __parallel_partial_sum_linear(_IIter __begin, _IIter __end,
+			      _OutputIterator __result, _BinaryOperation __bin_op,
 			      typename std::iterator_traits
-			      <InputIterator>::difference_type n)
+			      <_IIter>::difference_type __n)
   {
-    typedef std::iterator_traits<InputIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    typedef typename traits_type::difference_type difference_type;
+    typedef std::iterator_traits<_IIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
 
-    if (begin == end)
-      return result;
+    if (__begin == __end)
+      return __result;
 
-    thread_index_t num_threads =
-        std::min<difference_type>(get_max_threads(), n - 1);
+    _ThreadIndex __num_threads =
+        std::min<_DifferenceType>(__get_max_threads(), __n - 1);
 
-    if (num_threads < 2)
+    if (__num_threads < 2)
       {
-        *result = *begin;
-        return parallel_partial_sum_basecase(
-            begin + 1, end, result + 1, bin_op, *begin);
+        *__result = *__begin;
+        return __parallel_partial_sum_basecase(
+            __begin + 1, __end, __result + 1, __bin_op, *__begin);
       }
 
-    difference_type* borders;
-    value_type* sums;
+    _DifferenceType* __borders;
+    _ValueType* __sums;
 
     const _Settings& __s = _Settings::get();
 
-#   pragma omp parallel num_threads(num_threads)
+#   pragma omp parallel num_threads(__num_threads)
       {
 #       pragma omp single
           {
-            num_threads = omp_get_num_threads();
+            __num_threads = omp_get_num_threads();
 
-            borders = new difference_type[num_threads + 2];
+            __borders = new _DifferenceType[__num_threads + 2];
 
             if (__s.partial_sum_dilation == 1.0f)
-              equally_split(n, num_threads + 1, borders);
+              equally_split(__n, __num_threads + 1, __borders);
             else
               {
-                difference_type chunk_length =
-                    ((double)n
-		     / ((double)num_threads + __s.partial_sum_dilation)),
-		  borderstart = n - num_threads * chunk_length;
-                borders[0] = 0;
-                for (int i = 1; i < (num_threads + 1); ++i)
+                _DifferenceType __chunk_length =
+                    ((double)__n
+		     / ((double)__num_threads + __s.partial_sum_dilation)),
+		  __borderstart = __n - __num_threads * __chunk_length;
+                __borders[0] = 0;
+                for (int __i = 1; __i < (__num_threads + 1); ++__i)
                   {
-                    borders[i] = borderstart;
-                    borderstart += chunk_length;
+                    __borders[__i] = __borderstart;
+                    __borderstart += __chunk_length;
                   }
-                borders[num_threads + 1] = n;
+                __borders[__num_threads + 1] = __n;
               }
 
-            sums = static_cast<value_type*>(::operator new(sizeof(value_type)
-							   * num_threads));
-            OutputIterator target_end;
+            __sums = static_cast<_ValueType*>(::operator new(sizeof(_ValueType)
+							   * __num_threads));
+            _OutputIterator __target_end;
           } //single
 
-        thread_index_t iam = omp_get_thread_num();
-        if (iam == 0)
+        _ThreadIndex __iam = omp_get_thread_num();
+        if (__iam == 0)
           {
-            *result = *begin;
-            parallel_partial_sum_basecase(begin + 1, begin + borders[1],
-					  result + 1, bin_op, *begin);
-            ::new(&(sums[iam])) value_type(*(result + borders[1] - 1));
+            *__result = *__begin;
+            __parallel_partial_sum_basecase(__begin + 1, __begin + __borders[1],
+					  __result + 1, __bin_op, *__begin);
+            ::new(&(__sums[__iam])) _ValueType(*(__result + __borders[1] - 1));
           }
         else
           {
-            ::new(&(sums[iam]))
-	      value_type(std::accumulate(begin + borders[iam] + 1,
-					 begin + borders[iam + 1],
-					 *(begin + borders[iam]),
-					 bin_op,
+            ::new(&(__sums[__iam]))
+	      _ValueType(std::accumulate(__begin + __borders[__iam] + 1,
+					 __begin + __borders[__iam + 1],
+					 *(__begin + __borders[__iam]),
+					 __bin_op,
 					 __gnu_parallel::sequential_tag()));
           }
 
 #       pragma omp barrier
 
 #       pragma omp single
-          parallel_partial_sum_basecase(
-              sums + 1, sums + num_threads, sums + 1, bin_op, sums[0]);
+          __parallel_partial_sum_basecase(
+              __sums + 1, __sums + __num_threads, __sums + 1, __bin_op, __sums[0]);
 
 #       pragma omp barrier
 
         // Still same team.
-        parallel_partial_sum_basecase(begin + borders[iam + 1],
-				      begin + borders[iam + 2],
-				      result + borders[iam + 1], bin_op,
-				      sums[iam]);
+        __parallel_partial_sum_basecase(__begin + __borders[__iam + 1],
+				      __begin + __borders[__iam + 2],
+				      __result + __borders[__iam + 1], __bin_op,
+				      __sums[__iam]);
       } //parallel
 
-    ::operator delete(sums);
-    delete[] borders;
+    ::operator delete(__sums);
+    delete[] __borders;
 
-    return result + n;
+    return __result + __n;
   }
 
-/** @brief Parallel partial sum front-end.
-  *  @param begin Begin iterator of input sequence.
-  *  @param end End iterator of input sequence.
-  *  @param result Begin iterator of output sequence.
-  *  @param bin_op Associative binary function.
+/** @brief Parallel partial sum front-__end.
+  *  @param __begin Begin iterator of input sequence.
+  *  @param __end End iterator of input sequence.
+  *  @param __result Begin iterator of output sequence.
+  *  @param __bin_op Associative binary function.
   *  @return End iterator of output sequence. */
-template<typename InputIterator,
-	 typename OutputIterator,
-	 typename BinaryOperation>
-  OutputIterator
-  parallel_partial_sum(InputIterator begin, InputIterator end,
-                       OutputIterator result, BinaryOperation bin_op)
+template<typename _IIter,
+	 typename _OutputIterator,
+	 typename _BinaryOperation>
+  _OutputIterator
+  __parallel_partial_sum(_IIter __begin, _IIter __end,
+                       _OutputIterator __result, _BinaryOperation __bin_op)
   {
-    _GLIBCXX_CALL(begin - end)
+    _GLIBCXX_CALL(__begin - __end)
 
-    typedef std::iterator_traits<InputIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    typedef typename traits_type::difference_type difference_type;
+    typedef std::iterator_traits<_IIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
 
-    difference_type n = end - begin;
+    _DifferenceType __n = __end - __begin;
 
     switch (_Settings::get().partial_sum_algorithm)
       {
       case LINEAR:
-        // Need an initial offset.
-        return parallel_partial_sum_linear(begin, end, result, bin_op, n);
+        // Need an initial __offset.
+        return __parallel_partial_sum_linear(__begin, __end, __result, __bin_op, __n);
       default:
     // Partial_sum algorithm not implemented.
         _GLIBCXX_PARALLEL_ASSERT(0);
-        return result + n;
+        return __result + __n;
       }
   }
 }
diff --git a/libstdc++-v3/include/parallel/partition.h b/libstdc++-v3/include/parallel/partition.h
index b88133c..81b7299 100644
--- a/libstdc++-v3/include/parallel/partition.h
+++ b/libstdc++-v3/include/parallel/partition.h
@@ -45,231 +45,231 @@
 namespace __gnu_parallel
 {
 /** @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 num_threads Maximum number of threads to use for this task.
+  *  @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 __num_threads Maximum number of threads to use for this task.
   *  @return Number of elements not fulfilling the predicate. */
-template<typename RandomAccessIterator, typename Predicate>
-  typename std::iterator_traits<RandomAccessIterator>::difference_type
-  parallel_partition(RandomAccessIterator begin, RandomAccessIterator end,
-                     Predicate pred, thread_index_t num_threads)
+template<typename _RAIter, typename _Predicate>
+  typename std::iterator_traits<_RAIter>::difference_type
+  __parallel_partition(_RAIter __begin, _RAIter __end,
+                     _Predicate __pred, _ThreadIndex __num_threads)
   {
-    typedef std::iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    typedef typename traits_type::difference_type difference_type;
+    typedef std::iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
 
-    difference_type n = end - begin;
+    _DifferenceType __n = __end - __begin;
 
-    _GLIBCXX_CALL(n)
+    _GLIBCXX_CALL(__n)
 
     const _Settings& __s = _Settings::get();
 
     // Shared.
-    _GLIBCXX_VOLATILE difference_type left = 0, right = n - 1;
-    _GLIBCXX_VOLATILE difference_type leftover_left, leftover_right;
-    _GLIBCXX_VOLATILE difference_type leftnew, rightnew;
+    _GLIBCXX_VOLATILE _DifferenceType __left = 0, __right = __n - 1;
+    _GLIBCXX_VOLATILE _DifferenceType __leftover_left, __leftover_right;
+    _GLIBCXX_VOLATILE _DifferenceType __leftnew, __rightnew;
 
-    bool* reserved_left = NULL, * reserved_right = NULL;
+    bool* __reserved_left = NULL, * __reserved_right = NULL;
 
-    difference_type chunk_size;
+    _DifferenceType __chunk_size;
 
-    omp_lock_t result_lock;
-    omp_init_lock(&result_lock);
+    omp_lock_t __result_lock;
+    omp_init_lock(&__result_lock);
 
-    //at least two chunks per thread
-    if(right - left + 1 >= 2 * num_threads * chunk_size)
-#   pragma omp parallel num_threads(num_threads)
+    //at least two __chunks per thread
+    if(__right - __left + 1 >= 2 * __num_threads * __chunk_size)
+#   pragma omp parallel num_threads(__num_threads)
       {
 #       pragma omp single
           {
-            num_threads = omp_get_num_threads();
-            reserved_left = new bool[num_threads];
-            reserved_right = new bool[num_threads];
+            __num_threads = omp_get_num_threads();
+            __reserved_left = new bool[__num_threads];
+            __reserved_right = new bool[__num_threads];
 
             if (__s.partition_chunk_share > 0.0)
-              chunk_size = std::max<difference_type>(__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;
+              __chunk_size = __s.partition_chunk_size;
           }
 
-        while (right - left + 1 >= 2 * num_threads * chunk_size)
+        while (__right - __left + 1 >= 2 * __num_threads * __chunk_size)
           {
 #           pragma omp single
               {
-                difference_type num_chunks = (right - left + 1) / chunk_size;
+                _DifferenceType __num_chunks = (__right - __left + 1) / __chunk_size;
 
-                for (int r = 0; r < num_threads; ++r)
+                for (int __r = 0; __r < __num_threads; ++__r)
                   {
-                    reserved_left[r] = false;
-                    reserved_right[r] = false;
+                    __reserved_left[__r] = false;
+                    __reserved_right[__r] = false;
                   }
-                leftover_left = 0;
-                leftover_right = 0;
+                __leftover_left = 0;
+                __leftover_right = 0;
               } //implicit barrier
 
             // Private.
-            difference_type thread_left, thread_left_border,
-                            thread_right, thread_right_border;
-            thread_left = left + 1;
+            _DifferenceType __thread_left, __thread_left_border,
+                            thread_right, __thread_right_border;
+            __thread_left = __left + 1;
 
             // Just to satisfy the condition below.
-            thread_left_border = thread_left - 1;
-            thread_right = n - 1;
-            thread_right_border = thread_right + 1;
+            __thread_left_border = __thread_left - 1;
+            thread_right = __n - 1;
+            __thread_right_border = thread_right + 1;
 
-            bool iam_finished = false;
-            while (!iam_finished)
+            bool __iam_finished = false;
+            while (!__iam_finished)
               {
-                if (thread_left > thread_left_border)
+                if (__thread_left > __thread_left_border)
                   {
-                    omp_set_lock(&result_lock);
-                    if (left + (chunk_size - 1) > right)
-                      iam_finished = true;
+                    omp_set_lock(&__result_lock);
+                    if (__left + (__chunk_size - 1) > __right)
+                      __iam_finished = true;
                     else
                       {
-                        thread_left = left;
-                        thread_left_border = left + (chunk_size - 1);
-                        left += chunk_size;
+                        __thread_left = __left;
+                        __thread_left_border = __left + (__chunk_size - 1);
+                        __left += __chunk_size;
                       }
-                    omp_unset_lock(&result_lock);
+                    omp_unset_lock(&__result_lock);
                   }
 
-                if (thread_right < thread_right_border)
+                if (thread_right < __thread_right_border)
                   {
-                    omp_set_lock(&result_lock);
-                    if (left > right - (chunk_size - 1))
-                      iam_finished = true;
+                    omp_set_lock(&__result_lock);
+                    if (__left > __right - (__chunk_size - 1))
+                      __iam_finished = true;
                     else
                       {
-                        thread_right = right;
-                        thread_right_border = right - (chunk_size - 1);
-                        right -= chunk_size;
+                        thread_right = __right;
+                        __thread_right_border = __right - (__chunk_size - 1);
+                        __right -= __chunk_size;
                       }
-                    omp_unset_lock(&result_lock);
+                    omp_unset_lock(&__result_lock);
                   }
 
-                if (iam_finished)
+                if (__iam_finished)
                   break;
 
                 // Swap as usual.
-                while (thread_left < thread_right)
+                while (__thread_left < thread_right)
                   {
-                    while (pred(begin[thread_left])
-                            && thread_left <= thread_left_border)
-                      ++thread_left;
-                    while (!pred(begin[thread_right])
-                            && thread_right >= thread_right_border)
+                    while (__pred(__begin[__thread_left])
+                            && __thread_left <= __thread_left_border)
+                      ++__thread_left;
+                    while (!__pred(__begin[thread_right])
+                            && thread_right >= __thread_right_border)
                       --thread_right;
 
-                    if (thread_left > thread_left_border
-                        || thread_right < thread_right_border)
-                      // Fetch new chunk(s).
+                    if (__thread_left > __thread_left_border
+                        || thread_right < __thread_right_border)
+                      // Fetch new chunk(__s).
                       break;
 
-                    std::swap(begin[thread_left], begin[thread_right]);
-                    ++thread_left;
+                    std::swap(__begin[__thread_left], __begin[thread_right]);
+                    ++__thread_left;
                     --thread_right;
                   }
               }
 
             // Now swap the leftover chunks to the right places.
-            if (thread_left <= thread_left_border)
+            if (__thread_left <= __thread_left_border)
 #             pragma omp atomic
-              ++leftover_left;
-            if (thread_right >= thread_right_border)
+              ++__leftover_left;
+            if (thread_right >= __thread_right_border)
 #             pragma omp atomic
-              ++leftover_right;
+              ++__leftover_right;
 
 #           pragma omp barrier
 
 #           pragma omp single
               {
-                leftnew = left - leftover_left * chunk_size;
-                rightnew = right + leftover_right * chunk_size;
+                __leftnew = __left - __leftover_left * __chunk_size;
+                __rightnew = __right + __leftover_right * __chunk_size;
               }
 
 #           pragma omp barrier
 
-            // <=> thread_left_border + (chunk_size - 1) >= leftnew
-            if (thread_left <= thread_left_border
-                && thread_left_border >= leftnew)
+            // <=> __thread_left_border + (__chunk_size - 1) >= __leftnew
+            if (__thread_left <= __thread_left_border
+                && __thread_left_border >= __leftnew)
               {
                 // Chunk already in place, reserve spot.
-                reserved_left[(left - (thread_left_border + 1)) / chunk_size]
+                __reserved_left[(__left - (__thread_left_border + 1)) / __chunk_size]
                     = true;
               }
 
-            // <=> thread_right_border - (chunk_size - 1) <= rightnew
-            if (thread_right >= thread_right_border
-                && thread_right_border <= rightnew)
+            // <=> __thread_right_border - (__chunk_size - 1) <= __rightnew
+            if (thread_right >= __thread_right_border
+                && __thread_right_border <= __rightnew)
               {
                 // Chunk already in place, reserve spot.
-                reserved_right[((thread_right_border - 1) - right)
-			       / chunk_size] = true;
+                __reserved_right[((__thread_right_border - 1) - __right)
+			       / __chunk_size] = true;
               }
 
 #           pragma omp barrier
 
-            if (thread_left <= thread_left_border
-                && thread_left_border < leftnew)
+            if (__thread_left <= __thread_left_border
+                && __thread_left_border < __leftnew)
               {
                 // Find spot and swap.
-                difference_type swapstart = -1;
-                omp_set_lock(&result_lock);
-                for (int r = 0; r < leftover_left; ++r)
-                  if (!reserved_left[r])
+                _DifferenceType __swapstart = -1;
+                omp_set_lock(&__result_lock);
+                for (int __r = 0; __r < __leftover_left; ++__r)
+                  if (!__reserved_left[__r])
                     {
-                      reserved_left[r] = true;
-                      swapstart = left - (r + 1) * chunk_size;
+                      __reserved_left[__r] = true;
+                      __swapstart = __left - (__r + 1) * __chunk_size;
                       break;
                     }
-                omp_unset_lock(&result_lock);
+                omp_unset_lock(&__result_lock);
 
 #if _GLIBCXX_ASSERTIONS
-                _GLIBCXX_PARALLEL_ASSERT(swapstart != -1);
+                _GLIBCXX_PARALLEL_ASSERT(__swapstart != -1);
 #endif
 
-                std::swap_ranges(begin + thread_left_border
-				 - (chunk_size - 1),
-				 begin + thread_left_border + 1,
-				 begin + swapstart);
+                std::swap_ranges(__begin + __thread_left_border
+				 - (__chunk_size - 1),
+				 __begin + __thread_left_border + 1,
+				 __begin + __swapstart);
               }
 
-            if (thread_right >= thread_right_border
-                && thread_right_border > rightnew)
+            if (thread_right >= __thread_right_border
+                && __thread_right_border > __rightnew)
               {
                 // Find spot and swap
-                difference_type swapstart = -1;
-                omp_set_lock(&result_lock);
-                for (int r = 0; r < leftover_right; ++r)
-                  if (!reserved_right[r])
+                _DifferenceType __swapstart = -1;
+                omp_set_lock(&__result_lock);
+                for (int __r = 0; __r < __leftover_right; ++__r)
+                  if (!__reserved_right[__r])
                     {
-                      reserved_right[r] = true;
-                      swapstart = right + r * chunk_size + 1;
+                      __reserved_right[__r] = true;
+                      __swapstart = __right + __r * __chunk_size + 1;
                       break;
                     }
-                omp_unset_lock(&result_lock);
+                omp_unset_lock(&__result_lock);
 
 #if _GLIBCXX_ASSERTIONS
-                _GLIBCXX_PARALLEL_ASSERT(swapstart != -1);
+                _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
 
 #             pragma omp single
                 {
-                  for (int r = 0; r < leftover_left; ++r)
-                    _GLIBCXX_PARALLEL_ASSERT(reserved_left[r]);
-                  for (int r = 0; r < leftover_right; ++r)
-                    _GLIBCXX_PARALLEL_ASSERT(reserved_right[r]);
+                  for (int __r = 0; __r < __leftover_left; ++__r)
+                    _GLIBCXX_PARALLEL_ASSERT(__reserved_left[__r]);
+                  for (int __r = 0; __r < __leftover_right; ++__r)
+                    _GLIBCXX_PARALLEL_ASSERT(__reserved_right[__r]);
                 }
 
 #             pragma omp barrier
@@ -277,149 +277,149 @@ template<typename RandomAccessIterator, typename Predicate>
 
 #             pragma omp barrier
 
-              left = leftnew;
-              right = rightnew;
+              __left = __leftnew;
+              __right = __rightnew;
           }
-#         pragma omp flush(left, right)
+#         pragma omp flush(__left, __right)
       } // end "recursion" //parallel
 
-    difference_type final_left = left, final_right = right;
+    _DifferenceType __final_left = __left, __final_right = __right;
 
-    while (final_left < final_right)
+    while (__final_left < __final_right)
       {
         // Go right until key is geq than pivot.
-        while (pred(begin[final_left]) && final_left < final_right)
-          ++final_left;
+        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)
-          --final_right;
+        while (!__pred(__begin[__final_right]) && __final_left < __final_right)
+          --__final_right;
 
-        if (final_left == final_right)
+        if (__final_left == __final_right)
           break;
-        std::swap(begin[final_left], begin[final_right]);
-        ++final_left;
-        --final_right;
+        std::swap(__begin[__final_left], __begin[__final_right]);
+        ++__final_left;
+        --__final_right;
       }
 
     // All elements on the left side are < piv, all elements on the
     // right are >= piv
-    delete[] reserved_left;
-    delete[] reserved_right;
+    delete[] __reserved_left;
+    delete[] __reserved_right;
 
-    omp_destroy_lock(&result_lock);
+    omp_destroy_lock(&__result_lock);
 
-    // Element "between" final_left and final_right might not have
+    // Element "between" __final_left and __final_right might not have
     // been regarded yet
-    if (final_left < n && !pred(begin[final_left]))
+    if (__final_left < __n && !__pred(__begin[__final_left]))
       // Really swapped.
-      return final_left;
+      return __final_left;
     else
-      return final_left + 1;
+      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.
+  *  @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 RandomAccessIterator, typename Comparator>
+template<typename _RAIter, typename _Compare>
   void 
-  parallel_nth_element(RandomAccessIterator begin, RandomAccessIterator nth, 
-		       RandomAccessIterator end, Comparator comp)
+  parallel_nth_element(_RAIter __begin, _RAIter __nth, 
+		       _RAIter __end, _Compare __comp)
   {
-    typedef std::iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    typedef typename traits_type::difference_type difference_type;
+    typedef std::iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
 
-    _GLIBCXX_CALL(end - begin)
+    _GLIBCXX_CALL(__end - __begin)
 
-    RandomAccessIterator split;
-    random_number rng;
+    _RAIter __split;
+    _RandomNumber __rng;
 
-    difference_type minimum_length =
-      std::max<difference_type>(2, _Settings::get().partition_minimal_n);
+    _DifferenceType minimum_length =
+      std::max<_DifferenceType>(2, _Settings::get().partition_minimal_n);
 
     // Break if input range to small.
-    while (static_cast<sequence_index_t>(end - begin) >= minimum_length)
+    while (static_cast<_SequenceIndex>(__end - __begin) >= minimum_length)
       {
-        difference_type n = end - begin;
+        _DifferenceType __n = __end - __begin;
 
-        RandomAccessIterator pivot_pos = begin +  rng(n);
+        _RAIter __pivot_pos = __begin +  __rng(__n);
 
-        // Swap pivot_pos value to end.
-        if (pivot_pos != (end - 1))
-          std::swap(*pivot_pos, *(end - 1));
-        pivot_pos = end - 1;
+        // Swap __pivot_pos value to end.
+        if (__pivot_pos != (__end - 1))
+          std::swap(*__pivot_pos, *(__end - 1));
+        __pivot_pos = __end - 1;
 
-        // XXX Comparator must have first_value_type, second_value_type,
-	// result_type
-        // Comparator == __gnu_parallel::lexicographic<S, int,
-	// __gnu_parallel::less<S, S> >
-        // pivot_pos == std::pair<S, int>*
-        // XXX binder2nd only for RandomAccessIterators??
-        __gnu_parallel::binder2nd<Comparator, value_type, value_type, bool>
-	  pred(comp, *pivot_pos);
+        // XXX _Compare must have first__ValueType, second__ValueType,
+	// _ResultType
+        // _Compare == __gnu_parallel::_Lexicographic<S, int,
+	// __gnu_parallel::_Less<S, S> >
+        // __pivot_pos == std::pair<S, int>*
+        // XXX binder2nd only for _RAIters??
+        __gnu_parallel::binder2nd<_Compare, _ValueType, _ValueType, bool>
+	  __pred(__comp, *__pivot_pos);
 
         // Divide, leave pivot unchanged in last place.
-        RandomAccessIterator split_pos1, split_pos2;
-        split_pos1 = begin + parallel_partition(begin, end - 1, pred,
-						get_max_threads());
+        _RAIter __split_pos1, __split_pos2;
+        __split_pos1 = __begin + __parallel_partition(__begin, __end - 1, __pred,
+						__get_max_threads());
 
-        // Left side: < pivot_pos; right side: >= pivot_pos
+        // Left side: < __pivot_pos; __right side: >= __pivot_pos
 
         // Swap pivot back to middle.
-        if (split_pos1 != pivot_pos)
-          std::swap(*split_pos1, *pivot_pos);
-        pivot_pos = split_pos1;
+        if (__split_pos1 != __pivot_pos)
+          std::swap(*__split_pos1, *__pivot_pos);
+        __pivot_pos = __split_pos1;
 
-        // In case all elements are equal, split_pos1 == 0
-        if ((split_pos1 + 1 - begin) < (n >> 7)
-	    || (end - split_pos1) < (n >> 7))
+        // In case all elements are equal, __split_pos1 == 0
+        if ((__split_pos1 + 1 - __begin) < (__n >> 7)
+	    || (__end - __split_pos1) < (__n >> 7))
           {
             // Very unequal split, one part smaller than one 128th
             // elements not strictly larger than the pivot.
-            __gnu_parallel::unary_negate<__gnu_parallel::
-	      binder1st<Comparator, value_type, value_type, bool>, value_type>
-	      pred(__gnu_parallel::binder1st<Comparator, value_type,
-		   value_type, bool>(comp, *pivot_pos));
+            __gnu_parallel::__unary_negate<__gnu_parallel::
+	      __binder1st<_Compare, _ValueType, _ValueType, bool>, _ValueType>
+	      __pred(__gnu_parallel::__binder1st<_Compare, _ValueType,
+		   _ValueType, bool>(__comp, *__pivot_pos));
 
             // Find other end of pivot-equal range.
-            split_pos2 = __gnu_sequential::partition(split_pos1 + 1,
-						     end, pred);
+            __split_pos2 = __gnu_sequential::partition(__split_pos1 + 1,
+						     __end, __pred);
           }
         else
           // Only skip the pivot.
-          split_pos2 = split_pos1 + 1;
+          __split_pos2 = __split_pos1 + 1;
 
         // Compare iterators.
-        if (split_pos2 <= nth)
-          begin = split_pos2;
-        else if (nth < split_pos1)
-          end = split_pos1;
+        if (__split_pos2 <= __nth)
+          __begin = __split_pos2;
+        else if (__nth < __split_pos1)
+          __end = __split_pos1;
         else
           break;
       }
 
-    // Only at most _Settings::partition_minimal_n elements left.
-    __gnu_sequential::sort(begin, end, comp);
+    // Only at most _Settings::partition_minimal_n __elements __left.
+    __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 RandomAccessIterator, typename Comparator>
+*  @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(RandomAccessIterator begin,
-			RandomAccessIterator middle,
-			RandomAccessIterator end, Comparator comp)
+  parallel_partial_sort(_RAIter __begin,
+			_RAIter __middle,
+			_RAIter __end, _Compare __comp)
   {
-    parallel_nth_element(begin, middle, end, comp);
-    std::sort(begin, middle, comp);
+    parallel_nth_element(__begin, __middle, __end, __comp);
+    std::sort(__begin, __middle, __comp);
   }
 
 } //namespace __gnu_parallel
diff --git a/libstdc++-v3/include/parallel/queue.h b/libstdc++-v3/include/parallel/queue.h
index 9686a9a..ab6e2d3 100644
--- a/libstdc++-v3/include/parallel/queue.h
+++ b/libstdc++-v3/include/parallel/queue.h
@@ -45,99 +45,99 @@ namespace __gnu_parallel
    *  atomic access.  push_front() and pop_front() must not be called
    *  concurrently to each other, while pop_back() can be called
    *  concurrently at all times.
-   *  @c empty(), @c size(), and @c top() are intentionally not provided.
+   *  @__c empty(), @__c size(), and @__c top() are intentionally not provided.
    *  Calling them would not make sense in a concurrent setting.
-   *  @param T Contained element type. */
-  template<typename T>
-    class RestrictedBoundedConcurrentQueue
+   *  @param _Tp Contained element type. */
+  template<typename _Tp>
+    class _RestrictedBoundedConcurrentQueue
     {
     private:
       /** @brief Array of elements, seen as cyclic buffer. */
-      T* base;
+      _Tp* _M_base;
 
       /** @brief Maximal number of elements contained at the same time. */
-      sequence_index_t max_size;
+      _SequenceIndex _M_max_size;
 
-      /** @brief Cyclic begin and end pointers contained in one
+      /** @brief Cyclic __begin and __end pointers contained in one
 	  atomically changeable value. */
-      _GLIBCXX_VOLATILE lcas_t borders;
+      _GLIBCXX_VOLATILE _CASable _M_borders;
 
     public:
       /** @brief Constructor. Not to be called concurrent, of course.
-       *  @param max_size Maximal number of elements to be contained. */
-      RestrictedBoundedConcurrentQueue(sequence_index_t max_size)
+       *  @param _M_max_size Maximal number of elements to be contained. */
+      _RestrictedBoundedConcurrentQueue(_SequenceIndex _M_max_size)
       {
-	this->max_size = max_size;
-	base = new T[max_size];
-	borders = encode2(0, 0);
+	this->_M_max_size = _M_max_size;
+	_M_base = new _Tp[_M_max_size];
+	_M_borders = __encode2(0, 0);
 #pragma omp flush
       }
 
       /** @brief Destructor. Not to be called concurrent, of course. */
-      ~RestrictedBoundedConcurrentQueue()
-      { delete[] base; }
+      ~_RestrictedBoundedConcurrentQueue()
+      { delete[] _M_base; }
 
-      /** @brief Pushes one element into the queue at the front end.
+      /** @brief Pushes one element into the queue at the front __end.
        *  Must not be called concurrently with pop_front(). */
       void
-      push_front(const T& t)
+      push_front(const _Tp& __t)
       {
-	lcas_t former_borders = borders;
-	int former_front, former_back;
-	decode2(former_borders, former_front, former_back);
-	*(base + former_front % max_size) = t;
+	_CASable __former_borders = _M_borders;
+	int __former_front, __former_back;
+	decode2(__former_borders, __former_front, __former_back);
+	*(_M_base + __former_front % _M_max_size) = __t;
 #if _GLIBCXX_ASSERTIONS
-	// Otherwise: front - back > max_size eventually.
-	_GLIBCXX_PARALLEL_ASSERT(((former_front + 1) - former_back)
-				 <= max_size);
+	// Otherwise: front - back > _M_max_size eventually.
+	_GLIBCXX_PARALLEL_ASSERT(((__former_front + 1) - __former_back)
+				 <= _M_max_size);
 #endif
-	fetch_and_add(&borders, encode2(1, 0));
+	__fetch_and_add(&_M_borders, __encode2(1, 0));
       }
 
-      /** @brief Pops one element from the queue at the front end.
+      /** @brief Pops one element from the queue at the front __end.
        *  Must not be called concurrently with pop_front(). */
       bool
-      pop_front(T& t)
+      pop_front(_Tp& __t)
       {
-	int former_front, former_back;
+	int __former_front, __former_back;
 #pragma omp flush
-	decode2(borders, former_front, former_back);
-	while (former_front > former_back)
+	decode2(_M_borders, __former_front, __former_back);
+	while (__former_front > __former_back)
 	  {
 	    // Chance.
-	    lcas_t former_borders = encode2(former_front, former_back);
-	    lcas_t new_borders = encode2(former_front - 1, former_back);
-	    if (compare_and_swap(&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 = *(base + (former_front - 1) % max_size);
+		__t = *(_M_base + (__former_front - 1) % _M_max_size);
 		return true;
 	      }
 #pragma omp flush
-	    decode2(borders, former_front, former_back);
+	    decode2(_M_borders, __former_front, __former_back);
 	  }
 	return false;
       }
 
-      /** @brief Pops one element from the queue at the front end.
+      /** @brief Pops one element from the queue at the front __end.
        *  Must not be called concurrently with pop_front(). */
       bool
-      pop_back(T& t)	//queue behavior
+      pop_back(_Tp& __t)	//queue behavior
       {
-	int former_front, former_back;
+	int __former_front, __former_back;
 #pragma omp flush
-	decode2(borders, former_front, former_back);
-	while (former_front > former_back)
+	decode2(_M_borders, __former_front, __former_back);
+	while (__former_front > __former_back)
 	  {
 	    // Chance.
-	    lcas_t former_borders = encode2(former_front, former_back);
-	    lcas_t new_borders = encode2(former_front, former_back + 1);
-	    if (compare_and_swap(&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 = *(base + former_back % max_size);
+		__t = *(_M_base + __former_back % _M_max_size);
 		return true;
 	      }
 #pragma omp flush
-	    decode2(borders, former_front, former_back);
+	    decode2(_M_borders, __former_front, __former_back);
 	  }
 	return false;
       }
diff --git a/libstdc++-v3/include/parallel/quicksort.h b/libstdc++-v3/include/parallel/quicksort.h
index 712b479..60f4b23 100644
--- a/libstdc++-v3/include/parallel/quicksort.h
+++ b/libstdc++-v3/include/parallel/quicksort.h
@@ -38,140 +38,140 @@
 namespace __gnu_parallel
 {
   /** @brief Unbalanced quicksort divide step.
-   *  @param begin Begin iterator of subsequence.
-   *  @param end End iterator of subsequence.
-   *  @param comp Comparator.
-   *  @param pivot_rank Desired rank of the pivot.
-   *  @param num_samples Choose pivot from that many samples.
-   *  @param num_threads Number of threads that are allowed to work on
+   *  @param __begin Begin iterator of subsequence.
+   *  @param __end End iterator of subsequence.
+   *  @param __comp Comparator.
+   *  @param __pivot_rank Desired __rank of the pivot.
+   *  @param __num_samples Choose pivot from that many samples.
+   *  @param __num_threads Number of threads that are allowed to work on
    *  this part.
    */
-  template<typename RandomAccessIterator, typename Comparator>
-    typename std::iterator_traits<RandomAccessIterator>::difference_type
-    parallel_sort_qs_divide(RandomAccessIterator begin,
-			    RandomAccessIterator end,
-			    Comparator comp, typename std::iterator_traits
-			    <RandomAccessIterator>::difference_type pivot_rank,
+  template<typename _RAIter, typename _Compare>
+    typename std::iterator_traits<_RAIter>::difference_type
+    __parallel_sort_qs_divide(_RAIter __begin,
+			    _RAIter __end,
+			    _Compare __comp, typename std::iterator_traits
+			    <_RAIter>::difference_type __pivot_rank,
 			    typename std::iterator_traits
-			    <RandomAccessIterator>::difference_type
-			    num_samples, thread_index_t num_threads)
+			    <_RAIter>::difference_type
+			    __num_samples, _ThreadIndex __num_threads)
     {
-      typedef std::iterator_traits<RandomAccessIterator> traits_type;
-      typedef typename traits_type::value_type value_type;
-      typedef typename traits_type::difference_type difference_type;
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
 
-      difference_type n = end - begin;
-      num_samples = std::min(num_samples, n);
+      _DifferenceType __n = __end - __begin;
+      __num_samples = std::min(__num_samples, __n);
 
       // Allocate uninitialized, to avoid default constructor.
-      value_type* samples =
-	static_cast<value_type*>(::operator new(num_samples
-						* sizeof(value_type)));
+      _ValueType* __samples =
+	static_cast<_ValueType*>(::operator new(__num_samples
+						* sizeof(_ValueType)));
 
-      for (difference_type s = 0; s < num_samples; ++s)
+      for (_DifferenceType __s = 0; __s < __num_samples; ++__s)
 	{
-	  const unsigned long long index = static_cast<unsigned long long>(s)
-	    * n / num_samples;
-	  ::new(&(samples[s])) value_type(begin[index]);
+	  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);
+      __gnu_sequential::sort(__samples, __samples + __num_samples, __comp);
 
-      value_type& pivot = samples[pivot_rank * num_samples / n];
+      _ValueType& pivot = __samples[__pivot_rank * __num_samples / __n];
 
-      __gnu_parallel::binder2nd<Comparator, value_type, value_type, bool>
-        pred(comp, pivot);
-      difference_type split =
-          parallel_partition(begin, end, pred, num_threads);
+      __gnu_parallel::binder2nd<_Compare, _ValueType, _ValueType, bool>
+        __pred(__comp, pivot);
+      _DifferenceType __split =
+          __parallel_partition(__begin, __end, __pred, __num_threads);
 
-      ::operator delete(samples);
+      ::operator delete(__samples);
 
-      return split;
+      return __split;
     }
 
   /** @brief Unbalanced quicksort conquer 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
+   *  @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.
    */
-  template<typename RandomAccessIterator, typename Comparator>
+  template<typename _RAIter, typename _Compare>
     void
-    parallel_sort_qs_conquer(RandomAccessIterator begin,
-			     RandomAccessIterator end,
-			     Comparator comp,
-			     thread_index_t num_threads)
+    __parallel_sort_qs_conquer(_RAIter __begin,
+			     _RAIter __end,
+			     _Compare __comp,
+			     _ThreadIndex __num_threads)
     {
-      typedef std::iterator_traits<RandomAccessIterator> traits_type;
-      typedef typename traits_type::value_type value_type;
-      typedef typename traits_type::difference_type difference_type;
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
 
-      if (num_threads <= 1)
+      if (__num_threads <= 1)
 	{
-	  __gnu_sequential::sort(begin, end, comp);
+	  __gnu_sequential::sort(__begin, __end, __comp);
 	  return;
 	}
 
-      difference_type n = end - begin, pivot_rank;
+      _DifferenceType __n = __end - __begin, __pivot_rank;
 
-      if (n <= 1)
+      if (__n <= 1)
 	return;
 
-      thread_index_t num_threads_left;
+      _ThreadIndex __num_threads_left;
 
-      if ((num_threads % 2) == 1)
-	num_threads_left = num_threads / 2 + 1;
+      if ((__num_threads % 2) == 1)
+	__num_threads_left = __num_threads / 2 + 1;
       else
-	num_threads_left = num_threads / 2;
+	__num_threads_left = __num_threads / 2;
 
-      pivot_rank = n * num_threads_left / num_threads;
+      __pivot_rank = __n * __num_threads_left / __num_threads;
 
-      difference_type split =
-	parallel_sort_qs_divide(begin, end, comp, pivot_rank,
+      _DifferenceType __split =
+	__parallel_sort_qs_divide(__begin, __end, __comp, __pivot_rank,
 				_Settings::get().sort_qs_num_samples_preset,
-				num_threads);
+				__num_threads);
 
 #pragma omp parallel sections num_threads(2)
       {
 #pragma omp section
-	parallel_sort_qs_conquer(begin, begin + split,
-				 comp, num_threads_left);
+	__parallel_sort_qs_conquer(__begin, __begin + __split,
+				 __comp, __num_threads_left);
 #pragma omp section
-	parallel_sort_qs_conquer(begin + split, end,
-				 comp, num_threads - num_threads_left);
+	__parallel_sort_qs_conquer(__begin + __split, __end,
+				 __comp, __num_threads - __num_threads_left);
       }
     }
 
 
 
   /** @brief Unbalanced quicksort main call.
-   *  @param begin Begin iterator of input sequence.
-   *  @param end End iterator input sequence, ignored.
-   *  @param comp Comparator.
-   *  @param num_threads Number of threads that are allowed to work on
+   *  @param __begin Begin iterator of input sequence.
+   *  @param __end End iterator input sequence, ignored.
+   *  @param __comp Comparator.
+   *  @param __num_threads Number of threads that are allowed to work on
    *  this part.
    */
-  template<typename RandomAccessIterator, typename Comparator>
+  template<typename _RAIter, typename _Compare>
     void
-    parallel_sort_qs(RandomAccessIterator begin,
-		     RandomAccessIterator end,
-		     Comparator comp,
-		     thread_index_t num_threads)
+    __parallel_sort_qs(_RAIter __begin,
+		     _RAIter __end,
+		     _Compare __comp,
+		     _ThreadIndex __num_threads)
     {
-      _GLIBCXX_CALL(n)
+      _GLIBCXX_CALL(__n)
 
-      typedef std::iterator_traits<RandomAccessIterator> traits_type;
-      typedef typename traits_type::value_type value_type;
-      typedef typename traits_type::difference_type difference_type;
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
 
-      difference_type n = end - begin;
+      _DifferenceType __n = __end - __begin;
 
       // At least one element per processor.
-      if (num_threads > n)
-        num_threads = static_cast<thread_index_t>(n);
+      if (__num_threads > __n)
+        __num_threads = static_cast<_ThreadIndex>(__n);
 
-      parallel_sort_qs_conquer(begin, begin + n, comp, num_threads);
+      __parallel_sort_qs_conquer(__begin, __begin + __n, __comp, __num_threads);
     }
 
 } //namespace __gnu_parallel
diff --git a/libstdc++-v3/include/parallel/random_number.h b/libstdc++-v3/include/parallel/random_number.h
index 7e821a4..69cbc94 100644
--- a/libstdc++-v3/include/parallel/random_number.h
+++ b/libstdc++-v3/include/parallel/random_number.h
@@ -38,84 +38,84 @@
 namespace __gnu_parallel
 {
   /** @brief Random number generator, based on the Mersenne twister. */
-  class random_number
+  class _RandomNumber
   {
   private:
-    std::tr1::mt19937 	mt;
-    uint64 		supremum;
-    uint64 		RAND_SUP;
-    double 		supremum_reciprocal;
-    double 		RAND_SUP_REC;
+    std::tr1::mt19937 	_M_mt;
+    uint64 		_M_supremum;
+    uint64 		_RAND_SUP;
+    double 		_M_supremum_reciprocal;
+    double 		_RAND_SUP_REC;
 
     // Assumed to be twice as long as the usual random number.
-    uint64 		cache;  
+    uint64 		__cache;  
 
     // Bit results.
-    int bits_left;
+    int __bits_left;
     
     static uint32
-    scale_down(uint64 x,
+    __scale_down(uint64 __x,
 #if _GLIBCXX_SCALE_DOWN_FPU
-	       uint64 /*supremum*/, double supremum_reciprocal)
+	       uint64 /*_M_supremum*/, double _M_supremum_reciprocal)
 #else
-               uint64 supremum, double /*supremum_reciprocal*/)
+               uint64 _M_supremum, double /*_M_supremum_reciprocal*/)
 #endif
 	{
 #if _GLIBCXX_SCALE_DOWN_FPU
-	  return uint32(x * supremum_reciprocal);
+	  return uint32(__x * _M_supremum_reciprocal);
 #else
-	  return static_cast<uint32>(x % supremum);
+	  return static_cast<uint32>(__x % _M_supremum);
 #endif
 	}
 
   public:
     /** @brief Default constructor. Seed with 0. */
-    random_number()
-    : mt(0), supremum(0x100000000ULL),
-      RAND_SUP(1ULL << (sizeof(uint32) * 8)),
-      supremum_reciprocal(double(supremum) / double(RAND_SUP)),
-      RAND_SUP_REC(1.0 / double(RAND_SUP)),
-      cache(0), bits_left(0) { }
+    _RandomNumber()
+    : _M_mt(0), _M_supremum(0x100000000ULL),
+      _RAND_SUP(1ULL << (sizeof(uint32) * 8)),
+      _M_supremum_reciprocal(double(_M_supremum) / double(_RAND_SUP)),
+      _RAND_SUP_REC(1.0 / double(_RAND_SUP)),
+      __cache(0), __bits_left(0) { }
 
     /** @brief Constructor.
-     *  @param seed Random seed.
-     *  @param supremum Generate integer random numbers in the
-     *                  interval @c [0,supremum). */
-    random_number(uint32 seed, uint64 supremum = 0x100000000ULL)
-    : mt(seed), supremum(supremum),
-      RAND_SUP(1ULL << (sizeof(uint32) * 8)),
-      supremum_reciprocal(double(supremum) / double(RAND_SUP)),
-      RAND_SUP_REC(1.0 / double(RAND_SUP)),
-      cache(0), bits_left(0) { }
+     *  @param __seed Random __seed.
+     *  @param _M_supremum Generate integer random numbers in the
+     *                  interval @__c [0,_M_supremum). */
+    _RandomNumber(uint32 __seed, uint64 _M_supremum = 0x100000000ULL)
+    : _M_mt(__seed), _M_supremum(_M_supremum),
+      _RAND_SUP(1ULL << (sizeof(uint32) * 8)),
+      _M_supremum_reciprocal(double(_M_supremum) / double(_RAND_SUP)),
+      _RAND_SUP_REC(1.0 / double(_RAND_SUP)),
+      __cache(0), __bits_left(0) { }
 
     /** @brief Generate unsigned random 32-bit integer. */
     uint32
     operator()()
-    { return scale_down(mt(), supremum, supremum_reciprocal); }
+    { return __scale_down(_M_mt(), _M_supremum, _M_supremum_reciprocal); }
 
     /** @brief Generate unsigned random 32-bit integer in the
-	interval @c [0,local_supremum). */
+	interval @__c [0,local_supremum). */
     uint32
     operator()(uint64 local_supremum)
     {
-      return scale_down(mt(), local_supremum,
-			double(local_supremum * RAND_SUP_REC));
+      return __scale_down(_M_mt(), local_supremum,
+			double(local_supremum * _RAND_SUP_REC));
     }
 
     /** @brief Generate a number of random bits, run-time parameter.
      *  @param bits Number of bits to generate. */
     unsigned long
-    genrand_bits(int bits)
+    __genrand_bits(int bits)
     {
-      unsigned long res = cache & ((1 << bits) - 1);
-      cache = cache >> bits;
-      bits_left -= bits;
-      if (bits_left < 32)
+      unsigned long __res = __cache & ((1 << bits) - 1);
+      __cache = __cache >> bits;
+      __bits_left -= bits;
+      if (__bits_left < 32)
 	{
-	  cache |= ((uint64(mt())) << bits_left);
-	  bits_left += 32;
+	  __cache |= ((uint64(_M_mt())) << __bits_left);
+	  __bits_left += 32;
 	}
-      return res;
+      return __res;
     }
 };
 
diff --git a/libstdc++-v3/include/parallel/random_shuffle.h b/libstdc++-v3/include/parallel/random_shuffle.h
index 6e0ebef..5d6bfce 100644
--- a/libstdc++-v3/include/parallel/random_shuffle.h
+++ b/libstdc++-v3/include/parallel/random_shuffle.h
@@ -41,477 +41,477 @@ namespace __gnu_parallel
 {
 /** @brief Type to hold the index of a bin.
   *
-  *  Since many variables of this type are allocated, it should be
+  *  Since many variables of this _Self are allocated, it should be
   *  chosen as small as possible.
   */
-typedef unsigned short bin_index;
+typedef unsigned short _BinIndex;
 
 /** @brief Data known to every thread participating in
-    __gnu_parallel::parallel_random_shuffle(). */
-template<typename RandomAccessIterator>
-  struct DRandomShufflingGlobalData
+    __gnu_parallel::__parallel_random_shuffle(). */
+template<typename _RAIter>
+  struct _DRandomShufflingGlobalData
   {
-    typedef std::iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    typedef typename traits_type::difference_type difference_type;
+    typedef std::iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
 
-    /** @brief Begin iterator of the source. */
-    RandomAccessIterator& source;
+    /** @brief Begin iterator of the _M_source. */
+    _RAIter& _M_source;
 
     /** @brief Temporary arrays for each thread. */
-    value_type** temporaries;
+    _ValueType** _M_temporaries;
 
     /** @brief Two-dimensional array to hold the thread-bin distribution.
      *
-     *  Dimensions (num_threads + 1) x (num_bins + 1). */
-    difference_type** dist;
+     *  Dimensions (__num_threads + 1) __x (_M_num_bins + 1). */
+    _DifferenceType** _M_dist;
 
-    /** @brief Start indexes of the threads' chunks. */
-    difference_type* starts;
+    /** @brief Start indexes of the threads' __chunks. */
+    _DifferenceType* _M_starts;
 
     /** @brief Number of the thread that will further process the
 	corresponding bin. */
-    thread_index_t* bin_proc;
+    _ThreadIndex* _M_bin_proc;
 
     /** @brief Number of bins to distribute to. */
-    int num_bins;
+    int _M_num_bins;
 
     /** @brief Number of bits needed to address the bins. */
-    int num_bits;
+    int _M_num_bits;
 
     /** @brief Constructor. */
-    DRandomShufflingGlobalData(RandomAccessIterator& _source)
-    : source(_source) { }
+    _DRandomShufflingGlobalData(_RAIter& _source)
+    : _M_source(_source) { }
   };
 
 /** @brief Local data for a thread participating in
-    __gnu_parallel::parallel_random_shuffle().
+    __gnu_parallel::__parallel_random_shuffle().
   */
-template<typename RandomAccessIterator, typename RandomNumberGenerator>
-  struct DRSSorterPU
+template<typename _RAIter, typename RandomNumberGenerator>
+  struct _DRSSorterPU
   {
     /** @brief Number of threads participating in total. */
-    int num_threads;
+    int __num_threads;
 
-    /** @brief Begin index for bins taken care of by this thread. */
-    bin_index bins_begin;
+    /** @brief Begin __index for bins taken care of by this thread. */
+    _BinIndex _M_bins_begin;
 
-    /** @brief End index for bins taken care of by this thread. */
-    bin_index bins_end;
+    /** @brief End __index for bins taken care of by this thread. */
+    _BinIndex __bins_end;
 
-    /** @brief Random seed for this thread. */
-    uint32 seed;
+    /** @brief Random _M_seed for this thread. */
+    uint32 _M_seed;
 
     /** @brief Pointer to global data. */
-    DRandomShufflingGlobalData<RandomAccessIterator>* sd;
+    _DRandomShufflingGlobalData<_RAIter>* _M_sd;
   };
 
-/** @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.
+/** @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>
   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.
-  *  @param pus Array of thread-local data records. */
-template<typename RandomAccessIterator, typename RandomNumberGenerator>
+  *  @param __pus Array of thread-local data records. */
+template<typename _RAIter, typename RandomNumberGenerator>
   void 
-  parallel_random_shuffle_drs_pu(DRSSorterPU<RandomAccessIterator,
-                                 RandomNumberGenerator>* pus)
+  __parallel_random_shuffle_drs_pu(_DRSSorterPU<_RAIter,
+                                 RandomNumberGenerator>* __pus)
   {
-    typedef std::iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    typedef typename traits_type::difference_type difference_type;
+    typedef std::iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
 
-    thread_index_t iam = omp_get_thread_num();
-    DRSSorterPU<RandomAccessIterator, RandomNumberGenerator>* d = &pus[iam];
-    DRandomShufflingGlobalData<RandomAccessIterator>* sd = d->sd;
+    _ThreadIndex __iam = omp_get_thread_num();
+    _DRSSorterPU<_RAIter, RandomNumberGenerator>* d = &__pus[__iam];
+    _DRandomShufflingGlobalData<_RAIter>* _M_sd = d->_M_sd;
 
-    // Indexing: dist[bin][processor]
-    difference_type length = sd->starts[iam + 1] - sd->starts[iam];
-    bin_index* oracles = new bin_index[length];
-    difference_type* dist = new difference_type[sd->num_bins + 1];
-    bin_index* bin_proc = new bin_index[sd->num_bins];
-    value_type** temporaries = new value_type*[d->num_threads];
+    // Indexing: _M_dist[bin][processor]
+    _DifferenceType __length = _M_sd->_M_starts[__iam + 1] - _M_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->__num_threads];
 
     // Compute oracles and count appearances.
-    for (bin_index b = 0; b < sd->num_bins + 1; ++b)
-      dist[b] = 0;
-    int num_bits = sd->num_bits;
+    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;
 
-    random_number rng(d->seed);
+    _RandomNumber __rng(d->_M_seed);
 
     // First main loop.
-    for (difference_type i = 0; i < length; ++i)
+    for (_DifferenceType __i = 0; __i < __length; ++__i)
       {
-        bin_index oracle = random_number_pow2(num_bits, rng);
-        oracles[i] = oracle;
+        _BinIndex __oracle = __random_number_pow2(_M_num_bits, __rng);
+        __oracles[__i] = __oracle;
 
         // To allow prefix (partial) sum.
-        ++(dist[oracle + 1]);
+        ++(_M_dist[__oracle + 1]);
       }
 
-    for (bin_index b = 0; b < sd->num_bins + 1; ++b)
-      sd->dist[b][iam + 1] = dist[b];
+    for (_BinIndex __b = 0; __b < _M_sd->_M_num_bins + 1; ++__b)
+      _M_sd->_M_dist[__b][__iam + 1] = _M_dist[__b];
 
 #   pragma omp barrier
 
 #   pragma omp single
     {
-      // Sum up bins, sd->dist[s + 1][d->num_threads] now contains the
-      // total number of items in bin s
-      for (bin_index s = 0; s < sd->num_bins; ++s)
-        __gnu_sequential::partial_sum(sd->dist[s + 1],
-                                      sd->dist[s + 1] + d->num_threads + 1,
-                                      sd->dist[s + 1]);
+      // Sum up bins, _M_sd->_M_dist[__s + 1][d->__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->__num_threads + 1,
+                                      _M_sd->_M_dist[__s + 1]);
     }
 
 #   pragma omp barrier
 
-    sequence_index_t offset = 0, global_offset = 0;
-    for (bin_index s = 0; s < d->bins_begin; ++s)
-      global_offset += sd->dist[s + 1][d->num_threads];
+    _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->__num_threads];
 
 #   pragma omp barrier
 
-    for (bin_index s = d->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->num_threads + 1; ++t)
-	  sd->dist[s + 1][t] += offset;
-	offset = sd->dist[s + 1][d->num_threads];
+	for (int __t = 0; __t < d->__num_threads + 1; ++__t)
+	  _M_sd->_M_dist[__s + 1][__t] += __offset;
+	__offset = _M_sd->_M_dist[__s + 1][d->__num_threads];
       }
 
-    sd->temporaries[iam] = static_cast<value_type*>(
-      ::operator new(sizeof(value_type) * offset));
+    _M_sd->_M_temporaries[__iam] = static_cast<_ValueType*>(
+      ::operator new(sizeof(_ValueType) * __offset));
 
 #   pragma omp barrier
 
     // Draw local copies to avoid false sharing.
-    for (bin_index b = 0; b < sd->num_bins + 1; ++b)
-      dist[b] = sd->dist[b][iam];
-    for (bin_index b = 0; b < sd->num_bins; ++b)
-      bin_proc[b] = sd->bin_proc[b];
-    for (thread_index_t t = 0; t < d->num_threads; ++t)
-      temporaries[t] = sd->temporaries[t];
+    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->__num_threads; ++__t)
+      _M_temporaries[__t] = _M_sd->_M_temporaries[__t];
 
-    RandomAccessIterator source = sd->source;
-    difference_type start = sd->starts[iam];
+    _RAIter _M_source = _M_sd->_M_source;
+    _DifferenceType __start = _M_sd->_M_starts[__iam];
 
     // Distribute according to oracles, second main loop.
-    for (difference_type i = 0; i < length; ++i)
+    for (_DifferenceType __i = 0; __i < __length; ++__i)
       {
-        bin_index target_bin = oracles[i];
-        thread_index_t target_p = bin_proc[target_bin];
+        _BinIndex target_bin = __oracles[__i];
+        _ThreadIndex target_p = _M_bin_proc[target_bin];
 
-        // Last column [d->num_threads] stays unchanged.
-        ::new(&(temporaries[target_p][dist[target_bin + 1]++]))
-	    value_type(*(source + i + start));
+        // Last column [d->__num_threads] stays unchanged.
+        ::new(&(_M_temporaries[target_p][_M_dist[target_bin + 1]++]))
+	    _ValueType(*(_M_source + __i + __start));
       }
 
-    delete[] oracles;
-    delete[] dist;
-    delete[] bin_proc;
-    delete[] temporaries;
+    delete[] __oracles;
+    delete[] _M_dist;
+    delete[] _M_bin_proc;
+    delete[] _M_temporaries;
 
 #   pragma omp barrier
 
     // Shuffle bins internally.
-    for (bin_index b = d->bins_begin; b < d->bins_end; ++b)
+    for (_BinIndex __b = d->_M_bins_begin; __b < d->__bins_end; ++__b)
       {
-        value_type* begin =
-                    sd->temporaries[iam] +
-                    ((b == d->bins_begin) ? 0 : sd->dist[b][d->num_threads]),
-                  * end =
-                    sd->temporaries[iam] + sd->dist[b + 1][d->num_threads];
-        sequential_random_shuffle(begin, end, rng);
-        std::copy(begin, end, sd->source + global_offset +
-            ((b == d->bins_begin) ? 0 : sd->dist[b][d->num_threads]));
+        _ValueType* __begin =
+                    _M_sd->_M_temporaries[__iam] +
+                    ((__b == d->_M_bins_begin) ? 0 : _M_sd->_M_dist[__b][d->__num_threads]),
+                  * __end =
+                    _M_sd->_M_temporaries[__iam] + _M_sd->_M_dist[__b + 1][d->__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->__num_threads]));
       }
 
-    ::operator delete(sd->temporaries[iam]);
+    ::operator delete(_M_sd->_M_temporaries[__iam]);
   }
 
 /** @brief Round up to the next greater power of 2.
-  *  @param x Integer to round up */
-template<typename T>
-  T 
-  round_up_to_pow2(T x)
+  *  @param __x _Integer to round up */
+template<typename _Tp>
+  _Tp 
+  __round_up_to_pow2(_Tp __x)
   {
-    if (x <= 1)
+    if (__x <= 1)
       return 1;
     else
-      return (T)1 << (__log2(x - 1) + 1);
+      return (_Tp)1 << (__log2(__x - 1) + 1);
   }
 
 /** @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.
+  *  @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 RandomAccessIterator, typename RandomNumberGenerator>
+template<typename _RAIter, typename RandomNumberGenerator>
   void
-  parallel_random_shuffle_drs(RandomAccessIterator begin,
-			      RandomAccessIterator end,
+  __parallel_random_shuffle_drs(_RAIter __begin,
+			      _RAIter __end,
 			      typename std::iterator_traits
-			      <RandomAccessIterator>::difference_type n,
-			      thread_index_t num_threads,
-			      RandomNumberGenerator& rng)
+			      <_RAIter>::difference_type __n,
+			      _ThreadIndex __num_threads,
+			      RandomNumberGenerator& __rng)
   {
-    typedef std::iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    typedef typename traits_type::difference_type difference_type;
+    typedef std::iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
 
-    _GLIBCXX_CALL(n)
+    _GLIBCXX_CALL(__n)
 
     const _Settings& __s = _Settings::get();
 
-    if (num_threads > n)
-      num_threads = static_cast<thread_index_t>(n);
+    if (__num_threads > __n)
+      __num_threads = static_cast<_ThreadIndex>(__n);
 
-    bin_index num_bins, num_bins_cache;
+    _BinIndex _M_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<difference_type>(
-        1, n / (__s.L1_cache_size_lb / sizeof(value_type)));
-    num_bins_cache = round_up_to_pow2(num_bins_cache);
+    __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.
-    num_bins = std::min<difference_type>(n, num_bins_cache);
+    _M_num_bins = std::min<_DifferenceType>(__n, __num_bins_cache);
 
 #if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_TLB
     // 2 TLB entries needed per bin.
-    num_bins = std::min<difference_type>(__s.TLB_size / 2, num_bins);
+    _M_num_bins = std::min<_DifferenceType>(__s.TLB_size / 2, _M_num_bins);
 #endif
-    num_bins = round_up_to_pow2(num_bins);
+    _M_num_bins = __round_up_to_pow2(_M_num_bins);
 
-    if (num_bins < num_bins_cache)
+    if (_M_num_bins < __num_bins_cache)
       {
 #endif
         // Now try the L2 cache
         // Must fit into L2
-        num_bins_cache = static_cast<bin_index>(std::max<difference_type>(
-            1, n / (__s.L2_cache_size / sizeof(value_type))));
-        num_bins_cache = round_up_to_pow2(num_bins_cache);
+        __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.
-        num_bins = static_cast<bin_index>(
-            std::min(n, static_cast<difference_type>(num_bins_cache)));
+        _M_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.
-        num_bins = std::min(
-            static_cast<difference_type>(__s.TLB_size / 2), num_bins);
+        _M_num_bins = std::min(
+            static_cast<_DifferenceType>(__s.TLB_size / 2), _M_num_bins);
 #endif
-          num_bins = round_up_to_pow2(num_bins);
+          _M_num_bins = __round_up_to_pow2(_M_num_bins);
 #if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_L1
       }
 #endif
 
-    num_threads = std::min<bin_index>(num_threads, num_bins);
+    __num_threads = std::min<_BinIndex>(__num_threads, _M_num_bins);
 
-    if (num_threads <= 1)
-      return sequential_random_shuffle(begin, end, rng);
+    if (__num_threads <= 1)
+      return __sequential_random_shuffle(__begin, __end, __rng);
 
-    DRandomShufflingGlobalData<RandomAccessIterator> sd(begin);
-    DRSSorterPU<RandomAccessIterator, random_number >* pus;
-    difference_type* starts;
+    _DRandomShufflingGlobalData<_RAIter> _M_sd(__begin);
+    _DRSSorterPU<_RAIter, _RandomNumber >* __pus;
+    _DifferenceType* _M_starts;
 
-#   pragma omp parallel num_threads(num_threads)
+#   pragma omp parallel num_threads(__num_threads)
       {
-        thread_index_t num_threads = omp_get_num_threads();
+        _ThreadIndex __num_threads = omp_get_num_threads();
 #       pragma omp single
           {
-            pus = new DRSSorterPU<RandomAccessIterator, random_number>
-                [num_threads];
-
-            sd.temporaries = new value_type*[num_threads];
-            sd.dist = new difference_type*[num_bins + 1];
-            sd.bin_proc = new thread_index_t[num_bins];
-            for (bin_index b = 0; b < num_bins + 1; ++b)
-              sd.dist[b] = new difference_type[num_threads + 1];
-            for (bin_index b = 0; b < (num_bins + 1); ++b)
+            __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)
               {
-                sd.dist[0][0] = 0;
-                sd.dist[b][0] = 0;
+                _M_sd._M_dist[0][0] = 0;
+                _M_sd._M_dist[__b][0] = 0;
               }
-            starts = sd.starts = new difference_type[num_threads + 1];
+            _M_starts = _M_sd._M_starts = new _DifferenceType[__num_threads + 1];
             int bin_cursor = 0;
-            sd.num_bins = num_bins;
-            sd.num_bits = __log2(num_bins);
-
-            difference_type chunk_length = n / num_threads,
-                            split = n % num_threads, start = 0;
-            difference_type bin_chunk_length = num_bins / num_threads,
-                            bin_split = num_bins % num_threads;
-            for (thread_index_t i = 0; i < num_threads; ++i)
+            _M_sd._M_num_bins = _M_num_bins;
+            _M_sd._M_num_bits = __log2(_M_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;
+            for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)
               {
-                starts[i] = start;
-                start += (i < split) ? (chunk_length + 1) : chunk_length;
-                int j = pus[i].bins_begin = bin_cursor;
+                _M_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_cursor += (__i < bin_split) ?
                     (bin_chunk_length + 1) : bin_chunk_length;
-                pus[i].bins_end = bin_cursor;
-                for (; j < bin_cursor; ++j)
-                  sd.bin_proc[j] = i;
-                pus[i].num_threads = num_threads;
-                pus[i].seed = rng(std::numeric_limits<uint32>::max());
-                pus[i].sd = &sd;
+                __pus[__i].__bins_end = bin_cursor;
+                for (; __j < bin_cursor; ++__j)
+                  _M_sd._M_bin_proc[__j] = __i;
+                __pus[__i].__num_threads = __num_threads;
+                __pus[__i]._M_seed = __rng(std::numeric_limits<uint32>::max());
+                __pus[__i]._M_sd = &_M_sd;
               }
-            starts[num_threads] = start;
+            _M_starts[__num_threads] = __start;
           } //single
         // Now shuffle in parallel.
-        parallel_random_shuffle_drs_pu(pus);
+        __parallel_random_shuffle_drs_pu(__pus);
       }  // parallel
 
-    delete[] starts;
-    delete[] sd.bin_proc;
-    for (int s = 0; s < (num_bins + 1); ++s)
-      delete[] sd.dist[s];
-    delete[] sd.dist;
-    delete[] sd.temporaries;
+    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[] pus;
+    delete[] __pus;
   }
 
-/** @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.
+/** @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 RandomAccessIterator, typename RandomNumberGenerator>
+template<typename _RAIter, typename RandomNumberGenerator>
   void
-  sequential_random_shuffle(RandomAccessIterator begin, 
-                            RandomAccessIterator end,
-                            RandomNumberGenerator& rng)
+  __sequential_random_shuffle(_RAIter __begin, 
+                            _RAIter __end,
+                            RandomNumberGenerator& __rng)
   {
-    typedef std::iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    typedef typename traits_type::difference_type difference_type;
+    typedef std::iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
 
-    difference_type n = end - begin;
+    _DifferenceType __n = __end - __begin;
     const _Settings& __s = _Settings::get();
 
-    bin_index num_bins, num_bins_cache;
+    _BinIndex _M_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<difference_type>
-            (1, n / (__s.L1_cache_size_lb / sizeof(value_type)));
-    num_bins_cache = round_up_to_pow2(num_bins_cache);
+    __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
-    num_bins = std::min(n, (difference_type)num_bins_cache);
+    _M_num_bins = std::min(__n, (_DifferenceType)__num_bins_cache);
 #if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_TLB
     // 2 TLB entries needed per bin
-    num_bins = std::min((difference_type)__s.TLB_size / 2, num_bins);
+    _M_num_bins = std::min((_DifferenceType)__s.TLB_size / 2, _M_num_bins);
 #endif
-    num_bins = round_up_to_pow2(num_bins);
+    _M_num_bins = __round_up_to_pow2(_M_num_bins);
 
-    if (num_bins < num_bins_cache)
+    if (_M_num_bins < __num_bins_cache)
       {
 #endif
         // Now try the L2 cache, must fit into L2.
-        num_bins_cache =
-            static_cast<bin_index>(std::max<difference_type>(
-                1, n / (__s.L2_cache_size / sizeof(value_type))));
-        num_bins_cache = round_up_to_pow2(num_bins_cache);
+        __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.
-        num_bins = static_cast<bin_index>
-            (std::min(n, static_cast<difference_type>(num_bins_cache)));
+        _M_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
-        num_bins =
-            std::min<difference_type>(__s.TLB_size / 2, num_bins);
+        _M_num_bins =
+            std::min<_DifferenceType>(__s.TLB_size / 2, _M_num_bins);
 #endif
-        num_bins = round_up_to_pow2(num_bins);
+        _M_num_bins = __round_up_to_pow2(_M_num_bins);
 #if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_L1
       }
 #endif
 
-    int num_bits = __log2(num_bins);
+    int _M_num_bits = __log2(_M_num_bins);
 
-    if (num_bins > 1)
+    if (_M_num_bins > 1)
       {
-        value_type* target = static_cast<value_type*>(
-          ::operator new(sizeof(value_type) * n));
-        bin_index* oracles = new bin_index[n];
-        difference_type* dist0 = new difference_type[num_bins + 1],
-                       * dist1 = new difference_type[num_bins + 1];
+        _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];
 
-        for (int b = 0; b < num_bins + 1; ++b)
-          dist0[b] = 0;
+        for (int __b = 0; __b < _M_num_bins + 1; ++__b)
+          __dist0[__b] = 0;
 
-        random_number bitrng(rng(0xFFFFFFFF));
+        _RandomNumber bitrng(__rng(0xFFFFFFFF));
 
-        for (difference_type i = 0; i < n; ++i)
+        for (_DifferenceType __i = 0; __i < __n; ++__i)
           {
-            bin_index oracle = random_number_pow2(num_bits, bitrng);
-            oracles[i] = oracle;
+            _BinIndex __oracle = __random_number_pow2(_M_num_bits, bitrng);
+            __oracles[__i] = __oracle;
 
             // To allow prefix (partial) sum.
-            ++(dist0[oracle + 1]);
+            ++(__dist0[__oracle + 1]);
           }
 
         // Sum up bins.
-        __gnu_sequential::partial_sum(dist0, dist0 + num_bins + 1, dist0);
+        __gnu_sequential::partial_sum(__dist0, __dist0 + _M_num_bins + 1, __dist0);
 
-        for (int b = 0; b < num_bins + 1; ++b)
-          dist1[b] = dist0[b];
+        for (int __b = 0; __b < _M_num_bins + 1; ++__b)
+          __dist1[__b] = __dist0[__b];
 
         // Distribute according to oracles.
-        for (difference_type i = 0; i < n; ++i)
-          ::new(&(target[(dist0[oracles[i]])++])) value_type(*(begin + i));
+        for (_DifferenceType __i = 0; __i < __n; ++__i)
+          ::new(&(__target[(__dist0[__oracles[__i]])++])) _ValueType(*(__begin + __i));
 
-        for (int b = 0; b < num_bins; ++b)
+        for (int __b = 0; __b < _M_num_bins; ++__b)
           {
-            sequential_random_shuffle(target + dist1[b],
-                                      target + dist1[b + 1],
-                                      rng);
+            __sequential_random_shuffle(__target + __dist1[__b],
+                                      __target + __dist1[__b + 1],
+                                      __rng);
           }
 
         // Copy elements back.
-        std::copy(target, target + n, begin);
+        std::copy(__target, __target + __n, __begin);
 
-        delete[] dist0;
-        delete[] dist1;
-        delete[] oracles;
-        ::operator delete(target);
+        delete[] __dist0;
+        delete[] __dist1;
+        delete[] __oracles;
+        ::operator delete(__target);
       }
     else
-      __gnu_sequential::random_shuffle(begin, end, rng);
+      __gnu_sequential::random_shuffle(__begin, __end, __rng);
   }
 
 /** @brief Parallel random public call.
- *  @param begin Begin iterator of sequence.
- *  @param end End iterator of sequence.
- *  @param rng Random number generator to use.
+ *  @param __begin Begin iterator of sequence.
+ *  @param __end End iterator of sequence.
+ *  @param __rng Random number generator to use.
  */
-template<typename RandomAccessIterator, typename RandomNumberGenerator>
+template<typename _RAIter, typename RandomNumberGenerator>
   inline void
-  parallel_random_shuffle(RandomAccessIterator begin,
-                          RandomAccessIterator end,
-                          RandomNumberGenerator rng = random_number())
+  __parallel_random_shuffle(_RAIter __begin,
+                          _RAIter __end,
+                          RandomNumberGenerator __rng = _RandomNumber())
   {
-    typedef std::iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::difference_type difference_type;
-    difference_type n = end - begin;
-    parallel_random_shuffle_drs(begin, end, n, get_max_threads(), rng) ;
+    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) ;
   }
 
 }
diff --git a/libstdc++-v3/include/parallel/search.h b/libstdc++-v3/include/parallel/search.h
index 31a8534..b0a9f69 100644
--- a/libstdc++-v3/include/parallel/search.h
+++ b/libstdc++-v3/include/parallel/search.h
@@ -23,7 +23,7 @@
 // <http://www.gnu.org/licenses/>.
 
 /** @file parallel/search.h
- *  @brief Parallel implementation base for std::search() and
+ *  @brief Parallel implementation __base for std::search() and
  *  std::search_n().
  *  This file is a GNU parallel extension to the Standard C++ Library.
  */
@@ -42,130 +42,130 @@
 namespace __gnu_parallel
 {
   /**
-   *  @brief Precalculate advances for Knuth-Morris-Pratt algorithm.
-   *  @param elements Begin iterator of sequence to search for.
-   *  @param length Length of sequence to search for.
-   *  @param advances Returned offsets. 
+   *  @brief Precalculate __advances for Knuth-Morris-Pratt algorithm.
+   *  @param __elements Begin iterator of sequence to search for.
+   *  @param __length Length of sequence to search for.
+   *  @param __advances Returned __offsets. 
    */
-template<typename RandomAccessIterator, typename _DifferenceTp>
+template<typename _RAIter, typename _DifferenceTp>
   void
-  calc_borders(RandomAccessIterator elements, _DifferenceTp length, 
-              _DifferenceTp* off)
+  __calc_borders(_RAIter __elements, _DifferenceTp __length, 
+              _DifferenceTp* __off)
   {
-    typedef _DifferenceTp difference_type;
+    typedef _DifferenceTp _DifferenceType;
 
-    off[0] = -1;
-    if (length > 1)
-      off[1] = 0;
-    difference_type k = 0;
-    for (difference_type j = 2; j <= length; j++)
+    __off[0] = -1;
+    if (__length > 1)
+      __off[1] = 0;
+    _DifferenceType __k = 0;
+    for (_DifferenceType __j = 2; __j <= __length; __j++)
       {
-        while ((k >= 0) && !(elements[k] == elements[j-1]))
-          k = off[k];
-        off[j] = ++k;
+        while ((__k >= 0) && !(__elements[__k] == __elements[__j-1]))
+          __k = __off[__k];
+        __off[__j] = ++__k;
       }
   }
 
   // Generic parallel find algorithm (requires random access iterator).
 
   /** @brief Parallel std::search.
-   *  @param begin1 Begin iterator of first sequence.
-   *  @param end1 End iterator of first sequence.
-   *  @param begin2 Begin iterator of second sequence.
-   *  @param end2 End iterator of second sequence.
-   *  @param pred Find predicate.
+   *  @param __begin1 Begin iterator of first sequence.
+   *  @param __end1 End iterator of first sequence.
+   *  @param __begin2 Begin iterator of second sequence.
+   *  @param __end2 End iterator of second sequence.
+   *  @param __pred Find predicate.
    *  @return Place of finding in first sequences. */
-template<typename _RandomAccessIterator1,
-	 typename _RandomAccessIterator2,
-	 typename Pred>
-  _RandomAccessIterator1
-  search_template(_RandomAccessIterator1 begin1, _RandomAccessIterator1 end1,
-                  _RandomAccessIterator2 begin2, _RandomAccessIterator2 end2,
-                  Pred pred)
+template<typename __RAIter1,
+	 typename __RAIter2,
+	 typename _Pred>
+  __RAIter1
+  __search_template(__RAIter1 __begin1, __RAIter1 __end1,
+                  __RAIter2 __begin2, __RAIter2 __end2,
+                  _Pred __pred)
   {
-    typedef std::iterator_traits<_RandomAccessIterator1> traits_type;
-    typedef typename traits_type::difference_type difference_type;
+    typedef std::iterator_traits<__RAIter1> _TraitsType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
 
-    _GLIBCXX_CALL((end1 - begin1) + (end2 - begin2));
+    _GLIBCXX_CALL((__end1 - __begin1) + (__end2 - __begin2));
 
-    difference_type pattern_length = end2 - begin2;
+    _DifferenceType __pattern_length = __end2 - __begin2;
 
     // Pattern too short.
-    if(pattern_length <= 0)
-      return end1;
+    if(__pattern_length <= 0)
+      return __end1;
 
     // Last point to start search.
-    difference_type input_length = (end1 - begin1) - pattern_length;
+    _DifferenceType __input_length = (__end1 - __begin1) - __pattern_length;
 
     // Where is first occurrence of pattern? defaults to end.
-    difference_type result = (end1 - begin1);
-    difference_type *splitters;
+    _DifferenceType __result = (__end1 - __begin1);
+    _DifferenceType *__splitters;
 
     // Pattern too long.
-    if (input_length < 0)
-      return end1;
+    if (__input_length < 0)
+      return __end1;
 
-    omp_lock_t result_lock;
-    omp_init_lock(&result_lock);
+    omp_lock_t __result_lock;
+    omp_init_lock(&__result_lock);
 
-    thread_index_t num_threads =
-        std::max<difference_type>(1,
-            std::min<difference_type>(input_length, get_max_threads()));
+    _ThreadIndex __num_threads =
+        std::max<_DifferenceType>(1,
+            std::min<_DifferenceType>(__input_length, __get_max_threads()));
 
-    difference_type advances[pattern_length];
-    calc_borders(begin2, pattern_length, advances);
+    _DifferenceType __advances[__pattern_length];
+    __calc_borders(__begin2, __pattern_length, __advances);
 
-#   pragma omp parallel num_threads(num_threads)
+#   pragma omp parallel num_threads(__num_threads)
       {
 #       pragma omp single
           {
-            num_threads = omp_get_num_threads();
-            splitters = new difference_type[num_threads + 1];
-            equally_split(input_length, num_threads, splitters);
+            __num_threads = omp_get_num_threads();
+            __splitters = new _DifferenceType[__num_threads + 1];
+            equally_split(__input_length, __num_threads, __splitters);
           }
 
-        thread_index_t iam = omp_get_thread_num();
+        _ThreadIndex __iam = omp_get_thread_num();
 
-        difference_type start = splitters[iam], stop = splitters[iam + 1];
+        _DifferenceType __start = __splitters[__iam], __stop = __splitters[__iam + 1];
 
-        difference_type pos_in_pattern = 0;
-        bool found_pattern = false;
+        _DifferenceType __pos_in_pattern = 0;
+        bool __found_pattern = false;
 
-        while (start <= stop && !found_pattern)
+        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)
+            if (__result < __start)
               break;
-            while (pred(begin1[start + pos_in_pattern],
-                         begin2[pos_in_pattern]))
+            while (__pred(__begin1[__start + __pos_in_pattern],
+                         __begin2[__pos_in_pattern]))
               {
-                ++pos_in_pattern;
-                if (pos_in_pattern == pattern_length)
+                ++__pos_in_pattern;
+                if (__pos_in_pattern == __pattern_length)
                   {
                     // Found new candidate for result.
-                            omp_set_lock(&result_lock);
-                    result = std::min(result, start);
-                            omp_unset_lock(&result_lock);
+                            omp_set_lock(&__result_lock);
+                    __result = std::min(__result, __start);
+                            omp_unset_lock(&__result_lock);
 
-                    found_pattern = true;
+                    __found_pattern = true;
                     break;
                   }
               }
             // Make safe jump.
-            start += (pos_in_pattern - advances[pos_in_pattern]);
-            pos_in_pattern =
-                (advances[pos_in_pattern] < 0) ? 0 : advances[pos_in_pattern];
+            __start += (__pos_in_pattern - __advances[__pos_in_pattern]);
+            __pos_in_pattern =
+                (__advances[__pos_in_pattern] < 0) ? 0 : __advances[__pos_in_pattern];
           }
       } //parallel
 
-    omp_destroy_lock(&result_lock);
+    omp_destroy_lock(&__result_lock);
 
-    delete[] splitters;
+    delete[] __splitters;
 
     // Return iterator on found element.
-    return (begin1 + result);
+    return (__begin1 + __result);
   }
 } // end namespace
 
diff --git a/libstdc++-v3/include/parallel/set_operations.h b/libstdc++-v3/include/parallel/set_operations.h
index 2800819..a726d30 100644
--- a/libstdc++-v3/include/parallel/set_operations.h
+++ b/libstdc++-v3/include/parallel/set_operations.h
@@ -41,482 +41,482 @@
 
 namespace __gnu_parallel
 {
-template<typename InputIterator, typename OutputIterator>
-  OutputIterator
-  copy_tail(std::pair<InputIterator, InputIterator> b,
-            std::pair<InputIterator, InputIterator> e, OutputIterator r)
+template<typename _IIter, typename _OutputIterator>
+  _OutputIterator
+  copy_tail(std::pair<_IIter, _IIter> __b,
+            std::pair<_IIter, _IIter> __e, _OutputIterator __r)
   {
-    if (b.first != e.first)
+    if (__b.first != __e.first)
       {
         do
           {
-            *r++ = *b.first++;
+            *__r++ = *__b.first++;
           }
-        while (b.first != e.first);
+        while (__b.first != __e.first);
       }
     else
       {
-        while (b.second != e.second)
-          *r++ = *b.second++;
+        while (__b.second != __e.second)
+          *__r++ = *__b.second++;
       }
-    return r;
+    return __r;
   }
 
-template<typename InputIterator,
-	 typename OutputIterator,
-	 typename Comparator>
+template<typename _IIter,
+	 typename _OutputIterator,
+	 typename _Compare>
   struct symmetric_difference_func
   {
-    typedef std::iterator_traits<InputIterator> traits_type;
-    typedef typename traits_type::difference_type difference_type;
-    typedef typename std::pair<InputIterator, InputIterator> iterator_pair;
+    typedef std::iterator_traits<_IIter> _TraitsType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
+    typedef typename std::pair<_IIter, _IIter> _IteratorPair;
 
-    symmetric_difference_func(Comparator c) : comp(c) {}
+    symmetric_difference_func(_Compare __c) : __comp(__c) {}
 
-    Comparator comp;
+    _Compare __comp;
 
-    OutputIterator
-    invoke(InputIterator a, InputIterator b,
-	   InputIterator c, InputIterator d,
-	   OutputIterator r) const
+    _OutputIterator
+    _M_invoke(_IIter __a, _IIter __b,
+	   _IIter __c, _IIter d,
+	   _OutputIterator __r) const
     {
-      while (a != b && c != d)
+      while (__a != __b && __c != d)
         {
-          if (comp(*a, *c))
+          if (__comp(*__a, *__c))
             {
-              *r = *a;
-              ++a;
-              ++r;
+              *__r = *__a;
+              ++__a;
+              ++__r;
             }
-          else if (comp(*c, *a))
+          else if (__comp(*__c, *__a))
             {
-              *r = *c;
-              ++c;
-              ++r;
+              *__r = *__c;
+              ++__c;
+              ++__r;
             }
           else
             {
-              ++a;
-              ++c;
+              ++__a;
+              ++__c;
             }
         }
-      return std::copy(c, d, std::copy(a, b, r));
+      return std::copy(__c, d, std::copy(__a, __b, __r));
     }
 
-    difference_type
-    count(InputIterator a, InputIterator b,
-	  InputIterator c, InputIterator d) const
+    _DifferenceType
+    __count(_IIter __a, _IIter __b,
+	  _IIter __c, _IIter d) const
     {
-      difference_type counter = 0;
+      _DifferenceType __counter = 0;
 
-      while (a != b && c != d)
+      while (__a != __b && __c != d)
         {
-          if (comp(*a, *c))
+          if (__comp(*__a, *__c))
             {
-              ++a;
-              ++counter;
+              ++__a;
+              ++__counter;
             }
-          else if (comp(*c, *a))
+          else if (__comp(*__c, *__a))
             {
-              ++c;
-              ++counter;
+              ++__c;
+              ++__counter;
             }
           else
             {
-              ++a;
-              ++c;
+              ++__a;
+              ++__c;
             }
         }
 
-      return counter + (b - a) + (d - c);
+      return __counter + (__b - __a) + (d - __c);
     }
 
-    OutputIterator
-    first_empty(InputIterator c, InputIterator 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); }
 
-    OutputIterator
-    second_empty(InputIterator a, InputIterator b, OutputIterator out) const
-    { return std::copy(a, b, out); }
+    _OutputIterator
+    __second_empty(_IIter __a, _IIter __b, _OutputIterator __out) const
+    { return std::copy(__a, __b, __out); }
   };
 
 
-template<typename InputIterator,
-	 typename OutputIterator,
-	 typename Comparator>
-  struct difference_func
+template<typename _IIter,
+	 typename _OutputIterator,
+	 typename _Compare>
+  struct __difference_func
   {
-    typedef std::iterator_traits<InputIterator> traits_type;
-    typedef typename traits_type::difference_type difference_type;
-    typedef typename std::pair<InputIterator, InputIterator> iterator_pair;
+    typedef std::iterator_traits<_IIter> _TraitsType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
+    typedef typename std::pair<_IIter, _IIter> _IteratorPair;
 
-    difference_func(Comparator c) : comp(c) {}
+    __difference_func(_Compare __c) : __comp(__c) {}
 
-    Comparator comp;
+    _Compare __comp;
 
-    OutputIterator
-    invoke(InputIterator a, InputIterator b, InputIterator c, InputIterator d,
-          OutputIterator r) const
+    _OutputIterator
+    _M_invoke(_IIter __a, _IIter __b, _IIter __c, _IIter d,
+          _OutputIterator __r) const
     {
-      while (a != b && c != d)
+      while (__a != __b && __c != d)
         {
-          if (comp(*a, *c))
+          if (__comp(*__a, *__c))
             {
-              *r = *a;
-              ++a;
-              ++r;
+              *__r = *__a;
+              ++__a;
+              ++__r;
             }
-          else if (comp(*c, *a))
-            { ++c; }
+          else if (__comp(*__c, *__a))
+            { ++__c; }
           else
             {
-              ++a;
-              ++c;
+              ++__a;
+              ++__c;
             }
         }
-      return std::copy(a, b, r);
+      return std::copy(__a, __b, __r);
     }
 
-    difference_type
-    count(InputIterator a, InputIterator b,
-	  InputIterator c, InputIterator d) const
+    _DifferenceType
+    __count(_IIter __a, _IIter __b,
+	  _IIter __c, _IIter d) const
     {
-      difference_type counter = 0;
+      _DifferenceType __counter = 0;
 
-      while (a != b && c != d)
+      while (__a != __b && __c != d)
         {
-          if (comp(*a, *c))
+          if (__comp(*__a, *__c))
             {
-              ++a;
-              ++counter;
+              ++__a;
+              ++__counter;
             }
-          else if (comp(*c, *a))
-            { ++c; }
+          else if (__comp(*__c, *__a))
+            { ++__c; }
           else
-            { ++a; ++c; }
+            { ++__a; ++__c; }
         }
 
-      return counter + (b - a);
+      return __counter + (__b - __a);
     }
 
-    inline OutputIterator
-    first_empty(InputIterator c, InputIterator d, OutputIterator out) const
-    { return out; }
+    inline _OutputIterator
+    __first_empty(_IIter __c, _IIter d, _OutputIterator __out) const
+    { return __out; }
 
-    inline OutputIterator
-    second_empty(InputIterator a, InputIterator b, OutputIterator out) const
-    { return std::copy(a, b, out); }
+    inline _OutputIterator
+    __second_empty(_IIter __a, _IIter __b, _OutputIterator __out) const
+    { return std::copy(__a, __b, __out); }
   };
 
 
-template<typename InputIterator,
-	 typename OutputIterator,
-	 typename Comparator>
-  struct intersection_func
+template<typename _IIter,
+	 typename _OutputIterator,
+	 typename _Compare>
+  struct __intersection_func
   {
-    typedef std::iterator_traits<InputIterator> traits_type;
-    typedef typename traits_type::difference_type difference_type;
-    typedef typename std::pair<InputIterator, InputIterator> iterator_pair;
+    typedef std::iterator_traits<_IIter> _TraitsType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
+    typedef typename std::pair<_IIter, _IIter> _IteratorPair;
 
-    intersection_func(Comparator c) : comp(c) {}
+    __intersection_func(_Compare __c) : __comp(__c) {}
 
-    Comparator comp;
+    _Compare __comp;
 
-    OutputIterator
-    invoke(InputIterator a, InputIterator b, InputIterator c, InputIterator d,
-          OutputIterator r) const
+    _OutputIterator
+    _M_invoke(_IIter __a, _IIter __b, _IIter __c, _IIter d,
+          _OutputIterator __r) const
     {
-      while (a != b && c != d)
+      while (__a != __b && __c != d)
         {
-          if (comp(*a, *c))
-            { ++a; }
-          else if (comp(*c, *a))
-            { ++c; }
+          if (__comp(*__a, *__c))
+            { ++__a; }
+          else if (__comp(*__c, *__a))
+            { ++__c; }
           else
             {
-              *r = *a;
-              ++a;
-              ++c;
-              ++r;
+              *__r = *__a;
+              ++__a;
+              ++__c;
+              ++__r;
             }
         }
 
-      return r;
+      return __r;
     }
 
-    difference_type
-    count(InputIterator a, InputIterator b,
-	  InputIterator c, InputIterator d) const
+    _DifferenceType
+    __count(_IIter __a, _IIter __b,
+	  _IIter __c, _IIter d) const
     {
-      difference_type counter = 0;
+      _DifferenceType __counter = 0;
 
-      while (a != b && c != d)
+      while (__a != __b && __c != d)
         {
-          if (comp(*a, *c))
-            { ++a; }
-          else if (comp(*c, *a))
-            { ++c; }
+          if (__comp(*__a, *__c))
+            { ++__a; }
+          else if (__comp(*__c, *__a))
+            { ++__c; }
           else
             {
-              ++a;
-              ++c;
-              ++counter;
+              ++__a;
+              ++__c;
+              ++__counter;
             }
         }
 
-      return counter;
+      return __counter;
     }
 
-    inline OutputIterator
-    first_empty(InputIterator c, InputIterator d, OutputIterator out) const
-    { return out; }
+    inline _OutputIterator
+    __first_empty(_IIter __c, _IIter d, _OutputIterator __out) const
+    { return __out; }
 
-    inline OutputIterator
-    second_empty(InputIterator a, InputIterator b, OutputIterator out) const
-    { return out; }
+    inline _OutputIterator
+    __second_empty(_IIter __a, _IIter __b, _OutputIterator __out) const
+    { return __out; }
   };
 
-template<class InputIterator, class OutputIterator, class Comparator>
-  struct union_func
+template<class _IIter, class _OutputIterator, class _Compare>
+  struct __union_func
   {
-    typedef typename std::iterator_traits<InputIterator>::difference_type
-    difference_type;
+    typedef typename std::iterator_traits<_IIter>::difference_type
+    _DifferenceType;
 
-    union_func(Comparator c) : comp(c) {}
+    __union_func(_Compare __c) : __comp(__c) {}
 
-    Comparator comp;
+    _Compare __comp;
 
-    OutputIterator
-    invoke(InputIterator a, const InputIterator b, InputIterator c,
-          const InputIterator d, OutputIterator r) const
+    _OutputIterator
+    _M_invoke(_IIter __a, const _IIter __b, _IIter __c,
+          const _IIter d, _OutputIterator __r) const
     {
-      while (a != b && c != d)
+      while (__a != __b && __c != d)
         {
-          if (comp(*a, *c))
+          if (__comp(*__a, *__c))
             {
-              *r = *a;
-              ++a;
+              *__r = *__a;
+              ++__a;
             }
-          else if (comp(*c, *a))
+          else if (__comp(*__c, *__a))
             {
-              *r = *c;
-              ++c;
+              *__r = *__c;
+              ++__c;
             }
           else
             {
-              *r = *a;
-              ++a;
-              ++c;
+              *__r = *__a;
+              ++__a;
+              ++__c;
             }
-          ++r;
+          ++__r;
         }
-      return std::copy(c, d, std::copy(a, b, r));
+      return std::copy(__c, d, std::copy(__a, __b, __r));
     }
 
-    difference_type
-    count(InputIterator a, InputIterator b,
-	  InputIterator c, InputIterator d) const
+    _DifferenceType
+    __count(_IIter __a, _IIter __b,
+	  _IIter __c, _IIter d) const
     {
-      difference_type counter = 0;
+      _DifferenceType __counter = 0;
 
-      while (a != b && c != d)
+      while (__a != __b && __c != d)
         {
-          if (comp(*a, *c))
-            { ++a; }
-          else if (comp(*c, *a))
-            { ++c; }
+          if (__comp(*__a, *__c))
+            { ++__a; }
+          else if (__comp(*__c, *__a))
+            { ++__c; }
           else
             {
-              ++a;
-              ++c;
+              ++__a;
+              ++__c;
             }
-          ++counter;
+          ++__counter;
         }
 
-      counter += (b - a);
-      counter += (d - c);
-      return counter;
+      __counter += (__b - __a);
+      __counter += (d - __c);
+      return __counter;
     }
 
-    inline OutputIterator
-    first_empty(InputIterator c, InputIterator d, OutputIterator out) const
-    { return std::copy(c, d, out); }
+    inline _OutputIterator
+    __first_empty(_IIter __c, _IIter d, _OutputIterator __out) const
+    { return std::copy(__c, d, __out); }
 
-    inline OutputIterator
-    second_empty(InputIterator a, InputIterator b, OutputIterator out) const
-    { return std::copy(a, b, out); }
+    inline _OutputIterator
+    __second_empty(_IIter __a, _IIter __b, _OutputIterator __out) const
+    { return std::copy(__a, __b, __out); }
   };
 
-template<typename InputIterator,
-	 typename OutputIterator,
+template<typename _IIter,
+	 typename _OutputIterator,
 	 typename Operation>
-  OutputIterator
-  parallel_set_operation(InputIterator begin1, InputIterator end1,
-                         InputIterator begin2, InputIterator end2,
-                         OutputIterator result, Operation op)
+  _OutputIterator
+  __parallel_set_operation(_IIter __begin1, _IIter __end1,
+                         _IIter __begin2, _IIter __end2,
+                         _OutputIterator __result, Operation __op)
   {
-    _GLIBCXX_CALL((end1 - begin1) + (end2 - begin2))
+    _GLIBCXX_CALL((__end1 - __begin1) + (__end2 - __begin2))
 
-    typedef std::iterator_traits<InputIterator> traits_type;
-    typedef typename traits_type::difference_type difference_type;
-    typedef typename std::pair<InputIterator, InputIterator> iterator_pair;
+    typedef std::iterator_traits<_IIter> _TraitsType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
+    typedef typename std::pair<_IIter, _IIter> _IteratorPair;
 
-    if (begin1 == end1)
-      return op.first_empty(begin2, end2, result);
+    if (__begin1 == __end1)
+      return __op.__first_empty(__begin2, __end2, __result);
 
-    if (begin2 == end2)
-      return op.second_empty(begin1, end1, result);
+    if (__begin2 == __end2)
+      return __op.__second_empty(__begin1, __end1, __result);
 
-    const difference_type size = (end1 - begin1) + (end2 - begin2);
+    const _DifferenceType size = (__end1 - __begin1) + (__end2 - __begin2);
 
-    const iterator_pair sequence[ 2 ] =
-        { std::make_pair(begin1, end1), std::make_pair(begin2, end2) } ;
-    OutputIterator return_value = result;
-    difference_type *borders;
-    iterator_pair *block_begins;
-    difference_type* lengths;
+    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;
 
-    thread_index_t num_threads =
-        std::min<difference_type>(get_max_threads(),
-            std::min(end1 - begin1, end2 - begin2));
+    _ThreadIndex __num_threads =
+        std::min<_DifferenceType>(__get_max_threads(),
+            std::min(__end1 - __begin1, __end2 - __begin2));
 
-#   pragma omp parallel num_threads(num_threads)
+#   pragma omp parallel num_threads(__num_threads)
       {
 #       pragma omp single
           {
-            num_threads = omp_get_num_threads();
-
-            borders = new difference_type[num_threads + 2];
-            equally_split(size, num_threads + 1, borders);
-            block_begins = new iterator_pair[num_threads + 1];
-            // Very start.
-            block_begins[0] = std::make_pair(begin1, begin2);
-            lengths = new difference_type[num_threads];
+            __num_threads = omp_get_num_threads();
+
+            __borders = new _DifferenceType[__num_threads + 2];
+            equally_split(size, __num_threads + 1, __borders);
+            __block_begins = new _IteratorPair[__num_threads + 1];
+            // Very __start.
+            __block_begins[0] = std::make_pair(__begin1, __begin2);
+            __lengths = new _DifferenceType[__num_threads];
           } //single
 
-        thread_index_t iam = omp_get_thread_num();
+        _ThreadIndex __iam = omp_get_thread_num();
 
-        // Result from multiseq_partition.
-        InputIterator offset[2];
-        const difference_type rank = borders[iam + 1];
+        // _Result from multiseq_partition.
+        _IIter __offset[2];
+        const _DifferenceType __rank = __borders[__iam + 1];
 
-        multiseq_partition(sequence, sequence + 2, rank, offset, op.comp);
+        multiseq_partition(__sequence, __sequence + 2, __rank, __offset, __op.__comp);
 
         // allowed to read?
         // together
-        // *(offset[ 0 ] - 1) == *offset[ 1 ]
-        if (offset[ 0 ] != begin1 && offset[ 1 ] != end2
-            && !op.comp(*(offset[ 0 ] - 1), *offset[ 1 ])
-            && !op.comp(*offset[ 1 ], *(offset[ 0 ] - 1)))
+        // *(__offset[ 0 ] - 1) == *__offset[ 1 ]
+        if (__offset[ 0 ] != __begin1 && __offset[ 1 ] != __end2
+            && !__op.__comp(*(__offset[ 0 ] - 1), *__offset[ 1 ])
+            && !__op.__comp(*__offset[ 1 ], *(__offset[ 0 ] - 1)))
           {
             // Avoid split between globally equal elements: move one to
             // front in first sequence.
-            --offset[ 0 ];
+            --__offset[ 0 ];
           }
 
-        iterator_pair block_end = block_begins[ iam + 1 ] =
-            iterator_pair(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
 
-        iterator_pair 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.
-        if (iam == 0)
+        if (__iam == 0)
           {
             // The first thread can copy already.
-            lengths[ iam ] = op.invoke(block_begin.first, block_end.first,
-                                       block_begin.second, block_end.second,
-                                       result)
-                              - result;
+            __lengths[ __iam ] = __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);
+            __lengths[ __iam ] = __op.__count(__block_begin.first, block_end.first,
+                        __block_begin.second, block_end.second);
           }
 
         // Make sure everyone wrote their lengths.
 #       pragma omp barrier
 
-        OutputIterator r = result;
+        _OutputIterator __r = __result;
 
-        if (iam == 0)
+        if (__iam == 0)
           {
             // Do the last block.
-            for (int i = 0; i < num_threads; ++i)
-              r += lengths[i];
+            for (int __i = 0; __i < __num_threads; ++__i)
+              __r += __lengths[__i];
 
-            block_begin = block_begins[num_threads];
+            __block_begin = __block_begins[__num_threads];
 
             // Return the result iterator of the last block.
-            return_value = op.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
           {
-            for (int i = 0; i < iam; ++i)
-              r += lengths[ i ];
+            for (int __i = 0; __i < __iam; ++__i)
+              __r += __lengths[ __i ];
 
             // Reset begins for copy pass.
-            op.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;
   }
 
 
-template<typename InputIterator,
-	 typename OutputIterator,
-	 typename Comparator>
-  inline OutputIterator
-  parallel_set_union(InputIterator begin1, InputIterator end1,
-                     InputIterator begin2, InputIterator end2,
-                     OutputIterator result, Comparator comp)
+template<typename _IIter,
+	 typename _OutputIterator,
+	 typename _Compare>
+  inline _OutputIterator
+  __parallel_set_union(_IIter __begin1, _IIter __end1,
+                     _IIter __begin2, _IIter __end2,
+                     _OutputIterator __result, _Compare __comp)
   {
-    return parallel_set_operation(begin1, end1, begin2, end2, result,
-        union_func< InputIterator, OutputIterator, Comparator>(comp));
+    return __parallel_set_operation(__begin1, __end1, __begin2, __end2, __result,
+        __union_func< _IIter, _OutputIterator, _Compare>(__comp));
   }
 
-template<typename InputIterator,
-	 typename OutputIterator,
-	 typename Comparator>
-  inline OutputIterator
-  parallel_set_intersection(InputIterator begin1, InputIterator end1,
-                            InputIterator begin2, InputIterator end2,
-                            OutputIterator result, Comparator comp)
+template<typename _IIter,
+	 typename _OutputIterator,
+	 typename _Compare>
+  inline _OutputIterator
+  __parallel_set_intersection(_IIter __begin1, _IIter __end1,
+                            _IIter __begin2, _IIter __end2,
+                            _OutputIterator __result, _Compare __comp)
   {
-    return parallel_set_operation(begin1, end1, begin2, end2, result,
-        intersection_func<InputIterator, OutputIterator, Comparator>(comp));
+    return __parallel_set_operation(__begin1, __end1, __begin2, __end2, __result,
+        __intersection_func<_IIter, _OutputIterator, _Compare>(__comp));
   }
 
-template<typename InputIterator,
-	 typename OutputIterator,
-	 typename Comparator>
-  inline OutputIterator
-  parallel_set_difference(InputIterator begin1, InputIterator end1,
-                          InputIterator begin2, InputIterator end2,
-                          OutputIterator result, Comparator comp)
+template<typename _IIter,
+	 typename _OutputIterator,
+	 typename _Compare>
+  inline _OutputIterator
+  __parallel_set_difference(_IIter __begin1, _IIter __end1,
+                          _IIter __begin2, _IIter __end2,
+                          _OutputIterator __result, _Compare __comp)
   {
-    return parallel_set_operation(begin1, end1, begin2, end2, result,
-        difference_func<InputIterator, OutputIterator, Comparator>(comp));
+    return __parallel_set_operation(__begin1, __end1, __begin2, __end2, __result,
+        __difference_func<_IIter, _OutputIterator, _Compare>(__comp));
   }
 
-template<typename InputIterator,
-	 typename OutputIterator,
-	 typename Comparator>
-  inline OutputIterator
-  parallel_set_symmetric_difference(InputIterator begin1, InputIterator end1,
-                                    InputIterator begin2, InputIterator end2,
-                                    OutputIterator result, Comparator comp)
+template<typename _IIter,
+	 typename _OutputIterator,
+	 typename _Compare>
+  inline _OutputIterator
+  __parallel_set_symmetric_difference(_IIter __begin1, _IIter __end1,
+                                    _IIter __begin2, _IIter __end2,
+                                    _OutputIterator __result, _Compare __comp)
   {
-    return parallel_set_operation(begin1, end1, begin2, end2, result,
-        symmetric_difference_func<InputIterator, OutputIterator, Comparator>
-            (comp));
+    return __parallel_set_operation(__begin1, __end1, __begin2, __end2, __result,
+        symmetric_difference_func<_IIter, _OutputIterator, _Compare>
+            (__comp));
   }
 
 }
diff --git a/libstdc++-v3/include/parallel/settings.h b/libstdc++-v3/include/parallel/settings.h
index e4873b4..525bd9e 100644
--- a/libstdc++-v3/include/parallel/settings.h
+++ b/libstdc++-v3/include/parallel/settings.h
@@ -30,7 +30,7 @@
  *  @section parallelization_decision 
  *  The decision whether to run an algorithm in parallel.
  *
- *  There are several ways the user can switch on and off the parallel
+ *  There are several ways the user can switch on and __off the parallel
  *  execution of an algorithm, both at compile- and run-time.
  *
  *  Only sequential execution can be forced at compile-time.  This
@@ -46,11 +46,11 @@
  *
  *  To force sequential execution of an algorithm ultimately at
  *  compile-time, the user must add the tag
- *  __gnu_parallel::sequential_tag() to the end of the parameter list,
+*  gnu_parallel::sequential_tag() to the end of the parameter list,
  *  e. g.
  *
  *  \code
- *  std::sort(v.begin(), v.end(), __gnu_parallel::sequential_tag());
+ *  std::sort(__v.begin(), __v.end(), __gnu_parallel::sequential_tag());
  *  \endcode
  *
  *  This is compatible with all overloaded algorithm variants.  No
@@ -60,18 +60,18 @@
  *  If the algorithm call is not forced to be executed sequentially
  *  at compile-time, the decision is made at run-time.
  *  The global variable __gnu_parallel::_Settings::algorithm_strategy
- *  is checked. It is a tristate variable corresponding to:
+ *  is checked. _It is a tristate variable corresponding to:
  *
  *  a. force_sequential, meaning the sequential algorithm is executed.
- *  b. force_parallel, meaning the parallel algorithm is executed.
- *  c. heuristic
+*  b. force_parallel, meaning the parallel algorithm is executed.
+*  c. heuristic
  *
  *  For heuristic, the parallel algorithm implementation is called
  *  only if the input size is sufficiently large.  For most
  *  algorithms, the input size is the (combined) length of the input
- *  sequence(s).  The threshold can be set by the user, individually
+*  sequence(__s).  The threshold can be set by the user, individually
  *  for each algorithm.  The according variables are called
- *  __gnu_parallel::_Settings::[algorithm]_minimal_n .
+*  gnu_parallel::_Settings::[algorithm]_minimal_n .
  *
  *  For some of the algorithms, there are even more tuning options,
  *  e. g. the ability to choose from multiple algorithm variants.  See
@@ -88,24 +88,24 @@
 /** 
   * @brief Determine at compile(?)-time if the parallel variant of an
   * algorithm should be called.
-  * @param c A condition that is convertible to bool that is overruled by
+  * @param __c A condition that is convertible to bool that is overruled by
   * __gnu_parallel::_Settings::algorithm_strategy. Usually a decision
   * based on the input size.
   */
-#define _GLIBCXX_PARALLEL_CONDITION(c) (__gnu_parallel::_Settings::get().algorithm_strategy != __gnu_parallel::force_sequential && ((__gnu_parallel::get_max_threads() > 1 && (c)) || __gnu_parallel::_Settings::get().algorithm_strategy == __gnu_parallel::force_parallel))
+#define _GLIBCXX_PARALLEL_CONDITION(__c) (__gnu_parallel::_Settings::get().algorithm_strategy != __gnu_parallel::force_sequential && ((__gnu_parallel::__get_max_threads() > 1 && (__c)) || __gnu_parallel::_Settings::get().algorithm_strategy == __gnu_parallel::force_parallel))
 
 /*
 inline bool
-parallel_condition(bool c)
+parallel_condition(bool __c)
 {
   bool ret = false;
-  const _Settings& s = _Settings::get();
-  if (s.algorithm_strategy != force_seqential)
+  const _Settings& __s = _Settings::get();
+  if (__s.algorithm_strategy != force_seqential)
     {
-      if (s.algorithm_strategy == force_parallel)
+      if (__s.algorithm_strategy == force_parallel)
 	ret = true;
       else
-	ret = get_max_threads() > 1 && c;
+	ret = __get_max_threads() > 1 && __c;
     }
   return ret;
 }
@@ -131,49 +131,49 @@ namespace __gnu_parallel
     // Per-algorithm settings.
 
     /// Minimal input size for accumulate.
-    sequence_index_t 		accumulate_minimal_n;
+    _SequenceIndex 		accumulate_minimal_n;
 
     /// Minimal input size for adjacent_difference.
     unsigned int 		adjacent_difference_minimal_n;
 
     /// Minimal input size for count and count_if.
-    sequence_index_t 		count_minimal_n;
+    _SequenceIndex 		count_minimal_n;
 
     /// Minimal input size for fill.
-    sequence_index_t 		fill_minimal_n;
+    _SequenceIndex 		fill_minimal_n;
 
     /// Block size increase factor for find.
     double 			find_increasing_factor;
 
     /// Initial block size for find.
-    sequence_index_t 		find_initial_block_size;
+    _SequenceIndex 		find_initial_block_size;
 
     /// Maximal block size for find.
-    sequence_index_t 		find_maximum_block_size;
+    _SequenceIndex 		find_maximum_block_size;
 
     /// Start with looking for this many elements sequentially, for find.
-    sequence_index_t 		find_sequential_search_size;
+    _SequenceIndex 		find_sequential_search_size;
 
     /// Minimal input size for for_each.
-    sequence_index_t 		for_each_minimal_n;
+    _SequenceIndex 		for_each_minimal_n;
 
     /// Minimal input size for generate.
-    sequence_index_t 		generate_minimal_n;
+    _SequenceIndex 		generate_minimal_n;
 
     /// Minimal input size for max_element.
-    sequence_index_t 		max_element_minimal_n;
+    _SequenceIndex 		max_element_minimal_n;
 
     /// Minimal input size for merge.
-    sequence_index_t 		merge_minimal_n;
+    _SequenceIndex 		merge_minimal_n;
 
     /// Oversampling factor for merge.
     unsigned int 		merge_oversampling;
 
     /// Minimal input size for min_element.
-    sequence_index_t 		min_element_minimal_n;
+    _SequenceIndex 		min_element_minimal_n;
 
     /// Minimal input size for multiway_merge.
-    sequence_index_t 		multiway_merge_minimal_n;
+    _SequenceIndex 		multiway_merge_minimal_n;
 
     /// Oversampling factor for multiway_merge.
     int 			multiway_merge_minimal_k;
@@ -182,22 +182,22 @@ namespace __gnu_parallel
     unsigned int 		multiway_merge_oversampling;
 
     /// Minimal input size for nth_element.
-    sequence_index_t 		nth_element_minimal_n;
+    _SequenceIndex 		nth_element_minimal_n;
 
     /// Chunk size for partition.
-    sequence_index_t 		partition_chunk_size;
+    _SequenceIndex 		partition_chunk_size;
 
     /// Chunk size for partition, relative to input size.  If > 0.0,
     /// this value overrides partition_chunk_size.
     double 			partition_chunk_share;
 
     /// Minimal input size for partition.
-    sequence_index_t 		partition_minimal_n;
+    _SequenceIndex 		partition_minimal_n;
 
     /// Minimal input size for partial_sort.
-    sequence_index_t 		partial_sort_minimal_n;
+    _SequenceIndex 		partial_sort_minimal_n;
 
-    /// Ratio for partial_sum. Assume "sum and write result" to be
+    /// Ratio for partial_sum. Assume "sum and write __result" to be
     /// this factor slower than just "sum".
     float 			partial_sum_dilation;
 
@@ -208,22 +208,22 @@ namespace __gnu_parallel
     unsigned int 		random_shuffle_minimal_n;
 
     /// Minimal input size for replace and replace_if.
-    sequence_index_t 		replace_minimal_n;
+    _SequenceIndex 		replace_minimal_n;
 
     /// Minimal input size for set_difference.
-    sequence_index_t 		set_difference_minimal_n;
+    _SequenceIndex 		set_difference_minimal_n;
 
     /// Minimal input size for set_intersection.
-    sequence_index_t 		set_intersection_minimal_n;
+    _SequenceIndex 		set_intersection_minimal_n;
 
     /// Minimal input size for set_symmetric_difference.
-    sequence_index_t 		set_symmetric_difference_minimal_n;
+    _SequenceIndex 		set_symmetric_difference_minimal_n;
 
     /// Minimal input size for set_union.
-    sequence_index_t 		set_union_minimal_n;
+    _SequenceIndex 		set_union_minimal_n;
 
     /// Minimal input size for parallel sorting.
-    sequence_index_t 		sort_minimal_n;
+    _SequenceIndex 		sort_minimal_n;
 
     /// Oversampling factor for parallel std::sort (MWMS).
     unsigned int 		sort_mwms_oversampling;
@@ -231,38 +231,38 @@ namespace __gnu_parallel
     /// Such many samples to take to find a good pivot (quicksort).
     unsigned int 		sort_qs_num_samples_preset;
 
-    /// Maximal subsequence length to switch to unbalanced base case.
+    /// Maximal subsequence __length to switch to unbalanced __base case.
     /// Applies to std::sort with dynamically load-balanced quicksort.
-    sequence_index_t 		sort_qsb_base_case_maximal_n;
+    _SequenceIndex 		sort_qsb_base_case_maximal_n;
 
     /// Minimal input size for parallel std::transform.
-    sequence_index_t 		transform_minimal_n;
+    _SequenceIndex 		transform_minimal_n;
 
     /// Minimal input size for unique_copy. 
-    sequence_index_t 		unique_copy_minimal_n;
+    _SequenceIndex 		unique_copy_minimal_n;
 
-    sequence_index_t 		workstealing_chunk_size;
+    _SequenceIndex 		workstealing_chunk_size;
 
     // Hardware dependent tuning parameters.
 
-    /// Size of the L1 cache in bytes (underestimation).
+    /// size of the L1 cache in bytes (underestimation).
     unsigned long long 		L1_cache_size;
 
-    /// Size of the L2 cache in bytes (underestimation).
+    /// size of the L2 cache in bytes (underestimation).
     unsigned long long 		L2_cache_size;
 
-    /// Size of the Translation Lookaside Buffer (underestimation).
+    /// size of the Translation Lookaside Buffer (underestimation).
     unsigned int 		TLB_size;
 
     /// Overestimation of cache line size.  Used to avoid false
-    /// sharing, i. e. elements of different threads are at least this
+    /// sharing, i.e. elements of different threads are at least this
     /// amount apart.
     unsigned int 		cache_line_size;
 
     // Statistics.
 
     /// The number of stolen ranges in load-balanced quicksort.
-    sequence_index_t 		qsb_steals;
+    _SequenceIndex 		qsb_steals;
 
     /// Get the global settings.
     _GLIBCXX_CONST static const _Settings&
diff --git a/libstdc++-v3/include/parallel/sort.h b/libstdc++-v3/include/parallel/sort.h
index de226e8..a34d773 100644
--- a/libstdc++-v3/include/parallel/sort.h
+++ b/libstdc++-v3/include/parallel/sort.h
@@ -55,174 +55,174 @@
 namespace __gnu_parallel
 {
 	//prototype
-  template<bool stable, typename RandomAccessIterator,
-           typename Comparator, typename Parallelism>
+  template<bool __stable, typename _RAIter,
+           typename _Compare, typename _Parallelism>
   void
-  parallel_sort(RandomAccessIterator begin, RandomAccessIterator end,
-  Comparator comp, Parallelism parallelism);
+  parallel_sort(_RAIter __begin, _RAIter __end,
+  _Compare __comp, _Parallelism __parallelism);
 	
   /** 
    *  @brief Choose multiway mergesort, splitting variant at run-time,
    *  for parallel sorting.
-   *  @param begin Begin iterator of input sequence.
-   *  @param end End iterator of input sequence.
-   *  @param comp Comparator.
+   *  @param __begin Begin iterator of input sequence.
+   *  @param __end End iterator of input sequence.
+   *  @param __comp Comparator.
    *  @callgraph 
    */
-  template<bool stable, typename RandomAccessIterator, typename Comparator>
+  template<bool __stable, typename _RAIter, typename _Compare>
   inline void
-  parallel_sort(RandomAccessIterator begin, RandomAccessIterator end,
-    Comparator comp, multiway_mergesort_tag parallelism)
+  parallel_sort(_RAIter __begin, _RAIter __end,
+    _Compare __comp, multiway_mergesort_tag __parallelism)
   {
-    _GLIBCXX_CALL(end - begin)
+    _GLIBCXX_CALL(__end - __begin)
 
     if(_Settings::get().sort_splitting == EXACT)
-      parallel_sort_mwms<stable, true>
-        (begin, end, comp, parallelism.get_num_threads());
+      parallel_sort_mwms<__stable, true>
+        (__begin, __end, __comp, __parallelism.__get_num_threads());
     else
-      parallel_sort_mwms<stable, false>
-        (begin, end, comp, parallelism.get_num_threads());
+      parallel_sort_mwms<__stable, false>
+        (__begin, __end, __comp, __parallelism.__get_num_threads());
   }
 
   /** 
-   *  @brief Choose multiway mergesort with exact splitting,
+   *  @brief Choose multiway mergesort with __exact splitting,
    *  for parallel sorting.
-   *  @param begin Begin iterator of input sequence.
-   *  @param end End iterator of input sequence.
-   *  @param comp Comparator.
+   *  @param __begin Begin iterator of input sequence.
+   *  @param __end End iterator of input sequence.
+   *  @param __comp Comparator.
    *  @callgraph 
    */
-  template<bool stable, typename RandomAccessIterator, typename Comparator>
+  template<bool __stable, typename _RAIter, typename _Compare>
   inline void
-  parallel_sort(RandomAccessIterator begin, RandomAccessIterator end,
-    Comparator comp, multiway_mergesort_exact_tag parallelism)
+  parallel_sort(_RAIter __begin, _RAIter __end,
+    _Compare __comp, multiway_mergesort_exact_tag __parallelism)
   {
-    _GLIBCXX_CALL(end - begin)
+    _GLIBCXX_CALL(__end - __begin)
 
-      parallel_sort_mwms<stable, true>
-        (begin, end, comp, parallelism.get_num_threads());
+      parallel_sort_mwms<__stable, true>
+        (__begin, __end, __comp, __parallelism.__get_num_threads());
   }
 
   /** 
    *  @brief Choose multiway mergesort with splitting by sampling,
    *  for parallel sorting.
-   *  @param begin Begin iterator of input sequence.
-   *  @param end End iterator of input sequence.
-   *  @param comp Comparator.
+   *  @param __begin Begin iterator of input sequence.
+   *  @param __end End iterator of input sequence.
+   *  @param __comp Comparator.
    *  @callgraph 
    */
-  template<bool stable, typename RandomAccessIterator, typename Comparator>
+  template<bool __stable, typename _RAIter, typename _Compare>
   inline void
-  parallel_sort(RandomAccessIterator begin, RandomAccessIterator end,
-    Comparator comp, multiway_mergesort_sampling_tag parallelism)
+  parallel_sort(_RAIter __begin, _RAIter __end,
+    _Compare __comp, multiway_mergesort_sampling_tag __parallelism)
   {
-    _GLIBCXX_CALL(end - begin)
+    _GLIBCXX_CALL(__end - __begin)
 
-    parallel_sort_mwms<stable, false>
-      (begin, end, comp, parallelism.get_num_threads());
+    parallel_sort_mwms<__stable, false>
+      (__begin, __end, __comp, __parallelism.__get_num_threads());
   }
 
   /**
    *  @brief Choose quicksort for parallel sorting.
-   *  @param begin Begin iterator of input sequence.
-   *  @param end End iterator of input sequence.
-   *  @param comp Comparator.
+   *  @param __begin Begin iterator of input sequence.
+   *  @param __end End iterator of input sequence.
+   *  @param __comp Comparator.
    *  @callgraph 
    */
-  template<bool stable, typename RandomAccessIterator, typename Comparator>
+  template<bool __stable, typename _RAIter, typename _Compare>
   inline void
-  parallel_sort(RandomAccessIterator begin, RandomAccessIterator end,
-    Comparator comp, quicksort_tag parallelism)
+  parallel_sort(_RAIter __begin, _RAIter __end,
+    _Compare __comp, quicksort_tag __parallelism)
   {
-    _GLIBCXX_CALL(end - begin)
+    _GLIBCXX_CALL(__end - __begin)
 
-    _GLIBCXX_PARALLEL_ASSERT(stable == false);
+    _GLIBCXX_PARALLEL_ASSERT(__stable == false);
 
-    parallel_sort_qs(begin, end, comp, parallelism.get_num_threads());
+    __parallel_sort_qs(__begin, __end, __comp, __parallelism.__get_num_threads());
   }
 
   /**
    *  @brief Choose balanced quicksort for parallel sorting.
-   *  @param begin Begin iterator of input sequence.
-   *  @param end End iterator of input sequence.
-   *  @param comp Comparator.
-   *  @param stable Sort stable.
+   *  @param __begin Begin iterator of input sequence.
+   *  @param __end End iterator of input sequence.
+   *  @param __comp Comparator.
+   *  @param __stable Sort __stable.
    *  @callgraph 
    */
-  template<bool stable, typename RandomAccessIterator, typename Comparator>
+  template<bool __stable, typename _RAIter, typename _Compare>
   inline void
-  parallel_sort(RandomAccessIterator begin, RandomAccessIterator end,
-    Comparator comp, balanced_quicksort_tag parallelism)
+  parallel_sort(_RAIter __begin, _RAIter __end,
+    _Compare __comp, balanced_quicksort_tag __parallelism)
   {
-    _GLIBCXX_CALL(end - begin)
+    _GLIBCXX_CALL(__end - __begin)
 
-    _GLIBCXX_PARALLEL_ASSERT(stable == false);
+    _GLIBCXX_PARALLEL_ASSERT(__stable == false);
 
-    parallel_sort_qsb(begin, end, comp, parallelism.get_num_threads());
+    __parallel_sort_qsb(__begin, __end, __comp, __parallelism.__get_num_threads());
   }
 
 
   /** 
-   *  @brief Choose multiway mergesort with exact splitting,
+   *  @brief Choose multiway mergesort with __exact splitting,
    *  for parallel sorting.
-   *  @param begin Begin iterator of input sequence.
-   *  @param end End iterator of input sequence.
-   *  @param comp Comparator.
+   *  @param __begin Begin iterator of input sequence.
+   *  @param __end End iterator of input sequence.
+   *  @param __comp Comparator.
    *  @callgraph 
    */
-  template<bool stable, typename RandomAccessIterator, typename Comparator>
+  template<bool __stable, typename _RAIter, typename _Compare>
   inline void
-  parallel_sort(RandomAccessIterator begin, RandomAccessIterator end,
-    Comparator comp, default_parallel_tag parallelism)
+  parallel_sort(_RAIter __begin, _RAIter __end,
+    _Compare __comp, default_parallel_tag __parallelism)
   {
-    _GLIBCXX_CALL(end - begin)
+    _GLIBCXX_CALL(__end - __begin)
 
-    parallel_sort<stable>
-      (begin, end, comp,
-        multiway_mergesort_exact_tag(parallelism.get_num_threads()));
+    parallel_sort<__stable>
+      (__begin, __end, __comp,
+        multiway_mergesort_exact_tag(__parallelism.__get_num_threads()));
   }
 
 
   /**
    *  @brief Choose a parallel sorting algorithm.
-   *  @param begin Begin iterator of input sequence.
-   *  @param end End iterator of input sequence.
-   *  @param comp Comparator.
-   *  @param stable Sort stable.
+   *  @param __begin Begin iterator of input sequence.
+   *  @param __end End iterator of input sequence.
+   *  @param __comp Comparator.
+   *  @param __stable Sort __stable.
    *  @callgraph 
    */
-  template<bool stable, typename RandomAccessIterator, typename Comparator>
+  template<bool __stable, typename _RAIter, typename _Compare>
     inline void
-    parallel_sort(RandomAccessIterator begin, RandomAccessIterator end,
-                  Comparator comp, parallel_tag parallelism)
+    parallel_sort(_RAIter __begin, _RAIter __end,
+                  _Compare __comp, parallel_tag __parallelism)
     {
-      _GLIBCXX_CALL(end - begin)
-      typedef std::iterator_traits<RandomAccessIterator> traits_type;
-      typedef typename traits_type::value_type value_type;
-      typedef typename traits_type::difference_type difference_type;
+      _GLIBCXX_CALL(__end - __begin)
+      typedef std::iterator_traits<_RAIter> _TraitsType;
+      typedef typename _TraitsType::value_type _ValueType;
+      typedef typename _TraitsType::difference_type _DifferenceType;
 
       if (false) ;
 #if _GLIBCXX_MERGESORT
-      else if (stable || _Settings::get().sort_algorithm == MWMS)
+      else if (__stable || _Settings::get().sort_algorithm == MWMS)
         {
           if(_Settings::get().sort_splitting == EXACT)
-            parallel_sort_mwms<stable, true>
-              (begin, end, comp, parallelism.get_num_threads());
+            parallel_sort_mwms<__stable, true>
+              (__begin, __end, __comp, __parallelism.__get_num_threads());
           else
             parallel_sort_mwms<false, false>
-              (begin, end, comp, parallelism.get_num_threads());
+              (__begin, __end, __comp, __parallelism.__get_num_threads());
         }
 #endif
 #if _GLIBCXX_QUICKSORT
       else if (_Settings::get().sort_algorithm == QS)
-        parallel_sort_qs(begin, end, comp, parallelism.get_num_threads());
+        __parallel_sort_qs(__begin, __end, __comp, __parallelism.__get_num_threads());
 #endif
 #if _GLIBCXX_BAL_QUICKSORT
       else if (_Settings::get().sort_algorithm == QS_BALANCED)
-        parallel_sort_qsb(begin, end, comp, parallelism.get_num_threads());
+        __parallel_sort_qsb(__begin, __end, __comp, __parallelism.__get_num_threads());
 #endif
       else
-        __gnu_sequential::sort(begin, end, comp);
+        __gnu_sequential::sort(__begin, __end, __comp);
     }
 } // end namespace __gnu_parallel
 
diff --git a/libstdc++-v3/include/parallel/tags.h b/libstdc++-v3/include/parallel/tags.h
index bc1a7e5..ae0c202 100644
--- a/libstdc++-v3/include/parallel/tags.h
+++ b/libstdc++-v3/include/parallel/tags.h
@@ -46,37 +46,37 @@ namespace __gnu_parallel
   struct parallel_tag
   {
     private:
-      thread_index_t num_threads;
+      _ThreadIndex __num_threads;
 
     public:
       /** @brief Default constructor. Use default number of threads. */
       parallel_tag()
       {
-        this->num_threads = 0;
+        this->__num_threads = 0;
       }
 
       /** @brief Default constructor. Recommend number of threads to use.
-       *  @param num_threads Desired number of threads. */
-      parallel_tag(thread_index_t num_threads)
+       *  @param __num_threads Desired number of threads. */
+      parallel_tag(_ThreadIndex __num_threads)
       {
-        this->num_threads = num_threads;
+        this->__num_threads = __num_threads;
       }
 
-      /** @brief Find out desired number of threads.
+      /** @brief Find __out desired number of threads.
        *  @return Desired number of threads. */
-      inline thread_index_t get_num_threads()
+      inline _ThreadIndex __get_num_threads()
       {
-        if(num_threads == 0)
+        if(__num_threads == 0)
           return omp_get_max_threads();
         else
-          return num_threads;
+          return __num_threads;
       }
 
       /** @brief Set the desired number of threads.
-       *  @param num_threads Desired number of threads. */
-      inline void set_num_threads(thread_index_t num_threads)
+       *  @param __num_threads Desired number of threads. */
+      inline void set_num_threads(_ThreadIndex __num_threads)
       {
-        this->num_threads = num_threads;
+        this->__num_threads = __num_threads;
       }
   };
 
@@ -85,8 +85,8 @@ namespace __gnu_parallel
   struct default_parallel_tag : public parallel_tag
   {
       default_parallel_tag() { }
-      default_parallel_tag(thread_index_t num_threads)
-          : parallel_tag(num_threads) { }
+      default_parallel_tag(_ThreadIndex __num_threads)
+          : parallel_tag(__num_threads) { }
   };
 
   /** @brief Recommends parallel execution using dynamic
@@ -111,21 +111,21 @@ namespace __gnu_parallel
 
 
   /** @brief Forces parallel merging
-   *  with exact splitting, at compile time. */
+   *  with __exact splitting, at compile time. */
   struct exact_tag : public parallel_tag
   {
       exact_tag() { }
-      exact_tag(thread_index_t num_threads)
-          : parallel_tag(num_threads) { }
+      exact_tag(_ThreadIndex __num_threads)
+          : parallel_tag(__num_threads) { }
   };
 
   /** @brief Forces parallel merging
-   *  with exact splitting, at compile time. */
+   *  with __exact splitting, at compile time. */
   struct sampling_tag : public parallel_tag
   {
       sampling_tag() { }
-      sampling_tag(thread_index_t num_threads)
-          : parallel_tag(num_threads) { }
+      sampling_tag(_ThreadIndex __num_threads)
+          : parallel_tag(__num_threads) { }
   };
 
 
@@ -134,17 +134,17 @@ namespace __gnu_parallel
   struct multiway_mergesort_tag : public parallel_tag
   {
       multiway_mergesort_tag() { }
-      multiway_mergesort_tag(thread_index_t num_threads)
-          : parallel_tag(num_threads) { }
+      multiway_mergesort_tag(_ThreadIndex __num_threads)
+          : parallel_tag(__num_threads) { }
   };
 
   /** @brief Forces parallel sorting using multiway mergesort
-   *  with exact splitting at compile time. */
+   *  with __exact splitting at compile time. */
   struct multiway_mergesort_exact_tag : public parallel_tag
   {
       multiway_mergesort_exact_tag() { }
-      multiway_mergesort_exact_tag(thread_index_t num_threads)
-          : parallel_tag(num_threads) { }
+      multiway_mergesort_exact_tag(_ThreadIndex __num_threads)
+          : parallel_tag(__num_threads) { }
   };
 
   /** @brief Forces parallel sorting using multiway mergesort
@@ -152,8 +152,8 @@ namespace __gnu_parallel
   struct multiway_mergesort_sampling_tag : public parallel_tag
   {
       multiway_mergesort_sampling_tag() { }
-      multiway_mergesort_sampling_tag(thread_index_t num_threads)
-          : parallel_tag(num_threads) { }
+      multiway_mergesort_sampling_tag(_ThreadIndex __num_threads)
+          : parallel_tag(__num_threads) { }
   };
 
   /** @brief Forces parallel sorting using unbalanced quicksort
@@ -161,8 +161,8 @@ namespace __gnu_parallel
   struct quicksort_tag : public parallel_tag
   {
       quicksort_tag() { }
-      quicksort_tag(thread_index_t num_threads)
-          : parallel_tag(num_threads) { }
+      quicksort_tag(_ThreadIndex __num_threads)
+          : parallel_tag(__num_threads) { }
   };
 
   /** @brief Forces parallel sorting using balanced quicksort
@@ -170,8 +170,8 @@ namespace __gnu_parallel
   struct balanced_quicksort_tag : public parallel_tag
   {
       balanced_quicksort_tag() { }
-      balanced_quicksort_tag(thread_index_t num_threads)
-          : parallel_tag(num_threads) { }
+      balanced_quicksort_tag(_ThreadIndex __num_threads)
+          : parallel_tag(__num_threads) { }
   };
 
 
diff --git a/libstdc++-v3/include/parallel/types.h b/libstdc++-v3/include/parallel/types.h
index 053dfff..70bfb64 100644
--- a/libstdc++-v3/include/parallel/types.h
+++ b/libstdc++-v3/include/parallel/types.h
@@ -79,7 +79,7 @@ namespace __gnu_parallel
     };
 
   /// Merging algorithms: 
-  // bubblesort-alike, loser-tree variants, enum sentinel.
+  // bubblesort-alike, loser-tree variants, enum __sentinel.
   enum _MultiwayMergeAlgorithm
     {
       LOSER_TREE
@@ -92,7 +92,7 @@ namespace __gnu_parallel
       LINEAR 
     };
 
-  /// Sorting/merging algorithms: sampling, exact.
+  /// Sorting/merging algorithms: sampling, __exact.
   enum _SplittingAlgorithm 
     { 
       SAMPLING, 
@@ -108,7 +108,7 @@ namespace __gnu_parallel
       EQUAL_SPLIT 
     };
 
-  /// Integer Types.
+  /// _Integer Types.
   // XXX need to use <cstdint>
   /** @brief 16-bit signed integer. */
   typedef short int16;
@@ -129,27 +129,27 @@ namespace __gnu_parallel
   typedef unsigned long long uint64;
 
   /**
-   * @brief Unsigned integer to index elements.
+   * @brief Unsigned integer to index __elements.
    * The total number of elements for each algorithm must fit into this type.
    */
-  typedef uint64 sequence_index_t;
+  typedef uint64 _SequenceIndex;
 
   /**
    * @brief Unsigned integer to index a thread number.
    * The maximum thread number (for each processor) must fit into this type.
    */
-  typedef uint16 thread_index_t;
+  typedef uint16 _ThreadIndex;
 
   // XXX atomics interface?
   /// Longest compare-and-swappable integer type on this platform.
-  typedef int64 lcas_t;
+  typedef int64 _CASable;
 
   // XXX numeric_limits::digits?
-  /// Number of bits of ::lcas_t.
-  static const int lcas_t_bits = sizeof(lcas_t) * 8;
+  /// Number of bits of ::_CASable.
+  static const int _CASable_bits = sizeof(_CASable) * 8;
 
-  /// ::lcas_t with the right half of bits set to 1.
-  static const lcas_t lcas_t_mask = ((lcas_t(1) << (lcas_t_bits / 2)) - 1);
+  /// ::_CASable with the right half of bits set to 1.
+  static const _CASable _CASable_mask = ((_CASable(1) << (_CASable_bits / 2)) - 1);
 }
 
 #endif /* _GLIBCXX_PARALLEL_TYPES_H */
diff --git a/libstdc++-v3/include/parallel/unique_copy.h b/libstdc++-v3/include/parallel/unique_copy.h
index a83c2c0..db2e820 100644
--- a/libstdc++-v3/include/parallel/unique_copy.h
+++ b/libstdc++-v3/include/parallel/unique_copy.h
@@ -38,153 +38,153 @@
 namespace __gnu_parallel
 {
 
-/** @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 InputIterator,
-	 class OutputIterator,
-	 class BinaryPredicate>
-  OutputIterator
-  parallel_unique_copy(InputIterator first, InputIterator last,
-                       OutputIterator result, BinaryPredicate binary_pred)
+/** @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,
+	 class _OutputIterator,
+	 class _BinaryPredicate>
+  _OutputIterator
+  __parallel_unique_copy(_IIter __first, _IIter __last,
+                       _OutputIterator __result, _BinaryPredicate __binary_pred)
   {
-    _GLIBCXX_CALL(last - first)
+    _GLIBCXX_CALL(__last - __first)
 
-    typedef std::iterator_traits<InputIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    typedef typename traits_type::difference_type difference_type;
+    typedef std::iterator_traits<_IIter> _TraitsType;
+    typedef typename _TraitsType::value_type _ValueType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
 
-    difference_type size = last - first;
+    _DifferenceType size = __last - __first;
 
     if (size == 0)
-      return result;
+      return __result;
 
     // Let the first thread process two parts.
-    difference_type *counter;
-    difference_type *borders;
+    _DifferenceType *__counter;
+    _DifferenceType *__borders;
 
-    thread_index_t num_threads = get_max_threads();
+    _ThreadIndex __num_threads = __get_max_threads();
     // First part contains at least one element.
-#   pragma omp parallel num_threads(num_threads)
+#   pragma omp parallel num_threads(__num_threads)
       {
 #       pragma omp single
           {
-	    num_threads = omp_get_num_threads();
-	    borders = new difference_type[num_threads + 2];
-	    equally_split(size, num_threads + 1, borders);
-	    counter = new difference_type[num_threads + 1];
+	    __num_threads = omp_get_num_threads();
+	    __borders = new _DifferenceType[__num_threads + 2];
+	    equally_split(size, __num_threads + 1, __borders);
+	    __counter = new _DifferenceType[__num_threads + 1];
           }
 
-        thread_index_t iam = omp_get_thread_num();
+        _ThreadIndex __iam = omp_get_thread_num();
 
-        difference_type begin, end;
+        _DifferenceType __begin, __end;
 
         // Check for length without duplicates
         // Needed for position in output
-        difference_type i = 0;
-        OutputIterator out = result;
+        _DifferenceType __i = 0;
+        _OutputIterator __out = __result;
 
-        if (iam == 0)
+        if (__iam == 0)
         {
-          begin = borders[0] + 1;	// == 1
-          end = borders[iam + 1];
+          __begin = __borders[0] + 1;	// == 1
+          __end = __borders[__iam + 1];
 
-          ++i;
-          *out++ = *first;
+          ++__i;
+          *__out++ = *__first;
 
-          for (InputIterator 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;
+                  ++__i;
+                  *__out++ = *iter;
                 }
             }
         }
       else
         {
-          begin = borders[iam]; //one part
-          end = borders[iam + 1];
+          __begin = __borders[__iam]; //one part
+          __end = __borders[__iam + 1];
 
-          for (InputIterator iter = first + begin; iter < first + end; ++iter)
+          for (_IIter iter = __first + __begin; iter < __first + __end; ++iter)
             {
-              if (!binary_pred(*iter, *(iter - 1)))
-		++i;
+              if (!__binary_pred(*iter, *(iter - 1)))
+		++__i;
 	    }
         }
-      counter[iam] = i;
+      __counter[__iam] = __i;
 
       // Last part still untouched.
-      difference_type begin_output;
+      _DifferenceType __begin_output;
 
 #     pragma omp barrier
 
       // Store result in output on calculated positions.
-      begin_output = 0;
+      __begin_output = 0;
 
-      if (iam == 0)
+      if (__iam == 0)
         {
-          for (int t = 0; t < num_threads; ++t)
-            begin_output += counter[t];
+          for (int __t = 0; __t < __num_threads; ++__t)
+            __begin_output += __counter[__t];
 
-          i = 0;
+          __i = 0;
 
-          OutputIterator iter_out = result + begin_output;
+          _OutputIterator __iter_out = __result + __begin_output;
 
-          begin = borders[num_threads];
-          end = size;
+          __begin = __borders[__num_threads];
+          __end = size;
 
-          for (InputIterator 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;
+                  ++__i;
+                  *__iter_out++ = *iter;
                 }
             }
 
-          counter[num_threads] = i;
+          __counter[__num_threads] = __i;
         }
       else
         {
-          for (int t = 0; t < iam; t++)
-            begin_output += counter[t];
+          for (int __t = 0; __t < __iam; __t++)
+            __begin_output += __counter[__t];
 
-          OutputIterator iter_out = result + begin_output;
-          for (InputIterator iter = first + begin; iter < first + end; ++iter)
+          _OutputIterator __iter_out = __result + __begin_output;
+          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;
 	    }
         }
     }
 
-    difference_type end_output = 0;
-    for (int t = 0; t < num_threads + 1; t++)
-      end_output += counter[t];
+    _DifferenceType __end_output = 0;
+    for (int __t = 0; __t < __num_threads + 1; __t++)
+      __end_output += __counter[__t];
 
-    delete[] borders;
+    delete[] __borders;
 
-    return result + end_output;
+    return __result + __end_output;
   }
 
 /** @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 InputIterator, class OutputIterator>
-  inline OutputIterator
-  parallel_unique_copy(InputIterator first, InputIterator last,
-                       OutputIterator result)
+  *  @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>
+  inline _OutputIterator
+  __parallel_unique_copy(_IIter __first, _IIter __last,
+                       _OutputIterator __result)
   {
-    typedef typename std::iterator_traits<InputIterator>::value_type
-      value_type;
-    return parallel_unique_copy(first, last, result,
-				std::equal_to<value_type>());
+    typedef typename std::iterator_traits<_IIter>::value_type
+      _ValueType;
+    return __parallel_unique_copy(__first, __last, __result,
+				std::equal_to<_ValueType>());
   }
 
 }//namespace __gnu_parallel
diff --git a/libstdc++-v3/include/parallel/workstealing.h b/libstdc++-v3/include/parallel/workstealing.h
index b82fe7c..a43c261 100644
--- a/libstdc++-v3/include/parallel/workstealing.h
+++ b/libstdc++-v3/include/parallel/workstealing.h
@@ -49,257 +49,257 @@ namespace __gnu_parallel
 
 #define _GLIBCXX_JOB_VOLATILE volatile
 
-/** @brief One job for a certain thread. */
+/** @brief One __job for a certain thread. */
 template<typename _DifferenceTp>
-  struct Job
+  struct _Job
   {
-    typedef _DifferenceTp difference_type;
+    typedef _DifferenceTp _DifferenceType;
 
     /** @brief First element.
      *
      *  Changed by owning and stealing thread. By stealing thread,
      *  always incremented. */
-    _GLIBCXX_JOB_VOLATILE difference_type first;
+    _GLIBCXX_JOB_VOLATILE _DifferenceType __first;
 
     /** @brief Last element.
      *
      *  Changed by owning thread only. */
-    _GLIBCXX_JOB_VOLATILE difference_type last;
+    _GLIBCXX_JOB_VOLATILE _DifferenceType __last;
 
-    /** @brief Number of elements, i. e. @c last-first+1.
+    /** @brief Number of elements, i.e. @__c __last-__first+1.
      *
      *  Changed by owning thread only. */
-    _GLIBCXX_JOB_VOLATILE difference_type load;
+    _GLIBCXX_JOB_VOLATILE _DifferenceType __load;
   };
 
 /** @brief Work stealing algorithm for random access iterators.
   *
-  *  Uses O(1) additional memory. Synchronization at job lists is
+  *  Uses O(1) additional memory. Synchronization at __job lists is
   *  done with atomic operations.
-  *  @param begin Begin iterator of element sequence.
-  *  @param end End iterator of element sequence.
-  *  @param op User-supplied functor (comparator, predicate, adding
+  *  @param __begin Begin iterator of element __sequence.
+  *  @param __end End iterator of element __sequence.
+  *  @param __op User-supplied functor (comparator, predicate, adding
   *  functor, ...).
-  *  @param f Functor to "process" an element with op (depends on
+  *  @param __f Functor to "process" an element with __op (depends on
   *  desired functionality, e. g. for std::for_each(), ...).
-  *  @param r Functor to "add" a single result to the already
-  *  processed elements (depends on functionality).
-  *  @param base Base value for reduction.
-  *  @param output Pointer to position where final result is written to
-  *  @param bound Maximum number of elements processed (e. g. for
+  *  @param __r Functor to "add" a single __result to the already
+  *  processed __elements (depends on functionality).
+  *  @param __base Base value for reduction.
+  *  @param __output Pointer to position where final result is written to
+  *  @param __bound Maximum number of elements processed (e. g. for
   *  std::count_n()).
   *  @return User-supplied functor (that may contain a part of the result).
   */
-template<typename RandomAccessIterator,
-	 typename Op,
-	 typename Fu,
-	 typename Red,
-	 typename Result>
-  Op
-  for_each_template_random_access_workstealing(RandomAccessIterator begin,
-					       RandomAccessIterator end,
-					       Op op, Fu& f, Red r,
-					       Result base, Result& output,
+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,
 					       typename std::iterator_traits
-					       <RandomAccessIterator>::
-					       difference_type bound)
+					       <_RAIter>::
+					       difference_type __bound)
   {
-    _GLIBCXX_CALL(end - begin)
+    _GLIBCXX_CALL(__end - __begin)
 
-    typedef std::iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::difference_type difference_type;
+    typedef std::iterator_traits<_RAIter> _TraitsType;
+    typedef typename _TraitsType::difference_type _DifferenceType;
     
     const _Settings& __s = _Settings::get();
 
-    difference_type chunk_size = static_cast<difference_type>(__s.workstealing_chunk_size);
+    _DifferenceType __chunk_size = static_cast<_DifferenceType>(__s.workstealing_chunk_size);
 
     // How many jobs?
-    difference_type length = (bound < 0) ? (end - begin) : bound;
+    _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<difference_type>) + 1;
+    const int __stride = __s.cache_line_size * 10 / sizeof(_Job<_DifferenceType>) + 1;
 
     // Total number of threads currently working.
-    thread_index_t busy = 0;
+    _ThreadIndex __busy = 0;
 
-    Job<difference_type> *job;
+    _Job<_DifferenceType> *__job;
 
-    omp_lock_t output_lock;
-    omp_init_lock(&output_lock);
+    omp_lock_t __output_lock;
+    omp_init_lock(&__output_lock);
 
-    // Write base value to output.
-    output = base;
+    // Write __base __value to output.
+    __output = __base;
 
     // No more threads than jobs, at least one thread.
-    thread_index_t num_threads =
-        __gnu_parallel::max<thread_index_t>(1,
-            __gnu_parallel::min<difference_type>(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 parallel shared(__busy) num_threads(__num_threads)
       {
 
 #       pragma omp single
           {
-            num_threads = omp_get_num_threads();
+            __num_threads = omp_get_num_threads();
 
-            // Create job description array.
-            job = new Job<difference_type>[num_threads * stride];
+            // Create __job description array.
+            __job = new _Job<_DifferenceType>[__num_threads * __stride];
           }
 
         // Initialization phase.
 
         // Flags for every thread if it is doing productive work.
-        bool iam_working = false;
+        bool __iam_working = false;
 
         // Thread id.
-        thread_index_t iam = omp_get_thread_num();
+        _ThreadIndex __iam = omp_get_thread_num();
 
-        // This job.
-        Job<difference_type>& my_job = job[iam * stride];
+        // This __job.
+        _Job<_DifferenceType>& __my_job = __job[__iam * __stride];
 
         // Random number (for work stealing).
-        thread_index_t victim;
+        _ThreadIndex __victim;
 
         // Local value for reduction.
-        Result result = Result();
+        _Result __result = _Result();
 
         // Number of elements to steal in one attempt.
-        difference_type steal;
+        _DifferenceType __steal;
 
         // Every thread has its own random number generator
-        // (modulo num_threads).
-        random_number rand_gen(iam, num_threads);
+        // (modulo __num_threads).
+        _RandomNumber rand_gen(__iam, __num_threads);
 
         // This thread is currently working.
 #       pragma omp atomic
-          ++busy;
+          ++__busy;
 
-        iam_working = true;
+        __iam_working = true;
 
         // How many jobs per thread? last thread gets the rest.
-        my_job.first =
-            static_cast<difference_type>(iam * (length / num_threads));
+        __my_job.__first =
+            static_cast<_DifferenceType>(__iam * (__length / __num_threads));
 
-        my_job.last = (iam == (num_threads - 1)) ?
-            (length - 1) : ((iam + 1) * (length / num_threads) - 1);
-        my_job.load = my_job.last - my_job.first + 1;
+        __my_job.__last = (__iam == (__num_threads - 1)) ?
+            (__length - 1) : ((__iam + 1) * (__length / __num_threads) - 1);
+        __my_job.__load = __my_job.__last - __my_job.__first + 1;
 
-        // Init result with first value (to have a base value for reduction).
-        if (my_job.first <= my_job.last)
+        // Init __result with __first __value (to have a base value for reduction).
+        if (__my_job.__first <= __my_job.__last)
           {
             // Cannot use volatile variable directly.
-            difference_type my_first = my_job.first;
-            result = f(op, begin + my_first);
-            ++my_job.first;
-            --my_job.load;
+            _DifferenceType __my_first = __my_job.__first;
+            __result = __f(__op, __begin + __my_first);
+            ++__my_job.__first;
+            --__my_job.__load;
           }
 
-        RandomAccessIterator current;
+        _RAIter __current;
 
 #       pragma omp barrier
 
         // Actual work phase
-        // Work on own or stolen start
-        while (busy > 0)
+        // Work on own or stolen __start
+        while (__busy > 0)
           {
-            // Work until no productive thread left.
-#           pragma omp flush(busy)
+            // Work until no productive thread __left.
+#           pragma omp flush(__busy)
 
             // Thread has own work to do
-            while (my_job.first <= my_job.last)
+            while (__my_job.__first <= __my_job.__last)
               {
                 // fetch-and-add call
-                // Reserve current job block (size chunk_size) in my queue.
-                difference_type current_job =
-                  fetch_and_add<difference_type>(&(my_job.first), chunk_size);
-
-                // Update load, to make the three values consistent,
-                // first might have been changed in the meantime
-                my_job.load = my_job.last - my_job.first + 1;
-                for (difference_type job_counter = 0;
-                     job_counter < chunk_size && current_job <= my_job.last;
+                // Reserve __current __job block (size __chunk_size) in my queue.
+                _DifferenceType current_job =
+                  __fetch_and_add<_DifferenceType>(&(__my_job.__first), __chunk_size);
+
+                // Update __load, to make the three values consistent,
+                // __first might have been changed in the meantime
+                __my_job.__load = __my_job.__last - __my_job.__first + 1;
+                for (_DifferenceType job_counter = 0;
+                     job_counter < __chunk_size && current_job <= __my_job.__last;
                      ++job_counter)
                   {
                     // Yes: process it!
-                    current = begin + current_job;
+                    __current = __begin + current_job;
                     ++current_job;
 
                     // Do actual work.
-                    result = r(result, f(op, current));
+                    __result = __r(__result, __f(__op, __current));
                   }
 
-#               pragma omp flush(busy)
+#               pragma omp flush(__busy)
               }
 
-            // After reaching this point, a thread's job list is empty.
-            if (iam_working)
+            // After reaching this point, a thread's __job list is empty.
+            if (__iam_working)
               {
                 // This thread no longer has work.
 #               pragma omp atomic
-                --busy;
+                --__busy;
 
-                iam_working = false;
+                __iam_working = false;
               }
 
-            difference_type 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();
-                supposed_first = job[victim * stride].first;
-                supposed_last = job[victim * stride].last;
-                supposed_load = job[victim * stride].load;
+                __yield();
+#               pragma omp flush(__busy)
+                __victim = rand_gen();
+                __supposed_first = __job[__victim * __stride].__first;
+                __supposed_last = __job[__victim * __stride].__last;
+                __supposed_load = __job[__victim * __stride].__load;
               }
-            while (busy > 0
-              && ((supposed_load <= 0)
-                || ((supposed_first + supposed_load - 1) != supposed_last)));
+            while (__busy > 0
+              && ((__supposed_load <= 0)
+                || ((__supposed_first + __supposed_load - 1) != __supposed_last)));
 
-            if (busy == 0)
+            if (__busy == 0)
               break;
 
-            if (supposed_load > 0)
+            if (__supposed_load > 0)
               {
                 // Has work and work to do.
                 // Number of elements to steal (at least one).
-                steal = (supposed_load < 2) ? 1 : supposed_load / 2;
+                __steal = (__supposed_load < 2) ? 1 : __supposed_load / 2;
 
-                // Push victim's start forward.
-                difference_type stolen_first =
-                    fetch_and_add<difference_type>(
-                        &(job[victim * stride].first), steal);
-                difference_type stolen_try =
-                    stolen_first + steal - difference_type(1);
+                // Push __victim's __start forward.
+                _DifferenceType __stolen_first =
+                    __fetch_and_add<_DifferenceType>(
+                        &(__job[__victim * __stride].__first), __steal);
+                _DifferenceType stolen_try =
+                    __stolen_first + __steal - _DifferenceType(1);
 
-                my_job.first = stolen_first;
-                my_job.last = __gnu_parallel::min(stolen_try, supposed_last);
-                my_job.load = my_job.last - my_job.first + 1;
+                __my_job.__first = __stolen_first;
+                __my_job.__last = __gnu_parallel::min(stolen_try, __supposed_last);
+                __my_job.__load = __my_job.__last - __my_job.__first + 1;
 
                 // Has potential work again.
 #               pragma omp atomic
-                  ++busy;
-                iam_working = true;
+                  ++__busy;
+                __iam_working = true;
 
-#               pragma omp flush(busy)
+#               pragma omp flush(__busy)
               }
-#           pragma omp flush(busy)
-          } // end while busy > 0
-            // Add accumulated result to output.
-        omp_set_lock(&output_lock);
-        output = r(output, result);
-        omp_unset_lock(&output_lock);
+#           pragma omp flush(__busy)
+          } // end while __busy > 0
+            // Add accumulated __result to output.
+        omp_set_lock(&__output_lock);
+        __output = __r(__output, __result);
+        omp_unset_lock(&__output_lock);
       }
 
-    delete[] job;
+    delete[] __job;
 
     // Points to last element processed (needed as return value for
     // some algorithms like transform)
-    f.finish_iterator = begin + length;
+    __f.finish_iterator = __begin + __length;
 
-    omp_destroy_lock(&output_lock);
+    omp_destroy_lock(&__output_lock);
 
-    return op;
+    return __op;
   }
 } // end namespace